/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Attribute location tests
 *//*--------------------------------------------------------------------*/

#include "glsAttributeLocationTests.hpp"

#include "tcuStringTemplate.hpp"
#include "tcuTestLog.hpp"

#include "gluDefs.hpp"
#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluShaderUtil.hpp"
#include "gluStrUtil.hpp"

#include "glwFunctions.hpp"

#include "deStringUtil.hpp"

#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>

#include <cstring>

#include "glw.h"

using tcu::TestLog;

using std::string;
using std::vector;
using std::set;
using std::map;
using std::pair;

using namespace deqp::gls::AttributeLocationTestUtil;

namespace deqp
{
namespace gls
{
namespace
{

deInt32 getBoundLocation (const map<string, deUint32>& bindings, const string& attrib)
{
	std::map<string, deUint32>::const_iterator iter = bindings.find(attrib);

	return (iter == bindings.end() ? (deInt32)Attribute::LOC_UNDEF : iter->second);
}

bool hasAttributeAliasing (const vector<Attribute>& attributes, const map<string, deUint32>& bindings)
{
	vector<bool> reservedSpaces;

	for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++)
	{
		const deInt32	location	= getBoundLocation(bindings, attributes[attribNdx].getName());
		const deUint32	size		= attributes[attribNdx].getType().getLocationSize();

		if (location != Attribute::LOC_UNDEF)
		{
			if (reservedSpaces.size() < location + size)
				reservedSpaces.resize(location + size, false);

			for (int i = 0; i < (int)size; i++)
			{
				if (reservedSpaces[location + i])
					return true;

				reservedSpaces[location + i] = true;
			}
		}
	}

	return false;
}

deInt32 getMaxAttributeLocations (glu::RenderContext& renderCtx)
{
	const glw::Functions& gl = renderCtx.getFunctions();
	deInt32 maxAttribs;

	gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttribs);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv()");

	return maxAttribs;
}

string generateAttributeDefinitions (const vector<Attribute>& attributes)
{
	std::ostringstream src;

	for (vector<Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
	{
		if (iter->getLayoutLocation() != Attribute::LOC_UNDEF)
			src << "layout(location = " << iter->getLayoutLocation() << ") ";

		src << "${VTX_INPUT} mediump "
			<< iter->getType().getName() << " "
			<< iter->getName()
			<<  (iter->getArraySize() != Attribute::NOT_ARRAY ? "[" + de::toString(iter->getArraySize()) + "]" : "") << ";\n";
	}

	return src.str();
}

string generateConditionUniformDefinitions (const vector<Attribute>& attributes)
{
	std::ostringstream src;
	set<string> conditions;

	for (vector<Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
	{
		if (iter->getCondition() != Cond::COND_NEVER && iter->getCondition() != Cond::COND_ALWAYS)
			conditions.insert(iter->getCondition().getName());
	}

	for (set<string>::const_iterator iter = conditions.begin(); iter != conditions.end(); ++iter)
			src << "uniform mediump float u_" << (*iter) << ";\n";

	return src.str();
}

string generateToVec4Expression (const Attribute& attrib, int id=-1)
{
	const string		variableName(attrib.getName() + (attrib.getArraySize() != Attribute::NOT_ARRAY ? "[" + de::toString(id) + "]" : ""));
	std::ostringstream	src;

	switch (attrib.getType().getGLTypeEnum())
	{
		case GL_INT_VEC2:
		case GL_UNSIGNED_INT_VEC2:
		case GL_FLOAT_VEC2:
			src << "vec4(" << variableName << ".xy, " << variableName << ".yx)";
			break;

		case GL_INT_VEC3:
		case GL_UNSIGNED_INT_VEC3:
		case GL_FLOAT_VEC3:
			src << "vec4(" << variableName << ".xyz, " << variableName << ".x)";
			break;

		default:
			src << "vec4(" << variableName << ")";
			break;
	}

	return src.str();
}

string generateOutputCode (const vector<Attribute>& attributes)
{
	std::ostringstream src;

	for (vector<Attribute>::const_iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
	{
		if (iter->getCondition() == Cond::COND_NEVER)
		{
			src <<
			"\tif (0 != 0)\n"
			"\t{\n";

			if (iter->getArraySize() == Attribute::NOT_ARRAY)
				src << "\t\tcolor += " << generateToVec4Expression(*iter) << ";\n";
			else
			{
				for (int i = 0; i < iter->getArraySize(); i++)
					src << "\t\tcolor += " << generateToVec4Expression(*iter, i) << ";\n";
			}

			src << "\t}\n";
		}
		else if (iter->getCondition() == Cond::COND_ALWAYS)
		{
			if (iter->getArraySize() == Attribute::NOT_ARRAY)
				src << "\tcolor += " << generateToVec4Expression(*iter) << ";\n";
			else
			{
				for (int i = 0; i < iter->getArraySize(); i++)
					src << "\tcolor += " << generateToVec4Expression(*iter, i) << ";\n";
			}
		}
		else
		{
			src <<
			"\tif (u_" << iter->getCondition().getName() << (iter->getCondition().getNegate() ? " != " : " == ") << "0.0)\n"
			"\t{\n";

			if (iter->getArraySize() == Attribute::NOT_ARRAY)
				src << "\t\tcolor += " << generateToVec4Expression(*iter) << ";\n";
			else
			{
				for (int i = 0; i < iter->getArraySize(); i++)
					src << "\t\tcolor += " << generateToVec4Expression(*iter, i) << ";\n";
			}

			src <<
			"\t}\n";
		}
	}

	return src.str();
}

string generateVertexShaderTemplate (const vector<Attribute>& attributes)
{
	std::ostringstream src;

	src <<	"${VERSION}\n"
			"${VTX_OUTPUT} mediump vec4 v_color;\n";

	src << generateAttributeDefinitions(attributes)
		<< "\n"
		<< generateConditionUniformDefinitions(attributes)
		<< "\n";

	src <<	"void main (void)\n"
			"{\n"
			"\tmediump vec4 color = vec4(0.0);\n"
			"\n";

	src << generateOutputCode(attributes);

	src <<	"\n"
			"\tv_color = color;\n"
			"\tgl_Position = color;\n"
			"}\n";

	return src.str();
}

string createVertexShaderSource (glu::RenderContext& renderCtx, const vector<Attribute>& attributes, bool attributeAliasing)
{
	// \note On GLES only GLSL #version 100 supports aliasing
	const glu::GLSLVersion		contextGLSLVersion		= glu::getContextTypeGLSLVersion(renderCtx.getType());
	const glu::GLSLVersion		glslVersion				= (attributeAliasing && glu::glslVersionIsES(contextGLSLVersion) ? glu::GLSL_VERSION_100_ES : contextGLSLVersion);
	const bool					usesInOutQualifiers		= glu::glslVersionUsesInOutQualifiers(glslVersion);
	const tcu::StringTemplate	vertexShaderTemplate(generateVertexShaderTemplate(attributes));

	map<string, string> parameters;

	parameters["VERSION"]					= glu::getGLSLVersionDeclaration(glslVersion);
	parameters["VTX_OUTPUT"]				= (usesInOutQualifiers ? "out"				: "varying");
	parameters["VTX_INPUT"]					= (usesInOutQualifiers ? "in"				: "attribute");
	parameters["FRAG_INPUT"]				= (usesInOutQualifiers ? "in"				: "varying");
	parameters["FRAG_OUTPUT_VAR"]			= (usesInOutQualifiers ? "dEQP_FragColor"	: "gl_FragColor");
	parameters["FRAG_OUTPUT_DECLARATION"]	= (usesInOutQualifiers
													? "layout(location=0) out mediump vec4 dEQP_FragColor;"
													: "");

	return vertexShaderTemplate.specialize(parameters);
}

string createFragmentShaderSource (glu::RenderContext& renderCtx, bool attributeAliasing)
{
	const char* const fragmentShaderSource =
		"${VERSION}\n"
		"${FRAG_OUTPUT_DECLARATION}\n"
		"${FRAG_INPUT} mediump vec4 v_color;\n"
		"void main (void)\n"
		"{\n"
		"\t${FRAG_OUTPUT_VAR} = v_color;\n"
		"}\n";

	// \note On GLES only GLSL #version 100 supports aliasing
	const glu::GLSLVersion		contextGLSLVersion		= glu::getContextTypeGLSLVersion(renderCtx.getType());
	const glu::GLSLVersion		glslVersion				= (attributeAliasing && glu::glslVersionIsES(contextGLSLVersion) ? glu::GLSL_VERSION_100_ES : contextGLSLVersion);
	const tcu::StringTemplate	fragmentShaderTemplate(fragmentShaderSource);
	const bool					usesInOutQualifiers		= glu::glslVersionUsesInOutQualifiers(glslVersion);

	map<string, string> parameters;

	parameters["VERSION"]					= glu::getGLSLVersionDeclaration(glslVersion);
	parameters["VTX_OUTPUT"]				= (usesInOutQualifiers ? "out"				: "varying");
	parameters["VTX_INPUT"]					= (usesInOutQualifiers ? "in"				: "attribute");
	parameters["FRAG_INPUT"]				= (usesInOutQualifiers ? "in"				: "varying");
	parameters["FRAG_OUTPUT_VAR"]			= (usesInOutQualifiers ? "dEQP_FragColor"	: "gl_FragColor");
	parameters["FRAG_OUTPUT_DECLARATION"]	= (usesInOutQualifiers
													? "layout(location=0) out mediump vec4 dEQP_FragColor;"
													: "");

	return fragmentShaderTemplate.specialize(parameters);
}

string getShaderInfoLog (const glw::Functions& gl, deUint32 shader)
{
	deInt32	length = 0;
	string	infoLog;

	gl.getShaderiv(shader, GL_INFO_LOG_LENGTH, &length);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");

	infoLog.resize(length, '\0');

	gl.getShaderInfoLog(shader, (glw::GLsizei)infoLog.length(), DE_NULL, &(infoLog[0]));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog()");

	return infoLog;
}

bool getShaderCompileStatus (const glw::Functions& gl, deUint32 shader)
{
	deInt32 status;

	gl.getShaderiv(shader, GL_COMPILE_STATUS, &status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");

	return status == GL_TRUE;
}

string getProgramInfoLog (const glw::Functions& gl, deUint32 program)
{
	deInt32	length = 0;
	string	infoLog;

	gl.getProgramiv(program, GL_INFO_LOG_LENGTH, &length);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");

	infoLog.resize(length, '\0');

	gl.getProgramInfoLog(program, (glw::GLsizei)infoLog.length(), DE_NULL, &(infoLog[0]));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog()");

	return infoLog;
}

bool getProgramLinkStatus (const glw::Functions& gl, deUint32 program)
{
	deInt32 status;

	gl.getProgramiv(program, GL_LINK_STATUS, &status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv()");

	return status == GL_TRUE;
}

void logProgram (TestLog& log, const glw::Functions& gl, deUint32 program)
{
	const bool				programLinkOk	= getProgramLinkStatus(gl, program);
	const string			programInfoLog	= getProgramInfoLog(gl, program);
	tcu::ScopedLogSection	linkInfo		(log, "Program Link Info", "Program Link Info");

	{
		tcu::ScopedLogSection infoLogSection(log, "Info Log", "Info Log");

		log << TestLog::Message << programInfoLog << TestLog::EndMessage;
	}

	log << TestLog::Message << "Link result: " << (programLinkOk ? "Ok" : "Fail") << TestLog::EndMessage;
}

void logShaders (TestLog&		log,
				const string&	vertexShaderSource,
				const string&	vertexShaderInfoLog,
				bool			vertexCompileOk,
				const string&	fragmentShaderSource,
				const string&	fragmentShaderInfoLog,
				bool			fragmentCompileOk)
{
	// \todo [mika] Log as real shader elements. Currently not supported by TestLog.
	{
		tcu::ScopedLogSection shaderSection(log, "Vertex Shader Info", "Vertex Shader Info");

		log << TestLog::KernelSource(vertexShaderSource);

		{
			tcu::ScopedLogSection infoLogSection(log, "Info Log", "Info Log");

			log << TestLog::Message << vertexShaderInfoLog << TestLog::EndMessage;
		}

		log << TestLog::Message << "Compilation result: " << (vertexCompileOk ? "Ok" : "Failed") << TestLog::EndMessage;
	}

	{
		tcu::ScopedLogSection shaderSection(log, "Fragment Shader Info", "Fragment Shader Info");

		log << TestLog::KernelSource(fragmentShaderSource);

		{
			tcu::ScopedLogSection infoLogSection(log, "Info Log", "Info Log");

			log << TestLog::Message << fragmentShaderInfoLog << TestLog::EndMessage;
		}

		log << TestLog::Message << "Compilation result: " << (fragmentCompileOk ? "Ok" : "Failed") << TestLog::EndMessage;
	}
}

pair<deUint32, deUint32> createAndAttachShaders (TestLog& log, glu::RenderContext& renderCtx, deUint32 program, const vector<Attribute>& attributes, bool attributeAliasing)
{
	const glw::Functions&	gl						= renderCtx.getFunctions();
	const string			vertexShaderSource		= createVertexShaderSource(renderCtx, attributes, attributeAliasing);
	const string			fragmentShaderSource	= createFragmentShaderSource(renderCtx, attributeAliasing);

	const deUint32			vertexShader			= gl.createShader(GL_VERTEX_SHADER);
	const deUint32			fragmentShader			= gl.createShader(GL_FRAGMENT_SHADER);

	try
	{
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader()");

		{
			const char* const vertexShaderString	= vertexShaderSource.c_str();
			const char* const fragmentShaderString	= fragmentShaderSource.c_str();

			gl.shaderSource(vertexShader, 1, &vertexShaderString, DE_NULL);
			gl.shaderSource(fragmentShader, 1, &fragmentShaderString, DE_NULL);

			GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource()");
		}

		gl.compileShader(vertexShader);
		gl.compileShader(fragmentShader);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader()");

		gl.attachShader(program, vertexShader);
		gl.attachShader(program, fragmentShader);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader()");

		{
			const bool		vertexCompileOk			= getShaderCompileStatus(gl, vertexShader);
			const bool		fragmentCompileOk		= getShaderCompileStatus(gl, fragmentShader);

			const string	vertexShaderInfoLog		= getShaderInfoLog(gl, vertexShader);
			const string	fragmentShaderInfoLog	= getShaderInfoLog(gl, fragmentShader);

			logShaders(log, vertexShaderSource, vertexShaderInfoLog, vertexCompileOk, fragmentShaderSource, fragmentShaderInfoLog, fragmentCompileOk);

			TCU_CHECK_MSG(vertexCompileOk, "Vertex shader compilation failed");
			TCU_CHECK_MSG(fragmentCompileOk, "Fragment shader compilation failed");
		}

		gl.deleteShader(vertexShader);
		gl.deleteShader(fragmentShader);

		return pair<deUint32, deUint32>(vertexShader, fragmentShader);
	}
	catch (...)
	{
		if (vertexShader != 0)
			gl.deleteShader(vertexShader);

		if (fragmentShader != 0)
			gl.deleteShader(fragmentShader);

		throw;
	}
}

void bindAttributes (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Bind>& binds)
{
	for (vector<Bind>::const_iterator iter = binds.begin(); iter != binds.end(); ++iter)
	{
		log << TestLog::Message << "Bind attribute: '" << iter->getAttributeName() << "' to " << iter->getLocation() << TestLog::EndMessage;
		gl.bindAttribLocation(program, iter->getLocation(), iter->getAttributeName().c_str());
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindAttribLocation()");
	}
}

void logAttributes (TestLog& log, const vector<Attribute>& attributes)
{
	for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++)
	{
		const Attribute& attrib = attributes[attribNdx];

		log << TestLog::Message
			<< "Type: " << attrib.getType().getName()
			<< ", Name: " << attrib.getName()
			<< (attrib.getLayoutLocation()	!= Attribute::LOC_UNDEF ? ", Layout location "	+ de::toString(attrib.getLayoutLocation()) : "")
			<< TestLog::EndMessage;
	}
}

bool checkActiveAttribQuery (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Attribute>& attributes)
{
	deInt32					activeAttribCount = 0;
	set<string>				activeAttributes;
	bool					isOk = true;

	gl.getProgramiv(program, GL_ACTIVE_ATTRIBUTES, &activeAttribCount);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &activeAttribCount)");

	for (int activeAttribNdx = 0; activeAttribNdx < activeAttribCount; activeAttribNdx++)
	{
		char			name[128];
		const size_t	maxNameSize = DE_LENGTH_OF_ARRAY(name) - 1;
		deInt32			length = 0;
		deInt32			size = 0;
		deUint32		type = 0;

		std::memset(name, 0, sizeof(name));

		gl.getActiveAttrib(program, activeAttribNdx, maxNameSize, &length, &size, &type, name);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetActiveAttrib()");

		log << TestLog::Message
			<< "glGetActiveAttrib(program"
			<< ", index=" << activeAttribNdx
			<< ", bufSize=" << maxNameSize
			<< ", length=" << length
			<< ", size=" << size
			<< ", type=" << glu::getShaderVarTypeStr(type)
			<< ", name='" << name << "')" << TestLog::EndMessage;

		{
			bool found = false;

			for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++)
			{
				const Attribute& attrib = attributes[attribNdx];

				if (attrib.getName() == name)
				{
					if (type != attrib.getType().getGLTypeEnum())
					{
						log << TestLog::Message
							<< "Error: Wrong type " << glu::getShaderVarTypeStr(type)
							<< " expected " << glu::getShaderVarTypeStr(attrib.getType().getGLTypeEnum())
							<< TestLog::EndMessage;

						isOk = false;
					}

					if (attrib.getArraySize() == Attribute::NOT_ARRAY)
					{
						if (size != 1)
						{
							log << TestLog::Message << "Error: Wrong size " << size << " expected " << 1 << TestLog::EndMessage;
							isOk = false;
						}
					}
					else
					{
						if (size != attrib.getArraySize())
						{
							log << TestLog::Message << "Error: Wrong size " << size << " expected " << attrib.getArraySize() << TestLog::EndMessage;
							isOk = false;
						}
					}

					found = true;
					break;
				}
			}

			if (!found)
			{
				log << TestLog::Message << "Error: Unknown attribute '" << name << "' returned by glGetActiveAttrib()." << TestLog::EndMessage;
				isOk = false;
			}
		}

		activeAttributes.insert(name);
	}

	for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++)
	{
		const Attribute&	attrib		= attributes[attribNdx];
		const bool			isActive	= attrib.getCondition() != Cond::COND_NEVER;

		if (isActive)
		{
			if (activeAttributes.find(attrib.getName()) == activeAttributes.end())
			{
				log << TestLog::Message << "Error: Active attribute " << attrib.getName() << " wasn't returned by glGetActiveAttrib()." << TestLog::EndMessage;
				isOk = false;
			}
		}
		else
		{
			if (activeAttributes.find(attrib.getName()) != activeAttributes.end())
				log << TestLog::Message << "Note: Inactive attribute " << attrib.getName() << " was returned by glGetActiveAttrib()." << TestLog::EndMessage;
		}
	}

	return isOk;
}

bool checkAttribLocationQuery (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Attribute>& attributes, const map<string, deUint32>& bindings)
{
	bool isOk = true;

	for (int attribNdx = 0; attribNdx < (int)attributes.size(); attribNdx++)
	{
		const Attribute&	attrib				= attributes[attribNdx];
		const deInt32		expectedLocation	= (attrib.getLayoutLocation() != Attribute::LOC_UNDEF ? attrib.getLayoutLocation() : getBoundLocation(bindings, attrib.getName()));
		const deInt32		location			= gl.getAttribLocation(program, attrib.getName().c_str());

		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation()");

		log << TestLog::Message
			<< location << " = glGetAttribLocation(program, \"" << attrib.getName() << "\")"
			<< (attrib.getCondition() != Cond::COND_NEVER && expectedLocation != Attribute::LOC_UNDEF ? ", expected " + de::toString(expectedLocation) : "")
			<< "." << TestLog::EndMessage;

		if (attrib.getCondition() == Cond::COND_NEVER && location != -1)
			log << TestLog::Message << "\tNote: Inactive attribute with location." << TestLog::EndMessage;

		if (attrib.getCondition() != Cond::COND_NEVER && expectedLocation != Attribute::LOC_UNDEF && expectedLocation != location)
			log << TestLog::Message << "\tError: Invalid attribute location." << TestLog::EndMessage;

		isOk &= (attrib.getCondition() == Cond::COND_NEVER || expectedLocation == Attribute::LOC_UNDEF || expectedLocation == location);
	}

	return isOk;
}

bool checkQuery (TestLog& log, const glw::Functions& gl, deUint32 program, const vector<Attribute>& attributes, const map<string, deUint32>& bindings)
{
	bool isOk = checkActiveAttribQuery(log, gl, program, attributes);

	if (!checkAttribLocationQuery(log, gl, program, attributes, bindings))
		isOk = false;

	return isOk;
}

string generateTestName (const AttribType& type, int arraySize)
{
	return type.getName() + (arraySize != Attribute::NOT_ARRAY ? "_array_" + de::toString(arraySize) : "");
}

} // anonymous

namespace AttributeLocationTestUtil
{

AttribType::AttribType (const string& name, deUint32 localSize, deUint32 typeEnum)
	: m_name			(name)
	, m_locationSize	(localSize)
	, m_glTypeEnum		(typeEnum)
{
}

Cond::Cond (const string& name, bool negate)
	: m_negate	(negate)
	, m_name	(name)
{
}

Cond::Cond (ConstCond cond)
	: m_negate	(cond != COND_NEVER)
	, m_name	("__always__")
{
	DE_ASSERT(cond == COND_ALWAYS || cond == COND_NEVER);
}

Attribute::Attribute (const AttribType& type, const string& name, deInt32 layoutLocation, const Cond& cond, int arraySize)
	: m_type			(type)
	, m_name			(name)
	, m_layoutLocation	(layoutLocation)
	, m_cond			(cond)
	, m_arraySize		(arraySize)
{
}

Bind::Bind (const std::string& attribute, deUint32 location)
	: m_attribute	(attribute)
	, m_location	(location)
{
}

void runTest (tcu::TestContext&			testCtx,
			glu::RenderContext&			renderCtx,
			const vector<Attribute>&	attributes,
			const vector<Bind>&			preAttachBind,
			const vector<Bind>&			preLinkBind,
			const vector<Bind>&			postLinkBind,
			bool						relink,
			bool						reattach = false,
			const vector<Attribute>&	reattachAttributes = vector<Attribute>())
{
	TestLog&					log			= testCtx.getLog();
	const glw::Functions&		gl			= renderCtx.getFunctions();
	deUint32					program		= 0;
	pair<deUint32, deUint32>	shaders;

	try
	{
		bool					isOk			= true;
		map<string, deUint32>	activeBindings;

		for (int bindNdx = 0; bindNdx < (int)preAttachBind.size(); bindNdx++)
			activeBindings[preAttachBind[bindNdx].getAttributeName()] = preAttachBind[bindNdx].getLocation();

		for (int bindNdx = 0; bindNdx < (int)preLinkBind.size(); bindNdx++)
			activeBindings[preLinkBind[bindNdx].getAttributeName()] = preLinkBind[bindNdx].getLocation();

		{
			tcu::ScopedLogSection section(log, "Attributes", "Attribute information");
			logAttributes(testCtx.getLog(), attributes);
		}

		log << TestLog::Message << "Create program." << TestLog::EndMessage;
		program = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram()");

		if (!preAttachBind.empty())
			bindAttributes(log, gl, program, preAttachBind);

		log << TestLog::Message << "Create and attach shaders to program." << TestLog::EndMessage;
		shaders = createAndAttachShaders(log, renderCtx, program, attributes, hasAttributeAliasing(attributes, activeBindings));

		if (!preLinkBind.empty())
			bindAttributes(log, gl, program, preLinkBind);

		log << TestLog::Message << "Link program." << TestLog::EndMessage;

		gl.linkProgram(program);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");

		logProgram(log, gl, program);
		TCU_CHECK_MSG(getProgramLinkStatus(gl, program), "Program link failed");

		if (!checkQuery(log, gl, program, attributes, activeBindings))
			isOk = false;

		if (!postLinkBind.empty())
		{
			bindAttributes(log, gl, program, postLinkBind);

			if (!checkQuery(log, gl, program, attributes, activeBindings))
				isOk = false;
		}

		if (relink)
		{
			log << TestLog::Message << "Relink program." << TestLog::EndMessage;
			gl.linkProgram(program);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");

			logProgram(log, gl, program);
			TCU_CHECK_MSG(getProgramLinkStatus(gl, program), "Program link failed");

			for (int bindNdx = 0; bindNdx < (int)postLinkBind.size(); bindNdx++)
				activeBindings[postLinkBind[bindNdx].getAttributeName()] = postLinkBind[bindNdx].getLocation();

			if (!checkQuery(log, gl, program, attributes, activeBindings))
				isOk = false;
		}

		if (reattach)
		{
			gl.detachShader(program, shaders.first);
			gl.detachShader(program, shaders.second);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader()");

			log << TestLog::Message << "Create and attach shaders to program." << TestLog::EndMessage;
			createAndAttachShaders(log, renderCtx, program, reattachAttributes, hasAttributeAliasing(reattachAttributes, activeBindings));

			log << TestLog::Message << "Relink program." << TestLog::EndMessage;
			gl.linkProgram(program);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram()");

			logProgram(log, gl, program);
			TCU_CHECK_MSG(getProgramLinkStatus(gl, program), "Program link failed");

			if (!checkQuery(log, gl, program, reattachAttributes, activeBindings))
				isOk = false;
		}

		gl.deleteProgram(program);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteProgram()");

		if (isOk)
			testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
		else
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}
	catch (...)
	{
		if (program)
			gl.deleteProgram(program);

		throw;
	}
}

} // AttributeLocationTestUtil

BindAttributeTest::BindAttributeTest (tcu::TestContext&		testCtx,
									  glu::RenderContext&	renderCtx,
									  const AttribType&		type,
									  int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(m_type, "a_0", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

BindMaxAttributesTest::BindMaxAttributesTest (tcu::TestContext&		testCtx,
											  glu::RenderContext&	renderCtx,
											  const AttribType&		type,
											  int					arraySize)
	: TestCase		(testCtx,  generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindMaxAttributesTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	vector<Bind>		bindings;
	int					ndx = 0;

	m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage;

	for (int loc = maxAttributes - (arrayElementCount * m_type.getLocationSize()); loc >= 0; loc -= (arrayElementCount * m_type.getLocationSize()))
	{
		attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));
		bindings.push_back(Bind("a_" + de::toString(ndx), loc));
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

BindAliasingAttributeTest::BindAliasingAttributeTest (tcu::TestContext&		testCtx,
													  glu::RenderContext&	renderCtx,
													  const AttribType&		type,
													  int					offset,
													  int					arraySize)
	: TestCase		(testCtx,	("cond_" + generateTestName(type, arraySize) + (offset != 0 ? "_offset_" + de::toString(offset) : "")).c_str(),
								("cond_" + generateTestName(type, arraySize) + (offset != 0 ? "_offset_" + de::toString(offset) : "")).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_offset		(offset)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindAliasingAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(m_type, "a_0", Attribute::LOC_UNDEF, Cond("A", true), m_arraySize));
	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_1", Attribute::LOC_UNDEF, Cond("A", false)));
	bindings.push_back(Bind("a_0", 1));
	bindings.push_back(Bind("a_1", 1 + m_offset));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

BindMaxAliasingAttributeTest::BindMaxAliasingAttributeTest (tcu::TestContext&	testCtx,
															glu::RenderContext&	renderCtx,
															const AttribType&	type,
															int					arraySize)
	: TestCase		(testCtx, ("max_cond_" + generateTestName(type, arraySize)).c_str(), ("max_cond_" + generateTestName(type, arraySize)).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindMaxAliasingAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	vector<Bind>		bindings;
	int					ndx = 0;

	m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage;

	for (int loc = maxAttributes - arrayElementCount * m_type.getLocationSize(); loc >= 0; loc -= m_type.getLocationSize() * arrayElementCount)
	{
		attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond("A", true)));
		bindings.push_back(Bind("a_" + de::toString(ndx), loc));

		attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx + maxAttributes), Attribute::LOC_UNDEF, Cond("A", false)));
		bindings.push_back(Bind("a_" + de::toString(ndx + maxAttributes), loc));
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

BindHoleAttributeTest::BindHoleAttributeTest (tcu::TestContext&		testCtx,
											  glu::RenderContext&	renderCtx,
											  const AttribType&		type,
											  int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindHoleAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes = getMaxAttributeLocations(m_renderCtx);
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	vector<Bind>		bindings;
	int					ndx;

	attributes.push_back(Attribute(vec4, "a_0"));
	bindings.push_back(Bind("a_0", 0));

	attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));

	ndx = 2;
	for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++)
	{
		attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx)));
		bindings.push_back(Bind("a_" + de::toString(ndx), loc));

		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

BindInactiveAliasingAttributeTest::BindInactiveAliasingAttributeTest (tcu::TestContext&		testCtx,
																	  glu::RenderContext&	renderCtx,
																	  const AttribType&		type,
																	  int					arraySize)
	: TestCase		(testCtx,	("max_inactive_" + generateTestName(type, arraySize)).c_str(),
								("max_inactive_" + generateTestName(type, arraySize)).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindInactiveAliasingAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	vector<Bind>		bindings;
	int					ndx = 0;

	m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage;

	for (int loc = maxAttributes - arrayElementCount * m_type.getLocationSize(); loc >= 0; loc -= m_type.getLocationSize() * arrayElementCount)
	{
		attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond("A")));
		bindings.push_back(Bind("a_" + de::toString(ndx), loc));

		attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx + maxAttributes), Attribute::LOC_UNDEF, Cond::COND_NEVER));
		bindings.push_back(Bind("a_" + de::toString(ndx + maxAttributes), loc));
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

PreAttachBindAttributeTest::PreAttachBindAttributeTest (tcu::TestContext&	testCtx,
														glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "pre_attach", "pre_attach")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult PreAttachBindAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0"));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, bindings, noBindings, noBindings, false);
	return STOP;
}

PreLinkBindAttributeTest::PreLinkBindAttributeTest (tcu::TestContext&	testCtx,
													glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "pre_link", "pre_link")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult PreLinkBindAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0"));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

PostLinkBindAttributeTest::PostLinkBindAttributeTest (tcu::TestContext&		testCtx,
													  glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "post_link", "post_link")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult PostLinkBindAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0"));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, bindings, false);
	return STOP;
}

LocationAttributeTest::LocationAttributeTest (tcu::TestContext&		testCtx,
											  glu::RenderContext&	renderCtx,
											  const AttribType&		type,
											  int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult LocationAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;

	attributes.push_back(Attribute(m_type, "a_0", 3, Cond::COND_ALWAYS, m_arraySize));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, noBindings, false);
	return STOP;
}

LocationMaxAttributesTest::LocationMaxAttributesTest (tcu::TestContext&		testCtx,
													  glu::RenderContext&	renderCtx,
													  const AttribType&		type,
													  int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult LocationMaxAttributesTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	int					ndx = 0;

	m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage;

	for (int loc = maxAttributes - (arrayElementCount * m_type.getLocationSize()); loc >= 0; loc -= (arrayElementCount * m_type.getLocationSize()))
	{
		attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), loc, Cond::COND_ALWAYS, m_arraySize));
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, noBindings, false);
	return STOP;
}

LocationHoleAttributeTest::LocationHoleAttributeTest (tcu::TestContext&		testCtx,
													  glu::RenderContext&	renderCtx,
													  const AttribType&		type,
													  int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult LocationHoleAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes = getMaxAttributeLocations(m_renderCtx);
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	int					ndx;

	attributes.push_back(Attribute(vec4, "a_0", 0));

	attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));

	ndx = 2;
	for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++)
	{
		attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc));
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, noBindings, false);
	return STOP;
}

MixedAttributeTest::MixedAttributeTest (tcu::TestContext&	testCtx,
										glu::RenderContext&	renderCtx,
										const AttribType&	type,
										int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult MixedAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Bind>		bindings;
	vector<Attribute>	attributes;

	attributes.push_back(Attribute(m_type, "a_0", 3, Cond::COND_ALWAYS, m_arraySize));
	bindings.push_back(Bind("a_0", 4));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

MixedMaxAttributesTest::MixedMaxAttributesTest (tcu::TestContext&	testCtx,
												glu::RenderContext&	renderCtx,
												const AttribType&	type,
												int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult MixedMaxAttributesTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Bind>		bindings;
	vector<Attribute>	attributes;
	int					ndx = 0;

	m_testCtx.getLog() << TestLog::Message << "GL_MAX_VERTEX_ATTRIBS: " << maxAttributes << TestLog::EndMessage;

	for (int loc = maxAttributes - (arrayElementCount * m_type.getLocationSize()); loc >= 0; loc -= (arrayElementCount * m_type.getLocationSize()))
	{
		if ((ndx % 2) != 0)
			attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), loc, Cond::COND_ALWAYS, m_arraySize));
		else
		{
			attributes.push_back(Attribute(m_type, "a_" + de::toString(ndx), Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));
			bindings.push_back(Bind("a_" + de::toString(ndx), loc));

		}
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

MixedHoleAttributeTest::MixedHoleAttributeTest (tcu::TestContext&		testCtx,
												glu::RenderContext&		renderCtx,
												const AttribType&		type,
												int						arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult MixedHoleAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes = getMaxAttributeLocations(m_renderCtx);
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Bind>		bindings;
	vector<Attribute>	attributes;
	int					ndx;

	attributes.push_back(Attribute(vec4, "a_0"));
	bindings.push_back(Bind("a_0", 0));

	attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));

	ndx = 2;
	for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++)
	{
		if ((ndx % 2) != 0)
			attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc));
		else
		{
			attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc));
			bindings.push_back(Bind("a_" + de::toString(ndx), loc));

		}
		ndx++;
	}

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

BindRelinkAttributeTest::BindRelinkAttributeTest (tcu::TestContext&		testCtx,
												  glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "relink", "relink")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult BindRelinkAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);

	vector<Attribute>	attributes;
	vector<Bind>		preLinkBindings;
	vector<Bind>		postLinkBindings;

	attributes.push_back(Attribute(vec4, "a_0"));
	attributes.push_back(Attribute(vec4, "a_1"));

	preLinkBindings.push_back(Bind("a_0", 3));
	preLinkBindings.push_back(Bind("a_0", 5));

	postLinkBindings.push_back(Bind("a_0", 6));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true);
	return STOP;
}

BindRelinkHoleAttributeTest::BindRelinkHoleAttributeTest (tcu::TestContext&		testCtx,
														  glu::RenderContext&	renderCtx,
														  const AttribType&		type,
														  int					arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult BindRelinkHoleAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const AttribType	vec4				("vec4", 1, GL_FLOAT_VEC4);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Attribute>	attributes;
	vector<Bind>		preLinkBindings;
	vector<Bind>		postLinkBindings;
	int					ndx;

	attributes.push_back(Attribute(vec4, "a_0"));
	preLinkBindings.push_back(Bind("a_0", 0));

	attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));

	ndx = 2;
	for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++)
	{
		attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx)));
		preLinkBindings.push_back(Bind("a_" + de::toString(ndx), loc));

		ndx++;
	}

	postLinkBindings.push_back(Bind("a_2", 1));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true);
	return STOP;
}

MixedRelinkHoleAttributeTest::MixedRelinkHoleAttributeTest (tcu::TestContext&		testCtx,
															glu::RenderContext&		renderCtx,
															const AttribType&		type,
															int						arraySize)
	: TestCase		(testCtx, generateTestName(type, arraySize).c_str(), generateTestName(type, arraySize).c_str())
	, m_renderCtx	(renderCtx)
	, m_type		(type)
	, m_arraySize	(arraySize)
{
}

tcu::TestCase::IterateResult MixedRelinkHoleAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const deInt32		maxAttributes		= getMaxAttributeLocations(m_renderCtx);
	const AttribType	vec4				("vec4", 1, GL_FLOAT_VEC4);
	const int			arrayElementCount	= (m_arraySize != Attribute::NOT_ARRAY ? m_arraySize : 1);

	vector<Bind>		preLinkBindings;
	vector<Bind>		postLinkBindings;
	vector<Attribute>	attributes;
	int					ndx;

	attributes.push_back(Attribute(vec4, "a_0"));
	preLinkBindings.push_back(Bind("a_0", 0));

	attributes.push_back(Attribute(m_type, "a_1", Attribute::LOC_UNDEF, Cond::COND_ALWAYS, m_arraySize));

	ndx = 2;
	for (int loc = 1 + m_type.getLocationSize() * arrayElementCount; loc < maxAttributes; loc++)
	{
		if ((ndx % 2) != 0)
			attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx), loc));
		else
		{
			attributes.push_back(Attribute(vec4, "a_" + de::toString(ndx)));
			preLinkBindings.push_back(Bind("a_" + de::toString(ndx), loc));

		}
		ndx++;
	}

	postLinkBindings.push_back(Bind("a_2", 1));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true);
	return STOP;
}

BindReattachAttributeTest::BindReattachAttributeTest (tcu::TestContext&		testCtx,
													  glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "reattach", "reattach")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult BindReattachAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);
	const AttribType	vec2("vec2", 1, GL_FLOAT_VEC2);

	vector<Bind>		bindings;
	vector<Attribute>	attributes;
	vector<Attribute>	reattachAttributes;

	attributes.push_back(Attribute(vec4, "a_0"));
	bindings.push_back(Bind("a_0", 1));
	bindings.push_back(Bind("a_1", 1));

	reattachAttributes.push_back(Attribute(vec2, "a_1"));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false, true, reattachAttributes);
	return STOP;
}

PreAttachMixedAttributeTest::PreAttachMixedAttributeTest (tcu::TestContext&	testCtx,
														glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "pre_attach", "pre_attach")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult PreAttachMixedAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0", 1));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, bindings, noBindings, noBindings, false);
	return STOP;
}

PreLinkMixedAttributeTest::PreLinkMixedAttributeTest (tcu::TestContext&	testCtx,
													glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "pre_link", "pre_link")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult PreLinkMixedAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0", 1));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false);
	return STOP;
}

PostLinkMixedAttributeTest::PostLinkMixedAttributeTest (tcu::TestContext&	testCtx,
														glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "post_link", "post_link")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult PostLinkMixedAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;

	vector<Attribute>	attributes;
	vector<Bind>		bindings;

	attributes.push_back(Attribute(AttribType("vec4", 1, GL_FLOAT_VEC4), "a_0", 1));
	bindings.push_back(Bind("a_0", 3));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, noBindings, bindings, false);
	return STOP;
}

MixedReattachAttributeTest::MixedReattachAttributeTest (tcu::TestContext&	testCtx,
														glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "reattach", "reattach")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult MixedReattachAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);
	const AttribType	vec2("vec2", 1, GL_FLOAT_VEC2);

	vector<Bind>		bindings;
	vector<Attribute>	attributes;
	vector<Attribute>	reattachAttributes;

	attributes.push_back(Attribute(vec4, "a_0", 2));
	bindings.push_back(Bind("a_0", 1));
	bindings.push_back(Bind("a_1", 1));

	reattachAttributes.push_back(Attribute(vec2, "a_1"));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, bindings, noBindings, false, true, reattachAttributes);
	return STOP;
}

MixedRelinkAttributeTest::MixedRelinkAttributeTest (tcu::TestContext&	testCtx,
													glu::RenderContext&	renderCtx)
	: TestCase		(testCtx, "relink", "relink")
	, m_renderCtx	(renderCtx)
{
}

tcu::TestCase::IterateResult MixedRelinkAttributeTest::iterate (void)
{
	const vector<Bind>	noBindings;
	const AttribType	vec4("vec4", 1, GL_FLOAT_VEC4);

	vector<Attribute>	attributes;
	vector<Bind>		preLinkBindings;
	vector<Bind>		postLinkBindings;

	attributes.push_back(Attribute(vec4, "a_0", 1));
	attributes.push_back(Attribute(vec4, "a_1"));

	preLinkBindings.push_back(Bind("a_0", 3));
	preLinkBindings.push_back(Bind("a_0", 5));

	postLinkBindings.push_back(Bind("a_0", 6));

	runTest(m_testCtx, m_renderCtx, attributes, noBindings, preLinkBindings, postLinkBindings, true);
	return STOP;
}

} // gls
} // deqp