/*-------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2017 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 SPIR-V Assembly Tests for Integer Types
 *//*--------------------------------------------------------------------*/

#include "vktSpvAsmTypeTests.hpp"

#include "tcuRGBA.hpp"
#include "tcuStringTemplate.hpp"

#include "vkDefs.hpp"
#include "vkMemUtil.hpp"
#include "vkPrograms.hpp"
#include "vkQueryUtil.hpp"
#include "vkRefUtil.hpp"
#include "vktTestCase.hpp"

#include "deStringUtil.hpp"

#include "vktSpvAsmGraphicsShaderTestUtil.hpp"
#include "vktSpvAsmComputeShaderCase.hpp"
#include "vktSpvAsmComputeShaderTestUtil.hpp"
#include "vktTestGroupUtil.hpp"
#include "spirv/unified1/spirv.h"
#include "spirv/unified1/GLSL.std.450.h"

#include <cmath>

#define TEST_DATASET_SIZE 10

#define UNDEFINED_SPIRV_TEST_TYPE "testtype"

namespace de
{
	// Specialize template to have output as integers instead of chars
	template<>
	inline std::string toString<deInt8> (const deInt8& value)
	{
		std::ostringstream s;
		s << static_cast<deInt32>(value);
		return s.str();
	}

	template<>
	inline std::string toString<deUint8> (const deUint8& value)
	{
		std::ostringstream s;
		s << static_cast<deUint32>(value);
		return s.str();
	}
}

namespace vkt
{
namespace SpirVAssembly
{

using namespace vk;
using tcu::RGBA;
using std::map;
using std::string;
using std::vector;
using tcu::StringTemplate;

void createComputeTest(ComputeShaderSpec& computeResources, const tcu::StringTemplate& shaderTemplate, const map<string, string>& fragments, tcu::TestCaseGroup& group, const std::string& namePrefix)
{
	const string testName = namePrefix + "_comp";

	computeResources.assembly		= shaderTemplate.specialize(fragments);
	computeResources.numWorkGroups	= tcu::IVec3(1, 1, 1);

	group.addChild(new SpvAsmComputeShaderCase(group.getTestContext(), testName.c_str(), testName.c_str(), computeResources));
}

// The compute shader switch tests output a single 32-bit integer.
bool verifyComputeSwitchResult (const vector<Resource>&		,
								const vector<AllocationSp>&	outputAllocations,
								const vector<Resource>&		expectedOutputs,
								tcu::TestLog&				log)
{
	DE_ASSERT(outputAllocations.size()	== 1);
	DE_ASSERT(expectedOutputs.size()	== 1);

	vector<deUint8> expectedBytes;
	expectedOutputs[0].getBytes(expectedBytes);
	DE_ASSERT(expectedBytes.size() == sizeof(deInt32));

	const deInt32* obtained = reinterpret_cast<const deInt32*>(outputAllocations[0]->getHostPtr());
	const deInt32* expected = reinterpret_cast<const deInt32*>(expectedBytes.data());

	if (*obtained != *expected)
	{
		log << tcu::TestLog::Message
			<< "Error: found unexpected result for compute switch: expected " << *expected << ", obtained " << *obtained
			<< tcu::TestLog::EndMessage;
		return false;
	}

	return true;
}

enum InputRange
{
	RANGE_FULL = 0,
	RANGE_BIT_WIDTH,
	RANGE_BIT_WIDTH_SUM,

	RANGE_LAST
};

enum InputWidth
{
	WIDTH_DEFAULT = 0,
	WIDTH_8,
	WIDTH_16,
	WIDTH_32,
	WIDTH_64,
	WIDTH_8_8,
	WIDTH_8_16,
	WIDTH_8_32,
	WIDTH_8_64,
	WIDTH_16_8,
	WIDTH_16_16,
	WIDTH_16_32,
	WIDTH_16_64,
	WIDTH_32_8,
	WIDTH_32_16,
	WIDTH_32_32,
	WIDTH_32_64,
	WIDTH_64_8,
	WIDTH_64_16,
	WIDTH_64_32,
	WIDTH_64_64,

	WIDTH_LAST
};

enum InputType
{
	TYPE_I8 = 0,
	TYPE_U8,
	TYPE_I16,
	TYPE_U16,
	TYPE_I32,
	TYPE_U32,
	TYPE_I64,
	TYPE_U64,

	TYPE_LAST
};

deUint32 getConstituentIndex (deUint32 ndx, deUint32 vectorSize)
{
	DE_ASSERT(vectorSize != 0u);
	return (ndx / vectorSize) / (1u + (ndx % vectorSize));
}

bool isScalarInput (deUint32 spirvOperation, deUint32 numInput)
{
	switch (spirvOperation)
	{
		case SpvOpBitFieldInsert:
			return (numInput > 1);
		case SpvOpBitFieldSExtract:
			return (numInput > 0);
		case SpvOpBitFieldUExtract:
			return (numInput > 0);
		default:
			return false;
	}
}

bool isBooleanResultTest (deUint32 spirvOperation)
{
	switch (spirvOperation)
	{
		case SpvOpIEqual:
			return true;
		case SpvOpINotEqual:
			return true;
		case SpvOpUGreaterThan:
			return true;
		case SpvOpSGreaterThan:
			return true;
		case SpvOpUGreaterThanEqual:
			return true;
		case SpvOpSGreaterThanEqual:
			return true;
		case SpvOpULessThan:
			return true;
		case SpvOpSLessThan:
			return true;
		case SpvOpULessThanEqual:
			return true;
		case SpvOpSLessThanEqual:
			return true;
		default:
			return false;
	}
}

bool isConstantOrVariableTest (deUint32 spirvOperation)
{
	switch (spirvOperation)
	{
		case SpvOpConstantNull:
			return true;
		case SpvOpConstant:
			return true;
		case SpvOpConstantComposite:
			return true;
		case SpvOpVariable:
			return true;
		case SpvOpSpecConstant:
			return true;
		case SpvOpSpecConstantComposite:
			return true;
		default:
			return false;
	}
}

const char* getSpvOperationStr (deUint32 spirvOperation)
{
	switch (spirvOperation)
	{
		case SpvOpSNegate:
			return "OpSNegate";
		case SpvOpIAdd:
			return "OpIAdd";
		case SpvOpISub:
			return "OpISub";
		case SpvOpIMul:
			return "OpIMul";
		case SpvOpSDiv:
			return "OpSDiv";
		case SpvOpUDiv:
			return "OpUDiv";
		case SpvOpSRem:
			return "OpSRem";
		case SpvOpSMod:
			return "OpSMod";
		case SpvOpUMod:
			return "OpUMod";
		case SpvOpShiftRightLogical:
			return "OpShiftRightLogical";
		case SpvOpShiftRightArithmetic:
			return "OpShiftRightArithmetic";
		case SpvOpShiftLeftLogical:
			return "OpShiftLeftLogical";
		case SpvOpBitwiseOr:
			return "OpBitwiseOr";
		case SpvOpBitwiseXor:
			return "OpBitwiseXor";
		case SpvOpBitwiseAnd:
			return "OpBitwiseAnd";
		case SpvOpNot:
			return "OpNot";
		case SpvOpIEqual:
			return "OpIEqual";
		case SpvOpINotEqual:
			return "OpINotEqual";
		case SpvOpUGreaterThan:
			return "OpUGreaterThan";
		case SpvOpSGreaterThan:
			return "OpSGreaterThan";
		case SpvOpUGreaterThanEqual:
			return "OpUGreaterThanEqual";
		case SpvOpSGreaterThanEqual:
			return "OpSGreaterThanEqual";
		case SpvOpULessThan:
			return "OpULessThan";
		case SpvOpSLessThan:
			return "OpSLessThan";
		case SpvOpULessThanEqual:
			return "OpULessThanEqual";
		case SpvOpSLessThanEqual:
			return "OpSLessThanEqual";
		case SpvOpBitFieldInsert:
			return "OpBitFieldInsert";
		case SpvOpBitFieldSExtract:
			return "OpBitFieldSExtract";
		case SpvOpBitFieldUExtract:
			return "OpBitFieldUExtract";
		case SpvOpBitReverse:
			return "OpBitReverse";
		case SpvOpBitCount:
			return "OpBitCount";
		case SpvOpConstant:
			return "OpConstant";
		case SpvOpConstantComposite:
			return "OpConstantComposite";
		case SpvOpConstantNull:
			return "OpConstantNull";
		case SpvOpVariable:
			return "OpVariable";
		case SpvOpSpecConstant:
			return "OpSpecConstant";
		case SpvOpSpecConstantComposite:
			return "OpSpecConstantComposite";
		default:
			return "";
	}
}

const char* getGLSLstd450OperationStr (deUint32 spirvOperation)
{
	switch (spirvOperation)
	{
		case GLSLstd450SAbs:
			return "SAbs";
		case GLSLstd450SSign:
			return "SSign";
		case GLSLstd450SMin:
			return "SMin";
		case GLSLstd450UMin:
			return "UMin";
		case GLSLstd450SMax:
			return "SMax";
		case GLSLstd450UMax:
			return "UMax";
		case GLSLstd450SClamp:
			return "SClamp";
		case GLSLstd450UClamp:
			return "UClamp";
		case GLSLstd450FindILsb:
			return "FindILsb";
		case GLSLstd450FindSMsb:
			return "FindSMsb";
		case GLSLstd450FindUMsb:
			return "FindUMsb";
		default:
			DE_FATAL("Not implemented");
			return "";
	}
}

string getBooleanResultType (deUint32 vectorSize)
{
	if (vectorSize > 1)
		return "v" + de::toString(vectorSize) + "bool";
	else
		return "bool";
}

deUint32 getInputWidth (InputWidth inputWidth, deUint32 ndx)
{
	switch (inputWidth)
	{
		case WIDTH_8:
			DE_ASSERT(ndx < 1);
			return 8;
		case WIDTH_16:
			DE_ASSERT(ndx < 1);
			return 16;
		case WIDTH_32:
			DE_ASSERT(ndx < 1);
			return 32;
		case WIDTH_64:
			DE_ASSERT(ndx < 1);
			return 64;
		case WIDTH_8_8:
			DE_ASSERT(ndx < 2);
			return 8;
		case WIDTH_8_16:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 8 : 16;
		case WIDTH_8_32:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 8 : 32;
		case WIDTH_8_64:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 8 : 64;
		case WIDTH_16_8:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 16 : 8;
		case WIDTH_16_16:
			DE_ASSERT(ndx < 2);
			return 16;
		case WIDTH_16_32:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 16 : 32;
		case WIDTH_16_64:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 16 : 64;
		case WIDTH_32_8:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 32 : 8;
		case WIDTH_32_16:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 32 : 16;
		case WIDTH_32_32:
			DE_ASSERT(ndx < 2);
			return 32;
		case WIDTH_32_64:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 32 : 64;
		case WIDTH_64_8:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 64 : 8;
		case WIDTH_64_16:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 64 : 16;
		case WIDTH_64_32:
			DE_ASSERT(ndx < 2);
			return (ndx == 0) ? 64 : 32;
		case WIDTH_64_64:
			DE_ASSERT(ndx < 2);
			return 64;
		default:
			DE_FATAL("Not implemented");
			return 0;
	}
}

bool has8BitInputWidth (InputWidth inputWidth)
{
	switch (inputWidth)
	{
		case WIDTH_8:		return true;
		case WIDTH_16:		return false;
		case WIDTH_32:		return false;
		case WIDTH_64:		return false;
		case WIDTH_8_8:		return true;
		case WIDTH_8_16:	return true;
		case WIDTH_8_32:	return true;
		case WIDTH_8_64:	return true;
		case WIDTH_16_8:	return true;
		case WIDTH_16_16:	return false;
		case WIDTH_16_32:	return false;
		case WIDTH_16_64:	return false;
		case WIDTH_32_8:	return true;
		case WIDTH_32_16:	return false;
		case WIDTH_32_32:	return false;
		case WIDTH_32_64:	return false;
		case WIDTH_64_8:	return true;
		case WIDTH_64_16:	return false;
		case WIDTH_64_32:	return false;
		case WIDTH_64_64:	return false;
		default:			return false;
	}
}

bool has16BitInputWidth (InputWidth inputWidth)
{
	switch (inputWidth)
	{
		case WIDTH_8:		return false;
		case WIDTH_16:		return true;
		case WIDTH_32:		return false;
		case WIDTH_64:		return false;
		case WIDTH_8_8:		return false;
		case WIDTH_8_16:	return true;
		case WIDTH_8_32:	return false;
		case WIDTH_8_64:	return false;
		case WIDTH_16_8:	return true;
		case WIDTH_16_16:	return true;
		case WIDTH_16_32:	return true;
		case WIDTH_16_64:	return true;
		case WIDTH_32_8:	return false;
		case WIDTH_32_16:	return true;
		case WIDTH_32_32:	return false;
		case WIDTH_32_64:	return false;
		case WIDTH_64_8:	return false;
		case WIDTH_64_16:	return true;
		case WIDTH_64_32:	return false;
		case WIDTH_64_64:	return false;
		default:			return false;
	}
}

bool has64BitInputWidth (InputWidth inputWidth)
{
	switch (inputWidth)
	{
		case WIDTH_8:		return false;
		case WIDTH_16:		return false;
		case WIDTH_32:		return false;
		case WIDTH_64:		return true;
		case WIDTH_8_8:		return false;
		case WIDTH_8_16:	return false;
		case WIDTH_8_32:	return false;
		case WIDTH_8_64:	return true;
		case WIDTH_16_8:	return false;
		case WIDTH_16_16:	return false;
		case WIDTH_16_32:	return false;
		case WIDTH_16_64:	return true;
		case WIDTH_32_8:	return false;
		case WIDTH_32_16:	return false;
		case WIDTH_32_32:	return false;
		case WIDTH_32_64:	return true;
		case WIDTH_64_8:	return true;
		case WIDTH_64_16:	return true;
		case WIDTH_64_32:	return true;
		case WIDTH_64_64:	return true;
		default:			return false;
	}
}

InputType getInputType (deUint32 inputWidth, bool isSigned)
{
	switch (inputWidth)
	{
		case 8:
			return (isSigned) ? TYPE_I8  : TYPE_U8;
		case 16:
			return (isSigned) ? TYPE_I16 : TYPE_U16;
		case 32:
			return (isSigned) ? TYPE_I32 : TYPE_U32;
		case 64:
			return (isSigned) ? TYPE_I64 : TYPE_U64;
		default:
			DE_FATAL("Not possible");
			return TYPE_LAST;
	}
}

string getOtherSizeTypes (InputType inputType, deUint32 vectorSize, InputWidth inputWidth)
{
	const deUint32 inputWidthValues[] =
	{
		8, 16, 32, 64
	};

	for (deUint32 widthNdx = 0; widthNdx < DE_LENGTH_OF_ARRAY(inputWidthValues); widthNdx++)
	{
		const deUint32	typeWidth		= inputWidthValues[widthNdx];
		const InputType	typeUnsigned	= getInputType(typeWidth, false);
		const InputType	typeSigned		= getInputType(typeWidth, true);

		if ((inputType == typeUnsigned) || (inputType == typeSigned))
		{
			const bool		isSigned	= (inputType == typeSigned);
			const string	signPrefix	= (isSigned) ? "i" : "u";
			const string	signBit		= (isSigned) ? "1" : "0";

			string			str			= "";

			if (has8BitInputWidth(inputWidth) && typeWidth != 8)
			{
				// 8-bit scalar type
				str += "%" + signPrefix + "8 = OpTypeInt 8 " + signBit + "\n";

				// 8-bit vector type
				if (vectorSize > 1)
					str += "%v" + de::toString(vectorSize) + signPrefix + "8 = OpTypeVector %" + signPrefix + "8 " + de::toString(vectorSize) + "\n";
			}

			if (has16BitInputWidth(inputWidth) && typeWidth != 16)
			{
				// 16-bit scalar type
				str += "%" + signPrefix + "16 = OpTypeInt 16 " + signBit + "\n";

				// 16-bit vector type
				if (vectorSize > 1)
					str += "%v" + de::toString(vectorSize) + signPrefix + "16 = OpTypeVector %" + signPrefix + "16 " + de::toString(vectorSize) + "\n";
			}

			if (has64BitInputWidth(inputWidth) && typeWidth != 64)
			{
				// 64-bit scalar type
				str += "%" + signPrefix + "64 = OpTypeInt 64 " + signBit + "\n";

				// 64-bit vector type
				if (vectorSize > 1)
					str += "%v" + de::toString(vectorSize) + signPrefix + "64 = OpTypeVector %" + signPrefix + "64 " + de::toString(vectorSize) + "\n";
			}

			return str;
		}
	}

	DE_FATAL("Not possible");
	return "";
}

string getSpirvCapabilityStr (const char* spirvCapability, InputWidth inputWidth)
{
	string str = "";

	if (spirvCapability)
	{
		if (has8BitInputWidth(inputWidth) || deStringEqual("Int8", spirvCapability))
			str += "OpCapability Int8\n";

		if (has16BitInputWidth(inputWidth) || deStringEqual("Int16", spirvCapability))
			str += "OpCapability Int16\n";

		if (has64BitInputWidth(inputWidth) || deStringEqual("Int64", spirvCapability))
			str += "OpCapability Int64\n";

		if (deStringEqual("Int8", spirvCapability))
			str += "OpCapability UniformAndStorageBuffer8BitAccess\n";

		if (deStringEqual("Int16", spirvCapability))
			str += "OpCapability UniformAndStorageBuffer16BitAccess\n";
	}
	else
	{
		if (has8BitInputWidth(inputWidth))
			str += "OpCapability Int8\n";

		if (has16BitInputWidth(inputWidth))
			str += "OpCapability Int16\n";

		if (has64BitInputWidth(inputWidth))
			str += "OpCapability Int64\n";
	}


	return str;
}

string getBinaryFullOperationWithInputWidthStr (string resultName, string spirvOperation, InputType inputType, string spirvTestType, deUint32 vectorSize, InputWidth inputWidth)
{
	const deUint32 inputWidthValues[] =
	{
		8, 16, 32, 64
	};

	for (deUint32 widthNdx = 0; widthNdx < DE_LENGTH_OF_ARRAY(inputWidthValues); widthNdx++)
	{
		const deUint32	typeWidth		= inputWidthValues[widthNdx];
		const InputType	typeUnsigned	= getInputType(typeWidth, false);
		const InputType	typeSigned		= getInputType(typeWidth, true);

		if ((inputType == typeUnsigned) || (inputType == typeSigned))
		{
			const bool		isSigned		= (inputType == typeSigned);
			const string	signPrefix		= (isSigned) ? "i" : "u";
			const string	typePrefix		= (vectorSize == 1) ? "%" : "%v" + de::toString(vectorSize);
			const deUint32	input1Width		= getInputWidth(inputWidth, 0);

			const string	inputTypeStr	= (input1Width == typeWidth) ? "%testtype"
											: typePrefix + signPrefix + de::toString(input1Width);

			string str = "";

			// Create intermediate value with different width
			if (input1Width != typeWidth)
				str += "%input1_val_" + de::toString(input1Width) + " = OpSConvert " + inputTypeStr + " %input1_val\n";

			// Input with potentially different width
			const string input1Str = "%input1_val" + ((input1Width != typeWidth) ? "_" + de::toString(input1Width) : "");

			str += resultName + " = " + spirvOperation + " %" + spirvTestType + " %input0_val " + input1Str + "\n";

			return str;
		}
	}

	DE_FATAL("Not possible");
	return "";
}

string getFullOperationWithDifferentInputWidthStr (string resultName, string spirvOperation, InputType inputType, string spirvTestType, InputWidth inputWidth, bool isQuaternary)
{
	const bool		isSigned	= (inputType == TYPE_I32);

	const deUint32	offsetWidth	= getInputWidth(inputWidth, 0);
	const deUint32	countWidth	= getInputWidth(inputWidth, 1);

	const string	offsetType	= ((isSigned) ? "i" : "u") + de::toString(offsetWidth);
	const string	countType	= ((isSigned) ? "i" : "u") + de::toString(countWidth);

	const string	offsetNdx	= (isQuaternary) ? "2" : "1";
	const string	countNdx	= (isQuaternary) ? "3" : "2";

	string str = "";

	// Create intermediate values with different width
	if (offsetWidth != 32)
		str += "%input" + offsetNdx + "_val_" + de::toString(offsetWidth) + " = OpSConvert %" + offsetType + " %input" + offsetNdx + "_val\n";
	if (countWidth != 32)
		str += "%input" + countNdx + "_val_" + de::toString(countWidth) + " = OpSConvert %" + countType + " %input" + countNdx + "_val\n";

	// Inputs with potentially different width
	const string offsetStr	= "%input" + offsetNdx + "_val" + ((offsetWidth != 32) ? "_" + de::toString(offsetWidth) : "");
	const string countStr	= "%input" + countNdx + "_val" + ((countWidth != 32) ? "_" + de::toString(countWidth) : "");

	if (isQuaternary)
		str += resultName + " = " + spirvOperation + " %" + spirvTestType + " %input0_val %input1_val " + offsetStr + " " + countStr +"\n";
	else
		str += resultName + " = " + spirvOperation + " %" + spirvTestType + " %input0_val " + offsetStr + " " + countStr +"\n";

	return str;
}

static inline void requiredFeaturesFromStrings(const std::vector<std::string> &features, VulkanFeatures &requestedFeatures)
{
	for (deUint32 featureNdx = 0; featureNdx < features.size(); ++featureNdx)
	{
		const std::string& feature = features[featureNdx];

		if (feature == "shaderInt16")
			requestedFeatures.coreFeatures.shaderInt16 = VK_TRUE;
		else if (feature == "shaderInt64")
			requestedFeatures.coreFeatures.shaderInt64 = VK_TRUE;
		else
			DE_ASSERT(0);  // Not implemented. Don't add to here. Just use VulkanFeatures
	}
}

template <class T>
class SpvAsmTypeTests : public tcu::TestCaseGroup
{
public:
	typedef T		(*OpUnaryFuncType)			(T);
	typedef T		(*OpBinaryFuncType)			(T, T);
	typedef T		(*OpTernaryFuncType)		(T, T, T);
	typedef T		(*OpQuaternaryFuncType)		(T, T, T, T);
	typedef bool	(*UnaryFilterFuncType)		(T);
	typedef bool	(*BinaryFilterFuncType)		(T, T);
	typedef bool	(*TernaryFilterFuncType)	(T, T, T);
	typedef bool	(*QuaternaryFilterFuncType)	(T, T, T, T);
					SpvAsmTypeTests				(tcu::TestContext&			testCtx,
												 const char*				name,
												 const char*				description,
												 const char*				deviceFeature,
												 const char*				spirvCapability,
												 const char*				spirvType,
												 InputType					inputType,
												 deUint32					typeSize,
												 deUint32					vectorSize);
					~SpvAsmTypeTests			(void);
	void			createTests					(const char*				testName,
												 deUint32					spirvOperation,
												 OpUnaryFuncType			op,
												 UnaryFilterFuncType		filter,
												 InputRange					inputRange,
												 InputWidth					inputWidth,
												 const char*				spirvExtension,
												 const bool					returnHighPart	= false);
	void			createTests					(const char*				testName,
												 deUint32					spirvOperation,
												 OpBinaryFuncType			op,
												 BinaryFilterFuncType		filter,
												 InputRange					inputRange,
												 InputWidth					inputWidth,
												 const char*				spirvExtension,
												 const bool					returnHighPart	= false);
	void			createTests					(const char*				testName,
												 deUint32					spirvOperation,
												 OpTernaryFuncType			op,
												 TernaryFilterFuncType		filter,
												 InputRange					inputRange,
												 InputWidth					inputWidth,
												 const char*				spirvExtension,
												 const bool					returnHighPart	= false);
	void			createTests					(const char*				testName,
												 deUint32					spirvOperation,
												 OpQuaternaryFuncType		op,
												 QuaternaryFilterFuncType	filter,
												 InputRange					inputRange,
												 InputWidth					inputWidth,
												 const char*				spirvExtension,
												 const bool					returnHighPart	= false);
	void			createSwitchTests			(void);
	void			getConstantDataset			(vector<T>					inputDataset,
												 vector<T>&					outputDataset,
												 deUint32					spirvOperation);
	virtual void	getDataset					(vector<T>& input,			deUint32 numElements) = 0;
	virtual void	pushResource				(vector<Resource>&			resource,
												 const vector<T>&			data) = 0;

	static bool		filterNone					(T a);
	static bool		filterNone					(T a, T b);
	static bool		filterNone					(T a, T b, T c);
	static bool		filterNone					(T a, T b, T c, T d);
	static bool		filterZero					(T a, T b);
	static bool		filterNegativesAndZero		(T a, T b);
	static bool		filterMinGtMax				(T, T a, T b);

	static T		zero						(T);
	static T		zero						(T, T);
	static T		zero						(T, T, T);
	static T		zero						(T, T, T, T);

	static string	replicate					(const std::string&			replicant,
												 const deUint32				count);

protected:
	de::Random	m_rnd;
	T			m_cases[3];

private:
	std::string	createInputDecoration			(deUint32						numInput);
	std::string	createInputPreMain				(deUint32						numInput,
												 deUint32						spirvOpertaion);
	std::string	createConstantDeclaration		(vector<T>&						dataset,
												 deUint32						spirvOperation);
	std::string	createInputTestfun				(deUint32						numInput,
												 deUint32						spirvOpertaion);
	deUint32	combine							(GraphicsResources&				resources,
												 ComputeShaderSpec&				computeResources,
												 vector<T>&						data,
												 OpUnaryFuncType				operation,
												 UnaryFilterFuncType			filter,
												 InputRange						inputRange);
	deUint32	combine							(GraphicsResources&				resources,
												 ComputeShaderSpec&				computeResources,
												 vector<T>&						data,
												 OpBinaryFuncType				operation,
												 BinaryFilterFuncType			filter,
												 InputRange						inputRange);
	deUint32	combine							(GraphicsResources&				resources,
												 ComputeShaderSpec&				computeResources,
												 vector<T>&						data,
												 OpTernaryFuncType				operation,
												 TernaryFilterFuncType			filter,
												 InputRange						inputRange);
	deUint32	combine							(GraphicsResources&				resources,
												 ComputeShaderSpec&				computeResources,
												 vector<T>&						data,
												 OpQuaternaryFuncType			operation,
												 QuaternaryFilterFuncType		filter,
												 InputRange						inputRange);
	deUint32	fillResources					(GraphicsResources&				resources,
												 ComputeShaderSpec&				computeResources,
												 const vector<T>&				data);
	void		createStageTests				(const char*					testName,
												 GraphicsResources&				resources,
												 ComputeShaderSpec&				computeResources,
												 deUint32						numElements,
												 vector<string>&				decorations,
												 vector<string>&				pre_mains,
												 vector<string>&				testfuns,
												 string&						operation,
												 InputWidth						inputWidth,
												 const char*					funVariables,
												 const char*					spirvExtension	= DE_NULL);
	void		finalizeFullOperation			(string&						fullOperation,
												 const string&					resultName,
												 const bool						returnHighPart,
												 const bool						isBooleanResult);

	static bool	verifyResult					(const vector<Resource>&		inputs,
												 const vector<AllocationSp>&	outputAllocations,
												 const vector<Resource>&		expectedOutputs,
												 deUint32						skip,
												 tcu::TestLog&					log);
	static bool	verifyDefaultResult				(const vector<Resource>&		inputs,
												 const vector<AllocationSp>&	outputAllocations,
												 const vector<Resource>&		expectedOutputs,
												 tcu::TestLog&					log);
	static bool	verifyVec3Result				(const vector<Resource>&		inputs,
												 const vector<AllocationSp>&	outputAllocations,
												 const vector<Resource>&		expectedOutputs,
												 tcu::TestLog&					log);
	const char* const	m_deviceFeature;
	const char* const	m_spirvCapability;
	const char* const	m_spirvType;
	InputType			m_inputType;
	deUint32			m_typeSize;
	deUint32			m_vectorSize;
	std::string			m_spirvTestType;
};

template <class T>
SpvAsmTypeTests<T>::SpvAsmTypeTests	(tcu::TestContext&	testCtx,
									 const char*		name,
									 const char*		description,
									 const char*		deviceFeature,
									 const char*		spirvCapability,
									 const char*		spirvType,
									 InputType			inputType,
									 deUint32			typeSize,
									 deUint32			vectorSize)
	: tcu::TestCaseGroup	(testCtx, name, description)
	, m_rnd					(deStringHash(name))
	, m_deviceFeature		(deviceFeature)
	, m_spirvCapability		(spirvCapability)
	, m_spirvType			(spirvType)
	, m_inputType			(inputType)
	, m_typeSize			(typeSize)
	, m_vectorSize			(vectorSize)
{
	std::string scalarType;

	DE_ASSERT(vectorSize >= 1 && vectorSize <= 4);

	if (m_inputType == TYPE_I32)
		scalarType = "i32";
	else if (m_inputType == TYPE_U32)
		scalarType = "u32";
	else
		scalarType = "";

	if (scalarType.empty())
	{
		m_spirvTestType = UNDEFINED_SPIRV_TEST_TYPE;
	}
	else
	{
		if (m_vectorSize > 1)
			m_spirvTestType = "v" + de::toString(m_vectorSize) + scalarType;
		else
			m_spirvTestType = scalarType;
	}
}

template <class T>
SpvAsmTypeTests<T>::~SpvAsmTypeTests	(void)
{
}

template <class T>
std::string SpvAsmTypeTests<T>::createInputDecoration (deUint32 numInput)
{
	const StringTemplate	decoration	("OpDecorate %input${n_input} DescriptorSet 0\n"
										 "OpDecorate %input${n_input} Binding ${n_input}\n");
	map<string, string>		specs;

	specs["n_input"] = de::toString(numInput);

	return decoration.specialize(specs);
}

template <class T>
std::string SpvAsmTypeTests<T>::createInputPreMain (deUint32 numInput, deUint32 spirvOpertaion)
{
	const bool				scalarInput = (m_vectorSize != 1) && isScalarInput(spirvOpertaion, numInput);
	const string			bufferType	= (scalarInput) ? "%scalarbufptr" : "%bufptr";

	return "%input" + de::toString(numInput) + " = OpVariable " + bufferType + " Uniform\n";
}

template <class T>
std::string SpvAsmTypeTests<T>::createInputTestfun (deUint32 numInput, deUint32 spirvOpertaion)
{
	const bool				scalarInput	= (m_vectorSize != 1) && isScalarInput(spirvOpertaion, numInput);
	const string			pointerType	= (scalarInput) ? "%up_scalartype" : "%up_testtype";
	const string			valueType	= (scalarInput) ? "%u32" : "%${testtype}";

	const StringTemplate	testfun		("%input${n_input}_loc = OpAccessChain " + pointerType + " %input${n_input} "
										 "%c_i32_0 %counter_val\n"
										 "%input${n_input}_val = OpLoad " + valueType + " %input${n_input}_loc\n");
	map<string, string>		specs;

	specs["n_input"] = de::toString(numInput);
	specs["testtype"] = m_spirvTestType;

	return testfun.specialize(specs);
}

template <class T>
deUint32 SpvAsmTypeTests<T>::combine (GraphicsResources&	resources,
									  ComputeShaderSpec&	computeResources,
									  vector<T>&			data,
									  OpUnaryFuncType		operation,
									  UnaryFilterFuncType	filter,
									  InputRange			inputRange)
{
	DE_UNREF(inputRange);
	const deUint32	datasize		= static_cast<deUint32>(data.size());
	const deUint32	sizeWithPadding = (m_vectorSize == 3) ? 4 : m_vectorSize;
	const deUint32	totalPadding	= (m_vectorSize == 3) ? (datasize / m_vectorSize) : 0;
	const deUint32	total			= datasize + totalPadding;
	deUint32		padCount		= m_vectorSize;
	deUint32		outputsSize;
	vector<T>		inputs;
	vector<T>		outputs;

	inputs.reserve(total);
	outputs.reserve(total);

	/* According to spec, a three-component vector, with components of size N,
	   has a base alignment of 4 N */
	for (deUint32 elemNdx = 0; elemNdx < datasize; ++elemNdx)
	{
		if (filter(data[elemNdx]))
		{
			inputs.push_back(data[elemNdx]);
			outputs.push_back(operation(data[elemNdx]));
			if (m_vectorSize == 3)
			{
				padCount--;
				if (padCount == 0)
				{
					inputs.push_back(0);
					outputs.push_back(0);
					padCount = m_vectorSize;
				}
			}
		}
	}

	outputsSize = static_cast<deUint32>(outputs.size());

	/* Ensure we have pushed a multiple of vector size, including padding if
	   required */
	while (outputsSize % sizeWithPadding != 0)
	{
		inputs.pop_back();
		outputs.pop_back();
		outputsSize--;
	}

	pushResource(resources.inputs, inputs);
	pushResource(resources.outputs, outputs);

	pushResource(computeResources.inputs, inputs);
	pushResource(computeResources.outputs, outputs);

	return outputsSize / sizeWithPadding;
}

template <class T>
deUint32 SpvAsmTypeTests<T>::combine (GraphicsResources&	resources,
									  ComputeShaderSpec&	computeResources,
									  vector<T>&			data,
									  OpBinaryFuncType		operation,
									  BinaryFilterFuncType	filter,
									  InputRange			inputRange)
{
	const deUint32	datasize		= static_cast<deUint32>(data.size());
	const deUint32	sizeWithPadding = (m_vectorSize == 3) ? 4 : m_vectorSize;
	const deUint32	totalData		= datasize * datasize;
	const deUint32	totalPadding	= (m_vectorSize == 3) ? (totalData / m_vectorSize) : 0;
	const deUint32	total			= totalData + totalPadding;
	deUint32		padCount		= m_vectorSize;
	deUint32		outputsSize;
	vector<T>		inputs0;
	vector<T>		inputs1;
	vector<T>		outputs;

	inputs0.reserve(total);
	inputs1.reserve(total);
	outputs.reserve(total);

	/* According to spec, a three-component vector, with components of size N,
	   has a base alignment of 4 N */
	for (deUint32 elemNdx1 = 0; elemNdx1 < datasize; ++elemNdx1)
	for (deUint32 elemNdx2 = 0; elemNdx2 < datasize; ++elemNdx2)
	{
		if (filter(data[elemNdx1], data[elemNdx2]))
		{
			switch (inputRange)
			{
				case RANGE_FULL:
				{
					inputs0.push_back(data[elemNdx1]);
					inputs1.push_back(data[elemNdx2]);
					outputs.push_back(operation(data[elemNdx1], data[elemNdx2]));
					break;
				}
				case RANGE_BIT_WIDTH:
				{
					// Make sure shift count doesn't exceed the bit width
					const T shift = data[elemNdx2] & static_cast<T>(m_typeSize - 1u);
					inputs0.push_back(data[elemNdx1]);
					inputs1.push_back(shift);
					outputs.push_back(operation(data[elemNdx1], shift));
					break;
				}
				default:
					DE_FATAL("Not implemented");
			}

			if (m_vectorSize == 3)
			{
				padCount--;
				if (padCount == 0)
				{
					inputs0.push_back(0);
					inputs1.push_back(0);
					outputs.push_back(0);
					padCount = m_vectorSize;
				}
			}
		}
	}

	outputsSize = static_cast<deUint32>(outputs.size());

	/* Ensure we have pushed a multiple of vector size, including padding if
	   required */
	while (outputsSize % sizeWithPadding != 0)
	{
		inputs0.pop_back();
		inputs1.pop_back();
		outputs.pop_back();
		outputsSize--;
	}

	pushResource(resources.inputs, inputs0);
	pushResource(resources.inputs, inputs1);
	pushResource(resources.outputs, outputs);

	pushResource(computeResources.inputs, inputs0);
	pushResource(computeResources.inputs, inputs1);
	pushResource(computeResources.outputs, outputs);

	return outputsSize / sizeWithPadding;
}

template <class T>
deUint32 SpvAsmTypeTests<T>::combine (GraphicsResources&	resources,
									  ComputeShaderSpec&	computeResources,
									  vector<T>&			data,
									  OpTernaryFuncType		operation,
									  TernaryFilterFuncType	filter,
									  InputRange			inputRange)
{
	const deUint32	datasize		= static_cast<deUint32>(data.size());
	const deUint32	sizeWithPadding = (m_vectorSize == 3) ? 4 : m_vectorSize;
	const deUint32	totalData		= datasize * datasize * datasize;
	const deUint32	totalPadding	= (m_vectorSize == 3) ? (totalData / m_vectorSize) : 0;
	const deUint32	total			= totalData + totalPadding;
	deUint32		padCount		= m_vectorSize;
	deUint32		outputsSize;
	vector<T>		inputs0;
	vector<T>		inputs1;
	vector<T>		inputs2;
	vector<T>		outputs;

	inputs0.reserve(total);
	inputs1.reserve(total);
	inputs2.reserve(total);
	outputs.reserve(total);

	// Reduce the amount of input data in tests without filtering
	deUint32		datasize2		= (inputRange == RANGE_BIT_WIDTH_SUM) ? 4u * m_vectorSize : datasize;
	T				bitOffset		= static_cast<T>(0);
	T				bitCount		= static_cast<T>(0);

	/* According to spec, a three-component vector, with components of size N,
	   has a base alignment of 4 N */
	for (deUint32 elemNdx1 = 0; elemNdx1 < datasize; ++elemNdx1)
	for (deUint32 elemNdx2 = 0; elemNdx2 < datasize2; ++elemNdx2)
	for (deUint32 elemNdx3 = 0; elemNdx3 < datasize2; ++elemNdx3)
	{
		if (filter(data[elemNdx1], data[elemNdx2], data[elemNdx3]))
		{
			switch (inputRange)
			{
				case RANGE_FULL:
				{
					inputs0.push_back(data[elemNdx1]);
					inputs1.push_back(data[elemNdx2]);
					inputs2.push_back(data[elemNdx3]);
					outputs.push_back(operation(data[elemNdx1], data[elemNdx2], data[elemNdx3]));
					break;
				}
				case RANGE_BIT_WIDTH_SUM:
				{
					if (elemNdx3 % m_vectorSize == 0)
					{
						bitOffset	= static_cast<T>(m_rnd.getUint32() & (m_typeSize - 1u));
						bitCount	= static_cast<T>(m_rnd.getUint32() & (m_typeSize - 1u));
					}

					// Make sure the sum of offset and count doesn't exceed bit width
					if ((deUint32)(bitOffset + bitCount) > m_typeSize)
						bitCount = static_cast<T>(m_typeSize - bitOffset);

					inputs0.push_back(data[elemNdx1]);
					inputs1.push_back(bitOffset);
					inputs2.push_back(bitCount);
					outputs.push_back(operation(data[elemNdx1], bitOffset, bitCount));
					break;
				}
				default:
					DE_FATAL("Not implemented");
			}
			if (m_vectorSize == 3)
			{
				padCount--;
				if (padCount == 0)
				{
					inputs0.push_back(0);
					inputs1.push_back(0);
					inputs2.push_back(0);
					outputs.push_back(0);
					padCount = m_vectorSize;
				}
			}
		}
	}
	outputsSize = static_cast<deUint32>(outputs.size());

	/* Ensure we have pushed a multiple of vector size, including padding if
	   required */
	while (outputsSize % sizeWithPadding != 0)
	{
		inputs0.pop_back();
		inputs1.pop_back();
		inputs2.pop_back();
		outputs.pop_back();
		outputsSize--;
	}

	pushResource(resources.inputs, inputs0);
	pushResource(resources.inputs, inputs1);
	pushResource(resources.inputs, inputs2);
	pushResource(resources.outputs, outputs);

	pushResource(computeResources.inputs, inputs0);
	pushResource(computeResources.inputs, inputs1);
	pushResource(computeResources.inputs, inputs2);
	pushResource(computeResources.outputs, outputs);

	return outputsSize / sizeWithPadding;
}

template <class T>
deUint32 SpvAsmTypeTests<T>::combine (GraphicsResources&		resources,
									  ComputeShaderSpec&		computeResources,
									  vector<T>&				data,
									  OpQuaternaryFuncType		operation,
									  QuaternaryFilterFuncType	filter,
									  InputRange				inputRange)
{
	const deUint32	datasize		= static_cast<deUint32>(data.size());
	const deUint32	sizeWithPadding = (m_vectorSize == 3) ? 4 : m_vectorSize;
	const deUint32	totalData		= datasize * datasize;
	const deUint32	totalPadding	= (m_vectorSize == 3) ? (totalData / m_vectorSize) : 0;
	const deUint32	total			= totalData + totalPadding;
	deUint32		padCount		= m_vectorSize;
	deUint32		outputsSize;
	vector<T>		inputs0;
	vector<T>		inputs1;
	vector<T>		inputs2;
	vector<T>		inputs3;
	vector<T>		outputs;

	inputs0.reserve(total);
	inputs1.reserve(total);
	inputs2.reserve(total);
	inputs3.reserve(total);
	outputs.reserve(total);

	// Reduce the amount of input data in tests without filtering
	deUint32		datasize2		= (inputRange == RANGE_BIT_WIDTH_SUM) ? 2u * m_vectorSize : datasize;
	T				bitOffset		= static_cast<T>(0);
	T				bitCount		= static_cast<T>(0);

	/* According to spec, a three-component vector, with components of size N,
	   has a base alignment of 4 N */
	for (deUint32 elemNdx1 = 0; elemNdx1 < datasize; ++elemNdx1)
	for (deUint32 elemNdx2 = 0; elemNdx2 < datasize2; ++elemNdx2)
	for (deUint32 elemNdx3 = 0; elemNdx3 < datasize2; ++elemNdx3)
	for (deUint32 elemNdx4 = 0; elemNdx4 < datasize2; ++elemNdx4)
	{
		if (filter(data[elemNdx1], data[elemNdx2], data[elemNdx3], data[elemNdx4]))
		{
			switch (inputRange)
			{
				case RANGE_FULL:
				{
					inputs0.push_back(data[elemNdx1]);
					inputs1.push_back(data[elemNdx2]);
					inputs2.push_back(data[elemNdx3]);
					inputs3.push_back(data[elemNdx3]);
					outputs.push_back(operation(data[elemNdx1], data[elemNdx2], data[elemNdx3], data[elemNdx4]));
					break;
				}
				case RANGE_BIT_WIDTH_SUM:
				{
					if (elemNdx4 % m_vectorSize == 0)
					{
						bitOffset	= static_cast<T>(m_rnd.getUint32() & (m_typeSize - 1u));
						bitCount	= static_cast<T>(m_rnd.getUint32() & (m_typeSize - 1u));
					}

					// Make sure the sum of offset and count doesn't exceed bit width
					if ((deUint32)(bitOffset + bitCount) > m_typeSize)
						bitCount -= bitOffset + bitCount - static_cast<T>(m_typeSize);

					inputs0.push_back(data[elemNdx1]);
					inputs1.push_back(data[elemNdx2]);
					inputs2.push_back(bitOffset);
					inputs3.push_back(bitCount);
					outputs.push_back(operation(data[elemNdx1], data[elemNdx2], bitOffset, bitCount));
					break;
				}
				default:
					DE_FATAL("Not implemented");
			}
			if (m_vectorSize == 3)
			{
				padCount--;
				if (padCount == 0)
				{
					inputs0.push_back(0);
					inputs1.push_back(0);
					inputs2.push_back(0);
					inputs3.push_back(0);
					outputs.push_back(0);
					padCount = m_vectorSize;
				}
			}
		}
	}

	outputsSize = static_cast<deUint32>(outputs.size());

	/* Ensure we have pushed a multiple of vector size, including padding if
	   required */
	while (outputsSize % sizeWithPadding != 0)
	{
		inputs0.pop_back();
		inputs1.pop_back();
		inputs2.pop_back();
		inputs3.pop_back();
		outputs.pop_back();
		outputsSize--;
	}

	pushResource(resources.inputs, inputs0);
	pushResource(resources.inputs, inputs1);
	pushResource(resources.inputs, inputs2);
	pushResource(resources.inputs, inputs3);
	pushResource(resources.outputs, outputs);

	pushResource(computeResources.inputs, inputs0);
	pushResource(computeResources.inputs, inputs1);
	pushResource(computeResources.inputs, inputs2);
	pushResource(computeResources.inputs, inputs3);
	pushResource(computeResources.outputs, outputs);

	return outputsSize / sizeWithPadding;
}

// This one is used for switch tests.
template <class T>
deUint32 SpvAsmTypeTests<T>::fillResources (GraphicsResources&	resources,
											ComputeShaderSpec&	computeResources,
											const vector<T>&	data)
{
	vector<T>	outputs;

	outputs.reserve(data.size());

	for (deUint32 elemNdx = 0; elemNdx < data.size(); ++elemNdx)
	{
		if (data[elemNdx] == m_cases[0])
			outputs.push_back(100);
		else if (data[elemNdx] == m_cases[1])
			outputs.push_back(110);
		else if (data[elemNdx] == m_cases[2])
			outputs.push_back(120);
		else
			outputs.push_back(10);
	}

	pushResource(resources.inputs, data);
	pushResource(resources.inputs, outputs);

	pushResource(computeResources.inputs, data);
	pushResource(computeResources.inputs, outputs);

	// Prepare an array of 32-bit integer values with a single integer. The expected value is 1.
	vector<deInt32> expectedOutput;
	expectedOutput.push_back(1);
	computeResources.outputs.push_back(Resource(BufferSp(new Int32Buffer(expectedOutput))));
	computeResources.verifyIO = verifyComputeSwitchResult;

	return static_cast<deUint32>(outputs.size());
}

template <class T>
void SpvAsmTypeTests<T>::createStageTests (const char*			testName,
										   GraphicsResources&	resources,
										   ComputeShaderSpec&	computeResources,
										   deUint32				numElements,
										   vector<string>&		decorations,
										   vector<string>&		pre_mains,
										   vector<string>&		testfuns,
										   string&				operation,
										   InputWidth			inputWidth,
										   const char*			funVariables,
										   const char*			spirvExtension)
{
	// Roughly equivalent to the following GLSL compute shader:
	//
	//      vec4 testfun(in vec4 param);
	//
	//      void main()
	//      {
	//          vec4 in_color	= vec4(0.0, 0.0, 0.0, 1.0);
	//          vec4 out_color	= testfun(in_color);
	//      }
	//
	// The input and output colors are irrelevant, but testfun will iterate over the input buffers and calculate results on the output
	// buffer. After the compute shader has run, we can verify the output buffer contains the expected results.
	const tcu::StringTemplate computeShaderTemplate(R"(
					OpCapability Shader
					${capability:opt}
					${extension:opt}
					OpMemoryModel Logical GLSL450
					OpEntryPoint GLCompute %BP_main "main"
					OpExecutionMode %BP_main LocalSize 1 1 1
					${execution_mode:opt}
					${debug:opt}
					${moduleprocessed:opt}
					${IF_decoration:opt}
					${decoration:opt}
	)"
					SPIRV_ASSEMBLY_TYPES
					SPIRV_ASSEMBLY_CONSTANTS
					SPIRV_ASSEMBLY_ARRAYS
	R"(
		%BP_color = OpConstantComposite %v4f32 %c_f32_0 %c_f32_0 %c_f32_0 %c_f32_1
					${pre_main:opt}
					${IF_variable:opt}
		 %BP_main = OpFunction %void None %voidf
   %BP_label_main = OpLabel
					${IF_carryforward:opt}
					${post_interface_op_comp:opt}
	 %BP_in_color = OpVariable %fp_v4f32 Function
	%BP_out_color = OpVariable %fp_v4f32 Function
					OpStore %BP_in_color %BP_color
		 %BP_tmp1 = OpLoad %v4f32 %BP_in_color
		 %BP_tmp2 = OpFunctionCall %v4f32 %test_code %BP_tmp1
					OpStore %BP_out_color %BP_tmp2
					OpReturn
					OpFunctionEnd

					${testfun}
	)");

	const StringTemplate		decoration		("OpDecorate %output DescriptorSet 0\n"
												 "OpDecorate %output Binding ${output_binding}\n"
												 "OpDecorate %a${num_elements}testtype ArrayStride ${typesize}\n"
												 "OpDecorate %buf BufferBlock\n"
												 "OpMemberDecorate %buf 0 Offset 0\n");

	const StringTemplate		vecDecoration	("OpDecorate %a${num_elements}scalartype ArrayStride ${typesize}\n"
												 "OpDecorate %scalarbuf BufferBlock\n"
												 "OpMemberDecorate %scalarbuf 0 Offset 0\n");

	const StringTemplate		pre_pre_main	("%c_u32_${num_elements} = OpConstant %u32 ${num_elements}\n"
												 "%c_i32_${num_elements} = OpConstant %i32 ${num_elements}\n");

	const StringTemplate		scalar_pre_main	("%testtype = ${scalartype}\n");

	const StringTemplate		vector_pre_main	("%scalartype = ${scalartype}\n"
												 "%testtype = OpTypeVector %scalartype ${vector_size}\n");

	const StringTemplate		pre_main_consts	("%c_shift  = OpConstant %u32 16\n"
												 "${constant_zero}\n"
												 "${constant_one}\n");

	const StringTemplate		pre_main_constv	("%c_shift1 = OpConstant %u32 16\n"
												 "%c_shift  = OpConstantComposite %v${vector_size}u32 ${shift_initializers}\n"
												 "${bvec}\n"
												 "${constant_zero}\n"
												 "${constant_one}\n"
												 "%a${num_elements}scalartype = OpTypeArray %u32 %c_u32_${num_elements}\n"
												 "%up_scalartype = OpTypePointer Uniform %u32\n"
												 "%scalarbuf = OpTypeStruct %a${num_elements}scalartype\n"
												 "%scalarbufptr = OpTypePointer Uniform %scalarbuf\n");

	const StringTemplate		post_pre_main	("%a${num_elements}testtype = OpTypeArray %${testtype} "
												 "%c_u32_${num_elements}\n"
												 "%up_testtype = OpTypePointer Uniform %${testtype}\n"
												 "%buf = OpTypeStruct %a${num_elements}testtype\n"
												 "%bufptr = OpTypePointer Uniform %buf\n"
												 "%output = OpVariable %bufptr Uniform\n"
												 "${other_size_types}\n"
												 "${u32_function_pointer}\n");

	const StringTemplate		pre_testfun		("%test_code = OpFunction %v4f32 None %v4f32_v4f32_function\n"
												 "%param = OpFunctionParameter %v4f32\n"
												 "%entry = OpLabel\n"
												 "%op_constant = OpVariable %fp_${testtype} Function\n"
												 + string(funVariables) +
												 "%counter = OpVariable %fp_i32 Function\n"
												 "OpStore %counter %c_i32_0\n"
												 "OpBranch %loop\n"

												 "%loop = OpLabel\n"
												 "%counter_val = OpLoad %i32 %counter\n"
												 "%lt = OpSLessThan %bool %counter_val %c_i32_${num_elements}\n"
												 "OpLoopMerge %exit %inc None\n"
												 "OpBranchConditional %lt %write %exit\n"

												 "%write = OpLabel\n"
												 "%output_loc = OpAccessChain %up_testtype %output %c_i32_0 "
												 "%counter_val\n");

	const StringTemplate		post_testfun	("OpStore %output_loc %op_result\n"
												 "OpBranch %inc\n"

												 "%inc = OpLabel\n"
												 "%counter_val_next = OpIAdd %i32 %counter_val %c_i32_1\n"
												 "OpStore %counter %counter_val_next\n"
												 "OpBranch %loop\n"

												 "%exit = OpLabel\n"
												 "OpReturnValue %param\n"

												 "OpFunctionEnd\n");

	const bool					uses8bit		(m_inputType == TYPE_I8 || m_inputType == TYPE_U8 || has8BitInputWidth(inputWidth));
	const string				vectorSizeStr	(de::toString(m_vectorSize));
	std::vector<std::string>	noExtensions;
	std::vector<std::string>	features;
	RGBA						defaultColors[4];
	map<string, string>			fragments;
	map<string, string>			specs;
	VulkanFeatures				requiredFeatures;
	std::string					spirvExtensions;
	std::string					spirvCapabilities;

	getDefaultColors(defaultColors);

	if (m_vectorSize == 3)
	{
		resources.verifyIO = verifyVec3Result;
		computeResources.verifyIO = verifyVec3Result;
	}
	else
	{
		resources.verifyIO = verifyDefaultResult;
		computeResources.verifyIO = verifyDefaultResult;
	}

	// All of the following tests write their results into an output SSBO, therefore they require the following features.
	requiredFeatures.coreFeatures.vertexPipelineStoresAndAtomics = DE_TRUE;
	requiredFeatures.coreFeatures.fragmentStoresAndAtomics = DE_TRUE;

	if (m_deviceFeature)
		features.insert(features.begin(), m_deviceFeature);

	if (inputWidth != WIDTH_DEFAULT)
	{
		if (has16BitInputWidth(inputWidth))
			features.insert(features.begin(), "shaderInt16");
		if (has64BitInputWidth(inputWidth))
			features.insert(features.begin(), "shaderInt64");
	}

	if (uses8bit)
	{
		requiredFeatures.extFloat16Int8.shaderInt8 = true;
	}

	if (m_inputType == TYPE_I8 || m_inputType == TYPE_U8)
	{
		requiredFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
		spirvExtensions					+= "OpExtension \"SPV_KHR_8bit_storage\"\n";
	}

	if (m_inputType == TYPE_I16 || m_inputType == TYPE_U16)
	{
		requiredFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
		spirvExtensions						+= "OpExtension \"SPV_KHR_16bit_storage\"\n";
	}

	specs["testtype"]				= m_spirvTestType;
	specs["scalartype"]				= m_spirvType;
	specs["typesize"]				= de::toString(((m_vectorSize == 3) ? 4 : m_vectorSize) * m_typeSize / 8);
	specs["vector_size"]			= vectorSizeStr;
	specs["num_elements"]			= de::toString(numElements);
	specs["output_binding"]			= de::toString(resources.inputs.size());
	specs["shift_initializers"]		= replicate(" %c_shift1", m_vectorSize);

	specs["bvec"]					= (m_vectorSize == 1 || m_vectorSize == 4) ? ("")
									: ("%v" + vectorSizeStr + "bool = OpTypeVector %bool " + vectorSizeStr);

	specs["constant_zero"]			= (m_vectorSize == 1)
									? ("%c_zero = OpConstant %u32 0\n")
									: ("%c_zero = OpConstantComposite %v" + vectorSizeStr + "u32" + replicate(" %c_u32_0", m_vectorSize));

	specs["constant_one"]			= (m_vectorSize == 1)
									? ("%c_one = OpConstant %u32 1\n")
									: ("%c_one = OpConstantComposite %v" + vectorSizeStr + "u32" + replicate(" %c_u32_1", m_vectorSize));

	specs["other_size_types"]		= (inputWidth == WIDTH_DEFAULT) ? ("")
									: getOtherSizeTypes(m_inputType, m_vectorSize, inputWidth);

	specs["u32_function_pointer"]	= deStringEqual(m_spirvTestType.c_str(), "i32") ? ("")
									: ("%fp_" + m_spirvTestType + " = OpTypePointer Function %" + m_spirvTestType + "\n");

	if (spirvExtension)
		spirvExtensions += "%ext1 = OpExtInstImport \"" + string(spirvExtension) + "\"";

	for (deUint32 elemNdx = 0; elemNdx < decorations.size(); ++elemNdx)
		fragments["decoration"] += decorations[elemNdx];
	fragments["decoration"] += decoration.specialize(specs);

	if (m_vectorSize > 1)
		fragments["decoration"] += vecDecoration.specialize(specs);

	fragments["pre_main"] = pre_pre_main.specialize(specs);
	if (specs["testtype"].compare(UNDEFINED_SPIRV_TEST_TYPE) == 0)
	{
		if (m_vectorSize > 1)
			fragments["pre_main"] += vector_pre_main.specialize(specs);
		else
			fragments["pre_main"] += scalar_pre_main.specialize(specs);
	}

	if (m_vectorSize > 1)
		fragments["pre_main"] += pre_main_constv.specialize(specs);
	else
		fragments["pre_main"] += pre_main_consts.specialize(specs);

	fragments["pre_main"] += post_pre_main.specialize(specs);
	for (deUint32 elemNdx = 0; elemNdx < pre_mains.size(); ++elemNdx)
		fragments["pre_main"] += pre_mains[elemNdx];

	fragments["testfun"] = pre_testfun.specialize(specs);
	for (deUint32 elemNdx = 0; elemNdx < testfuns.size(); ++elemNdx)
		fragments["testfun"] += testfuns[elemNdx];
	fragments["testfun"] += operation + post_testfun.specialize(specs);

	spirvCapabilities += getSpirvCapabilityStr(m_spirvCapability, inputWidth);

	fragments["extension"]	= spirvExtensions;
	fragments["capability"]	= spirvCapabilities;

	requiredFeaturesFromStrings(features, requiredFeatures);

	createTestsForAllStages(testName, defaultColors, defaultColors, fragments, resources, noExtensions, this, requiredFeatures);

	computeResources.requestedVulkanFeatures = requiredFeatures;
	computeResources.requestedVulkanFeatures.coreFeatures.vertexPipelineStoresAndAtomics = false;
	computeResources.requestedVulkanFeatures.coreFeatures.fragmentStoresAndAtomics = false;

	createComputeTest(computeResources, computeShaderTemplate, fragments, *this, testName);
}

template <class T>
std::string valueToStr(const T v)
{
	std::stringstream s;
	s << v;
	return s.str();
}

template <>
std::string valueToStr<deUint8> (const deUint8 v)
{
	std::stringstream s;
	s << (deUint16)v;
	return s.str();
}

template <>
std::string valueToStr<deInt8> ( const deInt8 v)
{
	std::stringstream s;
	s << (deInt16)v;
	return s.str();
}

template <class T>
bool SpvAsmTypeTests<T>::verifyResult (const vector<Resource>&		inputs,
									   const vector<AllocationSp>&	outputAllocations,
									   const vector<Resource>&		expectedOutputs,
									   deUint32						skip,
									   tcu::TestLog&				log)
{
	DE_ASSERT(outputAllocations.size() == 1);
	DE_ASSERT(inputs.size() > 0 && inputs.size() < 5);

	const T*		input[4]		= { DE_NULL };
	vector<deUint8>	inputBytes[4];
	vector<deUint8>	expectedBytes;

	expectedOutputs[0].getBytes(expectedBytes);
	const deUint32 count	= static_cast<deUint32>(expectedBytes.size() / sizeof(T));
	const T* obtained		= static_cast<const T *>(outputAllocations[0]->getHostPtr());
	const T* expected		= reinterpret_cast<const T*>(&expectedBytes.front());

	for (deUint32 ndxCount = 0; ndxCount < inputs.size(); ndxCount++)
	{
		inputs[ndxCount].getBytes(inputBytes[ndxCount]);
		input[ndxCount]	= reinterpret_cast<const T*>(&inputBytes[ndxCount].front());
	}

	for (deUint32 ndxCount = 0 ; ndxCount < count; ++ndxCount)
	{
		/* Skip padding */
		if (((ndxCount + 1) % skip) == 0)
			continue;

		if (obtained[ndxCount] != expected[ndxCount])
		{
			std::stringstream inputStream;
			inputStream << "(";
			for (deUint32 ndxIndex = 0 ; ndxIndex < inputs.size(); ++ndxIndex)
			{
				inputStream << valueToStr(input[ndxIndex][ndxCount]);
				if (ndxIndex < inputs.size() - 1)
					inputStream << ",";
			}
			inputStream << ")";
			log << tcu::TestLog::Message
				<< "Error: found unexpected result for inputs " << inputStream.str()
				<< ": expected " << valueToStr(expected[ndxCount]) << ", obtained "
				<< valueToStr(obtained[ndxCount]) << tcu::TestLog::EndMessage;
			return false;
		}
	}

	return true;
}

template <class T>
bool SpvAsmTypeTests<T>::verifyDefaultResult (const vector<Resource>&		inputs,
											  const vector<AllocationSp>&	outputAllocations,
											  const vector<Resource>&		expectedOutputs,
											  tcu::TestLog&					log)
{
	return verifyResult(inputs, outputAllocations, expectedOutputs, ~0, log);
}

template <class T>
bool SpvAsmTypeTests<T>::verifyVec3Result (const vector<Resource>&		inputs,
										   const vector<AllocationSp>&	outputAllocations,
										   const vector<Resource>&		expectedOutputs,
										   tcu::TestLog&				log)
{
	return verifyResult(inputs, outputAllocations, expectedOutputs, 4, log);
}

template <class T>
string SpvAsmTypeTests<T>::createConstantDeclaration (vector<T>& dataset, deUint32 spirvOperation)
{
	const bool		isVariableTest				= (SpvOpVariable == spirvOperation);
	const bool		isConstantNullTest			= (SpvOpConstantNull == spirvOperation) || isVariableTest;
	const bool		isConstantCompositeTest		= (SpvOpConstantComposite == spirvOperation) || (isConstantNullTest && m_vectorSize > 1);
	const bool		isConstantTest				= (SpvOpConstant == spirvOperation) || isConstantCompositeTest || isConstantNullTest;
	const bool		isSpecConstantTest			= (SpvOpSpecConstant == spirvOperation);
	const bool		isSpecConstantCompositeTest	= (SpvOpSpecConstantComposite == spirvOperation);

	const string	testScalarType				= (m_inputType == TYPE_I32) ? "i32"
												: (m_inputType == TYPE_U32) ? "u32"
												: "scalartype";
	const string	constantType				= (m_vectorSize > 1) ? testScalarType : m_spirvTestType;
	const string	constantName				= (m_vectorSize > 1) ? "%c_constituent_" : "%c_testtype_";

	string			str							= "";

	// Declare scalar specialization constants
	if (isSpecConstantTest)
	{
		for (size_t constantNdx = 0u; constantNdx < dataset.size(); constantNdx++)
			str += constantName + de::toString(constantNdx) + " = OpSpecConstant %" + constantType + " " + de::toString(dataset[constantNdx]) + "\n";
	}

	// Declare specialization constant composites
	if (isSpecConstantCompositeTest)
	{
		// Constituents are a mix of OpConstantNull, OpConstants and OpSpecializationConstants
		for (size_t constantNdx = 0u; constantNdx < dataset.size(); constantNdx++)
		{
			const char* constantOp[] =
			{
				"OpConstant",
				"OpSpecConstant"
			};

			if (constantNdx == 0u)
				str += constantName + de::toString(constantNdx) + " = OpConstantNull %" + constantType + "\n";
			else
				str += constantName + de::toString(constantNdx) + " = " + constantOp[constantNdx % 2] + " %" + constantType + " " + de::toString(dataset[constantNdx]) + "\n";
		}

		for (deUint32 compositeNdx = 0u; compositeNdx < (deUint32)dataset.size(); compositeNdx++)
		{
			str += "%c_testtype_" + de::toString(compositeNdx) + " = OpSpecConstantComposite %" + m_spirvTestType;

			for (deUint32 componentNdx = 0u; componentNdx < m_vectorSize; componentNdx++)
				str += " %c_constituent_" + de::toString(getConstituentIndex(compositeNdx * m_vectorSize + componentNdx, m_vectorSize));

			str += "\n";
		}
	}

	// Declare scalar constants
	if (isConstantTest || isVariableTest)
	{
		for (size_t constantNdx = 0u; constantNdx < dataset.size(); constantNdx++)
		{
			if (isConstantNullTest && constantNdx == 0u)
				str += constantName + de::toString(constantNdx) + " = OpConstantNull %" + constantType + "\n";
			else
				str += constantName + de::toString(constantNdx) + " = OpConstant %" + constantType + " " + de::toString(dataset[constantNdx]) + "\n";
		}
	}

	// Declare constant composites
	if (isConstantCompositeTest)
	{
		for (deUint32 compositeNdx = 0u; compositeNdx < (deUint32)dataset.size(); compositeNdx++)
		{
			str += "%c_testtype_" + de::toString(compositeNdx) + " = OpConstantComposite %" + m_spirvTestType;

			for (deUint32 componentNdx = 0u; componentNdx < m_vectorSize; componentNdx++)
				str += " %c_constituent_" + de::toString(getConstituentIndex(compositeNdx * m_vectorSize + componentNdx, m_vectorSize));

			str += "\n";
		}
	}

	return str;
}

template <class T>
string getVariableStr (vector<T>& dataset, const char* spirvType, deUint32 spirvOperation)
{
	const bool		isVariableTest = (SpvOpVariable == spirvOperation);
	string			str = "";

	// Declare variables with initializers
	if (isVariableTest)
		for (size_t i = 0u; i < dataset.size(); i++)
			str += "%testvariable_" + de::toString(i) + " = OpVariable %fp_" + spirvType + " Function %c_testtype_" + de::toString(i) + "\n";

	return str;
}

template <class T>
void SpvAsmTypeTests<T>::createTests (const char*			testName,
									  deUint32				spirvOperation,
									  OpUnaryFuncType		operation,
									  UnaryFilterFuncType	filter,
									  InputRange			inputRange,
									  InputWidth			inputWidth,
									  const char*			spirvExtension,
									  const bool			returnHighPart)
{
	DE_ASSERT(!isBooleanResultTest(spirvOperation));

	const string		resultName	= returnHighPart ? "%op_result_pre" : "%op_result";
	OpUnaryFuncType		zeroFunc	= &zero;
	vector<T>			dataset;
	vector<string>		decorations;
	vector<string>		pre_mains;
	vector<string>		testfuns;
	GraphicsResources	resources;
	ComputeShaderSpec	computeResources;
	map<string, string>	fragments;
	map<string, string>	specs;

	if (isConstantOrVariableTest(spirvOperation))
	{
		DE_ASSERT(!spirvExtension);

		const deUint32		inputSize		= TEST_DATASET_SIZE;
		const deUint32		outputSize		= TEST_DATASET_SIZE * m_vectorSize;
		vector<T>			inputDataset;

		inputDataset.reserve(inputSize);
		dataset.reserve(outputSize);

		getDataset(inputDataset, inputSize);
		getConstantDataset(inputDataset, dataset, spirvOperation);

		const deUint32		totalElements	= combine(resources, computeResources, dataset, (returnHighPart ? zeroFunc : operation), filter, inputRange);

		pre_mains.reserve(1);
		pre_mains.push_back(createConstantDeclaration(inputDataset, spirvOperation));

		string				fullOperation	= "OpBranch %switchStart\n"
											  "%switchStart = OpLabel\n"
											  "OpSelectionMerge %switchEnd None\n"
											  "OpSwitch %counter_val %caseDefault";

		for (deUint32 caseNdx = 0u; caseNdx < inputSize; caseNdx++)
			fullOperation += " " + de::toString(caseNdx) + " " + "%case" + de::toString(caseNdx);

		fullOperation += "\n";

		const string		funVariables	= getVariableStr(inputDataset, m_spirvTestType.c_str(), spirvOperation);

		if (SpvOpVariable == spirvOperation)
		{
			for (deUint32 caseNdx = 0u; caseNdx < inputSize; caseNdx++)
				fullOperation +=	"%case" + de::toString(caseNdx) + " = OpLabel\n"
									"%temp_" + de::toString(caseNdx) + " = OpLoad %" + m_spirvTestType + " %testvariable_" + de::toString(caseNdx) + "\n"
									"OpStore %op_constant %temp_" + de::toString(caseNdx) + "\n"
									"OpBranch %switchEnd\n";
		}
		else
		{
			for (deUint32 caseNdx = 0u; caseNdx < inputSize; caseNdx++)
				fullOperation +=	"%case" + de::toString(caseNdx) + " = OpLabel\n"
									"OpStore %op_constant %c_testtype_" + de::toString(caseNdx) + "\n"
									"OpBranch %switchEnd\n";
		}

		fullOperation +=	"%caseDefault = OpLabel\n"
							"OpBranch %switchEnd\n"
							"%switchEnd = OpLabel\n"
							+ resultName + " = OpLoad %" + m_spirvTestType + " %op_constant\n";


		finalizeFullOperation(fullOperation, resultName, returnHighPart, false);

		createStageTests(testName, resources, computeResources, totalElements, decorations,
						 pre_mains, testfuns, fullOperation, inputWidth, funVariables.c_str(), spirvExtension);
	}
	else
	{
		dataset.reserve(TEST_DATASET_SIZE * m_vectorSize);
		getDataset(dataset, TEST_DATASET_SIZE * m_vectorSize);
		const deUint32	totalElements	= combine(resources, computeResources, dataset, (returnHighPart ? zeroFunc : operation), filter, inputRange);

		decorations.reserve(1);
		pre_mains.reserve(1);
		testfuns.reserve(1);

		decorations.push_back(createInputDecoration(0));
		pre_mains.push_back(createInputPreMain(0, spirvOperation));
		testfuns.push_back(createInputTestfun(0, spirvOperation));

		string			full_operation	(spirvExtension ? resultName + " = OpExtInst %" + m_spirvTestType + " %ext1 " + getGLSLstd450OperationStr(spirvOperation) + " %input0_val\n"
										: resultName + " = " + getSpvOperationStr(spirvOperation) + " %" + m_spirvTestType + " %input0_val\n");

		finalizeFullOperation(full_operation, resultName, returnHighPart, false);

		createStageTests(testName, resources, computeResources, totalElements, decorations,
						 pre_mains, testfuns, full_operation, inputWidth, "", spirvExtension);
	}
}

template <class T>
void SpvAsmTypeTests<T>::createTests (const char*			testName,
									  deUint32				spirvOperation,
									  OpBinaryFuncType		operation,
									  BinaryFilterFuncType	filter,
									  InputRange			inputRange,
									  InputWidth			inputWidth,
									  const char*			spirvExtension,
									  const bool			returnHighPart)
{
	const bool			isBoolean		= isBooleanResultTest(spirvOperation);
	const string		resultName		= (returnHighPart || isBoolean) ? "%op_result_pre" : "%op_result";
	const string		resultType		= isBoolean ? getBooleanResultType(m_vectorSize) : m_spirvTestType;
	OpBinaryFuncType	zeroFunc		= &zero;
	vector<T>			dataset;
	vector<string>		decorations;
	vector<string>		pre_mains;
	vector<string>		testfuns;
	GraphicsResources	resources;
	ComputeShaderSpec	computeResources;
	map<string, string>	fragments;
	map<string, string>	specs;
	string				full_operation;

	dataset.reserve(TEST_DATASET_SIZE * m_vectorSize);
	getDataset(dataset, TEST_DATASET_SIZE * m_vectorSize);
	const deUint32		totalElements	= combine(resources, computeResources, dataset, (returnHighPart ? zeroFunc : operation), filter, inputRange);

	decorations.reserve(2);
	pre_mains.reserve(2);
	testfuns.reserve(2);

	for (deUint32 elemNdx = 0; elemNdx < 2; ++elemNdx)
	{
		decorations.push_back(createInputDecoration(elemNdx));
		pre_mains.push_back(createInputPreMain(elemNdx, spirvOperation));
		testfuns.push_back(createInputTestfun(elemNdx, spirvOperation));
	}

	if (spirvOperation != DE_NULL)
	{
		if (inputWidth == WIDTH_DEFAULT)
			full_operation = spirvExtension	? resultName + " = OpExtInst %" + resultType + " %ext1 " + getGLSLstd450OperationStr(spirvOperation) + " %input0_val %input1_val\n"
											: resultName + " = " + getSpvOperationStr(spirvOperation) + " %" + resultType + " %input0_val %input1_val\n";
		else
			full_operation = getBinaryFullOperationWithInputWidthStr(resultName, getSpvOperationStr(spirvOperation), m_inputType, m_spirvTestType, m_vectorSize, inputWidth);
	}
	else
	{
		if (deStringBeginsWith(testName, "mul_sdiv"))
		{
			DE_ASSERT(spirvExtension == DE_NULL);
			full_operation = "%op_result2 = OpIMul %" + m_spirvTestType + " %input0_val %input1_val\n";
			full_operation += resultName + " = OpSDiv %" + m_spirvTestType + " %op_result2 %input1_val\n";
		}
		if (deStringBeginsWith(testName, "mul_udiv"))
		{
			DE_ASSERT(spirvExtension == DE_NULL);
			full_operation = "%op_result2 = OpIMul %" + m_spirvTestType + " %input0_val %input1_val\n";
			full_operation += resultName + " = OpUDiv %" + m_spirvTestType + " %op_result2 %input1_val\n";
		}
	}

	finalizeFullOperation(full_operation, resultName, returnHighPart, isBoolean);

	createStageTests(testName, resources, computeResources, totalElements, decorations,
					 pre_mains, testfuns, full_operation, inputWidth, "", spirvExtension);
}

template <class T>
void SpvAsmTypeTests<T>::createTests (const char*			testName,
									  deUint32				spirvOperation,
									  OpTernaryFuncType		operation,
									  TernaryFilterFuncType	filter,
									  InputRange			inputRange,
									  InputWidth			inputWidth,
									  const char*			spirvExtension,
									  const bool			returnHighPart)
{
	DE_ASSERT(!isBooleanResultTest(spirvOperation));

	const string		resultName		= returnHighPart ? "%op_result_pre" : "%op_result";
	OpTernaryFuncType	zeroFunc		= &zero;
	vector<T>			dataset;
	vector<string>		decorations;
	vector<string>		pre_mains;
	vector<string>		testfuns;
	GraphicsResources	resources;
	ComputeShaderSpec	computeResources;
	map<string, string>	fragments;
	map<string, string>	specs;

	dataset.reserve(TEST_DATASET_SIZE * m_vectorSize);
	getDataset(dataset, TEST_DATASET_SIZE * m_vectorSize);
	const deUint32		totalElements	= combine(resources, computeResources, dataset, (returnHighPart ? zeroFunc : operation), filter, inputRange);

	decorations.reserve(3);
	pre_mains.reserve(3);
	testfuns.reserve(3);

	for (deUint32 elemNdx = 0; elemNdx < 3; ++elemNdx)
	{
		decorations.push_back(createInputDecoration(elemNdx));
		pre_mains.push_back(createInputPreMain(elemNdx, spirvOperation));
		testfuns.push_back(createInputTestfun(elemNdx, spirvOperation));
	}

	string				full_operation	= "";

	if (inputWidth == WIDTH_DEFAULT)
		full_operation = (spirvExtension ? resultName + " = OpExtInst %" + m_spirvTestType + " %ext1 " + getGLSLstd450OperationStr(spirvOperation) + " %input0_val %input1_val %input2_val\n"
										 : resultName + " = " + getSpvOperationStr(spirvOperation) + " %" + m_spirvTestType + " %input0_val %input1_val %input2_val\n");
	else
		full_operation = getFullOperationWithDifferentInputWidthStr(resultName, getSpvOperationStr(spirvOperation), m_inputType, m_spirvTestType, inputWidth, false);

	finalizeFullOperation(full_operation, resultName, returnHighPart, false);

	createStageTests(testName, resources, computeResources, totalElements, decorations,
					 pre_mains, testfuns, full_operation, inputWidth, "", spirvExtension);
}

template <class T>
void SpvAsmTypeTests<T>::createTests (const char*				testName,
									  deUint32					spirvOperation,
									  OpQuaternaryFuncType		operation,
									  QuaternaryFilterFuncType	filter,
									  InputRange				inputRange,
									  InputWidth				inputWidth,
									  const char*				spirvExtension,
									  const bool				returnHighPart)
{
	DE_ASSERT(!spirvExtension);
	DE_ASSERT(!isBooleanResultTest(spirvOperation));

	const string			resultName		= returnHighPart ? "%op_result_pre" : "%op_result";
	OpQuaternaryFuncType	zeroFunc		= &zero;
	vector<T>				dataset;
	vector<string>			decorations;
	vector<string>			pre_mains;
	vector<string>			testfuns;
	GraphicsResources		resources;
	ComputeShaderSpec		computeResources;
	map<string, string>		fragments;
	map<string, string>		specs;
	string					full_operation;

	dataset.reserve(TEST_DATASET_SIZE * m_vectorSize);
	getDataset(dataset, TEST_DATASET_SIZE * m_vectorSize);
	const deUint32			totalElements	= combine(resources, computeResources, dataset, (returnHighPart ? zeroFunc : operation), filter, inputRange);

	decorations.reserve(4);
	pre_mains.reserve(4);
	testfuns.reserve(4);

	for (deUint32 elemNdx = 0; elemNdx < 4; ++elemNdx)
	{
		decorations.push_back(createInputDecoration(elemNdx));
		pre_mains.push_back(createInputPreMain(elemNdx, spirvOperation));
		testfuns.push_back(createInputTestfun(elemNdx, spirvOperation));
	}

	if (inputWidth == WIDTH_DEFAULT)
		full_operation	= resultName + " = " + getSpvOperationStr(spirvOperation) + " %" + m_spirvTestType + " %input0_val %input1_val %input2_val %input3_val\n";
	else
		full_operation = getFullOperationWithDifferentInputWidthStr(resultName, getSpvOperationStr(spirvOperation), m_inputType, m_spirvTestType, inputWidth, true);

	finalizeFullOperation(full_operation, resultName, returnHighPart, false);

	createStageTests(testName, resources, computeResources, totalElements, decorations,
					 pre_mains, testfuns, full_operation, inputWidth, "", spirvExtension);
}

template <class T>
void SpvAsmTypeTests<T>::createSwitchTests (void)
{
	// The switch case test function is a bit different from the normal one. It uses two input buffers for input data and expected
	// results. The shader itself will calculate results based on input data and compare them to the expected results in the second
	// buffer, instead of verifying results on the CPU.
	//
	// The test function will return the color passed to it if the obtained results match the expected results, and will return (0.5,
	// 0.5, 0.5, 1.0) if they do not. For graphic stages, this returned color will be used to draw things and we can verify the output
	// image as usual with the graphics shader test utils. For compute shaders, this does not work.
	//
	// In this case, we will pass black as the input color for the test function, and will verify it returns black. We will write a
	// single integer in an output storage buffer as a boolean value indicating if the returned color matches the input color, to be
	// checked after the shader runs. Roughly equivalent to the following GLSL code:
	//
	//      layout(binding = 2) buffer BlockType { int values[]; } block;
	//
	//      vec4 testfun(in vec4 param);
	//
	//      void main()
	//      {
	//              vec4 in_color   = vec4(0.0, 0.0, 0.0, 1.0);
	//              vec4 out_color  = testfun(in_color);
	//              block.values[0] = int(all(equal(in_color, out_color)));
	//      }
	const tcu::StringTemplate computeShaderSwitchTemplate(R"(
					OpCapability Shader
					${capability:opt}
					${extension:opt}
					OpMemoryModel Logical GLSL450
					OpEntryPoint GLCompute %BP_main "main"
					OpExecutionMode %BP_main LocalSize 1 1 1
					${execution_mode:opt}
					${debug:opt}
					${moduleprocessed:opt}
					${IF_decoration:opt}
					${decoration:opt}
					OpDecorate %rta_i32 ArrayStride 4
					OpMemberDecorate %BlockType 0 Offset 0
					OpDecorate %BlockType BufferBlock
					OpDecorate %block DescriptorSet 0
					OpDecorate %block Binding 2
	)"
					SPIRV_ASSEMBLY_TYPES
					SPIRV_ASSEMBLY_CONSTANTS
					SPIRV_ASSEMBLY_ARRAYS
	R"(
		 %rta_i32 = OpTypeRuntimeArray %i32
	   %BlockType = OpTypeStruct %rta_i32
	%up_BlockType = OpTypePointer Uniform %BlockType
		   %block = OpVariable %up_BlockType Uniform
		%BP_color = OpConstantComposite %v4f32 %c_f32_0 %c_f32_0 %c_f32_0 %c_f32_1
					${pre_main:opt}
					${IF_variable:opt}
		  %up_i32 = OpTypePointer Uniform %i32
		 %BP_main = OpFunction %void None %voidf
   %BP_label_main = OpLabel
					${IF_carryforward:opt}
					${post_interface_op_comp:opt}
	 %BP_in_color = OpVariable %fp_v4f32 Function
	%BP_out_color = OpVariable %fp_v4f32 Function
					OpStore %BP_in_color %BP_color
		 %BP_tmp1 = OpLoad %v4f32 %BP_in_color
		 %BP_tmp2 = OpFunctionCall %v4f32 %test_code %BP_tmp1
					OpStore %BP_out_color %BP_tmp2

		 %BP_tmp3 = OpLoad %v4f32 %BP_in_color
		 %BP_tmp4 = OpLoad %v4f32 %BP_out_color
		 %BP_tmp5 = OpFOrdEqual %v4bool %BP_tmp3 %BP_tmp4
		 %BP_tmp6 = OpAll %bool %BP_tmp5
		 %BP_tmp7 = OpSelect %i32 %BP_tmp6 %c_i32_1 %c_i32_0
		 %BP_tmp8 = OpAccessChain %up_i32 %block %c_i32_0 %c_i32_0
					OpStore %BP_tmp8 %BP_tmp7

					OpReturn
					OpFunctionEnd

					${testfun}
	)");

	const StringTemplate	decoration		("OpDecorate %input DescriptorSet 0\n"
											 "OpDecorate %input Binding 0\n"
											 "OpDecorate %input NonWritable\n"
											 "OpDecorate %expectedOutput DescriptorSet 0\n"
											 "OpDecorate %expectedOutput Binding 1\n"
											 "OpDecorate %expectedOutput NonWritable\n"
											 "OpDecorate %a${num_elements}testtype ArrayStride ${typesize}\n"
											 "OpDecorate %buf BufferBlock\n"
											 "OpMemberDecorate %buf 0 Offset 0\n");

	const StringTemplate	pre_pre_main	("%fp_bool = OpTypePointer Function %bool\n"
											 "%c_u32_${num_elements} = OpConstant %u32 ${num_elements}\n"
											 "%c_i32_${num_elements} = OpConstant %i32 ${num_elements}\n");

	const StringTemplate	scalar_pre_main	("%testtype = ${scalartype}\n");

	const StringTemplate	post_pre_main	("%c_casedefault = OpConstant %${testtype} 10\n"
											 "%c_case0 = OpConstant %${testtype} 100\n"
											 "%c_case1 = OpConstant %${testtype} 110\n"
											 "%c_case2 = OpConstant %${testtype} 120\n"
											 "%fail_color = OpConstantComposite %v4f32 %c_f32_0_5 %c_f32_0_5 %c_f32_0_5 %c_f32_1\n"
											 "%a${num_elements}testtype = OpTypeArray %${testtype} %c_u32_${num_elements}\n"
											 "%up_testtype = OpTypePointer Uniform %${testtype}\n"
											 "%buf = OpTypeStruct %a${num_elements}testtype\n"
											 "%bufptr = OpTypePointer Uniform %buf\n"
											 "%input = OpVariable %bufptr Uniform\n"
											 "%expectedOutput = OpVariable %bufptr Uniform\n");

	const StringTemplate	testfun			("%test_code = OpFunction %v4f32 None %v4f32_v4f32_function\n"
											 "%param = OpFunctionParameter %v4f32\n"

											 "%entry = OpLabel\n"
											 "%counter = OpVariable %fp_i32 Function\n"
											 "%return = OpVariable %fp_v4f32 Function\n"
											 "%works = OpVariable %fp_bool Function\n"
											 "OpStore %counter %c_i32_0\n"
											 "OpStore %return %param\n"
											 "OpBranch %loop\n"

											 "%loop = OpLabel\n"
											 "%counter_val = OpLoad %i32 %counter\n"
											 "%lt = OpSLessThan %bool %counter_val %c_i32_${num_elements}\n"
											 "OpLoopMerge %loop_exit %inc None\n"
											 "OpBranchConditional %lt %load %loop_exit\n"

											 "%load = OpLabel\n"
											 "%input_loc = OpAccessChain %up_testtype %input %c_i32_0 %counter_val\n"
											 "%input_val = OpLoad %${testtype} %input_loc\n"
											 "%expectedOutput_loc = OpAccessChain %up_testtype %expectedOutput %c_i32_0 %counter_val\n"
											 "%expectedOutput_val = OpLoad %${testtype} %expectedOutput_loc\n"

											 "OpSelectionMerge %switch_exit None\n"
											 "OpSwitch %input_val %default ${case0} %case0 ${case1} %case1 ${case2} %case2\n"

											 "%default = OpLabel\n"
											 "%is_default = OpIEqual %bool %expectedOutput_val %c_casedefault\n"
											 "OpBranch %switch_exit\n"

											 "%case0 = OpLabel\n"
											 "%is_case0 = OpIEqual %bool %expectedOutput_val %c_case0\n"
											 "OpBranch %switch_exit\n"

											 "%case1 = OpLabel\n"
											 "%is_case1 = OpIEqual %bool %expectedOutput_val %c_case1\n"
											 "OpBranch %switch_exit\n"

											 "%case2 = OpLabel\n"
											 "%is_case2 = OpIEqual %bool %expectedOutput_val %c_case2\n"
											 "OpBranch %switch_exit\n"

											 "%switch_exit = OpLabel\n"
											 "%case_result = OpPhi %bool %is_default %default %is_case0 %case0 %is_case1 %case1 %is_case2 %case2\n"
											 "OpSelectionMerge %result_end None\n"
											 "OpBranchConditional %case_result %result_correct %result_incorrect\n"

											 "%result_correct = OpLabel\n"
											 "OpBranch %result_end\n"

											 "%result_incorrect = OpLabel\n"
											 "%counter_val_end = OpIAdd %i32 %counter_val %c_i32_${num_elements}\n"
											 "OpStore %counter %counter_val_end\n"
											 "OpStore %return %fail_color\n"
											 "OpBranch %result_end\n"

											 "%result_end = OpLabel\n"
											 "OpBranch %inc\n"

											 "%inc = OpLabel\n"
											 "%counter_val_next = OpIAdd %i32 %counter_val %c_i32_1\n"
											 "OpStore %counter %counter_val_next\n"
											 "OpBranch %loop\n"

											 "%loop_exit = OpLabel\n"
											 "%return_val = OpLoad %v4f32 %return\n"
											 "OpReturnValue %return_val\n"

											 "OpFunctionEnd\n");

	const bool				uses8bit		(m_inputType == TYPE_I8 || m_inputType == TYPE_U8);

	GraphicsResources		resources;
	ComputeShaderSpec		computeResources;
	RGBA					defaultColors[4];
	map<string, string>		fragments;
	map<string, string>		specs;
	std::vector<string>		noExtensions;
	std::vector<string>		features;
	VulkanFeatures			requiredFeatures;
	vector<T>				dataset;
	deUint32				numElements;
	std::string				spirvExtensions;
	std::string				spirvCapabilities;

	getDefaultColors(defaultColors);

	dataset.reserve(TEST_DATASET_SIZE);
	getDataset(dataset, TEST_DATASET_SIZE);
	numElements = fillResources(resources, computeResources, dataset);

	if (m_deviceFeature)
		features.insert(features.begin(), m_deviceFeature);

	if (uses8bit)
	{
		requiredFeatures.extFloat16Int8.shaderInt8 = true;
	}

	if (m_inputType == TYPE_I8 || m_inputType == TYPE_U8)
	{
		requiredFeatures.ext8BitStorage.storageBuffer8BitAccess = true;
		spirvExtensions						+= "OpExtension \"SPV_KHR_8bit_storage\"\n";
	}

	if (m_inputType == TYPE_I16 || m_inputType == TYPE_U16)
	{
		requiredFeatures.ext16BitStorage.storageBuffer16BitAccess = true;
		spirvExtensions						+= "OpExtension \"SPV_KHR_16bit_storage\"\n";
	}

	specs["testtype"] = m_spirvTestType;
	specs["scalartype"] = m_spirvType;
	specs["typesize"] = de::toString(m_typeSize / 8);
	specs["num_elements"] = de::toString(numElements);
	specs["case0"] = de::toString(m_cases[0]);
	specs["case1"] = de::toString(m_cases[1]);
	specs["case2"] = de::toString(m_cases[2]);

	fragments["decoration"] = decoration.specialize(specs);

	fragments["pre_main"] = pre_pre_main.specialize(specs);
	if (specs["testtype"].compare(UNDEFINED_SPIRV_TEST_TYPE) == 0)
		fragments["pre_main"] += scalar_pre_main.specialize(specs);
	fragments["pre_main"] += post_pre_main.specialize(specs);

	fragments["testfun"] = testfun.specialize(specs);

	spirvCapabilities += getSpirvCapabilityStr(m_spirvCapability, WIDTH_DEFAULT);

	fragments["extension"]	= spirvExtensions;
	fragments["capability"]	= spirvCapabilities;

	requiredFeaturesFromStrings(features, requiredFeatures);
	computeResources.requestedVulkanFeatures = requiredFeatures;

	const string testName = "switch";

	createTestsForAllStages(testName, defaultColors, defaultColors, fragments, resources, noExtensions, this, requiredFeatures);
	createComputeTest(computeResources, computeShaderSwitchTemplate, fragments, *this, testName);
}

template <class T>
void SpvAsmTypeTests<T>::getConstantDataset (vector<T> inputDataset, vector<T>& outputDataset, deUint32 spirvOperation)
{
	const deUint32 numElements = (deUint32)inputDataset.size();

	if ((SpvOpConstant == spirvOperation) || (SpvOpSpecConstant == spirvOperation))
	{
		for (deUint32 elementNdx = 0u; elementNdx < numElements; elementNdx++)
			outputDataset.push_back(inputDataset[elementNdx]);
	}
	else
	{
		for (deUint32 elementNdx = 0; elementNdx < numElements * m_vectorSize; elementNdx++)
			outputDataset.push_back(inputDataset[getConstituentIndex(elementNdx, m_vectorSize)]);
	}
}

template <class T>
void SpvAsmTypeTests<T>::finalizeFullOperation (string&			fullOperation,
												const string&	resultName,
												const bool		returnHighPart,
												const bool		isBooleanResult)
{
	DE_ASSERT(!fullOperation.empty());

	if (returnHighPart)
	{
		DE_ASSERT(sizeof(T) == sizeof(deInt16));
		DE_ASSERT((m_inputType == TYPE_I16) || (m_inputType == TYPE_U16));

		const bool		signedness		= (m_inputType == TYPE_I16);
		const string	convertOp		= signedness ? "OpSConvert" : "OpUConvert";
		const string	convertPrefix	= (m_vectorSize == 1) ? "" : "v" + de::toString(m_vectorSize);
		const string	convertType		= convertPrefix + "u32";

		// Zero extend value to double-width value, then return high part
		fullOperation += "%op_result_a = OpUConvert %" + convertType + " " + resultName + "\n";
		fullOperation += "%op_result_b = OpShiftRightLogical %" + convertType + " %op_result_a %c_shift\n";
		fullOperation += "%op_result   = " + convertOp + " %" + m_spirvTestType + " %op_result_b\n";
	}
	else if (isBooleanResult)
	{
		const string selectType = (m_vectorSize == 1) ? ("u32") : ("v" + de::toString(m_vectorSize) + "u32");

		// Convert boolean values to result format
		if (m_inputType == TYPE_U32)
		{
			fullOperation += "%op_result     = OpSelect %" + selectType + " %op_result_pre %c_one %c_zero\n";
		}
		else
		{
			fullOperation += "%op_result_u32 = OpSelect %" + selectType + " %op_result_pre %c_one %c_zero\n";

			if (m_typeSize == 32)
				fullOperation += "%op_result     = OpBitcast %" + m_spirvTestType + " %op_result_u32\n";
			else
				fullOperation += "%op_result     = OpSConvert %" + m_spirvTestType + " %op_result_u32\n";
		}
	}
	else
	{
		DE_ASSERT(resultName == "%op_result");
	}
}

template <class T>
bool SpvAsmTypeTests<T>::filterNone	(T)
{
	return true;
}

template <class T>
bool SpvAsmTypeTests<T>::filterNone (T, T)
{
	return true;
}

template <class T>
bool SpvAsmTypeTests<T>::filterNone (T, T, T)
{
	return true;
}

template <class T>
bool SpvAsmTypeTests<T>::filterNone (T, T, T, T)
{
	return true;
}

template <class T>
bool SpvAsmTypeTests<T>::filterZero	(T, T b)
{
	if (b == static_cast<T>(0))
		return false;
	else
		return true;
}

template <class T>
bool SpvAsmTypeTests<T>::filterNegativesAndZero	(T a, T b)
{
	if (a < static_cast<T>(0) || b <= static_cast<T>(0))
		return false;
	else
		return true;
}

template <class T>
bool SpvAsmTypeTests<T>::filterMinGtMax	(T, T a, T b)
{
	if (a > b)
		return false;
	else
		return true;
}

template <class T>
T SpvAsmTypeTests<T>::zero (T)
{
	return static_cast<T>(0.0);
}

template <class T>
T SpvAsmTypeTests<T>::zero (T, T)
{
	return static_cast<T>(0.0);
}

template <class T>
T SpvAsmTypeTests<T>::zero (T, T, T)
{
	return static_cast<T>(0.0);
}

template <class T>
T SpvAsmTypeTests<T>::zero (T, T, T, T)
{
	return static_cast<T>(0.0);
}

template <class T>
std::string	SpvAsmTypeTests<T>::replicate (const std::string&	replicant,
										   const deUint32		count)
{
	std::string result;

	for (deUint32 i = 0; i < count; ++i)
		result += replicant;

	return result;
}

class SpvAsmTypeInt8Tests : public SpvAsmTypeTests<deInt8>
{
public:
				SpvAsmTypeInt8Tests		(tcu::TestContext&		testCtx,
										 deUint32				vectorSize);
				~SpvAsmTypeInt8Tests	(void);
	void		getDataset				(vector<deInt8>&		input,
										 deUint32				numElements);
	void		pushResource			(vector<Resource>&		resource,
										 const vector<deInt8>&	data);
};

SpvAsmTypeInt8Tests::SpvAsmTypeInt8Tests	(tcu::TestContext&	testCtx,
											 deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "i8", "int8 tests", DE_NULL, "Int8", "OpTypeInt 8 1", TYPE_I8, 8, vectorSize)
{
	m_cases[0] = -42;
	m_cases[1] = 73;
	m_cases[2] = 121;
}

SpvAsmTypeInt8Tests::~SpvAsmTypeInt8Tests (void)
{
}

void SpvAsmTypeInt8Tests::getDataset (vector<deInt8>&	input,
									  deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);
	input.push_back(static_cast<deInt8>(deIntMinValue32(8)));// A 8-bit negative number
	input.push_back(static_cast<deInt8>(deIntMaxValue32(8)));// A 8-bit positive number

	// Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(static_cast<deInt8>(m_rnd.getUint8()));
}

void SpvAsmTypeInt8Tests::pushResource (vector<Resource>&		resource,
										const vector<deInt8>&	data)
{
	resource.push_back(Resource(BufferSp(new Int8Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeInt16Tests : public SpvAsmTypeTests<deInt16>
{
public:
				SpvAsmTypeInt16Tests	(tcu::TestContext&		testCtx,
										 deUint32				vectorSize);
				~SpvAsmTypeInt16Tests	(void);
	void		getDataset				(vector<deInt16>&		input,
										 deUint32				numElements);
	void		pushResource			(vector<Resource>&		resource,
										 const vector<deInt16>&	data);
};

SpvAsmTypeInt16Tests::SpvAsmTypeInt16Tests	(tcu::TestContext&	testCtx,
											 deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "i16", "int16 tests", "shaderInt16", "Int16", "OpTypeInt 16 1", TYPE_I16, 16, vectorSize)
{
	m_cases[0] = -3221;
	m_cases[1] = 3210;
	m_cases[2] = 19597;
}

SpvAsmTypeInt16Tests::~SpvAsmTypeInt16Tests (void)
{
}

void SpvAsmTypeInt16Tests::getDataset (vector<deInt16>&	input,
									   deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);
	input.push_back(static_cast<deInt16>(deIntMinValue32(16)));// A 16-bit negative number
	input.push_back(static_cast<deInt16>(deIntMaxValue32(16)));// A 16-bit positive number

	// Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(static_cast<deInt16>(m_rnd.getUint16()));
}

void SpvAsmTypeInt16Tests::pushResource (vector<Resource>&		resource,
										 const vector<deInt16>&	data)
{
	resource.push_back(Resource(BufferSp(new Int16Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeInt32Tests : public SpvAsmTypeTests<deInt32>
{
public:
				SpvAsmTypeInt32Tests	(tcu::TestContext&		testCtx,
										 deUint32				vectorSize);
				~SpvAsmTypeInt32Tests	(void);
	void		getDataset				(vector<deInt32>&		input,
										 deUint32				numElements);
	void		pushResource			(vector<Resource>&		resource,
										 const vector<deInt32>&	data);
};

SpvAsmTypeInt32Tests::SpvAsmTypeInt32Tests (tcu::TestContext&	testCtx,
											deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "i32", "int32 tests", DE_NULL, DE_NULL, "OpTypeInt 32 1", TYPE_I32, 32, vectorSize)
{
	m_cases[0] = -3221;
	m_cases[1] = 3210;
	m_cases[2] = 268438669;
}

SpvAsmTypeInt32Tests::~SpvAsmTypeInt32Tests (void)
{
}

void SpvAsmTypeInt32Tests::getDataset (vector<deInt32>&	input,
									   deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);
	input.push_back(deIntMinValue32(32) + 1); // So MIN = -MAX
	input.push_back(deIntMaxValue32(32));

	// Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(static_cast<deInt32>(m_rnd.getUint32()));
}

void SpvAsmTypeInt32Tests::pushResource (vector<Resource>&		resource,
										 const vector<deInt32>&	data)
{
	resource.push_back(Resource(BufferSp(new Int32Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeInt64Tests : public SpvAsmTypeTests<deInt64>
{
public:
				SpvAsmTypeInt64Tests	(tcu::TestContext&		testCtx,
										 deUint32				vectorSize);
				~SpvAsmTypeInt64Tests	(void);
	void		getDataset				(vector<deInt64>&		input,
										 deUint32				numElements);
	void		pushResource			(vector<Resource>&		resource,
										 const vector<deInt64>&	data);
};

SpvAsmTypeInt64Tests::SpvAsmTypeInt64Tests (tcu::TestContext&	testCtx,
											deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "i64", "int64 tests", "shaderInt64", "Int64", "OpTypeInt 64 1", TYPE_I64, 64, vectorSize)
{
	m_cases[0] = 3210;
	m_cases[1] = -268438669;
	m_cases[2] = 26843866939192872;
}

SpvAsmTypeInt64Tests::~SpvAsmTypeInt64Tests (void)
{
}

void SpvAsmTypeInt64Tests::getDataset (vector<deInt64>&	input,
									   deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);
	input.push_back(0xFFFF859A3BF78592);// A 64-bit negative number
	input.push_back(0x7FFF859A3BF78592);// A 64-bit positive number

	// Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(static_cast<deInt64>(m_rnd.getUint64()));
}

void SpvAsmTypeInt64Tests::pushResource	(vector<Resource>&		resource,
										 const vector<deInt64>&	data)
{
	resource.push_back(Resource(BufferSp(new Int64Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeUint8Tests : public SpvAsmTypeTests<deUint8>
{
public:
				SpvAsmTypeUint8Tests	(tcu::TestContext&		testCtx,
										 deUint32				vectorSize);
				~SpvAsmTypeUint8Tests	(void);
	void		getDataset				(vector<deUint8>&		input,
										 deUint32				numElements);
	void		pushResource			(vector<Resource>&		resource,
										 const vector<deUint8>&	data);
};

SpvAsmTypeUint8Tests::SpvAsmTypeUint8Tests	(tcu::TestContext&	testCtx,
											 deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "u8", "uint8 tests", DE_NULL, "Int8", "OpTypeInt 8 0", TYPE_U8, 8, vectorSize)
{
	m_cases[0] = 0;
	m_cases[1] = 73;
	m_cases[2] = 193;
}

SpvAsmTypeUint8Tests::~SpvAsmTypeUint8Tests (void)
{
}

void SpvAsmTypeUint8Tests::getDataset (vector<deUint8>&	input,
									   deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);  // Min value
	input.push_back(~0); // Max value

	//Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(m_rnd.getUint8());
}

void SpvAsmTypeUint8Tests::pushResource (vector<Resource>&		resource,
										 const vector<deUint8>&	data)
{
	resource.push_back(Resource(BufferSp(new Uint8Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeUint16Tests : public SpvAsmTypeTests<deUint16>
{
public:
				SpvAsmTypeUint16Tests	(tcu::TestContext&			testCtx,
										 deUint32					vectorSize);
				~SpvAsmTypeUint16Tests	(void);
	void		getDataset				(vector<deUint16>&			input,
										 deUint32					numElements);
	void		pushResource			(vector<Resource>&			resource,
										 const vector<deUint16>&	data);
};

SpvAsmTypeUint16Tests::SpvAsmTypeUint16Tests	(tcu::TestContext&	testCtx,
												 deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "u16", "uint16 tests", "shaderInt16", "Int16", "OpTypeInt 16 0", TYPE_U16, 16, vectorSize)
{
	m_cases[0] = 0;
	m_cases[1] = 3210;
	m_cases[2] = 19597;
}

SpvAsmTypeUint16Tests::~SpvAsmTypeUint16Tests (void)
{
}

void SpvAsmTypeUint16Tests::getDataset (vector<deUint16>&	input,
										deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);  // Min value
	input.push_back(~0); // Max value

	//Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(m_rnd.getUint16());
}

void SpvAsmTypeUint16Tests::pushResource (vector<Resource>&			resource,
										  const vector<deUint16>&	data)
{
	resource.push_back(Resource(BufferSp(new Uint16Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeUint32Tests : public SpvAsmTypeTests<deUint32>
{
public:
				SpvAsmTypeUint32Tests	(tcu::TestContext&			testCtx,
										 deUint32					vectorSize);
				~SpvAsmTypeUint32Tests	(void);
	void		getDataset				(vector<deUint32>&			input,
										 deUint32					numElements);
	void		pushResource			(vector<Resource>&			resource,
										 const vector<deUint32>&	data);
};

SpvAsmTypeUint32Tests::SpvAsmTypeUint32Tests (tcu::TestContext&	testCtx,
											  deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "u32", "uint32 tests", DE_NULL, DE_NULL, "OpTypeInt 32 0", TYPE_U32, 32, vectorSize)
{
	m_cases[0] = 0;
	m_cases[1] = 3210;
	m_cases[2] = 268438669;
}

SpvAsmTypeUint32Tests::~SpvAsmTypeUint32Tests (void)
{
}

void SpvAsmTypeUint32Tests::getDataset (vector<deUint32>&	input,
										deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);  // Min value
	input.push_back(~0); // Max value

	// Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(m_rnd.getUint32());
}

void SpvAsmTypeUint32Tests::pushResource (vector<Resource>&			resource,
										  const vector<deUint32>&	data)
{
	resource.push_back(Resource(BufferSp(new Uint32Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

class SpvAsmTypeUint64Tests : public SpvAsmTypeTests<deUint64>
{
public:
				SpvAsmTypeUint64Tests	(tcu::TestContext&			testCtx,
										 deUint32					vectorSize);
				~SpvAsmTypeUint64Tests	(void);
	void		getDataset				(vector<deUint64>&			input,
										 deUint32					numElements);
	void		pushResource			(vector<Resource>&			resource,
										 const vector<deUint64>&	data);
};

SpvAsmTypeUint64Tests::SpvAsmTypeUint64Tests (tcu::TestContext&	testCtx,
											  deUint32			vectorSize)
	: SpvAsmTypeTests	(testCtx, "u64", "uint64 tests", "shaderInt64", "Int64", "OpTypeInt 64 0", TYPE_U64, 64, vectorSize)
{
	m_cases[0] = 3210;
	m_cases[1] = 268438669;
	m_cases[2] = 26843866939192872;
}

SpvAsmTypeUint64Tests::~SpvAsmTypeUint64Tests (void)
{
}

void SpvAsmTypeUint64Tests::getDataset (vector<deUint64>&	input,
										deUint32			numElements)
{
	// Push first special cases
	input.push_back(0);  // Min value
	input.push_back(~0); // Max value

	// Push switch cases
	input.push_back(m_cases[0]);
	input.push_back(m_cases[1]);
	input.push_back(m_cases[2]);

	numElements -= static_cast<deUint32>(input.size());

	// Random values
	for (deUint32 elemNdx = 0; elemNdx < numElements; ++elemNdx)
		input.push_back(m_rnd.getUint64());
}

void SpvAsmTypeUint64Tests::pushResource (vector<Resource>&			resource,
										  const vector<deUint64>&	data)
{
	resource.push_back(Resource(BufferSp(new Uint64Buffer(data)), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER));
}

template <class T>
class TestMath
{
public:
	static inline T test_abs (T x)
	{
		T t0 = static_cast<T>(0.0);

		if (x >= t0)
			return x;
		else
			return test_negate(x);
	}

	static inline T test_add (T x, T y)
	{
		return static_cast<T>(x + y);
	}

	static inline T test_clamp (T x, T minVal, T maxVal)
	{
		return test_min(test_max(x, minVal), maxVal);
	}

	static inline T test_div (T x, T y)
	{
		// In SPIR-V, if "y" is 0, then the result is undefined. In our case,
		// let's return 0
		if (y == static_cast<T>(0))
			return 0;
		else
			return static_cast<T>(x / y);
	}

	static inline T test_lsb (T x)
	{
		for (deUint32 i = 0; i < 8 * sizeof(T); i++)
		{
			if (x & (1u << i))
				return static_cast<T>(i);
		}

		return static_cast<T>(-1.0);
	}

	static inline T test_max (T x, T y)
	{
		if (x < y)
			return y;
		else
			return x;
	}

	static inline T test_min (T x, T y)
	{
		if (y < x)
			return y;
		else
			return x;
	}

	static inline T test_mod (T x, T y)
	{
		T sign_x, sign_y;

		// In SPIR-V, if "y" is 0, then the result is undefined. In our case,
		// let's return 0
		if (y == static_cast<T>(0))
			return 0;

		if (x >= static_cast<T>(0))
			sign_x = 1;
		else
			sign_x = -1;

		if (y >= static_cast<T>(0))
			sign_y = 1;
		else
			sign_y = -1;

		return static_cast<T>(static_cast<T>(static_cast<T>(x) - static_cast<T>(y * static_cast<T>(x / y))) * static_cast<T>(sign_y * sign_x));
	}

	static inline T test_mul (T x, T y)
	{
		return static_cast<T>(x * y);
	}

	static inline T test_negate (T x)
	{
		return static_cast<T>(static_cast<T>(0.0) - static_cast<T>(x));
	}

	static inline T test_rem (T x, T y)
	{
		// In SPIR-V, if "y" is 0, then the result is undefined. In our case,
		// let's return 0
		if (y == static_cast<T>(0))
			return 0;

		return static_cast<T>(x % y);
	}

	static inline T test_sign (T x)
	{
		T t0 = static_cast<T>(0.0);

		if (x > t0)
			return static_cast<T>(1.0);
		else if (x < t0)
			return static_cast<T>(-1.0);
		else
			return t0;
	}

	static inline T test_sub (T x, T y)
	{
		return static_cast<T>(x - y);
	}

	static inline T test_msb (T)
	{
		TCU_THROW(InternalError, "Not implemented");
	}

	static inline T test_lsr (T x, T y)
	{
		if (x >= static_cast<T>(0) || y == static_cast<T>(0))
		{
			return static_cast<T>(x >> y);
		}
		else
		{
			const T	mask = de::leftZeroMask(y);
			return static_cast<T>((x >> y) & mask);
		}
	}

	static inline T test_asr (T x, T y)
	{
		const T bitmask = static_cast<T>(deUint64(1) << (sizeof(T) * 8u - 1u));

		if ((x & bitmask) && y > 0)
		{
			const T	mask	= de::leftSetMask(y);
			const T	result	= static_cast<T>((x >> y) | mask);
			return result;
		}
		else
		{
			return static_cast<T>(x >> y);
		}
	}

	static inline T test_lsl (T x, T y)
	{
		return static_cast<T>(x << y);
	}

	static inline T test_bitwise_or (T x, T y)
	{
		return static_cast<T>(x | y);
	}

	static inline T test_bitwise_xor (T x, T y)
	{
		return static_cast<T>(x ^ y);
	}

	static inline T test_bitwise_and (T x, T y)
	{
		return static_cast<T>(x & y);
	}

	static inline T test_not (T x)
	{
		return static_cast<T>(~x);
	}

	static inline T test_iequal (T x, T y)
	{
		if (x == y)
			return static_cast<T>(1);
		else
			return static_cast<T>(0);
	}

	static inline T test_inotequal (T x, T y)
	{
		if (x != y)
			return static_cast<T>(1);
		else
			return static_cast<T>(0);
	}

	static inline T test_ugreaterthan (T x, T y)
	{
		if (x > y)
			return static_cast<T>(1);
		else
			return static_cast<T>(0);
	}

	static inline T test_ulessthan (T x, T y)
	{
		return test_ugreaterthan(y, x);
	}

	static inline T test_sgreaterthan (T x, T y)
	{
		if (x > y)
			return static_cast<T>(1);
		else
			return static_cast<T>(0);
	}

	static inline T test_slessthan (T x, T y)
	{
		return test_sgreaterthan(y, x);
	}

	static inline T test_ugreaterthanequal (T x, T y)
	{
		if (x >= y)
			return static_cast<T>(1);
		else
			return static_cast<T>(0);
	}

	static inline T test_ulessthanequal (T x, T y)
	{
		return test_ugreaterthanequal(y, x);
	}

	static inline T test_sgreaterthanequal (T x, T y)
	{
		if (x >= y)
			return static_cast<T>(1);
		else
			return static_cast<T>(0);
	}

	static inline T test_slessthanequal (T x, T y)
	{
		return test_sgreaterthanequal(y, x);
	}

	static inline T test_bitFieldInsert (T base, T insert, T offset, T count)
	{
		const T	insertMask	= de::rightSetMask(count);

		return static_cast<T>((base & ~(insertMask << offset)) | ((insert & insertMask) << offset));
	}

	static inline T test_bitFieldSExtract (T x, T y, T z)
	{
		const T allZeros	= static_cast<T>(0);

		// Count can be 0, in which case the result will be 0
		if (z == allZeros)
			return allZeros;

		const T extractMask	= de::rightSetMask(z);
		const T signBit		= static_cast<T>(x & (1 << (y + z - 1)));
		const T signMask	= static_cast<T>(signBit ? ~extractMask : allZeros);

		return static_cast<T>((signMask & ~extractMask) | ((x >> y) & extractMask));
	}

	static inline T test_bitFieldUExtract (T x, T y, T z)
	{
		const T allZeros	= (static_cast<T>(0));

		// Count can be 0, in which case the result will be 0
		if (z == allZeros)
			return allZeros;

		const T extractMask	= de::rightSetMask(z);

		return static_cast<T>((x >> y) & extractMask);
	}

	static inline T test_bitReverse (T x)
	{
		T		base	= x;
		T		result	= static_cast<T>(0);

		for (size_t bitNdx = 0u; bitNdx < sizeof(T) * 8u; bitNdx++)
		{
			result = static_cast<T>(result << 1) | (base & 1);
			base >>= 1;
		}

		return result;
	}

	static inline T test_bitCount (T x)
	{
		T count	= static_cast<T>(0);

		for (deUint32 bitNdx = 0u; bitNdx < (deUint32)sizeof(T) * 8u; bitNdx++)
			if (x & (static_cast<T>(1) << bitNdx))
				count++;

		return count;
	}

	static inline T test_constant (T a)
	{
		return a;
	}
};

class TestMathInt8 : public TestMath<deInt8>
{
public:
	static inline deInt8 test_msb (deInt8 x)
	{
		if (x > 0)
			return static_cast<deInt8>(7 - deClz32((deUint32)x));
		else if (x < 0)
			return static_cast<deInt8>(7 - deClz32(~(deUint32)x));
		else
			return -1;
	}

	static inline deInt8 test_mul_div (deInt8 x, deInt8 y)
	{
		deInt32	x32	= static_cast<deInt32>(x);
		deInt32	y32	= static_cast<deInt32>(y);

		// In SPIR-V, if "y" is 0, then the result is undefined. In our case, let's return 0
		if (y == static_cast<deInt8>(0))
			return 0;
		else
			return static_cast<deInt8>(static_cast<deInt8>(x32 * y32) / y32);
	}

	static inline deInt8 test_ugreaterthan (deInt8 x, deInt8 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x80) ^ (y & 0x80))
			std::swap(x,y);

		if (x > y)
			return static_cast<deInt8>(1);
		else
			return static_cast<deInt8>(0);
	}

	static inline deInt8 test_ulessthan (deInt8 x, deInt8 y)
	{
		return test_ugreaterthan(y, x);
	}

	static inline deInt8 test_ugreaterthanequal (deInt8 x, deInt8 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x80) ^ (y & 0x80))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deInt8>(1);
		else
			return static_cast<deInt8>(0);
	}

	static inline deInt8 test_ulessthanequal (deInt8 x, deInt8 y)
	{
		return test_ugreaterthanequal(y, x);
	}
};

class TestMathInt16 : public TestMath<deInt16>
{
public:
	static inline deInt16 test_msb (deInt16 x)
	{
		if (x > 0)
			return static_cast<deInt16>(15 - deClz32((deUint32)x));
		else if (x < 0)
			return static_cast<deInt16>(15 - deClz32(~(deUint32)x));
		else
			return -1;
	}

	static inline deInt16 test_mul_div (deInt16 x, deInt16 y)
	{
		deInt32	x32	= static_cast<deInt32>(x);
		deInt32	y32	= static_cast<deInt32>(y);

		// In SPIR-V, if "y" is 0, then the result is undefined. In our case, let's return 0
		if (y == static_cast<deInt16>(0))
			return 0;
		else
			return static_cast<deInt16>(static_cast<deInt16>(x32 * y32) / y32);
	}

	static inline deInt16 test_ugreaterthan (deInt16 x, deInt16 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x8000) ^ (y & 0x8000))
			std::swap(x,y);

		if (x > y)
			return static_cast<deInt16>(1);
		else
			return static_cast<deInt16>(0);
	}

	static inline deInt16 test_ulessthan (deInt16 x, deInt16 y)
	{
		return test_ugreaterthan(y, x);
	}

	static inline deInt16 test_ugreaterthanequal (deInt16 x, deInt16 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x8000) ^ (y & 0x8000))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deInt16>(1);
		else
			return static_cast<deInt16>(0);
	}

	static inline deInt16 test_ulessthanequal (deInt16 x, deInt16 y)
	{
		return test_ugreaterthanequal(y, x);
	}
};

class TestMathInt32 : public TestMath<deInt32>
{
public:
	static inline deInt32 test_msb (deInt32 x)
	{
		if (x > 0)
			return 31 - deClz32((deUint32)x);
		else if (x < 0)
			return 31 - deClz32(~(deUint32)x);
		else
			return -1;
	}

	static inline deInt32 test_ugreaterthan (deInt32 x, deInt32 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x80000000) ^ (y & 0x80000000))
			std::swap(x,y);

		if (x > y)
			return static_cast<deInt32>(1);
		else
			return static_cast<deInt32>(0);
	}

	static inline deInt32 test_ulessthan (deInt32 x, deInt32 y)
	{
		return test_ugreaterthan(y, x);
	}

	static inline deInt32 test_ugreaterthanequal (deInt32 x, deInt32 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x80000000) ^ (y & 0x80000000))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deInt32>(1);
		else
			return static_cast<deInt32>(0);
	}

	static inline deInt32 test_ulessthanequal (deInt32 x, deInt32 y)
	{
		return test_ugreaterthanequal(y, x);
	}
};

class TestMathInt64 : public TestMath<deInt64>
{
public:
	static inline deInt64 test_ugreaterthan (deInt64 x, deInt64 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x8000000000000000) ^ (y & 0x8000000000000000))
			std::swap(x,y);

		if (x > y)
			return static_cast<deInt64>(1);
		else
			return static_cast<deInt64>(0);
	}

	static inline deInt64 test_ulessthan (deInt64 x, deInt64 y)
	{
		return test_ugreaterthan(y, x);
	}

	static inline deInt64 test_ugreaterthanequal (deInt64 x, deInt64 y)
	{
		// Consume signed integers as unsigned integers
		if ((x & 0x8000000000000000) ^ (y & 0x8000000000000000))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deInt64>(1);
		else
			return static_cast<deInt64>(0);
	}

	static inline deInt64 test_ulessthanequal (deInt64 x, deInt64 y)
	{
		return test_ugreaterthanequal(y, x);
	}
};

class TestMathUint8 : public TestMath<deUint8>
{
public:
	static inline deUint32 test_msb (deUint8 x)
	{
		if (x > 0)
			return 7 - deClz32((deUint32)x);
		else
			return -1;
	}

	static inline deUint8 test_mul_div (deUint8 x, deUint8 y)
	{
		const deUint32 x32 = static_cast<deUint32>(x);
		const deUint32 y32 = static_cast<deUint32>(y);

		// In SPIR-V, if "y" is 0, then the result is undefined. In our case, let's return 0
		if (y == static_cast<deUint8>(0))
			return 0;
		else
			return static_cast<deUint8>(static_cast<deUint8>(x32 * y32) / y32);
	}

	static inline deUint8 test_sgreaterthan (deUint8 x, deUint8 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x80) ^ (y & 0x80))
			std::swap(x,y);

		if (x > y)
			return static_cast<deUint8>(1);
		else
			return static_cast<deUint8>(0);
	}

	static inline deUint8 test_slessthan (deUint8 x, deUint8 y)
	{
		return test_sgreaterthan(y, x);
	}

	static inline deUint8 test_sgreaterthanequal (deUint8 x, deUint8 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x80) ^ (y & 0x80))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deUint8>(1);
		else
			return static_cast<deUint8>(0);
	}

	static inline deUint8 test_slessthanequal (deUint8 x, deUint8 y)
	{
		return test_sgreaterthanequal(y, x);
	}
};

class TestMathUint16 : public TestMath<deUint16>
{
public:
	static inline deUint32 test_msb (deUint16 x)
	{
		if (x > 0)
			return 15 - deClz32((deUint32)x);
		else
			return -1;
	}

	static inline deUint16 test_mul_div (deUint16 x, deUint16 y)
	{
		const deUint32 x32 = static_cast<deUint32>(x);
		const deUint32 y32 = static_cast<deUint32>(y);

		// In SPIR-V, if "y" is 0, then the result is undefined. In our case, let's return 0
		if (y == static_cast<deUint16>(0))
			return 0;
		else
			return static_cast<deUint16>(static_cast<deUint16>(x32 * y32) / y32);
	}

	static inline deUint16 test_sgreaterthan (deUint16 x, deUint16 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x8000) ^ (y & 0x8000))
			std::swap(x,y);

		if (x > y)
			return static_cast<deUint16>(1);
		else
			return static_cast<deUint16>(0);
	}

	static inline deUint16 test_slessthan (deUint16 x, deUint16 y)
	{
		return test_sgreaterthan(y, x);
	}

	static inline deUint16 test_sgreaterthanequal (deUint16 x, deUint16 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x8000) ^ (y & 0x8000))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deUint16>(1);
		else
			return static_cast<deUint16>(0);
	}

	static inline deUint16 test_slessthanequal (deUint16 x, deUint16 y)
	{
		return test_sgreaterthanequal(y, x);
	}
};

class TestMathUint32 : public TestMath<deUint32>
{
public:
	static inline deUint32 test_msb (deUint32 x)
	{
		if (x > 0)
			return 31 - deClz32(x);
		else
			return -1;
	}

	static inline deUint32 test_sgreaterthan (deUint32 x, deUint32 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x80000000) ^ (y & 0x80000000))
			std::swap(x,y);

		if (x > y)
			return static_cast<deUint32>(1);
		else
			return static_cast<deUint32>(0);
	}

	static inline deUint32 test_slessthan (deUint32 x, deUint32 y)
	{
		return test_sgreaterthan(y, x);
	}

	static inline deUint32 test_sgreaterthanequal (deUint32 x, deUint32 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x80000000) ^ (y & 0x80000000))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deUint32>(1);
		else
			return static_cast<deUint32>(0);
	}

	static inline deUint32 test_slessthanequal (deUint32 x, deUint32 y)
	{
		return test_sgreaterthanequal(y, x);
	}

};

class TestMathUint64 : public TestMath<deUint64>
{
public:
	static inline deUint64 test_sgreaterthan (deUint64 x, deUint64 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x8000000000000000) ^ (y & 0x8000000000000000))
			std::swap(x,y);

		if (x > y)
			return static_cast<deUint64>(1);
		else
			return static_cast<deUint64>(0);
	}

	static inline deUint64 test_slessthan (deUint64 x, deUint64 y)
	{
		return test_sgreaterthan(y, x);
	}

	static inline deUint64 test_sgreaterthanequal (deUint64 x, deUint64 y)
	{
		// Consume unsigned integers as signed integers
		if ((x & 0x8000000000000000) ^ (y & 0x8000000000000000))
			std::swap(x,y);

		if (x >= y)
			return static_cast<deUint64>(1);
		else
			return static_cast<deUint64>(0);
	}

	static inline deUint64 test_slessthanequal (deUint64 x, deUint64 y)
	{
		return test_sgreaterthanequal(y, x);
	}
};

#define I8_FILTER_NONE SpvAsmTypeInt8Tests::filterNone
#define I16_FILTER_NONE SpvAsmTypeInt16Tests::filterNone
#define I32_FILTER_NONE SpvAsmTypeInt32Tests::filterNone
#define I64_FILTER_NONE SpvAsmTypeInt64Tests::filterNone
#define U8_FILTER_NONE SpvAsmTypeUint8Tests::filterNone
#define U16_FILTER_NONE SpvAsmTypeUint16Tests::filterNone
#define U32_FILTER_NONE SpvAsmTypeUint32Tests::filterNone
#define U64_FILTER_NONE SpvAsmTypeUint64Tests::filterNone

#define I8_FILTER_ZERO SpvAsmTypeInt8Tests::filterZero
#define I16_FILTER_ZERO SpvAsmTypeInt16Tests::filterZero
#define I32_FILTER_ZERO SpvAsmTypeInt32Tests::filterZero
#define I64_FILTER_ZERO SpvAsmTypeInt64Tests::filterZero
#define U8_FILTER_ZERO SpvAsmTypeUint8Tests::filterZero
#define U16_FILTER_ZERO SpvAsmTypeUint16Tests::filterZero
#define U32_FILTER_ZERO SpvAsmTypeUint32Tests::filterZero
#define U64_FILTER_ZERO SpvAsmTypeUint64Tests::filterZero

#define I8_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeInt8Tests::filterNegativesAndZero
#define I16_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeInt16Tests::filterNegativesAndZero
#define I32_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeInt32Tests::filterNegativesAndZero
#define I64_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeInt64Tests::filterNegativesAndZero
#define U8_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeUint8Tests::filterNegativesAndZero
#define U16_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeUint16Tests::filterNegativesAndZero
#define U32_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeUint32Tests::filterNegativesAndZero
#define U64_FILTER_NEGATIVES_AND_ZERO SpvAsmTypeUint64Tests::filterNegativesAndZero

#define I8_FILTER_MIN_GT_MAX SpvAsmTypeInt8Tests::filterMinGtMax
#define I16_FILTER_MIN_GT_MAX SpvAsmTypeInt16Tests::filterMinGtMax
#define I32_FILTER_MIN_GT_MAX SpvAsmTypeInt32Tests::filterMinGtMax
#define I64_FILTER_MIN_GT_MAX SpvAsmTypeInt64Tests::filterMinGtMax
#define U8_FILTER_MIN_GT_MAX SpvAsmTypeUint8Tests::filterMinGtMax
#define U16_FILTER_MIN_GT_MAX SpvAsmTypeUint16Tests::filterMinGtMax
#define U32_FILTER_MIN_GT_MAX SpvAsmTypeUint32Tests::filterMinGtMax
#define U64_FILTER_MIN_GT_MAX SpvAsmTypeUint64Tests::filterMinGtMax

const string bitShiftTestPostfix[] =
{
	"_shift8",
	"_shift16",
	"_shift32",
	"_shift64"
};

const string bitFieldTestPostfix[] =
{
	"_offset8_count8",
	"_offset8_count16",
	"_offset8_count32",
	"_offset8_count64",
	"_offset16_count8",
	"_offset16_count16",
	"_offset16_count32",
	"_offset16_count64",
	"_offset32_count8",
	"_offset32_count16",
	"_offset32_count32",
	"_offset32_count64",
	"_offset64_count8",
	"_offset64_count16",
	"_offset64_count32",
	"_offset64_count64",
};

// Macro to create tests.
// Syntax: MAKE_TEST_{S,V}_{I,U}_{8,1,3,6}
//
//  'S': create scalar test
//  'V': create vector test
//
//  'I': create integer test
//  'U': create unsigned integer test
//
//  '8': create 8-bit test
//  '1': create 16-bit test
//  '3': create 32-bit test
//  '6': create 64-bit test
//
//  'W': bit width of some parameters in bit field and shift operations can be different from Result and Base
//  'N': create 16-bit tests without 'test_high_part_zero' variants

#define MAKE_TEST_S_I_8136(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 1; ++ndx) \
	{ \
		int8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt8::test_##op, I8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
		int32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt64::test_##op, I64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_V_I_8136(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 1; ndx < 4; ++ndx) \
	{ \
		int8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt8::test_##op, I8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
		int32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt64::test_##op, I64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_SV_I_8136(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	{ \
		int8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt8::test_##op, I8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
		int32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt64::test_##op, I64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_SV_I_8136_N(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	{ \
		int8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt8::test_##op, I8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt64::test_##op, I64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_SV_I_8136_W(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	for (deUint32 widthNdx = 0; widthNdx < DE_LENGTH_OF_ARRAY(bitShiftTestPostfix); ++widthNdx) \
	{ \
		const InputWidth inputWidth = static_cast<InputWidth>(WIDTH_8 + widthNdx); \
		\
		int8Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathInt8::test_##op, I8_##filter, inputRange, inputWidth, (extension)); \
		int16Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, inputWidth, (extension)); \
		int16Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx] + "_test_high_part_zero").c_str(), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, inputWidth, (extension), true); \
		int32Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, inputWidth, (extension)); \
		int64Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathInt64::test_##op, I64_##filter, inputRange, inputWidth, (extension)); \
	} \

#define MAKE_TEST_SV_I_1(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	{ \
		int16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		int16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathInt16::test_##op, I16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
	} \

#define MAKE_TEST_SV_I_3(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
		int32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \

#define MAKE_TEST_SV_I_3_W(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	for (deUint32 width = 0; width < DE_LENGTH_OF_ARRAY(bitFieldTestPostfix); ++width) \
	{ \
		int32Tests[ndx]->createTests(string(name + bitFieldTestPostfix[width]).c_str(), (spirvOp), \
			TestMathInt32::test_##op, I32_##filter, inputRange, InputWidth(WIDTH_8_8 + width), (extension)); \
	} \

#define MAKE_TEST_S_U_8136(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 1; ++ndx) \
	{ \
		uint8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint8::test_##op, U8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
		uint32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint64::test_##op, U64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_V_U_8136(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 1; ndx < 4; ++ndx) \
	{ \
		uint16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
		uint32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint64::test_##op, U64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_SV_U_8136(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	{ \
		uint8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint8::test_##op, U8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
		uint32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint64::test_##op, U64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_SV_U_8136_N(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	{ \
		uint8Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint8::test_##op, U8_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint64Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint64::test_##op, U64_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
	} \

#define MAKE_TEST_SV_U_8136_W(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	for (deUint32 widthNdx = 0; widthNdx < DE_LENGTH_OF_ARRAY(bitShiftTestPostfix); ++widthNdx) \
	{ \
		const InputWidth inputWidth = static_cast<InputWidth>(WIDTH_8 + widthNdx); \
		\
		uint8Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathUint8::test_##op, U8_##filter, inputRange, inputWidth, (extension)); \
		uint16Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, inputWidth, (extension)); \
		uint16Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx] + "_test_high_part_zero").c_str(), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, inputWidth, (extension), true); \
		uint32Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, inputWidth, (extension)); \
		uint64Tests[ndx]->createTests(string(name + bitShiftTestPostfix[widthNdx]).c_str(), (spirvOp), \
			TestMathUint64::test_##op, U64_##filter, inputRange, inputWidth, (extension)); \
	} \

#define MAKE_TEST_SV_U_1(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	{ \
		uint16Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension)); \
		uint16Tests[ndx]->createTests((name "_test_high_part_zero"), (spirvOp), \
			TestMathUint16::test_##op, U16_##filter, inputRange, WIDTH_DEFAULT, (extension), true); \
	} \

#define MAKE_TEST_SV_U_3(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
		uint32Tests[ndx]->createTests((name), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, WIDTH_DEFAULT, (extension)); \

#define MAKE_TEST_SV_U_3_W(name, spirvOp, op, filter, inputRange, extension) \
	for (deUint32 ndx = 0; ndx < 4; ++ndx) \
	for (deUint32 width = 0; width < DE_LENGTH_OF_ARRAY(bitFieldTestPostfix); ++width) \
	{ \
		uint32Tests[ndx]->createTests(string(name + bitFieldTestPostfix[width]).c_str(), (spirvOp), \
			TestMathUint32::test_##op, U32_##filter, inputRange, InputWidth(WIDTH_8_8 + width), (extension)); \
	} \

tcu::TestCaseGroup* createTypeTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup>		typeTests			(new tcu::TestCaseGroup(testCtx, "type", "Test types"));
	de::MovePtr<tcu::TestCaseGroup>		typeScalarTests		(new tcu::TestCaseGroup(testCtx, "scalar", "scalar tests"));
	de::MovePtr<tcu::TestCaseGroup>		typeVectorTests[3];

	de::MovePtr<SpvAsmTypeInt8Tests>	int8Tests[4];
	de::MovePtr<SpvAsmTypeInt16Tests>	int16Tests[4];
	de::MovePtr<SpvAsmTypeInt32Tests>	int32Tests[4];
	de::MovePtr<SpvAsmTypeInt64Tests>	int64Tests[4];
	de::MovePtr<SpvAsmTypeUint8Tests>	uint8Tests[4];
	de::MovePtr<SpvAsmTypeUint16Tests>	uint16Tests[4];
	de::MovePtr<SpvAsmTypeUint32Tests>	uint32Tests[4];
	de::MovePtr<SpvAsmTypeUint64Tests>	uint64Tests[4];

	for (deUint32 ndx = 0; ndx < 3; ++ndx)
	{
		std::string testName = "vec" + de::toString(ndx + 2);
		typeVectorTests[ndx] = de::MovePtr<tcu::TestCaseGroup>(new tcu::TestCaseGroup(testCtx, testName.c_str(), "vector tests"));
	}

	for (deUint32 ndx = 0; ndx < 4; ++ndx)
	{
		int8Tests[ndx]		= de::MovePtr<SpvAsmTypeInt8Tests>(new SpvAsmTypeInt8Tests(testCtx, ndx + 1));
		int16Tests[ndx]		= de::MovePtr<SpvAsmTypeInt16Tests>(new SpvAsmTypeInt16Tests(testCtx, ndx + 1));
		int32Tests[ndx]		= de::MovePtr<SpvAsmTypeInt32Tests>(new SpvAsmTypeInt32Tests(testCtx, ndx + 1));
		int64Tests[ndx]		= de::MovePtr<SpvAsmTypeInt64Tests>(new SpvAsmTypeInt64Tests(testCtx, ndx + 1));
		uint8Tests[ndx]		= de::MovePtr<SpvAsmTypeUint8Tests>(new SpvAsmTypeUint8Tests(testCtx, ndx + 1));
		uint16Tests[ndx]	= de::MovePtr<SpvAsmTypeUint16Tests>(new SpvAsmTypeUint16Tests(testCtx, ndx + 1));
		uint32Tests[ndx]	= de::MovePtr<SpvAsmTypeUint32Tests>(new SpvAsmTypeUint32Tests(testCtx, ndx + 1));
		uint64Tests[ndx]	= de::MovePtr<SpvAsmTypeUint64Tests>(new SpvAsmTypeUint64Tests(testCtx, ndx + 1));
	}

	MAKE_TEST_SV_I_8136("negate", SpvOpSNegate, negate, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("add", SpvOpIAdd, add, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("sub", SpvOpISub, sub, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("mul", SpvOpIMul, mul, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("div", SpvOpSDiv, div, FILTER_ZERO, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136("div", SpvOpUDiv, div, FILTER_ZERO, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("rem", SpvOpSRem, rem, FILTER_NEGATIVES_AND_ZERO, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("mod", SpvOpSMod, mod, FILTER_NEGATIVES_AND_ZERO, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136("mod", SpvOpUMod, mod, FILTER_ZERO, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("abs", GLSLstd450SAbs, abs, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_8136("sign", GLSLstd450SSign, sign, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_8136("min", GLSLstd450SMin, min, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_U_8136("min", GLSLstd450UMin, min, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_8136("max", GLSLstd450SMax, max, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_U_8136("max", GLSLstd450UMax, max, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_8136("clamp", GLSLstd450SClamp, clamp, FILTER_MIN_GT_MAX, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_U_8136("clamp", GLSLstd450UClamp, clamp, FILTER_MIN_GT_MAX, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_3("find_lsb", GLSLstd450FindILsb, lsb, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_3("find_msb", GLSLstd450FindSMsb, msb, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_U_3("find_msb", GLSLstd450FindUMsb, msb, FILTER_NONE, RANGE_FULL, "GLSL.std.450")
	MAKE_TEST_SV_I_1("mul_sdiv", DE_NULL, mul_div, FILTER_ZERO, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_1("mul_udiv", DE_NULL, mul_div, FILTER_ZERO, RANGE_FULL, DE_NULL)

	MAKE_TEST_SV_U_8136_W("shift_right_logical", SpvOpShiftRightLogical, lsr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
	MAKE_TEST_SV_I_8136_W("shift_right_logical", SpvOpShiftRightLogical, lsr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
	MAKE_TEST_SV_U_8136_W("shift_right_arithmetic", SpvOpShiftRightArithmetic, asr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
	MAKE_TEST_SV_I_8136_W("shift_right_arithmetic", SpvOpShiftRightArithmetic, asr, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
	MAKE_TEST_SV_U_8136_W("shift_left_logical", SpvOpShiftLeftLogical, lsl, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)
	MAKE_TEST_SV_I_8136_W("shift_left_logical", SpvOpShiftLeftLogical, lsl, FILTER_NONE, RANGE_BIT_WIDTH, DE_NULL)

	MAKE_TEST_SV_U_8136("bitwise_or", SpvOpBitwiseOr, bitwise_or, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("bitwise_or", SpvOpBitwiseOr, bitwise_or , FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136("bitwise_xor", SpvOpBitwiseXor, bitwise_xor, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("bitwise_xor", SpvOpBitwiseXor, bitwise_xor, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136("bitwise_and", SpvOpBitwiseAnd, bitwise_and, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("bitwise_and", SpvOpBitwiseAnd, bitwise_and, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136("not", SpvOpNot, not, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("not", SpvOpNot, not, FILTER_NONE, RANGE_FULL, DE_NULL)

	MAKE_TEST_SV_U_8136_N("iequal", SpvOpIEqual, iequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("iequal", SpvOpIEqual, iequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("inotequal", SpvOpINotEqual, inotequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("inotequal", SpvOpINotEqual, inotequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("ugreaterthan", SpvOpUGreaterThan, ugreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("ugreaterthan", SpvOpUGreaterThan, ugreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("sgreaterthan", SpvOpSGreaterThan, sgreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("sgreaterthan", SpvOpSGreaterThan, sgreaterthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("ugreaterthanequal", SpvOpUGreaterThanEqual, ugreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("ugreaterthanequal", SpvOpUGreaterThanEqual, ugreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("sgreaterthanequal", SpvOpSGreaterThanEqual, sgreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("sgreaterthanequal", SpvOpSGreaterThanEqual, sgreaterthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("ulessthan", SpvOpULessThan, ulessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("ulessthan", SpvOpULessThan, ulessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("slessthan", SpvOpSLessThan, slessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("slessthan", SpvOpSLessThan, slessthan, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("ulessthanequal", SpvOpULessThanEqual, ulessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("ulessthanequal", SpvOpULessThanEqual, ulessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136_N("slessthanequal", SpvOpSLessThanEqual, slessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136_N("slessthanequal", SpvOpSLessThanEqual, slessthanequal, FILTER_NONE, RANGE_FULL, DE_NULL)

	MAKE_TEST_SV_U_3_W("bit_field_insert", SpvOpBitFieldInsert, bitFieldInsert, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
	MAKE_TEST_SV_I_3_W("bit_field_insert", SpvOpBitFieldInsert, bitFieldInsert, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
	MAKE_TEST_SV_U_3_W("bit_field_s_extract", SpvOpBitFieldSExtract, bitFieldSExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
	MAKE_TEST_SV_I_3_W("bit_field_s_extract", SpvOpBitFieldSExtract, bitFieldSExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
	MAKE_TEST_SV_U_3_W("bit_field_u_extract", SpvOpBitFieldUExtract, bitFieldUExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
	MAKE_TEST_SV_I_3_W("bit_field_u_extract", SpvOpBitFieldUExtract, bitFieldUExtract, FILTER_NONE, RANGE_BIT_WIDTH_SUM, DE_NULL)
	MAKE_TEST_SV_U_3("bit_reverse", SpvOpBitReverse, bitReverse, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_3("bit_reverse", SpvOpBitReverse, bitReverse, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_3("bit_count", SpvOpBitCount, bitCount, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_3("bit_count", SpvOpBitCount, bitCount, FILTER_NONE, RANGE_FULL, DE_NULL)

	MAKE_TEST_S_U_8136("constant", SpvOpConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_S_I_8136("constant", SpvOpConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_V_U_8136("constant_composite", SpvOpConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_V_I_8136("constant_composite", SpvOpConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_V_U_8136("constant_null", SpvOpConstantNull, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_V_I_8136("constant_null", SpvOpConstantNull, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_U_8136("variable_initializer", SpvOpVariable, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_SV_I_8136("variable_initializer", SpvOpVariable, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_S_U_8136("spec_constant_initializer", SpvOpSpecConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_S_I_8136("spec_constant_initializer", SpvOpSpecConstant, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_V_U_8136("spec_constant_composite_initializer", SpvOpSpecConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)
	MAKE_TEST_V_I_8136("spec_constant_composite_initializer", SpvOpSpecConstantComposite, constant, FILTER_NONE, RANGE_FULL, DE_NULL)

	int8Tests[0]->createSwitchTests();
	int16Tests[0]->createSwitchTests();
	int32Tests[0]->createSwitchTests();
	int64Tests[0]->createSwitchTests();
	uint8Tests[0]->createSwitchTests();
	uint16Tests[0]->createSwitchTests();
	uint32Tests[0]->createSwitchTests();
	uint64Tests[0]->createSwitchTests();

	typeScalarTests->addChild(int8Tests[0].release());
	typeScalarTests->addChild(int16Tests[0].release());
	typeScalarTests->addChild(int32Tests[0].release());
	typeScalarTests->addChild(int64Tests[0].release());
	typeScalarTests->addChild(uint8Tests[0].release());
	typeScalarTests->addChild(uint16Tests[0].release());
	typeScalarTests->addChild(uint32Tests[0].release());
	typeScalarTests->addChild(uint64Tests[0].release());

	typeTests->addChild(typeScalarTests.release());

	for (deUint32 ndx = 0; ndx < 3; ++ndx)
	{
		typeVectorTests[ndx]->addChild(int8Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(int16Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(int32Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(int64Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(uint8Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(uint16Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(uint32Tests[ndx + 1].release());
		typeVectorTests[ndx]->addChild(uint64Tests[ndx + 1].release());

		typeTests->addChild(typeVectorTests[ndx].release());
	}

	return typeTests.release();
}

} // SpirVAssembly
} // vkt