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

/**
 * @file  gl4cVertexAttrib64BitTests.hpp
 * @brief Implement conformance tests for GL_ARB_vertex_attrib_64bit functionality
 **/

#include "gl4cVertexAttrib64BitTest.hpp"

#include "gluContextInfo.hpp"
#include "gluStrUtil.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"

#include <algorithm>
#include <iomanip>
#include <string>
#include <vector>

using namespace glw;

namespace VertexAttrib64Bit
{

class Base : public deqp::TestCase
{
public:
	/* Public constructor and destructor */
	Base(deqp::Context& context, const char* name, const char* description);

	virtual ~Base()
	{
	}

	/* Public methods */
	void BuildProgram(const GLchar* fragment_shader_code, GLuint& program_id, const GLchar* vertex_shader_code,
					  GLuint& out_fragment_shader_id, GLuint& out_vertex_shader_id) const;

	void BuildProgramVSOnly(GLuint out_program_id, const GLchar* vertex_shader_code,
							GLuint& out_vertex_shader_id) const;

	void CompileShader(GLuint id, const GLchar* source_code) const;

	GLint GetMaxVertexAttribs() const;

	void IterateStart();

	tcu::TestNode::IterateResult IterateStop(bool result) const;

	void LinkProgram(GLuint id) const;

	static GLdouble RandomDouble(GLdouble min, GLdouble max);

	void RequireExtension(const GLchar* extension_name) const;

	/* Public fields */
	/* Test framework objects */
	glw::Functions gl; /* prefix "m_" ommitted for readability */
	tcu::TestLog&  m_log;
};

/** Constructor
 *
 **/
Base::Base(deqp::Context& context, const char* name, const char* description)
	: TestCase(context, name, description), m_log(m_context.getTestContext().getLog())
{
	/* Nothing to be done here */
}

void Base::BuildProgram(const GLchar* fragment_shader_code, GLuint& program_id, const GLchar* vertex_shader_code,
						GLuint& out_fragment_shader_id, GLuint& out_vertex_shader_id) const
{
	out_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");

	out_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");

	CompileShader(out_fragment_shader_id, fragment_shader_code);
	CompileShader(out_vertex_shader_id, vertex_shader_code);

	gl.attachShader(program_id, out_fragment_shader_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");

	gl.attachShader(program_id, out_vertex_shader_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");

	LinkProgram(program_id);
}

/** Builds and links a program object consisting only of vertex shader stage.
 *  The function also creates a vertex shader, assigns it user-provided body
 *  and compiles it.
 *
 *  @param program_id           ID of a created program object to configure.
 *  @param vertex_shader_code   Source code to use for the vertex shader.
 *  @param out_vertex_shader_id Will hold
 **/
void Base::BuildProgramVSOnly(GLuint program_id, const GLchar* vertex_shader_code, GLuint& out_vertex_shader_id) const
{
	out_vertex_shader_id = gl.createShader(GL_VERTEX_SHADER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");

	CompileShader(out_vertex_shader_id, vertex_shader_code);

	gl.attachShader(program_id, out_vertex_shader_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");

	LinkProgram(program_id);
}

void Base::CompileShader(GLuint id, const GLchar* source_code) const
{
	GLint status = 0;

	gl.shaderSource(id, 1, &source_code, 0 /* length */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource");

	gl.compileShader(id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader");

	gl.getShaderiv(id, GL_COMPILE_STATUS, &status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");

	if (GL_FALSE == status)
	{
		GLint				message_length = 0;
		std::vector<GLchar> message;

		gl.getShaderiv(id, GL_INFO_LOG_LENGTH, &message_length);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");

		message.resize(message_length + 1);

		gl.getShaderInfoLog(id, message_length, &message_length, &message[0]);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog");

		m_log << tcu::TestLog::Section("Shader compilation error", "");

		m_log << tcu::TestLog::Message << "Compilation log:\n" << &message[0] << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "Shader source:\n" << source_code << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::EndSection;

		TCU_FAIL("Shader compilation failed");
	}
}

/** Get value of GL_MAX_VERTEX_ATTRIBS
 *
 * Throws exception in case of failure
 *
 * @return Value
 **/
GLint Base::GetMaxVertexAttribs() const
{
	GLint max_vertex_attribs;

	gl.getIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetIntegerv");

	return max_vertex_attribs;
}

void Base::IterateStart()
{
	gl = m_context.getRenderContext().getFunctions();
}

tcu::TestNode::IterateResult Base::IterateStop(bool result) const
{
	/* Set test result */
	if (false == result)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}
	else
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}

	/* Done */
	return tcu::TestNode::STOP;
}

void Base::LinkProgram(GLuint id) const
{
	GLint status = 0;
	gl.linkProgram(id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram");

	gl.getProgramiv(id, GL_LINK_STATUS, &status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");

	if (GL_FALSE == status)
	{
		GLint				message_length = 0;
		std::vector<GLchar> message;

		gl.getProgramiv(id, GL_INFO_LOG_LENGTH, &message_length);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");

		message.resize(message_length + 1);

		gl.getProgramInfoLog(id, message_length, &message_length, &message[0]);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog");

		m_log << tcu::TestLog::Section("Program link error", "");

		m_log << tcu::TestLog::Message << "Link log:\n" << &message[0] << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::EndSection;

		TCU_FAIL("Program linking failed");
	}
}

/** Return "random" double value from range <min:max>
 *
 * @return Value
 **/
GLdouble Base::RandomDouble(GLdouble min, GLdouble max)
{
	static const glw::GLushort max_value = 0x2000;
	static glw::GLushort	   value	 = 0x1234;

	GLdouble	   fraction = ((GLdouble)value) / ((GLdouble)max_value);
	const GLdouble range	= max - min;

	value = static_cast<glw::GLushort>((max_value <= value) ? 0 : value + 1);

	return min + fraction * range;
}

/** Throws tcu::NotSupportedError if requested extensions is not available.
 *
 **/
void Base::RequireExtension(const GLchar* extension_name) const
{
	const std::vector<std::string>& extensions = m_context.getContextInfo().getExtensions();

	if (std::find(extensions.begin(), extensions.end(), extension_name) == extensions.end())
	{
		std::string message = "Required extension is not supported: ";
		message.append(extension_name);

		throw tcu::NotSupportedError(message);
	}
}

/** Implementation of conformance test "1", description follows.
 *
 *  Make sure the following errors are generated as specified:
 *
 *  a) GL_INVALID_VALUE should be generated by:
 *     I.    glVertexAttribL1d     ()
 *     II.   glVertexAttribL2d     ()
 *     III.  glVertexAttribL3d     ()
 *     IV.   glVertexAttribL4d     ()
 *     V.    glVertexAttribL1dv    ()
 *     VI.   glVertexAttribL2dv    ()
 *     VII.  glVertexAttribL3dv    ()
 *     VIII. glVertexAttribL4dv    ()
 *     IX.   glVertexAttribLPointer()
 *
 *     if <index> is greater than or equal to GL_MAX_VERTEX_ATTRIBS;
 *
 *  b) GL_INVALID_ENUM should be generated by glVertexAttribLPointer()
 *     if <type> is not GL_DOUBLE;
 *
 *  c) GL_INVALID_VALUE should be generated by glVertexAttribLPointer()
 *     if <size> is not 1, 2, 3 or 4.
 *
 *  d) GL_INVALID_VALUE should be generated by glVertexAttribLPointer()
 *     if <stride> is negative.
 *
 *  e) GL_INVALID_OPERATION should be generated by glVertexAttribLPointer()
 *     if zero is bound to the GL_ARRAY_BUFFER buffer object binding
 *     point and the <pointer> argument is not NULL.
 *
 *  f) GL_INVALID_OPERATION should be generated by glGetVertexAttribLdv()
 *     if <index> is zero.
 **/
class ApiErrorsTest : public Base
{
public:
	/* Public methods */
	ApiErrorsTest(deqp::Context& context);

	virtual ~ApiErrorsTest()
	{
	}

	/* Public methods inheritated from TestCase */
	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

private:
	/* Private methods */
	void invalidEnum(bool& result);
	void invalidOperation(bool& result);
	void invalidValue(bool& result);
	void verifyError(GLenum expected_error, const char* function_name, int line_number, bool& result);

	/* Private fields */
	GLuint m_vertex_array_object_id;
};

/** Constructor
 *
 * @param context CTS context instance
 **/
ApiErrorsTest::ApiErrorsTest(deqp::Context& context)
	: Base(context, "api_errors", "Verify that API routines provoke errors as specified"), m_vertex_array_object_id(0)
{
	/* Nothing to be done here */
}

void ApiErrorsTest::deinit()
{
	/* Delete VAO */
	if (0 != m_vertex_array_object_id)
	{
		gl.bindVertexArray(0);
		gl.deleteVertexArrays(1, &m_vertex_array_object_id);
		m_vertex_array_object_id = 0;
	}
}

/** Execute test
 *
 * @return tcu::TestNode::STOP
 **/
tcu::TestNode::IterateResult ApiErrorsTest::iterate()
{
	IterateStart();

	bool result = true;

	RequireExtension("GL_ARB_vertex_attrib_64bit");

	gl.genVertexArrays(1, &m_vertex_array_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays");

	gl.bindVertexArray(m_vertex_array_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray");

	invalidEnum(result);
	invalidOperation(result);
	invalidValue(result);

	/* Done */
	return IterateStop(result);
}

/** Test if GL_INVALID_ENUM error is provoked as expected
 *
 * @param result If test fails result is set to false, not modified otherwise.
 **/
void ApiErrorsTest::invalidEnum(bool& result)
{
	/*
	 *b) GL_INVALID_ENUM should be generated by glVertexAttribLPointer()
	 *   if <type> is not GL_DOUBLE;
	 */

	static const GLenum type_array[] = { GL_BYTE,
										 GL_UNSIGNED_BYTE,
										 GL_SHORT,
										 GL_UNSIGNED_SHORT,
										 GL_INT,
										 GL_UNSIGNED_INT,
										 GL_HALF_FLOAT,
										 GL_FLOAT,
										 GL_FIXED,
										 GL_INT_2_10_10_10_REV,
										 GL_UNSIGNED_INT_2_10_10_10_REV,
										 GL_UNSIGNED_INT_10F_11F_11F_REV };
	static const GLuint type_array_length = sizeof(type_array) / sizeof(type_array[0]);

	for (GLuint i = 0; i < type_array_length; ++i)
	{
		const GLenum type = type_array[i];

		std::stringstream message;
		message << "VertexAttribLPointer(..., " << glu::getTypeName(type) << " /* type */, ...)";

		gl.vertexAttribLPointer(1 /*index */, 4 /*size */, type, 0 /* stride */, 0 /* pointer */);
		verifyError(GL_INVALID_ENUM, message.str().c_str(), __LINE__, result);
	}

	gl.vertexAttribLPointer(1 /* index */, 4 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */);
	verifyError(GL_NO_ERROR, "VertexAttribLPointer(..., GL_DOUBLE /* type */, ...)", __LINE__, result);
}

/** Test if GL_INVALID_OPERATON error is provoked as expected
 *
 * @param result If test fails result is set to false, not modified otherwise.
 **/
void ApiErrorsTest::invalidOperation(bool& result)
{

	/*
	 *e) GL_INVALID_OPERATION should be generated by glVertexAttribLPointer()
	 *   if zero is bound to the GL_ARRAY_BUFFER buffer object binding
	 *   point and the <pointer> argument is not NULL.
	 */
	static const GLvoid* pointer_array[]	  = { (GLvoid*)1, (GLvoid*)4, (GLvoid*)-16 };
	static const GLuint  pointer_array_length = sizeof(pointer_array) / sizeof(pointer_array[0]);

	gl.bindBuffer(GL_ARRAY_BUFFER, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

	for (GLuint i = 0; i < pointer_array_length; ++i)
	{
		const GLvoid* pointer = pointer_array[i];

		std::stringstream message;
		message << "VertexAttribLPointer(..., " << pointer << " /* pointer */)";

		gl.vertexAttribLPointer(1 /* index */, 4 /*size */, GL_DOUBLE, 0 /* stride */, pointer);
		verifyError(GL_INVALID_OPERATION, message.str().c_str(), __LINE__, result);
	}
}

/** Test if GL_INVALID_VALUE error is provoked as expected
 *
 * @param result If test fails result is set to false, not modified otherwise.
 **/
void ApiErrorsTest::invalidValue(bool& result)
{
	GLint		   max_vertex_attribs = GetMaxVertexAttribs();
	const GLdouble vector[4]		  = { 0.0, 0.0, 0.0, 0.0 };

	/*
	 * a) GL_INVALID_VALUE should be generated by:
	 *    I.    glVertexAttribL1d     ()
	 *    II.   glVertexAttribL2d     ()
	 *    III.  glVertexAttribL3d     ()
	 *    IV.   glVertexAttribL4d     ()
	 *    V.    glVertexAttribL1dv    ()
	 *    VI.   glVertexAttribL2dv    ()
	 *    VII.  glVertexAttribL3dv    ()
	 *    VIII. glVertexAttribL4dv    ()
	 *    IX.   glVertexAttribLPointer()
	 *
	 *    if <index> is greater than or equal to GL_MAX_VERTEX_ATTRIBS;
	 */
	gl.vertexAttribL1d(max_vertex_attribs, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL1d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL1d(max_vertex_attribs + 1, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL1d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL2d(max_vertex_attribs, 0.0, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL2d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL2d(max_vertex_attribs + 1, 0.0, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL2d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL3d(max_vertex_attribs, 0.0, 0.0, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL3d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL3d(max_vertex_attribs + 1, 0.0, 0.0, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL3d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL4d(max_vertex_attribs, 0.0, 0.0, 0.0, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL4d(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL4d(max_vertex_attribs + 1, 0.0, 0.0, 0.0, 0.0);
	verifyError(GL_INVALID_VALUE, "VertexAttribL4d(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL1dv(max_vertex_attribs, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL1dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL1dv(max_vertex_attribs + 1, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL1dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL2dv(max_vertex_attribs, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL2dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL2dv(max_vertex_attribs + 1, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL2dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL3dv(max_vertex_attribs, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL3dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL3dv(max_vertex_attribs + 1, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL3dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribL4dv(max_vertex_attribs, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL4dv(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribL4dv(max_vertex_attribs + 1, vector);
	verifyError(GL_INVALID_VALUE, "VertexAttribL4dv(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	gl.vertexAttribLPointer(max_vertex_attribs, 4 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */);
	verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(GL_MAX_VERTEX_ATTRIBS, ...)", __LINE__, result);

	gl.vertexAttribLPointer(max_vertex_attribs + 1, 4 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */);
	verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(GL_MAX_VERTEX_ATTRIBS + 1, ...)", __LINE__, result);

	/*
	 *c) GL_INVALID_VALUE should be generated by glVertexAttribLPointer()
	 *if <size> is not 1, 2, 3 or 4.
	 */
	gl.vertexAttribLPointer(1, 0 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */);
	verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., 0 /* size */, ...)", __LINE__, result);

	gl.vertexAttribLPointer(1, 5 /*size */, GL_DOUBLE, 0 /* stride */, 0 /* pointer */);
	verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., 5 /* size */, ...)", __LINE__, result);

	/*
	 *d) GL_INVALID_VALUE should be generated by glVertexAttribLPointer()
	 *   if <stride> is negative.
	 */
	gl.vertexAttribLPointer(1, 4 /*size */, GL_DOUBLE, -1 /* stride */, 0 /* pointer */);
	verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., -1 /* stride */, ...)", __LINE__, result);

	gl.vertexAttribLPointer(1, 4 /*size */, GL_DOUBLE, -4 /* stride */, 0 /* pointer */);
	verifyError(GL_INVALID_VALUE, "VertexAttribLPointer(..., -4 /* stride */, ...)", __LINE__, result);
}

/** Verify that GetError returns expected error code. In case of failure logs error message.
 *
 * @param expected_error Expected error code
 * @param function_name  Name of function to log in case of error
 * @param line_number    Line number, for reference
 * @param result         Result of verification, set to false in case of failure, not modified otherwise
 **/
void ApiErrorsTest::verifyError(GLenum expected_error, const char* function_name, int line_number, bool& result)
{
	GLenum error = gl.getError();

	if (expected_error != error)
	{
		m_log << tcu::TestLog::Section("Error", "");

		m_log << tcu::TestLog::Message << "GetError returned: " << glu::getErrorStr(error) << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "Expected: " << glu::getErrorStr(expected_error) << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "Operation: " << function_name << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "File: " << __FILE__ << "@" << line_number << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::EndSection;

		result = false;
	}
}

/** Implementation of conformance test "2", description follows.
 *
 *  Make sure that all available generic vertex attributes report
 *  correct values when queried with corresponding glGetVertexAttribL*()
 *  function, after they had been set with a glVertexAttribL*() call.
 *  All double-precision floating-point setters and getters should
 *  be checked, as enlisted below:
 *
 *  * glVertexAttribL1d ()
 *  * glVertexAttribL2d ()
 *  * glVertexAttribL3d ()
 *  * glVertexAttribL4d ()
 *  * glVertexAttribL1dv()
 *  * glVertexAttribL2dv()
 *  * glVertexAttribL3dv()
 *  * glVertexAttribL4dv()
 *
 *  The test should also verify glGetVertexAttribiv() and
 *  glGetVertexAttribLdv() report correct property values for all
 *  vertex attribute arrays configured with glVertexAttribLPointer()
 *  call. Two different configurations should be checked for each
 *  VAA index.
 **/
class GetVertexAttribTest : public Base
{
public:
	/* Public constructor and destructor */
	GetVertexAttribTest(deqp::Context& context);

	virtual ~GetVertexAttribTest()
	{
	}

	/* Public methods inheritated from TestCase */
	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

private:
	/* Private types */
	/** Template class to store vertex attribute data
	 *
	 * @tparam SIZE Number of elements
	 **/
	template <GLuint SIZE>
	class vertexAttribute
	{
	public:
		vertexAttribute(GLdouble min, GLdouble max)
		{
			for (GLuint i = 0; i < SIZE; ++i)
			{
				m_array[i] = RandomDouble(min, max);
			}
		}

		GLdouble m_array[SIZE];
	};

	/* Private methods */
	/* checkVertexAttrib methods */
	template <GLuint SIZE>
	void checkVertexAttribLd(GLuint index, bool& result) const;

	template <GLuint SIZE>
	void checkVertexAttribLdv(GLuint index, bool& result) const;

	void checkVertexAttribLPointer(GLuint index, bool& result) const;

	/* Wrappers for vertexAttribLd routines */
	template <GLuint SIZE>
	void vertexAttribLd(GLuint index, const vertexAttribute<SIZE>& attribute) const;

	template <GLuint SIZE>
	void vertexAttribLdv(GLuint index, const vertexAttribute<SIZE>& attribute) const;

	/* Utilities */
	bool compareDoubles(const GLdouble* a, const GLdouble* b, GLuint length) const;

	void initTest();

	bool verifyResults(GLuint index, GLenum pname, GLint expected_value) const;

	bool verifyResults(const GLdouble* set_values, GLuint length, GLuint index, const char* function_name,
					   int line_number) const;

	bool verifyPointerResults(const GLdouble* set_values, GLuint length, GLuint index, int line_number) const;

	void logError(const GLdouble* set_values, const GLdouble* get_values, GLuint length, const char* function_name,
				  GLuint index, int line_number) const;

	/* Private fields */
	const GLdouble		m_epsilon;
	static const GLuint m_n_iterations = 128;
	GLint				m_max_vertex_attribs;
	const GLdouble		m_min;
	const GLdouble		m_max;

	/* GL objects */
	GLuint m_buffer_object_id;
	GLuint m_vertex_array_object_id;
};

/** Constructor
 *
 * @param context CTS context
 **/
GetVertexAttribTest::GetVertexAttribTest(deqp::Context& context)
	: Base(context, "get_vertex_attrib", "Verify that GetVertexAttribL* routines")
	, m_epsilon(0.0)
	, m_max_vertex_attribs(0)
	, m_min(-16.384)
	, m_max(16.384)
	, m_buffer_object_id(0)
	, m_vertex_array_object_id(0)
{
	/* Nothing to be done */
}

/** Clean up after test
 *
 **/
void GetVertexAttribTest::deinit()
{
	if (0 != m_buffer_object_id)
	{
		gl.bindBuffer(GL_ARRAY_BUFFER, 0);
		gl.deleteBuffers(1, &m_buffer_object_id);
		m_buffer_object_id = 0;
	}

	if (0 != m_vertex_array_object_id)
	{
		gl.bindVertexArray(0);
		gl.deleteVertexArrays(1, &m_vertex_array_object_id);
		m_vertex_array_object_id = 0;
	}
}

/** Execute test
 *
 * @return tcu::TestNode::STOP
 **/
tcu::TestNode::IterateResult GetVertexAttribTest::iterate()
{
	IterateStart();

	bool result = true;

	RequireExtension("GL_ARB_vertex_attrib_64bit");

	initTest();

	for (GLint i = 1; i < m_max_vertex_attribs; ++i)
	{
		checkVertexAttribLd<1>(i, result);
		checkVertexAttribLd<2>(i, result);
		checkVertexAttribLd<3>(i, result);
		checkVertexAttribLd<4>(i, result);
		checkVertexAttribLdv<1>(i, result);
		checkVertexAttribLdv<2>(i, result);
		checkVertexAttribLdv<3>(i, result);
		checkVertexAttribLdv<4>(i, result);
		checkVertexAttribLPointer(i, result);
	}

	/* Done */
	return IterateStop(result);
}

/** Verifies glVertexAttribLd routines
 *
 * @tparam SIZE Size of vertex attribute
 *
 * @param index  Index of vertex attribute, starts from 1.
 * @param result Result of verification, set to false in case of failure, not modified otherwise.
 **/
template <GLuint SIZE>
void GetVertexAttribTest::checkVertexAttribLd(GLuint index, bool& result) const
{
	std::stringstream function_name;

	function_name << "VertexAttribL" << SIZE << "d";

	for (GLuint i = 0; i < m_n_iterations; ++i)
	{
		vertexAttribute<SIZE> vertex_attribute(m_min, m_max);

		vertexAttribLd<SIZE>(index, vertex_attribute);
		GLU_EXPECT_NO_ERROR(gl.getError(), function_name.str().c_str());

		if (false == verifyResults(vertex_attribute.m_array, SIZE, index, function_name.str().c_str(), __LINE__))
		{
			result = false;
			return;
		}
	}
}

/** Verifies glVertexAttribLdv routines
 *
 * @tparam SIZE Size of vertex attribute
 *
 * @param index  Index of vertex attribute, starts from 1.
 * @param result Result of verification, set to false in case of failure, not modified otherwise.
 **/
template <GLuint SIZE>
void GetVertexAttribTest::checkVertexAttribLdv(GLuint index, bool& result) const
{
	std::stringstream function_name;

	function_name << "VertexAttribL" << SIZE << "dv";

	for (GLuint i = 0; i < m_n_iterations; ++i)
	{
		vertexAttribute<SIZE> vertex_attribute(m_min, m_max);

		vertexAttribLdv<SIZE>(index, vertex_attribute);
		GLU_EXPECT_NO_ERROR(gl.getError(), function_name.str().c_str());

		if (false == verifyResults(vertex_attribute.m_array, SIZE, index, function_name.str().c_str(), __LINE__))
		{
			result = false;
			return;
		}
	}
}

/** Verifies glVertexAttribLPointer
 *
 * @param index  Index of vertex attribute, starts from 1.
 * @param result Result of verification, set to false in case of failure, not modified otherwise.
 **/
void GetVertexAttribTest::checkVertexAttribLPointer(GLuint index, bool& result) const
{
	static const GLuint max_size   = 4;
	static const GLuint max_stride = 16;

	gl.bindVertexArray(m_vertex_array_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray");

	gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

	for (GLuint size = 1; size <= max_size; ++size)
	{
		for (GLuint stride = 0; stride < max_stride; ++stride)
		{
			gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id);
			GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

			gl.vertexAttribLPointer(index, size, GL_DOUBLE, stride, (GLvoid*)0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribLPointer");

			gl.bindBuffer(GL_ARRAY_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, m_buffer_object_id))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, GL_FALSE))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_SIZE, size))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_STRIDE, stride))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_TYPE, GL_DOUBLE))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_NORMALIZED, GL_FALSE))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_INTEGER, GL_FALSE))
			{
				result = false;
			}

			if (false == verifyResults(index, GL_VERTEX_ATTRIB_ARRAY_DIVISOR, 0))
			{
				result = false;
			}
		}
	}
}

/** Wrapper of vertexAttribLd routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 1.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLd<1>(GLuint										   index,
											const GetVertexAttribTest::vertexAttribute<1>& attribute) const
{
	gl.vertexAttribL1d(index, attribute.m_array[0]);
}

/** Wrapper of vertexAttribLd routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 2.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLd<2>(GLuint										   index,
											const GetVertexAttribTest::vertexAttribute<2>& attribute) const
{
	gl.vertexAttribL2d(index, attribute.m_array[0], attribute.m_array[1]);
}

/** Wrapper of vertexAttribLd routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 3.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLd<3>(GLuint										   index,
											const GetVertexAttribTest::vertexAttribute<3>& attribute) const
{
	gl.vertexAttribL3d(index, attribute.m_array[0], attribute.m_array[1], attribute.m_array[2]);
}

/** Wrapper of vertexAttribLd routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 4.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLd<4>(GLuint										   index,
											const GetVertexAttribTest::vertexAttribute<4>& attribute) const
{
	gl.vertexAttribL4d(index, attribute.m_array[0], attribute.m_array[1], attribute.m_array[2], attribute.m_array[3]);
}

/** Wrapper of vertexAttribLdv routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 1.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLdv<1>(GLuint											index,
											 const GetVertexAttribTest::vertexAttribute<1>& attribute) const
{
	gl.vertexAttribL1dv(index, attribute.m_array);
}

/** Wrapper of vertexAttribLdv routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 2.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLdv<2>(GLuint											index,
											 const GetVertexAttribTest::vertexAttribute<2>& attribute) const
{
	gl.vertexAttribL2dv(index, attribute.m_array);
}

/** Wrapper of vertexAttribLdv routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 3.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLdv<3>(GLuint											index,
											 const GetVertexAttribTest::vertexAttribute<3>& attribute) const
{
	gl.vertexAttribL3dv(index, attribute.m_array);
}

/** Wrapper of vertexAttribLdv routines.
 *
 * @tparam SIZE Size of vertex attribute. Specialisation for 4.
 *
 * @param index     Index parameter
 * @param attribute Vertex attribute data are taken from provided instance of vertexAttribute
 **/
template <>
void GetVertexAttribTest::vertexAttribLdv<4>(GLuint											index,
											 const GetVertexAttribTest::vertexAttribute<4>& attribute) const
{
	gl.vertexAttribL4dv(index, attribute.m_array);
}

/** Compare two arrays of doubles
 *
 * @param a      First array of doubles
 * @param b      Second array of doubles
 * @param length Length of arrays
 *
 * @return true if arrays are considered equal, false otherwise
 **/
bool GetVertexAttribTest::compareDoubles(const GLdouble* a, const GLdouble* b, GLuint length) const
{
	for (GLuint i = 0; i < length; ++i)
	{
		if ((b[i] > a[i] + m_epsilon) || (b[i] < a[i] - m_epsilon))
		{
			return false;
		}
	}

	return true;
}

/** Prepare buffer and vertex array object, get max vertex attributes
 *
 **/
void GetVertexAttribTest::initTest()
{
	gl.genBuffers(1, &m_buffer_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers");

	gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

	gl.bufferData(GL_ARRAY_BUFFER, 16 * sizeof(GLdouble), 0, GL_DYNAMIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BufferStorage");

	gl.genVertexArrays(1, &m_vertex_array_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays");

	m_max_vertex_attribs = GetMaxVertexAttribs();
}

/** Logs message informing that values got with GetVertexAttribLdv do not match set with "function_name"
 *
 * @param set_values    Values set with "function_name"
 * @param get_values    Values extracted with GetVertexAttribLdv
 * @param length        Length of "get/set_values" arrays
 * @param function_name Name of function used to set vertex attributes
 * @param index         Index of vertex attribute
 * @param line_number   Line number refereing to location of "function_name"
 **/
void GetVertexAttribTest::logError(const GLdouble* set_values, const GLdouble* get_values, GLuint length,
								   const char* function_name, GLuint index, int line_number) const
{
	m_log << tcu::TestLog::Section("Error", "");

	tcu::MessageBuilder message = m_log << tcu::TestLog::Message;
	message << "Values set with " << function_name << " [";

	for (GLuint i = 0; i < length; ++i)
	{
		message << std::setprecision(24) << set_values[i];

		if (length != i + 1)
		{
			message << ", ";
		}
	}

	message << "]" << tcu::TestLog::EndMessage;

	message = m_log << tcu::TestLog::Message;
	message << "Values got with GetVertexAttribLdv"
			<< " [";

	for (GLuint i = 0; i < length; ++i)
	{
		message << std::setprecision(24) << get_values[i];

		if (length != i + 1)
		{
			message << ", ";
		}
	}

	message << "]" << tcu::TestLog::EndMessage;

	m_log << tcu::TestLog::Message << "Index: " << index << tcu::TestLog::EndMessage;

	m_log << tcu::TestLog::Message << "File: " << __FILE__ << "@" << line_number << tcu::TestLog::EndMessage;

	m_log << tcu::TestLog::EndSection;
}

/** Verify results of vertexAttribLPointer
 *
 * @param index          Index of vertex attribute
 * @param pname          Parameter name to be querried with getVertexAttribiv and getVertexAttribLdv
 * @param expected_value Expected valued
 *
 * @return true if Results match expected_value, false otherwise
 **/
bool GetVertexAttribTest::verifyResults(GLuint index, GLenum pname, GLint expected_value) const
{
	GLint	params_getVertexAttribiv  = 0;
	GLdouble params_getVertexAttribLdv = 0.0;

	gl.getVertexAttribiv(index, pname, &params_getVertexAttribiv);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetVertexAttribiv");

	gl.getVertexAttribLdv(index, pname, &params_getVertexAttribLdv);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetVertexAttribLdv");

	if ((expected_value != params_getVertexAttribiv) || (expected_value != params_getVertexAttribLdv))
	{
		m_log << tcu::TestLog::Section("Error", "");

		m_log << tcu::TestLog::Message << "GetVertexAttribiv(" << index << "/* index */, "
			  << glu::getVertexAttribParameterNameName(pname) << "/* pname */)" << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "Result: " << params_getVertexAttribiv << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "GetVertexAttribLdv(" << index << "/* index */, "
			  << glu::getVertexAttribParameterNameName(pname) << "/* pname */)" << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "Result: " << params_getVertexAttribLdv << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "Expected: " << expected_value << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::Message << "File: " << __FILE__ << "@" << __LINE__ << tcu::TestLog::EndMessage;

		m_log << tcu::TestLog::EndSection;

		return false;
	}

	return true;
}

/** Verify results of vertexAttribLdv routines
 *
 * @param set_values    Values set with vertexAttribLdv
 * @param length        Length of "set_values" array
 * @param index         Index of vertex attribute
 * @param function_name Name of function used to set, it will be used for error logging
 * @param line_number   Line number refering to location of "function_name", used to log errors
 *
 * @return true if results match set values, false otherwise
 **/
bool GetVertexAttribTest::verifyResults(const GLdouble* set_values, GLuint length, GLuint index,
										const char* function_name, int line_number) const
{
	GLdouble results[4] = { 0.0, 0.0, 0.0, 0.0 };

	gl.getVertexAttribLdv(index, GL_CURRENT_VERTEX_ATTRIB, results);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetVertexAttribLdv");

	if (false == compareDoubles(set_values, results, length))
	{
		logError(set_values, results, length, function_name, index, line_number);

		return false;
	}

	return true;
}

/** Implementation of conformance test "3", description follows.
 *
 *  Verify that a total of GL_MAX_VERTEX_ATTRIBS double and dvec2,
 *  (GL_MAX_VERTEX_ATTRIBS / 2) dvec3, dvec4 and dmat2,
 *  (GL_MAX_VERTEX_ATTRIBS / 3) dmat3x2,
 *  (GL_MAX_VERTEX_ATTRIBS / 4) dmat4x2, dmat2x3 and dmat2x4,
 *  (GL_MAX_VERTEX_ATTRIBS / 6) dmat3 and dmat3x4,
 *  (GL_MAX_VERTEX_ATTRIBS / 8) dmat4x3 and dmat4,
 *  attributes can be used in each shader stage at the same time.
 *
 *  The test should run in 7 iterations:
 *
 *  a) In the first iteration, (GL_MAX_VERTEX_ATTRIBS / 2) double
 *      attributes and (GL_MAX_VERTEX_ATTRIBS / 2) dvec2 attributes
 *      should be defined in a vertex shader. The test should verify
 *      the values exposed by these attributes and write 1 to an
 *      output variable if all attribute values are found to be
 *      correct, or set it to 0 if at least one of the retrieved
 *      values is found invalid.
 *
 *      Double attributes should be assigned the value:
 *                  (n_attribute + gl_VertexID * 2)
 *
 *      Dvec2 attribute components should be assigned the following
 *      vector values:
 *                  (n_attribute + gl_VertexID * 3 + 1,
 *                  n_attribute + gl_VertexID * 3 + 2)
 *
 *  b) In the second iteration, (GL_MAX_VERTEX_ATTRIBS / 4) dvec3
 *      and (GL_MAX_VERTEX_ATTRIBS / 4) dvec4 attributes should be
 *      defined in a vertex shader. Verification of the data exposed
 *      by these input variables should be performed as in step a),
 *      with an exception of the values passed through the attributes.
 *
 *      Dvec3 attribute components should be assigned the following
 *      vector values:
 *                  (n_attribute + gl_VertexID * 3 + 0,
 *                  n_attribute + gl_VertexID * 3 + 1,
 *                  n_attribute + gl_VertexID * 3 + 2).
 *
 *      Dvec4 attribute components should be assigned the following
 *      vector values:
 *                  (n_attribute + gl_VertexID * 4 + 0,
 *                  n_attribute + gl_VertexID * 4 + 1,
 *                  n_attribute + gl_VertexID * 4 + 2,
 *                  n_attribute + gl_VertexID * 4 + 3).
 *
 *      n_attribute corresponds to the ordinal number of each attribute,
 *      as defined in the shader.
 *
 *  c) In the third iteration, (GL_MAX_VERTEX_ATTRIBS / 2) dmat2 attributes
 *      should be defined in a vertex shader. Verification of the data exposed
 *      by these input variables should be performed as in step a), with an
 *      exception of the values passed through the attributes.
 *
 *      Subsequent matrix elements should be assigned the following value:
 *              (n_type + n_attribute + gl_VertexID * 16 + n_value)
 *
 *      n_type corresponds to the ordinal number of type as per the
 *      order at the beginning of the paragraph.
 *      n_value corresponds to the ordinal number of the element.
 *
 *  d) In the fourth iteration, (GL_MAX_VERTEX_ATTRIBS / 8) dmat3x2 and
 *      (GL_MAX_VERTEX_ATTRIBS / 8) dmat4x2 attributes should be defined in a
 *      vertex shader. Verification of the data exposed by these input
 *      variables should be performed as in step a), with an exception of the
 *      values passed through the attributes.
 *
 *      Use the same element values as in step c)
 *
 *  e) In the fifth iteration, (GL_MAX_VERTEX_ATTRIBS / 8) dmat2x3 and
 *      (GL_MAX_VERTEX_ATTRIBS / 8) dmat2x4 attributes should be defined in a
 *      vertex shader. Verification of the data exposed by these input
 *      variables should be performed as in step a), with an exception of the
 *      values passed through the attributes.
 *
 *      Use the same element values as in step c)
 *
 *  f) In the sixth iteration, (GL_MAX_VERTEX_ATTRIBS / 12) dmat3 and
 *      (GL_MAX_VERTEX_ATTRIBS / 12) dmat3x4 attributes should be defined in a
 *      vertex shader. Verification of the data exposed by these input
 *      variables should be performed as in step a), with an exception of the
 *      values passed through the attributes.
 *
 *      Use the same element values as in step c)
 *
 *  g) In the seventh iteration, (GL_MAX_VERTEX_ATTRIBS / 16) dmat4x3 and
 *      (GL_MAX_VERTEX_ATTRIBS / 16) dmat4 attributes should be defined in a
 *      vertex shader. Verification of the data exposed by these input
 *      variables should be performed as in step a), with an exception of the
 *      values passed through the attributes.
 *
 *      Use the same element values as in step c)
 *
 *  h) Modify the language of cases a) - g), so that instead of separate
 *      attributes, all attributes of the same type are now a single arrayed
 *      attribute.
 *
 *  Vertex shaders from both iterations should be used to form two program
 *  objects. 1024 vertices should be used for a non-indiced GL_POINTS
 *  draw call, made using those two programs.
 *
 *  All glVertexAttribL*() and glVertexAttribLPointer() should be used for
 *  the purpose of the test. The following draw call API functions should be
 *  tested:
 *
 *  a) glDrawArrays()
 *  b) glDrawArraysInstanced(), primcount > 1, zero vertex attrib divisor
 *  c) glDrawArraysInstanced(), primcount > 1, non-zero vertex attrib divisor
 *  d) glDrawElements()
 *  e) glDrawElementsInstanced(), properties as in b)
 *  f) glDrawElementsInstanced(), properties as in c)
 *
 *  All shaders used by the test should come in two flavors:
 *
 *  - one where attribute locations are explicitly defined in the body;
 *  - the other one where attribute locations are to be assigned by
 *      the compiler.
 *
 *  For each shader, the test should make sure that all attributes have
 *  been assigned correct amount of locations. (eg: dvec4 attribute
 *  should be granted exactly one location).
 *
 *  Data stored in output variables should be XFBed to the test.
 *  The test passes if the retrieved values are found to be valid
 *  for all vertex shader invocations.
 **/

class LimitTest : public Base
{
public:
	/* Public constructor and destructor */
	LimitTest(deqp::Context& context);

	virtual ~LimitTest()
	{
	}

	/* Public methods inheritated from TestCase */
	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

private:
	/* Private types */
	class programInfo
	{
	public:
		programInfo(const glw::Functions& gl);
		~programInfo();

		GLuint m_fragment_shader_id;
		GLuint m_program_id;
		GLuint m_vertex_shader_id;

	private:
		const glw::Functions& gl;
	};

	struct attributeConfiguration
	{
		attributeConfiguration()
			: m_n_attributes_per_group(0)
			, m_n_elements(0)
			, m_n_rows(0)
			, m_n_types(0)
			, m_type_names(0)
			, m_vertex_length(0)
		{
			/* nothing to be done */
		}

		GLint				 m_n_attributes_per_group;
		const GLint*		 m_n_elements;
		const GLint*		 m_n_rows;
		GLint				 m_n_types;
		const GLchar* const* m_type_names;
		GLint				 m_vertex_length;
	};

	typedef GLint _varyingType;

	/* Private enums */
	enum _iteration
	{
		DOUBLE_DVEC2,	// 1 + 1         = 2
		DVEC3_DVEC4,	 // 2 + 2         = 4
		DMAT2,			 // 2 * 1         = 2
		DMAT3X2_DMAT4X2, // 3 * 1 + 4 * 1 = 8
		DMAT2X3_DMAT2X4, // 2 * 2 + 2 * 2 = 8
		DMAT3_DMAT3X4,   // 3 * 2 + 3 * 2 = 12
		DMAT4X3_DMAT4	// 4 * 2 + 4 * 2 = 16
	};

	enum _attributeType
	{
		REGULAR,
		PER_INSTANCE,
		CONSTANT,
	};

	/*Private methods */
	GLint calculateAttributeGroupOffset(const attributeConfiguration& configuration, GLint index) const;

	GLint calculateAttributeLocation(const attributeConfiguration& configuration, GLint attribute, GLint n_type) const;

	void calculateVertexLength(attributeConfiguration& configuration) const;

	void configureAttribute(_iteration iteration, const attributeConfiguration& configuration, GLint n_type,
							GLuint program_id, bool use_arrays, bool use_vertex_array) const;

	void getProgramDetails(_iteration iteration, bool use_arrays, bool use_locations, bool use_vertex_attrib_divisor,
						   std::string& out_varying_name, std::string& out_vertex_shader_code) const;

	void getVertexArrayConfiguration(_iteration iteration, attributeConfiguration& out_configuration) const;

	void logTestIterationAndConfig(_iteration iteration, _attributeType attribute_type, bool use_arrays,
								   bool use_locations) const;

	void prepareProgram(_iteration iteration, bool use_arrays, bool use_locations, bool use_vertex_attrib_divisor,
						programInfo& programInfo);

	void prepareVertexArray(_iteration iteration, _attributeType attribute_type, GLuint program_id,
							bool use_arrays) const;

	void prepareVertexArrayBuffer(_iteration iteration);

	void setAttributes(_iteration iteration, const attributeConfiguration& configuration, GLuint vertex,
					   std::vector<GLdouble>& out_buffer_data) const;

	void setAttributes_a(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
						 std::vector<GLdouble>& out_buffer_data) const;

	void setAttributes_a_scalar(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
								std::vector<GLdouble>& out_buffer_data) const;

	void setAttributes_a_vec(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
							 std::vector<GLdouble>& out_buffer_data) const;

	void setAttributes_b(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
						 std::vector<GLdouble>& out_buffer_dataa) const;

	void setAttributes_c(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
						 std::vector<GLdouble>& out_buffer_data) const;

	bool testDrawArrays() const;
	bool testDrawArraysInstanced() const;
	bool testDrawElements() const;
	bool testDrawElementsInstanced() const;
	void testInit();
	bool testIteration(_iteration iteration);

	bool testProgram(_iteration iteration, GLuint program_id, bool use_arrays) const;

	bool testProgramWithConstant(_iteration iteration, GLuint program_id, bool use_arrays) const;

	bool testProgramWithDivisor(_iteration iteration, GLuint program_id, bool use_arrays) const;

	bool verifyResult(bool use_instancing) const;

	/* Private fields */
	/* Constants */
	static const GLint  m_array_attribute = -1;
	static const GLuint m_n_instances	 = 16;
	static const GLuint m_n_varyings	  = 1;
	static const GLuint m_n_vertices	  = 1024;
	static const GLuint m_transform_feedback_buffer_size =
		sizeof(_varyingType) * m_n_instances * m_n_vertices * m_n_varyings;

	/* GL objects */
	GLuint m_element_array_buffer_id;
	GLuint m_transoform_feedback_buffer_id;
	GLuint m_vertex_array_buffer_id;
	GLuint m_vertex_array_object_id;
};

/** Constructor
 *
 **/
LimitTest::programInfo::programInfo(const glw::Functions& gl_functions)
	: m_fragment_shader_id(0), m_program_id(0), m_vertex_shader_id(0), gl(gl_functions)
{
	/* Nothing to be done here */
}

/** Destructor
 *
 **/
LimitTest::programInfo::~programInfo()
{
	if (0 != m_program_id)
	{
		gl.deleteProgram(m_program_id);
		m_program_id = 0;
	}

	if (0 != m_fragment_shader_id)
	{
		gl.deleteShader(m_fragment_shader_id);
		m_fragment_shader_id = 0;
	}

	if (0 != m_vertex_shader_id)
	{
		gl.deleteShader(m_vertex_shader_id);
		m_vertex_shader_id = 0;
	}
}

/** Constructor
 *
 * @param context CTS context
 **/
LimitTest::LimitTest(deqp::Context& context)
	: Base(context, "limits_test", "Verify that maximum allowed number of attribiutes can be used")
	, m_element_array_buffer_id(0)
	, m_transoform_feedback_buffer_id(0)
	, m_vertex_array_buffer_id(0)
	, m_vertex_array_object_id(0)
{
	/* Nothing to be done here */
}

/** Clean up after test
 *
 **/
void LimitTest::deinit()
{
	/* Restore default settings */
	if (0 != gl.disable)
	{
		gl.disable(GL_RASTERIZER_DISCARD);
	}

	/* Delete GL objects */
	if (0 != m_element_array_buffer_id)
	{
		gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
		gl.deleteBuffers(1, &m_element_array_buffer_id);
		m_element_array_buffer_id = 0;
	}

	if (0 != m_transoform_feedback_buffer_id)
	{
		gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, 0);
		gl.deleteBuffers(1, &m_transoform_feedback_buffer_id);
		m_transoform_feedback_buffer_id = 0;
	}

	if (0 != m_vertex_array_buffer_id)
	{
		gl.bindBuffer(GL_ARRAY_BUFFER, 0);
		gl.deleteBuffers(1, &m_vertex_array_buffer_id);
		m_vertex_array_buffer_id = 0;
	}

	if (0 != m_vertex_array_object_id)
	{
		gl.bindVertexArray(0);
		gl.deleteVertexArrays(1, &m_vertex_array_object_id);
		m_vertex_array_object_id = 0;
	}
}

/** Execute test
 *
 * @return tcu::TestNode::STOP
 **/
tcu::TestNode::IterateResult LimitTest::iterate()
{
	IterateStart();

	bool result = true;

	RequireExtension("GL_ARB_vertex_attrib_64bit");

	testInit();

	if (false == testIteration(DOUBLE_DVEC2))
	{
		result = false;
	}

	if (false == testIteration(DVEC3_DVEC4))
	{
		result = false;
	}

	if (false == testIteration(DMAT2))
	{
		result = false;
	}

	if (false == testIteration(DMAT3X2_DMAT4X2))
	{
		result = false;
	}

	if (false == testIteration(DMAT2X3_DMAT2X4))
	{
		result = false;
	}

	if (false == testIteration(DMAT3_DMAT3X4))
	{
		result = false;
	}

	if (false == testIteration(DMAT4X3_DMAT4))
	{
		result = false;
	}

	/* Done */
	return IterateStop(result);
}

/** Calculate offset of "n_type" attributes group in doubles, tightly packed, for vertex buffer offsets
 *
 * @param configuration Attribute configuration
 * @param n_type        Attribute type ordinal number
 *
 * @return Calculated offset
 **/
GLint LimitTest::calculateAttributeGroupOffset(const attributeConfiguration& configuration, GLint n_type) const
{
	GLint result = 0;

	for (GLint i = 0; i < n_type; ++i)
	{
		result += configuration.m_n_attributes_per_group * configuration.m_n_elements[i];
	}

	return result;
}

/** Calculates attribute location for manually setting "layout(location =)".
 *  Results are in reveresed order of vertex buffer
 *
 * @param configuration Attribute configuration
 * @param attribute     Intex of attribute in "n_type" group
 * @param n_type        Ordinal number of type
 *
 * @return Calculated location
 **/
GLint LimitTest::calculateAttributeLocation(const attributeConfiguration& configuration, GLint attribute,
											GLint n_type) const
{
	const GLint n_types = configuration.m_n_types;
	GLint		result  = 0;

	/* Amount of location required for types after given "n_type" */
	for (GLint i = n_types - 1; i > n_type; --i)
	{
		const GLint n_elements = configuration.m_n_elements[i];
		const GLint n_rows	 = configuration.m_n_rows[i];
		const GLint n_columns  = n_elements / n_rows;

		result += n_columns * configuration.m_n_attributes_per_group;
	}

	/* Amount of locations required for attributes after given attribute in given "n_type" */
	/* Arrayed attributes does not have any attributes after */
	if (m_array_attribute != attribute)
	{
		const GLint n_elements = configuration.m_n_elements[n_type];
		const GLint n_rows	 = configuration.m_n_rows[n_type];
		const GLint n_columns  = n_elements / n_rows;

		result += n_columns * (configuration.m_n_attributes_per_group - 1 - attribute);
	}

	/* Done */
	return result;
}

/** Calculate vertex length in "doubles", tightly packed, for offset in vertex buffer
 *
 * @param configuration Attribute configuration, result is store as field ::m_vertex_length
 **/
void LimitTest::calculateVertexLength(attributeConfiguration& configuration) const
{
	GLint result = 0;

	for (GLint i = 0; i < configuration.m_n_types; ++i)
	{
		result += configuration.m_n_elements[i] * configuration.m_n_attributes_per_group;
	}

	configuration.m_vertex_length = result;
}

/** Configure attributes in given "n_type" group
 *
 * @param iteration        Iteration id
 * @param configuration    Configuration of attributes
 * @param n_type           "n_type" of attibutes
 * @param program_id       Program object id
 * @param use_arrays       If attributes are groupd in arrays
 * @param use_vertex_array If attributes are configured with vertex array or as constants
 **/
void LimitTest::configureAttribute(_iteration iteration, const attributeConfiguration& configuration, GLint n_type,
								   GLuint program_id, bool use_arrays, bool use_vertex_array) const
{
	static const GLint invalid_attrib_location = -1;

	const GLint attributes_index = n_type * configuration.m_n_attributes_per_group;
	const GLint group_offset	 = calculateAttributeGroupOffset(configuration, n_type);
	const GLint n_elements		 = configuration.m_n_elements[n_type];
	const GLint n_rows			 = configuration.m_n_rows[n_type];
	const GLint n_columns		 = n_elements / n_rows;
	const GLint vertex_length	= configuration.m_vertex_length;

	/* For each attribute in "n_type" group */
	for (GLint i = 0; i < configuration.m_n_attributes_per_group; ++i)
	{
		const GLint		  attribute_ordinal = i + attributes_index;
		std::stringstream attribute_name;

		/* Separate attributes are called: attribute_ORDINAL, arrayed: attribute_N_TYPE[INDEX] */
		if (false == use_arrays)
		{
			attribute_name << "attribute_" << attribute_ordinal;
		}
		else
		{
			attribute_name << "attribute_" << n_type << "[" << i << "]";
		}

		/* get location */
		GLint attribute_location = gl.getAttribLocation(program_id, attribute_name.str().c_str());
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetAttribLocation");

		if (invalid_attrib_location == attribute_location)
		{
			m_log << tcu::TestLog::Message << "GetAttribLocation(" << program_id << ", " << attribute_name.str()
				  << ") returned: " << attribute_location << tcu::TestLog::EndMessage;

			TCU_FAIL("Inactive attribute");
		}

		/* Configure */
		if (true == use_vertex_array)
		{
			/* With vertex array */
			for (GLint column = 0; column < n_columns; ++column)
			{
				const GLint attribute_offset = group_offset + i * n_elements;
				const GLint column_offset	= column * n_rows;

				gl.enableVertexAttribArray(attribute_location + column);
				GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray");

				gl.vertexAttribLPointer(attribute_location + column, n_rows /* size */, GL_DOUBLE,
										static_cast<glw::GLsizei>(vertex_length * sizeof(GLdouble)),
										(GLvoid*)((attribute_offset + column_offset) * sizeof(GLdouble)));
				GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribLPointer");
			}
		}
		else
		{
			/* As constant */
			for (GLint column = 0; column < n_columns; ++column)
			{
				switch (iteration)
				{
				case DOUBLE_DVEC2:

					/* Double attributes should be assigned the value:
					 (n_attribute + gl_VertexID * 2) */
					/* Dvec2 attribute components should be assigned the following
					 vector values:
					 (n_attribute + gl_VertexID * 3 + 1,
					 n_attribute + gl_VertexID * 3 + 2)*/

					if (1 == n_rows)
					{
						gl.vertexAttribL1d(attribute_location, attribute_ordinal);
					}
					else
					{
						gl.vertexAttribL2d(attribute_location, attribute_ordinal + 1, attribute_ordinal + 2);
					}

					break;

				case DVEC3_DVEC4:

					/* Dvec3 attribute components should be assigned the following
					 vector values:
					 (n_attribute + gl_VertexID * 3 + 0,
					 n_attribute + gl_VertexID * 3 + 1,
					 n_attribute + gl_VertexID * 3 + 2).

					 Dvec4 attribute components should be assigned the following
					 vector values:
					 (n_attribute + gl_VertexID * 4 + 0,
					 n_attribute + gl_VertexID * 4 + 1,
					 n_attribute + gl_VertexID * 4 + 2,
					 n_attribute + gl_VertexID * 4 + 3).*/

					if (3 == n_rows)
					{
						gl.vertexAttribL3d(attribute_location, attribute_ordinal + 0, attribute_ordinal + 1,
										   attribute_ordinal + 2);
					}
					else
					{
						gl.vertexAttribL4d(attribute_location, attribute_ordinal + 0, attribute_ordinal + 1,
										   attribute_ordinal + 2, attribute_ordinal + 3);
					}

					break;

				case DMAT2:
				case DMAT3X2_DMAT4X2:
				case DMAT2X3_DMAT2X4:
				case DMAT3_DMAT3X4:
				case DMAT4X3_DMAT4:

					/* Subsequent matrix elements should be assigned the following value:
					 (n_type + n_attribute + gl_VertexID * 16 + n_value)*/

					if (2 == n_rows)
					{
						gl.vertexAttribL2d(attribute_location + column,
										   n_type + attribute_ordinal + 0 + column * n_rows,
										   n_type + attribute_ordinal + 1 + column * n_rows);
					}
					else if (3 == n_rows)
					{
						gl.vertexAttribL3d(attribute_location + column,
										   n_type + attribute_ordinal + 0 + column * n_rows,
										   n_type + attribute_ordinal + 1 + column * n_rows,
										   n_type + attribute_ordinal + 2 + column * n_rows);
					}
					else
					{
						gl.vertexAttribL4d(attribute_location + column,
										   n_type + attribute_ordinal + 0 + column * n_rows,
										   n_type + attribute_ordinal + 1 + column * n_rows,
										   n_type + attribute_ordinal + 2 + column * n_rows,
										   n_type + attribute_ordinal + 3 + column * n_rows);
					}

					break;
				}
			}
		}
	}
}

/** Get varying name and vertex shader code for given configuration
 *
 * @param iteration                 Iteration id
 * @param use_arrays                If attributes should be grouped in arrays
 * @param use_locations             If attributes locations should be set manualy
 * @param use_vertex_attrib_divisor If vertex attribute divisor should be used
 * @param out_varying_name          Name of varying to be captured with transform feedback
 * @param out_vertex_shader_code    Source code of vertex shader
 **/
void LimitTest::getProgramDetails(_iteration iteration, bool use_arrays, bool use_locations,
								  bool use_vertex_attrib_divisor, std::string& out_varying_name,
								  std::string& out_vertex_shader_code) const
{
	static const GLchar* varying_name = "vs_output_value";

	attributeConfiguration configuration;
	GLint				   n_attributes = 0;
	GLint				   n_types		= 0;
	std::stringstream	  stream;

	const GLchar* advancement_str = (true == use_vertex_attrib_divisor) ? "gl_InstanceID" : "gl_VertexID";

	getVertexArrayConfiguration(iteration, configuration);

	n_attributes = configuration.m_n_attributes_per_group;
	n_types		 = configuration.m_n_types;

	/* Preamble */
	stream << "#version 400\n"
			  "#extension GL_ARB_vertex_attrib_64bit : require\n"
			  "\n"
			  "precision highp float;\n"
			  "\n";

	/* Attribute declarations */
	/* Spearated attributes are called: attribute_ORDINAL, arrayed: attribute_N_TYPE */
	for (GLint n_type = 0; n_type < n_types; ++n_type)
	{
		const GLint   attribute_offset = n_type * n_attributes;
		const GLchar* type_name		   = configuration.m_type_names[n_type];

		stream << "// " << type_name << "\n";

		if (false == use_arrays)
		{
			for (GLint attribute = 0; attribute < n_attributes; ++attribute)
			{
				if (true == use_locations)
				{
					const GLint location = calculateAttributeLocation(configuration, attribute, n_type);

					stream << "layout(location = " << location << ") ";
				}

				stream << "in " << type_name << " attribute_" << attribute + attribute_offset << ";\n";
			}
		}
		else
		{
			if (true == use_locations)
			{
				const GLint location = calculateAttributeLocation(configuration, m_array_attribute, n_type);

				stream << "layout(location = " << location << ") ";
			}

			stream << "in " << type_name << " attribute_" << n_type << "[" << n_attributes << "];\n";
		}

		stream << "\n";
	}

	/* Varying declaration */
	stream << "out int " << varying_name << ";\n\n";

	/* Main */
	stream << "void main()\n"
			  "{\n";

	for (GLint n_type = 0; n_type < n_types; ++n_type)
	{
		const GLint   n_elements = configuration.m_n_elements[n_type];
		const GLchar* type_name  = configuration.m_type_names[n_type];

		stream << "// " << type_name << "\n";

		/* if (attribute_name != type(values))
		 * {
		 *     varying = 0;
		 * }
		 */
		for (GLint attribute = 0; attribute < n_attributes; ++attribute)
		{
			const GLint attribute_ordinal = attribute + n_type * n_attributes;

			/* First attribute is verified with "if", rest with "else if" */
			if (0 == attribute_ordinal)
			{
				stream << "    if (attribute_";
			}
			else
			{
				stream << "    else if (attribute_";
			}

			/* Spearated attributes are called: attribute_ORDINAL, arrayed: attribute_N_TYPE[INDEX] */
			if (false == use_arrays)
			{
				stream << attribute_ordinal;
			}
			else
			{
				stream << n_type << "[" << attribute << "]";
			}

			/* != type() */
			stream << " != " << type_name << "(";

			/* Values for type constructor, depend on iteration */
			switch (iteration)
			{
			case DOUBLE_DVEC2:

				/* Double attributes should be assigned the value:
				 (n_attribute + gl_VertexID * 2) */
				/* Dvec2 attribute components should be assigned the following
				 vector values:
				 (n_attribute + gl_VertexID * 3 + 1,
				 n_attribute + gl_VertexID * 3 + 2)*/

				if (1 == n_elements)
				{
					stream << attribute_ordinal << " + " << advancement_str << " * 2";
				}
				else
				{
					stream << attribute_ordinal << " + " << advancement_str << " * 3 + 1"
						   << ", " << attribute_ordinal << " + " << advancement_str << " * 3 + 2";
				}

				break;

			case DVEC3_DVEC4:

				/* Dvec3 attribute components should be assigned the following
				 vector values:
				 (n_attribute + gl_VertexID * 3 + 0,
				 n_attribute + gl_VertexID * 3 + 1,
				 n_attribute + gl_VertexID * 3 + 2).

				 Dvec4 attribute components should be assigned the following
				 vector values:
				 (n_attribute + gl_VertexID * 4 + 0,
				 n_attribute + gl_VertexID * 4 + 1,
				 n_attribute + gl_VertexID * 4 + 2,
				 n_attribute + gl_VertexID * 4 + 3).*/

				for (GLint element = 0; element < n_elements; ++element)
				{
					stream << attribute_ordinal << " + " << advancement_str << " * " << n_elements << " + " << element;

					if (n_elements != element + 1)
					{
						stream << ", ";
					}
				}

				break;

			case DMAT2:
			case DMAT3X2_DMAT4X2:
			case DMAT2X3_DMAT2X4:
			case DMAT3_DMAT3X4:
			case DMAT4X3_DMAT4:

				/* Subsequent matrix elements should be assigned the following value:
				 (n_type + n_attribute + gl_VertexID * 16 + n_value)*/

				for (GLint element = 0; element < n_elements; ++element)
				{
					stream << n_type << " + " << attribute_ordinal << " + " << advancement_str << " * 16 + " << element;

					if (n_elements != element + 1)
					{
						stream << ", ";
					}
				}

				break;
			}

			/* type() { varying = 0 } */
			stream << "))\n"
				   << "    {\n"
				   << "        " << varying_name << " = 0;\n"
				   << "    }\n";
		}
	}

	/* All attributes verified: else { varyin = 1 }
	 Close main body */
	stream << "    else\n"
		   << "    {\n"
		   << "        " << varying_name << " = 1;\n"
		   << "    }\n"
		   << "}\n\n";

	/* Store results */
	out_varying_name	   = varying_name;
	out_vertex_shader_code = stream.str();
}

/** Get configuration of vertex array object
 *
 * @param iteration         Iteration id
 * @param out_configuration Configuration
 **/
void LimitTest::getVertexArrayConfiguration(_iteration iteration, attributeConfiguration& out_configuration) const
{
	static const GLuint n_elements_per_scalar = 1;
	static const GLuint n_elements_per_vec2   = 2;
	static const GLuint n_elements_per_vec3   = 3;
	static const GLuint n_elements_per_vec4   = 4;
	static const GLuint n_elements_per_mat2   = 4;
	static const GLuint n_elements_per_mat2x3 = 6;
	static const GLuint n_elements_per_mat2x4 = 8;
	static const GLuint n_elements_per_mat3   = 9;
	static const GLuint n_elements_per_mat3x2 = 6;
	static const GLuint n_elements_per_mat3x4 = 12;
	static const GLuint n_elements_per_mat4   = 16;
	static const GLuint n_elements_per_mat4x2 = 8;
	static const GLuint n_elements_per_mat4x3 = 12;

	const GLint max_vertex_attribs = GetMaxVertexAttribs();

	switch (iteration)
	{
	case DOUBLE_DVEC2:
	{
		static const GLint n_elements[] = { n_elements_per_scalar, n_elements_per_vec2 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 2;

		static const GLchar* type_names[] = { "double", "dvec2" };

		static const GLint n_rows[] = {
			1, 2,
		};

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	case DVEC3_DVEC4:
	{
		static const GLint n_elements[] = { n_elements_per_vec3, n_elements_per_vec4 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 4;

		static const GLchar* type_names[] = { "dvec3", "dvec4" };

		static const GLint n_rows[] = {
			3, 4,
		};

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	case DMAT2:
	{
		static const GLint n_elements[] = { n_elements_per_mat2 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 2;

		static const GLchar* type_names[] = { "dmat2" };

		static const GLint n_rows[] = { 2 };

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	case DMAT3X2_DMAT4X2:
	{
		static const GLint n_elements[] = { n_elements_per_mat3x2, n_elements_per_mat4x2 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 8;

		static const GLchar* type_names[] = { "dmat3x2", "dmat4x2" };

		static const GLint n_rows[] = { 2, 2 };

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	case DMAT2X3_DMAT2X4:
	{
		static const GLint n_elements[] = { n_elements_per_mat2x3, n_elements_per_mat2x4 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 8;

		static const GLchar* type_names[] = { "dmat2x3", "dmat2x4" };

		static const GLint n_rows[] = { 3, 4 };

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	case DMAT3_DMAT3X4:
	{
		static const GLint n_elements[] = { n_elements_per_mat3, n_elements_per_mat3x4 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 12;

		static const GLchar* type_names[] = { "dmat3", "dmat3x4" };

		static const GLint n_rows[] = { 3, 4 };

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	case DMAT4X3_DMAT4:
	{
		static const GLint n_elements[] = { n_elements_per_mat4x3, n_elements_per_mat4 };
		static const GLint n_types		= sizeof(n_elements) / sizeof(n_elements[0]);

		static const GLint divisor = 16;

		static const GLchar* type_names[] = { "dmat4x3", "dmat4" };

		static const GLint n_rows[] = { 3, 4 };

		out_configuration.m_n_attributes_per_group = max_vertex_attribs / divisor;
		out_configuration.m_n_elements			   = n_elements;
		out_configuration.m_n_rows				   = n_rows;
		out_configuration.m_n_types				   = n_types;
		out_configuration.m_type_names			   = type_names;
	}
	break;
	}

	calculateVertexLength(out_configuration);
}

/** Logs iteration and configuration of test
 *
 * @param iteration      Iteration id
 * @param use_arrays     If attributes are grouped in arrays
 * @param use_locations  If manual attribute locations are used
 * @param attribute_type Regular, constant or per instance
 **/
void LimitTest::logTestIterationAndConfig(_iteration iteration, _attributeType attribute_type, bool use_arrays,
										  bool use_locations) const
{
	tcu::MessageBuilder message = m_log << tcu::TestLog::Message;

	switch (iteration)
	{
	case DOUBLE_DVEC2:
		message << "Iteration: double + dvec2";

		break;
	case DVEC3_DVEC4:
		message << "Iteration: devc3 + dvec4";

		break;
	case DMAT2:
		message << "Iteration: dmat2";

		break;
	case DMAT3X2_DMAT4X2:
		message << "Iteration: dmat3x2 + dmat4x2";

		break;
	case DMAT2X3_DMAT2X4:
		message << "Iteration: dmat2x3 + dmat2x4";

		break;
	case DMAT3_DMAT3X4:
		message << "Iteration: dmat3 + dmat3x4";

		break;
	case DMAT4X3_DMAT4:
		message << "Iteration: dmat4x3 + dmat4";

		break;
	}

	message << "Configuration: ";

	if (true == use_arrays)
	{
		message << "arrayed attributes";
	}
	else
	{
		message << "separate attributes";
	}

	message << ", ";

	if (true == use_locations)
	{
		message << "reversed locations";
	}
	else
	{
		message << "default locations";
	}

	message << ", ";

	switch (attribute_type)
	{
	case REGULAR:
		message << "vertex attribute divisor: 0";

		break;
	case CONSTANT:
		message << "constant vertex attribute";

		break;
	case PER_INSTANCE:
		message << "vertex attribute divisor: 1";

		break;
	}

	message << tcu::TestLog::EndMessage;
}

/** Prepare program info for given configuration
 *
 * @param iteration                 Iteration id
 * @param use_arrays                If attributes should be grouped in arrays
 * @param use_locations             If manual attribute locations should be used
 * @param use_vertex_attrib_divisor If vertex attribute divisor should be used
 * @param program_info              Program info
 **/
void LimitTest::prepareProgram(_iteration iteration, bool use_arrays, bool use_locations,
							   bool use_vertex_attrib_divisor, programInfo& program_info)
{
	static const GLchar* fragment_shader_code = "#version 400\n"
												"#extension GL_ARB_vertex_attrib_64bit : require\n"
												"\n"
												"precision highp float;\n"
												"\n"
												"void main()\n"
												"{\n"
												"    discard;\n"
												"}\n\n";
	std::string varying_name;
	std::string vertex_shader_code;

	program_info.m_program_id = gl.createProgram();
	GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram");

	getProgramDetails(iteration, use_arrays, use_locations, use_vertex_attrib_divisor, varying_name,
					  vertex_shader_code);

	{
		const GLchar* temp_varying_name = varying_name.c_str();

		gl.transformFeedbackVaryings(program_info.m_program_id, m_n_varyings, &temp_varying_name,
									 GL_INTERLEAVED_ATTRIBS);
		GLU_EXPECT_NO_ERROR(gl.getError(), "TransformFeedbackVaryings");
	}

	BuildProgram(fragment_shader_code, program_info.m_program_id, vertex_shader_code.c_str(),
				 program_info.m_fragment_shader_id, program_info.m_vertex_shader_id);
}

/** Configure vertex array object for all attributes
 *
 * @param iteration      Iteration id
 * @param attribute_type Regular, constant or per instance
 * @param program_id     Program object id
 * @param use_arrays     If attributes are grouped with arrays
 **/
void LimitTest::prepareVertexArray(_iteration iteration, _attributeType attribute_type, GLuint program_id,
								   bool use_arrays) const
{
	const GLint  max_vertex_attribs	= GetMaxVertexAttribs();
	const GLuint vertex_attrib_divisor = (PER_INSTANCE == attribute_type) ? 1 : 0;

	attributeConfiguration configuration;

	getVertexArrayConfiguration(iteration, configuration);

	/* Set vertex attributes divisor and disable */
	for (GLint i = 0; i < max_vertex_attribs; ++i)
	{
		gl.vertexAttribDivisor(i, vertex_attrib_divisor);
		GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribDivisor");

		gl.disableVertexAttribArray(i);
		GLU_EXPECT_NO_ERROR(gl.getError(), "DisableVertexAttribArray");
	}

	for (GLint n_type = 0; n_type < configuration.m_n_types; ++n_type)
	{
		configureAttribute(iteration, configuration, n_type, program_id, use_arrays, (CONSTANT != attribute_type));
	}
}

/** Prepare vertex buffer data for given iteration
 *
 * @param iteration Iteration id
 **/
void LimitTest::prepareVertexArrayBuffer(_iteration iteration)
{
	GLuint				   buffer_length = 0;
	attributeConfiguration configuration;

	getVertexArrayConfiguration(iteration, configuration);

	buffer_length = m_n_vertices * configuration.m_vertex_length;

	std::vector<GLdouble> buffer_data;
	buffer_data.resize(buffer_length);

	for (GLuint vertex = 0; vertex < m_n_vertices; ++vertex)
	{
		setAttributes(iteration, configuration, vertex, buffer_data);
	}

	gl.bufferData(GL_ARRAY_BUFFER, buffer_length * sizeof(GLdouble), &buffer_data[0], GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData");
}

/** Set all attributes for <vertex>
 *
 * @param iteration       Iteration id
 * @param configuration   Attribute configuration
 * @param vertex          Vertex orinal number
 * @param out_buffer_data Buffer data
 **/
void LimitTest::setAttributes(_iteration iteration, const attributeConfiguration& configuration, GLuint vertex,
							  std::vector<GLdouble>& out_buffer_data) const
{
	const GLint n_types = configuration.m_n_types;

	for (GLint n_type = 0; n_type < n_types; ++n_type)
	{
		switch (iteration)
		{
		case DOUBLE_DVEC2:

			setAttributes_a(configuration, n_type, vertex, out_buffer_data);

			break;

		case DVEC3_DVEC4:

			setAttributes_b(configuration, n_type, vertex, out_buffer_data);

			break;

		case DMAT2:
		case DMAT3X2_DMAT4X2:
		case DMAT2X3_DMAT2X4:
		case DMAT3_DMAT3X4:
		case DMAT4X3_DMAT4:

			setAttributes_c(configuration, n_type, vertex, out_buffer_data);

			break;
		}
	}
}

/** Set attributes of given <n_type> for <vertex>, as described in "iteration a".
 *
 * @param configuration   Attribute configuration
 * @param n_type          "n_type" ordinal number
 * @param vertex          Vertex orinal number
 * @param out_buffer_data Buffer data
 **/
void LimitTest::setAttributes_a(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
								std::vector<GLdouble>& out_buffer_data) const
{
	const GLint n_elements = configuration.m_n_elements[n_type];

	if (1 == n_elements)
	{
		setAttributes_a_scalar(configuration, n_type, vertex, out_buffer_data);
	}
	else
	{
		setAttributes_a_vec(configuration, n_type, vertex, out_buffer_data);
	}
}

/** Set scalar double attributes of given <n_type> for <vertex>, as described in "iteration a".
 *
 * @param configuration   Attribute configuration
 * @param n_type          "n_type" ordinal number
 * @param vertex          Vertex orinal number
 * @param out_buffer_data Buffer data
 **/
void LimitTest::setAttributes_a_scalar(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
									   std::vector<GLdouble>& out_buffer_data) const
{
	const GLint n_attributes	= configuration.m_n_attributes_per_group;
	const GLint attribute_index = n_attributes * n_type;
	GLuint		vertex_offset   = vertex * configuration.m_vertex_length;

	const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset;

	/* Double attributes should be assigned the value:
	 (n_attribute + gl_VertexID * 2) */

	for (GLint attribute = 0; attribute < n_attributes; ++attribute)
	{
		const GLuint attribute_offset = attribute + group_offset;

		out_buffer_data[attribute_offset] = attribute + attribute_index + vertex * 2;
	}
}

/** Set dvec2 attributes of given <n_type> for <vertex>, as described in "iteration a".
 *
 * @param configuration   Attribute configuration
 * @param n_type          "n_type" ordinal number
 * @param vertex          Vertex orinal number
 * @param out_buffer_data Buffer data
 **/
void LimitTest::setAttributes_a_vec(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
									std::vector<GLdouble>& out_buffer_data) const
{
	const GLint n_attributes	= configuration.m_n_attributes_per_group;
	const GLint attribute_index = n_attributes * n_type;
	const GLint n_elements		= configuration.m_n_elements[n_type];
	GLuint		vertex_offset   = vertex * configuration.m_vertex_length;

	const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset;

	/* Dvec2 attribute components should be assigned the following
	 vector values:
	 (n_attribute + gl_VertexID * 3 + 1,
	 n_attribute + gl_VertexID * 3 + 2)*/

	for (GLint attribute = 0; attribute < n_attributes; ++attribute)
	{
		const GLuint attribute_offset = n_elements * attribute + group_offset;

		for (GLint i = 0; i < n_elements; ++i)
		{
			out_buffer_data[attribute_offset + i] = attribute + attribute_index + vertex * 3 + i + 1;
		}
	}
}

/** Set attributes of given <n_type> for <vertex>, as described in "iteration b".
 *
 * @param configuration   Attribute configuration
 * @param n_type          "n_type" ordinal number
 * @param vertex          Vertex orinal number
 * @param out_buffer_data Buffer data
 **/
void LimitTest::setAttributes_b(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
								std::vector<GLdouble>& out_buffer_data) const
{
	const GLint n_attributes	= configuration.m_n_attributes_per_group;
	const GLint attribute_index = n_attributes * n_type;
	const GLint n_elements		= configuration.m_n_elements[n_type];
	GLuint		vertex_offset   = vertex * configuration.m_vertex_length;

	const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset;

	/* Dvec3 attribute components should be assigned the following
	 vector values:
	 (n_attribute + gl_VertexID * 3 + 0,
	 n_attribute + gl_VertexID * 3 + 1,
	 n_attribute + gl_VertexID * 3 + 2).

	 Dvec4 attribute components should be assigned the following
	 vector values:
	 (n_attribute + gl_VertexID * 4 + 0,
	 n_attribute + gl_VertexID * 4 + 1,
	 n_attribute + gl_VertexID * 4 + 2,
	 n_attribute + gl_VertexID * 4 + 3).*/

	for (GLint attribute = 0; attribute < n_attributes; ++attribute)
	{
		const GLuint attribute_offset = n_elements * attribute + group_offset;

		for (GLint i = 0; i < n_elements; ++i)
		{
			out_buffer_data[attribute_offset + i] = attribute + attribute_index + vertex * n_elements + i;
		}
	}
}

/** Set attributes of given <n_type> for <vertex>, as described in "iteration c".
 *
 * @param configuration   Attribute configuration
 * @param n_type          "n_type" ordinal number
 * @param vertex          Vertex orinal number
 * @param out_buffer_data Buffer data
 **/
void LimitTest::setAttributes_c(const attributeConfiguration& configuration, GLint n_type, GLuint vertex,
								std::vector<GLdouble>& out_buffer_data) const
{
	const GLint n_attributes	= configuration.m_n_attributes_per_group;
	const GLint attribute_index = n_attributes * n_type;
	const GLint n_elements		= configuration.m_n_elements[n_type];
	GLuint		vertex_offset   = vertex * configuration.m_vertex_length;

	const GLint group_offset = calculateAttributeGroupOffset(configuration, n_type) + vertex_offset;

	/* Subsequent matrix elements should be assigned the following value:
	 (n_type + n_attribute + gl_VertexID * 16 + n_value)*/

	for (GLint attribute = 0; attribute < n_attributes; ++attribute)
	{
		const GLuint attribute_offset = n_elements * attribute + group_offset;

		for (GLint i = 0; i < n_elements; ++i)
		{
			out_buffer_data[attribute_offset + i] = n_type + attribute + attribute_index + vertex * 16 + i;
		}
	}
}

/** Run test with DrawArrays routine
 *
 * @return true if test pass, false otherwise
 **/
bool LimitTest::testDrawArrays() const
{
	gl.beginTransformFeedback(GL_POINTS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");

	gl.drawArrays(GL_POINTS, 0 /* first */, m_n_vertices);
	GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");

	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");

	if (true == verifyResult(false))
	{
		return true;
	}
	else
	{
		m_log << tcu::TestLog::Message << "Draw function: DrawArrays" << tcu::TestLog::EndMessage;

		return false;
	}
}

/** Run test with DrawArraysInstanced routine
 *
 * @return true if test pass, false otherwise
 **/
bool LimitTest::testDrawArraysInstanced() const
{
	gl.beginTransformFeedback(GL_POINTS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");

	gl.drawArraysInstanced(GL_POINTS, 0 /* first */, m_n_vertices, m_n_instances);
	GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArraysInstanced");

	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");

	if (true == verifyResult(true))
	{
		return true;
	}
	else
	{
		m_log << tcu::TestLog::Message << "Draw function: DrawArraysInstanced" << tcu::TestLog::EndMessage;

		return false;
	}
}

/** Run test with DrawElements routine
 *
 * @return true if test pass, false otherwise
 **/
bool LimitTest::testDrawElements() const
{
	gl.beginTransformFeedback(GL_POINTS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");

	gl.drawElements(GL_POINTS, m_n_vertices, GL_UNSIGNED_INT, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "DrawElements");

	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");

	if (true == verifyResult(false))
	{
		return true;
	}
	else
	{
		m_log << tcu::TestLog::Message << "Draw function: DrawElements" << tcu::TestLog::EndMessage;

		return false;
	}
}

/** Run test with DrawElementsInstanced routine
 *
 * @return true if test pass, false otherwise
 **/
bool LimitTest::testDrawElementsInstanced() const
{
	gl.beginTransformFeedback(GL_POINTS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BeginTransformFeedback");

	gl.drawElementsInstanced(GL_POINTS, m_n_vertices, GL_UNSIGNED_INT, 0, m_n_instances);
	GLU_EXPECT_NO_ERROR(gl.getError(), "DrawElementsInstanced");

	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "EndTransformFeedback");

	if (true == verifyResult(true))
	{
		return true;
	}
	else
	{
		m_log << tcu::TestLog::Message << "Draw function: DrawElementsInstanced" << tcu::TestLog::EndMessage;

		return false;
	}
}

/** Test initialisation
 *
 **/
void LimitTest::testInit()
{
	/* Prepare data for element array buffer */
	std::vector<GLuint> indices_data;
	indices_data.resize(m_n_vertices);
	for (GLuint i = 0; i < m_n_vertices; ++i)
	{
		indices_data[i] = i;
	}

	/* Prepare vertex array object */
	gl.genVertexArrays(1, &m_vertex_array_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays");

	gl.bindVertexArray(m_vertex_array_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArray");

	/* Generate buffers */
	gl.genBuffers(1, &m_element_array_buffer_id);
	gl.genBuffers(1, &m_transoform_feedback_buffer_id);
	gl.genBuffers(1, &m_vertex_array_buffer_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers");

	/* Prepare element array buffer */
	gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_element_array_buffer_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

	gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, m_n_vertices * sizeof(GLuint), &indices_data[0], GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData");

	/* Prepare transform feedback buffer */
	gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_transoform_feedback_buffer_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

	gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, m_transform_feedback_buffer_size, 0 /* data */, GL_DYNAMIC_COPY);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData");

	/* Bind array buffer for future use */
	gl.bindBuffer(GL_ARRAY_BUFFER, m_vertex_array_buffer_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

	/* Disabe rasterization */
	gl.enable(GL_RASTERIZER_DISCARD);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Enable");
}

/** Tests specified "iteration"
 *
 * @param iteration Iteration id
 *
 * @return true if tests pass, false otherwise
 **/
bool LimitTest::testIteration(_iteration iteration)
{
	bool result = true;

	/* Program infos */
	programInfo _no_array__no_location______regular(gl);
	programInfo use_array__no_location______regular(gl);
	programInfo _no_array_use_location______regular(gl);
	programInfo use_array_use_location______regular(gl);
	programInfo _no_array__no_location_per_instance(gl);
	programInfo use_array__no_location_per_instance(gl);
	programInfo _no_array_use_location_per_instance(gl);
	programInfo use_array_use_location_per_instance(gl);

	/* Prepare programs for all configuration */
	prepareProgram(iteration, false, false, false, _no_array__no_location______regular);
	prepareProgram(iteration, true, false, false, use_array__no_location______regular);
	prepareProgram(iteration, false, true, false, _no_array_use_location______regular);
	prepareProgram(iteration, true, true, false, use_array_use_location______regular);
	prepareProgram(iteration, false, false, true, _no_array__no_location_per_instance);
	prepareProgram(iteration, true, false, true, use_array__no_location_per_instance);
	prepareProgram(iteration, false, true, true, _no_array_use_location_per_instance);
	prepareProgram(iteration, true, true, true, use_array_use_location_per_instance);

	/* Bind buffers */
	gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_element_array_buffer_id);
	gl.bindBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_transoform_feedback_buffer_id, 0,
					   m_transform_feedback_buffer_size);
	GLU_EXPECT_NO_ERROR(gl.getError(), "BindBufferRange");

	/* Prepare vertex array buffer for iteration */
	prepareVertexArrayBuffer(iteration);

	/* Regular and instanced draw calls, vertex attribute divisor: 0 */
	if (false == testProgram(iteration, _no_array__no_location______regular.m_program_id, false))
	{
		logTestIterationAndConfig(iteration, REGULAR, false /* use_arrays */, false /* use_locations */);

		result = false;
	}

	if (false == testProgram(iteration, use_array__no_location______regular.m_program_id, true))
	{
		logTestIterationAndConfig(iteration, REGULAR, true /* use_arrays */, false /* use_locations */);

		result = false;
	}

	if (false == testProgram(iteration, _no_array_use_location______regular.m_program_id, false))
	{
		logTestIterationAndConfig(iteration, REGULAR, false /* use_arrays */, true /* use_locations */);

		result = false;
	}

	if (false == testProgram(iteration, use_array_use_location______regular.m_program_id, true))
	{
		logTestIterationAndConfig(iteration, REGULAR, true /* use_arrays */, true /* use_locations */);

		result = false;
	}

	/* Regular draw calls, constant vertex attribute */
	if (false == testProgramWithConstant(iteration, _no_array__no_location_per_instance.m_program_id, false))
	{
		logTestIterationAndConfig(iteration, CONSTANT, false /* use_arrays */, false /* use_locations */);

		result = false;
	}

	if (false == testProgramWithConstant(iteration, use_array__no_location_per_instance.m_program_id, true))
	{
		logTestIterationAndConfig(iteration, CONSTANT, true /* use_arrays */, false /* use_locations */);

		result = false;
	}

	if (false == testProgramWithConstant(iteration, _no_array_use_location_per_instance.m_program_id, false))
	{
		logTestIterationAndConfig(iteration, CONSTANT, false /* use_arrays */, true /* use_locations */);

		result = false;
	}

	if (false == testProgramWithConstant(iteration, use_array_use_location_per_instance.m_program_id, true))
	{
		logTestIterationAndConfig(iteration, CONSTANT, true /* use_arrays */, true /* use_locations */);

		result = false;
	}

	/* Instanced draw calls, vertex attribute divisor: 1 */
	if (false == testProgramWithDivisor(iteration, _no_array__no_location_per_instance.m_program_id, false))
	{
		logTestIterationAndConfig(iteration, PER_INSTANCE, false /* use_arrays */, false /* use_locations */);

		result = false;
	}

	if (false == testProgramWithDivisor(iteration, use_array__no_location_per_instance.m_program_id, true))
	{
		logTestIterationAndConfig(iteration, PER_INSTANCE, true /* use_arrays */, false /* use_locations */);

		result = false;
	}

	if (false == testProgramWithDivisor(iteration, _no_array_use_location_per_instance.m_program_id, false))
	{
		logTestIterationAndConfig(iteration, PER_INSTANCE, false /* use_arrays */, true /* use_locations */);

		result = false;
	}

	if (false == testProgramWithDivisor(iteration, use_array_use_location_per_instance.m_program_id, true))
	{
		logTestIterationAndConfig(iteration, PER_INSTANCE, true /* use_arrays */, true /* use_locations */);

		result = false;
	}

	/* Done */
	return result;
}

/** Tests regular and instanced draw calls with vertex attribute divisor set to 0
 *
 * @param iteration  Iteration id
 * @param program_id Program object id
 * @param use_arrays true if arrays of attributes are used
 *
 * @return true if tests pass, false otherwise
 **/
bool LimitTest::testProgram(_iteration iteration, GLuint program_id, bool use_arrays) const
{
	bool result = true;

	gl.useProgram(program_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");

	prepareVertexArray(iteration, REGULAR, program_id, use_arrays);

	if (false == testDrawArrays())
	{
		result = false;
	}

	if (false == testDrawElements())
	{
		result = false;
	}

	if (false == testDrawArraysInstanced())
	{
		result = false;
	}

	if (false == testDrawElementsInstanced())
	{
		result = false;
	}

	return result;
}

/** Tests constant attributes value, set with VertexAttribLd* routines
 *
 * @param iteration  Iteration id
 * @param program_id Program object id
 * @param use_arrays true if arrays of attributes are used
 *
 * @return true if tests pass, false otherwise
 **/
bool LimitTest::testProgramWithConstant(_iteration iteration, GLuint program_id, bool use_arrays) const
{
	bool result = true;

	gl.useProgram(program_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");

	prepareVertexArray(iteration, CONSTANT, program_id, use_arrays);

	if (false == testDrawArrays())
	{
		result = false;
	}

	if (false == testDrawElements())
	{
		result = false;
	}

	return result;
}

/** Tests instanced draw calls with vertex attribute divisor set to 1
 *
 * @param iteration  Iteration id
 * @param program_id Program object id
 * @param use_arrays true if arrays of attributes are used
 *
 * @return true if tests pass, false otherwise
 **/
bool LimitTest::testProgramWithDivisor(_iteration iteration, GLuint program_id, bool use_arrays) const
{
	bool result = true;

	gl.useProgram(program_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");

	prepareVertexArray(iteration, PER_INSTANCE, program_id, use_arrays);

	if (false == testDrawArraysInstanced())
	{
		result = false;
	}

	if (false == testDrawElementsInstanced())
	{
		result = false;
	}

	return result;
}

/** Verifies results
 *
 * @param use_instancing true if instanced draw call was made, otherwise false
 *
 * @result true if all vertices outputed 1, false otherwise
 **/
bool LimitTest::verifyResult(bool use_instancing) const
{
	_varyingType* buffer_data = (_varyingType*)gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);
	const GLuint  n_instances = (true == use_instancing) ? m_n_instances : 1;
	bool		  result	  = true;

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

	if (0 == buffer_data)
	{
		TCU_FAIL("Failed to map GL_TRANSFORM_FEEDBACK_BUFFER buffer");
	}

	/* For each instance */
	for (GLuint instance = 0; instance < n_instances; ++instance)
	{
		const GLuint instance_offset = instance * m_n_vertices * m_n_varyings;

		/* For each vertex */
		for (GLuint vertex = 0; vertex < m_n_vertices; ++vertex)
		{
			const GLuint vertex_offset = vertex * m_n_varyings;

			if (1 != buffer_data[vertex_offset + instance_offset])
			{
				if (true == use_instancing)
				{
					m_log << tcu::TestLog::Message << "Failure. Instance: " << instance << " Vertex: " << vertex
						  << tcu::TestLog::EndMessage;
				}
				else
				{
					m_log << tcu::TestLog::Message << "Failure. Vertex: " << vertex << tcu::TestLog::EndMessage;
				}

				/* Save failure and break loop */
				result = false;

				/* Sorry about that, but this is nested loop */
				goto end;
			}
		}
	}

end:
	gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "UnmapBuffer");

	return result;
}

/** Implementation of conformance test "4", description follows.
 *
 *  Make sure non-trivial VAO configurations are correctly supported
 *  for double-precision floating-point types.
 *
 *  Consider the following Vertex Buffer Object configurations:
 *
 *  BO1:
 *  0            72 73 75      91 96
 *  --------------+-+--+-------+---
 *  |      A      |B| C|    D  | E|  (times 1024)
 *  -------------------------------
 *
 *  where:
 *
 *  A: 3x3 double matrix  (72 bytes)
 *  B: 1 unsigned byte    (1  byte)
 *  C: 1 short            (2  bytes)
 *  D: 2 doubles          (16 bytes)
 *  E: padding            (5  bytes)
 *                     (+) --------
 *                         96 bytes
 *
 *  BO2:
 *  --+------------------
 *  |A|         B       |  (times 1024)
 *  --+------------------
 *
 *  where:
 *
 *  A: 1 signed byte     (1  byte)
 *  B: 4x2 double matrix (64 bytes)
 *                    (+) --------
 *                        65 bytes
 *
 *  A VAO used for the test should be configured as described
 *  below:
 *
 *  Att 0 (L): VAP-type:GL_DOUBLE,        GLSL-type: dmat3,   stride:96,
 *             offset:  0,                normalized:0,       source:BO1;
 *  Att 1 (F): VAP-type:GL_UNSIGNED_BYTE, GLSL-type: float,   stride:5,
 *             offset:  0,                normalized:1,       source:BO2;
 *  Att 2 (L): VAP-type:GL_DOUBLE,        GLSL-type: dvec2,   stride:96,
 *             offset:  75,               normalized:0,       source:BO1;
 *  Att 3 (L): VAP-type:GL_DOUBLE,        GLSL-type: double,  stride:48,
 *             offset:  0,                normalized:0,       source:BO1;
 *  Att 4 (L): VAP-type:GL_DOUBLE,        GLSL-type: dmat4x2, stride:65,
 *             offset:  1,                normalized:0,       source:BO2;
 *  Att 5 (F): VAP-type:GL_SHORT,         GLSL-type: float,   stride:96,
 *             offset:  73,               normalized:0,       source:BO1;
 *  Att 6 (I): VAP-type:GL_BYTE,          GLSL-type: int,     stride:96,
 *             offset:  72,               normalized:1,       source:BO1;
 *
 *  where:
 *
 *  GLSL-type: Input variable type, as to be used in corresponding
 *             vertex shader.
 *  (F):       glVertexAttribPointer() call should be used to configure
 *             given vertex attribute array;
 *  (I):       glVertexAttribIPointer() call should be used to configure
 *             given vertex attribute array;
 *  (L):       glVertexAttribLPointer() call should be used to configure
 *             given vertex attribute array;
 *  VAP-type:  <type> argument as passed to corresponding
 *             glVertexAttrib*Pointer() call.
 *
 *  The test should use a program object consisting only of VS.
 *  The shader should read all the attributes and store the
 *  values in corresponding output variables. These should then be
 *  XFBed out to the test implementation, which should then verify
 *  the values read in the shader are valid in light of the specification.
 *
 *  All the draw call types described in test 3) should be tested.
 *  A single draw call for each of the types, rendering a total of
 *  1024 points should be used for the purpose of the test
 *
 **/
class VAOTest : public Base
{
public:
	/* Public methods */
	VAOTest(deqp::Context& context);

	virtual ~VAOTest()
	{
	}

	/* Public methods inheritated from TestCase */
	virtual void						 deinit();
	virtual tcu::TestNode::IterateResult iterate();

private:
	/* Private type declarations */
	enum _draw_call_type
	{
		DRAW_CALL_TYPE_ARRAYS,
		DRAW_CALL_TYPE_ELEMENTS,

		/* Always last */
		DRAW_CALL_TYPE_COUNT
	};

	/* Private methods */
	bool executeTest(_draw_call_type draw_call, bool instanced, bool zero_vertex_attrib_divisor);

	void initBufferObjects();
	void initBuffers();
	void initProgramObject();
	void initVAO();

	bool verifyXFBData(const void* data, _draw_call_type draw_call, bool instanced, bool zero_vertex_attrib_divisor);

	/* Private fields */
	unsigned char*  m_bo_1_data;
	unsigned int	m_bo_1_data_size;
	unsigned int	m_bo_1_offset_matrix;
	unsigned int	m_bo_1_offset_ubyte;
	unsigned int	m_bo_1_offset_short;
	unsigned int	m_bo_1_offset_double;
	unsigned char*  m_bo_2_data;
	unsigned int	m_bo_2_data_size;
	unsigned int	m_bo_2_offset_sbyte;
	unsigned int	m_bo_2_offset_matrix;
	unsigned short* m_bo_index_data;
	unsigned int	m_bo_index_data_size;
	glw::GLuint		m_bo_id_1;
	glw::GLuint		m_bo_id_2;
	glw::GLuint		m_bo_id_indices;
	glw::GLuint		m_bo_id_result;
	glw::GLint		m_po_bo1_dmat3_attr_location;
	glw::GLint		m_po_bo2_dmat4x2_attr_location;
	glw::GLint		m_po_bo1_double_attr_location;
	glw::GLint		m_po_bo1_dvec2_attr_location;
	glw::GLint		m_po_bo1_float2_attr_location;
	glw::GLint		m_po_bo1_int_attr_location;
	glw::GLint		m_po_bo2_float_attr_location;
	glw::GLuint		m_po_id;
	glw::GLuint		m_vao_id;
	glw::GLuint		m_vs_id;
	unsigned int	m_xfb_bo1_dmat3_offset;
	unsigned int	m_xfb_bo1_dmat3_size;
	unsigned int	m_xfb_bo1_double_offset;
	unsigned int	m_xfb_bo1_double_size;
	unsigned int	m_xfb_bo1_dvec2_offset;
	unsigned int	m_xfb_bo1_dvec2_size;
	unsigned int	m_xfb_bo1_float2_offset;
	unsigned int	m_xfb_bo1_float2_size;
	unsigned int	m_xfb_bo1_int_offset;
	unsigned int	m_xfb_bo1_int_size;
	unsigned int	m_xfb_bo2_dmat4x2_offset;
	unsigned int	m_xfb_bo2_dmat4x2_size;
	unsigned int	m_xfb_bo2_float_offset;
	unsigned int	m_xfb_bo2_float_size;
	unsigned int	m_xfb_total_size;

	const unsigned int m_bo_1_batch_size;
	const unsigned int m_bo_2_batch_size;
	const unsigned int m_n_batches;
	const unsigned int m_n_draw_call_instances;
	const unsigned int m_nonzero_vertex_attrib_divisor;
	const unsigned int m_po_bo1_dmat3_attr_offset;
	const unsigned int m_po_bo1_dmat3_attr_stride;
	const unsigned int m_po_bo1_double_attr_offset;
	const unsigned int m_po_bo1_double_attr_stride;
	const unsigned int m_po_bo1_dvec2_attr_offset;
	const unsigned int m_po_bo1_dvec2_attr_stride;
	const unsigned int m_po_bo1_float2_attr_offset;
	const unsigned int m_po_bo1_float2_attr_stride;
	const unsigned int m_po_bo1_int_attr_offset;
	const unsigned int m_po_bo1_int_attr_stride;
	const unsigned int m_po_bo2_dmat4x2_attr_offset;
	const unsigned int m_po_bo2_dmat4x2_attr_stride;
	const unsigned int m_po_bo2_float_attr_offset;
	const unsigned int m_po_bo2_float_attr_stride;
};

/** Constructor
 *
 * @param context CTS context instance
 **/
VAOTest::VAOTest(deqp::Context& context)
	: Base(context, "vao", "Verify that non-trivial VAO configurations are correctly supported "
						   "for double-precision floating-point types.")
	, m_bo_1_data(DE_NULL)
	, m_bo_1_data_size(0)
	, m_bo_1_offset_matrix(0)
	, m_bo_1_offset_ubyte(72)
	, m_bo_1_offset_short(73)
	, m_bo_1_offset_double(75)
	, m_bo_2_data(DE_NULL)
	, m_bo_2_data_size(0)
	, m_bo_2_offset_sbyte(0)
	, m_bo_2_offset_matrix(1)
	, m_bo_index_data(DE_NULL)
	, m_bo_index_data_size(0)
	, m_bo_id_1(0)
	, m_bo_id_2(0)
	, m_bo_id_indices(0)
	, m_bo_id_result(0)
	, m_po_bo1_dmat3_attr_location(-1)
	, m_po_bo2_dmat4x2_attr_location(-1)
	, m_po_bo1_double_attr_location(-1)
	, m_po_bo1_dvec2_attr_location(-1)
	, m_po_bo1_float2_attr_location(-1)
	, m_po_bo1_int_attr_location(-1)
	, m_po_bo2_float_attr_location(-1)
	, m_po_id(0)
	, m_vao_id(0)
	, m_vs_id(0)
	, m_xfb_bo1_dmat3_offset(0)
	, m_xfb_bo1_dmat3_size(0)
	, m_xfb_bo1_double_offset(0)
	, m_xfb_bo1_double_size(0)
	, m_xfb_bo1_dvec2_offset(0)
	, m_xfb_bo1_dvec2_size(0)
	, m_xfb_bo1_float2_offset(0)
	, m_xfb_bo1_float2_size(0)
	, m_xfb_bo1_int_offset(0)
	, m_xfb_bo1_int_size(0)
	, m_xfb_bo2_dmat4x2_offset(0)
	, m_xfb_bo2_dmat4x2_size(0)
	, m_xfb_bo2_float_offset(0)
	, m_xfb_bo2_float_size(0)
	, m_xfb_total_size(0)
	, m_bo_1_batch_size(96)
	, m_bo_2_batch_size(65)
	, m_n_batches(1024)
	, m_n_draw_call_instances(4)
	, m_nonzero_vertex_attrib_divisor(2)
	, m_po_bo1_dmat3_attr_offset(0)
	, m_po_bo1_dmat3_attr_stride(96)
	, m_po_bo1_double_attr_offset(0)
	, m_po_bo1_double_attr_stride(48)
	, m_po_bo1_dvec2_attr_offset(75)
	, m_po_bo1_dvec2_attr_stride(96)
	, m_po_bo1_float2_attr_offset(73)
	, m_po_bo1_float2_attr_stride(96)
	, m_po_bo1_int_attr_offset(72)
	, m_po_bo1_int_attr_stride(96)
	, m_po_bo2_dmat4x2_attr_offset(1)
	, m_po_bo2_dmat4x2_attr_stride(65)
	, m_po_bo2_float_attr_offset(0)
	, m_po_bo2_float_attr_stride(5)
{
	/* Nothing to be done here */
}

/** Deinitializes GL objects and deallocates buffers that may have
 *  been created during test execution */
void VAOTest::deinit()
{
	if (m_bo_1_data != DE_NULL)
	{
		delete[] m_bo_1_data;

		m_bo_1_data = DE_NULL;
	}

	if (m_bo_2_data != DE_NULL)
	{
		delete[] m_bo_2_data;

		m_bo_2_data = DE_NULL;
	}

	if (m_bo_index_data != DE_NULL)
	{
		delete[] m_bo_index_data;

		m_bo_index_data = DE_NULL;
	}

	if (m_bo_id_1 != 0)
	{
		gl.deleteBuffers(1, &m_bo_id_1);

		m_bo_id_1 = 0;
	}

	if (m_bo_id_2 != 0)
	{
		gl.deleteBuffers(1, &m_bo_id_2);

		m_bo_id_2 = 0;
	}

	if (m_bo_id_indices != 0)
	{
		gl.deleteBuffers(1, &m_bo_id_indices);

		m_bo_id_indices = 0;
	}

	if (m_bo_id_result != 0)
	{
		gl.deleteBuffers(1, &m_bo_id_result);

		m_bo_id_result = 0;
	}

	if (m_po_id != 0)
	{
		gl.deleteProgram(m_po_id);

		m_po_id = 0;
	}

	if (m_vao_id != 0)
	{
		gl.deleteVertexArrays(1, &m_vao_id);

		m_vao_id = 0;
	}

	if (m_vs_id != 0)
	{
		gl.deleteShader(m_vs_id);

		m_vs_id = 0;
	}
}

/** Executes a single test iteration.
 *
 *  This function may throw error exceptions if GL implementation misbehaves.
 *
 *  @param draw_call                  Type of the draw call that should be issued.
 *  @param instanced                  True if the draw call should be instanced, false otherwise.
 *  @param zero_vertex_attrib_divisor True if a zero divisor should be used for all checked attributes,
 *                                    false to use a value of m_nonzero_vertex_attrib_divisor as the divisor.
 *
 *  @return true if the test iteration passed, false otherwise.
 **/
bool VAOTest::executeTest(_draw_call_type draw_call, bool instanced, bool zero_vertex_attrib_divisor)
{
	bool result = true;

	gl.beginTransformFeedback(GL_POINTS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed.");
	{
		const glw::GLint divisor	  = (zero_vertex_attrib_divisor) ? 0 : m_nonzero_vertex_attrib_divisor;
		const glw::GLint attributes[] = { m_po_bo1_dmat3_attr_location,		  m_po_bo1_dmat3_attr_location + 1,
										  m_po_bo1_dmat3_attr_location + 2,

										  m_po_bo2_dmat4x2_attr_location,	 m_po_bo2_dmat4x2_attr_location + 1,
										  m_po_bo2_dmat4x2_attr_location + 2, m_po_bo2_dmat4x2_attr_location + 3,

										  m_po_bo1_double_attr_location,	  m_po_bo1_dvec2_attr_location,
										  m_po_bo1_float2_attr_location,	  m_po_bo1_int_attr_location,
										  m_po_bo2_float_attr_location };
		const unsigned int n_attributes = sizeof(attributes) / sizeof(attributes[0]);

		for (unsigned int n_attribute = 0; n_attribute < n_attributes; ++n_attribute)
		{
			glw::GLint attribute = attributes[n_attribute];

			/* Configure vertex attribute divisor */
			gl.vertexAttribDivisor(attribute, divisor);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribDivisor() call failed.");
		} /* for (all attribute locations) */

		/* Issue the draw call */
		switch (draw_call)
		{
		case DRAW_CALL_TYPE_ARRAYS:
		{
			if (instanced)
			{
				gl.drawArraysInstanced(GL_POINTS, 0 /* first */, m_n_batches, m_n_draw_call_instances);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArraysInstanced() call failed");
			}
			else
			{
				gl.drawArrays(GL_POINTS, 0 /* first */, m_n_batches);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
			}

			break;
		} /* case DRAW_CALL_TYPE_ARRAYS: */

		case DRAW_CALL_TYPE_ELEMENTS:
		{
			if (instanced)
			{
				gl.drawElementsInstanced(GL_POINTS, m_n_batches, GL_UNSIGNED_SHORT, DE_NULL /* indices */,
										 m_n_draw_call_instances);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElementsInstanced() call failed.");
			}
			else
			{
				gl.drawElements(GL_POINTS, m_n_batches, GL_UNSIGNED_SHORT, DE_NULL); /* indices */
				GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElements() call failed.");
			}

			break;
		} /* case DRAW_CALL_TYPE_ELEMENTS: */

		default:
		{
			TCU_FAIL("Unrecognized draw call type");
		}
		} /* switch (draw_call) */
	}
	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed.");

	/* Retrieve the results */
	const void* pXFBData = gl.mapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_ONLY);

	GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBuffer() call failed.");

	/* Verify the data */
	result = verifyXFBData(pXFBData, draw_call, instanced, zero_vertex_attrib_divisor);

	/* Unmap the buffer */
	gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed.");

	return result;
}

/** Initializes buffer objects that will be used by the test.
 *
 *  This function may throw error exceptions if GL implementation misbehaves.
 **/
void VAOTest::initBufferObjects()
{
	DE_ASSERT(m_bo_1_data != DE_NULL);
	DE_ASSERT(m_bo_2_data != DE_NULL);

	/* Generate BOs */
	gl.genBuffers(1, &m_bo_id_1);
	gl.genBuffers(1, &m_bo_id_2);
	gl.genBuffers(1, &m_bo_id_indices);
	gl.genBuffers(1, &m_bo_id_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call(s) failed.");

	/* Initiailize BO storage */
	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.bufferData(GL_ARRAY_BUFFER, m_bo_1_data_size, m_bo_1_data, GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");

	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_2);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.bufferData(GL_ARRAY_BUFFER, m_bo_2_data_size, m_bo_2_data, GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");

	gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bo_id_indices);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, m_bo_index_data_size, m_bo_index_data, GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");

	/* Finally, reserve sufficient amount of space for the data to be XFBed out from
	 * the test program. We need:
	 *
	 * a) dmat3:   (3 * 3 * 2) components: 18 float components
	 * b) float:   (1)         component :  1 float component
	 * c) dvec2:   (2 * 2)     components:  4 float components
	 * d) double:  (1 * 2)     components:  2 float components
	 * e) dmat4x2: (4 * 2 * 2) components: 16 float components
	 * f) int:     (1)         components:  1 int   component
	 * g) float:   (1)         component:   1 float components
	 * h) padding: 4 bytes because fp64 buffer needs 8 bytes alignment
	 *                                 (+)------
	 *                                    (42 float + 1 int + 4 bytes padding) components times 1024 batches: 43008 floats, 1024 ints
	 *
	 * Don't forget about instanced draw calls. We'll be XFBing data for either 1 or m_n_draw_call_instances
	 * instances.
	 */
	const unsigned int xfb_dat_pad = sizeof(int);
	const unsigned int xfb_data_size =
		static_cast<unsigned int>((42 * sizeof(float) + sizeof(int) + xfb_dat_pad) * 1024 * m_n_draw_call_instances);

	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.bufferData(GL_ARRAY_BUFFER, xfb_data_size, DE_NULL /* data */, GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");

	/* Set up XFB bindings */
	gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* index */, m_bo_id_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed.");
}

/** Initializes buffers that will later be used to fill storage of buffer objects used by the test. */
void VAOTest::initBuffers()
{
	DE_ASSERT(m_bo_1_data == DE_NULL);
	DE_ASSERT(m_bo_2_data == DE_NULL);
	DE_ASSERT(m_bo_index_data == DE_NULL);

	/* Prepare buffers storing underlying data. The buffers will be used for:
	 *
	 * - storage purposes;
	 * - verification of the data XFBed from the vertex shader.
	 */
	m_bo_1_data_size	 = m_bo_1_batch_size * m_n_batches;
	m_bo_2_data_size	 = m_bo_2_batch_size * m_n_batches;
	m_bo_index_data_size = static_cast<unsigned int>(sizeof(unsigned short) * m_n_batches);

	m_bo_1_data		= new unsigned char[m_bo_1_data_size];
	m_bo_2_data		= new unsigned char[m_bo_2_data_size];
	m_bo_index_data = new unsigned short[m_bo_index_data_size / sizeof(unsigned short)];

	/* Workaround for alignment issue that may result in bus error on some platforms */
	union {
		double		  d;
		unsigned char c[sizeof(double)];
	} u;

	/* Fill index data */
	for (unsigned short n_index = 0; n_index < (unsigned short)m_n_batches; ++n_index)
	{
		m_bo_index_data[n_index] = (unsigned short)((unsigned short)(m_n_batches - 1) - n_index);
	}

	/* Fill 3x3 matrix data in BO1 */
	for (unsigned int n_matrix = 0; n_matrix < m_n_batches; ++n_matrix)
	{
		double* matrix_ptr = (double*)(m_bo_1_data + n_matrix * m_bo_1_batch_size + m_bo_1_offset_matrix);

		for (unsigned int n_element = 0; n_element < 9 /* 3x3 matrix */; ++n_element)
		{
			matrix_ptr[n_element] = (double)(n_matrix * 3 * 3 + n_element + 1);
		}
	} /* for (all matrices) */

	/* Fill unsigned byte data in BO1 */
	for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
	{
		unsigned char* data_ptr = m_bo_1_data + n_element * m_bo_1_batch_size + m_bo_1_offset_ubyte;

		*data_ptr = (unsigned char)n_element;
	}

	/* Fill short data in BO1 */
	for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
	{
		unsigned short* data_ptr = (unsigned short*)(m_bo_1_data + n_element * m_bo_1_batch_size + m_bo_1_offset_short);

		*data_ptr = (unsigned short)n_element;
	}

	/* Fill 2 doubles data in BO1 */
	for (unsigned int n_batch = 0; n_batch < m_n_batches; ++n_batch)
	{
		unsigned char* data1_ptr = m_bo_1_data + n_batch * m_bo_1_batch_size + m_bo_1_offset_double;
		unsigned char* data2_ptr = data1_ptr + sizeof(double);

		u.d = (double)(2 * n_batch);
		memcpy(data1_ptr, u.c, sizeof(double));
		u.d = (double)(2 * n_batch + 1);
		memcpy(data2_ptr, u.c, sizeof(double));
	}

	/* Fill signed byte data in BO2 */
	for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
	{
		signed char* data_ptr = (signed char*)(m_bo_2_data + n_element * m_bo_2_batch_size + m_bo_2_offset_sbyte);

		*data_ptr = (signed char)n_element;
	}

	/* Fill 4x2 matrix data in BO2 */
	for (unsigned int n_matrix = 0; n_matrix < m_n_batches; ++n_matrix)
	{
		unsigned char* matrix_ptr = m_bo_2_data + n_matrix * m_bo_2_batch_size + m_bo_2_offset_matrix;

		for (unsigned int n_element = 0; n_element < 8 /* 4x2 matrix */; ++n_element)
		{
			u.d = (double)(n_matrix * 4 * 2 + n_element);
			memcpy(matrix_ptr + (sizeof(double) * n_element), u.c, sizeof(double));
		}
	} /* for (all matrices) */
}

/** Initializes a program object used by the test.
 *
 *  This function may throw error exceptions if GL implementation misbehaves.
 *
 **/
void VAOTest::initProgramObject()
{
	DE_ASSERT(m_po_id == 0);
	DE_ASSERT(m_vs_id == 0);

	/* Generate a program object */
	m_po_id = gl.createProgram();
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed.");

	/* Configure XFB */
	const char* xfb_varyings[] = { "out_bo1_dmat3",  "out_bo1_double",  "out_bo1_int",   "out_bo1_dvec2",
								   "out_bo1_float2", "out_bo2_dmat4x2", "out_bo2_float", "gl_SkipComponents1" };
	const unsigned int n_xfb_varyings = sizeof(xfb_varyings) / sizeof(xfb_varyings[0]);

	gl.transformFeedbackVaryings(m_po_id, n_xfb_varyings, xfb_varyings, GL_INTERLEAVED_ATTRIBS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed.");

	/* Initialize XFB-specific offset information for the verification routine */
	m_xfb_bo1_dmat3_offset   = 0;
	m_xfb_bo1_dmat3_size	 = sizeof(double) * 3 * 3;
	m_xfb_bo1_double_offset  = m_xfb_bo1_dmat3_offset + m_xfb_bo1_dmat3_size;
	m_xfb_bo1_double_size	= sizeof(double);
	m_xfb_bo1_int_offset	 = m_xfb_bo1_double_offset + m_xfb_bo1_double_size;
	m_xfb_bo1_int_size		 = sizeof(int);
	m_xfb_bo1_dvec2_offset   = m_xfb_bo1_int_offset + m_xfb_bo1_int_size;
	m_xfb_bo1_dvec2_size	 = sizeof(double) * 2;
	m_xfb_bo1_float2_offset  = m_xfb_bo1_dvec2_offset + m_xfb_bo1_dvec2_size;
	m_xfb_bo1_float2_size	= sizeof(float);
	m_xfb_bo2_dmat4x2_offset = m_xfb_bo1_float2_offset + m_xfb_bo1_float2_size;
	m_xfb_bo2_dmat4x2_size   = sizeof(double) * 4 * 2;
	m_xfb_bo2_float_offset   = m_xfb_bo2_dmat4x2_offset + m_xfb_bo2_dmat4x2_size;
	m_xfb_bo2_float_size	 = sizeof(float);
	m_xfb_total_size = m_xfb_bo1_dmat3_size + m_xfb_bo1_double_size + m_xfb_bo1_int_size + m_xfb_bo1_dvec2_size +
					   m_xfb_bo1_float2_size + m_xfb_bo2_dmat4x2_size + m_xfb_bo2_float_size + sizeof(int);

	/* Build the test program object */
	const char* vs_code = "#version 400\n"
						  "\n"
						  "#extension GL_ARB_vertex_attrib_64bit : require\n"
						  "\n"
						  "in dmat3   in_bo1_dmat3;\n"
						  "in double  in_bo1_double;\n"
						  "in dvec2   in_bo1_dvec2;\n"
						  "in float   in_bo1_float2;\n"
						  "in int     in_bo1_int;\n"
						  "in dmat4x2 in_bo2_dmat4x2;\n"
						  "in float   in_bo2_float;\n"
						  "\n"
						  "out dmat3   out_bo1_dmat3;\n"
						  "out double  out_bo1_double;\n"
						  "out dvec2   out_bo1_dvec2;\n"
						  "out float   out_bo1_float2;\n"
						  "out int     out_bo1_int;\n"
						  "out dmat4x2 out_bo2_dmat4x2;\n"
						  "out float   out_bo2_float;\n"
						  "\n"
						  "void main()\n"
						  "{\n"
						  "    out_bo1_dmat3   = in_bo1_dmat3;\n"
						  "    out_bo1_double  = in_bo1_double;\n"
						  "    out_bo1_dvec2   = in_bo1_dvec2;\n"
						  "    out_bo1_int     = in_bo1_int;\n"
						  "    out_bo1_float2  = in_bo1_float2;\n"
						  "    out_bo2_dmat4x2 = in_bo2_dmat4x2;\n"
						  "    out_bo2_float   = in_bo2_float;\n"
						  "}\n";

	BuildProgramVSOnly(m_po_id, vs_code, m_vs_id);

	m_po_bo1_dmat3_attr_location   = gl.getAttribLocation(m_po_id, "in_bo1_dmat3");
	m_po_bo1_double_attr_location  = gl.getAttribLocation(m_po_id, "in_bo1_double");
	m_po_bo1_dvec2_attr_location   = gl.getAttribLocation(m_po_id, "in_bo1_dvec2");
	m_po_bo1_float2_attr_location  = gl.getAttribLocation(m_po_id, "in_bo1_float2");
	m_po_bo1_int_attr_location	 = gl.getAttribLocation(m_po_id, "in_bo1_int");
	m_po_bo2_dmat4x2_attr_location = gl.getAttribLocation(m_po_id, "in_bo2_dmat4x2");
	m_po_bo2_float_attr_location   = gl.getAttribLocation(m_po_id, "in_bo2_float");
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation() call(s) failed.");

	if (m_po_bo1_dmat3_attr_location == -1 || m_po_bo1_double_attr_location == -1 ||
		m_po_bo1_dvec2_attr_location == -1 || m_po_bo1_int_attr_location == -1 || m_po_bo1_float2_attr_location == -1 ||
		m_po_bo2_dmat4x2_attr_location == -1 || m_po_bo2_float_attr_location == -1)
	{
		TCU_FAIL("At least one attribute is considered inactive which is invalid.");
	}
}

/** Initializes a vertex array object used by the test.
 *
 *  This function may throw error exceptions if GL implementation misbehaves.
 **/
void VAOTest::initVAO()
{
	gl.genVertexArrays(1, &m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");

	gl.bindVertexArray(m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");

	/* Set up BO1-sourced attributes */
	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.vertexAttribLPointer(m_po_bo1_dmat3_attr_location + 0, 3, /* size */
							GL_DOUBLE, m_po_bo1_dmat3_attr_stride,
							(const glw::GLvoid*)(deUintptr)m_po_bo1_dmat3_attr_offset);
	gl.vertexAttribLPointer(m_po_bo1_dmat3_attr_location + 1, 3, /* size */
							GL_DOUBLE, m_po_bo1_dmat3_attr_stride,
							(const glw::GLvoid*)(m_po_bo1_dmat3_attr_offset + 1 * sizeof(double) * 3));
	gl.vertexAttribLPointer(m_po_bo1_dmat3_attr_location + 2, 3, /* size */
							GL_DOUBLE, m_po_bo1_dmat3_attr_stride,
							(const glw::GLvoid*)(m_po_bo1_dmat3_attr_offset + 2 * sizeof(double) * 3));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call(s) failed.");

	gl.enableVertexAttribArray(m_po_bo1_dmat3_attr_location + 0);
	gl.enableVertexAttribArray(m_po_bo1_dmat3_attr_location + 1);
	gl.enableVertexAttribArray(m_po_bo1_dmat3_attr_location + 2);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call(s) failed.");

	gl.vertexAttribLPointer(m_po_bo1_dvec2_attr_location, 2, /* size */
							GL_DOUBLE, m_po_bo1_dvec2_attr_stride,
							(const glw::GLvoid*)(deUintptr)m_po_bo1_dvec2_attr_offset);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call failed.");

	gl.enableVertexAttribArray(m_po_bo1_dvec2_attr_location);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");

	gl.vertexAttribLPointer(m_po_bo1_double_attr_location, 1, /* size */
							GL_DOUBLE, m_po_bo1_double_attr_stride,
							(const glw::GLvoid*)(deUintptr)m_po_bo1_double_attr_offset);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call failed.");

	gl.enableVertexAttribArray(m_po_bo1_double_attr_location);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");

	gl.vertexAttribPointer(m_po_bo1_float2_attr_location, 1, /* size */
						   GL_SHORT, GL_FALSE,				 /* normalized */
						   m_po_bo1_float2_attr_stride, (const glw::GLvoid*)(deUintptr)m_po_bo1_float2_attr_offset);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed.");

	gl.enableVertexAttribArray(m_po_bo1_float2_attr_location);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");

	gl.vertexAttribIPointer(m_po_bo1_int_attr_location, 1, /* size */
							GL_BYTE, m_po_bo1_int_attr_stride, (const glw::GLvoid*)(deUintptr)m_po_bo1_int_attr_offset);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribIPointer() call failed.");

	gl.enableVertexAttribArray(m_po_bo1_int_attr_location);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");

	/* Set up BO2-sourced attributes */
	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id_2);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.vertexAttribPointer(m_po_bo2_float_attr_location, 1, /* size */
						   GL_UNSIGNED_BYTE, GL_TRUE, m_po_bo2_float_attr_stride,
						   (const glw::GLvoid*)(deUintptr)m_po_bo2_float_attr_offset);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed.");

	gl.enableVertexAttribArray(m_po_bo2_float_attr_location);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");

	gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 0, 2, /* size */
							GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride,
							(const glw::GLvoid*)(deUintptr)m_po_bo2_dmat4x2_attr_offset);
	gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 1, 2, /* size */
							GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride,
							(const glw::GLvoid*)(m_po_bo2_dmat4x2_attr_offset + 2 * sizeof(double)));
	gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 2, 2, /* size */
							GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride,
							(const glw::GLvoid*)(m_po_bo2_dmat4x2_attr_offset + 4 * sizeof(double)));
	gl.vertexAttribLPointer(m_po_bo2_dmat4x2_attr_location + 3, 2, /* size */
							GL_DOUBLE, m_po_bo2_dmat4x2_attr_stride,
							(const glw::GLvoid*)(m_po_bo2_dmat4x2_attr_offset + 6 * sizeof(double)));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribLPointer() call failed.");

	gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 0);
	gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 1);
	gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 2);
	gl.enableVertexAttribArray(m_po_bo2_dmat4x2_attr_location + 3);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call(s) failed.");

	/* Set up element binding */
	gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_bo_id_indices);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");
}

/** Executes the test
 *
 *  @return tcu::TestNode::STOP
 **/
tcu::TestNode::IterateResult VAOTest::iterate()
{
	IterateStart();

	bool result = true;

	RequireExtension("GL_ARB_vertex_attrib_64bit");

	/* Initialize GL objects required to run the test */
	initBuffers();
	initBufferObjects();
	initProgramObject();
	initVAO();

	/* Activate the program object before we continue */
	gl.useProgram(m_po_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");

	/* Iterate through all draw call combinations */
	for (int n_draw_call_type = 0; n_draw_call_type < DRAW_CALL_TYPE_COUNT; ++n_draw_call_type)
	{
		_draw_call_type draw_call = (_draw_call_type)n_draw_call_type;

		for (int n_instanced_draw_call = 0; n_instanced_draw_call <= 1; /* false & true */
			 ++n_instanced_draw_call)
		{
			bool instanced_draw_call = (n_instanced_draw_call == 1);

			for (int n_vertex_attrib_divisor = 0; n_vertex_attrib_divisor <= 1; /* 0 & non-zero divisor */
				 ++n_vertex_attrib_divisor)
			{
				bool zero_vertex_attrib_divisor = (n_vertex_attrib_divisor == 0);

				/* Execute the test */
				result &= executeTest(draw_call, instanced_draw_call, zero_vertex_attrib_divisor);
			} /* for (two vertex attrib divisor configurations) */
		}	 /* for (non-instanced & instanced draw calls) */
	}		  /* for (array-based & indiced draw calls) */

	/* Done */
	return IterateStop(result);
}

/** Verifies data that has been XFBed out by the draw call.
 *
 *  @param data                       XFBed data. Must not be NULL.
 *  @param draw_call                  Type of the draw call that was issued.
 *  @param instanced                  True if the draw call was instanced, false otherwise.
 *  @param zero_vertex_attrib_divisor True if a zero divisor was used for all checked attributes,
 *                                    false if the divisors were set to a value of m_nonzero_vertex_attrib_divisor.
 */
bool VAOTest::verifyXFBData(const void* data, _draw_call_type draw_call, bool instanced,
							bool zero_vertex_attrib_divisor)
{
	const float			 epsilon	  = 1e-5f;
	bool				 is_indiced   = (draw_call == DRAW_CALL_TYPE_ELEMENTS);
	const unsigned int   n_instances  = (instanced) ? m_n_draw_call_instances : 1;
	bool				 result		  = true;
	const unsigned char* xfb_data_ptr = (const unsigned char*)data;

	for (unsigned int n_instance = 0; n_instance < n_instances; ++n_instance)
	{
		/* Verify dmat3 data from BO1 has been exposed correctly */
		for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
		{
			unsigned int in_index  = n_element;
			unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const double* in_matrix_data_ptr =
				(const double*)(m_bo_1_data + (in_index)*m_po_bo1_dmat3_attr_stride + m_po_bo1_dmat3_attr_offset);
			const double* xfb_matrix_data_ptr =
				(const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
								m_xfb_bo1_dmat3_offset);

			if (memcmp(in_matrix_data_ptr, xfb_matrix_data_ptr, m_xfb_bo1_dmat3_size) != 0)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO1 dmat3 attribute values mismatch for batch ["
								   << n_element << "]"
												   ", expected:["
								   << in_matrix_data_ptr[0] << ", " << in_matrix_data_ptr[1] << ", "
								   << in_matrix_data_ptr[2] << ", " << in_matrix_data_ptr[3] << ", "
								   << in_matrix_data_ptr[4] << ", " << in_matrix_data_ptr[5] << ", "
								   << in_matrix_data_ptr[6] << ", " << in_matrix_data_ptr[7] << ", "
								   << in_matrix_data_ptr[8] << ", "
								   << "], XFBed out:[" << xfb_matrix_data_ptr[0] << ", " << xfb_matrix_data_ptr[1]
								   << ", " << xfb_matrix_data_ptr[2] << ", " << xfb_matrix_data_ptr[3] << ", "
								   << xfb_matrix_data_ptr[4] << ", " << xfb_matrix_data_ptr[5] << ", "
								   << xfb_matrix_data_ptr[6] << ", " << xfb_matrix_data_ptr[7] << ", "
								   << xfb_matrix_data_ptr[8] << ", "
								   << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}

		/* Verify float data from BO2 has been exposed correctly */
		for (unsigned int n_batch = 0; n_batch < m_n_batches; ++n_batch)
		{
			unsigned int	   in_index  = n_batch;
			const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_batch] : n_batch;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const unsigned char* in_ubyte_data_ptr =
				(const unsigned char*)(m_bo_2_data + (in_index)*m_po_bo2_float_attr_stride +
									   m_po_bo2_float_attr_offset);
			const float* xfb_float_data_ptr =
				(const float*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
							   m_xfb_bo2_float_offset);
			float expected_value = ((float)*in_ubyte_data_ptr / 255.0f);

			if (de::abs(expected_value - *xfb_float_data_ptr) > epsilon)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO2 float attribute value mismatch for batch ["
								   << n_batch << "]"
												 ", expected: ["
								   << expected_value << "]"
														", XFBed out:["
								   << *xfb_float_data_ptr << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}

		/* Verify dvec2 data from BO1 has been exposed correctly */
		for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
		{
			unsigned int	   in_index  = n_element;
			const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const double* in_dvec2_data_ptr =
				(const double*)(m_bo_1_data + (in_index)*m_po_bo1_dvec2_attr_stride + m_po_bo1_dvec2_attr_offset);
			const double* xfb_dvec2_data_ptr =
				(const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
								m_xfb_bo1_dvec2_offset);

			if (memcmp(in_dvec2_data_ptr, in_dvec2_data_ptr, m_xfb_bo1_dvec2_size) != 0)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO1 dvec2 attribute values mismatch for batch ["
								   << n_element << "]"
												   ", expected:["
								   << in_dvec2_data_ptr[0] << ", " << in_dvec2_data_ptr[1] << ", "
								   << "], XFBed out:[" << xfb_dvec2_data_ptr[0] << ", " << xfb_dvec2_data_ptr[1] << ", "
								   << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}

		/* Verify double data from BO1 has been exposed correctly */
		for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
		{
			unsigned int	   in_index  = n_element;
			const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const double* in_double_data_ptr =
				(const double*)(m_bo_1_data + (in_index)*m_po_bo1_double_attr_stride + m_po_bo1_double_attr_offset);
			const double* xfb_double_data_ptr =
				(const double*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
								m_xfb_bo1_double_offset);

			if (memcmp(in_double_data_ptr, xfb_double_data_ptr, m_xfb_bo1_double_size) != 0)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO1 double attribute value mismatch for batch ["
								   << n_element << "]"
												   ", expected: ["
								   << *in_double_data_ptr << "]"
															 ", XFBed out:["
								   << *xfb_double_data_ptr << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}

		/* Verify dmat4x2 data from BO2 has been exposed correctly */
		for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
		{
			unsigned int	   in_index  = n_element;
			const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const unsigned char* in_matrix_data_ptr =
				m_bo_2_data + (in_index)*m_po_bo2_dmat4x2_attr_stride + m_po_bo2_dmat4x2_attr_offset;
			const unsigned char* xfb_matrix_data_ptr =
				xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size + m_xfb_bo2_dmat4x2_offset;

			if (memcmp(in_matrix_data_ptr, xfb_matrix_data_ptr, m_xfb_bo2_dmat4x2_size) != 0)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO2 dmat4x2 attribute values mismatch for batch ["
								   << n_element << "]"
												   ", expected:["
								   << in_matrix_data_ptr[0] << ", " << in_matrix_data_ptr[1] << ", "
								   << in_matrix_data_ptr[2] << ", " << in_matrix_data_ptr[3] << ", "
								   << in_matrix_data_ptr[4] << ", " << in_matrix_data_ptr[5] << ", "
								   << in_matrix_data_ptr[6] << ", " << in_matrix_data_ptr[7] << ", "
								   << "], XFBed out:[" << xfb_matrix_data_ptr[0] << ", " << xfb_matrix_data_ptr[1]
								   << ", " << xfb_matrix_data_ptr[2] << ", " << xfb_matrix_data_ptr[3] << ", "
								   << xfb_matrix_data_ptr[4] << ", " << xfb_matrix_data_ptr[5] << ", "
								   << xfb_matrix_data_ptr[6] << ", " << xfb_matrix_data_ptr[7] << ", "
								   << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}

		/* Verify int data from BO1 has been exposed correctly */
		for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
		{
			unsigned int	   in_index  = n_element;
			const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const signed char* in_char_data_ptr =
				(const signed char*)(m_bo_1_data + (in_index)*m_po_bo1_int_attr_stride + m_po_bo1_int_attr_offset);
			const signed int* xfb_int_data_ptr =
				(const signed int*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
									m_xfb_bo1_int_offset);

			if (de::abs((signed int)*in_char_data_ptr - *xfb_int_data_ptr) > epsilon)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO1 int attribute value mismatch for batch ["
								   << n_element << "]"
												   ", expected: ["
								   << (signed int)*in_char_data_ptr << "]"
																	   ", XFBed out:["
								   << *xfb_int_data_ptr << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}

		/* Verify float data from BO1 has been exposed correctly */
		for (unsigned int n_element = 0; n_element < m_n_batches; ++n_element)
		{
			unsigned int	   in_index  = n_element;
			const unsigned int xfb_index = is_indiced ? m_bo_index_data[n_element] : n_element;

			if (!zero_vertex_attrib_divisor)
			{
				in_index = n_instance / m_nonzero_vertex_attrib_divisor;
			}

			const unsigned short* in_short_data_ptr =
				(const unsigned short*)(m_bo_1_data + (in_index)*m_po_bo1_float2_attr_stride +
										m_po_bo1_float2_attr_offset);
			const float* xfb_float_data_ptr =
				(const float*)(xfb_data_ptr + (m_n_batches * n_instance + xfb_index) * m_xfb_total_size +
							   m_xfb_bo1_float2_offset);

			if (de::abs(*in_short_data_ptr - *xfb_float_data_ptr) > epsilon)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "BO1 float attribute value mismatch for batch ["
								   << n_element << "]"
												   ", expected: ["
								   << (signed int)*in_short_data_ptr << "]"
																		", XFBed out:["
								   << *xfb_float_data_ptr << "]" << tcu::TestLog::EndMessage;

				result = false;
				break;
			}
		}
	} /* for (all instances) */

	return result;
}

} /* namespace VertexAttrib64Bit */

namespace gl4cts
{

VertexAttrib64BitTests::VertexAttrib64BitTests(deqp::Context& context)
	: TestCaseGroup(context, "vertex_attrib_64bit", "Verifes GL_ARB_vertex_attrib_64bit functionality")
{
	/* Nothing to be done here */
}

void VertexAttrib64BitTests::init(void)
{
	addChild(new VertexAttrib64Bit::ApiErrorsTest(m_context));
	addChild(new VertexAttrib64Bit::GetVertexAttribTest(m_context));
	addChild(new VertexAttrib64Bit::LimitTest(m_context));
	addChild(new VertexAttrib64Bit::VAOTest(m_context));
}

} /* namespace gl4cts */