external/vulkancts/modules/vulkan/synchronization/vktSynchronizationBasicEventTests.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2016 The Khronos Group Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Synchronization event basic tests
  *//*--------------------------------------------------------------------*/

 #include "vktSynchronizationBasicEventTests.hpp"
 #include "vktTestCaseUtil.hpp"
 #include "vktSynchronizationUtil.hpp"

 #include "vkDefs.hpp"
 #include "vkPlatform.hpp"
 #include "vkRef.hpp"
 #include "vkCmdUtil.hpp"

 namespace vkt
 {
 namespace synchronization
 {
 namespace
 {

 using namespace vk;
 #define SHORT_FENCE_WAIT	1000ull
 #define LONG_FENCE_WAIT		~0ull

 tcu::TestStatus hostResetSetEventCase (Context& context)
 {
 	const DeviceInterface&		vk			= context.getDeviceInterface();
 	const VkDevice				device		= context.getDevice();
 	const VkEventCreateInfo		eventInfo	=
 											{
 												VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
 												DE_NULL,
 												0
 											};
 	VkEvent						event;
 	Move<VkEvent>				ptrEvent;

 	if (VK_SUCCESS != vk.createEvent(device, &eventInfo, DE_NULL, &event))
 		return tcu::TestStatus::fail("Couldn't create event");

 	ptrEvent = Move<VkEvent>(check<VkEvent>(event), Deleter<VkEvent>(vk, device, DE_NULL));

 	if (VK_EVENT_RESET != vk.getEventStatus(device, event))
 		return tcu::TestStatus::fail("Created event should be in unsignaled state");

 	if (VK_SUCCESS != vk.setEvent(device, event))
 		return tcu::TestStatus::fail("Couldn't set event");

 	if (VK_EVENT_SET != vk.getEventStatus(device, event))
 		return tcu::TestStatus::fail("Event should be in signaled state after set");

 	if (VK_SUCCESS != vk.resetEvent(device, event))
 		return tcu::TestStatus::fail("Couldn't reset event");

 	if (VK_EVENT_RESET != vk.getEventStatus(device, event))
 		return tcu::TestStatus::fail("Event should be in unsignaled state after reset");

 	return tcu::TestStatus::pass("Tests set and reset event on host pass");
 }

 tcu::TestStatus deviceResetSetEventCase (Context& context)
 {
 	const DeviceInterface&			vk					= context.getDeviceInterface();
 	const VkDevice					device				= context.getDevice();
 	const VkQueue					queue				= context.getUniversalQueue();
 	const deUint32					queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
 	const Unique<VkCommandPool>		cmdPool				(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 	const Unique<VkCommandBuffer>	cmdBuffer			(makeCommandBuffer(vk, device, *cmdPool));
 	const VkSubmitInfo				submitInfo			=
 														{
 															VK_STRUCTURE_TYPE_SUBMIT_INFO,	// VkStructureType				sType;
 															DE_NULL,						// const void*					pNext;
 															0u,								// deUint32						waitSemaphoreCount;
 															DE_NULL,						// const VkSemaphore*			pWaitSemaphores;
 															DE_NULL,						// const VkPipelineStageFlags*	pWaitDstStageMask;
 															1u,								// deUint32						commandBufferCount;
 															&cmdBuffer.get(),				// const VkCommandBuffer*		pCommandBuffers;
 															0u,								// deUint32						signalSemaphoreCount;
 															DE_NULL,						// const VkSemaphore*			pSignalSemaphores;
 														};
 	const Unique<VkEvent>			event				(createEvent(vk, device));

 	beginCommandBuffer(vk, *cmdBuffer);
 	vk.cmdSetEvent(*cmdBuffer, *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
 	endCommandBuffer(vk, *cmdBuffer);

 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, DE_NULL));
 	VK_CHECK(vk.queueWaitIdle(queue));

 	if (VK_EVENT_SET != vk.getEventStatus(device, *event))
 		return tcu::TestStatus::fail("Event should be in signaled state after set");

 	beginCommandBuffer(vk, *cmdBuffer);
 	vk.cmdResetEvent(*cmdBuffer, *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
 	endCommandBuffer(vk, *cmdBuffer);

 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, DE_NULL));
 	VK_CHECK(vk.queueWaitIdle(queue));

 	if (VK_EVENT_RESET != vk.getEventStatus(device, *event))
 		return tcu::TestStatus::fail("Event should be in unsignaled state after set");

 	return tcu::TestStatus::pass("Device set and reset event tests pass");
 }

 tcu::TestStatus singleSubmissionCase (Context& context)
 {
 	enum {SET=0, WAIT, COUNT};
 	const DeviceInterface&			vk					= context.getDeviceInterface();
 	const VkDevice					device				= context.getDevice();
 	const VkQueue					queue				= context.getUniversalQueue();
 	const deUint32					queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
 	const Unique<VkFence>			fence				(createFence(vk, device));
 	const Unique<VkCommandPool>		cmdPool				(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 	const Move<VkCommandBuffer>		ptrCmdBuffer[COUNT]	= {makeCommandBuffer(vk, device, *cmdPool), makeCommandBuffer(vk, device, *cmdPool)};
 	VkCommandBuffer					cmdBuffers[COUNT]	= {*ptrCmdBuffer[SET], *ptrCmdBuffer[WAIT]};
 	const VkSubmitInfo				submitInfo			=
 														{
 															VK_STRUCTURE_TYPE_SUBMIT_INFO,	// VkStructureType				sType;
 															DE_NULL,						// const void*					pNext;
 															0u,								// deUint32						waitSemaphoreCount;
 															DE_NULL,						// const VkSemaphore*			pWaitSemaphores;
 															DE_NULL,						// const VkPipelineStageFlags*	pWaitDstStageMask;
 															2u,								// deUint32						commandBufferCount;
 															cmdBuffers,						// const VkCommandBuffer*		pCommandBuffers;
 															0u,								// deUint32						signalSemaphoreCount;
 															DE_NULL,						// const VkSemaphore*			pSignalSemaphores;
 														};
 	const Unique<VkEvent>			event				(createEvent(vk, device));

 	beginCommandBuffer(vk, cmdBuffers[SET]);
 	vk.cmdSetEvent(cmdBuffers[SET], *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
 	endCommandBuffer(vk, cmdBuffers[SET]);

 	beginCommandBuffer(vk, cmdBuffers[WAIT]);
 	vk.cmdWaitEvents(cmdBuffers[WAIT], 1u, &event.get(),VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
 	endCommandBuffer(vk, cmdBuffers[WAIT]);

 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 	if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, LONG_FENCE_WAIT))
 		return tcu::TestStatus::fail("Queue should end execution");

 	return tcu::TestStatus::pass("Wait and set even on device single submission tests pass");
 }

 tcu::TestStatus multiSubmissionCase (Context& context)
 {
 	enum {SET=0, WAIT, COUNT};
 	const DeviceInterface&			vk					= context.getDeviceInterface();
 	const VkDevice					device				= context.getDevice();
 	const VkQueue					queue				= context.getUniversalQueue();
 	const deUint32					queueFamilyIndex	= context.getUniversalQueueFamilyIndex();
 	const Move<VkFence>				ptrFence[COUNT]		=
 	{
 		createFence(vk, device),
 		createFence(vk, device)
 	};
 	VkFence							fence[COUNT]		= {*ptrFence[SET], *ptrFence[WAIT]};
 	const Unique<VkCommandPool>		cmdPool				(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 	const Move<VkCommandBuffer>		ptrCmdBuffer[COUNT]	= {makeCommandBuffer(vk, device, *cmdPool), makeCommandBuffer(vk, device, *cmdPool)};
 	VkCommandBuffer					cmdBuffers[COUNT]	= {*ptrCmdBuffer[SET], *ptrCmdBuffer[WAIT]};
 	const VkSubmitInfo				submitInfo[COUNT]	=
 														{
 															{
 																VK_STRUCTURE_TYPE_SUBMIT_INFO,	// VkStructureType				sType;
 																DE_NULL,						// const void*					pNext;
 																0u,								// deUint32						waitSemaphoreCount;
 																DE_NULL,						// const VkSemaphore*			pWaitSemaphores;
 																DE_NULL,						// const VkPipelineStageFlags*	pWaitDstStageMask;
 																1u,								// deUint32						commandBufferCount;
 																&cmdBuffers[SET],				// const VkCommandBuffer*		pCommandBuffers;
 																0u,								// deUint32						signalSemaphoreCount;
 																DE_NULL,						// const VkSemaphore*			pSignalSemaphores;
 															},
 															{
 																VK_STRUCTURE_TYPE_SUBMIT_INFO,	// VkStructureType				sType;
 																DE_NULL,						// const void*					pNext;
 																0u,								// deUint32						waitSemaphoreCount;
 																DE_NULL,						// const VkSemaphore*			pWaitSemaphores;
 																DE_NULL,						// const VkPipelineStageFlags*	pWaitDstStageMask;
 																1u,								// deUint32						commandBufferCount;
 																&cmdBuffers[WAIT],				// const VkCommandBuffer*		pCommandBuffers;
 																0u,								// deUint32						signalSemaphoreCount;
 																DE_NULL,						// const VkSemaphore*			pSignalSemaphores;
 															}
 														};
 	const Unique<VkEvent>			event				(createEvent(vk, device));

 	beginCommandBuffer(vk, cmdBuffers[SET]);
 	vk.cmdSetEvent(cmdBuffers[SET], *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
 	endCommandBuffer(vk, cmdBuffers[SET]);

 	beginCommandBuffer(vk, cmdBuffers[WAIT]);
 	vk.cmdWaitEvents(cmdBuffers[WAIT], 1u, &event.get(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
 	endCommandBuffer(vk, cmdBuffers[WAIT]);

 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo[SET], fence[SET]));
 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo[WAIT], fence[WAIT]));

 	if (VK_SUCCESS != vk.waitForFences(device, 2u, fence, DE_TRUE, LONG_FENCE_WAIT))
 		return tcu::TestStatus::fail("Queue should end execution");

 	return tcu::TestStatus::pass("Wait and set even on device multi submission tests pass");
 }

 tcu::TestStatus secondaryCommandBufferCase (Context& context)
 {
 	enum {SET=0, WAIT, COUNT};
 	const DeviceInterface&					vk						= context.getDeviceInterface();
 	const VkDevice							device					= context.getDevice();
 	const VkQueue							queue					= context.getUniversalQueue();
 	const deUint32							queueFamilyIndex		= context.getUniversalQueueFamilyIndex();
 	const Unique<VkFence>					fence					(createFence(vk, device));
 	const Unique<VkCommandPool>				cmdPool					(createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
 	const Move<VkCommandBuffer>				primaryCmdBuffer		(makeCommandBuffer(vk, device, *cmdPool));
 	const VkCommandBufferAllocateInfo		cmdBufferInfo			=
 																	{
 																		VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,		// VkStructureType		sType;
 																		DE_NULL,											// const void*			pNext;
 																		*cmdPool,											// VkCommandPool		commandPool;
 																		VK_COMMAND_BUFFER_LEVEL_SECONDARY,					// VkCommandBufferLevel	level;
 																		1u,													// deUint32				commandBufferCount;
 																	};
 	const Move<VkCommandBuffer>				prtCmdBuffers[COUNT]	= {allocateCommandBuffer (vk, device, &cmdBufferInfo), allocateCommandBuffer (vk, device, &cmdBufferInfo)};
 	VkCommandBuffer							secondaryCmdBuffers[]	= {*prtCmdBuffers[SET], *prtCmdBuffers[WAIT]};
 	const VkSubmitInfo						submitInfo				=
 																	{
 																		VK_STRUCTURE_TYPE_SUBMIT_INFO,	// VkStructureType				sType;
 																		DE_NULL,						// const void*					pNext;
 																		0u,								// deUint32						waitSemaphoreCount;
 																		DE_NULL,						// const VkSemaphore*			pWaitSemaphores;
 																		DE_NULL,						// const VkPipelineStageFlags*	pWaitDstStageMask;
 																		1u,								// deUint32						commandBufferCount;
 																		&primaryCmdBuffer.get(),		// const VkCommandBuffer*		pCommandBuffers;
 																		0u,								// deUint32						signalSemaphoreCount;
 																		DE_NULL,						// const VkSemaphore*			pSignalSemaphores;
 																	};
 	const Unique<VkEvent>					event					(createEvent(vk, device));

 	const VkCommandBufferInheritanceInfo	secCmdBufInheritInfo	=
 																	{
 																		VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,	//VkStructureType					sType;
 																		DE_NULL,											//const void*						pNext;
 																		DE_NULL,											//VkRenderPass					renderPass;
 																		0u,													//deUint32						subpass;
 																		DE_NULL,											//VkFramebuffer					framebuffer;
 																		VK_FALSE,											//VkBool32						occlusionQueryEnable;
 																		(VkQueryControlFlags)0u,							//VkQueryControlFlags				queryFlags;
 																		(VkQueryPipelineStatisticFlags)0u,					//VkQueryPipelineStatisticFlags	pipelineStatistics;
 																	};
 	const VkCommandBufferBeginInfo			cmdBufferBeginInfo		=
 																	{
 																		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,	// VkStructureType                          sType;
 																		DE_NULL,										// const void*                              pNext;
 																		VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,	// VkCommandBufferUsageFlags                flags;
 																		&secCmdBufInheritInfo,							// const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
 																	};

 	VK_CHECK(vk.beginCommandBuffer(secondaryCmdBuffers[SET], &cmdBufferBeginInfo));
 	vk.cmdSetEvent(secondaryCmdBuffers[SET], *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
 	endCommandBuffer(vk, secondaryCmdBuffers[SET]);

 	VK_CHECK(vk.beginCommandBuffer(secondaryCmdBuffers[WAIT], &cmdBufferBeginInfo));
 	vk.cmdWaitEvents(secondaryCmdBuffers[WAIT], 1u, &event.get(),VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
 	endCommandBuffer(vk, secondaryCmdBuffers[WAIT]);

 	beginCommandBuffer(vk, *primaryCmdBuffer);
 	vk.cmdExecuteCommands(*primaryCmdBuffer, 2u, secondaryCmdBuffers);
 	endCommandBuffer(vk, *primaryCmdBuffer);

 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 	if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, LONG_FENCE_WAIT))
 		return tcu::TestStatus::fail("Queue should end execution");

 	return tcu::TestStatus::pass("Wait and set even on device using secondary command buffers tests pass");
 }

 } // anonymous

 tcu::TestCaseGroup* createBasicEventTests (tcu::TestContext& testCtx)
 {
 	de::MovePtr<tcu::TestCaseGroup> basicTests(new tcu::TestCaseGroup(testCtx, "event", "Basic event tests"));
 	addFunctionCase(basicTests.get(), "host_set_reset",   "Basic event tests set and reset on host", hostResetSetEventCase);
 	addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", deviceResetSetEventCase);
 	addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", singleSubmissionCase);
 	addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", multiSubmissionCase);
 	addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", secondaryCommandBufferCase);

 	return basicTests.release();
 }

 } // synchronization
 } // vkt
	/*------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2016 The Khronos Group Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Synchronization event basic tests
	//--------------------------------------------------------------------*/

	#include "vktSynchronizationBasicEventTests.hpp"
	#include "vktTestCaseUtil.hpp"
	#include "vktSynchronizationUtil.hpp"

	#include "vkDefs.hpp"
	#include "vkPlatform.hpp"
	#include "vkRef.hpp"
	#include "vkCmdUtil.hpp"

	namespace vkt
	{
	namespace synchronization
	{
	namespace
	{

	using namespace vk;
	#define SHORT_FENCE_WAIT 1000ull
	#define LONG_FENCE_WAIT ~0ull

	tcu::TestStatus hostResetSetEventCase (Context& context)
	{
	const DeviceInterface& vk = context.getDeviceInterface();
	const VkDevice device = context.getDevice();
	const VkEventCreateInfo eventInfo =
	{
	VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
	DE_NULL,
	0
	};
	VkEvent event;
	Move<VkEvent> ptrEvent;

	if (VK_SUCCESS != vk.createEvent(device, &eventInfo, DE_NULL, &event))
	return tcu::TestStatus::fail("Couldn't create event");

	ptrEvent = Move<VkEvent>(check<VkEvent>(event), Deleter<VkEvent>(vk, device, DE_NULL));

	if (VK_EVENT_RESET != vk.getEventStatus(device, event))
	return tcu::TestStatus::fail("Created event should be in unsignaled state");

	if (VK_SUCCESS != vk.setEvent(device, event))
	return tcu::TestStatus::fail("Couldn't set event");

	if (VK_EVENT_SET != vk.getEventStatus(device, event))
	return tcu::TestStatus::fail("Event should be in signaled state after set");

	if (VK_SUCCESS != vk.resetEvent(device, event))
	return tcu::TestStatus::fail("Couldn't reset event");

	if (VK_EVENT_RESET != vk.getEventStatus(device, event))
	return tcu::TestStatus::fail("Event should be in unsignaled state after reset");

	return tcu::TestStatus::pass("Tests set and reset event on host pass");
	}

	tcu::TestStatus deviceResetSetEventCase (Context& context)
	{
	const DeviceInterface& vk = context.getDeviceInterface();
	const VkDevice device = context.getDevice();
	const VkQueue queue = context.getUniversalQueue();
	const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
	const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
	const Unique<VkCommandBuffer> cmdBuffer (makeCommandBuffer(vk, device, *cmdPool));
	const VkSubmitInfo submitInfo =
	{
	VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // deUint32 waitSemaphoreCount;
	DE_NULL, // const VkSemaphore* pWaitSemaphores;
	DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
	1u, // deUint32 commandBufferCount;
	&cmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
	0u, // deUint32 signalSemaphoreCount;
	DE_NULL, // const VkSemaphore* pSignalSemaphores;
	};
	const Unique<VkEvent> event (createEvent(vk, device));

	beginCommandBuffer(vk, *cmdBuffer);
	vk.cmdSetEvent(cmdBuffer, event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
	endCommandBuffer(vk, *cmdBuffer);

	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, DE_NULL));
	VK_CHECK(vk.queueWaitIdle(queue));

	if (VK_EVENT_SET != vk.getEventStatus(device, *event))
	return tcu::TestStatus::fail("Event should be in signaled state after set");

	beginCommandBuffer(vk, *cmdBuffer);
	vk.cmdResetEvent(cmdBuffer, event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
	endCommandBuffer(vk, *cmdBuffer);

	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, DE_NULL));
	VK_CHECK(vk.queueWaitIdle(queue));

	if (VK_EVENT_RESET != vk.getEventStatus(device, *event))
	return tcu::TestStatus::fail("Event should be in unsignaled state after set");

	return tcu::TestStatus::pass("Device set and reset event tests pass");
	}

	tcu::TestStatus singleSubmissionCase (Context& context)
	{
	enum {SET=0, WAIT, COUNT};
	const DeviceInterface& vk = context.getDeviceInterface();
	const VkDevice device = context.getDevice();
	const VkQueue queue = context.getUniversalQueue();
	const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
	const Unique<VkFence> fence (createFence(vk, device));
	const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
	const Move<VkCommandBuffer> ptrCmdBuffer[COUNT] = {makeCommandBuffer(vk, device, cmdPool), makeCommandBuffer(vk, device, cmdPool)};
	VkCommandBuffer cmdBuffers[COUNT] = {ptrCmdBuffer[SET], ptrCmdBuffer[WAIT]};
	const VkSubmitInfo submitInfo =
	{
	VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // deUint32 waitSemaphoreCount;
	DE_NULL, // const VkSemaphore* pWaitSemaphores;
	DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
	2u, // deUint32 commandBufferCount;
	cmdBuffers, // const VkCommandBuffer* pCommandBuffers;
	0u, // deUint32 signalSemaphoreCount;
	DE_NULL, // const VkSemaphore* pSignalSemaphores;
	};
	const Unique<VkEvent> event (createEvent(vk, device));

	beginCommandBuffer(vk, cmdBuffers[SET]);
	vk.cmdSetEvent(cmdBuffers[SET], *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
	endCommandBuffer(vk, cmdBuffers[SET]);

	beginCommandBuffer(vk, cmdBuffers[WAIT]);
	vk.cmdWaitEvents(cmdBuffers[WAIT], 1u, &event.get(),VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
	endCommandBuffer(vk, cmdBuffers[WAIT]);

	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
	if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, LONG_FENCE_WAIT))
	return tcu::TestStatus::fail("Queue should end execution");

	return tcu::TestStatus::pass("Wait and set even on device single submission tests pass");
	}

	tcu::TestStatus multiSubmissionCase (Context& context)
	{
	enum {SET=0, WAIT, COUNT};
	const DeviceInterface& vk = context.getDeviceInterface();
	const VkDevice device = context.getDevice();
	const VkQueue queue = context.getUniversalQueue();
	const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
	const Move<VkFence> ptrFence[COUNT] =
	{
	createFence(vk, device),
	createFence(vk, device)
	};
	VkFence fence[COUNT] = {ptrFence[SET], ptrFence[WAIT]};
	const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
	const Move<VkCommandBuffer> ptrCmdBuffer[COUNT] = {makeCommandBuffer(vk, device, cmdPool), makeCommandBuffer(vk, device, cmdPool)};
	VkCommandBuffer cmdBuffers[COUNT] = {ptrCmdBuffer[SET], ptrCmdBuffer[WAIT]};
	const VkSubmitInfo submitInfo[COUNT] =
	{
	{
	VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // deUint32 waitSemaphoreCount;
	DE_NULL, // const VkSemaphore* pWaitSemaphores;
	DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
	1u, // deUint32 commandBufferCount;
	&cmdBuffers[SET], // const VkCommandBuffer* pCommandBuffers;
	0u, // deUint32 signalSemaphoreCount;
	DE_NULL, // const VkSemaphore* pSignalSemaphores;
	},
	{
	VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // deUint32 waitSemaphoreCount;
	DE_NULL, // const VkSemaphore* pWaitSemaphores;
	DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
	1u, // deUint32 commandBufferCount;
	&cmdBuffers[WAIT], // const VkCommandBuffer* pCommandBuffers;
	0u, // deUint32 signalSemaphoreCount;
	DE_NULL, // const VkSemaphore* pSignalSemaphores;
	}
	};
	const Unique<VkEvent> event (createEvent(vk, device));

	beginCommandBuffer(vk, cmdBuffers[SET]);
	vk.cmdSetEvent(cmdBuffers[SET], *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
	endCommandBuffer(vk, cmdBuffers[SET]);

	beginCommandBuffer(vk, cmdBuffers[WAIT]);
	vk.cmdWaitEvents(cmdBuffers[WAIT], 1u, &event.get(), VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
	endCommandBuffer(vk, cmdBuffers[WAIT]);

	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo[SET], fence[SET]));
	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo[WAIT], fence[WAIT]));

	if (VK_SUCCESS != vk.waitForFences(device, 2u, fence, DE_TRUE, LONG_FENCE_WAIT))
	return tcu::TestStatus::fail("Queue should end execution");

	return tcu::TestStatus::pass("Wait and set even on device multi submission tests pass");
	}

	tcu::TestStatus secondaryCommandBufferCase (Context& context)
	{
	enum {SET=0, WAIT, COUNT};
	const DeviceInterface& vk = context.getDeviceInterface();
	const VkDevice device = context.getDevice();
	const VkQueue queue = context.getUniversalQueue();
	const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
	const Unique<VkFence> fence (createFence(vk, device));
	const Unique<VkCommandPool> cmdPool (createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex));
	const Move<VkCommandBuffer> primaryCmdBuffer (makeCommandBuffer(vk, device, *cmdPool));
	const VkCommandBufferAllocateInfo cmdBufferInfo =
	{
	VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	*cmdPool, // VkCommandPool commandPool;
	VK_COMMAND_BUFFER_LEVEL_SECONDARY, // VkCommandBufferLevel level;
	1u, // deUint32 commandBufferCount;
	};
	const Move<VkCommandBuffer> prtCmdBuffers[COUNT] = {allocateCommandBuffer (vk, device, &cmdBufferInfo), allocateCommandBuffer (vk, device, &cmdBufferInfo)};
	VkCommandBuffer secondaryCmdBuffers[] = {prtCmdBuffers[SET], prtCmdBuffers[WAIT]};
	const VkSubmitInfo submitInfo =
	{
	VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // deUint32 waitSemaphoreCount;
	DE_NULL, // const VkSemaphore* pWaitSemaphores;
	DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
	1u, // deUint32 commandBufferCount;
	&primaryCmdBuffer.get(), // const VkCommandBuffer* pCommandBuffers;
	0u, // deUint32 signalSemaphoreCount;
	DE_NULL, // const VkSemaphore* pSignalSemaphores;
	};
	const Unique<VkEvent> event (createEvent(vk, device));

	const VkCommandBufferInheritanceInfo secCmdBufInheritInfo =
	{
	VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, //VkStructureType sType;
	DE_NULL, //const void* pNext;
	DE_NULL, //VkRenderPass renderPass;
	0u, //deUint32 subpass;
	DE_NULL, //VkFramebuffer framebuffer;
	VK_FALSE, //VkBool32 occlusionQueryEnable;
	(VkQueryControlFlags)0u, //VkQueryControlFlags queryFlags;
	(VkQueryPipelineStatisticFlags)0u, //VkQueryPipelineStatisticFlags pipelineStatistics;
	};
	const VkCommandBufferBeginInfo cmdBufferBeginInfo =
	{
	VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
	&secCmdBufInheritInfo, // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
	};

	VK_CHECK(vk.beginCommandBuffer(secondaryCmdBuffers[SET], &cmdBufferBeginInfo));
	vk.cmdSetEvent(secondaryCmdBuffers[SET], *event, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT);
	endCommandBuffer(vk, secondaryCmdBuffers[SET]);

	VK_CHECK(vk.beginCommandBuffer(secondaryCmdBuffers[WAIT], &cmdBufferBeginInfo));
	vk.cmdWaitEvents(secondaryCmdBuffers[WAIT], 1u, &event.get(),VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0u, DE_NULL, 0u, DE_NULL, 0u, DE_NULL);
	endCommandBuffer(vk, secondaryCmdBuffers[WAIT]);

	beginCommandBuffer(vk, *primaryCmdBuffer);
	vk.cmdExecuteCommands(*primaryCmdBuffer, 2u, secondaryCmdBuffers);
	endCommandBuffer(vk, *primaryCmdBuffer);

	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
	if (VK_SUCCESS != vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, LONG_FENCE_WAIT))
	return tcu::TestStatus::fail("Queue should end execution");

	return tcu::TestStatus::pass("Wait and set even on device using secondary command buffers tests pass");
	}

	} // anonymous

	tcu::TestCaseGroup* createBasicEventTests (tcu::TestContext& testCtx)
	{
	de::MovePtr<tcu::TestCaseGroup> basicTests(new tcu::TestCaseGroup(testCtx, "event", "Basic event tests"));
	addFunctionCase(basicTests.get(), "host_set_reset", "Basic event tests set and reset on host", hostResetSetEventCase);
	addFunctionCase(basicTests.get(), "device_set_reset", "Basic event tests set and reset on device", deviceResetSetEventCase);
	addFunctionCase(basicTests.get(), "single_submit_multi_command_buffer", "Wait and set event single submission on device", singleSubmissionCase);
	addFunctionCase(basicTests.get(), "multi_submit_multi_command_buffer", "Wait and set event mutli submission on device", multiSubmissionCase);
	addFunctionCase(basicTests.get(), "multi_secondary_command_buffer", "Event used on secondary command buffer ", secondaryCommandBufferCase);

	return basicTests.release();
	}

	} // synchronization
	} // vkt