/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 The Khronos Group Inc.
 * Copyright (c) 2016 The Android Open Source Project
 *
 * 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 Cover for non-zero of memoryTypeBits from vkGetBufferMemoryRequirements*() tests.
 *//*--------------------------------------------------------------------*/

#include "vktApiBufferMemoryRequirementsTests.hpp"
#include "vktApiBufferMemoryRequirementsTestsUtils.hpp"

#include "vkMemUtil.hpp"
#include "vkQueryUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkObjUtil.hpp"
#include "deFilePath.hpp"
#include "tcuTestLog.hpp"

#include <algorithm>
#include <array>
#include <functional>
#include <iostream>
#include <set>
#include <sstream>
#include <tuple>
#include <vector>

namespace vkt
{
namespace api
{
namespace
{

using namespace de;
using namespace vk;
using namespace tcu;

struct TestConfig;
struct InstanceConfig;

enum BufferFateFlagBits
{
	Transfer		= 0x01,
	Storage			= 0x02,
	Other			= 0x04,
	AccStructure	= 0x08,
	Video			= 0x10
};
typedef deUint32	BufferFateFlags;
typedef typename std::add_pointer<typename std::add_const<char>::type>::type	cstr;
typedef u::BitsSet<BufferFateFlags, BufferFateFlagBits, cstr> BufferFateBits;

const BufferFateBits	AvailableBufferFateBits
{
	std::make_tuple(Transfer,		"transfer_usage_bits"	),
	std::make_tuple(Storage,		"storage_usage_bits"	),
	std::make_tuple(Other,			"other_usage_bits"		),
	std::make_tuple(AccStructure,	"acc_struct_usage_bits"	),
	std::make_tuple(Video,			"video_usage_bits"		),
};

typedef u::BitsSet<VkBufferCreateFlags, VkBufferCreateFlagBits, cstr>				BufferCreateBits;
typedef u::BitsSet<VkBufferUsageFlags, VkBufferUsageFlagBits, BufferFateFlagBits>	BufferUsageBits;
typedef u::BitsSet<VkExternalMemoryHandleTypeFlags,
					VkExternalMemoryHandleTypeFlagBits, cstr, bool>					ExternalMemoryHandleBits;
typedef SharedPtr<BufferCreateBits>			BufferCreateBitsPtr;
typedef SharedPtr<BufferUsageBits>			BufferUsageBitsPtr;
typedef SharedPtr<ExternalMemoryHandleBits>	ExternalMemoryHandleBitsPtr;

struct TestConfig
{
	bool						useMethod2;
	SharedPtr<BufferCreateBits>	createBits;
	SharedPtr<BufferFateBits>	fateBits;
	bool						incExtMemTypeFlags;
	// Tests the buffer memory size requirement is less than or equal to the aligned size of the buffer.
	// Requires VK_KHR_maintenance4 extension.
	bool						testSizeRequirements;
};
struct InstanceConfig
{
	bool												useMethod2;
	SharedPtr<BufferCreateBits>							createBits;
	SharedPtr<BufferFateBits>							fateBits;
	SharedPtr<std::vector<BufferUsageBitsPtr>>			usageFlags;
	bool												incExtMemTypeFlags;
	SharedPtr<std::vector<ExternalMemoryHandleBitsPtr>>	extMemHandleFlags;
	bool												testSizeRequirements;

	InstanceConfig(const TestConfig& conf)
		: useMethod2			(conf.useMethod2)
		, createBits			(conf.createBits)
		, fateBits				(conf.fateBits)
		, usageFlags			(new std::vector<SharedPtr<BufferUsageBits>>)
		, incExtMemTypeFlags	(conf.incExtMemTypeFlags)
		, extMemHandleFlags		(new std::vector<SharedPtr<ExternalMemoryHandleBits>>)
		, testSizeRequirements	(conf.testSizeRequirements) {}
};

const BufferCreateBits	AvailableBufferCreateBits
{
	std::make_tuple(VkBufferCreateFlagBits(0),				"no_flags"			),
	std::make_tuple(VK_BUFFER_CREATE_PROTECTED_BIT,			"protected"			),
	std::make_tuple(VK_BUFFER_CREATE_SPARSE_BINDING_BIT,	"sparse_binding"	),
	std::make_tuple(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT,	"sparse_residency"	),
	std::make_tuple(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT,	"sparse_aliased"	),
};

const BufferUsageBits	AvailableBufferUsageBits
{
	std::make_tuple(VK_BUFFER_USAGE_TRANSFER_SRC_BIT										, Transfer		),
	std::make_tuple(VK_BUFFER_USAGE_TRANSFER_DST_BIT										, Transfer		),
	std::make_tuple(VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT								, Storage		),
	std::make_tuple(VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT								, Storage		),
	std::make_tuple(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT										, Storage		),
	std::make_tuple(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT										, Storage		),
	std::make_tuple(VK_BUFFER_USAGE_INDEX_BUFFER_BIT										, Storage		),
	std::make_tuple(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT										, Storage		),
	std::make_tuple(VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT										, Other			),
	std::make_tuple(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT								, Other			),
	std::make_tuple(VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR								, Video			),
	std::make_tuple(VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR								, Video			),
	std::make_tuple(VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT						, Other			),
	std::make_tuple(VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT				, Other			),
	std::make_tuple(VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT							, Other			),
	std::make_tuple(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR	, AccStructure	),
	std::make_tuple(VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR					, AccStructure	),
	std::make_tuple(VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR							, AccStructure	),
	std::make_tuple(VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR								, Video			),
	std::make_tuple(VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR								, Video			),
};

#define INTERNALTEST_EXTERNAL_MEMORY_HANDLE_TYPE_NO_BITS VkExternalMemoryHandleTypeFlagBits(0)
const ExternalMemoryHandleBits	AvailableExternalMemoryHandleBits
{
	std::make_tuple(INTERNALTEST_EXTERNAL_MEMORY_HANDLE_TYPE_NO_BITS					, "no_flags",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT						, "opaque_fd",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT						, "opaque_win32",		false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT					, "opaque_win32_kmt",	false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT					, "d3d11_tex",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT				, "d3d11_tex_kmt",		false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT						, "d3d12_heap",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT					, "d3d12_rsrc",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT						, "dma_buf",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID	, "android_hw",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT				, "host_alloc",			true  ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT	, "host_mapped",		true  ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA				, "zircon_vmo",			false ),
	std::make_tuple(VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV					, "roma_addr",			false ),
};

template<class Flag, class Bit, class Str, class... Ignored>
std::string bitsToString (const u::BitsSet<Flag, Bit, Str, Ignored...>& bits,
						  const std::string& prefix = std::string())
{
	DE_ASSERT(!bits.empty());
	std::stringstream s;
	s << prefix;
	bool atLeastOne = false;
	for (const auto& bit : bits) {
		if (atLeastOne) s << '_';
		s << std::get<1>(bit);
		atLeastOne = true;
	}
	return s.str();
}

void updateBufferCreateFlags(std::vector<BufferCreateBits>& flags)
{
	const auto&	residencyBit	= AvailableBufferCreateBits.get(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT);
	const auto&	aliasedBit		= AvailableBufferCreateBits.get(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT);
	const auto&	bindingBit		= AvailableBufferCreateBits.get(VK_BUFFER_CREATE_SPARSE_BINDING_BIT);
	const auto&	protectedBit	= AvailableBufferCreateBits.get(VK_BUFFER_CREATE_PROTECTED_BIT);
	const auto&	noneBit			= AvailableBufferCreateBits.get(VkBufferCreateFlagBits(0));

	// VUID-VkBufferCreateInfo-flags-00918 { if sparse residency or sparse aliased include sparse binding }
	for (auto& bits : flags)
	{
		if (bits.contains(residencyBit) || bits.contains(aliasedBit))
			bits.insert(bindingBit);
	}

	// VUID-VkBufferCreateInfo-None-01888 { if sparse residency, sparse aliased or sparse binding then flags must not include protected }
	const typename BufferCreateBits::key_type disallowdBits[] { residencyBit, aliasedBit, bindingBit };
	for (auto i = flags.begin(); i != flags.end();)
	{
		auto& bits = *i;
		if (bits.contains(protectedBit))
		{
			for (const auto& disallowdBit : disallowdBits)
			{
				auto find = bits.find(disallowdBit);
				if (find != bits.end())
					bits.erase(find);
			}
		}
		i = bits.empty() ? flags.erase(i) : std::next(i);
	}

	// since 0 is a valid VkBufferCreateFlagBits flag then remove it flags where it exists along with other non-zero flags
	for (auto i = flags.begin(); i != flags.end(); ++i)
	{
		auto& bits = *i;
		auto find = bits.find(noneBit);
		if (find != bits.end() && bits.size() > 1)
		{
			bits.erase(find);
		}
	}

	// remove duplicates
	for (auto i = flags.begin(); i != flags.end(); ++i)
	{
		for (auto j = std::next(i); j != flags.end();)
			j = (*i == *j) ? flags.erase(j) : std::next(j);
	}
}

class BufferMemoryRequirementsInstance : public TestInstance
{
public:
							BufferMemoryRequirementsInstance	(Context&				context,
																 const InstanceConfig	config)
								: TestInstance	(context)
								, m_config		(config) {}

	virtual					~BufferMemoryRequirementsInstance	(void) override = default;
	virtual tcu::TestStatus	iterate								(void) override;

	void						getBufferMemoryRequirements		(VkMemoryRequirements&	result,
																 const DeviceInterface&	vkd,
																 VkDevice				device,
																 VkBuffer				buffer) const;
	void						getBufferMemoryRequirements2	(VkMemoryRequirements&	result,
																 const DeviceInterface&	vkd,
																 VkDevice				device,
																 VkBuffer				buffer) const;
	typedef void (BufferMemoryRequirementsInstance::* Method)	(VkMemoryRequirements&	result,
																 const DeviceInterface&	intf,
																 VkDevice				device,
																 VkBuffer				buffer) const;
	template<class T, class... AddArgs>
						void*	chainVkStructure				(void*					pNext,
																 const AddArgs&...		addArgs) const;
private:
	void						logFailedSubtests				(const std::vector<BufferCreateBitsPtr>&			failCreateBits,
																 const std::vector<BufferUsageBitsPtr>&				failUsageBits,
																 const std::vector<ExternalMemoryHandleBitsPtr>&	failExtMemHandleBits) const;
	const InstanceConfig	m_config;
};

class MemoryRequirementsTest : public TestCase
{
public:
							MemoryRequirementsTest	(TestContext&			testCtx,
													 const std::string&		name,
													 const TestConfig		testConfig)
								: TestCase		(testCtx, name, std::string())
								, m_testConfig	(testConfig)
								, m_instConfig	(testConfig) {}

	virtual					~MemoryRequirementsTest	(void) override = default;
	virtual void			checkSupport			(Context&				context) const override;
	virtual TestInstance*	createInstance			(Context&				context) const override
	{
		return new BufferMemoryRequirementsInstance(context, m_instConfig);
	}

private:
	const TestConfig	m_testConfig;
	InstanceConfig		m_instConfig;
};

struct Info
{
	enum Type {
		Create,
		Usage
	}					m_type;
	std::ostringstream	m_str;
	cstr				m_file;
	int					m_line;
	template<class Msg>	Info(Type type, const Msg& msg, cstr file, int line)
		: m_type(type), m_str(), m_file(file), m_line(line) { m_str << msg; }
	friend std::ostringstream& operator<<(std::ostringstream& str, const Info& info) {
		switch (info.m_type) {
		case Create:
			str << "  Info (Create buffer with " << info.m_str.str() << " not supported by device at "
				<< de::FilePath(info.m_file).getBaseName() << ":" << info.m_line << ")";
			break;
		case Usage:
			str << "  Info (Create buffer with " << info.m_str.str() << " not supported by device at "
				<< de::FilePath(info.m_file).getBaseName() << ":" << info.m_line << ")";
			break;
		}
		return str;
	}
};
#define INFOCREATE(msg_) Info(Info::Create, (msg_), __FILE__, __LINE__)
#define INFOUSAGE(msg_) Info(Info::Usage, (msg_), __FILE__, __LINE__)

#ifndef VK_KHR_VIDEO_QUEUE_EXTENSION_NAME
#define VK_KHR_VIDEO_QUEUE_EXTENSION_NAME "VK_KHR_video_queue"
#endif

#ifndef VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME
#define VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME "VK_EXT_video_encode_h264"
#endif

#ifndef VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME
#define VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME "VK_EXT_video_decode_h264"
#endif

VkVideoCodecOperationFlagsKHR readVideoCodecOperationFlagsKHR (const InstanceInterface& vki, const VkPhysicalDevice& device)
{
	uint32_t	queueFamilyPropertyCount = 0;
	vki.getPhysicalDeviceQueueFamilyProperties2(device, &queueFamilyPropertyCount, nullptr);
	DE_ASSERT(queueFamilyPropertyCount);

	std::vector<VkVideoQueueFamilyProperties2KHR>	videoQueueFamilyProperties(
														queueFamilyPropertyCount,
														{
														   VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR,	// VkStructureType					sType
														   nullptr,													// void*							pNext
														   0														// VkVideoCodecOperationFlagsKHR	videoCodecOperations
														});
	std::vector<VkQueueFamilyProperties2>			queueFamilyProperties(
														queueFamilyPropertyCount,
														{
															VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,			// VkStructureType					sType
															nullptr,												// void*							pNext
															{}														// VkQueueFamilyProperties			queueFamilyProperties
														});
	for (auto begin = queueFamilyProperties.begin(), i = begin, end = queueFamilyProperties.end(); i != end; ++i)
	{
		i->pNext = &videoQueueFamilyProperties.data()[std::distance(begin, i)];
	}

	vki.getPhysicalDeviceQueueFamilyProperties2(device, &queueFamilyPropertyCount, queueFamilyProperties.data());

	VkVideoCodecOperationFlagsKHR	codecOperationFlags = VK_VIDEO_CODEC_OPERATION_INVALID_BIT_KHR;
	for (const VkVideoQueueFamilyProperties2KHR& props : videoQueueFamilyProperties)
	{
		codecOperationFlags |= props.videoCodecOperations;
	}

	return codecOperationFlags;
}

void MemoryRequirementsTest::checkSupport (Context& context) const
{
	const InstanceInterface&						intf				= context.getInstanceInterface();
	const VkPhysicalDevice							physDevice			= context.getPhysicalDevice();

	if (m_testConfig.useMethod2)
		context.requireDeviceFunctionality(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);

	VkPhysicalDeviceProtectedMemoryFeatures			protectedMemFeatures
	{
		vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,	// VkStructureType	sType;
		nullptr,															// void*			pNext;
		VK_FALSE															// VkBool32			protectedMemory;
	};
	VkPhysicalDeviceFeatures2						extFeatures
	{
		vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,					// VkStructureType			sType;
		&protectedMemFeatures,												// void*					pNext;
		{}																	// VkPhysicalDeviceFeatures	features;
	};
	intf.getPhysicalDeviceFeatures2(physDevice, &extFeatures);

	const VkPhysicalDeviceFeatures&	features					= extFeatures.features;
	const VkBool32&					protectedMemFeatureEnabled	= protectedMemFeatures.protectedMemory;

	// check the creating bits
	{
		std::ostringstream			str;
		bool		notSupported	= false;
		const auto& createBits		= *m_testConfig.createBits;

		if (createBits.contains(VK_BUFFER_CREATE_SPARSE_BINDING_BIT) && (VK_FALSE == features.sparseBinding))
		{
			str << INFOCREATE(getBufferCreateFlagsStr(VK_BUFFER_CREATE_SPARSE_BINDING_BIT));
			notSupported = true;
		}
		if (createBits.contains(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT) && (VK_FALSE == features.sparseResidencyBuffer))
		{
			if (notSupported) str << std::endl;
			str << INFOCREATE(getBufferCreateFlagsStr(VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT));
			notSupported = true;
		}
		if (createBits.contains(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT) && (VK_FALSE == features.sparseResidencyAliased))
		{
			if (notSupported) str << std::endl;
			str << INFOCREATE(getBufferCreateFlagsStr(VK_BUFFER_CREATE_SPARSE_ALIASED_BIT));
			notSupported = true;
		}
		if (createBits.contains(VK_BUFFER_CREATE_PROTECTED_BIT) && (VK_FALSE == protectedMemFeatureEnabled))
		{
			if (notSupported) str << std::endl;
			str << INFOCREATE(getBufferCreateFlagsStr(VK_BUFFER_CREATE_PROTECTED_BIT));
			notSupported = true;
		}
		if (notSupported)
		{
			std::cout << str.str() << std::endl;
			TCU_THROW(NotSupportedError, "One or more create buffer flags not supported by device");
		}
	}

	// check the usage bits and build instance input
	{
		std::vector<BufferUsageBits>	usageFlags;
		for (const auto& bit : *m_testConfig.fateBits)
		{
			auto fate = m_testConfig.fateBits->extract(bit);
			std::vector<VkBufferUsageFlags>		usageHints;
			std::vector<BufferUsageBits>		usageFlagsTmp;
			u::combine(usageFlagsTmp, AvailableBufferUsageBits.select<1>(fate), usageHints);
			u::mergeFlags(usageFlags, usageFlagsTmp);
		}

		std::ostringstream str;
		std::array<bool, 7> msgs;
		bool notSupported	= false;
		int  entryCount		= 0;
		msgs.fill(false);

		for (auto i = usageFlags.begin(); i != usageFlags.end();)
		{
			notSupported = false;

			if (i->any({VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR,
					   VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR, VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR})
					&& !context.isDeviceFunctionalitySupported("VK_KHR_acceleration_structure"))
			{
				if (!msgs[0])
				{
					if (entryCount++) str << std::endl;
					str << INFOUSAGE("VK_KHR_acceleration_structure not supported by device");
					msgs[0] = true;
				}
				notSupported = true;
			}

			if (i->contains(VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT)
					&& !context.isBufferDeviceAddressSupported())
			{
				if (!msgs[1])
				{
					if (entryCount++) str << std::endl;
					str << INFOUSAGE("VK_EXT_buffer_device_address not supported by device");
					msgs[1] = true;
				}
				notSupported = true;
			}

			if (i->any({VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR,
						VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR}))
			{
				if (!context.isDeviceFunctionalitySupported(VK_KHR_VIDEO_QUEUE_EXTENSION_NAME))
				{
					if (!msgs[2])
					{
						if (entryCount++) str << std::endl;
						str << INFOUSAGE("VK_EXT_video_queue not supported by device");
						msgs[2] = true;
					}
					notSupported = true;
				}
				else
				{
					const VkVideoCodecOperationFlagsKHR videoFlags = readVideoCodecOperationFlagsKHR(intf, physDevice);

					if (i->any({VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR}))
					{
						if (!context.isDeviceFunctionalitySupported(VK_EXT_VIDEO_ENCODE_H264_EXTENSION_NAME))
						{
							if (!msgs[3])
							{
								if (entryCount++) str << std::endl;
								str << INFOUSAGE("VK_EXT_video_encode_h264 not supported by device");
								msgs[3] = true;
							}
							notSupported = true;
						}
						if (!(videoFlags & VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT))
						{
							if (!msgs[4])
							{
								if (entryCount++) str << std::endl;
								str << INFOUSAGE("Could not find a queue that supports VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT on device");
								msgs[4] = true;
							}
							notSupported = true;
						}
					}
					if (i->any({VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR, VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR}))
					{
						if (!context.isDeviceFunctionalitySupported(VK_EXT_VIDEO_DECODE_H264_EXTENSION_NAME))
						{
							if (!msgs[5])
							{
								if (entryCount++) str << std::endl;
								str << INFOUSAGE("VK_EXT_video_decode_h264 not supported by device");
								msgs[5] = true;
							}
							notSupported = true;
						}
						if (!(videoFlags & VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT))
						{
							if (!msgs[6])
							{
								if (entryCount++) str << std::endl;
								str << INFOUSAGE("Could not find a queue that supports VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT on device");
								msgs[6] = true;
							}
							notSupported = true;
						}
					}
				}
			}

			i = notSupported ? usageFlags.erase(i) : std::next(i);
		}

		// remove duplicates
		for (auto i = usageFlags.begin(); i != usageFlags.end(); ++i)
		{
			for (auto j = std::next(i); j != usageFlags.end();)
				j = (*i == *j) ? usageFlags.erase(j) : std::next(j);
		}

		if (usageFlags.empty())
		{
			std::cout << str.str() << std::endl;
			TCU_THROW(NotSupportedError, "One or more buffer usage flags not supported by device");
		}
		else
		{
			if (entryCount > 0)
			{
				std::cout << str.str() << std::endl;
			}
			DE_ASSERT(m_instConfig.usageFlags.get());
			m_instConfig.usageFlags->resize(usageFlags.size());
			std::transform(usageFlags.begin(), usageFlags.end(), m_instConfig.usageFlags->begin(),
						   [](BufferUsageBits& bits){ return BufferUsageBits::makeShared(std::move(bits)); });
		}
	}

	// check the external memory handle type bits and build instance input
	{
		std::vector<ExternalMemoryHandleBits>	extMemHandleFlags;
		if (m_testConfig.incExtMemTypeFlags)
			extMemHandleFlags.push_back({AvailableExternalMemoryHandleBits.get(INTERNALTEST_EXTERNAL_MEMORY_HANDLE_TYPE_NO_BITS)});
		else
		{
			std::vector<VkExternalMemoryHandleTypeFlags>	handleHints;
			std::vector<ExternalMemoryHandleBits>			handleFlagsTmp;
			u::combine(handleFlagsTmp, AvailableExternalMemoryHandleBits.select<2>(true), handleHints);
			u::mergeFlags(extMemHandleFlags, handleFlagsTmp);
		}

		DE_ASSERT(m_instConfig.extMemHandleFlags.get());
		m_instConfig.extMemHandleFlags->resize(extMemHandleFlags.size());
		std::transform(extMemHandleFlags.begin(), extMemHandleFlags.end(), m_instConfig.extMemHandleFlags->begin(),
					   [](ExternalMemoryHandleBits& bits){ return ExternalMemoryHandleBits::makeShared(std::move(bits)); });
	}

	if (m_testConfig.testSizeRequirements)
	{
		if (!context.isDeviceFunctionalitySupported("VK_KHR_maintenance4"))
			TCU_THROW(NotSupportedError, "VK_KHR_maintenance4 not supported");
	}
}

void BufferMemoryRequirementsInstance::logFailedSubtests (const std::vector<BufferCreateBitsPtr>&			failCreateBits,
														  const std::vector<BufferUsageBitsPtr>&			failUsageBits,
														  const std::vector<ExternalMemoryHandleBitsPtr>&	failExtMemHandleBits) const
{
	const deUint32	flagCount	= deUint32(failCreateBits.size());
	TestLog&		log			= m_context.getTestContext().getLog();
	deUint32		entries		= 0;

	DE_ASSERT(flagCount && flagCount == failUsageBits.size() && flagCount == failExtMemHandleBits.size());

	log << TestLog::Section("Failed", "Failed subtests");

	for (deUint32 i = 0; i < flagCount; ++i)
	{
		{
			log << TestLog::Section("VkBufferCreateFlags", "Buffer create flags");
			auto msg = log << TestLog::Message;
			entries = 0;
			for (const auto& createBit : *failCreateBits[i])
			{
				if (entries++) msg << " ";
				const VkBufferCreateFlags flags = BufferCreateBits::extract(createBit);
				if (flags == 0)
					msg << "0";
				else msg << getBufferCreateFlagsStr(flags);
			}
			msg << TestLog::EndMessage << TestLog::EndSection;
		}

		{
			log << TestLog::Section("VkBufferUsageFlags", "Buffer usage flags");
			auto msg = log << TestLog::Message;
			entries = 0;
			for (const auto& usageBit : *failUsageBits[i])
			{
				if (entries++) msg << " ";
				msg << getBufferUsageFlagsStr(BufferUsageBits::extract(usageBit));
			}
			msg << TestLog::EndMessage << TestLog::EndSection;
		}

		{
			log << TestLog::Section("VkExternalMemoryHandleTypeFlags", "External memory handle type flags");
			auto msg = log << TestLog::Message;
			entries = 0;
			for (const auto& extMemHandleTypeBit : *failExtMemHandleBits[i])
			{
				if (entries++) msg << " ";
				msg << getExternalMemoryHandleTypeFlagsStr(ExternalMemoryHandleBits::extract(extMemHandleTypeBit));
			}
			msg << TestLog::EndMessage << TestLog::EndSection;
		}
	}

	log << TestLog::EndSection;
}

void BufferMemoryRequirementsInstance::getBufferMemoryRequirements2	(VkMemoryRequirements&	result,
																	 const DeviceInterface&	vkd,
																	 VkDevice				device,
																	 VkBuffer				buffer) const
{
	VkMemoryDedicatedRequirements	dedicatedRequirements	=
	{
		VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,		// VkStructureType			sType;
		nullptr,												// const void*				pNext;
		VK_FALSE,												// VkBool32					prefersDedicatedAllocation
		VK_FALSE												// VkBool32					requiresDedicatedAllocation
	};

	VkMemoryRequirements2			desiredRequirements		=
	{
		VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,				// VkStructureType			sType
		&dedicatedRequirements,									// void*					pNext
		result													// VkMemoryRequirements		memoryRequirements
	};

	VkBufferMemoryRequirementsInfo2	requirementsInfo		=
	{
		VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,	// VkStructureType			sType
		nullptr,												// const void*				pNext
		buffer													// VkBuffer					buffer
	};

	vkd.getBufferMemoryRequirements2(device, &requirementsInfo, &desiredRequirements);

	result = desiredRequirements.memoryRequirements;
}

void BufferMemoryRequirementsInstance::getBufferMemoryRequirements	(VkMemoryRequirements&	result,
																	 const DeviceInterface&	vkd,
																	 VkDevice				device,
																	 VkBuffer				buffer) const
{
	vkd.getBufferMemoryRequirements(device, buffer, &result);
}

template<> void*
BufferMemoryRequirementsInstance::chainVkStructure<VkExternalMemoryBufferCreateInfo> (void* pNext, const VkExternalMemoryHandleTypeFlags& handleTypes) const
{
	static VkExternalMemoryBufferCreateInfo	memInfo{};
	memInfo.sType		= VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
	memInfo.pNext		= pNext;
	memInfo.handleTypes	= handleTypes;

	return &memInfo;
}

template<> void* BufferMemoryRequirementsInstance::chainVkStructure<VkVideoProfilesKHR> (void* pNext, const VkBufferUsageFlags& videoCodecUsage) const
{
	const bool encode = (videoCodecUsage & VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR) || (videoCodecUsage & VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR);
	const bool decode = (videoCodecUsage & VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR) || (videoCodecUsage & VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR);

	static VkVideoEncodeH264ProfileEXT	encodeProfile
	{
		VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT,		// VkStructureType						sType;
		nullptr,												// const void*							pNext;
		STD_VIDEO_H264_PROFILE_IDC_BASELINE						// StdVideoH264ProfileIdc				stdProfileIdc;
	};

	static VkVideoDecodeH264ProfileEXT	decodeProfile
	{
		VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT,		// VkStructureType						sType;
		nullptr,												// const void*							pNext;
		STD_VIDEO_H264_PROFILE_IDC_BASELINE,					// StdVideoH264ProfileIdc				stdProfileIdc;
		VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_EXT		// VkVideoDecodeH264FieldLayoutFlagsEXT	fieldLayout;
	};

	static const VkVideoProfileKHR	videoProfiles[]
	{
		// encode profile
		{
			VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR,				// VkStructureType						sType;
			&encodeProfile,										// void*								pNext;
			VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT,		// VkVideoCodecOperationFlagBitsKHR		videoCodecOperation;
			VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR,		// VkVideoChromaSubsamplingFlagsKHR		chromaSubsampling;
			VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,				// VkVideoComponentBitDepthFlagsKHR		lumaBitDepth;
			VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR				// VkVideoComponentBitDepthFlagsKHR		chromaBitDepth;
		},
		// decode profile
		{
			VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR,				// VkStructureType						sType;
			&decodeProfile,										// void*								pNext;
			VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_EXT,		// VkVideoCodecOperationFlagBitsKHR		videoCodecOperation;
			VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR,		// VkVideoChromaSubsamplingFlagsKHR		chromaSubsampling;
			VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR,				// VkVideoComponentBitDepthFlagsKHR		lumaBitDepth;
			VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR				// VkVideoComponentBitDepthFlagsKHR		chromaBitDepth;
		}
	};
	static VkVideoProfilesKHR	profiles;
	profiles.sType			= VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR;
	profiles.pNext			= pNext;
	if (encode && decode)
	{
		profiles.profileCount	= 2u;
		profiles.pProfiles		= videoProfiles;
	}
	else if (encode)
	{
		profiles.profileCount	= 1u;
		profiles.pProfiles		= &videoProfiles[0];
	}
	else
	{
		profiles.profileCount	= 1u;
		profiles.pProfiles		= &videoProfiles[1];
	}
	return &profiles;
}

TestStatus	BufferMemoryRequirementsInstance::iterate (void)
{
	const DeviceInterface&							vkd					= m_context.getDeviceInterface();
	const VkDevice									device				= m_context.getDevice();
	const deUint32									queueFamilyIndex	= m_context.getUniversalQueueFamilyIndex();
	const Method									method				= m_config.useMethod2
																			? &BufferMemoryRequirementsInstance::getBufferMemoryRequirements2
																			: &BufferMemoryRequirementsInstance::getBufferMemoryRequirements;

	deUint32										passCount			= 0;
	deUint32										failCount			= 0;
	std::vector<BufferCreateBitsPtr>				failCreateBits;
	std::vector<BufferUsageBitsPtr>					failUsageBits;
	std::vector<ExternalMemoryHandleBitsPtr>		failExtMemHandleBits;

	DE_ASSERT(!m_config.createBits->empty());
	const VkBufferCreateFlags infoCreateFlags = *m_config.createBits;
	{
		DE_ASSERT(!m_config.usageFlags->empty());
		for (auto u = m_config.usageFlags->cbegin(); u != m_config.usageFlags->cend(); ++u)
		{
			const VkBufferUsageFlags infoUsageFlags = *(u->get());

			DE_ASSERT(!m_config.extMemHandleFlags->empty());
			for (auto m = m_config.extMemHandleFlags->cbegin(); m != m_config.extMemHandleFlags->cend(); ++m)
			{
				const VkExternalMemoryHandleTypeFlags handleFlags = *(m->get());

				void* pNext = nullptr;

				if (m_config.fateBits->contains(BufferFateFlagBits::Video))
				{
					pNext = chainVkStructure<VkVideoProfilesKHR>(pNext, infoUsageFlags);
				}
				if (m_config.incExtMemTypeFlags)
				{
					pNext = chainVkStructure<VkExternalMemoryBufferCreateInfo>(pNext, handleFlags);
				}
				VkBufferCreateInfo	createInfo
				{
					VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,					// VkStructureType					sType;
					pNext,													// const void*						pNext;
					infoCreateFlags,										// VkBufferCreateFlags				flags;
					4096u,													// VkDeviceSize						size;
					infoUsageFlags,											// VkBufferUsageFlags				usage;
					VK_SHARING_MODE_EXCLUSIVE,								// VkSharingMode					sharingMode;
					1u,														// uint32_t							queueFamilyIndexCount;
					&queueFamilyIndex,										// const uint32_t*					pQueueFamilyIndices;
				};

				if (m_config.testSizeRequirements)
				{
					VkPhysicalDeviceMaintenance4PropertiesKHR	maintenance4Properties		=
					{
						VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR,	// VkStructureType	sType;
						DE_NULL,														// void*			pNext;
						0u																// VkDeviceSize		maxBufferSize;
					};

					VkPhysicalDeviceProperties2					physicalDeviceProperties2	=
					{
						VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,	// VkStructureType				sType;
						&maintenance4Properties,						// void*						pNext;
						{},												// VkPhysicalDeviceProperties	properties;
					};

					m_context.getInstanceInterface().getPhysicalDeviceProperties2(m_context.getPhysicalDevice(), &physicalDeviceProperties2);

					const VkDeviceSize							maxBufferSize				= maintenance4Properties.maxBufferSize;
					DE_ASSERT(maxBufferSize > 0);
					VkDeviceSize								N							= 0;

					while ((1ull << N) + 1 < maxBufferSize)
					{
						createInfo.size = (1ull << N) + 1;

						try
						{
							Move<VkBuffer> buffer = createBuffer(vkd, device, &createInfo);

							VkMemoryRequirements reqs{};
							(this->*method)(reqs, vkd, device, *buffer);

							if (reqs.size <= static_cast<VkDeviceSize>(deAlign64(static_cast<deInt64>(createInfo.size), static_cast<deInt64>(reqs.alignment))))
							{
								++passCount;
							} else
							{
								++failCount;
								failCreateBits.emplace_back(m_config.createBits);
								failUsageBits.emplace_back(*u);
								failExtMemHandleBits.emplace_back(*m);
							}

							N++;
						}
						catch (const vk::OutOfMemoryError&)
						{
							break;
						}
					}

					if (m_context.getTestContext().getWatchDog())
						qpWatchDog_reset(m_context.getTestContext().getWatchDog());
				}
				else
				{
					Move<VkBuffer> buffer = createBuffer(vkd, device, &createInfo);

					VkMemoryRequirements reqs{};
					(this->*method)(reqs, vkd, device, *buffer);
					if (reqs.memoryTypeBits)
						++passCount;
					else
					{
						++failCount;
						failCreateBits.emplace_back(m_config.createBits);
						failUsageBits.emplace_back(*u);
						failExtMemHandleBits.emplace_back(*m);
					}
				}
			}
		}
	}

	if (failCount)
	{
		logFailedSubtests(failCreateBits, failUsageBits, failExtMemHandleBits);
		return TestStatus::fail(std::to_string(failCount));
	}

	return TestStatus::pass(std::to_string(passCount));
}

} // unnamed namespace

tcu::TestCaseGroup* createBufferMemoryRequirementsTests (tcu::TestContext& testCtx)
{
	cstr nilstr = "";

	struct
	{
		bool		include;
		cstr		name;
	} const extMemTypeFlags[] { { false, "ext_mem_flags_excluded" }, { true, "ext_mem_flags_included" } };

	struct
	{
		bool		method;
		cstr		name;
	} const methods[] { { false, "method1" }, { true, "method2" } };

	std::vector<SharedPtr<BufferCreateBits>>	createBitPtrs;
	{
		std::vector<VkBufferCreateFlags>		hints;
		std::vector<BufferCreateBits>			createFlags;
		u::combine(createFlags,	AvailableBufferCreateBits, hints);
		updateBufferCreateFlags(createFlags);
		createBitPtrs.resize(createFlags.size());
		std::transform(createFlags.begin(), createFlags.end(), createBitPtrs.begin(),
					   [](BufferCreateBits& bits) { return BufferCreateBits::makeShared(std::move(bits)); });
	}

	std::vector<SharedPtr<BufferFateBits>>	fateBitPtrs;
	{
		// An excerpt above has been disabled consciously for the sake of computational complexity.
		// Enabled block does the same things sequentially, it doesn't create cartesian product of combination of bits.
#if 0
		std::vector<BufferFateFlags>	hints;
		std::vector<BufferFateBits>		bufferFateFlags;
		u::combine(bufferFateFlags, AvailableBufferFateBits, hints);
		fateBitPtrs.resize(bufferFateFlags.size());
		std::transform(bufferFateFlags.begin(), bufferFateFlags.end(), fateBitPtrs.begin(),
					   [](BufferFateBits& bits) { return BufferFateBits::makeShared(std::move(bits)); });
#else
		fateBitPtrs.resize(AvailableBufferFateBits.size());
		std::transform(AvailableBufferFateBits.begin(), AvailableBufferFateBits.end(), fateBitPtrs.begin(),
					   [](const typename BufferFateBits::value_type& bit) { return BufferFateBits::makeShared(bit); });
#endif
	}

	auto groupRoot = new TestCaseGroup(testCtx, "buffer_memory_requirements", "vkGetBufferMemoryRequirements*(...) routines tests.");
	for (const auto& createBits : createBitPtrs)
	{
		auto groupCreate = new TestCaseGroup(testCtx, bitsToString(*createBits, "create_").c_str(), nilstr);
		for (const auto& extMemTypeFlag : extMemTypeFlags)
		{
			auto groupExtMemTypeFlags = new TestCaseGroup(testCtx, extMemTypeFlag.name, nilstr);
			for (const auto& method : methods)
			{
				auto groupMethod = new TestCaseGroup(testCtx, method.name, nilstr);
				for (const auto& fateBits : fateBitPtrs)
				{
					for (const auto testSizeReq : {false, true})
					{
						TestConfig	config;
						config.fateBits				= fateBits;
						config.incExtMemTypeFlags	= extMemTypeFlag.include;
						config.createBits			= createBits;
						config.useMethod2			= method.method;
						config.testSizeRequirements	= testSizeReq;
						groupMethod->addChild(new MemoryRequirementsTest(testCtx, ((testSizeReq ? "size_req_" : "") + bitsToString(*fateBits)).c_str(), config));
					}
				}
				groupExtMemTypeFlags->addChild(groupMethod);
			}
			groupCreate->addChild(groupExtMemTypeFlags);
		}
		groupRoot->addChild(groupCreate);
	}

	return groupRoot;
}
} // api
} // vkt