/*-------------------------------------------------------------------------
 * 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 "gl4cShaderImageSizeTests.hpp"
#include "gluContextInfo.hpp"
#include "glwEnums.hpp"
#include "tcuMatrix.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuVectorUtil.hpp"
#include <assert.h>
#include <cstdarg>

namespace gl4cts
{
using namespace glw;

namespace
{
typedef tcu::Vec3  vec3;
typedef tcu::Vec4  vec4;
typedef tcu::IVec4 ivec4;
typedef tcu::UVec4 uvec4;

class ShaderImageSizeBase : public deqp::SubcaseBase
{
	virtual std::string Title()
	{
		return "";
	}

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

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

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

public:
	bool SupportedInVS(int requiredVS)
	{
		GLint imagesVS;
		glGetIntegerv(GL_MAX_VERTEX_IMAGE_UNIFORMS, &imagesVS);
		if (imagesVS >= requiredVS)
			return true;
		else
		{
			std::ostringstream reason;
			reason << "Required " << requiredVS << " VS image uniforms but only " << imagesVS << " available."
				   << std::endl;
			OutputNotSupported(reason.str());
			return false;
		}
	}

	bool SupportedInTCS(int requiredTCS)
	{
		GLint imagesTCS;
		glGetIntegerv(GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS, &imagesTCS);
		if (imagesTCS >= requiredTCS)
			return true;
		else
		{
			std::ostringstream reason;
			reason << "Required " << requiredTCS << " TCS image uniforms but only " << imagesTCS << " available."
				   << std::endl;
			OutputNotSupported(reason.str());
			return false;
		}
	}

	bool SupportedInTES(int requiredTES)
	{
		GLint imagesTES;
		glGetIntegerv(GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS, &imagesTES);
		if (imagesTES >= requiredTES)
			return true;
		else
		{
			std::ostringstream reason;
			reason << "Required " << requiredTES << " TES image uniforms but only " << imagesTES << " available."
				   << std::endl;
			OutputNotSupported(reason.str());
			return false;
		}
	}

	bool SupportedInGS(int requiredGS)
	{
		GLint imagesGS;
		glGetIntegerv(GL_MAX_GEOMETRY_IMAGE_UNIFORMS, &imagesGS);
		if (imagesGS >= requiredGS)
			return true;
		else
		{
			std::ostringstream reason;
			reason << "Required " << requiredGS << " GS image uniforms but only " << imagesGS << " available."
				   << std::endl;
			OutputNotSupported(reason.str());
			return false;
		}
	}

	bool SupportedInStage(int stage, int required)
	{
		switch (stage)
		{
		case 0:
			return SupportedInVS(required);
		case 1:
			return SupportedInTCS(required);
		case 2:
			return SupportedInTES(required);
		case 3:
			return SupportedInGS(required);
		default:
			return true;
		}
	}

	bool SupportedSamples(int required)
	{
		int i;
		glGetIntegerv(GL_MAX_IMAGE_SAMPLES, &i);
		if (i >= required)
			return true;
		else
		{
			std::ostringstream reason;
			reason << "Required " << required << " image samples but only " << i << " available." << std::endl;
			OutputNotSupported(reason.str());
			return false;
		}
	}

	int getWindowWidth()
	{
		const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget();
		return renderTarget.getWidth();
	}

	int getWindowHeight()
	{
		const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget();
		return renderTarget.getHeight();
	}

	inline bool ColorEqual(const vec4& c0, const vec4& c1, const vec4& epsilon)
	{
		if (fabs(c0[0] - c1[0]) > epsilon[0])
			return false;
		if (fabs(c0[1] - c1[1]) > epsilon[1])
			return false;
		if (fabs(c0[2] - c1[2]) > epsilon[2])
			return false;
		if (fabs(c0[3] - c1[3]) > epsilon[3])
			return false;
		return true;
	}

	template <class T>
	std::string ToString(T v)
	{
		std::ostringstream s;
		s << "[";
		for (int i = 0; i < 4; ++i)
			s << v[i] << (i == 3 ? "" : ",");
		s << "]";
		return s.str();
	}

	bool ValidateReadBuffer(int x, int y, int w, int h, const vec4& expected)
	{
		bool					 status		  = true;
		const tcu::RenderTarget& renderTarget = m_context.getRenderContext().getRenderTarget();
		const tcu::PixelFormat&  pixelFormat  = renderTarget.getPixelFormat();
		vec4					 g_color_eps  = vec4(
			1.f / static_cast<float>(1 << pixelFormat.redBits), 1.f / static_cast<float>(1 << pixelFormat.greenBits),
			1.f / static_cast<float>(1 << pixelFormat.blueBits), 1.f / static_cast<float>(1 << pixelFormat.alphaBits));

		std::vector<vec4> fb(w * h);
		glReadPixels(x, y, w, h, GL_RGBA, GL_FLOAT, &fb[0]);

		for (int yy = 0; yy < h; ++yy)
		{
			for (int xx = 0; xx < w; ++xx)
			{
				const int idx = yy * w + xx;
				if (!ColorEqual(fb[idx], expected, g_color_eps))
				{
					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "First bad color: " << ToString(fb[idx])
						<< tcu::TestLog::EndMessage;
					status = false;
					return status;
				}
			}
		}
		return status;
	}

	bool CheckProgram(GLuint program)
	{
		if (program == 0)
			return 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;
						break;
					}
					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;
			}
		}
		return status == GL_TRUE ? true : false;
	}
};

template <typename T>
std::string ImageTypePrefix();

template <>
std::string ImageTypePrefix<vec4>()
{
	return "";
}

template <>
std::string ImageTypePrefix<ivec4>()
{
	return "i";
}

template <>
std::string ImageTypePrefix<uvec4>()
{
	return "u";
}

template <typename T>
std::string ImageFormatPostfix();

template <>
std::string ImageFormatPostfix<vec4>()
{
	return "f";
}

template <>
std::string ImageFormatPostfix<ivec4>()
{
	return "i";
}

template <>
std::string ImageFormatPostfix<uvec4>()
{
	return "ui";
}

template <typename T>
GLenum TexInternalFormat();

template <>
GLenum TexInternalFormat<vec4>()
{
	return GL_RGBA32F;
}

template <>
GLenum TexInternalFormat<ivec4>()
{
	return GL_RGBA32I;
}

template <>
GLenum TexInternalFormat<uvec4>()
{
	return GL_RGBA32UI;
}

template <typename T>
GLenum TexType();

template <>
GLenum TexType<vec4>()
{
	return GL_FLOAT;
}

template <>
GLenum TexType<ivec4>()
{
	return GL_INT;
}

template <>
GLenum TexType<uvec4>()
{
	return GL_UNSIGNED_INT;
}

template <typename T>
GLenum TexFormat();

template <>
GLenum TexFormat<vec4>()
{
	return GL_RGBA;
}

template <>
GLenum TexFormat<ivec4>()
{
	return GL_RGBA_INTEGER;
}

template <>
GLenum TexFormat<uvec4>()
{
	return GL_RGBA_INTEGER;
}
//=============================================================================
// ImageSizeMachine
//-----------------------------------------------------------------------------
class ImageSizeMachine : public deqp::GLWrapper
{
	GLuint m_pipeline;
	GLuint m_program[3];
	GLuint m_vertex_array;
	GLuint m_texture;

	template <typename T>
	std::string GenShader(int stage, bool ms_and_1d, bool subroutine)
	{
		std::ostringstream os;
		os << "#version 430 core";
		if (stage == 4)
		{ // CS
			os << NL "#extension GL_ARB_compute_shader : require";
		}
		os << NL "layout(binding = 0, rgba32i) writeonly uniform iimage2D g_result;";
		if (ms_and_1d == false)
		{
			os << NL "layout(binding = 1, rgba32" << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>()
			   << "image2D g_image_2d;" NL "layout(binding = 2, rgba32" << ImageFormatPostfix<T>() << ") uniform "
			   << ImageTypePrefix<T>() << "image3D g_image_3d;" NL "layout(binding = 3, rgba32"
			   << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>()
			   << "imageCube g_image_cube;" NL "layout(binding = 4, rgba32" << ImageFormatPostfix<T>() << ") uniform "
			   << ImageTypePrefix<T>() << "imageCubeArray g_image_cube_array;" NL "layout(binding = 5, rgba32"
			   << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>()
			   << "image2DRect g_image_rect;" NL "layout(binding = 6, rgba32" << ImageFormatPostfix<T>() << ") uniform "
			   << ImageTypePrefix<T>() << "image2DArray g_image_2d_array;" NL "layout(binding = 7, rgba32"
			   << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>() << "imageBuffer g_image_buffer;";
		}
		else
		{
			os << NL "layout(binding = 1, rgba32" << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>()
			   << "image1D g_image_1d;" NL "layout(binding = 2, rgba32" << ImageFormatPostfix<T>() << ") uniform "
			   << ImageTypePrefix<T>() << "image1DArray g_image_1d_array;" NL "layout(binding = 3, rgba32"
			   << ImageFormatPostfix<T>() << ") uniform " << ImageTypePrefix<T>()
			   << "image2DMS g_image_2dms;" NL "layout(binding = 4, rgba32" << ImageFormatPostfix<T>() << ") uniform "
			   << ImageTypePrefix<T>() << "image2DMSArray g_image_2dms_array;";
		}
		if (subroutine)
		{
			os << NL "subroutine void FuncType(int coord);" NL "subroutine uniform FuncType g_func;";
		}
		if (stage == 0)
		{ // VS
			os << NL "void main() {" NL "  int coord = gl_VertexID;";
		}
		else if (stage == 1)
		{ // TCS
			os << NL "layout(vertices = 1) out;" NL "void main() {" NL "  gl_TessLevelInner[0] = 1;" NL
					 "  gl_TessLevelInner[1] = 1;" NL "  gl_TessLevelOuter[0] = 1;" NL "  gl_TessLevelOuter[1] = 1;" NL
					 "  gl_TessLevelOuter[2] = 1;" NL "  gl_TessLevelOuter[3] = 1;" NL "  int coord = gl_PrimitiveID;";
		}
		else if (stage == 2)
		{ // TES
			os << NL "layout(quads, point_mode) in;" NL "void main() {" NL "  int coord = gl_PrimitiveID;";
		}
		else if (stage == 3)
		{ // GS
			os << NL "layout(points) in;" NL "layout(points, max_vertices = 1) out;" NL "void main() {" NL
					 "  int coord = gl_PrimitiveIDIn;";
		}
		else if (stage == 4)
		{ // CS
			os << NL "layout(local_size_x = 1) in;" NL "void main() {" NL "  int coord = int(gl_GlobalInvocationID.x);";
		}
		else if (stage == 5)
		{ // FS
			os << NL "void main() {" NL "  int coord = gl_PrimitiveID;";
		}
		if (subroutine)
		{
			os << NL "  g_func(coord);" NL "}" NL "subroutine(FuncType) void Func0(int coord) {";
		}
		if (ms_and_1d == false)
		{
			os << NL "  imageStore(g_result, ivec2(coord, 0), ivec4(imageSize(g_image_2d), 0, 0));" NL
					 "  imageStore(g_result, ivec2(coord, 1), ivec4(imageSize(g_image_3d), 0));" NL
					 "  imageStore(g_result, ivec2(coord, 2), ivec4(imageSize(g_image_cube), 0, 0));" NL
					 "  imageStore(g_result, ivec2(coord, 3), ivec4(imageSize(g_image_cube_array), 0));" NL
					 "  imageStore(g_result, ivec2(coord, 4), ivec4(imageSize(g_image_rect), 0, 0));" NL
					 "  imageStore(g_result, ivec2(coord, 5), ivec4(imageSize(g_image_2d_array), 0));" NL
					 "  imageStore(g_result, ivec2(coord, 6), ivec4(imageSize(g_image_buffer), 0, 0, 0));" NL "}";
		}
		else
		{
			os << NL "  imageStore(g_result, ivec2(coord, 0), ivec4(imageSize(g_image_1d), 0, 0, 0));" NL
					 "  imageStore(g_result, ivec2(coord, 1), ivec4(imageSize(g_image_1d_array), 0, 0));" NL
					 "  imageStore(g_result, ivec2(coord, 2), ivec4(imageSize(g_image_2dms), 0, 0));" NL
					 "  imageStore(g_result, ivec2(coord, 3), ivec4(imageSize(g_image_2dms_array), 0));" NL
					 "  imageStore(g_result, ivec2(coord, 4), ivec4(0));" NL
					 "  imageStore(g_result, ivec2(coord, 5), ivec4(0));" NL
					 "  imageStore(g_result, ivec2(coord, 6), ivec4(0));" NL "}";
		}
		return os.str();
	}

	bool CheckProgram(GLuint program)
	{
		if (program == 0)
			return 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;
						break;
					}
					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;
			}
		}
		return status == GL_TRUE ? true : false;
	}

public:
	ImageSizeMachine()
	{
		glGenProgramPipelines(1, &m_pipeline);
		memset(m_program, 0, sizeof(m_program));
		glGenVertexArrays(1, &m_vertex_array);
		glGenTextures(1, &m_texture);
	}

	~ImageSizeMachine()
	{
		glDeleteProgramPipelines(1, &m_pipeline);
		for (int i = 0; i < 3; ++i)
			glDeleteProgram(m_program[i]);
		glDeleteVertexArrays(1, &m_vertex_array);
		glDeleteTextures(1, &m_texture);
	}

	template <typename T>
	long Run(int stage, bool ms_and_1d, ivec4 expected_result[7], bool subroutine = false)
	{
		if (stage == 0)
		{ // VS
			std::string		  vs	  = GenShader<T>(stage, ms_and_1d, subroutine);
			const char* const glsl_vs = vs.c_str();
			m_program[0]			  = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs);
			glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]);
		}
		else if (stage == 1)
		{ // TCS
			const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL
										"void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}";
			const char* const glsl_tes = "#version 430 core" NL "layout(quads, point_mode) in;" NL "void main() {}";
			std::string		  tcs	  = GenShader<T>(stage, ms_and_1d, subroutine);
			const char* const glsl_tcs = tcs.c_str();
			m_program[0]			   = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs);
			m_program[1]			   = glCreateShaderProgramv(GL_TESS_CONTROL_SHADER, 1, &glsl_tcs);
			m_program[2]			   = glCreateShaderProgramv(GL_TESS_EVALUATION_SHADER, 1, &glsl_tes);
			glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]);
			glUseProgramStages(m_pipeline, GL_TESS_CONTROL_SHADER_BIT, m_program[1]);
			glUseProgramStages(m_pipeline, GL_TESS_EVALUATION_SHADER_BIT, m_program[2]);
		}
		else if (stage == 2)
		{ // TES
			const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL
										"void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}";
			std::string		  tes	  = GenShader<T>(stage, ms_and_1d, subroutine);
			const char* const glsl_tes = tes.c_str();
			m_program[0]			   = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs);
			m_program[1]			   = glCreateShaderProgramv(GL_TESS_EVALUATION_SHADER, 1, &glsl_tes);
			glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]);
			glUseProgramStages(m_pipeline, GL_TESS_EVALUATION_SHADER_BIT, m_program[1]);
		}
		else if (stage == 3)
		{ // GS
			const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL
										"void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}";
			std::string		  gs	  = GenShader<T>(stage, ms_and_1d, subroutine);
			const char* const glsl_gs = gs.c_str();
			m_program[0]			  = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs);
			m_program[1]			  = glCreateShaderProgramv(GL_GEOMETRY_SHADER, 1, &glsl_gs);
			glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]);
			glUseProgramStages(m_pipeline, GL_GEOMETRY_SHADER_BIT, m_program[1]);
		}
		else if (stage == 4)
		{ // CS
			std::string		  cs	  = GenShader<T>(stage, ms_and_1d, subroutine);
			const char* const glsl_cs = cs.c_str();
			m_program[0]			  = glCreateShaderProgramv(GL_COMPUTE_SHADER, 1, &glsl_cs);
			glUseProgramStages(m_pipeline, GL_COMPUTE_SHADER_BIT, m_program[0]);
		}
		else if (stage == 5)
		{ // FS
			const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL
										"void main() { gl_Position = vec4(0.0, 0.0, 0.0, 1.0);}";
			std::string		  fs	  = GenShader<T>(stage, ms_and_1d, subroutine);
			const char* const glsl_fs = fs.c_str();
			m_program[0]			  = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs);
			m_program[1]			  = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &glsl_fs);
			glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]);
			glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, m_program[1]);
		}
		for (int i = 0; i < 3; ++i)
		{
			if (!CheckProgram(m_program[i]))
				return ERROR;
		}

		glBindTexture(GL_TEXTURE_2D, m_texture);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
		{
			ivec4 data[7];
			for (int i  = 0; i < 7; ++i)
				data[i] = ivec4(100000);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32I, 1, 7, 0, GL_RGBA_INTEGER, GL_INT, &data[0]);
		}
		glBindTexture(GL_TEXTURE_2D, 0);

		glBindImageTexture(0, m_texture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32I);
		glBindProgramPipeline(m_pipeline);
		glBindVertexArray(m_vertex_array);
		if (stage != 5)
		{
			glEnable(GL_RASTERIZER_DISCARD);
		}
		if (stage == 1 || stage == 2)
		{ // TCS or TES
			glPatchParameteri(GL_PATCH_VERTICES, 1);
			glDrawArrays(GL_PATCHES, 0, 1);
			glPatchParameteri(GL_PATCH_VERTICES, 3);
		}
		else if (stage == 4)
		{ // CS
			glDispatchCompute(1, 1, 1);
		}
		else
		{
			glDrawArrays(GL_POINTS, 0, 1);
		}
		glDisable(GL_RASTERIZER_DISCARD);

		glBindTexture(GL_TEXTURE_2D, m_texture);
		glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
		{
			ivec4 data[7];
			glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA_INTEGER, GL_INT, &data[0]);
			for (int i = 0; i < 7; ++i)
			{
				if (data[i] != expected_result[i])
				{
					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "Returned value is: (" << data[i][0] << " " << data[i][1] << " "
						<< data[i][2] << " " << data[i][3] << "). Expected value is: (" << expected_result[i][0] << " "
						<< expected_result[i][1] << " " << expected_result[i][2] << " " << expected_result[i][3]
						<< "). Image unit is: " << (i + 1) << tcu::TestLog::EndMessage;
					return ERROR;
				}
			}
		}
		return NO_ERROR;
	}
};
//=============================================================================
// 1.1.x.y BasicNonMS
//-----------------------------------------------------------------------------

template <typename T, int STAGE>
class BasicNonMS : public ShaderImageSizeBase
{
	GLuint m_texture[7];
	GLuint m_buffer;

	virtual long Setup()
	{
		glGenTextures(7, m_texture);
		glGenBuffers(1, &m_buffer);
		return NO_ERROR;
	}

	virtual long Run()
	{
		if (!SupportedInStage(STAGE, 8))
			return NOT_SUPPORTED;

		const GLenum target[7] = { GL_TEXTURE_2D,		 GL_TEXTURE_3D,
								   GL_TEXTURE_CUBE_MAP,  GL_TEXTURE_CUBE_MAP_ARRAY,
								   GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D_ARRAY,
								   GL_TEXTURE_BUFFER };
		for (int i = 0; i < 7; ++i)
		{
			glBindTexture(target[i], m_texture[i]);
			if (target[i] != GL_TEXTURE_BUFFER)
			{
				glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
				glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			}

			if (i == 0)
			{
				glTexStorage2D(target[i], 10, TexInternalFormat<T>(), 512, 128);
				glBindImageTexture(1, m_texture[i], 1, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 1)
			{
				glTexStorage3D(target[i], 3, TexInternalFormat<T>(), 8, 8, 4);
				glBindImageTexture(2, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 2)
			{
				glTexStorage2D(target[i], 4, TexInternalFormat<T>(), 16, 16);
				glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 0, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 3)
			{
				glTexStorage3D(target[i], 2, TexInternalFormat<T>(), 4, 4, 12);
				glBindImageTexture(4, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 4)
			{
				glTexStorage2D(target[i], 1, TexInternalFormat<T>(), 16, 8);
				glBindImageTexture(5, m_texture[i], 0, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 5)
			{
				glTexStorage3D(target[i], 3, TexInternalFormat<T>(), 127, 39, 12);
				glBindImageTexture(6, m_texture[i], 2, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 6)
			{
				std::vector<GLubyte> data(256);
				glBindBuffer(GL_TEXTURE_BUFFER, m_buffer);
				glBufferData(GL_TEXTURE_BUFFER, 256, &data[0], GL_STATIC_DRAW);
				glTexBuffer(GL_TEXTURE_BUFFER, TexInternalFormat<T>(), m_buffer);
				glBindImageTexture(7, m_texture[i], 0, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
		}
		ImageSizeMachine machine;
		ivec4			 res[7] = { ivec4(256, 64, 0, 0), ivec4(8, 8, 4, 0),   ivec4(16, 16, 0, 0), ivec4(2, 2, 2, 0),
						 ivec4(16, 8, 0, 0),   ivec4(31, 9, 12, 0), ivec4(16, 0, 0, 0) };
		return machine.Run<T>(STAGE, false, res);
	}

	virtual long Cleanup()
	{
		glDeleteTextures(7, m_texture);
		glDeleteBuffers(1, &m_buffer);
		return NO_ERROR;
	}
};
//=============================================================================
// 1.2.x.y BasicMS
//-----------------------------------------------------------------------------

template <typename T, int STAGE>
class BasicMS : public ShaderImageSizeBase
{
	GLuint m_texture[4];

	virtual long Setup()
	{
		glGenTextures(4, m_texture);
		return NO_ERROR;
	}

	virtual long Run()
	{
		if (!SupportedInStage(STAGE, 5))
			return NOT_SUPPORTED;
		if (!SupportedSamples(4))
			return NOT_SUPPORTED;

		const GLenum target[4] = { GL_TEXTURE_1D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_2D_MULTISAMPLE,
								   GL_TEXTURE_2D_MULTISAMPLE_ARRAY };
		for (int i = 0; i < 4; ++i)
		{
			glBindTexture(target[i], m_texture[i]);
			if (target[i] == GL_TEXTURE_1D || target[i] == GL_TEXTURE_1D_ARRAY)
			{
				glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
				glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			}

			if (i == 0)
			{
				glTexStorage1D(target[i], 10, TexInternalFormat<T>(), 512);
				glBindImageTexture(1, m_texture[i], 6, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 1)
			{
				glTexStorage2D(target[i], 3, TexInternalFormat<T>(), 15, 7);
				glBindImageTexture(2, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 2)
			{
				glTexImage2DMultisample(target[i], 4, TexInternalFormat<T>(), 17, 19, GL_FALSE);
				glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 0, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 3)
			{
				glTexImage3DMultisample(target[i], 4, TexInternalFormat<T>(), 64, 32, 5, GL_FALSE);
				glBindImageTexture(4, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
		}
		ImageSizeMachine machine;
		ivec4 res[7] = { ivec4(8, 0, 0, 0), ivec4(7, 7, 0, 0), ivec4(17, 19, 0, 0), ivec4(64, 32, 5, 0), ivec4(0),
						 ivec4(0),			ivec4(0) };
		return machine.Run<T>(STAGE, true, res);
	}

	virtual long Cleanup()
	{
		glDeleteTextures(4, m_texture);
		return NO_ERROR;
	}
};
//=============================================================================
// 2.1 AdvancedChangeSize
//-----------------------------------------------------------------------------
class AdvancedChangeSize : public ShaderImageSizeBase
{
	GLuint m_pipeline;
	GLuint m_program[2];
	GLuint m_vertex_array;
	GLuint m_texture[2];

	virtual long Setup()
	{
		glGenProgramPipelines(1, &m_pipeline);
		memset(m_program, 0, sizeof(m_program));
		glGenVertexArrays(1, &m_vertex_array);
		glGenTextures(2, m_texture);
		return NO_ERROR;
	}

	virtual long Run()
	{
		const char* const glsl_vs = "#version 430 core" NL "out gl_PerVertex { vec4 gl_Position; };" NL
									"const vec2 g_position[3] = { vec2(-1, -1), vec2(3, -1), vec2(-1, 3) };" NL
									"void main() { gl_Position = vec4(g_position[gl_VertexID], 0, 1); }";
		const char* const glsl_fs =
			"#version 430 core" NL "layout(location = 0) out vec4 g_color;" NL
			"layout(binding = 0, rgba8) uniform image2D g_image[2];" NL "uniform ivec2 g_expected_size[2];" NL
			"uniform int g_0 = 0, g_1 = 1;" NL "void main() {" NL "  vec4 c = vec4(0, 1, 0, 1);" NL
			"  if (imageSize(g_image[g_0]).xy != g_expected_size[g_0]) c = vec4(1, 0, 0, 1);" NL
			"  if (imageSize(g_image[g_1]).yx != g_expected_size[g_1]) c = vec4(1, 0, 0, 1);" NL "  g_color = c;" NL
			"}";
		m_program[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &glsl_vs);
		m_program[1] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &glsl_fs);
		for (int i = 0; i < 2; ++i)
			if (!CheckProgram(m_program[i]))
				return ERROR;

		glUseProgramStages(m_pipeline, GL_VERTEX_SHADER_BIT, m_program[0]);
		glUseProgramStages(m_pipeline, GL_FRAGMENT_SHADER_BIT, m_program[1]);

		glBindVertexArray(m_vertex_array);
		glBindProgramPipeline(m_pipeline);

		int size[2] = { 32, 128 };
		for (int i = 0; i < 2; ++i)
		{
			glBindTexture(GL_TEXTURE_2D, m_texture[i]);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size[i], size[i], 0, GL_RGBA, GL_FLOAT, NULL);
			glBindImageTexture(i, m_texture[i], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
		}

		for (int i = 0; i < 3; ++i)
		{
			glProgramUniform2i(m_program[1], glGetUniformLocation(m_program[1], "g_expected_size[0]"), size[0],
							   size[0]);
			glProgramUniform2i(m_program[1], glGetUniformLocation(m_program[1], "g_expected_size[1]"), size[1],
							   size[1]);
			glClear(GL_COLOR_BUFFER_BIT);
			glDrawArrays(GL_TRIANGLES, 0, 3);

			{
				bool			  status = true;
				std::vector<vec3> fb(getWindowWidth() * getWindowHeight());
				glReadPixels(0, 0, getWindowWidth(), getWindowHeight(), GL_RGB, GL_FLOAT, &fb[0][0]);
				if (!ValidateReadBuffer(0, 0, getWindowWidth(), getWindowHeight(), vec4(0, 1, 0, 1)))
					status = false;
				if (!status)
					return ERROR;
			}

			size[0] /= 2;
			size[1] /= 2;

			glBindTexture(GL_TEXTURE_2D, m_texture[0]);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size[0], size[0], 0, GL_RGBA, GL_FLOAT, NULL);
			glBindTexture(GL_TEXTURE_2D, m_texture[1]);
			glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, size[1], size[1], 0, GL_RGBA, GL_FLOAT, NULL);
		}
		return NO_ERROR;
	}

	virtual long Cleanup()
	{
		glDeleteProgramPipelines(1, &m_pipeline);
		for (int i = 0; i < 2; ++i)
			glDeleteProgram(m_program[i]);
		glDeleteVertexArrays(1, &m_vertex_array);
		glDeleteTextures(2, m_texture);
		return NO_ERROR;
	}
};
//=============================================================================
// 2.2.x.y AdvancedNonMS
//-----------------------------------------------------------------------------

template <typename T, int STAGE>
class AdvancedNonMS : public ShaderImageSizeBase
{
	GLuint m_texture[7];
	GLuint m_buffer;

	virtual long Setup()
	{
		glGenTextures(7, m_texture);
		glGenBuffers(1, &m_buffer);
		return NO_ERROR;
	}

	virtual long Run()
	{
		if (!SupportedInStage(STAGE, 8))
			return NOT_SUPPORTED;

		const GLenum target[7] = { GL_TEXTURE_2D_ARRAY,		  GL_TEXTURE_3D,		GL_TEXTURE_CUBE_MAP_ARRAY,
								   GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D_ARRAY,
								   GL_TEXTURE_BUFFER };
		for (int i = 0; i < 7; ++i)
		{
			glBindTexture(target[i], m_texture[i]);
			if (target[i] != GL_TEXTURE_BUFFER)
			{
				glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
				glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			}

			if (i == 0)
			{
				glTexImage3D(target[i], 0, TexInternalFormat<T>(), 2, 2, 7, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 1, TexInternalFormat<T>(), 1, 1, 7, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(1, m_texture[i], 1, GL_FALSE, 3, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 1)
			{
				glTexImage3D(target[i], 0, TexInternalFormat<T>(), 4, 4, 2, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 1, TexInternalFormat<T>(), 2, 2, 1, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 2, TexInternalFormat<T>(), 1, 1, 1, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(2, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 2)
			{
				glTexImage3D(target[i], 0, TexInternalFormat<T>(), 2, 2, 12, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 1, TexInternalFormat<T>(), 1, 1, 12, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 1, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 3)
			{
				glTexImage3D(target[i], 0, TexInternalFormat<T>(), 4, 4, 18, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 1, TexInternalFormat<T>(), 2, 2, 18, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 2, TexInternalFormat<T>(), 1, 1, 18, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(4, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 4)
			{
				glTexImage2D(target[i], 0, TexInternalFormat<T>(), 123, 11, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(5, m_texture[i], 0, GL_FALSE, 0, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 5)
			{
				glTexImage3D(target[i], 0, TexInternalFormat<T>(), 13, 7, 4, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 1, TexInternalFormat<T>(), 6, 3, 4, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 2, TexInternalFormat<T>(), 3, 1, 4, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage3D(target[i], 3, TexInternalFormat<T>(), 1, 1, 4, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(6, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 6)
			{
				glBindBuffer(GL_TEXTURE_BUFFER, m_buffer);
				glBufferData(GL_TEXTURE_BUFFER, 1024, NULL, GL_STATIC_DRAW);
				glTexBufferRange(GL_TEXTURE_BUFFER, TexInternalFormat<T>(), m_buffer, 256, 512);
				glBindImageTexture(7, m_texture[i], 0, GL_FALSE, 0, GL_WRITE_ONLY, TexInternalFormat<T>());
			}
		}
		ImageSizeMachine machine;
		ivec4			 res[7] = { ivec4(1, 1, 0, 0),	ivec4(2, 2, 1, 0), ivec4(2, 2, 0, 0), ivec4(2, 2, 3, 0),
						 ivec4(123, 11, 0, 0), ivec4(6, 3, 4, 0), ivec4(32, 0, 0, 0) };
		return machine.Run<T>(STAGE, false, res, true);
	}

	virtual long Cleanup()
	{
		glDeleteTextures(7, m_texture);
		glDeleteBuffers(1, &m_buffer);
		return NO_ERROR;
	}
};
//=============================================================================
// 2.3.x.y AdvancedMS
//-----------------------------------------------------------------------------
template <typename T, int STAGE>
class AdvancedMS : public ShaderImageSizeBase
{
	GLuint m_texture[4];

	virtual long Setup()
	{
		glGenTextures(4, m_texture);
		return NO_ERROR;
	}

	virtual long Run()
	{
		if (!SupportedInStage(STAGE, 5))
			return NOT_SUPPORTED;
		if (!SupportedSamples(4))
			return NOT_SUPPORTED;

		const GLenum target[4] = { GL_TEXTURE_1D, GL_TEXTURE_1D_ARRAY, GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
								   GL_TEXTURE_2D_MULTISAMPLE_ARRAY };
		for (int i = 0; i < 4; ++i)
		{
			glBindTexture(target[i], m_texture[i]);
			if (target[i] == GL_TEXTURE_1D || target[i] == GL_TEXTURE_1D_ARRAY)
			{
				glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
				glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			}

			if (i == 0)
			{
				glTexImage1D(target[i], 0, TexInternalFormat<T>(), 7, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage1D(target[i], 1, TexInternalFormat<T>(), 3, 0, TexFormat<T>(), TexType<T>(), NULL);
				glTexImage1D(target[i], 2, TexInternalFormat<T>(), 1, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(1, m_texture[i], 1, GL_FALSE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 1)
			{
				glTexImage2D(target[i], 0, TexInternalFormat<T>(), 7, 15, 0, TexFormat<T>(), TexType<T>(), NULL);
				glBindImageTexture(2, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 2)
			{
				glTexImage3DMultisample(target[i], 4, TexInternalFormat<T>(), 7, 9, 3, GL_FALSE);
				glBindImageTexture(3, m_texture[i], 0, GL_FALSE, 1, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 3)
			{
				glTexImage3DMultisample(target[i], 4, TexInternalFormat<T>(), 64, 32, 5, GL_FALSE);
				glBindImageTexture(4, m_texture[i], 0, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
		}
		ImageSizeMachine machine;
		ivec4			 res[7] = { ivec4(3, 0, 0, 0), ivec4(7, 15, 0, 0), ivec4(7, 9, 0, 0), ivec4(64, 32, 5, 0),
						 ivec4(0),			ivec4(0),			ivec4(0) };
		return machine.Run<T>(STAGE, true, res, true);
	}

	virtual long Cleanup()
	{
		glDeleteTextures(4, m_texture);
		return NO_ERROR;
	}
};
//=============================================================================
// 4.1 NegativeCompileTime
//-----------------------------------------------------------------------------
class NegativeCompileTime : public ShaderImageSizeBase
{
	virtual long Run()
	{
		// '#extension GL_ARB_shader_image_size : require' is missing
		if (!Compile("#version 420 core" NL "layout(location = 0) out vec4 g_color;" NL
					 "layout(binding = 0, rg16f) uniform image2D g_image;" NL "uniform ivec2 g_expected_size;" NL
					 "void main() {" NL "  if (imageSize(g_image) == g_expected_size) g_color = vec4(0, 1, 0, 1);" NL
					 "  else g_color = vec4(1, 0, 0, 1);" NL "}"))
			return ERROR;
		// imageSize(sampler)
		if (!Compile("#version 430 core" NL "layout(location = 0) out vec4 g_color;" NL
					 "layout(binding = 0) uniform sampler2D g_sampler;" NL "uniform ivec2 g_expected_size;" NL
					 "void main() {" NL "  if (imageSize(g_sampler) == g_expected_size) g_color = vec4(0, 1, 0, 1);" NL
					 "  else g_color = vec4(1, 0, 0, 1);" NL "}"))
			return ERROR;
		return NO_ERROR;
	}

	bool Compile(const std::string& source)
	{
		const GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);

		const char* const src = source.c_str();
		glShaderSource(sh, 1, &src, NULL);
		glCompileShader(sh);

		GLchar log[1024];
		glGetShaderInfoLog(sh, sizeof(log), NULL, log);
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader Info Log:\n"
											<< log << tcu::TestLog::EndMessage;

		GLint status;
		glGetShaderiv(sh, GL_COMPILE_STATUS, &status);
		glDeleteShader(sh);

		if (status == GL_TRUE)
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Compilation should fail." << tcu::TestLog::EndMessage;
			return false;
		}
		return true;
	}
};

} // anonymous namespace

ShaderImageSizeTests::ShaderImageSizeTests(deqp::Context& context) : TestCaseGroup(context, "shader_image_size", "")
{
}

ShaderImageSizeTests::~ShaderImageSizeTests(void)
{
}

void ShaderImageSizeTests::init()
{
	using namespace deqp;
	addChild(new TestSubcase(m_context, "basic-nonMS-vs-float", TestSubcase::Create<BasicNonMS<vec4, 0> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-vs-int", TestSubcase::Create<BasicNonMS<ivec4, 0> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-vs-uint", TestSubcase::Create<BasicNonMS<uvec4, 0> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-tcs-float", TestSubcase::Create<BasicNonMS<vec4, 1> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-tcs-int", TestSubcase::Create<BasicNonMS<ivec4, 1> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-tcs-uint", TestSubcase::Create<BasicNonMS<uvec4, 1> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-tes-float", TestSubcase::Create<BasicNonMS<vec4, 2> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-tes-int", TestSubcase::Create<BasicNonMS<ivec4, 2> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-tes-uint", TestSubcase::Create<BasicNonMS<uvec4, 2> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-gs-float", TestSubcase::Create<BasicNonMS<vec4, 3> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-gs-int", TestSubcase::Create<BasicNonMS<ivec4, 3> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-gs-uint", TestSubcase::Create<BasicNonMS<uvec4, 3> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-fs-float", TestSubcase::Create<BasicNonMS<vec4, 5> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-fs-int", TestSubcase::Create<BasicNonMS<ivec4, 5> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-fs-uint", TestSubcase::Create<BasicNonMS<uvec4, 5> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-cs-float", TestSubcase::Create<BasicNonMS<vec4, 4> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-cs-int", TestSubcase::Create<BasicNonMS<ivec4, 4> >));
	addChild(new TestSubcase(m_context, "basic-nonMS-cs-uint", TestSubcase::Create<BasicNonMS<uvec4, 4> >));
	addChild(new TestSubcase(m_context, "basic-ms-vs-float", TestSubcase::Create<BasicMS<vec4, 0> >));
	addChild(new TestSubcase(m_context, "basic-ms-vs-int", TestSubcase::Create<BasicMS<ivec4, 0> >));
	addChild(new TestSubcase(m_context, "basic-ms-vs-uint", TestSubcase::Create<BasicMS<uvec4, 0> >));
	addChild(new TestSubcase(m_context, "basic-ms-tcs-float", TestSubcase::Create<BasicMS<vec4, 1> >));
	addChild(new TestSubcase(m_context, "basic-ms-tcs-int", TestSubcase::Create<BasicMS<ivec4, 1> >));
	addChild(new TestSubcase(m_context, "basic-ms-tcs-uint", TestSubcase::Create<BasicMS<uvec4, 1> >));
	addChild(new TestSubcase(m_context, "basic-ms-tes-float", TestSubcase::Create<BasicMS<vec4, 2> >));
	addChild(new TestSubcase(m_context, "basic-ms-tes-int", TestSubcase::Create<BasicMS<ivec4, 2> >));
	addChild(new TestSubcase(m_context, "basic-ms-tes-uint", TestSubcase::Create<BasicMS<uvec4, 2> >));
	addChild(new TestSubcase(m_context, "basic-ms-gs-float", TestSubcase::Create<BasicMS<vec4, 3> >));
	addChild(new TestSubcase(m_context, "basic-ms-gs-int", TestSubcase::Create<BasicMS<ivec4, 3> >));
	addChild(new TestSubcase(m_context, "basic-ms-gs-uint", TestSubcase::Create<BasicMS<uvec4, 3> >));
	addChild(new TestSubcase(m_context, "basic-ms-fs-float", TestSubcase::Create<BasicMS<vec4, 5> >));
	addChild(new TestSubcase(m_context, "basic-ms-fs-int", TestSubcase::Create<BasicMS<ivec4, 5> >));
	addChild(new TestSubcase(m_context, "basic-ms-fs-uint", TestSubcase::Create<BasicMS<uvec4, 5> >));
	addChild(new TestSubcase(m_context, "basic-ms-cs-float", TestSubcase::Create<BasicMS<vec4, 4> >));
	addChild(new TestSubcase(m_context, "basic-ms-cs-int", TestSubcase::Create<BasicMS<ivec4, 4> >));
	addChild(new TestSubcase(m_context, "basic-ms-cs-uint", TestSubcase::Create<BasicMS<uvec4, 4> >));
	addChild(new TestSubcase(m_context, "advanced-changeSize", TestSubcase::Create<AdvancedChangeSize>));
	addChild(new TestSubcase(m_context, "advanced-nonMS-vs-float", TestSubcase::Create<AdvancedNonMS<vec4, 0> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-vs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 0> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-vs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 0> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-tcs-float", TestSubcase::Create<AdvancedNonMS<vec4, 1> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-tcs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 1> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-tcs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 1> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-tes-float", TestSubcase::Create<AdvancedNonMS<vec4, 2> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-tes-int", TestSubcase::Create<AdvancedNonMS<ivec4, 2> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-tes-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 2> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-gs-float", TestSubcase::Create<AdvancedNonMS<vec4, 3> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-gs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 3> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-gs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 3> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-fs-float", TestSubcase::Create<AdvancedNonMS<vec4, 5> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-fs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 5> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-fs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 5> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-cs-float", TestSubcase::Create<AdvancedNonMS<vec4, 4> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-cs-int", TestSubcase::Create<AdvancedNonMS<ivec4, 4> >));
	addChild(new TestSubcase(m_context, "advanced-nonMS-cs-uint", TestSubcase::Create<AdvancedNonMS<uvec4, 4> >));
	addChild(new TestSubcase(m_context, "advanced-ms-vs-float", TestSubcase::Create<AdvancedMS<vec4, 0> >));
	addChild(new TestSubcase(m_context, "advanced-ms-vs-int", TestSubcase::Create<AdvancedMS<ivec4, 0> >));
	addChild(new TestSubcase(m_context, "advanced-ms-vs-uint", TestSubcase::Create<AdvancedMS<uvec4, 0> >));
	addChild(new TestSubcase(m_context, "advanced-ms-tcs-float", TestSubcase::Create<AdvancedMS<vec4, 1> >));
	addChild(new TestSubcase(m_context, "advanced-ms-tcs-int", TestSubcase::Create<AdvancedMS<ivec4, 1> >));
	addChild(new TestSubcase(m_context, "advanced-ms-tcs-uint", TestSubcase::Create<AdvancedMS<uvec4, 1> >));
	addChild(new TestSubcase(m_context, "advanced-ms-tes-float", TestSubcase::Create<AdvancedMS<vec4, 2> >));
	addChild(new TestSubcase(m_context, "advanced-ms-tes-int", TestSubcase::Create<AdvancedMS<ivec4, 2> >));
	addChild(new TestSubcase(m_context, "advanced-ms-tes-uint", TestSubcase::Create<AdvancedMS<uvec4, 2> >));
	addChild(new TestSubcase(m_context, "advanced-ms-gs-float", TestSubcase::Create<AdvancedMS<vec4, 3> >));
	addChild(new TestSubcase(m_context, "advanced-ms-gs-int", TestSubcase::Create<AdvancedMS<ivec4, 3> >));
	addChild(new TestSubcase(m_context, "advanced-ms-gs-uint", TestSubcase::Create<AdvancedMS<uvec4, 3> >));
	addChild(new TestSubcase(m_context, "advanced-ms-fs-float", TestSubcase::Create<AdvancedMS<vec4, 5> >));
	addChild(new TestSubcase(m_context, "advanced-ms-fs-int", TestSubcase::Create<AdvancedMS<ivec4, 5> >));
	addChild(new TestSubcase(m_context, "advanced-ms-fs-uint", TestSubcase::Create<AdvancedMS<uvec4, 5> >));
	addChild(new TestSubcase(m_context, "advanced-ms-cs-float", TestSubcase::Create<AdvancedMS<vec4, 4> >));
	addChild(new TestSubcase(m_context, "advanced-ms-cs-int", TestSubcase::Create<AdvancedMS<ivec4, 4> >));
	addChild(new TestSubcase(m_context, "advanced-ms-cs-uint", TestSubcase::Create<AdvancedMS<uvec4, 4> >));
	addChild(new TestSubcase(m_context, "negative-compileTime", TestSubcase::Create<NegativeCompileTime>));
}

} // namespace gl4cts