external/vulkancts/modules/vulkan/spirv_assembly/vktSpvAsmEmptyStructTests.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2020 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 Test copying struct which contains an empty struct.
 		  Test pointer comparisons of empty struct members.
  *//*--------------------------------------------------------------------*/

 #include "vktSpvAsmComputeShaderTestUtil.hpp"
 #include "vktSpvAsmComputeShaderCase.hpp"
 #include "vktSpvAsmEmptyStructTests.hpp"
 #include "tcuStringTemplate.hpp"
 #include "vktTestGroupUtil.hpp"
 #include "vktSpvAsmUtils.hpp"

 namespace vkt
 {
 namespace SpirVAssembly
 {
 namespace
 {

 bool verifyResult(const std::vector<Resource>&,
 				  const std::vector<AllocationSp>&	outputAllocs,
 				  const std::vector<Resource>&		expectedOutputs,
 				  tcu::TestLog&)
 {
 	for (deUint32 outputNdx = 0; outputNdx < static_cast<deUint32>(outputAllocs.size()); ++outputNdx)
 	{
 		std::vector<deUint8> expectedBytes;
 		expectedOutputs[outputNdx].getBytes(expectedBytes);

 		const deUint32  itemCount	= static_cast<deUint32>(expectedBytes.size()) / 4u;
 		const deUint32* returned	= static_cast<const deUint32*>(outputAllocs[outputNdx]->getHostPtr());
 		const deUint32* expected	= reinterpret_cast<const deUint32*>(&expectedBytes.front());

 		for (deUint32 i = 0; i < itemCount; ++i)
 		{
 			// skip items with 0 as this is used to mark empty structure
 			if (expected[i] == 0)
 				continue;
 			if (expected[i] != returned[i])
 				return false;
 		}
 	}
 	return true;
 }

 void addCopyingComputeGroup(tcu::TestCaseGroup* group)
 {
 	const tcu::StringTemplate shaderTemplate(
 		"OpCapability Shader\n"

 		"OpExtension \"SPV_KHR_storage_buffer_storage_class\"\n"

 		"OpMemoryModel Logical GLSL450\n"
 		"OpEntryPoint GLCompute %main \"main\" %var_id\n"
 		"OpExecutionMode %main LocalSize 1 1 1\n"

 		"OpDecorate %var_id BuiltIn GlobalInvocationId\n"
 		"OpDecorate %var_input Binding 0\n"
 		"OpDecorate %var_input DescriptorSet 0\n"

 		"OpDecorate %var_outdata Binding 1\n"
 		"OpDecorate %var_outdata DescriptorSet 0\n"

 		"OpMemberDecorate %type_container_struct 0 Offset 0\n"
 		"OpMemberDecorate %type_container_struct 1 Offset ${OFFSET_1}\n"
 		"OpMemberDecorate %type_container_struct 2 Offset ${OFFSET_2}\n"
 		"OpMemberDecorate %type_container_struct 3 Offset ${OFFSET_3}\n"
 		"OpDecorate %type_container_struct Block\n"

 		+ std::string(getComputeAsmCommonTypes()) +

 		//struct EmptyStruct {};
 		//struct ContainerStruct {
 		//  int i;
 		//  A a1;
 		//  A a2;
 		//  int j;
 		//};
 		//layout(set=, binding = ) buffer block B b;

 		// types
 		"%type_empty_struct					= OpTypeStruct\n"
 		"%type_container_struct				= OpTypeStruct %i32 %type_empty_struct %type_empty_struct %i32\n"

 		"%type_container_struct_ubo_ptr		= OpTypePointer Uniform %type_container_struct\n"
 		"%type_container_struct_ssbo_ptr	= OpTypePointer StorageBuffer %type_container_struct\n"

 		// variables
 		"%var_id							= OpVariable %uvec3ptr Input\n"
 		"${VARIABLES}\n"

 		// void main function
 		"%main								= OpFunction %void None %voidf\n"
 		"%label								= OpLabel\n"

 		"${COPYING_METHOD}"

 		"OpReturn\n"
 		"OpFunctionEnd\n");

 	struct BufferType
 	{
 		std::string				name;
 		VkDescriptorType		descriptorType;
 		std::vector<deUint32>	offsets;
 		std::vector<int>		input;
 		std::vector<int>		expectedOutput;
 		std::string				spirvVariables;
 		std::string				spirvCopyObject;
 	};
 	std::vector<BufferType> bufferTypes
 	{
 		{
 			"ubo",
 			VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

 			// structure decorated as Block for variable in Uniform storage class
 			// must follow relaxed uniform buffer layout rules and be aligned to 16
 			{0, 16, 32, 48},
 			{2, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0},
 			{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0},

 			"%var_input						= OpVariable %type_container_struct_ubo_ptr Uniform\n"
 			"%var_outdata					= OpVariable %type_container_struct_ssbo_ptr StorageBuffer\n",

 			"%input_copy					= OpCopyObject %type_container_struct_ubo_ptr %var_input\n"
 		},
 		{
 			"ssbo",
 			VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,

 			{0, 4, 8, 12},
 			{2, 3, 5, 7 },
 			{2, 0, 0, 7 },

 			"%var_input						= OpVariable %type_container_struct_ssbo_ptr StorageBuffer\n"
 			"%var_outdata					= OpVariable %type_container_struct_ssbo_ptr StorageBuffer\n",

 			"%input_copy					= OpCopyObject %type_container_struct_ssbo_ptr %var_input\n"
 		}
 	};

 	struct CopyingMethod
 	{
 		std::string name;
 		std::string spirvCopyCode;
 	};
 	std::vector<CopyingMethod> copyingMethods
 	{
 		{
 			"copy_object",

 			"%result						= OpLoad %type_container_struct %input_copy\n"
 			"OpStore %var_outdata %result\n"
 		},
 		{
 			"copy_memory",

 			"OpCopyMemory %var_outdata %var_input\n"
 		}
 	};

 	for (const auto& bufferType : bufferTypes)
 	{
 		for (const auto& copyingMethod : copyingMethods)
 		{
 			std::string name = copyingMethod.name + "_" + bufferType.name;

 			std::map<std::string, std::string> specializationMap
 			{
 				{ "OFFSET_1",		de::toString(bufferType.offsets[1]) },
 				{ "OFFSET_2",		de::toString(bufferType.offsets[2]) },
 				{ "OFFSET_3",		de::toString(bufferType.offsets[3]) },
 				{ "VARIABLES",		bufferType.spirvVariables },

 				// NOTE: to simlify code spirvCopyObject is added also when OpCopyMemory is used
 				{ "COPYING_METHOD", bufferType.spirvCopyObject + copyingMethod.spirvCopyCode },
 			};

 			ComputeShaderSpec spec;
 			spec.assembly		= shaderTemplate.specialize(specializationMap);
 			spec.numWorkGroups	= tcu::IVec3(1, 1, 1);
 			spec.verifyIO		= verifyResult;
 			spec.inputs.push_back (Resource(BufferSp(new Int32Buffer(bufferType.input)), bufferType.descriptorType));
 			spec.outputs.push_back(Resource(BufferSp(new Int32Buffer(bufferType.expectedOutput))));
 			group->addChild(new SpvAsmComputeShaderCase(group->getTestContext(), name.c_str(), "", spec));
 		}
 	}
 }

 void addPointerComparisionComputeGroup(tcu::TestCaseGroup* group)
 {
 	// NOTE: pointer comparison is possible only for StorageBuffer storage class

 	std::string computeSource =
 		"OpCapability Shader\n"
 		"OpCapability VariablePointersStorageBuffer\n"

 		"OpMemoryModel Logical GLSL450\n"
 		"OpEntryPoint GLCompute %main \"main\" %var_id %var_input %var_outdata\n"
 		"OpExecutionMode %main LocalSize 1 1 1\n"

 		"OpDecorate %var_id BuiltIn GlobalInvocationId\n"
 		"OpDecorate %var_input Binding 0\n"
 		"OpDecorate %var_input DescriptorSet 0\n"

 		"OpDecorate %var_outdata Binding 1\n"
 		"OpDecorate %var_outdata DescriptorSet 0\n"

 		"OpMemberDecorate %type_container_struct 0 Offset 0\n"
 		"OpMemberDecorate %type_container_struct 1 Offset 4\n"
 		"OpMemberDecorate %type_container_struct 2 Offset 8\n"
 		"OpMemberDecorate %type_container_struct 3 Offset 12\n"
 		"OpDecorate %type_container_struct Block\n"

 		"OpMemberDecorate %type_i32_struct 0 Offset 0\n"
 		"OpDecorate %type_i32_struct Block\n"

 		+ std::string(getComputeAsmCommonTypes("StorageBuffer")) +

 		//struct EmptyStruct {};
 		//struct ContainerStruct {
 		//  int i;
 		//  A a1;
 		//  A a2;
 		//  int j;
 		//};
 		//layout(set=, binding = ) buffer block B b;

 		// types
 		"%type_empty_struct					= OpTypeStruct\n"
 		"%type_container_struct				= OpTypeStruct %i32 %type_empty_struct %type_empty_struct %i32\n"
 		"%type_i32_struct					= OpTypeStruct %i32\n"

 		// constants
 		"%c_i32_0							= OpConstant %i32 0\n"
 		"%c_i32_1							= OpConstant %i32 1\n"
 		"%c_i32_2							= OpConstant %i32 2\n"

 		"%type_container_struct_in_ptr		= OpTypePointer StorageBuffer %type_container_struct\n"
 		"%type_i32_struct_out_ptr			= OpTypePointer StorageBuffer %type_i32_struct\n"

 		"%type_func_struct_ptr_ptr			= OpTypePointer StorageBuffer %type_empty_struct\n"

 		// variables
 		"%var_id							= OpVariable %uvec3ptr Input\n"
 		"%var_input							= OpVariable %type_container_struct_in_ptr StorageBuffer\n"
 		"%var_outdata						= OpVariable %type_i32_struct_out_ptr StorageBuffer\n"

 		// void main function
 		"%main								= OpFunction %void None %voidf\n"
 		"%label								= OpLabel\n"

 		// compare pointers to empty structures
 		"%ptr_to_first						= OpAccessChain %type_func_struct_ptr_ptr %var_input %c_i32_1\n"
 		"%ptr_to_second						= OpAccessChain %type_func_struct_ptr_ptr %var_input %c_i32_2\n"
 		"%pointers_not_equal				= OpPtrNotEqual %bool %ptr_to_first %ptr_to_second\n"
 		"%result							= OpSelect %i32 %pointers_not_equal %c_i32_1 %c_i32_0\n"
 		"%outloc							= OpAccessChain %i32ptr %var_outdata %c_i32_0\n"
 		"OpStore %outloc %result\n"

 		"OpReturn\n"
 		"OpFunctionEnd\n";

 	tcu::TestContext&	testCtx			= group->getTestContext();
 	std::vector<int>	input			= { 2, 3, 5, 7 };
 	std::vector<int>	expectedOutput	= { 1 };

 	ComputeShaderSpec spec;
 	spec.assembly		= computeSource;
 	spec.numWorkGroups	= tcu::IVec3(1, 1, 1);
 	spec.spirvVersion	= SPIRV_VERSION_1_4;
 	spec.requestedVulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
 	spec.inputs.push_back (Resource(BufferSp(new Int32Buffer(input))));
 	spec.outputs.push_back(Resource(BufferSp(new Int32Buffer(expectedOutput))));
 	spec.extensions.push_back("VK_KHR_spirv_1_4");
 	group->addChild(new SpvAsmComputeShaderCase(testCtx, "ssbo", "", spec));
 }

 } // anonymous

 tcu::TestCaseGroup* createEmptyStructComputeGroup (tcu::TestContext& testCtx)
 {
 	de::MovePtr<tcu::TestCaseGroup> group	(new tcu::TestCaseGroup(testCtx, "empty_struct", "Tests empty structs in UBOs and SSBOs"));

 	addTestGroup(group.get(), "copying",			"Test copying struct which contains an empty struct",	addCopyingComputeGroup);
 	addTestGroup(group.get(), "pointer_comparison",	"Test pointer comparisons of empty struct members",		addPointerComparisionComputeGroup);

 	return group.release();
 }

 } // SpirVAssembly
 } // vkt
	/*------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2020 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 Test copying struct which contains an empty struct.
	Test pointer comparisons of empty struct members.
	//--------------------------------------------------------------------*/

	#include "vktSpvAsmComputeShaderTestUtil.hpp"
	#include "vktSpvAsmComputeShaderCase.hpp"
	#include "vktSpvAsmEmptyStructTests.hpp"
	#include "tcuStringTemplate.hpp"
	#include "vktTestGroupUtil.hpp"
	#include "vktSpvAsmUtils.hpp"

	namespace vkt
	{
	namespace SpirVAssembly
	{
	namespace
	{

	bool verifyResult(const std::vector<Resource>&,
	const std::vector<AllocationSp>& outputAllocs,
	const std::vector<Resource>& expectedOutputs,
	tcu::TestLog&)
	{
	for (deUint32 outputNdx = 0; outputNdx < static_cast<deUint32>(outputAllocs.size()); ++outputNdx)
	{
	std::vector<deUint8> expectedBytes;
	expectedOutputs[outputNdx].getBytes(expectedBytes);

	const deUint32 itemCount = static_cast<deUint32>(expectedBytes.size()) / 4u;
	const deUint32* returned = static_cast<const deUint32*>(outputAllocs[outputNdx]->getHostPtr());
	const deUint32* expected = reinterpret_cast<const deUint32*>(&expectedBytes.front());

	for (deUint32 i = 0; i < itemCount; ++i)
	{
	// skip items with 0 as this is used to mark empty structure
	if (expected[i] == 0)
	continue;
	if (expected[i] != returned[i])
	return false;
	}
	}
	return true;
	}

	void addCopyingComputeGroup(tcu::TestCaseGroup* group)
	{
	const tcu::StringTemplate shaderTemplate(
	"OpCapability Shader\n"

	"OpExtension \"SPV_KHR_storage_buffer_storage_class\"\n"

	"OpMemoryModel Logical GLSL450\n"
	"OpEntryPoint GLCompute %main \"main\" %var_id\n"
	"OpExecutionMode %main LocalSize 1 1 1\n"

	"OpDecorate %var_id BuiltIn GlobalInvocationId\n"
	"OpDecorate %var_input Binding 0\n"
	"OpDecorate %var_input DescriptorSet 0\n"

	"OpDecorate %var_outdata Binding 1\n"
	"OpDecorate %var_outdata DescriptorSet 0\n"

	"OpMemberDecorate %type_container_struct 0 Offset 0\n"
	"OpMemberDecorate %type_container_struct 1 Offset ${OFFSET_1}\n"
	"OpMemberDecorate %type_container_struct 2 Offset ${OFFSET_2}\n"
	"OpMemberDecorate %type_container_struct 3 Offset ${OFFSET_3}\n"
	"OpDecorate %type_container_struct Block\n"

	+ std::string(getComputeAsmCommonTypes()) +

	//struct EmptyStruct {};
	//struct ContainerStruct {
	// int i;
	// A a1;
	// A a2;
	// int j;
	//};
	//layout(set=, binding = ) buffer block B b;

	// types
	"%type_empty_struct = OpTypeStruct\n"
	"%type_container_struct = OpTypeStruct %i32 %type_empty_struct %type_empty_struct %i32\n"

	"%type_container_struct_ubo_ptr = OpTypePointer Uniform %type_container_struct\n"
	"%type_container_struct_ssbo_ptr = OpTypePointer StorageBuffer %type_container_struct\n"

	// variables
	"%var_id = OpVariable %uvec3ptr Input\n"
	"${VARIABLES}\n"

	// void main function
	"%main = OpFunction %void None %voidf\n"
	"%label = OpLabel\n"

	"${COPYING_METHOD}"

	"OpReturn\n"
	"OpFunctionEnd\n");

	struct BufferType
	{
	std::string name;
	VkDescriptorType descriptorType;
	std::vector<deUint32> offsets;
	std::vector<int> input;
	std::vector<int> expectedOutput;
	std::string spirvVariables;
	std::string spirvCopyObject;
	};
	std::vector<BufferType> bufferTypes
	{
	{
	"ubo",
	VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,

	// structure decorated as Block for variable in Uniform storage class
	// must follow relaxed uniform buffer layout rules and be aligned to 16
	{0, 16, 32, 48},
	{2, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0},
	{2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0},

	"%var_input = OpVariable %type_container_struct_ubo_ptr Uniform\n"
	"%var_outdata = OpVariable %type_container_struct_ssbo_ptr StorageBuffer\n",

	"%input_copy = OpCopyObject %type_container_struct_ubo_ptr %var_input\n"
	},
	{
	"ssbo",
	VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,

	{0, 4, 8, 12},
	{2, 3, 5, 7 },
	{2, 0, 0, 7 },

	"%var_input = OpVariable %type_container_struct_ssbo_ptr StorageBuffer\n"
	"%var_outdata = OpVariable %type_container_struct_ssbo_ptr StorageBuffer\n",

	"%input_copy = OpCopyObject %type_container_struct_ssbo_ptr %var_input\n"
	}
	};

	struct CopyingMethod
	{
	std::string name;
	std::string spirvCopyCode;
	};
	std::vector<CopyingMethod> copyingMethods
	{
	{
	"copy_object",

	"%result = OpLoad %type_container_struct %input_copy\n"
	"OpStore %var_outdata %result\n"
	},
	{
	"copy_memory",

	"OpCopyMemory %var_outdata %var_input\n"
	}
	};

	for (const auto& bufferType : bufferTypes)
	{
	for (const auto& copyingMethod : copyingMethods)
	{
	std::string name = copyingMethod.name + "_" + bufferType.name;

	std::map<std::string, std::string> specializationMap
	{
	{ "OFFSET_1", de::toString(bufferType.offsets[1]) },
	{ "OFFSET_2", de::toString(bufferType.offsets[2]) },
	{ "OFFSET_3", de::toString(bufferType.offsets[3]) },
	{ "VARIABLES", bufferType.spirvVariables },

	// NOTE: to simlify code spirvCopyObject is added also when OpCopyMemory is used
	{ "COPYING_METHOD", bufferType.spirvCopyObject + copyingMethod.spirvCopyCode },
	};

	ComputeShaderSpec spec;
	spec.assembly = shaderTemplate.specialize(specializationMap);
	spec.numWorkGroups = tcu::IVec3(1, 1, 1);
	spec.verifyIO = verifyResult;
	spec.inputs.push_back (Resource(BufferSp(new Int32Buffer(bufferType.input)), bufferType.descriptorType));
	spec.outputs.push_back(Resource(BufferSp(new Int32Buffer(bufferType.expectedOutput))));
	group->addChild(new SpvAsmComputeShaderCase(group->getTestContext(), name.c_str(), "", spec));
	}
	}
	}

	void addPointerComparisionComputeGroup(tcu::TestCaseGroup* group)
	{
	// NOTE: pointer comparison is possible only for StorageBuffer storage class

	std::string computeSource =
	"OpCapability Shader\n"
	"OpCapability VariablePointersStorageBuffer\n"

	"OpMemoryModel Logical GLSL450\n"
	"OpEntryPoint GLCompute %main \"main\" %var_id %var_input %var_outdata\n"
	"OpExecutionMode %main LocalSize 1 1 1\n"

	"OpDecorate %var_id BuiltIn GlobalInvocationId\n"
	"OpDecorate %var_input Binding 0\n"
	"OpDecorate %var_input DescriptorSet 0\n"

	"OpDecorate %var_outdata Binding 1\n"
	"OpDecorate %var_outdata DescriptorSet 0\n"

	"OpMemberDecorate %type_container_struct 0 Offset 0\n"
	"OpMemberDecorate %type_container_struct 1 Offset 4\n"
	"OpMemberDecorate %type_container_struct 2 Offset 8\n"
	"OpMemberDecorate %type_container_struct 3 Offset 12\n"
	"OpDecorate %type_container_struct Block\n"

	"OpMemberDecorate %type_i32_struct 0 Offset 0\n"
	"OpDecorate %type_i32_struct Block\n"

	+ std::string(getComputeAsmCommonTypes("StorageBuffer")) +

	//struct EmptyStruct {};
	//struct ContainerStruct {
	// int i;
	// A a1;
	// A a2;
	// int j;
	//};
	//layout(set=, binding = ) buffer block B b;

	// types
	"%type_empty_struct = OpTypeStruct\n"
	"%type_container_struct = OpTypeStruct %i32 %type_empty_struct %type_empty_struct %i32\n"
	"%type_i32_struct = OpTypeStruct %i32\n"

	// constants
	"%c_i32_0 = OpConstant %i32 0\n"
	"%c_i32_1 = OpConstant %i32 1\n"
	"%c_i32_2 = OpConstant %i32 2\n"

	"%type_container_struct_in_ptr = OpTypePointer StorageBuffer %type_container_struct\n"
	"%type_i32_struct_out_ptr = OpTypePointer StorageBuffer %type_i32_struct\n"

	"%type_func_struct_ptr_ptr = OpTypePointer StorageBuffer %type_empty_struct\n"

	// variables
	"%var_id = OpVariable %uvec3ptr Input\n"
	"%var_input = OpVariable %type_container_struct_in_ptr StorageBuffer\n"
	"%var_outdata = OpVariable %type_i32_struct_out_ptr StorageBuffer\n"

	// void main function
	"%main = OpFunction %void None %voidf\n"
	"%label = OpLabel\n"

	// compare pointers to empty structures
	"%ptr_to_first = OpAccessChain %type_func_struct_ptr_ptr %var_input %c_i32_1\n"
	"%ptr_to_second = OpAccessChain %type_func_struct_ptr_ptr %var_input %c_i32_2\n"
	"%pointers_not_equal = OpPtrNotEqual %bool %ptr_to_first %ptr_to_second\n"
	"%result = OpSelect %i32 %pointers_not_equal %c_i32_1 %c_i32_0\n"
	"%outloc = OpAccessChain %i32ptr %var_outdata %c_i32_0\n"
	"OpStore %outloc %result\n"

	"OpReturn\n"
	"OpFunctionEnd\n";

	tcu::TestContext& testCtx = group->getTestContext();
	std::vector<int> input = { 2, 3, 5, 7 };
	std::vector<int> expectedOutput = { 1 };

	ComputeShaderSpec spec;
	spec.assembly = computeSource;
	spec.numWorkGroups = tcu::IVec3(1, 1, 1);
	spec.spirvVersion = SPIRV_VERSION_1_4;
	spec.requestedVulkanFeatures.extVariablePointers = EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER;
	spec.inputs.push_back (Resource(BufferSp(new Int32Buffer(input))));
	spec.outputs.push_back(Resource(BufferSp(new Int32Buffer(expectedOutput))));
	spec.extensions.push_back("VK_KHR_spirv_1_4");
	group->addChild(new SpvAsmComputeShaderCase(testCtx, "ssbo", "", spec));
	}

	} // anonymous

	tcu::TestCaseGroup* createEmptyStructComputeGroup (tcu::TestContext& testCtx)
	{
	de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "empty_struct", "Tests empty structs in UBOs and SSBOs"));

	addTestGroup(group.get(), "copying", "Test copying struct which contains an empty struct", addCopyingComputeGroup);
	addTestGroup(group.get(), "pointer_comparison", "Test pointer comparisons of empty struct members", addPointerComparisionComputeGroup);

	return group.release();
	}

	} // SpirVAssembly
	} // vkt