/*-------------------------------------------------------------------------
 * 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 "gl4cTextureGatherTests.hpp"
#include "glcTestSubcase.hpp"
#include "gluContextInfo.hpp"
#include "gluPixelTransfer.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
#include "tcuVector.hpp"
#include <cstdarg>
#include <math.h>
#include <string>
#include <vector>

namespace gl4cts
{

using namespace glw;
using tcu::Vec4;
using tcu::Vec3;
using tcu::Vec2;
using tcu::IVec4;
using tcu::UVec4;

namespace
{

class TGBase : public deqp::SubcaseBase
{
public:
	virtual ~TGBase()
	{
	}

	TGBase() : renderTarget(m_context.getRenderContext().getRenderTarget()), pixelFormat(renderTarget.getPixelFormat())
	{
		g_color_eps = Vec4(1.f / (float)(1 << pixelFormat.redBits), 1.f / (float)(1 << pixelFormat.greenBits),
						   1.f / (float)(1 << pixelFormat.blueBits), 1.f / (float)(1 << pixelFormat.alphaBits));
	}

	const tcu::RenderTarget& renderTarget;
	const tcu::PixelFormat&  pixelFormat;
	Vec4					 g_color_eps;

	int GetWindowWidth()
	{
		return renderTarget.getWidth();
	}

	int GetWindowHeight()
	{
		return renderTarget.getHeight();
	}

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

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

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

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

	GLuint CreateProgram(const char* src_vs, const char* src_tcs, const char* src_tes, const char* src_gs,
						 const char* src_fs)
	{
		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_tcs)
		{
			GLuint sh = glCreateShader(GL_TESS_CONTROL_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			glShaderSource(sh, 1, &src_tcs, NULL);
			glCompileShader(sh);
		}
		if (src_tes)
		{
			GLuint sh = glCreateShader(GL_TESS_EVALUATION_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			glShaderSource(sh, 1, &src_tes, NULL);
			glCompileShader(sh);
		}
		if (src_gs)
		{
			GLuint sh = glCreateShader(GL_GEOMETRY_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			glShaderSource(sh, 1, &src_gs, 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);
		}
		return p;
	}

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

		if (!cs.empty())
		{
			const GLuint sh = glCreateShader(GL_COMPUTE_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			const char* const src[1] = { cs.c_str() };
			glShaderSource(sh, 1, 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;

					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;
					}

					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;
					}
				}
			}

			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;
	}

	GLfloat distance(GLfloat p0, GLfloat p1)
	{
		return de::abs(p0 - p1);
	}

	inline bool ColorEqual(const Vec4& c0, const Vec4& c1, const Vec4& epsilon)
	{
		if (distance(c0.x(), c1.x()) > epsilon.x())
			return false;
		if (distance(c0.y(), c1.y()) > epsilon.y())
			return false;
		if (distance(c0.z(), c1.z()) > epsilon.z())
			return false;
		if (distance(c0.w(), c1.w()) > epsilon.w())
			return false;
		return true;
	}

	virtual long Setup()
	{
		return NO_ERROR;
	}

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

class GatherEnumsTest : public TGBase
{
	virtual std::string Title()
	{
		return "Basic Enum Test";
	}

	virtual std::string Purpose()
	{
		return "Verify that gather related enums are correct.";
	}

	virtual std::string Method()
	{
		return "Query GL_*_TEXTURE_GATHER_OFFSET enums.";
	}

	virtual std::string PassCriteria()
	{
		return "Values of enums meet GL spec requirements.";
	}

	virtual long Run()
	{
		GLint res;
		glGetIntegerv(GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET, &res);
		if (res > -8)
		{
			return ERROR;
		}
		glGetIntegerv(GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET, &res);
		if (res < 7)
		{
			return ERROR;
		}
		return NO_ERROR;
	}
};

class GatherGLSLCompile : public TGBase
{
	GLuint program;

	virtual std::string Title()
	{
		return "GLSL Compile Test";
	}

	virtual std::string Purpose()
	{
		return "Verify that gather functions are visible in the shaders.";
	}

	virtual std::string Method()
	{
		return "Create shaders which use all types of gather functions.";
	}

	virtual std::string PassCriteria()
	{
		return "Programs compile and link successfuly.";
	}

	virtual std::string Uniforms()
	{
		return "uniform sampler2D tex_2d;                  \n"
			   "uniform isamplerCube itex_cube;            \n"
			   "uniform usampler2DArray utex_2da;          \n"
			   "uniform isampler2DRect itex_2dr;           \n"
			   ""
			   "uniform sampler2DRectShadow tex_2drs;      \n"
			   "uniform sampler2DShadow tex_2ds;           \n"
			   "uniform samplerCubeShadow tex_cubes;       \n"
			   "uniform sampler2DArrayShadow tex_2das;     \n";
	}

	virtual std::string Sampling()
	{
		return "    textureGather(tex_2d,vec2(1));          \n"
			   "    textureGather(itex_cube,vec3(1));       \n"
			   "    textureGather(utex_2da,vec3(1));        \n"
			   "    textureGather(itex_2dr,vec2(1));        \n"
			   ""
			   "    textureGather(tex_2drs,vec2(1), 0.5);   \n"
			   "    textureGather(tex_2ds,vec2(1), 0.5);    \n"
			   "    textureGather(tex_cubes,vec3(1), 0.5);  \n"
			   "    textureGather(tex_2das,vec3(1), 0.5);   \n"
			   ""
			   "    textureGatherOffset(tex_2d,vec2(1), ivec2(0));          \n"
			   "    textureGatherOffset(utex_2da,vec3(1), ivec2(0));        \n"
			   "    textureGatherOffset(itex_2dr,vec2(1), ivec2(0));        \n"
			   ""
			   "    textureGatherOffset(tex_2drs,vec2(1), 0.5, ivec2(0));   \n"
			   "    textureGatherOffset(tex_2ds,vec2(1), 0.5, ivec2(0));    \n"
			   "    textureGatherOffset(tex_2das,vec3(1), 0.5, ivec2(0));   \n"
			   ""
			   "    const ivec2 offsets[4] = ivec2[](ivec2(0), ivec2(0), ivec2(0), ivec2(0)); \n"
			   "    textureGatherOffsets(tex_2d,vec2(1), offsets);          \n"
			   "    textureGatherOffsets(utex_2da,vec3(1), offsets);        \n"
			   "    textureGatherOffsets(itex_2dr,vec2(1), offsets);        \n"
			   ""
			   "    textureGatherOffsets(tex_2drs,vec2(1), 0.5, offsets);   \n"
			   "    textureGatherOffsets(tex_2ds,vec2(1), 0.5, offsets);    \n"
			   "    textureGatherOffsets(tex_2das,vec3(1), 0.5, offsets);   \n";
	}

	virtual std::string VertexShader()
	{
		return "#version 400                               \n" + Uniforms() +
			   "  void main() {                            \n" + Sampling() +
			   "    gl_Position = vec4(1);                 \n"
			   "  }                                        \n";
	}

	virtual std::string FragmentShader()
	{
		return "#version 400                               \n"
			   "out vec4 color;                            \n" +
			   Uniforms() + "  void main() {                            \n" + Sampling() +
			   "    color = vec4(1);                       \n"
			   "  }                                        \n";
	}

	virtual long Run()
	{
		program = CreateProgram(VertexShader().c_str(), NULL, NULL, NULL, FragmentShader().c_str());
		glLinkProgram(program);
		if (!CheckProgram(program))
			return ERROR;
		return NO_ERROR;
	}

	virtual long Cleanup()
	{
		glDeleteProgram(program);
		return NO_ERROR;
	}
};

class GatherBase : public TGBase
{
public:
	GLuint tex, fbo, rbo, program, vao, vbo;

	virtual GLvoid CreateTexture2DRgb(bool base_level = false)
	{
		GLenum		internal_format = GL_RGB32F;
		GLenum		format			= GL_RGB;
		const GLint csize			= base_level ? 64 : 32;
		GLint		size			= csize;
		GLenum		target			= GL_TEXTURE_2D;
		GLenum		tex_type		= GL_FLOAT;

		glGenTextures(1, &tex);
		glBindTexture(target, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage2D(target, i, internal_format, size, size, 0, format, tex_type, 0);
		}
		std::vector<Vec3> pixels(csize * csize, Vec3(1.0));
		glTexSubImage2D(target, 0, 0, 0, csize, csize, format, tex_type, &pixels[0]);
		glGenerateMipmap(target);

		Vec3 data[4] = { Vec3(12. / 16, 13. / 16, 14. / 16), Vec3(8. / 16, 9. / 16, 10. / 16),
						 Vec3(0. / 16, 1. / 16, 2. / 16), Vec3(4. / 16, 5. / 16, 6. / 16) };

		glTexSubImage2D(target, base_level, 22, 25, 2, 2, format, tex_type, data);
		glTexSubImage2D(target, base_level, 16, 10, 1, 1, format, tex_type, data + 0);
		glTexSubImage2D(target, base_level, 11, 2, 1, 1, format, tex_type, data + 1);
		glTexSubImage2D(target, base_level, 24, 13, 1, 1, format, tex_type, data + 2);
		glTexSubImage2D(target, base_level, 9, 14, 1, 1, format, tex_type, data + 3);

		glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	}

	virtual GLvoid CreateTexture2DRg(bool base_level = false)
	{
		GLenum		internal_format = GL_RG32F;
		GLenum		format			= GL_RG;
		const GLint csize			= base_level ? 64 : 32;
		GLint		size			= csize;
		GLenum		target			= GL_TEXTURE_2D;
		GLenum		tex_type		= GL_FLOAT;

		glGenTextures(1, &tex);
		glBindTexture(target, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage2D(target, i, internal_format, size, size, 0, format, tex_type, 0);
		}
		std::vector<Vec2> pixels(csize * csize, Vec2(1.0));
		glTexSubImage2D(target, 0, 0, 0, csize, csize, format, tex_type, &pixels[0]);
		glGenerateMipmap(target);

		Vec2 data[4] = { Vec2(12. / 16, 13. / 16), Vec2(8. / 16, 9. / 16), Vec2(0. / 16, 1. / 16),
						 Vec2(4. / 16, 5. / 16) };

		glTexSubImage2D(target, base_level, 22, 25, 2, 2, format, tex_type, data);
		glTexSubImage2D(target, base_level, 16, 10, 1, 1, format, tex_type, data + 0);
		glTexSubImage2D(target, base_level, 11, 2, 1, 1, format, tex_type, data + 1);
		glTexSubImage2D(target, base_level, 24, 13, 1, 1, format, tex_type, data + 2);
		glTexSubImage2D(target, base_level, 9, 14, 1, 1, format, tex_type, data + 3);

		glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	}

	virtual GLvoid CreateTexture2DR(bool base_level = false)
	{
		GLenum		internal_format = GL_R32F;
		GLenum		format			= GL_RED;
		const GLint csize			= base_level ? 64 : 32;
		GLint		size			= csize;
		GLenum		target			= GL_TEXTURE_2D;
		GLenum		tex_type		= GL_FLOAT;

		glGenTextures(1, &tex);
		glBindTexture(target, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage2D(target, i, internal_format, size, size, 0, format, tex_type, 0);
		}
		std::vector<GLfloat> pixels(csize * csize, 1.0);
		glTexSubImage2D(target, 0, 0, 0, csize, csize, format, tex_type, &pixels[0]);
		glGenerateMipmap(target);

		GLfloat data[4] = { 12. / 16., 8. / 16., 0. / 16., 4. / 16. };

		glTexSubImage2D(target, base_level, 22, 25, 2, 2, format, tex_type, data);
		glTexSubImage2D(target, base_level, 16, 10, 1, 1, format, tex_type, data + 0);
		glTexSubImage2D(target, base_level, 11, 2, 1, 1, format, tex_type, data + 1);
		glTexSubImage2D(target, base_level, 24, 13, 1, 1, format, tex_type, data + 2);
		glTexSubImage2D(target, base_level, 9, 14, 1, 1, format, tex_type, data + 3);

		glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	}

	virtual GLvoid CreateTexture2DInt(bool rect = false)
	{
		GLenum		internal_format = InternalFormat();
		const GLint csize			= 32;
		GLint		size			= csize;
		GLenum		target			= rect ? GL_TEXTURE_RECTANGLE : GL_TEXTURE_2D;

		glGenTextures(1, &tex);
		glBindTexture(target, tex);
		if (!rect)
		{
			for (int i = 0; size > 0; ++i, size /= 2)
			{
				glTexImage2D(target, i, internal_format, size, size, 0, GL_RGBA_INTEGER, GL_INT, 0);
			}
		}
		else
		{
			glTexImage2D(target, 0, internal_format, size, size, 0, GL_RGBA_INTEGER, GL_INT, 0);
		}
		std::vector<IVec4> pixels(csize * csize, IVec4(999));
		glTexSubImage2D(target, 0, 0, 0, csize, csize, GL_RGBA_INTEGER, GL_INT, &pixels[0]);

		IVec4 data[4] = { IVec4(12, 13, 14, 15), IVec4(8, 9, 10, 11), IVec4(0, 1, 2, 3), IVec4(4, 5, 6, 7) };

		glTexSubImage2D(target, 0, 22, 25, 2, 2, GL_RGBA_INTEGER, GL_INT, data);
		glTexSubImage2D(target, 0, 16, 10, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 0);
		glTexSubImage2D(target, 0, 11, 2, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 1);
		glTexSubImage2D(target, 0, 24, 13, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 2);
		glTexSubImage2D(target, 0, 9, 14, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 3);

		glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}

	virtual GLvoid CreateTexture2DArrayInt(int slices, int data_slice)
	{
		GLenum		internal_format = InternalFormat();
		const GLint csize			= 32;
		GLint		size			= csize;

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage3D(GL_TEXTURE_2D_ARRAY, i, internal_format, size, size, slices, 0, GL_RGBA_INTEGER, GL_INT, 0);
		}
		std::vector<IVec4> pixels(csize * csize, IVec4(999));
		for (int i = 0; i < slices; ++i)
		{
			glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, i, csize, csize, 1, GL_RGBA_INTEGER, GL_INT, &pixels[0]);
		}

		IVec4 data[4] = { IVec4(12, 13, 14, 15), IVec4(8, 9, 10, 11), IVec4(0, 1, 2, 3), IVec4(4, 5, 6, 7) };

		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 22, 25, data_slice, 2, 2, 1, GL_RGBA_INTEGER, GL_INT, data);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 16, 10, data_slice, 1, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 0);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 11, 2, data_slice, 1, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 1);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 24, 13, data_slice, 1, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 2);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 9, 14, data_slice, 1, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 3);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}

	virtual GLvoid CreateTextureCubeArray(int slices, int data_slice)
	{
		GLenum		internal_format = InternalFormat();
		GLenum		format			= Format();
		const GLint csize			= 32;
		GLint		size			= csize;

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, i, internal_format, size, size, 6 * slices, 0, format, GL_FLOAT, 0);
		}
		std::vector<Vec4> pixels(csize * csize, Vec4(1.0));
		for (int j = 0; j < 6 * slices; ++j)
		{
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, j, csize, csize, 1, format, GL_FLOAT, &pixels[0]);
		}

		if (format != GL_DEPTH_COMPONENT)
		{
			glGenerateMipmap(GL_TEXTURE_CUBE_MAP_ARRAY);
		}

		Vec4 data[4] = { Vec4(12. / 16, 13. / 16, 14. / 16, 15. / 16), Vec4(8. / 16, 9. / 16, 10. / 16, 11. / 16),
						 Vec4(0. / 16, 1. / 16, 2. / 16, 3. / 16), Vec4(4. / 16, 5. / 16, 6. / 16, 7. / 16) };

		Vec4  depthData(data[0][0], data[1][0], data[2][0], data[3][0]);
		Vec4* packedData = (format == GL_DEPTH_COMPONENT) ? &depthData : data;

		for (int i = 0; i < 6; ++i)
		{
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 22, 25, (6 * data_slice) + i, 2, 2, 1, format, GL_FLOAT,
							packedData);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 16, 10, (6 * data_slice) + i, 1, 1, 1, format, GL_FLOAT,
							data + 0);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 11, 2, (6 * data_slice) + i, 1, 1, 1, format, GL_FLOAT,
							data + 1);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 24, 13, (6 * data_slice) + i, 1, 1, 1, format, GL_FLOAT,
							data + 2);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 9, 14, (6 * data_slice) + i, 1, 1, 1, format, GL_FLOAT,
							data + 3);
		}

		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	}

	virtual GLvoid CreateTextureCubeArrayInt(int slices, int data_slice)
	{
		GLenum		internal_format = InternalFormat();
		GLenum		format			= GL_RGBA_INTEGER;
		const GLint csize			= 32;
		GLint		size			= csize;

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, i, internal_format, size, size, 6 * slices, 0, format, GL_INT, 0);
		}
		std::vector<IVec4> pixels(csize * csize, IVec4(999));
		for (int j = 0; j < 6 * slices; ++j)
		{
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 0, 0, j, csize, csize, 1, format, GL_INT, &pixels[0]);
		}

		IVec4 data[4] = { IVec4(12, 13, 14, 15), IVec4(8, 9, 10, 11), IVec4(0, 1, 2, 3), IVec4(4, 5, 6, 7) };

		for (int i = 0; i < 6; ++i)
		{
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 22, 25, (6 * data_slice) + i, 2, 2, 1, format, GL_INT, data);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 9, 14, (6 * data_slice) + i, 1, 1, 1, format, GL_INT,
							data + 3);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 16, 10, (6 * data_slice) + i, 1, 1, 1, format, GL_INT,
							data + 0);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 11, 2, (6 * data_slice) + i, 1, 1, 1, format, GL_INT,
							data + 1);
			glTexSubImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, 24, 13, (6 * data_slice) + i, 1, 1, 1, format, GL_INT,
							data + 2);
		}

		glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}

	virtual GLvoid CreateTexture2DArray(int slices, int data_slice)
	{
		GLenum		internal_format = InternalFormat();
		GLenum		format			= Format();
		const GLint csize			= 32;
		GLint		size			= csize;

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			glTexImage3D(GL_TEXTURE_2D_ARRAY, i, internal_format, size, size, slices, 0, format, GL_FLOAT, 0);
		}
		std::vector<Vec4> pixels(csize * csize, Vec4(1.0));
		for (int i = 0; i < slices; ++i)
		{
			glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, i, csize, csize, 1, format, GL_FLOAT, &pixels[0]);
		}

		if (format != GL_DEPTH_COMPONENT)
		{
			glGenerateMipmap(GL_TEXTURE_2D_ARRAY);
		}

		Vec4 data[4] = { Vec4(12. / 16, 13. / 16, 14. / 16, 15. / 16), Vec4(8. / 16, 9. / 16, 10. / 16, 11. / 16),
						 Vec4(0. / 16, 1. / 16, 2. / 16, 3. / 16), Vec4(4. / 16, 5. / 16, 6. / 16, 7. / 16) };

		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 22, 25, data_slice, 2, 2, 1, format, GL_FLOAT, data);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 16, 10, data_slice, 1, 1, 1, format, GL_FLOAT, data + 0);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 11, 2, data_slice, 1, 1, 1, format, GL_FLOAT, data + 1);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 24, 13, data_slice, 1, 1, 1, format, GL_FLOAT, data + 2);
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 9, 14, data_slice, 1, 1, 1, format, GL_FLOAT, data + 3);

		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	}

	virtual GLvoid CreateTextureCubeInt()
	{
		GLenum		internal_format = InternalFormat();
		const GLint csize			= 32;
		GLint		size			= csize;

		const GLenum faces[6] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
								  GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
								  GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			for (int j = 0; j < 6; ++j)
			{
				glTexImage2D(faces[j], i, internal_format, size, size, 0, GL_RGBA_INTEGER, GL_INT, 0);
			}
		}
		std::vector<IVec4> pixels(csize * csize, IVec4(999));
		for (int j = 0; j < 6; ++j)
		{
			glTexSubImage2D(faces[j], 0, 0, 0, csize, csize, GL_RGBA_INTEGER, GL_INT, &pixels[0]);
		}

		IVec4 data[4] = { IVec4(12, 13, 14, 15), IVec4(8, 9, 10, 11), IVec4(0, 1, 2, 3), IVec4(4, 5, 6, 7) };

		for (int j = 0; j < 6; ++j)
		{
			glTexSubImage2D(faces[j], 0, 22, 25, 2, 2, GL_RGBA_INTEGER, GL_INT, data);
			glTexSubImage2D(faces[j], 0, 16, 10, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 0);
			glTexSubImage2D(faces[j], 0, 11, 2, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 1);
			glTexSubImage2D(faces[j], 0, 24, 13, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 2);
			glTexSubImage2D(faces[j], 0, 9, 14, 1, 1, GL_RGBA_INTEGER, GL_INT, data + 3);
		}

		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	}

	virtual GLvoid CreateTextureCube()
	{
		GLenum		internal_format = InternalFormat();
		GLenum		format			= Format();
		const GLint csize			= 32;
		GLint		size			= csize;

		const GLenum faces[6] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
								  GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
								  GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
		for (int i = 0; size > 0; ++i, size /= 2)
		{
			for (int j = 0; j < 6; ++j)
			{
				glTexImage2D(faces[j], i, internal_format, size, size, 0, format, GL_FLOAT, 0);
			}
		}
		std::vector<Vec4> pixels(csize * csize, Vec4(1.0));
		for (int j = 0; j < 6; ++j)
		{
			glTexSubImage2D(faces[j], 0, 0, 0, csize, csize, format, GL_FLOAT, &pixels[0]);
		}

		if (format != GL_DEPTH_COMPONENT)
		{
			glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
		}

		Vec4 data[4] = { Vec4(12. / 16, 13. / 16, 14. / 16, 15. / 16), Vec4(8. / 16, 9. / 16, 10. / 16, 11. / 16),
						 Vec4(0. / 16, 1. / 16, 2. / 16, 3. / 16), Vec4(4. / 16, 5. / 16, 6. / 16, 7. / 16) };

		Vec4  depthData(data[0][0], data[1][0], data[2][0], data[3][0]);
		Vec4* packedData = (format == GL_DEPTH_COMPONENT) ? &depthData : data;

		for (int j = 0; j < 6; ++j)
		{
			glTexSubImage2D(faces[j], 0, 22, 25, 2, 2, format, GL_FLOAT, packedData);
			glTexSubImage2D(faces[j], 0, 16, 10, 1, 1, format, GL_FLOAT, data + 0);
			glTexSubImage2D(faces[j], 0, 11, 2, 1, 1, format, GL_FLOAT, data + 1);
			glTexSubImage2D(faces[j], 0, 24, 13, 1, 1, format, GL_FLOAT, data + 2);
			glTexSubImage2D(faces[j], 0, 9, 14, 1, 1, format, GL_FLOAT, data + 3);
		}

		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	}

	virtual GLvoid CreateTexture2D(bool rect = false, bool base_level = false)
	{
		GLenum		internal_format = InternalFormat();
		GLenum		format			= Format();
		const GLint csize			= base_level ? 64 : 32;
		GLint		size			= csize;
		GLenum		target			= rect ? GL_TEXTURE_RECTANGLE : GL_TEXTURE_2D;

		glGenTextures(1, &tex);
		glBindTexture(target, tex);
		if (!rect)
		{
			for (int i = 0; size > 0; ++i, size /= 2)
			{
				glTexImage2D(target, i, internal_format, size, size, 0, format, GL_FLOAT, 0);
			}
		}
		else
		{
			glTexImage2D(target, 0, internal_format, size, size, 0, format, GL_FLOAT, 0);
		}
		std::vector<Vec4> pixels(csize * csize, Vec4(1.0));
		glTexSubImage2D(target, 0, 0, 0, csize, csize, format, GL_FLOAT, &pixels[0]);

		if (!rect && format != GL_DEPTH_COMPONENT)
		{
			glGenerateMipmap(target);
		}

		Vec4 data[4] = { Vec4(12. / 16, 13. / 16, 14. / 16, 15. / 16), Vec4(8. / 16, 9. / 16, 10. / 16, 11. / 16),
						 Vec4(0. / 16, 1. / 16, 2. / 16, 3. / 16), Vec4(4. / 16, 5. / 16, 6. / 16, 7. / 16) };

		glTexSubImage2D(target, base_level, 22, 25, 2, 2, format, GL_FLOAT, data);
		glTexSubImage2D(target, base_level, 16, 10, 1, 1, format, GL_FLOAT, data + 0);
		glTexSubImage2D(target, base_level, 11, 2, 1, 1, format, GL_FLOAT, data + 1);
		glTexSubImage2D(target, base_level, 24, 13, 1, 1, format, GL_FLOAT, data + 2);
		glTexSubImage2D(target, base_level, 9, 14, 1, 1, format, GL_FLOAT, data + 3);

		glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

		if (base_level)
			glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 1);
	}

	virtual std::string FallthroughVertexShader()
	{
		return "#version 400                     \n"
			   "in vec4 v_in_0;                  \n"
			   "flat out vec4 v_out_0;           \n"
			   "void main() {                    \n"
			   "    gl_Position = vec4(0,0,0,1);                \n"
			   "    v_out_0 = v_in_0;                           \n"
			   "}";
	}

	virtual std::string FallthroughFragmentShader()
	{
		return "#version 400                     \n"
			   "out " +
			   Type() + " f_out_0;                \n"
						"flat in " +
			   Type() + " v_out_0;            \n"
						"void main() {                    \n"
						"    f_out_0 = v_out_0;           \n"
						"}";
	}

	virtual std::string TestFunction()
	{
		return Sampler() + TextBody();
	}

	virtual std::string Type()
	{
		return "vec4";
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2D my_sampler;                      \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                       \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y));           \n"
						"}\n";
	}

	virtual std::string VertexShader()
	{
		return "#version 400                                       \n"
			   "#extension GL_ARB_texture_cube_map_array : enable  \n"
			   ""
			   "in vec4 v_in_0;                                    \n"
			   "flat out " +
			   Type() + " v_out_0;                   \n" + TestFunction() +
			   "void main() {                                      \n"
			   "    gl_Position = vec4(0,0,0,1);                   \n"
			   "    v_out_0 = test_function(v_in_0);               \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 400                                       \n"
			   "#extension GL_ARB_texture_cube_map_array : enable  \n"
			   ""
			   "flat in vec4 v_out_0;                              \n"
			   "out " +
			   Type() + " f_out_0;                        \n" + TestFunction() +
			   "void main() {                                      \n"
			   "    f_out_0 = test_function(v_out_0);              \n"
			   "}";
	}

	virtual std::string ComputeShader()
	{
		return "#version 400 core                                           \n"
			   "#extension GL_ARB_shader_storage_buffer_object : require    \n"
			   "#extension GL_ARB_compute_shader : require            \n"
			   "#extension GL_ARB_texture_cube_map_array : enable     \n"
			   "layout(local_size_x = 1, local_size_y = 1) in;        \n"
			   "layout(std430) buffer Output {                        \n"
			   "  " +
			   Type() + " data;                                \n"
						"} g_out;                                              \n"
						"uniform vec4 cs_in;                                   \n" +
			   TestFunction() + "void main() {                                         \n"
								"  g_out.data = test_function(cs_in);                  \n"
								"}                                                     \n";
	}

	virtual void Init()
	{
		CreateTexture2D();
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32F, 1, 1);
	}

	virtual long Verify()
	{
		Vec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, &data);
		if (!ColorEqual(data, Expected(), g_color_eps))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << ", epsilon: " << g_color_eps.x() << ", " << g_color_eps.y() << ", "
				<< g_color_eps.z() << ", " << g_color_eps.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual Vec4 Expected()
	{
		return Vec4(0. / 16, 4. / 16, 8. / 16, 12. / 16);
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32F;
	}

	virtual GLenum Format()
	{
		return GL_RGBA;
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23. / 32, 26. / 32, 5, 3);
	}

	virtual bool Supported()
	{
		return true;
	}

	virtual long Run()
	{

		if (!Supported())
			return NO_ERROR;
		Init();

		glGenFramebuffers(1, &fbo);
		glGenRenderbuffers(1, &rbo);
		glBindRenderbuffer(GL_RENDERBUFFER, rbo);
		SetRbo();
		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
		GLenum drawBuffer = GL_COLOR_ATTACHMENT0;
		glDrawBuffers(1, &drawBuffer);
		GLfloat colorf[4] = { 0, 0, 0, 0 };
		glClearBufferfv(GL_COLOR, 0, colorf);
		glViewport(0, 0, 1, 1);

		glGenVertexArrays(1, &vao);
		glBindVertexArray(vao);
		glGenBuffers(1, &vbo);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glVertexAttribPointer(0, 4, GL_FLOAT, false, 0, 0);
		glEnableVertexAttribArray(0);
		Vec4 buffData = BufferData();
		glBufferData(GL_ARRAY_BUFFER, 16, &buffData, GL_STATIC_DRAW);

		for (int i = 0; i < 2; ++i)
		{
			if (i == 0)
				program = CreateProgram(VertexShader().c_str(), NULL, NULL, NULL, FallthroughFragmentShader().c_str());
			else
				program = CreateProgram(FallthroughVertexShader().c_str(), NULL, NULL, NULL, FragmentShader().c_str());
			glBindAttribLocation(program, 0, "v_in_0");
			glBindFragDataLocation(program, 0, "f_out_0");
			glLinkProgram(program);
			if (!CheckProgram(program))
				return ERROR;
			glUseProgram(program);

			glDrawArrays(GL_POINTS, 0, 1);
			glReadBuffer(GL_COLOR_ATTACHMENT0);

			glDeleteProgram(program);

			if (Verify() == ERROR)
				return ERROR;
		}

		if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_compute_shader") ||
			!m_context.getContextInfo().isExtensionSupported("GL_ARB_compute_shader"))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected "
				<< "GL_ARB_compute_shader or GL_ARB_compute_shader not supported, skipping compute stage"
				<< tcu::TestLog::EndMessage;
			return NO_ERROR;
		}
		else
		{
			return TestCompute();
		}
	}

	virtual long TestCompute()
	{
		GLuint m_buffer;

		program = CreateComputeProgram(ComputeShader());
		glLinkProgram(program);
		if (!CheckProgram(program))
			return ERROR;
		glUseProgram(program);

		glUniform4f(glGetUniformLocation(program, "cs_in"), BufferData().x(), BufferData().y(), BufferData().z(),
					BufferData().w());

		glGenBuffers(1, &m_buffer);
		glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, m_buffer);
		glBufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Vec4), NULL, GL_DYNAMIC_DRAW);
		glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);

		glDispatchCompute(1, 1, 1);

		glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_buffer);
		glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);
		long error = VerifyCompute();
		glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
		glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
		glDeleteBuffers(1, &m_buffer);

		return error;
	}

	virtual long VerifyCompute()
	{
		Vec4* data;
		data = static_cast<Vec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(Vec4), GL_MAP_READ_BIT));
		if (!ColorEqual(data[0], Expected(), g_color_eps))
		{ // for unorms
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << " got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long Cleanup()
	{
		glViewport(0, 0, GetWindowWidth(), GetWindowHeight());
		glDisableVertexAttribArray(0);
		glDeleteTextures(1, &tex);
		glDeleteVertexArrays(1, &vao);
		glDeleteBuffers(1, &vbo);
		glDeleteRenderbuffers(1, &rbo);
		glDeleteFramebuffers(1, &fbo);
		glDeleteProgram(program);
		return NO_ERROR;
	}
};

class PlainGatherFloat2DRgba : public GatherBase
{
};

class PlainGatherFloat2DRg : public GatherBase
{
public:
	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4 test_function(vec4 p) {                                    \n"
			   "    return textureGather(my_sampler, vec2(p.x, p.y), 1);        \n"
			   "}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(1. / 16, 5. / 16, 9. / 16, 13. / 16);
	}

	virtual GLenum InternalFormat()
	{
		return GL_RG32F;
	}
};

class PlainGatherUnorm2D : public GatherBase
{
public:
	virtual GLenum InternalFormat()
	{
		return GL_RGBA16;
	}

	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4 test_function(vec4 p) {                                    \n"
			   "    return textureGather(my_sampler, vec2(p.x, p.y), 0);        \n"
			   "}\n";
	}
};

class PlainGatherInt2DRgba : public GatherBase
{
public:
	virtual GLenum InternalFormat()
	{
		return GL_RGBA32I;
	}

	virtual void Init()
	{
		CreateTexture2DInt();
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32I, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Sampler()
	{
		return "uniform isampler2D my_sampler;                     \n";
	}

	virtual std::string Type()
	{
		return "ivec4";
	}
};

class PlainGatherInt2DRg : public PlainGatherInt2DRgba
{
public:
	virtual GLenum InternalFormat()
	{
		return GL_RG32I;
	}
};

class PlainGatherUint2D : public GatherBase
{
public:
	virtual GLenum InternalFormat()
	{
		return GL_RGBA32UI;
	}

	virtual void Init()
	{
		CreateTexture2DInt();
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32UI, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data);
		if (data != IVec4(2, 6, 10, 14))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 2, 6, 10, 14, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(2, 6, 10, 14))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Sampler()
	{
		return "uniform usampler2D my_sampler;                     \n";
	}

	virtual Vec4 BufferData()
	{
		return Vec4(22.9f / 32, 25.9f / 32, 2, 2);
	}

	virtual std::string Type()
	{
		return "uvec4";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                   \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y), 2);            \n"
						"}\n";
	}
};

class PlainGatherDepth2D : public GatherBase
{
public:
	virtual GLenum InternalFormat()
	{
		return GL_DEPTH_COMPONENT32F;
	}

	virtual GLenum Format()
	{
		return GL_DEPTH_COMPONENT;
	}

	virtual void Init()
	{
		CreateTexture2D();
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual Vec4 Expected()
	{
		return Vec4(1, 1, 0, 0);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23. / 32, 26. / 32, 13.5 / 16, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DShadow my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y), p.z);       \n"
						"}\n";
	}
};

class PlainGatherFloat2DArray : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DArray(9, 5);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z));       \n"
						"}\n";
	}
};

class PlainGatherUnorm2DArray : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DArray(7, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.w));       \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA16;
	}
};

class PlainGatherInt2DArray : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DArrayInt(20, 11);
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32I;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32I, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(3, 7, 11, 15))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 3, 7, 11, 15, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(3, 7, 11, 15))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "ivec4";
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23. / 32, 26. / 32, 11, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform isampler2DArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z), 3);    \n"
						"}\n";
	}
};

class PlainGatherUint2DArray : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DArrayInt(3, 1);
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32UI;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32UI, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data);
		if (data != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "uvec4";
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23. / 32, 26. / 32, 1, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform usampler2DArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z));       \n"
						"}\n";
	}
};

class PlainGatherDepth2DArray : public GatherBase
{
public:
	virtual GLenum InternalFormat()
	{
		return GL_DEPTH_COMPONENT32F;
	}

	virtual GLenum Format()
	{
		return GL_DEPTH_COMPONENT;
	}

	virtual void Init()
	{
		CreateTexture2DArray(9, 5);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual Vec4 Expected()
	{
		return Vec4(1, 1, 0, 0);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23. / 32, 26. / 32, 5, 13.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DArrayShadow my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z), p.w);       \n"
						"}\n";
	}
};

class PlainGatherFloatCubeRgba : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCube();
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCube my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z));       \n"
						"}\n";
	}
};

class PlainGatherFloatCubeRg : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCube();
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCube my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z), 1);    \n"
						"}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(1. / 16, 5. / 16, 9. / 16, 13. / 16);
	}

	virtual GLenum InternalFormat()
	{
		return GL_RG32F;
	}
};

class PlainGatherUnormCube : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCube();
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCube my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z));       \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA16;
	}
};

class PlainGatherIntCubeRgba : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCubeInt();
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform isamplerCube my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z));       \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32I;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32I, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "ivec4";
	}
};

class PlainGatherIntCubeRg : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCubeInt();
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform isamplerCube my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z), 1);    \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RG32I;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32I, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(1, 5, 9, 13))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 1, 5, 9, 13, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(1, 5, 9, 13))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "ivec4";
	}
};

class PlainGatherUintCube : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCubeInt();
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform usamplerCube my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z), 0);    \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32UI;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32UI, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "uvec4";
	}
};

class PlainGatherDepthCube : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTextureCube();
		glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual GLenum InternalFormat()
	{
		return GL_DEPTH_COMPONENT32F;
	}

	virtual GLenum Format()
	{
		return GL_DEPTH_COMPONENT;
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 7.5 / 16);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCubeShadow my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                \n"
						"    return textureGather(my_sampler, vec3(p.x, p.y, p.z), p.w);  \n"
						"}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(0, 0, 1, 1);
	}
};

class PlainGatherFloatCubeArray : public GatherBase
{
public:
	virtual bool Supported()
	{
		if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_cube_map_array"))
		{
			OutputNotSupported("GL_ARB_texture_cube_map_array not supported");
			return false;
		}
		return true;
	}

	virtual void Init()
	{
		CreateTextureCubeArray(9, 5);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 5);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCubeArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {              \n"
						"    return textureGather(my_sampler, p);       \n"
						"}\n";
	}
};

class PlainGatherUnormCubeArray : public GatherBase
{
public:
	virtual bool Supported()
	{
		if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_cube_map_array"))
		{
			OutputNotSupported("GL_ARB_texture_cube_map_array not supported");
			return false;
		}
		return true;
	}

	virtual void Init()
	{
		CreateTextureCubeArray(7, 3);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCubeArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {              \n"
						"    return textureGather(my_sampler, p);       \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA16;
	}
};

class PlainGatherIntCubeArray : public GatherBase
{
public:
	virtual bool Supported()
	{
		if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_cube_map_array"))
		{
			OutputNotSupported("GL_ARB_texture_cube_map_array not supported");
			return false;
		}
		return true;
	}

	virtual void Init()
	{
		CreateTextureCubeArrayInt(20, 11);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 11);
	}

	virtual std::string Sampler()
	{
		return "uniform isamplerCubeArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {              \n"
						"    return textureGather(my_sampler, p);       \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32I;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32I, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "ivec4";
	}
};

class PlainGatherUintCubeArray : public GatherBase
{
public:
	virtual bool Supported()
	{
		if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_cube_map_array"))
		{
			OutputNotSupported("GL_ARB_texture_cube_map_array not supported");
			return false;
		}
		return true;
	}

	virtual void Init()
	{
		CreateTextureCubeArrayInt(3, 1);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 1);
	}

	virtual std::string Sampler()
	{
		return "uniform usamplerCubeArray my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {              \n"
						"    return textureGather(my_sampler, p);       \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32UI;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32UI, 1, 1);
	}

	virtual long Verify()
	{
		UVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data);
		if (data != UVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "uvec4";
	}
};

class PlainGatherDepthCubeArray : public GatherBase
{
public:
	virtual bool Supported()
	{
		if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_texture_cube_map_array"))
		{
			OutputNotSupported("GL_ARB_texture_cube_map_array not supported");
			return false;
		}
		return true;
	}

	virtual void Init()
	{
		CreateTextureCubeArray(7, 3);
		glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(7. / 16, -10. / 16, 1, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform samplerCubeArrayShadow my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                   \n"
						"    return textureGather(my_sampler, p, 7.5/16);    \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_DEPTH_COMPONENT32F;
	}

	virtual GLenum Format()
	{
		return GL_DEPTH_COMPONENT;
	}

	virtual Vec4 Expected()
	{
		return Vec4(0, 0, 1, 1);
	}
};

class PlainGatherFloat2DRect : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2D(true);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23, 26, 0, 0);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DRect my_sampler;                     \n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(1. / 16, 5. / 16, 9. / 16, 13. / 16);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                          \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y), 1);   \n"
						"}\n";
	}
};

class PlainGatherUnorm2DRect : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2D(true);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23, 26, 0, 0);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DRect my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                       \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y));   \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA16;
	}
};

class PlainGatherInt2DRect : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DInt(true);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(22.9f, 25.9f, 0, 0);
	}

	virtual std::string Sampler()
	{
		return "uniform isampler2DRect my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                        \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y));    \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32I;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32I, 1, 1);
	}

	virtual long Verify()
	{
		IVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_INT, &data);
		if (data != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "ivec4";
	}
};

class PlainGatherUint2DRect : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DInt(true);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(22.9f, 25.9f, 0, 0);
	}

	virtual std::string Sampler()
	{
		return "uniform usampler2DRect my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                        \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y));    \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_RGBA32UI;
	}

	virtual void SetRbo()
	{
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32UI, 1, 1);
	}

	virtual long Verify()
	{
		UVec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data);
		if (data != UVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected 0, 4, 8, 12, got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual long VerifyCompute()
	{
		IVec4* data;
		data = static_cast<IVec4*>(glMapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(IVec4), GL_MAP_READ_BIT));
		if (data[0] != IVec4(0, 4, 8, 12))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected " << Expected().x() << ", " << Expected().y() << ", "
				<< Expected().z() << ", " << Expected().w() << ", got: " << data[0].x() << ", " << data[0].y() << ", "
				<< data[0].z() << ", " << data[0].w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}

	virtual std::string Type()
	{
		return "uvec4";
	}
};

class PlainGatherDepth2DRect : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2D(true);
		glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(23, 26, 13.5 / 16, 3);
	}

	virtual std::string Sampler()
	{
		return "uniform sampler2DRectShadow my_sampler;                     \n";
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                             \n"
						"    return textureGather(my_sampler, vec2(p.x, p.y), p.z);    \n"
						"}\n";
	}

	virtual GLenum InternalFormat()
	{
		return GL_DEPTH_COMPONENT32F;
	}

	virtual GLenum Format()
	{
		return GL_DEPTH_COMPONENT;
	}

	virtual Vec4 Expected()
	{
		return Vec4(1, 1, 0, 0);
	}
};

class OffsetGatherFloat2D : public GatherBase
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 4, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                               \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.z)));    \n"
						"}\n";
	}
};

class OffsetGatherUnorm2D : public PlainGatherUnorm2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 4, 4);
	}

	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4 test_function(vec4 p) {                                                    \n"
			   "    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.z)));    \n"
			   "}\n";
	}
};

class OffsetGatherInt2D : public PlainGatherInt2DRgba
{
	virtual Vec4 BufferData()
	{
		return Vec4(18.9f / 32.f, 21.9f / 32.f, 4, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                               \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.z)));    \n"
						"}\n";
	}
};

class OffsetGatherUint2D : public PlainGatherUint2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(18.9f / 32.f, 21.9f / 32.f, 4, 2);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                          \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.z)), 2);            \n"
						"}\n";
	}
};

class OffsetGatherDepth2D : public PlainGatherDepth2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 4, 13.5 / 16);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                               \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), p.w, ivec2(int(p.z)));    \n"
						"}\n";
	}
};

class OffsetGatherFloat2DArray : public PlainGatherFloat2DArray
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 5, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                    \n"
						"    return textureGatherOffset(my_sampler, vec3(p.x, p.y, p.z), ivec2(int(p.w)));    \n"
						"}\n";
	}
};

class OffsetGatherUnorm2DArray : public PlainGatherUnorm2DArray
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 3, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                    \n"
						"    return textureGatherOffset(my_sampler, vec3(p.x, p.y, p.z), ivec2(int(p.w)));    \n"
						"}\n";
	}
};

class OffsetGatherInt2DArray : public PlainGatherInt2DArray
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 11, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                    \n"
						"    return textureGatherOffset(my_sampler, vec3(p.x, p.y, p.z), ivec2(int(p.w)), 3); \n"
						"}\n";
	}
};

class OffsetGatherUint2DArray : public PlainGatherUint2DArray
{
	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 1, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                    \n"
						"    return textureGatherOffset(my_sampler, vec3(p.x, p.y, p.z), ivec2(int(p.w)));    \n"
						"}\n";
	}
};

class OffsetGatherDepth2DArray : public PlainGatherDepth2DArray
{
	virtual void Init()
	{
		CreateTexture2DArray(7, 3);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(19. / 32, 22. / 32, 3, 4);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                                   \n"
			   "    return textureGatherOffset(my_sampler, vec3(p.x, p.y, p.z), p.y + (5./32), ivec2(int(p.w)));    \n"
			   "}\n";
	}
};

class OffsetGatherFloat2DRect : public PlainGatherFloat2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(19, 22, 0, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                  \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.w)), 1);    \n"
						"}\n";
	}
};

class OffsetGatherUnorm2DRect : public PlainGatherUnorm2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(30.9f, 18.9f, -8.f, 7.f);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                         \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.z), int(p.w)));    \n"
						"}\n";
	}
};

class OffsetGatherInt2DRect : public PlainGatherInt2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(22.9f, 25.9f, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                               \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.w)));    \n"
						"}\n";
	}
};

class OffsetGatherUint2DRect : public PlainGatherUint2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(26.9f, 29.9f, 0, -4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                               \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), ivec2(int(p.w)));    \n"
						"}\n";
	}
};

class OffsetGatherDepth2DRect : public PlainGatherDepth2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(19, 22, 13.5 / 16, 4);
	}

	virtual std::string TextBody()
	{
		return Type() + " test_function(vec4 p) {                                                    \n"
						"    return textureGatherOffset(my_sampler, vec2(p.x, p.y), p.z, ivec2(int(p.w)));    \n"
						"}\n";
	}
};

class OffsetsGatherFloat2D : public OffsetGatherFloat2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets);                         \n"
			   "}\n";
	}
};

class OffsetsGatherUnorm2D : public OffsetGatherUnorm2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 0, 0);
	}

	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4  test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets);                         \n"
			   "}\n";
	}
};

class OffsetsGatherInt2D : public OffsetGatherInt2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets);                         \n"
			   "}\n";
	}
};

class OffsetsGatherUint2D : public OffsetGatherUint2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 2, 2);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets, 2);                      \n"
			   "}\n";
	}
};

class OffsetsGatherDepth2D : public OffsetGatherDepth2D
{
	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 0.49f, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), p.z, offsets);                    \n"
			   "}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(0, 0, 1, 1);
	}
};

class OffsetsGatherFloat2DArray : public PlainGatherFloat2DArray
{
	virtual void Init()
	{
		CreateTexture2DArray(3, 1);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 1, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec3(p.x, p.y, p.z), offsets);                    \n"
			   "}\n";
	}
};

class OffsetsGatherUnorm2DArray : public PlainGatherUnorm2DArray
{
	virtual void Init()
	{
		CreateTexture2DArray(3, 1);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 1, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec3(p.x, p.y, p.z), offsets);                    \n"
			   "}\n";
	}
};

class OffsetsGatherInt2DArray : public PlainGatherInt2DArray
{
	virtual void Init()
	{
		CreateTexture2DArrayInt(3, 1);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 1, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec3(p.x, p.y, p.z), offsets, 3);                 \n"
			   "}\n";
	}
};

class OffsetsGatherUint2DArray : public PlainGatherUint2DArray
{
	virtual void Init()
	{
		CreateTexture2DArrayInt(3, 1);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 1, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec3(p.x, p.y, p.z), offsets);                    \n"
			   "}\n";
	}
};

class OffsetsGatherDepth2DArray : public PlainGatherDepth2DArray
{
	virtual void Init()
	{
		CreateTexture2DArray(3, 1);
		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
	}

	virtual Vec4 BufferData()
	{
		return Vec4(18. / 32, 8. / 32, 1, 0.49f);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec3(p.x, p.y, p.z), p.w, offsets);               \n"
			   "}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(0, 0, 1, 1);
	}
};

class OffsetsGatherFloat2DRect : public PlainGatherFloat2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(18, 8, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets, 1);                      \n"
			   "}\n";
	}
};

class OffsetsGatherUnorm2DRect : public PlainGatherUnorm2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(18, 8, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets);                         \n"
			   "}\n";
	}
};

class OffsetsGatherInt2DRect : public PlainGatherUint2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(17.9f, 7.9f, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets);                         \n"
			   "}\n";
	}
};

class OffsetsGatherUint2DRect : public PlainGatherUint2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(17.9f, 7.9f, 0, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), offsets);                         \n"
			   "}\n";
	}
};

class OffsetsGatherDepth2DRect : public PlainGatherDepth2DRect
{
	virtual Vec4 BufferData()
	{
		return Vec4(17.9f, 7.9f, 0.49f, 0);
	}

	virtual std::string TextBody()
	{
		return Type() +
			   " test_function(vec4 p) {                                                             \n"
			   "    const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3)); \n"
			   "    return textureGatherOffsets(my_sampler, vec2(p.x, p.y), p.z, offsets);                    \n"
			   "}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(0, 0, 1, 1);
	}
};

class Swizzle : public PlainGatherFloat2DRgba
{
	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4 test_function(vec4 p) {                                    \n"
			   "    return textureGather(my_sampler, vec2(p.x, p.y), 1).yzww;   \n"
			   "}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(5. / 16, 9. / 16, 13. / 16, 13. / 16);
	}
};

class BaseLevel : public PlainGatherFloat2DRgba
{
	virtual void Init()
	{
		CreateTexture2D(false, true);
	}
};

class IncompleteTexture : public PlainGatherFloat2DRgba
{
	virtual void Init()
	{
		CreateTexture2D();
		glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, 1, 1, 0, GL_RGBA, GL_FLOAT, 0);
	}

	virtual Vec4 Expected()
	{
		return Vec4(0);
	}
};

class IncompleteTextureLastComp : public PlainGatherFloat2DRgba
{
	virtual void Init()
	{
		CreateTexture2D();
		glTexImage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, 1, 1, 0, GL_RGBA, GL_FLOAT, 0);
	}

	virtual Vec4 Expected()
	{
		return Vec4(1);
	}

	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4 test_function(vec4 p) {                                    \n"
			   "    return textureGather(my_sampler, vec2(p.x, p.y), 3);        \n"
			   "}\n";
	}
};

class TriangleDraw : public GatherBase
{
	GLuint program, rbo, fbo, vao, vbo;

	virtual std::string VertexShader()
	{
		return "#version 400                                  \n"
			   "out vec2 texcoords;                           \n"
			   "in vec4 Vertex;                               \n"
			   "void main() {                                 \n"
			   "   gl_Position = Vertex;                      \n"
			   "   texcoords = (Vertex.xy + vec2(1.0)) / 2.0; \n"
			   "}\n";
	}

	virtual std::string FragmentShader()
	{
		return "#version 400                                      \n"
			   "in vec2 texcoords;                                \n"
			   "out vec4 FragColor;                               \n"
			   "uniform sampler2D tex;                            \n"
			   "void main() {                                     \n"
			   "   FragColor = textureGather(tex, texcoords, 2);  \n"
			   "}\n";
	}

	virtual long Run()
	{
		glGenFramebuffers(1, &fbo);
		glGenRenderbuffers(1, &rbo);
		glBindRenderbuffer(GL_RENDERBUFFER, rbo);
		glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32F, 100, 100);
		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
		GLenum drawBuffer = GL_COLOR_ATTACHMENT0;
		glDrawBuffers(1, &drawBuffer);
		GLfloat colorf[4] = { 0, 0, 0, 0 };
		glClearBufferfv(GL_COLOR, 0, colorf);
		glViewport(0, 0, 100, 100);

		program = CreateProgram(VertexShader().c_str(), NULL, NULL, NULL, FragmentShader().c_str());
		glBindAttribLocation(program, 0, "Vertex");
		glBindFragDataLocation(program, 0, "FragColor");
		glLinkProgram(program);
		if (!CheckProgram(program))
			return ERROR;
		glUseProgram(program);

		glGenTextures(1, &tex);
		glBindTexture(GL_TEXTURE_2D, tex);
		std::vector<Vec4> data(100 * 100, Vec4(0.25, 0.5, 0.75, 1));
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 100, 100, 0, GL_RGBA, GL_FLOAT, &data[0]);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

		GLuint l_vao;
		glGenVertexArrays(1, &l_vao);
		glBindVertexArray(l_vao);
		glGenBuffers(1, &vbo);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		GLfloat buffData[16] = { -1, 1, 0, 1, -1, -1, 0, 1, 1, 1, 0, 1, 1, -1, 0, 1 };
		glBufferData(GL_ARRAY_BUFFER, sizeof(buffData), buffData, GL_STATIC_DRAW);
		glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, 0);
		glEnableVertexAttribArray(0);
		glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
		glDisableVertexAttribArray(0);
		glDeleteVertexArrays(1, &l_vao);
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		glReadBuffer(GL_COLOR_ATTACHMENT0);
		std::vector<Vec4> read(100 * 100, Vec4(0));
		glReadPixels(0, 0, 100, 100, GL_RGBA, GL_FLOAT, &read[0]);
		for (unsigned int i = 0; i < read.size(); ++i)
		{
			if (read[i] != Vec4(0.75))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "Got: " << read[i].x() << " " << read[i].y() << " " << read[i].z()
					<< " " << read[i].w() << ", expected vec4(0.25)" << tcu::TestLog::EndMessage;
				return ERROR;
			}
		}

		return NO_ERROR;
	}

	virtual long Cleanup()
	{
		glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
		glViewport(0, 0, GetWindowWidth(), GetWindowHeight());
		glDeleteTextures(1, &tex);
		glDeleteFramebuffers(1, &fbo);
		glDeleteRenderbuffers(1, &rbo);
		glDeleteVertexArrays(1, &vao);
		glDeleteBuffers(1, &vbo);
		glDeleteProgram(program);
		return NO_ERROR;
	}
};

class PlainGatherFloat2DSrgb : public GatherBase
{
public:
	virtual Vec4 Expected()
	{
		return Vec4(0.f, 0.0512695f, 0.21582f, 0.519531f);
	}

	virtual GLenum InternalFormat()
	{
		return GL_SRGB8_ALPHA8;
	}
};

class PlainGatherFloat2DSrgbAlpha : public GatherBase
{
public:
	virtual std::string TestFunction()
	{
		return "uniform sampler2D my_sampler;                                   \n"
			   ""
			   "vec4 test_function(vec4 p) {                                    \n"
			   "    return textureGather(my_sampler, vec2(p.x, p.y), 3);        \n"
			   "}\n";
	}

	virtual Vec4 Expected()
	{
		return Vec4(3. / 16, 7. / 16, 11. / 16, 15. / 16);
	}

	virtual GLenum InternalFormat()
	{
		return GL_SRGB8_ALPHA8;
	}
};

class GatherGeometryShader : public GatherBase
{
	virtual std::string VertexShader()
	{
		return "#version 400                       \n"
			   "in vec4 v_in_0;                    \n"
			   "out vec4 d;                        \n"
			   "void main() {                      \n"
			   "   gl_Position = vec4(0, 0, 0, 1); \n"
			   "   d = v_in_0;                     \n"
			   "}";
	};

	virtual std::string GeometryShader()
	{
		return "#version 400                                                  \n"
			   "layout(points) in;                                            \n"
			   "layout(points, max_vertices = 1) out;                         \n"
			   "out vec4 col;                                                 \n"
			   "in vec4 d[1];                                                 \n"
			   "uniform sampler2D tex;                                        \n"
			   ""
			   "void main() {                                                 \n"
			   "   vec4 v1 = textureGather(tex, vec2(d[0].x, d[0].y));                                               \n"
			   "   vec4 v2 = textureGatherOffset(tex, vec2(d[0].x, d[0].y) - vec2(4./32), ivec2(4));                 \n"
			   "   const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3));         \n"
			   "   vec4 v3 = textureGatherOffsets(tex, vec2(d[0].x, d[0].y) - vec2(5./32, 18./32), offsets);         \n"
			   "   vec4 expected = vec4(0./16, 4./16, 8./16, 12./16);                                                \n"
			   "   float error = 0.0;                                         \n"
			   ""
			   "   if (v1 != expected)    \n"
			   "       error += 0.01;     \n"
			   "   if (v2 != expected)    \n"
			   "       error += 0.02;     \n"
			   "   if (v3 != expected)    \n"
			   "       error += 0.04;     \n"
			   ""
			   "   if (error != 0.0)                         \n"
			   "       col = vec4(v1.x, v2.y, v3.z, d[0].x); \n"
			   "   else                                      \n"
			   "       col = vec4(0, 1, 0, 1);               \n"
			   ""
			   "   gl_Position = vec4(0, 0, 0, 1);         \n"
			   "   EmitVertex();                           \n"
			   "   EndPrimitive();                         \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 400               \n"
			   "in vec4 col;               \n"
			   "out vec4 f_out_0;          \n"
			   "void main() {              \n"
			   "   f_out_0 = col;          \n"
			   "}";
	}

	virtual long Run()
	{
		if (!Supported())
			return NO_ERROR;
		Init();

		glGenFramebuffers(1, &fbo);
		glGenRenderbuffers(1, &rbo);
		glBindRenderbuffer(GL_RENDERBUFFER, rbo);
		SetRbo();
		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
		GLenum drawBuffer = GL_COLOR_ATTACHMENT0;
		glDrawBuffers(1, &drawBuffer);
		GLfloat colorf[4] = { 0, 0, 0, 0 };
		glClearBufferfv(GL_COLOR, 0, colorf);
		glViewport(0, 0, 1, 1);

		glGenVertexArrays(1, &vao);
		glBindVertexArray(vao);
		glGenBuffers(1, &vbo);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glVertexAttribPointer(0, 4, GL_FLOAT, false, 0, 0);
		glEnableVertexAttribArray(0);
		Vec4 buffData = BufferData();
		glBufferData(GL_ARRAY_BUFFER, 16, &buffData, GL_STATIC_DRAW);

		program = CreateProgram(VertexShader().c_str(), NULL, NULL, GeometryShader().c_str(), FragmentShader().c_str());
		glBindAttribLocation(program, 0, "v_in_0");
		glBindFragDataLocation(program, 0, "f_out_0");
		glLinkProgram(program);
		if (!CheckProgram(program))
			return ERROR;
		glUseProgram(program);

		glDrawArrays(GL_POINTS, 0, 1);
		glReadBuffer(GL_COLOR_ATTACHMENT0);

		glDeleteProgram(program);
		Vec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, &data);
		if (!ColorEqual(data, Vec4(0, 1, 0, 1), g_color_eps))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected Vec4(0, 1, 0, 1), got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << ", epsilon: " << g_color_eps.x() << ", " << g_color_eps.y() << ", "
				<< g_color_eps.z() << ", " << g_color_eps.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}
};

class GatherTesselationShader : public GatherBase
{
	virtual std::string VertexShader()
	{
		return "#version 400               \n"
			   "in vec4 v_in_0;            \n"
			   "out vec4 d;                \n"
			   "void main() {              \n"
			   "   gl_Position = vec4(0, 0, 0, 1); \n"
			   "   d = v_in_0;             \n"
			   "}";
	}

	virtual std::string ControlShader()
	{
		return "#version 400                                                  \n"
			   "layout(vertices = 1) out;                                     \n"
			   "out vec4 ccol[];                                              \n"
			   "in vec4 d[];                                                  \n"
			   "out vec4 d_con[];                                             \n"
			   "uniform sampler2D tex;                                        \n"
			   ""
			   "void main() {                                        \n"
			   "   vec4 v1 = textureGather(tex, vec2(d[0].x, d[0].y));                                               \n"
			   "   vec4 v2 = textureGatherOffset(tex, vec2(d[0].x, d[0].y) - vec2(4./32), ivec2(4));                 \n"
			   "   const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3));         \n"
			   "   vec4 v3 = textureGatherOffsets(tex, vec2(d[0].x, d[0].y) - vec2(5./32, 18./32), offsets);         \n"
			   "   vec4 expected = vec4(0./16, 4./16, 8./16, 12./16);                                                \n"
			   "   float error = 0.0;                                         \n"
			   ""
			   "   if (v1 != expected)    \n"
			   "       error += 0.01;     \n"
			   "   if (v2 != expected)    \n"
			   "       error += 0.02;     \n"
			   "   if (v3 != expected)    \n"
			   "       error += 0.04;     \n"
			   ""
			   "   if (error != 0.0)                                            \n"
			   "       ccol[gl_InvocationID] = vec4(v1.x, v2.y, d[0].x, 1);      \n"
			   "   else                                                         \n"
			   "       ccol[gl_InvocationID] = vec4(0, 1, 0, 1);                \n"
			   ""
			   "   d_con[gl_InvocationID] = d[gl_InvocationID];                                 \n"
			   "   gl_out[gl_InvocationID].gl_Position = vec4(0, 0, 0, 1);                      \n"
			   "   gl_TessLevelInner[0] = 1.0;                                                  \n"
			   "   gl_TessLevelOuter[0] = 1.0;                                                  \n"
			   "   gl_TessLevelOuter[1] = 1.0;                                                  \n"
			   "   gl_TessLevelOuter[2] = 1.0;                                                  \n"
			   "}";
	}

	virtual std::string EvalShader()
	{
		return "#version 400                                                  \n"
			   "layout(triangles, point_mode) in;                             \n"
			   "in vec4 ccol[];                                               \n"
			   "in vec4 d_con[];                                              \n"
			   "out vec4 ecol;                                                \n"
			   "uniform sampler2D tex;                                        \n"
			   ""
			   "void main() {                                        \n"
			   "   vec4 v1 = textureGather(tex, vec2(d_con[0].x, d_con[0].y));                                         "
			   "      \n"
			   "   vec4 v2 = textureGatherOffset(tex, vec2(d_con[0].x, d_con[0].y) - vec2(4./32), ivec2(4));           "
			   "      \n"
			   "   const ivec2 offsets[4] = ivec2[](ivec2(7, 6), ivec2(-8, 7), ivec2(-6, -5), ivec2(-1, 3));           "
			   "      \n"
			   "   vec4 v3 = textureGatherOffsets(tex, vec2(d_con[0].x, d_con[0].y) - vec2(5./32, 18./32), offsets);   "
			   "      \n"
			   "   vec4 expected = vec4(0./16, 4./16, 8./16, 12./16);                                                  "
			   "      \n"
			   "   float error = 0.0;                                         \n"
			   ""
			   "   if (v1 != expected)    \n"
			   "       error += 0.01;     \n"
			   "   if (v2 != expected)    \n"
			   "       error += 0.02;     \n"
			   "   if (v3 != expected)    \n"
			   "       error += 0.04;     \n"
			   ""
			   "   if (error != 0.0)                                          \n"
			   "       ecol = vec4(v1.x, v2.y, d_con[0].x, -1);                      \n"
			   "   else if (ccol[0] != vec4(0, 1, 0, 1))     \n"
			   "       ecol = ccol[0];                       \n"
			   "   else                                      \n"
			   "       ecol = vec4(0, 1, 0, 1);              \n"
			   ""
			   "   gl_Position = vec4(0, 0, 0, 1);   \n"
			   "}";
	}

	virtual std::string FragmentShader()
	{
		return "#version 400               \n"
			   "in vec4 ecol;              \n"
			   "out vec4 f_out_0;          \n"
			   "void main() {              \n"
			   "   f_out_0 = ecol;         \n"
			   "}";
	}

	virtual long Run()
	{

		if (!Supported())
			return NO_ERROR;
		Init();

		glGenFramebuffers(1, &fbo);
		glGenRenderbuffers(1, &rbo);
		glBindRenderbuffer(GL_RENDERBUFFER, rbo);
		SetRbo();
		glBindFramebuffer(GL_FRAMEBUFFER, fbo);
		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
		GLenum drawBuffer = GL_COLOR_ATTACHMENT0;
		glDrawBuffers(1, &drawBuffer);
		GLfloat colorf[4] = { 0, 0, 0, 0 };
		glClearBufferfv(GL_COLOR, 0, colorf);
		glViewport(0, 0, 1, 1);

		glGenVertexArrays(1, &vao);
		glBindVertexArray(vao);
		glGenBuffers(1, &vbo);
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glVertexAttribPointer(0, 4, GL_FLOAT, false, 0, 0);
		glEnableVertexAttribArray(0);
		Vec4 buffData = BufferData();
		glBufferData(GL_ARRAY_BUFFER, 16, &buffData, GL_STATIC_DRAW);

		program = CreateProgram(VertexShader().c_str(), ControlShader().c_str(), EvalShader().c_str(), NULL,
								FragmentShader().c_str());
		glBindAttribLocation(program, 0, "v_in_0");
		glBindFragDataLocation(program, 0, "f_out_0");
		glLinkProgram(program);
		if (!CheckProgram(program))
			return ERROR;
		glUseProgram(program);

		glPatchParameteri(GL_PATCH_VERTICES, 1);
		glDrawArrays(GL_PATCHES, 0, 1);
		glReadBuffer(GL_COLOR_ATTACHMENT0);

		glDeleteProgram(program);
		Vec4 data;
		glReadPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, &data);
		if (!ColorEqual(data, Vec4(0, 1, 0, 1), g_color_eps))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Expected Vec4(0, 1, 0, 1), got: " << data.x() << ", " << data.y() << ", "
				<< data.z() << ", " << data.w() << ", epsilon: " << g_color_eps.x() << ", " << g_color_eps.y() << ", "
				<< g_color_eps.z() << ", " << g_color_eps.w() << tcu::TestLog::EndMessage;
			return ERROR;
		}
		return NO_ERROR;
	}
};

class PlainGatherFloat2DRgb : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DRgb();
	}
};

class PlainGatherFloat2DR : public GatherBase
{
public:
	virtual void Init()
	{
		CreateTexture2DR();
	}
};

class OffsetGatherFloat2DRgb : public OffsetGatherFloat2D
{
public:
	virtual void Init()
	{
		CreateTexture2DRgb();
	}
};

class OffsetGatherFloat2DRg : public OffsetGatherFloat2D
{
public:
	virtual void Init()
	{
		CreateTexture2DRg();
	}
};

class OffsetGatherFloat2DR : public OffsetGatherFloat2D
{
public:
	virtual void Init()
	{
		CreateTexture2DR();
	}
};

} // anonymous namespace

TextureGatherTests::TextureGatherTests(deqp::Context& context) : TestCaseGroup(context, "texture_gather", "")
{
}

TextureGatherTests::~TextureGatherTests(void)
{
}

void TextureGatherTests::init()
{
	using namespace deqp;
	addChild(new TestSubcase(m_context, "api-enums", TestSubcase::Create<GatherEnumsTest>));
	addChild(new TestSubcase(m_context, "gather-glsl-compile", TestSubcase::Create<GatherGLSLCompile>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2d-rgba", TestSubcase::Create<PlainGatherFloat2DRgba>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2d-rg", TestSubcase::Create<PlainGatherFloat2DRg>));
	addChild(new TestSubcase(m_context, "plain-gather-unorm-2d", TestSubcase::Create<PlainGatherUnorm2D>));
	addChild(new TestSubcase(m_context, "plain-gather-int-2d-rgba", TestSubcase::Create<PlainGatherInt2DRgba>));
	addChild(new TestSubcase(m_context, "plain-gather-int-2d-rg", TestSubcase::Create<PlainGatherInt2DRg>));
	addChild(new TestSubcase(m_context, "plain-gather-uint-2d", TestSubcase::Create<PlainGatherUint2D>));
	addChild(new TestSubcase(m_context, "plain-gather-depth-2d", TestSubcase::Create<PlainGatherDepth2D>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2darray", TestSubcase::Create<PlainGatherFloat2DArray>));
	addChild(new TestSubcase(m_context, "plain-gather-unorm-2darray", TestSubcase::Create<PlainGatherUnorm2DArray>));
	addChild(new TestSubcase(m_context, "plain-gather-int-2darray", TestSubcase::Create<PlainGatherInt2DArray>));
	addChild(new TestSubcase(m_context, "plain-gather-uint-2darray", TestSubcase::Create<PlainGatherUint2DArray>));
	addChild(new TestSubcase(m_context, "plain-gather-depth-2darray", TestSubcase::Create<PlainGatherDepth2DArray>));
	addChild(new TestSubcase(m_context, "plain-gather-float-cube-rgba", TestSubcase::Create<PlainGatherFloatCubeRgba>));
	addChild(new TestSubcase(m_context, "plain-gather-float-cube-rg", TestSubcase::Create<PlainGatherFloatCubeRg>));
	addChild(new TestSubcase(m_context, "plain-gather-unorm-cube", TestSubcase::Create<PlainGatherUnormCube>));
	addChild(new TestSubcase(m_context, "plain-gather-int-cube-rgba", TestSubcase::Create<PlainGatherIntCubeRgba>));
	addChild(new TestSubcase(m_context, "plain-gather-int-cube-rg", TestSubcase::Create<PlainGatherIntCubeRg>));
	addChild(new TestSubcase(m_context, "plain-gather-uint-cube", TestSubcase::Create<PlainGatherUintCube>));
	addChild(new TestSubcase(m_context, "plain-gather-depth-cube", TestSubcase::Create<PlainGatherDepthCube>));
	addChild(
		new TestSubcase(m_context, "plain-gather-float-cube-array", TestSubcase::Create<PlainGatherFloatCubeArray>));
	addChild(
		new TestSubcase(m_context, "plain-gather-unorm-cube-array", TestSubcase::Create<PlainGatherUnormCubeArray>));
	addChild(new TestSubcase(m_context, "plain-gather-int-cube-array", TestSubcase::Create<PlainGatherIntCubeArray>));
	addChild(new TestSubcase(m_context, "plain-gather-uint-cube-array", TestSubcase::Create<PlainGatherUintCubeArray>));
	addChild(
		new TestSubcase(m_context, "plain-gather-depth-cube-array", TestSubcase::Create<PlainGatherDepthCubeArray>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2drect", TestSubcase::Create<PlainGatherFloat2DRect>));
	addChild(new TestSubcase(m_context, "plain-gather-unorm-2drect", TestSubcase::Create<PlainGatherUnorm2DRect>));
	addChild(new TestSubcase(m_context, "plain-gather-int-2drect", TestSubcase::Create<PlainGatherInt2DRect>));
	addChild(new TestSubcase(m_context, "plain-gather-uint-2drect", TestSubcase::Create<PlainGatherUint2DRect>));
	addChild(new TestSubcase(m_context, "plain-gather-depth-2drect", TestSubcase::Create<PlainGatherDepth2DRect>));
	addChild(new TestSubcase(m_context, "offset-gather-float-2d", TestSubcase::Create<OffsetGatherFloat2D>));
	addChild(new TestSubcase(m_context, "offset-gather-unorm-2d", TestSubcase::Create<OffsetGatherUnorm2D>));
	addChild(new TestSubcase(m_context, "offset-gather-int-2d", TestSubcase::Create<OffsetGatherInt2D>));
	addChild(new TestSubcase(m_context, "offset-gather-uint-2d", TestSubcase::Create<OffsetGatherUint2D>));
	addChild(new TestSubcase(m_context, "offset-gather-depth-2d", TestSubcase::Create<OffsetGatherDepth2D>));
	addChild(new TestSubcase(m_context, "offset-gather-float-2darray", TestSubcase::Create<OffsetGatherFloat2DArray>));
	addChild(new TestSubcase(m_context, "offset-gather-unorm-2darray", TestSubcase::Create<OffsetGatherUnorm2DArray>));
	addChild(new TestSubcase(m_context, "offset-gather-int-2darray", TestSubcase::Create<OffsetGatherInt2DArray>));
	addChild(new TestSubcase(m_context, "offset-gather-uint-2darray", TestSubcase::Create<OffsetGatherUint2DArray>));
	addChild(new TestSubcase(m_context, "offset-gather-depth-2darray", TestSubcase::Create<OffsetGatherDepth2DArray>));
	addChild(new TestSubcase(m_context, "offset-gather-float-2drect", TestSubcase::Create<OffsetGatherFloat2DRect>));
	addChild(new TestSubcase(m_context, "offset-gather-unorm-2drect", TestSubcase::Create<OffsetGatherUnorm2DRect>));
	addChild(new TestSubcase(m_context, "offset-gather-int-2drect", TestSubcase::Create<OffsetGatherInt2DRect>));
	addChild(new TestSubcase(m_context, "offset-gather-uint-2drect", TestSubcase::Create<OffsetGatherUint2DRect>));
	addChild(new TestSubcase(m_context, "offset-gather-depth-2drect", TestSubcase::Create<OffsetGatherDepth2DRect>));
	addChild(new TestSubcase(m_context, "offsets-gather-float-2d", TestSubcase::Create<OffsetsGatherFloat2D>));
	addChild(new TestSubcase(m_context, "offsets-gather-unorm-2d", TestSubcase::Create<OffsetsGatherUnorm2D>));
	addChild(new TestSubcase(m_context, "offsets-gather-int-2d", TestSubcase::Create<OffsetsGatherInt2D>));
	addChild(new TestSubcase(m_context, "offsets-gather-uint-2d", TestSubcase::Create<OffsetsGatherUint2D>));
	addChild(new TestSubcase(m_context, "offsets-gather-depth-2d", TestSubcase::Create<OffsetsGatherDepth2D>));
	addChild(
		new TestSubcase(m_context, "offsets-gather-float-2darray", TestSubcase::Create<OffsetsGatherFloat2DArray>));
	addChild(
		new TestSubcase(m_context, "offsets-gather-unorm-2darray", TestSubcase::Create<OffsetsGatherUnorm2DArray>));
	addChild(new TestSubcase(m_context, "offsets-gather-int-2darray", TestSubcase::Create<OffsetsGatherInt2DArray>));
	addChild(new TestSubcase(m_context, "offsets-gather-uint-2darray", TestSubcase::Create<OffsetsGatherUint2DArray>));
	addChild(
		new TestSubcase(m_context, "offsets-gather-depth-2darray", TestSubcase::Create<OffsetsGatherDepth2DArray>));
	addChild(new TestSubcase(m_context, "offsets-gather-float-2drect", TestSubcase::Create<OffsetsGatherFloat2DRect>));
	addChild(new TestSubcase(m_context, "offsets-gather-unorm-2drect", TestSubcase::Create<OffsetsGatherUnorm2DRect>));
	addChild(new TestSubcase(m_context, "offsets-gather-int-2drect", TestSubcase::Create<OffsetsGatherInt2DRect>));
	addChild(new TestSubcase(m_context, "offsets-gather-uint-2drect", TestSubcase::Create<OffsetsGatherUint2DRect>));
	addChild(new TestSubcase(m_context, "offsets-gather-depth-2drect", TestSubcase::Create<OffsetsGatherDepth2DRect>));
	addChild(new TestSubcase(m_context, "swizzle", TestSubcase::Create<Swizzle>));
	addChild(new TestSubcase(m_context, "base-level", TestSubcase::Create<BaseLevel>));
	addChild(new TestSubcase(m_context, "incomplete-texture", TestSubcase::Create<IncompleteTexture>));
	addChild(
		new TestSubcase(m_context, "incomplete-texture-last-comp", TestSubcase::Create<IncompleteTextureLastComp>));
	addChild(new TestSubcase(m_context, "triangle-draw", TestSubcase::Create<TriangleDraw>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2d-srgb", TestSubcase::Create<PlainGatherFloat2DSrgb>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2d-srgb-alpha",
							 TestSubcase::Create<PlainGatherFloat2DSrgbAlpha>));
	addChild(new TestSubcase(m_context, "gather-geometry-shader", TestSubcase::Create<GatherGeometryShader>));
	addChild(new TestSubcase(m_context, "gather-tesselation-shader", TestSubcase::Create<GatherTesselationShader>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2d-rgb", TestSubcase::Create<PlainGatherFloat2DRgb>));
	addChild(new TestSubcase(m_context, "plain-gather-float-2d-r", TestSubcase::Create<PlainGatherFloat2DR>));
	addChild(new TestSubcase(m_context, "offset-gather-float-2d-rgb", TestSubcase::Create<OffsetGatherFloat2DRgb>));
	addChild(new TestSubcase(m_context, "offset-gather-float-2d-rg", TestSubcase::Create<OffsetGatherFloat2DRg>));
	addChild(new TestSubcase(m_context, "offset-gather-float-2d-r", TestSubcase::Create<OffsetGatherFloat2DR>));
}

} // gl4cts namespace