/*-------------------------------------------------------------------------
 * 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
 */ /*-------------------------------------------------------------------*/

#include "es31cProgramInterfaceQueryTests.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include <cstdarg>
#include <map>
#include <set>

namespace glcts
{

using namespace glw;

namespace
{

class PIQBase : public glcts::SubcaseBase
{

public:
	virtual ~PIQBase()
	{
	}

	virtual std::string PassCriteria()
	{
		return "All called functions return expected values.";
	}

	virtual std::string Purpose()
	{
		return "Verify that the set of tested functions glGetProgram* return\n"
			   "expected results when used to get data from program\n"
			   "made of " +
			   ShadersDesc() + "." + PurposeExt();
	}

	virtual std::string Method()
	{
		return "Create a program using " + ShadersDesc() +
			   "\n"
			   "then use set of tested functions to get an information about it and\n"
			   "verify that information with the expected data" +
			   Expectations();
	}

	virtual long Cleanup()
	{
		glUseProgram(0);
		return NO_ERROR;
	}

	virtual long Setup()
	{
		return NO_ERROR;
	}

protected:
	void LinkProgram(GLuint program)
	{
		glLinkProgram(program);
		GLsizei length;
		GLchar  log[1024];
		glGetProgramInfoLog(program, sizeof(log), &length, log);
		if (length > 1)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program Info Log:\n"
												<< log << tcu::TestLog::EndMessage;
		}
	}

	GLuint CreateProgram(const char* src_vs, const char* src_fs, bool link)
	{
		const GLuint p = glCreateProgram();

		if (src_vs)
		{
			GLuint sh = glCreateShader(GL_VERTEX_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			glShaderSource(sh, 1, &src_vs, NULL);
			glCompileShader(sh);
		}
		if (src_fs)
		{
			GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			glShaderSource(sh, 1, &src_fs, NULL);
			glCompileShader(sh);
		}
		if (link)
		{
			LinkProgram(p);
		}
		return p;
	}

	virtual std::string ShadersDesc()
	{
		return "";
	}

	virtual std::string Expectations()
	{
		return ".";
	}

	virtual std::string PurposeExt()
	{
		return "";
	}

	virtual inline void ExpectError(GLenum expected, long& error)
	{
		if (error != NO_ERROR)
			return;
		GLenum tmp = glGetError();
		if (tmp == expected)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Found expected error" << tcu::TestLog::EndMessage;
			error = NO_ERROR; // Error is expected
		}
		else
		{
			error = ERROR;
			m_context.getTestContext().getLog() << tcu::TestLog::Message << expected
												<< " error was expected, found: " << tmp << tcu::TestLog::EndMessage;
		}
	}

	virtual inline void VerifyGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, int expected,
													long& error)
	{
		GLint res;
		glGetProgramInterfaceiv(program, programInterface, pname, &res);
		if (res != expected)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res << ", expected "
												<< expected << tcu::TestLog::EndMessage;
			error = ERROR;
		}
	}

	virtual inline void VerifyGetProgramResourceIndex(GLuint program, GLenum programInterface, const std::string& name,
													  GLuint expected, long& error)
	{
		GLuint res = glGetProgramResourceIndex(program, programInterface, name.c_str());
		if (res != expected)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res << ", expected "
												<< expected << tcu::TestLog::EndMessage;
			error = ERROR;
		}
	}

	virtual inline void VerifyGetProgramResourceIndex(GLuint program, GLenum		 programInterface,
													  std::map<std::string, GLuint>& indices, const std::string& name,
													  long& error)
	{
		GLuint res = glGetProgramResourceIndex(program, programInterface, name.c_str());
		if (res == GL_INVALID_INDEX)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res
												<< ", expected number other than -1" << tcu::TestLog::EndMessage;
			error = ERROR;
			return;
		}
		std::map<std::string, GLuint>::iterator it = indices.begin();
		while (it != indices.end())
		{
			if (it->second == res)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "ERROR: Duplicated value found: " << res << tcu::TestLog::EndMessage;
				error = ERROR;
				return;
			}
			++it;
		}
		indices[name] = res;
	}

	virtual inline void VerifyGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index,
													 const std::string& expected, long& error)
	{
		GLchar  name[1024] = { '\0' };
		GLsizei len;
		glGetProgramResourceName(program, programInterface, index, 1024, &len, name);
		if (len <= 0 || len > 1023 || name[len - 1] == '\0')
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message
				<< "ERROR: Length in glGetProgramResourceName should not count null terminator!"
				<< tcu::TestLog::EndMessage;
			error = ERROR;
		}
		else if (name != expected || name[len] != '\0')
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << name << ", expected "
												<< expected << tcu::TestLog::EndMessage;
			error = ERROR;
		}
	}

	virtual inline void VerifyGetProgramResourceLocation(GLuint program, GLenum programInterface,
														 const std::string& name, GLint expected, long& error)
	{
		GLint res = glGetProgramResourceLocation(program, programInterface, name.c_str());
		if (res != expected)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res << ", expected "
												<< expected << tcu::TestLog::EndMessage;
			error = ERROR;
		}
	}

	virtual inline void VerifyGetProgramResourceLocation(GLuint program, GLenum		   programInterface,
														 std::map<std::string, GLint>& locations,
														 const std::string& name, long& error)
	{
		GLint res = glGetProgramResourceLocation(program, programInterface, name.c_str());
		if (res < 0)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: Got " << res
												<< ", expected not less than 0" << tcu::TestLog::EndMessage;
			error = ERROR;
			return;
		}
		std::map<std::string, GLint>::iterator it = locations.begin();
		while (it != locations.end())
		{
			if (it->second == res)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "ERROR: Duplicated value found: " << res << tcu::TestLog::EndMessage;
				error = ERROR;
				return;
			}
			++it;
		}
		locations[name] = res;
	}

	virtual inline void VerifyGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index,
												   GLsizei propCount, const GLenum props[], GLsizei expectedLength,
												   const GLint expected[], long& error)
	{
		const GLsizei bufSize = 1000;
		GLsizei		  length;
		GLint		  params[bufSize];
		glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, &length, params);
		if (length != expectedLength || length <= 0)
		{
			error = ERROR;
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "ERROR: Got length " << length << ", expected " << expectedLength
				<< "\nCALL: glGetProgramResourceiv, with " << programInterface << ", " << index
				<< tcu::TestLog::EndMessage;
			return;
		}
		for (int i = 0; i < length; ++i)
		{
			if (params[i] != expected[i])
			{
				error = ERROR;
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "ERROR: Got " << params[i] << ", expected " << expected[i]
					<< " at: " << i << "\nCALL: glGetProgramResourceiv, with " << programInterface << ", " << index
					<< tcu::TestLog::EndMessage;
			}
		}
	}

	virtual inline GLint GetProgramivRetValue(GLuint program, GLenum pname)
	{
		GLint ret;
		glGetProgramiv(program, pname, &ret);
		return ret;
	}

	static const GLenum interfaces[];
};

const GLenum PIQBase::interfaces[] = { GL_PROGRAM_INPUT,
									   GL_PROGRAM_OUTPUT,
									   GL_UNIFORM,
									   GL_UNIFORM_BLOCK,
									   GL_BUFFER_VARIABLE,
									   GL_SHADER_STORAGE_BLOCK,
									   GL_ATOMIC_COUNTER_BUFFER,
									   GL_TRANSFORM_FEEDBACK_VARYING };

class NoShaders : public PIQBase
{

	virtual std::string Title()
	{
		return "No Shaders Test";
	}

	virtual std::string ShadersDesc()
	{
		return "no shaders";
	}

	virtual long Run()
	{
		const GLuint program = glCreateProgram();

		long error = NO_ERROR;
		int  size  = sizeof(PIQBase::interfaces) / sizeof(PIQBase::interfaces[0]);

		for (int i = 0; i < size; ++i)
		{
			VerifyGetProgramInterfaceiv(program, PIQBase::interfaces[i], GL_ACTIVE_RESOURCES, 0, error);
			if (PIQBase::interfaces[i] == GL_ATOMIC_COUNTER_BUFFER)
				continue;
			VerifyGetProgramInterfaceiv(program, PIQBase::interfaces[i], GL_MAX_NAME_LENGTH, 0, error);
		}
		VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, 0, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, 0, error);
		VerifyGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, 0, error);

		for (int i = 0; i < size; ++i)
		{
			if (PIQBase::interfaces[i] == GL_ATOMIC_COUNTER_BUFFER)
				continue;
			VerifyGetProgramResourceIndex(program, PIQBase::interfaces[i], "", GL_INVALID_INDEX, error);
		}

		// can't test GetProgramResourceLocation* here since program has to be linked
		// can't test GetProgramResourceiv, need valid index

		glDeleteProgram(program);
		return error;
	}
};

class SimpleShaders : public PIQBase
{

public:
	virtual std::string Title()
	{
		return "Simple Shaders Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = position;          \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "out mediump vec4 color;        \n"
			   "void main() {                  \n"
			   "    color = vec4(0, 1, 0, 1);  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		glLinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 9, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 6, error);

		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "color", 0, error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "position", 0, error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, 0, "color", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, 0, "position", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", 0, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", 0, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 9, 35666, 1, 0, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 7, props, 7, expected, error);

		GLenum props2[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_LOCATION };
		GLint expected2[] = { 6, 35666, 1, 0, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, 0, 7, props2, 7, expected2, error);

		glDeleteProgram(program);
		return error;
	}
};

class ComputeShaderTest : public PIQBase
{
public:
	virtual std::string Title()
	{
		return "Compute Shader Test";
	}

	virtual std::string ShadersDesc()
	{
		return "compute shader";
	}

	virtual std::string ComputeShader()
	{
		return "layout(local_size_x = 1, local_size_y = 1) in; \n"
			   "layout(std430) buffer Output {                 \n"
			   "  mediump vec4 data[];                         \n"
			   "} g_out;                                       \n"
			   ""
			   "void main() {                                   \n"
			   "   g_out.data[0] = vec4(1.0, 2.0, 3.0, 4.0);    \n"
			   "   g_out.data[100] = vec4(1.0, 2.0, 3.0, 4.0);  \n"
			   "}";
	}

	GLuint CreateComputeProgram(const std::string& cs)
	{
		const GLuint p = glCreateProgram();

		const char* const kGLSLVer = "#version 310 es\n";

		if (!cs.empty())
		{
			const GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			const char* const src[2] = { kGLSLVer, cs.c_str() };
			glShaderSource(sh, 2, src, NULL);
			glCompileShader(sh);
		}

		return p;
	}

	bool CheckProgram(GLuint program, bool* compile_error = NULL)
	{
		GLint compile_status = GL_TRUE;
		GLint status;
		glGetProgramiv(program, GL_LINK_STATUS, &status);

		if (status == GL_FALSE)
		{
			GLint attached_shaders;
			glGetProgramiv(program, GL_ATTACHED_SHADERS, &attached_shaders);

			if (attached_shaders > 0)
			{
				std::vector<GLuint> shaders(attached_shaders);
				glGetAttachedShaders(program, attached_shaders, NULL, &shaders[0]);

				for (GLint i = 0; i < attached_shaders; ++i)
				{
					GLenum type;
					glGetShaderiv(shaders[i], GL_SHADER_TYPE, reinterpret_cast<GLint*>(&type));
					switch (type)
					{
					case GL_VERTEX_SHADER:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Vertex Shader ***" << tcu::TestLog::EndMessage;
						break;
					case GL_TESS_CONTROL_SHADER:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Tessellation Control Shader ***"
							<< tcu::TestLog::EndMessage;
						break;
					case GL_TESS_EVALUATION_SHADER:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Tessellation Evaluation Shader ***"
							<< tcu::TestLog::EndMessage;
						break;
					case GL_GEOMETRY_SHADER:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Geometry Shader ***" << tcu::TestLog::EndMessage;
						break;
					case GL_FRAGMENT_SHADER:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Fragment Shader ***" << tcu::TestLog::EndMessage;
						break;
					case GL_COMPUTE_SHADER:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Compute Shader ***" << tcu::TestLog::EndMessage;
						break;
					default:
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "*** Unknown Shader ***" << tcu::TestLog::EndMessage;
					}

					GLint res;
					glGetShaderiv(shaders[i], GL_COMPILE_STATUS, &res);
					if (res != GL_TRUE)
						compile_status = res;

					// shader source
					GLint length;
					glGetShaderiv(shaders[i], GL_SHADER_SOURCE_LENGTH, &length);
					if (length > 0)
					{
						std::vector<GLchar> source(length);
						glGetShaderSource(shaders[i], length, NULL, &source[0]);
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << &source[0] << tcu::TestLog::EndMessage;
					}

					// shader info log
					glGetShaderiv(shaders[i], GL_INFO_LOG_LENGTH, &length);
					if (length > 0)
					{
						std::vector<GLchar> log(length);
						glGetShaderInfoLog(shaders[i], length, NULL, &log[0]);
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage;
					}
				}
			}

			// program info log
			GLint length;
			glGetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
			if (length > 0)
			{
				std::vector<GLchar> log(length);
				glGetProgramInfoLog(program, length, NULL, &log[0]);
				m_context.getTestContext().getLog() << tcu::TestLog::Message << &log[0] << tcu::TestLog::EndMessage;
			}
		}

		if (compile_error)
			*compile_error = (compile_status == GL_TRUE ? false : true);
		if (compile_status != GL_TRUE)
			return false;
		return status == GL_TRUE ? true : false;
	}

	virtual void inline VerifyCompute(GLuint program, long& error)
	{
		VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_MAX_NAME_LENGTH, 15, error);
		VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, 7, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, 1, error);

		std::map<std::string, GLuint> indicesSSB;
		std::map<std::string, GLuint> indicesBV;
		VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "Output", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "Output.data", error);

		VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["Output"], "Output", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["Outputa.data"], "Output.data[0]", error);

		GLenum props3[] = { GL_NAME_LENGTH,
							GL_BUFFER_BINDING,
							GL_NUM_ACTIVE_VARIABLES,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_ACTIVE_VARIABLES };
		GLint expected3[] = { 7, 0, 1, 1, 0, 0, static_cast<GLint>(indicesBV["Outputa.data"]) };
		VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["Output"], 7, props3, 7, expected3,
								   error);

		GLenum props4[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_BLOCK_INDEX,
							GL_IS_ROW_MAJOR,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_TOP_LEVEL_ARRAY_SIZE };
		GLint expected4[] = { 15, 35666, 0, static_cast<GLint>(indicesSSB["Output"]), 0, 1, 0, 0, 1 };
		VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["Outputa.data"], 9, props4, 9, expected4,
								   error);
	}

	virtual long Run()
	{
		GLuint program = CreateComputeProgram(ComputeShader());
		glLinkProgram(program);
		if (!CheckProgram(program))
		{
			glDeleteProgram(program);
			return ERROR;
		}
		glUseProgram(program);

		long error = NO_ERROR;

		VerifyCompute(program, error);

		glDeleteProgram(program);
		return error;
	}
};

class InputTypes : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Input Types Test";
	}

	virtual std::string ShadersDesc()
	{
		return "vertex shader with different `in` types and a fallthrough fragment shader";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in mat4 a;                           \n"
			   "in vec4 b;                           \n"
			   "in float c;                          \n"
			   "in mat2x3 d;                         \n"
			   "in vec2 e;                           \n"
			   "in uint f;                           \n"
			   "in vec3 g;                           \n"
			   "in int h;                            \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "   vec4 pos;                                                 \n"
			   "   pos.w = float(h) + g.x + g.y + d[1].y;                    \n"
			   "   pos.y = float(b.x) * c + c + d[0][0];                     \n"
			   "   pos.x = a[0].x + a[1].y + a[2].z + a[3].w;                \n"
			   "   pos.z = d[0][1] + float(e.x) * float(f) + d[1][0];        \n"
			   "   gl_Position = pos;                                        \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "a");
		glBindAttribLocation(program, 4, "b");
		glBindAttribLocation(program, 5, "c");
		glBindAttribLocation(program, 7, "d");
		glBindAttribLocation(program, 11, "e");
		glBindAttribLocation(program, 12, "f");
		glBindAttribLocation(program, 13, "g");
		glBindAttribLocation(program, 15, "h");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 8, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 2, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "a", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "b", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "c", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "d", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "e", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "f", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "g", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "h", error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["d"], "d", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["e"], "e", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["f"], "f", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["g"], "g", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["h"], "h", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "a", 0, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "b", 4, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "c", 5, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "d", 7, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "e", 11, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "f", 12, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "g", 13, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "h", 15, error);

		GLenum props[] = {
			GL_NAME_LENGTH,
			GL_TYPE,
			GL_ARRAY_SIZE,
			GL_REFERENCED_BY_COMPUTE_SHADER,
			GL_REFERENCED_BY_FRAGMENT_SHADER,
			GL_REFERENCED_BY_VERTEX_SHADER,
			GL_LOCATION,
		};
		GLint expected[] = { 2, 35676, 1, 0, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["a"], 7, props, 7, expected, error);
		GLint expected2[] = { 2, 35666, 1, 0, 0, 1, 4 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["b"], 7, props, 7, expected2, error);
		GLint expected3[] = { 2, 5126, 1, 0, 0, 1, 5 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["c"], 7, props, 7, expected3, error);
		GLint expected4[] = { 2, 35685, 1, 0, 0, 1, 7 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["d"], 7, props, 7, expected4, error);
		GLint expected5[] = { 2, 35664, 1, 0, 0, 1, 11 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["e"], 7, props, 7, expected5, error);
		GLint expected6[] = { 2, 5125, 1, 0, 0, 1, 12 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["f"], 7, props, 7, expected6, error);
		GLint expected7[] = { 2, 35665, 1, 0, 0, 1, 13 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["g"], 7, props, 7, expected7, error);
		GLint expected8[] = { 2, 5124, 1, 0, 0, 1, 15 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["h"], 7, props, 7, expected8, error);

		glDeleteProgram(program);
		return error;
	}
};

class InputBuiltIn : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Input Built-ins Test";
	}

	virtual std::string ShadersDesc()
	{
		return "vertex shader using built-in variables and a fallthrough fragment shader";
	}

	virtual std::string Expectations()
	{
		return ".\n\n In this case we ask for information about built-in variables for the input interface.";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = (float(gl_VertexID) + float(gl_InstanceID)) * vec4(0.1);          \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 2, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 14, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "gl_VertexID", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "gl_InstanceID", error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["gl_VertexID"], "gl_VertexID", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["gl_InstanceID"], "gl_InstanceID", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "gl_VertexID", -1, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "gl_InstanceID", -1, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 12, 5124, 1, 0, 0, 1, -1 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["gl_VertexID"], 7, props, 7, expected, error);
		GLint expected2[] = { 14, 5124, 1, 0, 0, 1, -1 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["gl_InstanceID"], 7, props, 7, expected2, error);

		glDeleteProgram(program);
		return error;
	}
};

class InputLayout : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Input Layout Test";
	}

	virtual std::string ShadersDesc()
	{
		return "vertex shader with different `in` variables locations set through layout and a fallthrough fragment "
			   "shader";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "layout(location = 4) in vec4 b;      \n"
			   "layout(location = 7) in mat2x3 d;    \n"
			   "layout(location = 5) in float c;     \n"
			   "layout(location = 12) in uint f;     \n"
			   "layout(location = 13) in vec3 g;     \n"
			   "layout(location = 0) in mat4 a;      \n"
			   "layout(location = 15) in int h;      \n"
			   "layout(location = 11) in vec2 e;     \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "   vec4 pos;                                              \n"
			   "   pos.w = float(h) + g.x + g.y + d[1][1];                \n"
			   "   pos.y = float(b.x) * c + c + d[0][0];                  \n"
			   "   pos.x = a[0].x + a[1].y + a[2].z + a[3].w;             \n"
			   "   pos.z = d[0][1] + float(e.x) * float(f) + d[1][0];     \n"
			   "   gl_Position = pos;                                     \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 8, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 2, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "a", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "b", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "c", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "d", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "e", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "f", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "g", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indices, "h", error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["d"], "d", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["e"], "e", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["f"], "f", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["g"], "g", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indices["h"], "h", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "a", 0, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "b", 4, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "c", 5, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "d", 7, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "e", 11, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "f", 12, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "g", 13, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "h", 15, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 2, 35676, 1, 0, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["a"], 7, props, 7, expected, error);
		GLint expected2[] = { 2, 35666, 1, 0, 0, 1, 4 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["b"], 7, props, 7, expected2, error);
		GLint expected3[] = { 2, 5126, 1, 0, 0, 1, 5 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["c"], 7, props, 7, expected3, error);
		GLint expected4[] = { 2, 35685, 1, 0, 0, 1, 7 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["d"], 7, props, 7, expected4, error);
		GLint expected5[] = { 2, 35664, 1, 0, 0, 1, 11 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["e"], 7, props, 7, expected5, error);
		GLint expected6[] = { 2, 5125, 1, 0, 0, 1, 12 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["f"], 7, props, 7, expected6, error);
		GLint expected7[] = { 2, 35665, 1, 0, 0, 1, 13 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["g"], 7, props, 7, expected7, error);
		GLint expected8[] = { 2, 5124, 1, 0, 0, 1, 15 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indices["h"], 7, props, 7, expected8, error);

		glDeleteProgram(program);
		return error;
	}
};

class OutputLayout : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Output Layout Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fragment shader with different `out` variables locations set through layout and a fallthrough vertex "
			   "shader";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "layout(location = 2) out uint b;                    \n"
			   "layout(location = 3) out mediump vec2 e;            \n"
			   "layout(location = 0) out mediump vec3 a[2];         \n"
			   "void main() {                  \n"
			   "    b = 12u;                   \n"
			   "    e = vec2(0, 1);            \n"
			   "    a[1] = vec3(0, 1, 0);      \n"
			   "    a[0] = vec3(0, 1, 0);      \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 3, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 5, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "a", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "b", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "e", error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["a"], "a[0]", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["e"], "e", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "a[0]", 0, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "a", 0, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "a[1]", 1, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "b", 2, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "e", 3, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected_a[] = { 5, 35665, 2, 0, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["a"], 7, props, 7, expected_a, error);
		GLint expected_b[] = { 2, 5125, 1, 0, 1, 0, 2 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["b"], 7, props, 7, expected_b, error);
		GLint expected_e[] = { 2, 35664, 1, 0, 1, 0, 3 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["e"], 7, props, 7, expected_e, error);

		glDeleteProgram(program);
		return error;
	}
};

class UniformSimple : public PIQBase
{
	virtual std::string Title()
	{
		return "Uniform Simple Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders with uniforms used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_UNIFORM as an interface param.";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   "uniform mediump vec4 repos;          \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = position + repos;  \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "uniform mediump vec4 recolor;  \n"
			   "out mediump vec4 color;        \n"
			   "void main() {                  \n"
			   "    color = vec4(0, 1, 0, 1) + recolor;  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES,
									GetProgramivRetValue(program, GL_ACTIVE_UNIFORMS), error);
		VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, 8, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "repos", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "recolor", error);

		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["repos"], "repos", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["recolor"], "recolor", error);

		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "repos", glGetUniformLocation(program, "repos"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "recolor", glGetUniformLocation(program, "recolor"),
										 error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_OFFSET,
						   GL_BLOCK_INDEX,
						   GL_ARRAY_STRIDE,
						   GL_MATRIX_STRIDE,
						   GL_IS_ROW_MAJOR,
						   GL_ATOMIC_COUNTER_BUFFER_INDEX,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 6, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "repos") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["repos"], 13, props, 13, expected, error);

		GLint expected2[] = { 8, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "recolor") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["recolor"], 13, props, 13, expected2, error);

		glDeleteProgram(program);
		return error;
	}
};

class UniformTypes : public PIQBase
{
	virtual std::string Title()
	{
		return "Uniform Types Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders with different uniform types used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_UNIFORM as an interface param.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   "uniform mediump vec4 a;              \n"
			   "uniform ivec3 b;                     \n"
			   "uniform uvec2 c[3];                  \n"
			   "uniform mediump mat2 g[8];           \n"
			   "uniform mediump mat3x2 i;            \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    float tmp;                       \n"
			   "    tmp = g[0][1][1] * g[1][0][0] + g[2][1][0] - g[3][0][1]; \n"
			   "    tmp = tmp + g[4][0][0] * g[5][1][0] - g[6][1][1] + g[7][0][1]; \n"
			   "    tmp = tmp + a.z + +float(b.y) + float(c[0].x) - float(c[1].x) * float(c[2].y);   \n"
			   "    tmp = tmp + i[1][1];             \n"
			   "    gl_Position = position * tmp;    \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "struct U {                     \n"
			   "   bool a[3];                  \n"
			   "   mediump vec4 b;                     \n"
			   "   mediump mat3 c;                     \n"
			   "   mediump float d[2];                 \n"
			   "};                             \n"
			   "struct UU {                    \n"
			   "   U a;                        \n"
			   "   U b[2];                     \n"
			   "   uvec2 c;                    \n"
			   "};                             \n"
			   "uniform mediump mat4 d;                \n"
			   "uniform mediump mat3 e;                \n"
			   "uniform mediump float h;               \n"
			   "uniform int f;                 \n"
			   "uniform U j;                   \n"
			   "uniform UU k;                  \n"
			   "uniform UU l[3];               \n"
			   "out mediump vec4 color;                \n"
			   "void main() {                  \n"
			   "    mediump float tmp;                 \n"
			   "    tmp = h + float(f) + e[2][2];           \n"
			   "    tmp = tmp + d[0][0] + j.b.x;     \n"
			   "    tmp = tmp + k.b[0].c[0][0];      \n"
			   "    tmp = tmp + l[2].a.c[0][1];      \n"
			   "    tmp = tmp + l[2].b[1].d[0];      \n"
			   "    tmp = tmp + float(l[0].c.x);            \n"
			   "    color = vec4(0, 1, 0, 1) * tmp;  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		// only active structure members
		VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES,
									GetProgramivRetValue(program, GL_ACTIVE_UNIFORMS), error);
		// l[2].b[1].d[0] and \0
		VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, 15, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "a", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "b", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "c", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "d", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "e", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "f", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "g", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "h", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "i", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "j.b", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "k.b[0].c", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "l[0].c", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "l[2].b[1].d[0]", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "l[2].a.c", error);

		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["c"], "c[0]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["d"], "d", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["e"], "e", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["f"], "f", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["g"], "g[0]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["h"], "h", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["i"], "i", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["j.b"], "j.b", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["k.b[0].c"], "k.b[0].c", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["l[0].c"], "l[0].c", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["l[2].b[1].d[0]"], "l[2].b[1].d[0]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["l[2].a.c"], "l[2].a.c", error);

		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", glGetUniformLocation(program, "a"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", glGetUniformLocation(program, "b"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", glGetUniformLocation(program, "c"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d", glGetUniformLocation(program, "d"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "e", glGetUniformLocation(program, "e"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "f", glGetUniformLocation(program, "f"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "g", glGetUniformLocation(program, "g"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "h", glGetUniformLocation(program, "h"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "i", glGetUniformLocation(program, "i"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "j.b", glGetUniformLocation(program, "j.b"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "k.b[0].c", glGetUniformLocation(program, "k.b[0].c"),
										 error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "l[0].c", glGetUniformLocation(program, "l[0].c"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "l[2].b[1].d[0]",
										 glGetUniformLocation(program, "l[2].b[1].d[0]"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "l[2].a.c", glGetUniformLocation(program, "l[2].a.c"),
										 error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_OFFSET,
						   GL_BLOCK_INDEX,
						   GL_ARRAY_STRIDE,
						   GL_MATRIX_STRIDE,
						   GL_IS_ROW_MAJOR,
						   GL_ATOMIC_COUNTER_BUFFER_INDEX,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 2, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "a") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["a"], 13, props, 13, expected, error);
		GLint expected2[] = { 2, 35668, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "b") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["b"], 13, props, 13, expected2, error);
		GLint expected3[] = { 5, 36294, 3, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "c") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["c"], 13, props, 13, expected3, error);
		GLint expected4[] = { 2, 35676, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "d") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["d"], 13, props, 13, expected4, error);
		GLint expected5[] = { 2, 35675, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "e") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["e"], 13, props, 13, expected5, error);
		GLint expected6[] = { 2, 5124, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "f") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["f"], 13, props, 13, expected6, error);
		GLint expected7[] = { 5, 35674, 8, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "g") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["g"], 13, props, 13, expected7, error);
		GLint expected8[] = { 2, 5126, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "h") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["h"], 13, props, 13, expected8, error);
		GLint expected9[] = { 2, 35687, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "i") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["i"], 13, props, 13, expected9, error);
		GLint expected10[] = { 4, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "j.b") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["j.b"], 13, props, 13, expected10, error);
		GLint expected11[] = { 9, 35675, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "k.b[0].c") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["k.b[0].c"], 13, props, 13, expected11, error);
		GLint expected12[] = { 7, 36294, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "l[0].c") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["l[0].c"], 13, props, 13, expected12, error);
		GLint expected13[] = {
			15, 5126, 2, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "l[2].b[1].d[0]")
		};
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["l[2].b[1].d[0]"], 13, props, 13, expected13, error);
		GLint expected14[] = { 9, 35675, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, glGetUniformLocation(program, "l[2].a.c") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["l[2].a.c"], 13, props, 13, expected14, error);

		glDeleteProgram(program);
		return error;
	}
};

class UniformBlockTypes : public PIQBase
{
	virtual std::string Title()
	{
		return "Uniform Block Types Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders with different types of uniform blocks used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_UNIFORM_BLOCK as an interface param.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   ""
			   "uniform SimpleBlock {                \n"
			   "   mediump mat3x2 a;                         \n"
			   "   mediump mat4 b;                           \n"
			   "   vec4 c;                           \n"
			   "};                                   \n"
			   ""
			   "uniform NotSoSimpleBlockk {          \n"
			   "   ivec2 a[4];                       \n"
			   "   mediump mat3 b[2];                        \n"
			   "   mediump mat2 c;                           \n"
			   "} d;                                         \n"
			   ""
			   "void main(void)                                               \n"
			   "{                                                             \n"
			   "    mediump float tmp;                                        \n"
			   "    tmp =  a[0][1] * b[1][2] * c.x;                           \n"
			   "    tmp = tmp + float(d.a[2].y) + d.b[0][1][1] + d.c[1][1];   \n"
			   "    gl_Position = position * tmp;                             \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "struct U {                     \n"
			   "   bool a[3];                  \n"
			   "   mediump vec4 b;                     \n"
			   "   mediump mat3 c;                     \n"
			   "   mediump float d[2];                 \n"
			   "};                             \n"
			   "struct UU {                    \n"
			   "   U a;                        \n"
			   "   U b[2];                     \n"
			   "   uvec2 c;                    \n"
			   "};                             \n"
			   ""
			   "uniform TrickyBlock {                            \n"
			   "   UU a[3];                                      \n"
			   "   mediump mat4 b;                               \n"
			   "   uint c;                                       \n"
			   "} e[2];                                          \n"
			   ""
			   "out mediump vec4 color;                        \n"
			   "void main() {                                  \n"
			   "    mediump float tmp;                         \n"
			   "    tmp = e[0].a[2].b[0].d[1] * float(e[1].c); \n"
			   "    color = vec4(0, 1, 0, 1) * tmp;            \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_ACTIVE_RESOURCES,
									GetProgramivRetValue(program, GL_ACTIVE_UNIFORMS), error);
		VerifyGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_ACTIVE_RESOURCES, 4, error);
		VerifyGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NAME_LENGTH, 18, error);

		std::map<std::string, GLuint> indicesUB;
		std::map<std::string, GLuint> indicesU;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "SimpleBlock", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "NotSoSimpleBlockk", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "TrickyBlock", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM_BLOCK, indicesUB, "TrickyBlock[1]", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "c", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "NotSoSimpleBlockk.a[0]", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "NotSoSimpleBlockk.c", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "NotSoSimpleBlockk.b[0]", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "TrickyBlock.a[2].b[0].d", error);

		glUniformBlockBinding(program, indicesUB["SimpleBlock"], 0);
		glUniformBlockBinding(program, indicesUB["NotSoSimpleBlockk"], 2);
		glUniformBlockBinding(program, indicesUB["TrickyBlock"], 3);
		glUniformBlockBinding(program, indicesUB["TrickyBlock[1]"], 4);

		VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["SimpleBlock"], "SimpleBlock", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["NotSoSimpleBlockk"], "NotSoSimpleBlockk",
									 error);
		VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock"], "TrickyBlock[0]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock[1]"], "TrickyBlock[1]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["NotSoSimpleBlockk.a[0]"], "NotSoSimpleBlockk.a[0]",
									 error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["NotSoSimpleBlockk.c"], "NotSoSimpleBlockk.c",
									 error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["NotSoSimpleBlockk.b[0]"], "NotSoSimpleBlockk.b[0]",
									 error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["TrickyBlock.a[2].b[0].d"],
									 "TrickyBlock.a[2].b[0].d[0]", error);

		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", -1, error);

		GLenum props[] = {
			GL_NAME_LENGTH,
			GL_BUFFER_BINDING,
			GL_REFERENCED_BY_COMPUTE_SHADER,
			GL_REFERENCED_BY_FRAGMENT_SHADER,
			GL_REFERENCED_BY_VERTEX_SHADER,
			GL_BUFFER_DATA_SIZE,
		};
		GLint size;
		glGetActiveUniformBlockiv(program, indicesUB["SimpleBlock"], GL_UNIFORM_BLOCK_DATA_SIZE, &size);
		GLint expected[] = { 12, 0, 0, 0, 1, size };
		VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["SimpleBlock"], 6, props, 6, expected, error);
		glGetActiveUniformBlockiv(program, indicesUB["NotSoSimpleBlockk"], GL_UNIFORM_BLOCK_DATA_SIZE, &size);
		GLint expected2[] = { 18, 2, 0, 0, 1, size };
		VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["NotSoSimpleBlockk"], 6, props, 6, expected2,
								   error);
		glGetActiveUniformBlockiv(program, indicesUB["TrickyBlock"], GL_UNIFORM_BLOCK_DATA_SIZE, &size);
		GLint expected3[] = { 15, 3, 0, 1, 0, size };
		VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock"], 6, props, 6, expected3, error);
		GLint expected4[] = { 15, 4, 0, 1, 0, size };
		VerifyGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["TrickyBlock[1]"], 6, props, 6, expected4,
								   error);

		GLenum props2[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_BLOCK_INDEX,
							GL_ARRAY_STRIDE,
							GL_IS_ROW_MAJOR,
							GL_ATOMIC_COUNTER_BUFFER_INDEX,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_LOCATION };
		GLint expected5[] = { 2, 35687, 1, static_cast<GLint>(indicesUB["SimpleBlock"]), 0, 0, -1, 0, 0, 1, -1 };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 11, props2, 11, expected5, error);
		GLenum props3[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_BLOCK_INDEX,
							GL_MATRIX_STRIDE,
							GL_IS_ROW_MAJOR,
							GL_ATOMIC_COUNTER_BUFFER_INDEX,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_LOCATION };
		GLint expected6[] = { 27, 5126, 2, static_cast<GLint>(indicesUB["TrickyBlock"]), 0, 0, -1, 0, 1, 0, -1 };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indicesU["TrickyBlock.a[2].b[0].d"], 11, props3, 11, expected6,
								   error);

		GLenum			 prop	= GL_ACTIVE_VARIABLES;
		const GLsizei	bufSize = 1000;
		GLsizei			 length;
		GLint			 param[bufSize];
		std::set<GLuint> exp;
		exp.insert(indicesU["a"]);
		exp.insert(indicesU["b"]);
		exp.insert(indicesU["c"]);
		glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["SimpleBlock"], 1, &prop, bufSize, &length, param);
		for (int i = 0; i < length; ++i)
		{
			if (exp.find(param[i]) == exp.end())
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Unexpected index found in active variables of SimpleBlock: " << param[i]
					<< "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
			else if (length != 3)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
					<< "Expected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}
		std::set<GLuint> exp2;
		exp2.insert(indicesU["NotSoSimpleBlockk.a[0]"]);
		exp2.insert(indicesU["NotSoSimpleBlockk.b[0]"]);
		exp2.insert(indicesU["NotSoSimpleBlockk.c"]);
		glGetProgramResourceiv(program, GL_UNIFORM_BLOCK, indicesUB["NotSoSimpleBlockk"], 1, &prop, bufSize, &length,
							   param);
		for (int i = 0; i < length; ++i)
		{
			if (exp2.find(param[i]) == exp2.end())
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Unexpected index found in active variables of NotSoSimpleBlockk: " << param[i]
					<< "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
			else if (length != 3)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_UNIFORM_BLOCK"
					<< "Expected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}

		GLint res;
		glGetProgramInterfaceiv(program, GL_UNIFORM_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, &res);
		if (res < 3)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Value of GL_MAX_NUM_ACTIVE_VARIABLES less than 3!"
				<< tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}

		glDeleteProgram(program);
		return error;
	}
};

class TransformFeedbackTypes : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Transform Feedback Varying Types";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders with different types of out variables used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_TRANSFORM_FEEDBACK_VARYING as an interface param.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   ""
			   "flat out highp vec4 a;               \n"
			   "out mediump float b[2];              \n"
			   "flat out highp uvec2 c;              \n"
			   "flat out highp uint d;               \n"
			   "out mediump vec3 e[2];               \n"
			   "flat out int f;                      \n"
			   ""
			   "void main(void)                      \n"
			   "{                                    \n"
			   "   vec4 pos;                         \n"
			   "   a = vec4(1);                      \n"
			   "   b[0] = 1.1;                       \n"
			   "   b[1] = 1.1;                       \n"
			   "   c = uvec2(1u);                    \n"
			   "   d = 1u;                           \n"
			   "   e[0] = vec3(1.1);                 \n"
			   "   e[1] = vec3(1.1);                 \n"
			   "   f = 1;                            \n"
			   "   gl_Position = position;           \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		const char* varyings[6] = { "a", "b[0]", "b[1]", "c", "d", "e" };
		glTransformFeedbackVaryings(program, 6, varyings, GL_INTERLEAVED_ATTRIBS);
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, GL_ACTIVE_RESOURCES, 6, error);
		VerifyGetProgramInterfaceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, GL_MAX_NAME_LENGTH, 5, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "a", error);
		VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "b[0]", error);
		VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "b[1]", error);
		VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "c", error);
		VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "d", error);
		VerifyGetProgramResourceIndex(program, GL_TRANSFORM_FEEDBACK_VARYING, indices, "e", error);

		VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[0]"], "b[0]", error);
		VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[1]"], "b[1]", error);
		VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["d"], "d", error);
		VerifyGetProgramResourceName(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["e"], "e", error);

		GLenum props[]	= { GL_NAME_LENGTH, GL_TYPE, GL_ARRAY_SIZE };
		GLint  expected[] = { 2, 35666, 1 };
		VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["a"], 3, props, 3, expected, error);
		GLint expected2[] = { 5, 5126, 1 };
		VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[0]"], 3, props, 3, expected2,
								   error);
		GLint expected3[] = { 5, 5126, 1 };
		VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["b[1]"], 3, props, 3, expected3,
								   error);
		GLint expected4[] = { 2, 36294, 1 };
		VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["c"], 3, props, 3, expected4, error);
		GLint expected5[] = { 2, 5125, 1 };
		VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["d"], 3, props, 3, expected5, error);
		GLint expected6[] = { 2, 35665, 2 };
		VerifyGetProgramResourceiv(program, GL_TRANSFORM_FEEDBACK_VARYING, indices["e"], 3, props, 3, expected6, error);

		glDeleteProgram(program);
		return error;
	}
};

class AtomicCounterSimple : public ComputeShaderTest
{
public:
	virtual std::string Title()
	{
		return "Atomic Counter Buffer Simple Test";
	}

	virtual std::string ShadersDesc()
	{
		return "compute shader with atomic counters used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_ATOMIC_COUNTER_BUFFER as an interface param.\n";
	}

	virtual long Run()
	{

		GLint max_buffer_bindings = 0;
		glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &max_buffer_bindings);
		if (max_buffer_bindings < 6)
		{
			OutputNotSupported("Test requires at least 6 atomic counter buffer binding points.");
			return NOT_SUPPORTED;
		}

		const char* const glsl_cs = "layout(local_size_x = 1, local_size_y = 1) in;  \n"
									"layout(std430) buffer Output {                  \n"
									"   mediump vec4 data;                           \n"
									"} g_out;                                        \n"
									""
									"layout (binding = 1, offset = 0) uniform highp atomic_uint a;    \n"
									"layout (binding = 2, offset = 0) uniform highp atomic_uint b;    \n"
									"layout (binding = 2, offset = 4) uniform highp atomic_uint c;    \n"
									"layout (binding = 5, offset = 0) uniform highp atomic_uint d[3]; \n"
									"layout (binding = 5, offset = 12) uniform highp atomic_uint e;   \n"
									""
									"void main() {                                                         \n"
									"   uint x = atomicCounterIncrement(d[0]) + atomicCounterIncrement(a); \n"
									"   uint y = atomicCounterIncrement(d[1]) + atomicCounterIncrement(b); \n"
									"   uint z = atomicCounterIncrement(d[2]) + atomicCounterIncrement(c); \n"
									"   uint w = atomicCounterIncrement(e);                                \n"
									"   g_out.data = vec4(float(x), float(y), float(z), float(w));         \n"
									"}";

		GLuint program = CreateComputeProgram(glsl_cs);
		glLinkProgram(program);
		if (!CheckProgram(program))
		{
			glDeleteProgram(program);
			return ERROR;
		}
		glUseProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, 3, error);
		VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, 2, error);

		std::map<std::string, GLuint> indicesU;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "c", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "d", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "e", error);

		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["d"], "d[0]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["e"], "e", error);

		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "e", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d[0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d[1]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "d[2]", -1, error);

		GLenum		  prop	= GL_ATOMIC_COUNTER_BUFFER_INDEX;
		const GLsizei bufSize = 1000;
		GLsizei		  length;
		GLint		  res;
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, bufSize, &length, &res);

		GLenum props[] = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE, GL_NUM_ACTIVE_VARIABLES, GL_ACTIVE_VARIABLES };
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, bufSize, &length, &res);
		GLint expected[] = { 1, 4, 1, static_cast<GLint>(indicesU["a"]) };
		VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 4, props, 4, expected, error);

		GLenum props2[] = { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE, GL_NUM_ACTIVE_VARIABLES };
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, bufSize, &length, &res);
		GLint expected2[] = { 2, 8, 2 };
		VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected2, error);
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["c"], 1, &prop, bufSize, &length, &res);
		VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected2, error);

		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["d"], 1, &prop, bufSize, &length, &res);
		GLint expected3[] = { 5, 16, 2 };
		VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected3, error);
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["e"], 1, &prop, bufSize, &length, &res);
		VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props2, 3, expected3, error);

		GLenum			 prop2 = GL_ACTIVE_VARIABLES;
		GLint			 param[bufSize];
		std::set<GLuint> exp;
		exp.insert(indicesU["b"]);
		exp.insert(indicesU["c"]);
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, bufSize, &length, &res);
		glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 1, &prop2, bufSize, &length, param);
		for (int i = 0; i < length; ++i)
		{
			if (exp.find(param[i]) == exp.end() || length != 2)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "Length: " << length
					<< "Unexpected index/length found in active variables of ATOMIC_COUNTER_BUFFER: " << param[i]
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}
		std::set<GLuint> exp2;
		GLint			 param2[bufSize];
		exp2.insert(indicesU["d"]);
		exp2.insert(indicesU["e"]);
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["d"], 1, &prop, bufSize, &length, &res);
		glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 1, &prop2, bufSize, &length, param2);
		for (int i = 0; i < length; ++i)
		{
			if (exp2.find(param2[i]) == exp2.end() || length != 2)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "Length: " << length
					<< "Unexpected index/length found in active variables of ATOMIC_COUNTER_BUFFER: " << param2[i]
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}

		glDeleteProgram(program);
		return error;
	}
};

class AtomicCounterSimpleOneBuffer : public ComputeShaderTest
{
public:
	virtual std::string Title()
	{
		return "Atomic Counter Buffer Simple One Buffer Test";
	}

	virtual std::string ShadersDesc()
	{
		return "compute shader with atomic counters used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_ATOMIC_COUNTER_BUFFER as an interface param.\n";
	}

	virtual long Run()
	{

		GLint max_buffer_bindings = 0;
		glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &max_buffer_bindings);
		if (max_buffer_bindings < 3)
		{
			OutputNotSupported("Test requires at least 3 atomic counter buffer binding points.");
			return NOT_SUPPORTED;
		}

		const char* const glsl_cs = "layout(local_size_x = 1, local_size_y = 1) in;  \n"
									"layout(std430) buffer Output {                  \n"
									"   mediump vec4 data;                           \n"
									"} g_out;                                        \n"
									""
									"layout (binding = 0, offset = 0) uniform highp atomic_uint a;    \n"
									"layout (binding = 0, offset = 4) uniform highp atomic_uint b[3]; \n"
									"layout (binding = 0, offset = 16) uniform highp atomic_uint c;   \n"
									""
									"void main() {                                                         \n"
									"   uint x = atomicCounterIncrement(b[0]) + atomicCounterIncrement(a); \n"
									"   uint y = atomicCounterIncrement(b[1]) + atomicCounterIncrement(a); \n"
									"   uint z = atomicCounterIncrement(b[2]) + atomicCounterIncrement(a); \n"
									"   uint w = atomicCounterIncrement(c);                                \n"
									"   g_out.data = vec4(float(x), float(y), float(z), float(w));         \n"
									"}";

		GLuint program = CreateComputeProgram(glsl_cs);
		glLinkProgram(program);
		if (!CheckProgram(program))
		{
			glDeleteProgram(program);
			return ERROR;
		}
		glUseProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_NUM_ACTIVE_VARIABLES, 3, error);

		std::map<std::string, GLuint> indicesU;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "c", error);

		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["b"], "b[0]", error);
		VerifyGetProgramResourceName(program, GL_UNIFORM, indicesU["c"], "c", error);

		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "c", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b[0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b[1]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "b[2]", -1, error);

		GLenum		  prop	= GL_ATOMIC_COUNTER_BUFFER_INDEX;
		const GLsizei bufSize = 1000;
		GLsizei		  length;
		GLint		  res;

		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, bufSize, &length, &res);
		if (res != 0)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Got buffer index " << res << ", expected 0." << tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}

		GLenum props[]	= { GL_BUFFER_BINDING, GL_BUFFER_DATA_SIZE, GL_NUM_ACTIVE_VARIABLES };
		GLint  expected[] = { 0, 20, 3 };
		VerifyGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 3, props, 3, expected, error);

		GLenum			 prop2 = GL_ACTIVE_VARIABLES;
		GLint			 param[bufSize];
		std::set<GLuint> exp;
		exp.insert(indicesU["a"]);
		exp.insert(indicesU["b"]);
		exp.insert(indicesU["c"]);

		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, bufSize, &length, &res);
		if (res != 0)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Got buffer index " << res << ", expected 0." << tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}

		glGetProgramResourceiv(program, GL_ATOMIC_COUNTER_BUFFER, res, 1, &prop2, bufSize, &length, param);
		for (int i = 0; i < length; ++i)
		{
			if (exp.find(param[i]) == exp.end() || length != 3)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "Length: " << length
					<< "Unexpected index/length found in active variables of ATOMIC_COUNTER_BUFFER: " << param[i]
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}

		glDeleteProgram(program);
		return error;
	}
};

class InvalidValueTest : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Invalid Value Test";
	}

	virtual std::string PassCriteria()
	{
		return "GL_INVALID_VALUE error is generated after every function call.";
	}

	virtual std::string Purpose()
	{
		return "Verify that wrong use of functions generates GL_INVALID_VALUE as described in spec.";
	}

	virtual std::string Method()
	{
		return "Call functions with invalid values and check if GL_INVALID_VALUE was generated.";
	}

	virtual long Run()
	{
		long error = NO_ERROR;

		GLint   res;
		GLsizei len		  = 0;
		GLchar  name[100] = { '\0' };
		GLenum  props[1]  = { GL_NAME_LENGTH };

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 1: <program> not a name of shader/program object"
			<< tcu::TestLog::EndMessage;
		glGetProgramInterfaceiv(1337u, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &res);
		ExpectError(GL_INVALID_VALUE, error);
		glGetProgramResourceIndex(31337u, GL_PROGRAM_INPUT, "pie");
		ExpectError(GL_INVALID_VALUE, error);
		glGetProgramResourceName(1337u, GL_PROGRAM_INPUT, 0, 1024, &len, name);
		ExpectError(GL_INVALID_VALUE, error);
		glGetProgramResourceiv(1337u, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
		ExpectError(GL_INVALID_VALUE, error);
		glGetProgramResourceLocation(1337u, GL_PROGRAM_INPUT, "pie");
		ExpectError(GL_INVALID_VALUE, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1: finished" << tcu::TestLog::EndMessage;

		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message
			<< "Case 2: <index> is greater than the number of the active resources in GetProgramResourceName"
			<< tcu::TestLog::EndMessage;
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1: finished" << tcu::TestLog::EndMessage;
		glGetProgramResourceName(program, GL_PROGRAM_INPUT, 3000, 1024, &len, name);
		ExpectError(GL_INVALID_VALUE, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 2: finished" << tcu::TestLog::EndMessage;

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 3: <propCount> is zero in GetProgramResourceiv"
			<< tcu::TestLog::EndMessage;
		glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 0, props, 1024, &len, &res);
		ExpectError(GL_INVALID_VALUE, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 3: finished" << tcu::TestLog::EndMessage;

		std::string str = "position";
		glGetProgramResourceName(program, GL_PROGRAM_INPUT, 0, -100, NULL, const_cast<char*>(str.c_str()));
		ExpectError(GL_INVALID_VALUE, error);
		GLenum prop = GL_NAME_LENGTH;
		glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 1, &prop, -100, &len, &res);
		ExpectError(GL_INVALID_VALUE, error);

		glDeleteProgram(program);
		return error;
	}
};

class InvalidEnumTest : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Invalid Enum Test";
	}

	virtual std::string PassCriteria()
	{
		return "GL_INVALID_ENUM error is generated after every function call.";
	}

	virtual std::string Purpose()
	{
		return "Verify that wrong use of functions generates GL_INVALID_ENUM as described in spec.";
	}

	virtual std::string Method()
	{
		return "Call functions with invalid enums and check if GL_INVALID_ENUM was generated.";
	}

	// make sure at least one atomic counter resource is active
	virtual std::string FragmentShader()
	{
		return "#version 310 es                                        \n"
			   "layout (binding = 0, offset = 0) uniform highp atomic_uint a;\n"
			   "out mediump vec4 outColor;                             \n"
			   "void main(void) {                                      \n"
			   "   uint b = atomicCounterIncrement(a);                 \n"
			   "   outColor = vec4(float(b));                          \n"
			   "}                                                      \n";
	}

	virtual long Run()
	{
		GLint max_buffers = 0, max_counters = 0;
		glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, &max_buffers);
		glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTERS, &max_counters);
		if (max_buffers < 1 || max_counters < 1)
		{
			OutputNotSupported("Test requires at least 1 atomic counter.");
			return NOT_SUPPORTED;
		}

		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		GLint   res;
		GLsizei len		  = 0;
		GLchar  name[100] = { '\0' };
		GLenum  props[1]  = { GL_TEXTURE_1D };

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 1: <programInterface> is ATOMIC_COUNTER_BUFFER in "
										"GetProgramResourceIndex or GetProgramResourceName"
			<< tcu::TestLog::EndMessage;
		glGetProgramResourceIndex(program, GL_ATOMIC_COUNTER_BUFFER, name);
		ExpectError(GL_INVALID_ENUM, error);
		glGetProgramResourceName(program, GL_ATOMIC_COUNTER_BUFFER, 0, 1024, &len, name);
		ExpectError(GL_INVALID_ENUM, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1 finished" << tcu::TestLog::EndMessage;

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message
			<< "Case 2: <props> is not a property name supported by the command GetProgramResourceiv"
			<< tcu::TestLog::EndMessage;
		glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
		ExpectError(GL_INVALID_ENUM, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 2 finished" << tcu::TestLog::EndMessage;

		glGetProgramResourceLocation(program, GL_ATOMIC_COUNTER_BUFFER, "position");
		ExpectError(GL_INVALID_ENUM, error);

		glDeleteProgram(program);
		return error;
	}
};

class InvalidOperationTest : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Invalid Operation Test";
	}

	virtual std::string PassCriteria()
	{
		return "GL_INVALID_OPERATION error is generated after every function call.";
	}

	virtual std::string Purpose()
	{
		return "Verify that wrong use of functions generates GL_INVALID_OPERATION as described in spec.";
	}

	virtual std::string Method()
	{
		return "Perform invalid operation and check if GL_INVALID_OPERATION was generated.";
	}

	virtual long Run()
	{
		long error = NO_ERROR;

		GLuint program  = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		GLuint program2 = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		const GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);
		GLint		 res;
		GLsizei		 len	   = 0;
		GLchar		 name[100] = { '\0' };
		GLenum		 props[1]  = { GL_OFFSET };

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 1: <program> is the name of a shader object" << tcu::TestLog::EndMessage;
		glGetProgramInterfaceiv(sh, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &res);
		ExpectError(GL_INVALID_OPERATION, error);
		glGetProgramResourceIndex(sh, GL_PROGRAM_INPUT, "pie");
		ExpectError(GL_INVALID_OPERATION, error);
		glGetProgramResourceName(sh, GL_PROGRAM_INPUT, 0, 1024, &len, name);
		ExpectError(GL_INVALID_OPERATION, error);
		glGetProgramResourceiv(sh, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
		ExpectError(GL_INVALID_OPERATION, error);
		glGetProgramResourceLocation(sh, GL_PROGRAM_INPUT, "pie");
		ExpectError(GL_INVALID_OPERATION, error);
		glDeleteShader(sh);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 1 finished" << tcu::TestLog::EndMessage;

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 2: <pname> is not supported in GetProgramInterfaceiv"
			<< tcu::TestLog::EndMessage;
		glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NUM_ACTIVE_VARIABLES, &res);
		ExpectError(GL_INVALID_OPERATION, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 2 finished" << tcu::TestLog::EndMessage;

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 3: <props> is not supported in GetProgramResourceiv"
			<< tcu::TestLog::EndMessage;
		glGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, 1, props, 1024, &len, &res);
		ExpectError(GL_INVALID_OPERATION, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 3 finished" << tcu::TestLog::EndMessage;

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Case 4: <program> has not been linked in GetProgramResourceLocation"
			<< tcu::TestLog::EndMessage;
		glGetProgramResourceLocation(program2, GL_PROGRAM_INPUT, "pie");
		ExpectError(GL_INVALID_OPERATION, error);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Case 4 finished" << tcu::TestLog::EndMessage;

		glDeleteProgram(program);
		glDeleteProgram(program2);
		return error;
	}
};

class ShaderStorageBlock : public ComputeShaderTest
{
	virtual std::string Title()
	{
		return "Shader Storage Block Test";
	}

	virtual std::string ShadersDesc()
	{
		return "compute shader different types of storage blocks used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_BUFFER_VARIABLE and GL_SHADER_STORAGE_BLOCK as an interface "
			   "params.\n";
	}

	virtual std::string ComputeShader()
	{
		return "layout(local_size_x = 1, local_size_y = 1) in;  \n"
			   "layout(std430) buffer Output {                  \n"
			   "   mediump vec4 data;                           \n"
			   "} g_out;                                        \n"
			   ""
			   "struct U {                     \n"
			   "   bool a[3];                  \n"
			   "   mediump vec4 b;                     \n"
			   "   mediump mat3 c;                     \n"
			   "   mediump float d[2];                 \n"
			   "};                             \n"
			   "struct UU {                    \n"
			   "   U a;                        \n"
			   "   U b[2];                     \n"
			   "   uvec2 c;                    \n"
			   "};                             \n"
			   ""
			   "layout(binding=4) buffer TrickyBuffer {          \n"
			   "   UU a[3];                                      \n"
			   "   mediump mat4 b;                               \n"
			   "   uint c;                                       \n"
			   "} e[2];                                          \n"
			   ""
			   "layout(binding = 0) buffer SimpleBuffer {                \n"
			   "   mediump mat3x2 a;                                     \n"
			   "   mediump mat4 b;                                       \n"
			   "   mediump vec4 c;                                       \n"
			   "};                                                       \n"
			   ""
			   "layout(binding = 1) buffer NotSoSimpleBuffer {           \n"
			   "   ivec2 a[4];                                           \n"
			   "   mediump mat3 b[2];                                    \n"
			   "   mediump mat2 c;                                       \n"
			   "} d;                                                     \n"
			   ""
			   "void main() {                                    \n"
			   "    mediump float tmp;                           \n"
			   "    mediump float tmp2;                          \n"
			   "    tmp = e[0].a[0].b[0].d[0] * float(e[1].c);   \n"
			   "    tmp2 = a[0][0] * b[0][0] * c.x;                                \n"
			   "    tmp2 = tmp2 + float(d.a[0].y) + d.b[0][0][0] + d.c[0][0];      \n"
			   "    g_out.data = vec4(0, 1, 0, 1) * tmp * tmp2;                    \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateComputeProgram(ComputeShader());
		glLinkProgram(program);
		if (!CheckProgram(program))
		{
			glDeleteProgram(program);
			return ERROR;
		}
		glUseProgram(program);

		long error = NO_ERROR;

		GLint res;
		VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_MAX_NAME_LENGTH, 28, error);
		glGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_ACTIVE_RESOURCES, &res);
		if (res < 7)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message
				<< "Error on: glGetProgramInterfaceiv, if: GL_BUFFER_VARIABLE, param: GL_ACTIVE_RESOURCES\n"
				<< "Expected value greater or equal to 7, got " << res << tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, 5, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, 18, error);

		std::map<std::string, GLuint> indicesSSB;
		std::map<std::string, GLuint> indicesBV;
		VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "SimpleBuffer", error);
		VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "NotSoSimpleBuffer", error);
		VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "TrickyBuffer", error);
		VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "TrickyBuffer[1]", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "a", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "b", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "c", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "NotSoSimpleBuffer.a[0]", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "NotSoSimpleBuffer.c", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "NotSoSimpleBuffer.b[0]", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "TrickyBuffer.a[0].b[0].d", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "TrickyBuffer.b", error);
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "TrickyBuffer.c", error);

		VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["SimpleBuffer"], "SimpleBuffer",
									 error);
		VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["NotSoSimpleBuffer"],
									 "NotSoSimpleBuffer", error);
		VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer"], "TrickyBuffer[0]",
									 error);
		VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer[1]"], "TrickyBuffer[1]",
									 error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["NotSoSimpleBuffer.a[0]"],
									 "NotSoSimpleBuffer.a[0]", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["NotSoSimpleBuffer.c"],
									 "NotSoSimpleBuffer.c", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["NotSoSimpleBuffer.b[0]"],
									 "NotSoSimpleBuffer.b[0]", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.a[0].b[0].d"],
									 "TrickyBuffer.a[0].b[0].d[0]", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.b"], "TrickyBuffer.b", error);
		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.c"], "TrickyBuffer.c", error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_BUFFER_BINDING,
						   GL_NUM_ACTIVE_VARIABLES,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER };
		GLint expected[] = { 13, 0, 3, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["SimpleBuffer"], 6, props, 6, expected,
								   error);
		GLenum props2[] = { GL_NAME_LENGTH, GL_BUFFER_BINDING, GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER, GL_REFERENCED_BY_VERTEX_SHADER };
		GLint expected2[] = { 18, 1, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["NotSoSimpleBuffer"], 5, props2, 5,
								   expected2, error);
		GLint expected3[] = { 16, 4, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer"], 5, props2, 5,
								   expected3, error);
		GLint expected4[] = { 16, 5, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["TrickyBuffer[1]"], 5, props2, 5,
								   expected4, error);

		GLenum props3[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_BLOCK_INDEX,
							GL_ARRAY_STRIDE,
							GL_IS_ROW_MAJOR,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_TOP_LEVEL_ARRAY_SIZE,
							GL_TOP_LEVEL_ARRAY_STRIDE };
		GLint expected5[] = { 2, 35687, 1, static_cast<GLint>(indicesSSB["SimpleBuffer"]), 0, 0, 1, 0, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["a"], 11, props3, 11, expected5, error);
		GLenum props4[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_BLOCK_INDEX,
							GL_MATRIX_STRIDE,
							GL_IS_ROW_MAJOR,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_TOP_LEVEL_ARRAY_SIZE };
		GLint expected6[] = { 28, 5126, 2, static_cast<GLint>(indicesSSB["TrickyBuffer"]), 0, 0, 1, 0, 0, 3 };
		VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["TrickyBuffer.a[0].b[0].d"], 10, props4, 10,
								   expected6, error);

		GLenum			 prop	= GL_ACTIVE_VARIABLES;
		const GLsizei	bufSize = 1000;
		GLsizei			 length;
		GLint			 param[bufSize];
		std::set<GLuint> exp;
		exp.insert(indicesBV["a"]);
		exp.insert(indicesBV["b"]);
		exp.insert(indicesBV["c"]);
		glGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["SimpleBuffer"], 1, &prop, bufSize, &length,
							   param);
		for (int i = 0; i < length; ++i)
		{
			if (exp.find(param[i]) == exp.end())
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Unexpected index found in active variables of SimpleBuffer: " << param[i]
					<< "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: "
					   "GL_SHADER_STORAGE_BLOCK"
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
			else if (length != 3)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_SHADER_STORAGE_BLOCK"
					<< "Expected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}
		std::set<GLuint> exp2;
		exp2.insert(indicesBV["NotSoSimpleBuffer.a[0]"]);
		exp2.insert(indicesBV["NotSoSimpleBuffer.b[0]"]);
		exp2.insert(indicesBV["NotSoSimpleBuffer.c"]);
		glGetProgramResourceiv(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["NotSoSimpleBuffer"], 1, &prop, bufSize,
							   &length, param);
		for (int i = 0; i < length; ++i)
		{
			if (exp2.find(param[i]) == exp2.end())
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Unexpected index found in active variables of NotSoSimpleBuffer: " << param[i]
					<< "\nCall: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: "
					   "GL_SHADER_STORAGE_BLOCK"
					<< tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
			else if (length != 3)
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "Call: glGetProgramResourceiv, property: GL_ACTIVE_VARIABLES interface: GL_SHADER_STORAGE_BLOCK"
					<< param[i] << "\nExpected length: 3, actual length: " << length << tcu::TestLog::EndMessage;
				glDeleteProgram(program);
				return ERROR;
			}
		}

		glGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NUM_ACTIVE_VARIABLES, &res);
		if (res < 3)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Value of GL_MAX_NUM_ACTIVE_VARIABLES less than 3!\n"
				<< "Call: glGetProgramInterfaceiv, interface: GL_SHADER_STORAGE_BLOCK" << tcu::TestLog::EndMessage;
			return ERROR;
		}

		glDeleteProgram(program);
		return error;
	}
};

class NullLength : public SimpleShaders
{

	virtual std::string Title()
	{
		return "NULL Length Test";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify that GetProgramResourceName with null length doesn't return length (doesn't "
			   "crash).\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = position;          \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "out mediump vec4 color;                \n"
			   "void main() {                  \n"
			   "    color = vec4(0, 1, 0, 1);  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		GLchar name[1024] = { '\0' };
		GLuint index	  = glGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "color");
		GLenum prop		  = GL_ARRAY_SIZE;
		GLint  res;
		glGetProgramResourceName(program, GL_PROGRAM_OUTPUT, 0, 1024, NULL, name);
		glGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, index, 1, &prop, 1, NULL, &res);

		std::string expected = "color";
		if (name != expected)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "Expected name: " << expected
												<< ", got: " << name << tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}
		else if (res != 1)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected array_size: 1, got: " << res << tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}

		glDeleteProgram(program);
		return NO_ERROR;
	}
};

class ArraysOfArrays : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Arrays Of Arrays Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders with multi dimensional uniform array used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify that feature works correctly with arrays_of_arrays feature.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   "uniform mediump vec4 a[3][4][5];             \n"
			   "void main(void)                      \n"
			   "{                                                 \n"
			   "    gl_Position = position + a[2][1][0];          \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "out mediump vec4 color;                \n"
			   "void main() {                  \n"
			   "    color = vec4(0, 1, 0, 1);  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_UNIFORM, GL_MAX_NAME_LENGTH, 11, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indices, "a[2][1]", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, "a[2][1][0]", indices["a[2][1]"], error);

		VerifyGetProgramResourceName(program, GL_UNIFORM, indices["a[2][1]"], "a[2][1][0]", error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_OFFSET,
						   GL_BLOCK_INDEX,
						   GL_ARRAY_STRIDE,
						   GL_MATRIX_STRIDE,
						   GL_IS_ROW_MAJOR,
						   GL_ATOMIC_COUNTER_BUFFER_INDEX,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 11, 35666, 5, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(program, "a[2][1]") };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indices["a[2][1]"], 13, props, 13, expected, error);

		glDeleteProgram(program);
		return error;
	}
};

class TopLevelArray : public ComputeShaderTest
{

	virtual std::string Title()
	{
		return "Top Level Array Test";
	}

	virtual std::string ShadersDesc()
	{
		return "compute shader with multi dimensional array used inside storage block";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify that feature works correctly when querying for GL_TOP_LEVEL_ARRAY_SIZE\n"
			   " and GL_TOP_LEVEL_ARRAY_STRIDE.\n";
	}

	virtual std::string ComputeShader()
	{
		return "layout(local_size_x = 1, local_size_y = 1) in; \n"
			   "layout(std430) buffer Outp {                   \n"
			   "   mediump vec4 d;                             \n"
			   "} g_out;                                       \n"
			   ""
			   "buffer Block {                       \n"
			   "   mediump vec4 a[5][4][3];          \n"
			   "};                                   \n"
			   ""
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    g_out.d = a[0][0][0];            \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateComputeProgram(ComputeShader());
		glLinkProgram(program);
		if (!CheckProgram(program))
		{
			glDeleteProgram(program);
			return ERROR;
		}
		glUseProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_BUFFER_VARIABLE, GL_MAX_NAME_LENGTH, 11, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_MAX_NAME_LENGTH, 6, error);
		VerifyGetProgramInterfaceiv(program, GL_SHADER_STORAGE_BLOCK, GL_ACTIVE_RESOURCES, 2, error);

		std::map<std::string, GLuint> indicesSSB;
		std::map<std::string, GLuint> indicesBV;
		VerifyGetProgramResourceIndex(program, GL_BUFFER_VARIABLE, indicesBV, "a[0][0]", error);
		VerifyGetProgramResourceIndex(program, GL_SHADER_STORAGE_BLOCK, indicesSSB, "Block", error);

		VerifyGetProgramResourceName(program, GL_BUFFER_VARIABLE, indicesBV["a[0][0]"], "a[0][0][0]", error);
		VerifyGetProgramResourceName(program, GL_SHADER_STORAGE_BLOCK, indicesSSB["Block"], "Block", error);

		GLenum props3[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_BLOCK_INDEX,
							GL_IS_ROW_MAJOR,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_TOP_LEVEL_ARRAY_SIZE };
		GLint expected5[] = { 11, 35666, 3, static_cast<GLint>(indicesSSB["Block"]), 0, 1, 0, 0, 5 };
		VerifyGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["a[0][0]"], 9, props3, 9, expected5, error);

		GLenum  prop = GL_TOP_LEVEL_ARRAY_STRIDE;
		GLsizei len;
		GLint   res;
		glGetProgramResourceiv(program, GL_BUFFER_VARIABLE, indicesBV["a[0][0]"], 1, &prop, 1024, &len, &res);
		if (res <= 0)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message
				<< "Call: glGetProgramResourceiv, interface: GL_BUFFER_VARIABLE, param: GL_TOP_LEVEL_ARRAY_STRIDE\n"
				<< "Expected value greater than 0, got: " << res << tcu::TestLog::EndMessage;
			glDeleteProgram(program);
			return ERROR;
		}

		glDeleteProgram(program);
		return error;
	}
};

class SeparateProgramsVertex : public SimpleShaders
{
public:
	virtual std::string Title()
	{
		return "Separate Program Vertex Shader Test";
	}

	virtual std::string ShadersDesc()
	{
		return "vertex shader as separate shader object";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify that feature works correctly when using separate_shader_objects "
			   "functionality.\n";
	}

	virtual GLuint CreateShaderProgram(GLenum type, GLsizei count, const GLchar** strings)
	{
		GLuint program = glCreateShaderProgramv(type, count, strings);
		GLint  status  = GL_TRUE;
		glGetProgramiv(program, GL_LINK_STATUS, &status);
		if (status == GL_FALSE)
		{
			GLsizei length;
			GLchar  log[1024];
			glGetProgramInfoLog(program, sizeof(log), &length, log);
			if (length > 1)
			{
				m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program Info Log:\n"
													<< log << tcu::TestLog::EndMessage;
			}
		}
		return program;
	}

	virtual long Run()
	{
		long error = NO_ERROR;

		const char* srcVS = "#version 310 es                            \n"
							"layout(location = 0) in vec4 in_vertex;    \n"
							""
							"out mediump float r, g, b;                           \n"
							"out mediump vec4 iLikePie;                           \n"
							""
							"uniform mediump float u;                           \n"
							"uniform mediump vec4 v;                            \n"
							""
							"void main() {                     \n"
							"  gl_Position = in_vertex;        \n"
							"  r = u;                          \n"
							"  g = 0.0;                        \n"
							"  b = 0.0;                        \n"
							"  iLikePie = v;                   \n"
							"}";

		const GLuint vs = CreateShaderProgram(GL_VERTEX_SHADER, 1, &srcVS);

		VerifyGetProgramInterfaceiv(vs, GL_UNIFORM, GL_MAX_NAME_LENGTH, 2, error);
		VerifyGetProgramInterfaceiv(vs, GL_UNIFORM, GL_ACTIVE_RESOURCES, 2, error);
		VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 10, error);
		VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 12, error);
		VerifyGetProgramInterfaceiv(vs, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 5, error);

		std::map<std::string, GLuint> indicesU;
		std::map<std::string, GLuint> indicesI;
		std::map<std::string, GLuint> indicesO;
		VerifyGetProgramResourceIndex(vs, GL_UNIFORM, indicesU, "u", error);
		VerifyGetProgramResourceIndex(vs, GL_UNIFORM, indicesU, "v", error);
		VerifyGetProgramResourceIndex(vs, GL_PROGRAM_INPUT, indicesI, "in_vertex", error);
		VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "r", error);
		VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "g", error);
		VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "b", error);
		VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "iLikePie", error);
		VerifyGetProgramResourceIndex(vs, GL_PROGRAM_OUTPUT, indicesO, "gl_Position", error);

		VerifyGetProgramResourceName(vs, GL_UNIFORM, indicesU["u"], "u", error);
		VerifyGetProgramResourceName(vs, GL_UNIFORM, indicesU["v"], "v", error);
		VerifyGetProgramResourceName(vs, GL_PROGRAM_INPUT, indicesI["in_vertex"], "in_vertex", error);
		VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["r"], "r", error);
		VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["g"], "g", error);
		VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["b"], "b", error);
		VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["iLikePie"], "iLikePie", error);
		VerifyGetProgramResourceName(vs, GL_PROGRAM_OUTPUT, indicesO["gl_Position"], "gl_Position", error);

		VerifyGetProgramResourceLocation(vs, GL_UNIFORM, "u", glGetUniformLocation(vs, "u"), error);
		VerifyGetProgramResourceLocation(vs, GL_UNIFORM, "v", glGetUniformLocation(vs, "v"), error);
		VerifyGetProgramResourceLocation(vs, GL_PROGRAM_INPUT, "in_vertex", 0, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_OFFSET,
						   GL_BLOCK_INDEX,
						   GL_ARRAY_STRIDE,
						   GL_MATRIX_STRIDE,
						   GL_IS_ROW_MAJOR,
						   GL_ATOMIC_COUNTER_BUFFER_INDEX,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 2, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 0, 1, glGetUniformLocation(vs, "v") };
		VerifyGetProgramResourceiv(vs, GL_UNIFORM, indicesU["v"], 13, props, 13, expected, error);

		GLenum props2[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_LOCATION };
		GLint expected2[] = { 10, 35666, 1, 0, 0, 1, 0 };
		VerifyGetProgramResourceiv(vs, GL_PROGRAM_INPUT, indicesI["in_vertex"], 7, props2, 7, expected2, error);

		GLenum props3[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER };
		GLint expected3[] = { 9, 35666, 1, 0, 0, 1 };
		VerifyGetProgramResourceiv(vs, GL_PROGRAM_OUTPUT, indicesO["iLikePie"], 6, props3, 6, expected3, error);

		glDeleteProgram(vs);
		return error;
	}
};

class SeparateProgramsFragment : public SeparateProgramsVertex
{

	virtual std::string Title()
	{
		return "Separate Program Fragment Shader Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fragment shader as separate shader object";
	}

	virtual long Run()
	{
		long error = NO_ERROR;

		const char* srcTCS = "#version 310 es                                  \n"
							 "out mediump vec4 fs_color;                       \n"
							 ""
							 "layout(location = 1) uniform mediump vec4 x;     \n"
							 ""
							 "in mediump vec4 vs_color;                        \n"
							 "void main() {                                    \n"
							 "   fs_color = vs_color + x;                      \n"
							 "}";

		const GLuint tcs = CreateShaderProgram(GL_FRAGMENT_SHADER, 1, &srcTCS);

		VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 9, error);
		VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 9, error);
		VerifyGetProgramInterfaceiv(tcs, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(tcs, GL_UNIFORM, GL_MAX_NAME_LENGTH, 2, error);
		VerifyGetProgramInterfaceiv(tcs, GL_UNIFORM, GL_ACTIVE_RESOURCES, 1, error);

		std::map<std::string, GLuint> indicesI;
		std::map<std::string, GLuint> indicesO;
		std::map<std::string, GLuint> indicesU;
		VerifyGetProgramResourceIndex(tcs, GL_PROGRAM_INPUT, indicesI, "vs_color", error);
		VerifyGetProgramResourceIndex(tcs, GL_PROGRAM_OUTPUT, indicesO, "fs_color", error);
		VerifyGetProgramResourceIndex(tcs, GL_UNIFORM, indicesU, "x", error);

		VerifyGetProgramResourceName(tcs, GL_PROGRAM_INPUT, indicesI["vs_color"], "vs_color", error);
		VerifyGetProgramResourceName(tcs, GL_PROGRAM_OUTPUT, indicesO["fs_color"], "fs_color", error);
		VerifyGetProgramResourceName(tcs, GL_UNIFORM, indicesU["x"], "x", error);

		VerifyGetProgramResourceLocation(tcs, GL_UNIFORM, "x", 1, error);

		GLenum props2[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER };
		GLint expected2[] = { 9, 35666, 1, 0, 1, 0 };
		VerifyGetProgramResourceiv(tcs, GL_PROGRAM_INPUT, indicesI["vs_color"], 6, props2, 6, expected2, error);
		VerifyGetProgramResourceiv(tcs, GL_PROGRAM_OUTPUT, indicesO["fs_color"], 6, props2, 6, expected2, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_OFFSET,
						   GL_BLOCK_INDEX,
						   GL_ARRAY_STRIDE,
						   GL_MATRIX_STRIDE,
						   GL_IS_ROW_MAJOR,
						   GL_ATOMIC_COUNTER_BUFFER_INDEX,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 2, 35666, 1, -1, -1, -1, -1, 0, -1, 0, 1, 0, 1 };
		VerifyGetProgramResourceiv(tcs, GL_UNIFORM, indicesU["x"], 13, props, 13, expected, error);

		glDeleteProgram(tcs);
		return error;
	}
};

class UniformBlockAdvanced : public SimpleShaders
{
	virtual std::string Title()
	{
		return "Uniform Block Advanced Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment and vertex shaders with different types of uniform blocks used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify calls using GL_UNIFORM_BLOCK as an interface param and\n"
			   "verify results of querying offset, strides and row order.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   ""
			   "layout(row_major) uniform SimpleBlock {   \n"
			   "   mat4 a;                                \n"
			   "   vec4 b[10];                            \n"
			   "};                                        \n"
			   ""
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    float tmp;                       \n"
			   "    tmp = a[0][0] + b[0].x;          \n"
			   "    gl_Position = position * tmp;    \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		std::map<std::string, GLuint> indicesU;
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "a", error);
		VerifyGetProgramResourceIndex(program, GL_UNIFORM, indicesU, "b", error);

		GLenum props[]	= { GL_IS_ROW_MAJOR };
		GLint  expected[] = { 1 };
		VerifyGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, props, 1, expected, error);

		GLenum  prop = GL_MATRIX_STRIDE;
		GLsizei len;
		GLint   res;
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, 1024, &len, &res);
		if (res < 1)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message
				<< "ERROR: glGetProgramResourceiv, interface GL_UNIFORM, prop GL_MATRIX_STRIDE\n"
				<< "Expected value greater than 0, got " << res << tcu::TestLog::EndMessage;
		}
		prop = GL_OFFSET;
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["a"], 1, &prop, 1024, &len, &res);
		if (res < 0)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "ERROR: glGetProgramResourceiv, interface GL_UNIFORM, prop GL_OFFSET\n"
				<< "Expected value not less than 0, got " << res << tcu::TestLog::EndMessage;
		}
		prop = GL_ARRAY_STRIDE;
		glGetProgramResourceiv(program, GL_UNIFORM, indicesU["b"], 1, &prop, 1024, &len, &res);
		if (res < 1)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message
				<< "ERROR: glGetProgramResourceiv, interface GL_UNIFORM, prop GL_ARRAY_STRIDE\n"
				<< "Expected value greater than 0, got " << res << tcu::TestLog::EndMessage;
		}

		glDeleteProgram(program);
		return error;
	}
};

class ArrayNames : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Array Names Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment shader and a vertex shader with array of vec4 uniform used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify that GetProgramResourceLocation match "
			   "name strings correctly.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   ""
			   "uniform mediump vec4 a[2];           \n"
			   ""
			   "void main(void)                            \n"
			   "{                                          \n"
			   "    gl_Position = position + a[0] + a[1];  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a", glGetUniformLocation(program, "a"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0]", glGetUniformLocation(program, "a"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[1]", glGetUniformLocation(program, "a[1]"), error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[2]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0 + 0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0+0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[ 0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[0 ]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[\n0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[\t0]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[01]", -1, error);
		VerifyGetProgramResourceLocation(program, GL_UNIFORM, "a[00]", -1, error);

		glDeleteProgram(program);
		return error;
	}
};

class BuffLength : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Buff Length Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fallthrough fragment shader and vertex with uniform of vec4 type used";
	}

	virtual std::string PurposeExt()
	{
		return "\n\n Purpose is to verify that bufsize of GetProgramResourceName and "
			   "GetProgramResourceiv is respected.\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 position;                    \n"
			   ""
			   "uniform mediump vec4 someLongName;         \n"
			   ""
			   "void main(void)                            \n"
			   "{                                          \n"
			   "    gl_Position = position + someLongName; \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		LinkProgram(program);

		long error = NO_ERROR;

		GLuint  index = glGetProgramResourceIndex(program, GL_UNIFORM, "someLongName");
		GLsizei length;
		GLchar  buff[3] = { 'a', 'b', 'c' };
		glGetProgramResourceName(program, GL_UNIFORM, index, 0, NULL, NULL);
		glGetProgramResourceName(program, GL_UNIFORM, index, 0, NULL, buff);
		if (buff[0] != 'a' || buff[1] != 'b' || buff[2] != 'c')
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "ERROR: buff has changed" << tcu::TestLog::EndMessage;
			error = ERROR;
		}
		glGetProgramResourceName(program, GL_UNIFORM, index, 2, &length, buff);
		if (buff[0] != 's' || buff[1] != '\0' || buff[2] != 'c')
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "ERROR: buff different then expected" << tcu::TestLog::EndMessage;
			error = ERROR;
		}
		if (length != 1)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: incorrect length, expected 1, got "
												<< length << tcu::TestLog::EndMessage;
			error = ERROR;
		}

		GLint  params[3] = { 1, 2, 3 };
		GLenum props[]   = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_OFFSET,
						   GL_BLOCK_INDEX,
						   GL_ARRAY_STRIDE,
						   GL_MATRIX_STRIDE,
						   GL_IS_ROW_MAJOR,
						   GL_ATOMIC_COUNTER_BUFFER_INDEX,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		glGetProgramResourceiv(program, GL_UNIFORM, index, 13, props, 0, NULL, NULL);
		glGetProgramResourceiv(program, GL_UNIFORM, index, 13, props, 0, NULL, params);
		if (params[0] != 1 || params[1] != 2 || params[2] != 3)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "ERROR: params has changed" << tcu::TestLog::EndMessage;
			error = ERROR;
		}
		glGetProgramResourceiv(program, GL_UNIFORM, index, 13, props, 2, &length, params);
		if (params[0] != 13 || params[1] != 35666 || params[2] != 3)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "ERROR: params has incorrect values" << tcu::TestLog::EndMessage;
			error = ERROR;
		}
		if (length != 2)
		{
			m_context.getTestContext().getLog() << tcu::TestLog::Message << "ERROR: incorrect length, expected 2, got "
												<< length << tcu::TestLog::EndMessage;
			error = ERROR;
		}

		glDeleteProgram(program);
		return error;
	}
};

class NoLocations : public SimpleShaders
{

	virtual std::string Title()
	{
		return "No Locations Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fragment and vertex shaders with no locations set";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                      \n"
			   "in vec4 a;                           \n"
			   "in vec4 b;                           \n"
			   "in vec4 c;                           \n"
			   "in vec4 d;                           \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = a + b + c + d;     \n"
			   "}";
	}

	// fragment shader outputs need an explicit location per spec
	virtual std::string FragmentShader()
	{
		return "#version 310 es                \n"
			   "layout (location=0) out mediump vec4 a;            \n"
			   "layout (location=1) out mediump vec4 b;            \n"
			   "layout (location=2) out mediump vec4 c;            \n"
			   "layout (location=3) out mediump vec4 d[1];         \n"
			   "void main() {                  \n"
			   "    a = vec4(0, 1, 0, 1);      \n"
			   "    b = vec4(0, 1, 0, 1);      \n"
			   "    c = vec4(0, 1, 0, 1);      \n"
			   "    d[0] = vec4(0, 1, 0, 1);   \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		glLinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 4, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 2, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 4, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 5, error);

		std::map<std::string, GLuint> indicesI;
		std::map<std::string, GLuint> indicesO;
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "a", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "b", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "c", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, indicesI, "d", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "a", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "b", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "c", error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indicesO, "d[0]", error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, indicesI["d"], "d", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["a"], "a", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["b"], "b", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["c"], "c", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indicesO["d[0]"], "d[0]", error);

		std::map<std::string, GLint> locationsI;
		std::map<std::string, GLint> locationsO;
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "a", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "b", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "c", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, locationsI, "d", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "a", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "b", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "c", error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, locationsO, "d[0]", error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER };
		GLint expected[] = { 2, 35666, 1, 0, 0, 1 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["a"], 6, props, 6, expected, error);
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["b"], 6, props, 6, expected, error);
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["d"], 6, props, 6, expected, error);
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, indicesI["c"], 6, props, 6, expected, error);
		GLint expected3[] = { 2, 35666, 1, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["a"], 6, props, 6, expected3, error);
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["b"], 6, props, 6, expected3, error);
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["c"], 6, props, 6, expected3, error);
		GLint expected4[] = { 5, 35666, 1, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indicesO["d[0]"], 6, props, 6, expected4, error);

		glDeleteProgram(program);
		return error;
	}
};

class OutputBuiltIn : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Output Built-ins Test";
	}

	virtual std::string ShadersDesc()
	{
		return "fragment shader using built-in variables and a fallthrough vertex shader";
	}

	virtual std::string Expectations()
	{
		return ".\n\n In this case we ask for information about built-in variables for the output interface.";
	}

	virtual std::string FragmentShader()
	{
		return "#version 310 es                            \n"
			   "void main(void)                            \n"
			   "{                                          \n"
			   "    gl_FragDepth = 0.1;                    \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), true);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 13, error);

		std::map<std::string, GLuint> indices;
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, indices, "gl_FragDepth", error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, indices["gl_FragDepth"], "gl_FragDepth", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "gl_FragDepth", -1, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 13, 5126, 1, 0, 1, 0, -1 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, indices["gl_FragDepth"], DE_LENGTH_OF_ARRAY(props),
								   props, DE_LENGTH_OF_ARRAY(expected), expected, error);

		glDeleteProgram(program);
		return error;
	}
};

class QueryNotUsed : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Query Not Used Test";
	}

	virtual std::string PassCriteria()
	{
		return "Data from queries matches the not used program.";
	}

	virtual std::string Purpose()
	{
		return "Verify that program parameter works correctly and proper program is queried when different program is "
			   "used.";
	}

	virtual std::string Method()
	{
		return "Create 2 programs, use one of them and query the other, verify the results.";
	}

	virtual std::string VertexShader2()
	{
		return "#version 310 es                      \n"
			   "in mediump vec4 p;                   \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = p;                 \n"
			   "}";
	}

	virtual std::string FragmentShader2()
	{
		return "#version 310 es                \n"
			   "out mediump vec4 c;            \n"
			   "void main() {                  \n"
			   "    c = vec4(0., 1., 0., 1.);  \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		LinkProgram(program);

		GLuint program2 = CreateProgram(VertexShader2().c_str(), FragmentShader2().c_str(), false);
		LinkProgram(program2);
		glUseProgram(program2);

		long error = NO_ERROR;

		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, 9, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_ACTIVE_RESOURCES, 1, error);
		VerifyGetProgramInterfaceiv(program, GL_PROGRAM_OUTPUT, GL_MAX_NAME_LENGTH, 6, error);

		VerifyGetProgramResourceIndex(program, GL_PROGRAM_OUTPUT, "color", 0, error);
		VerifyGetProgramResourceIndex(program, GL_PROGRAM_INPUT, "position", 0, error);

		VerifyGetProgramResourceName(program, GL_PROGRAM_OUTPUT, 0, "color", error);
		VerifyGetProgramResourceName(program, GL_PROGRAM_INPUT, 0, "position", error);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", 0, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", 0, error);

		GLenum props[] = { GL_NAME_LENGTH,
						   GL_TYPE,
						   GL_ARRAY_SIZE,
						   GL_REFERENCED_BY_COMPUTE_SHADER,
						   GL_REFERENCED_BY_FRAGMENT_SHADER,
						   GL_REFERENCED_BY_VERTEX_SHADER,
						   GL_LOCATION };
		GLint expected[] = { 9, 35666, 1, 0, 0, 1, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_INPUT, 0, DE_LENGTH_OF_ARRAY(props), props,
								   DE_LENGTH_OF_ARRAY(expected), expected, error);

		GLenum props2[] = { GL_NAME_LENGTH,
							GL_TYPE,
							GL_ARRAY_SIZE,
							GL_REFERENCED_BY_COMPUTE_SHADER,
							GL_REFERENCED_BY_FRAGMENT_SHADER,
							GL_REFERENCED_BY_VERTEX_SHADER,
							GL_LOCATION };
		GLint expected2[] = { 6, 35666, 1, 0, 1, 0, 0 };
		VerifyGetProgramResourceiv(program, GL_PROGRAM_OUTPUT, 0, 7, props2, 7, expected2, error);

		glDeleteProgram(program);
		glDeleteProgram(program2);
		return error;
	}
};

class RelinkFailure : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Relink Failure Test";
	}

	virtual std::string PassCriteria()
	{
		return "INVALID_OPERATION is generated when asking for locations after failed link.";
	}

	virtual std::string Purpose()
	{
		return "Verify that queries behave correctly after failed relink of a program.";
	}

	virtual std::string Method()
	{
		return "Create a program, use it, relink with failure and then verify that INVALID_OPERATION is returned when "
			   "asking for locations.";
	}

	virtual std::string VertexShader()
	{
		return "#version 310 es                               \n"
			   "in mediump vec4 position;                     \n"
			   "in mediump vec3 pos;                          \n"
			   "void main(void)                               \n"
			   "{                                             \n"
			   "    gl_Position = position + vec4(pos, 1.);   \n"
			   "}";
	}

	virtual long Run()
	{
		GLuint program = CreateProgram(VertexShader().c_str(), FragmentShader().c_str(), false);
		glBindAttribLocation(program, 0, "position");
		glBindAttribLocation(program, 1, "pos");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "pos", 1, error);
		glUseProgram(program);

		tcu::Vec4 v[4] = { tcu::Vec4(-1, 1, 0, 1), tcu::Vec4(-1, -1, 0, 1), tcu::Vec4(1, 1, 0, 1),
						   tcu::Vec4(1, -1, 0, 1) };
		GLuint vao, vbuf;
		glGenVertexArrays(1, &vao);
		glBindVertexArray(vao);
		glGenBuffers(1, &vbuf);
		glBindBuffer(GL_ARRAY_BUFFER, vbuf);
		glBufferData(GL_ARRAY_BUFFER, sizeof(v), v, GL_STATIC_DRAW);
		glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), 0);
		glEnableVertexAttribArray(0);
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glDisableVertexAttribArray(0);
		glDeleteVertexArrays(1, &vao);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glDeleteBuffers(1, &vbuf);

		glBindAttribLocation(program, 0, "pos");
		glBindAttribLocation(program, 0, "position");
		const char* varyings[2] = { "q", "z" };
		glTransformFeedbackVaryings(program, 2, varyings, GL_INTERLEAVED_ATTRIBS);
		LinkProgram(program);

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", -1, error);
		ExpectError(GL_INVALID_OPERATION, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "pos", -1, error);
		ExpectError(GL_INVALID_OPERATION, error);
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", -1, error);
		ExpectError(GL_INVALID_OPERATION, error);

		glDeleteProgram(program);
		return error;
	}
};

class LinkFailure : public SimpleShaders
{

	virtual std::string Title()
	{
		return "Link Failure Test";
	}

	virtual std::string PassCriteria()
	{
		return "INVALID_OPERATION is generated when asking for locations after failed link.";
	}

	virtual std::string Purpose()
	{
		return "Verify that queries behave correctly after failed relink of a program with changed sources.";
	}

	virtual std::string Method()
	{
		return "Create a program, use it, relink with failure using different sources and then \n"
			   "verify that INVALID_OPERATION is returned when asking for locations.";
	}

	virtual const char* VertexShader_prop()
	{
		return "#version 310 es                      \n"
			   "in mediump vec4 posit;               \n"
			   "in mediump vec4 p;                   \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = p + posit;         \n"
			   "}";
	}

	virtual const char* FragmentShader_prop()
	{
		return "#version 310 es                    \n"
			   "out mediump vec4 color;            \n"
			   "void main() {                      \n"
			   "    color = vec4(0., 1., 0., 1.);  \n"
			   "}";
	}

	virtual const char* VertexShader_fail()
	{
		return "#version 310 es                      \n"
			   "in mediump vec4 position;            \n"
			   "void main(void)                      \n"
			   "{                                    \n"
			   "    gl_Position = position;          \n"
			   "}";
	}

	virtual long Run()
	{
		const GLuint program = glCreateProgram();
		const char*  src_vs  = VertexShader_prop();
		const char*  src_fs  = FragmentShader_prop();
		const char*  src_vsh = VertexShader_fail();

		GLuint sh1 = glCreateShader(GL_VERTEX_SHADER);
		glAttachShader(program, sh1);
		glDeleteShader(sh1);
		glShaderSource(sh1, 1, &src_vs, NULL);
		glCompileShader(sh1);

		GLuint sh2 = glCreateShader(GL_FRAGMENT_SHADER);
		glAttachShader(program, sh2);
		glDeleteShader(sh2);
		glShaderSource(sh2, 1, &src_fs, NULL);
		glCompileShader(sh2);

		glBindAttribLocation(program, 0, "p");
		glBindAttribLocation(program, 1, "posit");
		LinkProgram(program);

		long error = NO_ERROR;

		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "posit", 1, error);
		glUseProgram(program);

		tcu::Vec4 v[4] = { tcu::Vec4(-1, 1, 0, 1), tcu::Vec4(-1, -1, 0, 1), tcu::Vec4(1, 1, 0, 1),
						   tcu::Vec4(1, -1, 0, 1) };
		GLuint vao, vbuf;
		glGenVertexArrays(1, &vao);
		glBindVertexArray(vao);
		glGenBuffers(1, &vbuf);
		glBindBuffer(GL_ARRAY_BUFFER, vbuf);
		glBufferData(GL_ARRAY_BUFFER, sizeof(v), v, GL_STATIC_DRAW);
		glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(tcu::Vec4), 0);
		glEnableVertexAttribArray(0);
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		glDisableVertexAttribArray(0);
		glDeleteVertexArrays(1, &vao);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glDeleteBuffers(1, &vbuf);

		glDetachShader(program, sh1);
		GLuint vsh = glCreateShader(GL_VERTEX_SHADER);
		glAttachShader(program, vsh);
		glDeleteShader(vsh);
		glShaderSource(vsh, 1, &src_vsh, NULL);
		glCompileShader(vsh);
		const char* varyings[2] = { "q", "z" };
		glTransformFeedbackVaryings(program, 2, varyings, GL_INTERLEAVED_ATTRIBS);
		LinkProgram(program);

		GLint res;
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_INPUT, "position", -1, error);
		ExpectError(GL_INVALID_OPERATION, error);
		glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_ACTIVE_RESOURCES, &res);
		if (res != 0 && res != 1)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Error, expected 0 or 1 active resources, got: " << res
				<< tcu::TestLog::EndMessage;
			error = ERROR;
		}
		glGetProgramInterfaceiv(program, GL_PROGRAM_INPUT, GL_MAX_NAME_LENGTH, &res);
		if (res != 0 && res != 9)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Error, expected 1 or 9 GL_MAX_NAME_LENGTH, got: " << res
				<< tcu::TestLog::EndMessage;
			error = ERROR;
		}
		VerifyGetProgramResourceLocation(program, GL_PROGRAM_OUTPUT, "color", -1, error);
		ExpectError(GL_INVALID_OPERATION, error);

		glDeleteProgram(program);
		return error;
	}
};
}

ProgramInterfaceQueryTests::ProgramInterfaceQueryTests(glcts::Context& context)
	: TestCaseGroup(context, "program_interface_query", "")
{
}

ProgramInterfaceQueryTests::~ProgramInterfaceQueryTests(void)
{
}

void ProgramInterfaceQueryTests::init()
{
	using namespace glcts;
	addChild(new TestSubcase(m_context, "empty-shaders", TestSubcase::Create<NoShaders>));
	addChild(new TestSubcase(m_context, "simple-shaders", TestSubcase::Create<SimpleShaders>));
	addChild(new TestSubcase(m_context, "input-types", TestSubcase::Create<InputTypes>));
	addChild(new TestSubcase(m_context, "input-built-in", TestSubcase::Create<InputBuiltIn>));
	addChild(new TestSubcase(m_context, "input-layout", TestSubcase::Create<InputLayout>));
	addChild(new TestSubcase(m_context, "output-layout", TestSubcase::Create<OutputLayout>));
	addChild(new TestSubcase(m_context, "output-built-in", TestSubcase::Create<OutputBuiltIn>));
	addChild(new TestSubcase(m_context, "uniform-simple", TestSubcase::Create<UniformSimple>));
	addChild(new TestSubcase(m_context, "uniform-types", TestSubcase::Create<UniformTypes>));
	addChild(new TestSubcase(m_context, "uniform-block-types", TestSubcase::Create<UniformBlockTypes>));
	addChild(new TestSubcase(m_context, "transform-feedback-types", TestSubcase::Create<TransformFeedbackTypes>));
	addChild(new TestSubcase(m_context, "atomic-counters", TestSubcase::Create<AtomicCounterSimple>));
	addChild(
		new TestSubcase(m_context, "atomic-counters-one-buffer", TestSubcase::Create<AtomicCounterSimpleOneBuffer>));
	addChild(new TestSubcase(m_context, "ssb-types", TestSubcase::Create<ShaderStorageBlock>));
	addChild(new TestSubcase(m_context, "null-length", TestSubcase::Create<NullLength>));
	addChild(new TestSubcase(m_context, "arrays-of-arrays", TestSubcase::Create<ArraysOfArrays>));
	addChild(new TestSubcase(m_context, "top-level-array", TestSubcase::Create<TopLevelArray>));
	addChild(new TestSubcase(m_context, "separate-programs-vertex", TestSubcase::Create<SeparateProgramsVertex>));
	addChild(new TestSubcase(m_context, "separate-programs-fragment", TestSubcase::Create<SeparateProgramsFragment>));
	addChild(new TestSubcase(m_context, "uniform-block", TestSubcase::Create<UniformBlockAdvanced>));
	addChild(new TestSubcase(m_context, "array-names", TestSubcase::Create<ArrayNames>));
	addChild(new TestSubcase(m_context, "buff-length", TestSubcase::Create<BuffLength>));
	addChild(new TestSubcase(m_context, "no-locations", TestSubcase::Create<NoLocations>));
	addChild(new TestSubcase(m_context, "query-not-used", TestSubcase::Create<QueryNotUsed>));
	addChild(new TestSubcase(m_context, "relink-failure", TestSubcase::Create<RelinkFailure>));
	addChild(new TestSubcase(m_context, "link-failure", TestSubcase::Create<LinkFailure>));
	addChild(new TestSubcase(m_context, "compute-shader", TestSubcase::Create<ComputeShaderTest>));
	addChild(new TestSubcase(m_context, "invalid-value", TestSubcase::Create<InvalidValueTest>));
	addChild(new TestSubcase(m_context, "invalid-operation", TestSubcase::Create<InvalidOperationTest>));
	addChild(new TestSubcase(m_context, "invalid-enum", TestSubcase::Create<InvalidEnumTest>));
}
}