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

namespace glcts
{
using namespace glw;

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

const char* const kGLSLVer =
	"#version 310 es\n" NL "precision highp float;" NL "precision highp int;" NL "precision highp image2D;" NL
	"precision highp image3D;" NL "precision highp imageCube;" NL "precision highp image2DArray;" NL
	"precision highp iimage2D;" NL "precision highp iimage3D;" NL "precision highp iimageCube;" NL
	"precision highp iimage2DArray;" NL "precision highp uimage2D;" NL "precision highp uimage3D;" NL
	"precision highp uimageCube;" NL "precision highp uimage2DArray;";

class ShaderImageSizeBase : public glcts::SubcaseBase
{
public:
	virtual std::string Title()
	{
		return NL "";
	}
	virtual std::string Purpose()
	{
		return NL "";
	}
	virtual std::string Method()
	{
		return NL "";
	}
	virtual std::string PassCriteria()
	{
		return NL "";
	}
	bool IsVSFSAvailable(int requiredVS, int requiredFS)
	{
		GLint imagesVS, imagesFS;
		glGetIntegerv(GL_MAX_VERTEX_IMAGE_UNIFORMS, &imagesVS);
		glGetIntegerv(GL_MAX_FRAGMENT_IMAGE_UNIFORMS, &imagesFS);
		if (imagesVS >= requiredVS && imagesFS >= requiredFS)
			return true;
		else
		{
			std::ostringstream reason;
			reason << "Required " << requiredVS << " VS storage blocks but only " << imagesVS << " available."
				   << std::endl
				   << "Required " << requiredFS << " FS storage blocks but only " << imagesFS << " available."
				   << std::endl;
			OutputNotSupported(reason.str());
			return 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 <typename T>
GLenum TexFormat();

//=============================================================================
// ImageSizeMachine
//-----------------------------------------------------------------------------
class ImageSizeMachine : public glcts::GLWrapper
{
	GLuint m_pipeline;
	GLuint m_program[3];
	GLuint m_vertex_array;
	GLuint m_buffer;
	bool   pipeline;
	GLuint m_xfb_id;

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

	bool CompileShader(GLuint shader)
	{
		glCompileShader(shader);

		GLint status;
		glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
		if (status == GL_FALSE)
		{
			GLsizei length;
			GLchar  log[1024];
			glGetShaderInfoLog(shader, sizeof(log), &length, log);
			if (length > 1)
			{
				m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader Info Log:\n"
													<< log << tcu::TestLog::EndMessage;
			}
			return false;
		}
		return true;
	}

	bool LinkProgram(GLuint program)
	{
		glLinkProgram(program);

		GLint status;
		glGetProgramiv(program, GL_LINK_STATUS, &status);
		if (status == GL_FALSE)
		{
			GLsizei length;
			GLchar  log[1024];
			glGetProgramInfoLog(program, sizeof(log), &length, log);
			if (length > 1)
			{
				m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program Info Log:\n"
													<< log << tcu::TestLog::EndMessage;
			}
			return false;
		}
		return true;
	}

	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[2] = { kGLSLVer, cs.c_str() };
			glShaderSource(sh, 2, src, NULL);
			if (!CompileShader(sh))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << src[0] << src[1] << tcu::TestLog::EndMessage;
				return p;
			}
		}
		if (!LinkProgram(p))
		{
			if (!cs.empty())
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << kGLSLVer << cs << tcu::TestLog::EndMessage;
			return p;
		}

		return p;
	}

	GLuint BuildProgram(const char* src_vs, const char* src_fs, bool use_xfb, bool* result = NULL)
	{
		const GLuint p = glCreateProgram();

		if (src_vs)
		{
			GLuint sh = glCreateShader(GL_VERTEX_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			const char* const src[2] = { kGLSLVer, src_vs };
			glShaderSource(sh, 2, src, NULL);
			if (!CompileShader(sh))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << src[0] << src[1] << tcu::TestLog::EndMessage;
				if (result)
					*result = false;
				return p;
			}
		}
		if (src_fs)
		{
			GLuint sh = glCreateShader(GL_FRAGMENT_SHADER);
			glAttachShader(p, sh);
			glDeleteShader(sh);
			const char* const src[2] = { kGLSLVer, src_fs };
			glShaderSource(sh, 2, src, NULL);
			if (!CompileShader(sh))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << src[0] << src[1] << tcu::TestLog::EndMessage;
				if (result)
					*result = false;
				return p;
			}
		}
		if (use_xfb)
			SetupTransformFeedback(p);
		if (!LinkProgram(p))
		{
			if (src_vs)
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << kGLSLVer << src_vs << tcu::TestLog::EndMessage;
			if (src_fs)
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << kGLSLVer << src_fs << tcu::TestLog::EndMessage;
			if (result)
				*result = false;
			return p;
		}

		return p;
	}

	void SetupTransformFeedback(GLuint program)
	{
		const char* const varying_name = "count";
		glTransformFeedbackVaryings(program, 1, &varying_name, GL_INTERLEAVED_ATTRIBS);
	}

	inline bool Equal(const ivec4& result, const ivec4& expected)
	{
		if (expected[0] != result[0])
			return false;
		if (expected[1] != result[1])
			return false;
		if (expected[2] != result[2])
			return false;
		if (expected[3] != result[3])
			return false;
		return true;
	}

	template <typename T>
	std::string GenShader(int stage)
	{
		std::ostringstream os;
		os << NL "#define KSIZE 4";
		if (stage == 0)
		{ // VS uses transform feedback
			os << NL "flat out ivec4 count[KSIZE];";
		}
		else
		{ // CS + FS use SSBO
			os << NL "layout(std430) buffer OutputBuffer {" NL "  ivec4 count[KSIZE];" NL "};";
		}
		os << NL "layout(binding = 0, rgba32" << ImageFormatPostfix<T>() << ") readonly writeonly uniform highp "
		   << ImageTypePrefix<T>() << "image2D g_image_2d;" NL "layout(binding = 1, rgba32" << ImageFormatPostfix<T>()
		   << ") readonly writeonly uniform highp " << ImageTypePrefix<T>()
		   << "image3D g_image_3d;" NL "layout(binding = 2, rgba32" << ImageFormatPostfix<T>()
		   << ") readonly writeonly uniform highp " << ImageTypePrefix<T>()
		   << "imageCube g_image_cube;" NL "layout(binding = 3, rgba32" << ImageFormatPostfix<T>()
		   << ") readonly writeonly uniform highp " << ImageTypePrefix<T>() << "image2DArray g_image_2d_array;";
		if (stage == 0)
		{ // VS
			os << NL "void main() {" NL "  int coord = gl_VertexID;" NL "#ifdef GL_ES" NL "  gl_PointSize = 1.0;" NL
					 "#endif";
		}
		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 "uniform int fakePrimitiveID;" NL "void main() {" NL "  int coord = fakePrimitiveID;";
		}
		os << NL "  count[coord + 0] = ivec4(imageSize(g_image_2d), 0, 0);" NL
				 "  count[coord + 1] = ivec4(imageSize(g_image_3d), 0);" NL
				 "  count[coord + 2] = ivec4(imageSize(g_image_cube), 0, 0);" NL
				 "  count[coord + 3] = ivec4(imageSize(g_image_2d_array), 0);" NL "}";
		return os.str();
	}

public:
	ImageSizeMachine() : pipeline(false)
	{
		if (pipeline)
			glGenProgramPipelines(1, &m_pipeline);
		memset(m_program, 0, sizeof(m_program));
		glGenVertexArrays(1, &m_vertex_array);
		glGenBuffers(1, &m_buffer);
		glGenTransformFeedbacks(1, &m_xfb_id);
	}

	~ImageSizeMachine()
	{
		if (pipeline)
		{
			glDeleteProgramPipelines(1, &m_pipeline);
			for (int i = 0; i < 3; ++i)
				glDeleteProgram(m_program[i]);
		}
		else
		{
			glDeleteProgram(m_program[0]);
		}
		glDeleteVertexArrays(1, &m_vertex_array);
		glDeleteBuffers(1, &m_buffer);
		glDeleteTransformFeedbacks(1, &m_xfb_id);
	}

	template <typename T>
	long Run(int stage, ivec4 expected_result[4])
	{
		const int kSize = 4;
		if (stage == 0)
		{ // VS
			glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_xfb_id);
			const char* const glsl_fs = NL "void main() {" NL "  discard;" NL "}";
			std::string		  vs	  = GenShader<T>(stage);
			const char* const glsl_vs = vs.c_str();
			if (pipeline)
			{
				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]);
			}
			else
			{
				m_program[0] = BuildProgram(glsl_vs, glsl_fs, true);
			}
		}
		else if (stage == 4)
		{ // CS
			std::string		  cs	  = GenShader<T>(stage);
			const char* const glsl_cs = cs.c_str();
			if (pipeline)
			{
				m_program[0] = glCreateShaderProgramv(GL_COMPUTE_SHADER, 1, &glsl_cs);
				glUseProgramStages(m_pipeline, GL_COMPUTE_SHADER_BIT, m_program[0]);
			}
			else
			{
				m_program[0] = CreateComputeProgram(glsl_cs);
			}
		}
		else if (stage == 5)
		{ // FS
			const char* const glsl_vs =
				NL "layout(location = 0) in vec4 i_position;" NL "void main() {" NL "  gl_Position = i_position;" NL
				   "#ifdef GL_ES" NL "  gl_PointSize = 1.0;" NL "#endif" NL "}";
			std::string		  fs	  = GenShader<T>(stage);
			const char* const glsl_fs = fs.c_str();
			if (pipeline)
			{
				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]);
			}
			else
			{
				m_program[0] = BuildProgram(glsl_vs, glsl_fs, false);
			}
		}
		if (!CheckProgram(m_program[0]))
			return ERROR;
		if (pipeline)
			if (!CheckProgram(m_program[1]))
				return ERROR;

		ivec4 data[kSize];
		for (int i  = 0; i < kSize; ++i)
			data[i] = ivec4(100000);

		GLenum output_buffer_type = (stage == 0) ? GL_TRANSFORM_FEEDBACK_BUFFER : GL_SHADER_STORAGE_BUFFER;

		glBindBufferBase(output_buffer_type, 0, m_buffer);
		glBufferData(output_buffer_type, kSize * 4 * 4, &data[0], GL_STATIC_DRAW);

		if (pipeline)
			glBindProgramPipeline(m_pipeline);
		else
			glUseProgram(m_program[0]);
		glBindVertexArray(m_vertex_array);

		if (stage == 0)
			glBeginTransformFeedback(GL_POINTS);

		if (stage == 4)
			glDispatchCompute(1, 1, 1);
		else
			glDrawArrays(GL_POINTS, 0, 1);

		glMemoryBarrier(GL_BUFFER_UPDATE_BARRIER_BIT);

		if (stage == 0)
			glEndTransformFeedback();

		ivec4* map_data = (ivec4*)glMapBufferRange(output_buffer_type, 0, kSize * 4 * 4, GL_MAP_READ_BIT);
		for (int i = 0; i < kSize; ++i)
		{
			if (!Equal(map_data[i], expected_result[i]))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "Returned value is: (" << map_data[i][0] << " " << map_data[i][1] << " "
					<< map_data[i][2] << " " << map_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 << tcu::TestLog::EndMessage;
				return ERROR;
			}
		}
		glUnmapBuffer(output_buffer_type);

		if (stage == 0)
			glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);

		return NO_ERROR;
	}
};

//=============================================================================
// 1.1.x.y BasicNonMS
//-----------------------------------------------------------------------------
template <typename T, int STAGE>
class BasicNonMS : public ShaderImageSizeBase
{
	GLuint m_texture[4];

	virtual long Setup()
	{
		glGenTextures(4, m_texture);
		return NO_ERROR;
	}
	virtual long Run()
	{
		if (STAGE == 0 && !IsVSFSAvailable(4, 0))
			return NOT_SUPPORTED;
		if (STAGE == 5 && !IsVSFSAvailable(0, 4))
			return NOT_SUPPORTED;

		const GLenum target[4] = { GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_2D_ARRAY };
		for (int i = 0; i < 4; ++i)
		{
			glBindTexture(target[i], m_texture[i]);
			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(0, 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(1, 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(2, m_texture[i], 0, GL_TRUE, 0, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 3)
			{
				glTexStorage3D(target[i], 3, TexInternalFormat<T>(), 127, 39, 12);
				glBindImageTexture(3, m_texture[i], 2, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
		}
		ImageSizeMachine machine;
		ivec4			 res[4] = { ivec4(256, 64, 0, 0), ivec4(8, 8, 4, 0), ivec4(16, 16, 0, 0), ivec4(31, 9, 12, 0) };
		return machine.Run<T>(STAGE, res);
	}
	virtual long Cleanup()
	{
		glDeleteTextures(4, m_texture);
		return NO_ERROR;
	}
};
//=============================================================================
// 2.2.x.y AdvancedNonMS
//-----------------------------------------------------------------------------
template <typename T, int STAGE>
class AdvancedNonMS : public ShaderImageSizeBase
{
	GLuint m_texture[4];

	virtual long Setup()
	{
		glGenTextures(4, m_texture);
		return NO_ERROR;
	}
	virtual long Run()
	{
		if (STAGE == 0 && !IsVSFSAvailable(4, 0))
			return NOT_SUPPORTED;
		if (STAGE == 5 && !IsVSFSAvailable(0, 4))
			return NOT_SUPPORTED;

		const GLenum target[4] = { GL_TEXTURE_2D_ARRAY, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_2D_ARRAY };
		for (int i = 0; i < 4; ++i)
		{
			glBindTexture(target[i], m_texture[i]);
			glTexParameteri(target[i], GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(target[i], GL_TEXTURE_MAG_FILTER, GL_NEAREST);

			if (i == 0)
			{
				glTexStorage3D(target[i], 2, TexInternalFormat<T>(), 2, 2, 7);
				glBindImageTexture(0, m_texture[i], 1, GL_FALSE, 3, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 1)
			{
				glTexStorage3D(target[i], 3, TexInternalFormat<T>(), 4, 4, 2);
				glBindImageTexture(1, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
			else if (i == 2)
			{
				glTexStorage2D(target[i], 2, TexInternalFormat<T>(), 2, 2);
				glBindImageTexture(2, m_texture[i], 0, GL_TRUE, 0, GL_READ_WRITE, TexInternalFormat<T>());
			}
			else if (i == 3)
			{
				glTexStorage3D(target[i], 4, TexInternalFormat<T>(), 13, 7, 4);
				glBindImageTexture(3, m_texture[i], 1, GL_TRUE, 0, GL_READ_ONLY, TexInternalFormat<T>());
			}
		}
		ImageSizeMachine machine;
		ivec4			 res[4] = { ivec4(1, 1, 0, 0), ivec4(2, 2, 1, 0), ivec4(2, 2, 0, 0), ivec4(6, 3, 4, 0) };
		return machine.Run<T>(STAGE, res);
	}
	virtual long Cleanup()
	{
		glDeleteTextures(4, m_texture);
		return NO_ERROR;
	}
};
//=============================================================================
// 4.1 NegativeCompileTime
//-----------------------------------------------------------------------------
class NegativeCompileTime : public ShaderImageSizeBase
{
	virtual long Run()
	{
		if (!Compile( // imagesize return type check
				"#version 310 es" NL "precision highp float;" NL "precision highp int;" NL
				"layout(local_size_x = 1) in;" NL "layout(r32f) uniform image2D g_image;" NL
				"layout(std430) buffer OutputBuffer { vec4 g_color; };" NL "void main() {" NL
				"  if (imageSize(g_image) == ivec3(5)) g_color = vec4(0, 1, 0, 1);" NL
				"  else g_color = vec4(1, 0, 0, 1);" NL "}"))
		{
			return ERROR;
		}
		if (!Compile( // imageSize(samplertype)
				"#version 310 es" NL "precision highp float;" NL "precision highp int;" NL
				"layout(local_size_x = 1) in;" NL "layout(r32f) uniform sampler2D g_image;" NL
				"layout(std430) buffer OutputBuffer { vec4 g_color; };" NL "void main() {" NL
				"  if (imageSize(g_image) == ivec2(5)) 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_COMPUTE_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(glcts::Context& context) : TestCaseGroup(context, "shader_image_size", "")
{
}

ShaderImageSizeTests::~ShaderImageSizeTests(void)
{
}

void ShaderImageSizeTests::init()
{
	using namespace glcts;
	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-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, "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-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, "negative-compileTime", TestSubcase::Create<NegativeCompileTime>));
}
}