modules/gles3/functional/es3fShaderApiTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 Module
 * -------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * 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 Shader API tests.
 *//*--------------------------------------------------------------------*/

#include "es3fShaderApiTests.hpp"
#include "es3fApiCase.hpp"
#include "tcuTestLog.hpp"

#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluShaderUtil.hpp"
#include "gluDrawUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluCallLogWrapper.hpp"

#include "glwFunctions.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"

#include "deString.h"

#include "deRandom.hpp"
#include "deStringUtil.hpp"

#include <string>
#include <sstream>
#include <vector>
#include <map>

using namespace glw; // GL types

namespace deqp
{
namespace gles3
{
namespace Functional
{

using tcu::TestLog;

namespace
{

enum ShaderSourceCaseFlags
{
	CASE_EXPLICIT_SOURCE_LENGTHS	= 1,
	CASE_RANDOM_NULL_TERMINATED		= 2
};

struct ShaderSources
{
	std::vector<std::string>	strings;
	std::vector<int>			lengths;
};

// Simple shaders

const char* getSimpleShaderSource (const glu::ShaderType shaderType)
{
	const char* simpleVertexShaderSource =
		"#version 300 es\n"
		"void main (void)\n"
		"{\n"
		"	gl_Position = vec4(0.0);\n"
		"}\n";

	const char* simpleFragmentShaderSource =
		"#version 300 es\n"
		"layout(location = 0) out mediump vec4 o_fragColor;\n"
		"void main (void)\n"
		"{\n"
		"	o_fragColor = vec4(0.0);\n"
		"}\n";

	switch (shaderType)
	{
		case glu::SHADERTYPE_VERTEX:
			return simpleVertexShaderSource;
		case glu::SHADERTYPE_FRAGMENT:
			return simpleFragmentShaderSource;
		default:
			DE_ASSERT(DE_FALSE);
	}

	return 0;
}

void setShaderSources (glu::Shader& shader, const ShaderSources& sources)
{
	std::vector<const char*> cStrings (sources.strings.size(), 0);

	for (size_t ndx = 0; ndx < sources.strings.size(); ndx++)
		cStrings[ndx] = sources.strings[ndx].c_str();

	if (sources.lengths.size() > 0)
		shader.setSources((int)cStrings.size(), &cStrings[0], &sources.lengths[0]);
	else
		shader.setSources((int)cStrings.size(), &cStrings[0], 0);
}

void sliceSourceString (const std::string& in, ShaderSources& out, const int numSlices, const size_t paddingLength = 0)
{
	DE_ASSERT(numSlices > 0);

	const size_t		sliceSize			= in.length() / numSlices;
	const size_t		sliceSizeRemainder	= in.length() - (sliceSize * numSlices);
	const std::string	padding				(paddingLength, 'E');

	for (int ndx = 0; ndx < numSlices; ndx++)
	{
		out.strings.push_back(in.substr(ndx * sliceSize, sliceSize) + padding);

		if (paddingLength > 0)
			out.lengths.push_back((int)sliceSize);
	}

	if (sliceSizeRemainder > 0)
	{
		const std::string	lastString			= in.substr(numSlices * sliceSize);
		const int			lastStringLength	= (int)lastString.length();

		out.strings.push_back(lastString + padding);

		if (paddingLength > 0)
			out.lengths.push_back(lastStringLength);
	}
}

void queryShaderInfo (glu::RenderContext& renderCtx, deUint32 shader, glu::ShaderInfo& info)
{
	const glw::Functions& gl = renderCtx.getFunctions();

	info.compileOk		= false;
	info.compileTimeUs	= 0;
	info.infoLog.clear();

	// Query source, status & log.
	{
		int	compileStatus	= 0;
		int sourceLen		= 0;
		int	infoLogLen		= 0;
		int	unusedLen;

		gl.getShaderiv(shader, GL_COMPILE_STATUS,			&compileStatus);
		gl.getShaderiv(shader, GL_SHADER_SOURCE_LENGTH,	&sourceLen);
		gl.getShaderiv(shader, GL_INFO_LOG_LENGTH,		&infoLogLen);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");

		info.compileOk = compileStatus != GL_FALSE;

		if (sourceLen > 0)
		{
			std::vector<char> source(sourceLen);
			gl.getShaderSource(shader, (int)source.size(), &unusedLen, &source[0]);
			info.source = std::string(&source[0], sourceLen);
		}

		if (infoLogLen > 0)
		{
			std::vector<char> infoLog(infoLogLen);
			gl.getShaderInfoLog(shader, (int)infoLog.size(), &unusedLen, &infoLog[0]);
			info.infoLog = std::string(&infoLog[0], infoLogLen);
		}
	}
}

// Draw test quad

void drawWithProgram (glu::RenderContext& renderCtx, deUint32 program)
{
	const glw::Functions& gl = renderCtx.getFunctions();

	const float position[] =
	{
		-1.0f, -1.0f,  0.0f, 1.0f,
		-1.0f, +1.0f,  0.0f, 1.0f,
		+1.0f, -1.0f,  0.0f, 1.0f,
		+1.0f, +1.0f,  0.0f, 1.0f
	};
	const deUint16 quadIndices[] = { 0, 1, 2, 2, 1, 3 };

	gl.useProgram(program);

	{
		glu::VertexArrayBinding vertexArrays[] =
		{
			glu::va::Float("a_position",	4, 4, 0, &position[0])
		};
		glu::draw(renderCtx, program, DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0], glu::pr::Triangles(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0]));
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "Draw test quad");
}

// Shader source generator

class SourceGenerator
{
public:
	virtual				~SourceGenerator	(void)	{}

	virtual std::string	next				(const glu::ShaderType shaderType)			= 0;
	virtual bool		finished			(const glu::ShaderType shaderType) const	= 0;
};

class ConstantShaderGenerator : public SourceGenerator
{
public:
				ConstantShaderGenerator		(de::Random& rnd)	: m_rnd(rnd)	{}
				~ConstantShaderGenerator	(void)								{}

	bool		finished					(const glu::ShaderType shaderType) const	{ DE_UNREF(shaderType); return false; }

	std::string	next						(const glu::ShaderType shaderType);

private:
	de::Random	m_rnd;
};

std::string ConstantShaderGenerator::next (const glu::ShaderType shaderType)
{
	DE_ASSERT(shaderType == glu::SHADERTYPE_VERTEX || shaderType == glu::SHADERTYPE_FRAGMENT);

	const float			value		= m_rnd.getFloat(0.0f, 1.0f);
	const std::string	valueString	= de::toString(value);
	const std::string	outputName	= (shaderType == glu::SHADERTYPE_VERTEX) ? "gl_Position" : "o_fragColor";

	std::ostringstream	out;

	out << "#version 300 es\n";

	if (shaderType == glu::SHADERTYPE_FRAGMENT)
		out << "layout(location = 0) out mediump vec4 o_fragColor;\n";

	out << "void main (void)\n";
	out << "{\n";
	out << "	" << outputName << " = vec4(" << valueString << ");\n";
	out << "}\n";

	return out.str();
}

// Shader allocation utility

class ShaderAllocator
{
public:
					ShaderAllocator		(glu::RenderContext& context, SourceGenerator& generator);
					~ShaderAllocator	(void);

	bool			hasShader			(const glu::ShaderType shaderType);

	void			setSource			(const glu::ShaderType shaderType);

	glu::Shader&	createShader		(const glu::ShaderType shaderType);
	void			deleteShader		(const glu::ShaderType shaderType);

	glu::Shader&	get					(const glu::ShaderType shaderType)	{ DE_ASSERT(hasShader(shaderType)); return *m_shaders[shaderType]; }

private:
	const glu::RenderContext&				m_context;
	SourceGenerator&						m_srcGen;
	std::map<glu::ShaderType, glu::Shader*>	m_shaders;
};

ShaderAllocator::ShaderAllocator (glu::RenderContext& context, SourceGenerator& generator)
	: m_context	(context)
	, m_srcGen	(generator)
{
}

ShaderAllocator::~ShaderAllocator (void)
{
	for (std::map<glu::ShaderType, glu::Shader*>::iterator shaderIter = m_shaders.begin(); shaderIter != m_shaders.end(); shaderIter++)
		delete shaderIter->second;
	m_shaders.clear();
}

bool ShaderAllocator::hasShader (const glu::ShaderType shaderType)
{
	if (m_shaders.find(shaderType) != m_shaders.end())
		return true;
	else
		return false;
}

glu::Shader& ShaderAllocator::createShader (const glu::ShaderType shaderType)
{
	DE_ASSERT(!this->hasShader(shaderType));

	glu::Shader* const	shader	= new glu::Shader(m_context, shaderType);

	m_shaders[shaderType] = shader;
	this->setSource(shaderType);

	return *shader;
}

void ShaderAllocator::deleteShader (const glu::ShaderType shaderType)
{
	DE_ASSERT(this->hasShader(shaderType));

	delete m_shaders[shaderType];
	m_shaders.erase(shaderType);
}

void ShaderAllocator::setSource (const glu::ShaderType shaderType)
{
	DE_ASSERT(this->hasShader(shaderType));
	DE_ASSERT(!m_srcGen.finished(shaderType));

	const std::string	source	= m_srcGen.next(shaderType);
	const char* const	cSource	= source.c_str();

	m_shaders[shaderType]->setSources(1, &cSource, 0);
}

// Logging utilities

void logShader (TestLog& log, glu::RenderContext& renderCtx, glu::Shader& shader)
{
	glu::ShaderInfo info;

	queryShaderInfo(renderCtx, shader.getShader(), info);

	log << TestLog::Shader(getLogShaderType(shader.getType()), info.source, info.compileOk, info.infoLog);
}

void logProgram (TestLog& log, glu::RenderContext& renderCtx, glu::Program& program, ShaderAllocator& shaders)
{
	log << TestLog::ShaderProgram(program.getLinkStatus(), program.getInfoLog());

	for (int shaderTypeInt = 0; shaderTypeInt < glu::SHADERTYPE_LAST; shaderTypeInt++)
	{
		const glu::ShaderType shaderType = (glu::ShaderType)shaderTypeInt;

		if (shaders.hasShader(shaderType))
			logShader(log, renderCtx, shaders.get(shaderType));
	}

	log << TestLog::EndShaderProgram;
}

void logVertexFragmentProgram (TestLog& log, glu::RenderContext& renderCtx, glu::Program& program, glu::Shader& vertShader, glu::Shader& fragShader)
{
	DE_ASSERT(vertShader.getType() == glu::SHADERTYPE_VERTEX && fragShader.getType() == glu::SHADERTYPE_FRAGMENT);

	log << TestLog::ShaderProgram(program.getLinkStatus(), program.getInfoLog());

	logShader(log, renderCtx, vertShader);
	logShader(log, renderCtx, fragShader);

	log << TestLog::EndShaderProgram;
}

} // anonymous

// Simple glCreateShader() case

class CreateShaderCase : public ApiCase
{
public:
	CreateShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ApiCase		(context, name, desc)
		, m_shaderType	(shaderType)
	{
	}

	void test (void)
	{
		const GLuint shaderObject = glCreateShader(glu::getGLShaderType(m_shaderType));

		TCU_CHECK(shaderObject != 0);

		glDeleteShader(shaderObject);
	}

private:
	const glu::ShaderType m_shaderType;
};

// Simple glCompileShader() case

class CompileShaderCase : public ApiCase
{
public:
	CompileShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ApiCase		(context, name, desc)
		, m_shaderType	(shaderType)
	{
	}

	bool checkCompileStatus (const GLuint shaderObject)
	{
		GLint compileStatus = -1;
		glGetShaderiv(shaderObject, GL_COMPILE_STATUS, &compileStatus);
		GLU_CHECK();

		return (compileStatus == GL_TRUE);
	}

	void test (void)
	{
		const char*		shaderSource	= getSimpleShaderSource(m_shaderType);
		const GLuint	shaderObject	= glCreateShader(glu::getGLShaderType(m_shaderType));

		TCU_CHECK(shaderObject != 0);

		glShaderSource(shaderObject, 1, &shaderSource, 0);
		glCompileShader(shaderObject);

		TCU_CHECK(checkCompileStatus(shaderObject));

		glDeleteShader(shaderObject);
	}

private:
	const glu::ShaderType m_shaderType;
};

// Base class for simple program API tests

class SimpleProgramCase : public ApiCase
{
public:
	SimpleProgramCase (Context& context, const char* name, const char* desc)
		: ApiCase		(context, name, desc)
		, m_vertShader	(0)
		, m_fragShader	(0)
		, m_program		(0)
	{
	}

	virtual ~SimpleProgramCase (void)
	{
	}

	virtual void compileShaders (void)
	{
		const char*		vertSource	= getSimpleShaderSource(glu::SHADERTYPE_VERTEX);
		const char*		fragSource	= getSimpleShaderSource(glu::SHADERTYPE_FRAGMENT);

		const GLuint	vertShader	= glCreateShader(GL_VERTEX_SHADER);
		const GLuint	fragShader	= glCreateShader(GL_FRAGMENT_SHADER);

		TCU_CHECK(vertShader != 0);
		TCU_CHECK(fragShader != 0);

		glShaderSource(vertShader, 1, &vertSource, 0);
		glCompileShader(vertShader);

		glShaderSource(fragShader, 1, &fragSource, 0);
		glCompileShader(fragShader);

		GLU_CHECK();

		m_vertShader = vertShader;
		m_fragShader = fragShader;
	}

	void linkProgram (void)
	{
		const GLuint program = glCreateProgram();

		TCU_CHECK(program != 0);

		glAttachShader(program, m_vertShader);
		glAttachShader(program, m_fragShader);
		GLU_CHECK();

		glLinkProgram(program);

		m_program = program;
	}

	void cleanup (void)
	{
		glDeleteShader(m_vertShader);
		glDeleteShader(m_fragShader);
		glDeleteProgram(m_program);
	}

protected:
	GLuint	m_vertShader;
	GLuint	m_fragShader;
	GLuint	m_program;
};

// glDeleteShader() case

class DeleteShaderCase : public SimpleProgramCase
{
public:
	DeleteShaderCase (Context& context, const char* name, const char* desc)
		: SimpleProgramCase (context, name, desc)
	{
	}

	bool checkDeleteStatus(GLuint shader)
	{
		GLint deleteStatus = -1;
		glGetShaderiv(shader, GL_DELETE_STATUS, &deleteStatus);
		GLU_CHECK();

		return (deleteStatus == GL_TRUE);
	}

	void deleteShaders (void)
	{
		glDeleteShader(m_vertShader);
		glDeleteShader(m_fragShader);
		GLU_CHECK();
	}

	void test (void)
	{
		compileShaders();
		linkProgram();
		GLU_CHECK();

		deleteShaders();

		TCU_CHECK(checkDeleteStatus(m_vertShader) && checkDeleteStatus(m_fragShader));

		glDeleteProgram(m_program);

		TCU_CHECK(!(glIsShader(m_vertShader) || glIsShader(m_fragShader)));
	}
};

// Simple glLinkProgram() case

class LinkVertexFragmentCase : public SimpleProgramCase
{
public:
	LinkVertexFragmentCase (Context& context, const char* name, const char* desc)
		: SimpleProgramCase (context, name, desc)
	{
	}

	bool checkLinkStatus (const GLuint programObject)
	{
		GLint linkStatus = -1;
		glGetProgramiv(programObject, GL_LINK_STATUS, &linkStatus);
		GLU_CHECK();

		return (linkStatus == GL_TRUE);
	}

	void test (void)
	{
		compileShaders();
		linkProgram();

		GLU_CHECK_MSG("Linking failed.");
		TCU_CHECK_MSG(checkLinkStatus(m_program), "Fail, expected LINK_STATUS to be TRUE.");

		cleanup();
	}
};

class ShaderSourceReplaceCase : public ApiCase
{
public:
	ShaderSourceReplaceCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ApiCase		(context, name, desc)
		, m_shaderType	(shaderType)
	{
	}

	std::string generateFirstSource (void)
	{
		return getSimpleShaderSource(m_shaderType);
	}

	std::string generateSecondSource (void)
	{
		std::ostringstream out;

		out << "#version 300 es\n";
		out << "precision mediump float;\n";

		if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
			out << "layout(location = 0) out mediump vec4 o_fragColor;\n";

		out << "void main()\n";
		out << "{\n";
		out << "	float variable = 1.0f;\n";

		if		(m_shaderType == glu::SHADERTYPE_VERTEX)	out << "	gl_Position = vec4(variable);\n";
		else if	(m_shaderType == glu::SHADERTYPE_FRAGMENT)	out << "	o_fragColor = vec4(variable);\n";

		out << "}\n";

		return out.str();
	}

	GLint getSourceLength (glu::Shader& shader)
	{
		GLint sourceLength = 0;
		glGetShaderiv(shader.getShader(), GL_SHADER_SOURCE_LENGTH, &sourceLength);
		GLU_CHECK();

		return sourceLength;
	}

	std::string readSource (glu::Shader& shader)
	{
		const GLint			sourceLength	= getSourceLength(shader);
		std::vector<char>	sourceBuffer	(sourceLength + 1);

		glGetShaderSource(shader.getShader(), (GLsizei)sourceBuffer.size(), 0, &sourceBuffer[0]);

		return std::string(&sourceBuffer[0]);
	}

	void verifyShaderSourceReplaced (glu::Shader& shader, const std::string& firstSource, const std::string& secondSource)
	{
		TestLog&			log		= m_testCtx.getLog();
		const std::string	result	= readSource(shader);

		if (result == firstSource)
		{
			log << TestLog::Message << "Fail, source was not replaced." << TestLog::EndMessage;
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader source nor replaced");
		}
		else if (result != secondSource)
		{
			log << TestLog::Message << "Fail, invalid shader source." << TestLog::EndMessage;
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid source");
		}
	}

	void test (void)
	{
		TestLog&			log				= m_testCtx.getLog();

		glu::Shader			shader			(m_context.getRenderContext(), m_shaderType);

		const std::string	firstSourceStr	= generateFirstSource();
		const std::string	secondSourceStr	= generateSecondSource();

		const char*			firstSource		= firstSourceStr.c_str();
		const char*			secondSource	= secondSourceStr.c_str();

		log << TestLog::Message << "Setting shader source." << TestLog::EndMessage;

		shader.setSources(1, &firstSource, 0);
		GLU_CHECK();

		log << TestLog::Message << "Replacing shader source." << TestLog::EndMessage;

		shader.setSources(1, &secondSource, 0);
		GLU_CHECK();

		verifyShaderSourceReplaced(shader, firstSourceStr, secondSourceStr);
	}

private:
	glu::ShaderType	m_shaderType;
};

// glShaderSource() split source case

class ShaderSourceSplitCase : public ApiCase
{
public:
	ShaderSourceSplitCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType, const int numSlices, const deUint32 flags = 0)
		: ApiCase			(context, name, desc)
		, m_rnd				(deStringHash(getName()) ^ 0x4fb2337d)
		, m_shaderType		(shaderType)
		, m_numSlices		(numSlices)
		, m_explicitLengths	((flags & CASE_EXPLICIT_SOURCE_LENGTHS)	!= 0)
		, m_randomNullTerm	((flags & CASE_RANDOM_NULL_TERMINATED)	!= 0)
	{
		DE_ASSERT(m_shaderType == glu::SHADERTYPE_VERTEX || m_shaderType == glu::SHADERTYPE_FRAGMENT);
	}

	virtual ~ShaderSourceSplitCase (void)
	{
	}

	std::string generateFullSource (void)
	{
		std::ostringstream out;

		out << "#version 300 es\n";
		out << "precision mediump float;\n";

		if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
			out << "layout(location = 0) out mediump vec4 o_fragColor;\n";

		out << "void main()\n";
		out << "{\n";
		out << "	float variable = 1.0f;\n";

		if		(m_shaderType == glu::SHADERTYPE_VERTEX)	out << "	gl_Position = vec4(variable);\n";
		else if	(m_shaderType == glu::SHADERTYPE_FRAGMENT)	out << "	o_fragColor = vec4(variable);\n";

		out << "}\n";

		return out.str();
	}

	void insertRandomNullTermStrings (ShaderSources& sources)
	{
		const int			numInserts	= de::max(m_numSlices >> 2, 1);
		std::vector<int>	indices		(sources.strings.size(), 0);

		DE_ASSERT(sources.lengths.size() > 0);
		DE_ASSERT(sources.lengths.size() == sources.strings.size());

		for (int i = 0; i < (int)sources.strings.size(); i++)
			indices[i] = i;

		m_rnd.shuffle(indices.begin(), indices.end());

		for (int i = 0; i < numInserts; i++)
		{
			const int			ndx				= indices[i];
			const int			unpaddedLength	= sources.lengths[ndx];
			const std::string	unpaddedString	= sources.strings[ndx].substr(0, unpaddedLength);

			sources.strings[ndx] = unpaddedString;
			sources.lengths[ndx] = m_rnd.getInt(-10, -1);
		}
	}

	void generateSources (ShaderSources& sources)
	{
		const size_t	paddingLength	= (m_explicitLengths ? 10 : 0);
		std::string		str				= generateFullSource();

		sliceSourceString(str, sources, m_numSlices, paddingLength);

		if (m_randomNullTerm)
			insertRandomNullTermStrings(sources);
	}

	void buildProgram (glu::Shader& shader)
	{
		TestLog&				log					= m_testCtx.getLog();
		glu::RenderContext&		renderCtx			= m_context.getRenderContext();

		const glu::ShaderType	supportShaderType	= (m_shaderType == glu::SHADERTYPE_FRAGMENT ? glu::SHADERTYPE_VERTEX : glu::SHADERTYPE_FRAGMENT);
		const char*				supportShaderSource	= getSimpleShaderSource(supportShaderType);
		glu::Shader				supportShader		(renderCtx, supportShaderType);

		glu::Program			program				(renderCtx);

		supportShader.setSources(1, &supportShaderSource, 0);
		supportShader.compile();

		program.attachShader(shader.getShader());
		program.attachShader(supportShader.getShader());

		program.link();

		if (m_shaderType == glu::SHADERTYPE_VERTEX)
			logVertexFragmentProgram(log, renderCtx, program, shader, supportShader);
		else
			logVertexFragmentProgram(log, renderCtx, program, supportShader, shader);
	}

	void test (void)
	{
		TestLog&			log			= m_testCtx.getLog();
		glu::RenderContext&	renderCtx	= m_context.getRenderContext();

		ShaderSources		sources;
		glu::Shader			shader		(renderCtx, m_shaderType);

		generateSources(sources);
		setShaderSources(shader, sources);
		shader.compile();

		buildProgram(shader);

		if (!shader.getCompileStatus())
		{
			log << TestLog::Message << "Compilation failed." << TestLog::EndMessage;
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed");
		}
	}

private:
	de::Random				m_rnd;

	const glu::ShaderType	m_shaderType;
	const int				m_numSlices;

	const bool				m_explicitLengths;
	const bool				m_randomNullTerm;
};

// Base class for program state persistence cases

class ProgramStateCase : public ApiCase
{
public:
					ProgramStateCase	(Context& context, const char* name, const char* desc, glu::ShaderType shaderType);
	virtual			~ProgramStateCase	(void)	{}

	void			buildProgram		(glu::Program& program, ShaderAllocator& shaders);
	void			verify				(glu::Program& program, const glu::ProgramInfo& reference);

	void			test				(void);

	virtual void	executeForProgram	(glu::Program& program, ShaderAllocator& shaders)	= 0;

protected:
	de::Random					m_rnd;
	const glu::ShaderType		m_shaderType;
};

ProgramStateCase::ProgramStateCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
	: ApiCase		(context, name, desc)
	, m_rnd			(deStringHash(name) ^ 0x713de0ca)
	, m_shaderType	(shaderType)
{
	DE_ASSERT(m_shaderType == glu::SHADERTYPE_VERTEX || m_shaderType == glu::SHADERTYPE_FRAGMENT);
}

void ProgramStateCase::buildProgram (glu::Program& program, ShaderAllocator& shaders)
{
	TestLog&		log			= m_testCtx.getLog();

	glu::Shader&	vertShader	= shaders.createShader(glu::SHADERTYPE_VERTEX);
	glu::Shader&	fragShader	= shaders.createShader(glu::SHADERTYPE_FRAGMENT);

	vertShader.compile();
	fragShader.compile();

	program.attachShader(vertShader.getShader());
	program.attachShader(fragShader.getShader());
	program.link();

	logProgram(log, m_context.getRenderContext(), program, shaders);
}

void ProgramStateCase::verify (glu::Program& program, const glu::ProgramInfo& reference)
{
	TestLog&				log			= m_testCtx.getLog();
	const glu::ProgramInfo&	programInfo	= program.getInfo();

	if (!programInfo.linkOk)
	{
		log << TestLog::Message << "Fail, link status may only change as a result of linking or loading a program binary." << TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Link status changed");
	}

	if (programInfo.linkTimeUs != reference.linkTimeUs)
	{
		log << TestLog::Message << "Fail, reported link time changed." << TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Link time changed");
	}

	if (programInfo.infoLog != reference.infoLog)
	{
		log << TestLog::Message << "Fail, program infolog changed." << TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Infolog changed");
	}
}

void ProgramStateCase::test (void)
{
	TestLog&				log			= m_testCtx.getLog();
	glu::RenderContext&		renderCtx	= m_context.getRenderContext();

	ConstantShaderGenerator	sourceGen	(m_rnd);

	ShaderAllocator			shaders		(renderCtx, sourceGen);
	glu::Program			program		(renderCtx);

	buildProgram(program, shaders);

	if (program.getLinkStatus())
	{
		glu::ProgramInfo programInfo = program.getInfo();

		executeForProgram(program, shaders);

		verify(program, programInfo);

		logProgram(log, renderCtx, program, shaders);
	}
	else
	{
		log << TestLog::Message << "Fail, couldn't link program." << TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Linking failed");
	}
}

// Program state case utilities

namespace
{

template<class T>
void addProgramStateCase (TestCaseGroup* group, Context& context, const std::string& name, const std::string& desc)
{
	for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
	{
		const glu::ShaderType	shaderType		= (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;
		const std::string		shaderTypeName	= getShaderTypeName(shaderType);

		const std::string		caseName		= name + "_" + shaderTypeName;
		const std::string		caseDesc		= "Build program, " + desc + ", for " + shaderTypeName + " shader.";

		group->addChild(new T(context, caseName.c_str(), caseDesc.c_str(), shaderType));
	}
}

} // anonymous

// Specialized program state cases

class ProgramStateDetachShaderCase : public ProgramStateCase
{
public:
	ProgramStateDetachShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramStateCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramStateDetachShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Detaching " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
	}
};

class ProgramStateReattachShaderCase : public ProgramStateCase
{
public:
	ProgramStateReattachShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramStateCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramStateReattachShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Reattaching " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
		program.attachShader(caseShader.getShader());
	}
};

class ProgramStateDeleteShaderCase : public ProgramStateCase
{
public:
	ProgramStateDeleteShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramStateCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramStateDeleteShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Deleting " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
		shaders.deleteShader(m_shaderType);
	}
};

class ProgramStateReplaceShaderCase : public ProgramStateCase
{
public:
	ProgramStateReplaceShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramStateCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramStateReplaceShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Deleting and replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
		shaders.deleteShader(m_shaderType);
		program.attachShader(shaders.createShader(m_shaderType).getShader());
	}
};

class ProgramStateRecompileShaderCase : public ProgramStateCase
{
public:
	ProgramStateRecompileShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramStateCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramStateRecompileShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Recompiling " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		caseShader.compile();
		DE_UNREF(program);
	}
};

class ProgramStateReplaceSourceCase : public ProgramStateCase
{
public:
	ProgramStateReplaceSourceCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramStateCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramStateReplaceSourceCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader source and recompiling" << TestLog::EndMessage;
		shaders.setSource(m_shaderType);
		caseShader.compile();
		DE_UNREF(program);
	}
};

// Program binary utilities

namespace
{

struct ProgramBinary
{
	GLenum					format;
	std::vector<deUint8>	data;
};

bool programBinariesEqual (const ProgramBinary& first, const ProgramBinary& second)
{
	if ((first.format != second.format) || (first.data.size() != second.data.size()))
		return false;

	return std::equal(first.data.begin(), first.data.end(), second.data.begin());
}

} // anonymous

// Base class for program binary cases

class ProgramBinaryCase : public TestCase, protected glu::CallLogWrapper
{
public:
							ProgramBinaryCase	(Context& context, const char* name, const char* desc);
	virtual					~ProgramBinaryCase	(void);

	void					getBinaryFormats	(std::vector<GLenum>& out);
	bool					isFormatSupported	(const glw::GLenum format) const;

	void					getProgramBinary	(ProgramBinary& out, GLuint program);
	void					loadProgramBinary	(ProgramBinary& binary, GLuint program);

	void					verifyProgramBinary	(ProgramBinary& binary);

	void					init				(void);
	IterateResult			iterate				(void);

	virtual void			test				(void) = 0;

protected:
	std::vector<GLenum>		m_formats;
};

ProgramBinaryCase::ProgramBinaryCase (Context& context, const char* name, const char* desc)
		: TestCase			(context, name, desc)
		, CallLogWrapper	(context.getRenderContext().getFunctions(), context.getTestContext().getLog())
{
}

ProgramBinaryCase::~ProgramBinaryCase (void)
{
}

void ProgramBinaryCase::getBinaryFormats (std::vector<GLenum>& out)
{
	GLint numFormats = -1;
	glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &numFormats);

	out.clear();

	if (numFormats > 0)
	{
		out.resize(numFormats, 0);

		glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, (GLint*)&out[0]);
	}
}

bool ProgramBinaryCase::isFormatSupported (const glw::GLenum format) const
{
	return (std::find(m_formats.begin(), m_formats.end(), format) != m_formats.end());
}

void ProgramBinaryCase::getProgramBinary (ProgramBinary& out, GLuint program)
{
	GLint binaryLength = -1;
	glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);

	if (binaryLength > 0)
	{
		GLsizei	actualLength;
		GLenum	format;

		out.data.clear();
		out.data.resize(binaryLength, 0);

		GLU_CHECK_CALL(glGetProgramBinary(program, (GLsizei)out.data.size(), &actualLength, &format, &(out.data[0])));

		TCU_CHECK(actualLength == binaryLength);

		out.format = format;
	}
}

void ProgramBinaryCase::loadProgramBinary (ProgramBinary& binary, GLuint program)
{
	glProgramBinary(program, binary.format, &binary.data[0], (GLsizei)binary.data.size());
	GLU_CHECK_MSG("Failed to load program binary.");
}

void ProgramBinaryCase::verifyProgramBinary (ProgramBinary& binary)
{
	TestLog& log = m_testCtx.getLog();

	if (!isFormatSupported(binary.format))
	{
		log << TestLog::Message << "Program binary format " << binary.format << " is not among the supported formats reported by the platform." << TestLog::EndMessage;

		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid format");
	}
}

void ProgramBinaryCase::init (void)
{
	getBinaryFormats(m_formats);
}

tcu::TestNode::IterateResult ProgramBinaryCase::iterate (void)
{
	TestLog&	log	= m_testCtx.getLog();

	if (m_formats.empty())
	{
		log << TestLog::Message << "No program binary formats are supported." << TestLog::EndMessage;

		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not supported");
	}
	else
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

		enableLogging(true);
		test();
	}

	return STOP;
}

// Simple program binary case

class ProgramBinarySimpleCase : public ProgramBinaryCase
{
public:
	ProgramBinarySimpleCase (Context& context, const char* name, const char* desc)
		: ProgramBinaryCase(context, name, desc)
	{
	}

	virtual ~ProgramBinarySimpleCase (void)
	{
	}

	void test (void)
	{
		const std::string			vertSrc	= getSimpleShaderSource(glu::SHADERTYPE_VERTEX);
		const std::string			fragSrc	= getSimpleShaderSource(glu::SHADERTYPE_FRAGMENT);

		const glu::ProgramSources	sources	= glu::makeVtxFragSources(vertSrc, fragSrc);

		glu::ShaderProgram			program	(m_context.getRenderContext(), sources);

		if (program.isOk())
		{
			ProgramBinary binary;

			getProgramBinary(binary, program.getProgram());
			verifyProgramBinary(binary);
		}
	}
};

// Program binary uniform reset case

class ProgramBinaryUniformResetCase : public ProgramBinaryCase
{
public:
	ProgramBinaryUniformResetCase (Context& context, const char* name, const char* desc)
		: ProgramBinaryCase	(context, name, desc)
		, m_rnd				(deStringHash(name) ^ 0xf2b48c6a)
	{
	}

	virtual ~ProgramBinaryUniformResetCase (void)
	{
	}

	std::string getShaderSource (const glu::ShaderType shaderType) const
	{
		const char* vertSrc =
			"#version 300 es\n"
			"uniform bool u_boolVar;\n"
			"uniform highp int u_intVar;\n"
			"uniform highp float u_floatVar;\n\n"
			"in highp vec4 a_position;\n\n"
			"void main (void)\n"
			"{\n"
			"	gl_Position = a_position;\n"
			"}\n";
		const char* fragSrc =
			"#version 300 es\n"
			"uniform bool u_boolVar;\n"
			"uniform highp int u_intVar;\n"
			"uniform highp float u_floatVar;\n\n"
			"layout(location = 0) out mediump vec4 o_fragColor;\n\n"
			"void main (void)\n"
			"{\n"
			"	mediump float refAll = float(u_boolVar) + float(u_intVar) + u_floatVar;\n"
			"	o_fragColor = vec4(refAll);\n"
			"}\n";

		DE_ASSERT(shaderType == glu::SHADERTYPE_VERTEX || shaderType == glu::SHADERTYPE_FRAGMENT);

		return (shaderType == glu::SHADERTYPE_VERTEX) ? vertSrc : fragSrc;
	}

	void setUniformsRandom (glu::ShaderProgram& program)
	{
		TestLog&		log		= m_testCtx.getLog();
		const deUint32	glProg	= program.getProgram();

		log << TestLog::Message << "Setting uniforms to random non-zero values." << TestLog::EndMessage;

		glUseProgram(glProg);

		{
			const GLint		boolLoc		= glGetUniformLocation(glProg, "u_boolVar");
			const GLint		intLoc		= glGetUniformLocation(glProg, "u_intVar");
			const GLint		floatLoc	= glGetUniformLocation(glProg, "u_floatVar");

			const deInt32	intVal		= m_rnd.getInt(1, 1000);
			const float		floatVal	= m_rnd.getFloat(1.0, 1000.0);

			glUniform1i(boolLoc,	GL_TRUE);
			glUniform1f(floatLoc,	floatVal);
			glUniform1i(intLoc,		intVal);
		}
	}

	void verifyUniformInt (glu::ShaderProgram& program, const std::string& name)
	{
		const GLint		intLoc	= glGetUniformLocation(program.getProgram(), name.c_str());
		GLint			intVar	= -1;

		glGetUniformiv(program.getProgram(), intLoc, &intVar);

		if (intVar != 0)
		{
			m_testCtx.getLog() << TestLog::Message << "Fail, expected zero value for " << name << ", received: " << intVar << TestLog::EndMessage;
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Uniform value not reset");
		}
	}

	void verifyUniformFloat (glu::ShaderProgram& program, const std::string& name)
	{
		const GLint	floatLoc	= glGetUniformLocation(program.getProgram(), name.c_str());
		GLfloat		floatVar	= -1;

		glGetUniformfv(program.getProgram(), floatLoc, &floatVar);

		if (floatVar != 0.0f)
		{
			m_testCtx.getLog() << TestLog::Message << "Fail, expected zero value for " << name << ", received: " << de::toString(floatVar) << TestLog::EndMessage;
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Uniform value not reset");
		}
	}

	void verifyUniformsReset (glu::ShaderProgram& program)
	{
		m_testCtx.getLog() << TestLog::Message << "Verifying uniform reset to 0/false." << TestLog::EndMessage;

		verifyUniformInt	(program,	"u_boolVar");
		verifyUniformInt	(program,	"u_intVar");
		verifyUniformFloat	(program,	"u_floatVar");
	}

	void test (void)
	{
		TestLog&					log		= m_testCtx.getLog();

		const std::string			vertSrc	= getShaderSource(glu::SHADERTYPE_VERTEX);
		const std::string			fragSrc	= getShaderSource(glu::SHADERTYPE_FRAGMENT);

		const glu::ProgramSources	sources	= glu::makeVtxFragSources(vertSrc, fragSrc);

		glu::ShaderProgram			program	(m_context.getRenderContext(), sources);

		log << program;

		TCU_CHECK_MSG(program.isOk(), "Couldn't build program");

		{
			ProgramBinary binary;

			getProgramBinary(binary, program.getProgram());
			verifyProgramBinary(binary);

			setUniformsRandom(program);

			log << TestLog::Message << "Rendering test image and reloading binary" << TestLog::EndMessage;

			drawWithProgram(m_context.getRenderContext(), program.getProgram());
			loadProgramBinary(binary, program.getProgram());

			verifyUniformsReset(program);
		}
	}
private:
	de::Random	m_rnd;
};

// Base class for program state persistence cases

class ProgramBinaryPersistenceCase : public ProgramBinaryCase
{
public:
					ProgramBinaryPersistenceCase	(Context& context, const char* name, const char* desc, glu::ShaderType shaderType);
	virtual			~ProgramBinaryPersistenceCase	(void) {}

	void			buildProgram					(glu::Program& program, ShaderAllocator& shaders);

	void			test							(void);

	virtual void	executeForProgram				(glu::Program& program, ShaderAllocator& shaders)	= 0;
	virtual void	verify							(glu::Program& program, const ProgramBinary& binary);

protected:
	de::Random				m_rnd;
	const glu::ShaderType	m_shaderType;
};

ProgramBinaryPersistenceCase::ProgramBinaryPersistenceCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
	: ProgramBinaryCase	(context, name, desc)
	, m_rnd				(deStringHash(name) ^ 0x713de0ca)
	, m_shaderType		(shaderType)
{
	DE_ASSERT(m_shaderType == glu::SHADERTYPE_VERTEX || m_shaderType == glu::SHADERTYPE_FRAGMENT);
}

void ProgramBinaryPersistenceCase::buildProgram (glu::Program& program, ShaderAllocator& shaders)
{
	TestLog&		log			= m_testCtx.getLog();

	glu::Shader&	vertShader	= shaders.createShader(glu::SHADERTYPE_VERTEX);
	glu::Shader&	fragShader	= shaders.createShader(glu::SHADERTYPE_FRAGMENT);

	vertShader.compile();
	fragShader.compile();

	program.attachShader(vertShader.getShader());
	program.attachShader(fragShader.getShader());
	program.link();

	logProgram(log, m_context.getRenderContext(), program, shaders);
}

void ProgramBinaryPersistenceCase::verify (glu::Program& program, const ProgramBinary& binary)
{
	TestLog&		log				= m_testCtx.getLog();
	ProgramBinary	currentBinary;

	getProgramBinary(currentBinary, program.getProgram());

	if (!programBinariesEqual(binary, currentBinary))
	{
		log << TestLog::Message << "Fail, program binary may only change as a result of linking or loading." << TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program binary changed");
	}
}

void ProgramBinaryPersistenceCase::test (void)
{
	TestLog&				log			= m_testCtx.getLog();
	glu::RenderContext&		renderCtx	= m_context.getRenderContext();

	ConstantShaderGenerator	sourceGen	(m_rnd);

	ShaderAllocator			shaders		(renderCtx, sourceGen);
	glu::Program			program		(renderCtx);

	buildProgram(program, shaders);

	if (program.getLinkStatus())
	{
		ProgramBinary binary;
		getProgramBinary(binary, program.getProgram());

		executeForProgram(program, shaders);

		verify(program, binary);

		logProgram(log, renderCtx, program, shaders);
	}
	else
	{
		log << TestLog::Message << "Fail, couldn't link program." << TestLog::EndMessage;
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Linking failed");
	}
}

// Program state case utilities

namespace
{

template<class T>
void addProgramBinaryPersistenceCase (TestCaseGroup* group, Context& context, const std::string& name, const std::string& desc)
{
	for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
	{
		const glu::ShaderType	shaderType		= (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;
		const std::string		shaderTypeName	= getShaderTypeName(shaderType);

		const std::string		caseName		= name + "_" + shaderTypeName;
		const std::string		caseDesc		= "Build program, " + desc + ", for " + shaderTypeName + " shader.";

		group->addChild(new T(context, caseName.c_str(), caseDesc.c_str(), shaderType));
	}
}

} // anonymous

// Specialized program state cases

class ProgramBinaryPersistenceDetachShaderCase : public ProgramBinaryPersistenceCase
{
public:
	ProgramBinaryPersistenceDetachShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramBinaryPersistenceCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramBinaryPersistenceDetachShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Detaching " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
	}
};

class ProgramBinaryPersistenceReattachShaderCase : public ProgramBinaryPersistenceCase
{
public:
	ProgramBinaryPersistenceReattachShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramBinaryPersistenceCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramBinaryPersistenceReattachShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Reattaching " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
		program.attachShader(caseShader.getShader());
	}
};

class ProgramBinaryPersistenceDeleteShaderCase : public ProgramBinaryPersistenceCase
{
public:
	ProgramBinaryPersistenceDeleteShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramBinaryPersistenceCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramBinaryPersistenceDeleteShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Deleting " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
		shaders.deleteShader(m_shaderType);
	}
};

class ProgramBinaryPersistenceReplaceShaderCase : public ProgramBinaryPersistenceCase
{
public:
	ProgramBinaryPersistenceReplaceShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramBinaryPersistenceCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramBinaryPersistenceReplaceShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Deleting and replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		program.detachShader(caseShader.getShader());
		shaders.deleteShader(m_shaderType);
		program.attachShader(shaders.createShader(m_shaderType).getShader());
	}
};

class ProgramBinaryPersistenceRecompileShaderCase : public ProgramBinaryPersistenceCase
{
public:
	ProgramBinaryPersistenceRecompileShaderCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramBinaryPersistenceCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramBinaryPersistenceRecompileShaderCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Recompiling " + std::string(getShaderTypeName(m_shaderType)) + " shader" << TestLog::EndMessage;
		caseShader.compile();
		DE_UNREF(program);
	}
};

class ProgramBinaryPersistenceReplaceSourceCase : public ProgramBinaryPersistenceCase
{
public:
	ProgramBinaryPersistenceReplaceSourceCase (Context& context, const char* name, const char* desc, glu::ShaderType shaderType)
		: ProgramBinaryPersistenceCase (context, name, desc, shaderType)
	{
	}

	virtual ~ProgramBinaryPersistenceReplaceSourceCase (void)
	{
	}

	void executeForProgram (glu::Program& program, ShaderAllocator& shaders)
	{
		TestLog&		log			= m_testCtx.getLog();
		glu::Shader&	caseShader	= shaders.get(m_shaderType);

		log << TestLog::Message << "Replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader source and recompiling" << TestLog::EndMessage;
		shaders.setSource(m_shaderType);
		caseShader.compile();
		DE_UNREF(program);
	}
};

// Test group

ShaderApiTests::ShaderApiTests (Context& context)
	: TestCaseGroup(context, "shader_api", "Shader API Cases")
{
}

ShaderApiTests::~ShaderApiTests (void)
{
}

void ShaderApiTests::init (void)
{
	// create and delete shaders
	{
		TestCaseGroup* createDeleteGroup = new TestCaseGroup(m_context, "create_delete", "glCreateShader() tests");
		addChild(createDeleteGroup);

		createDeleteGroup->addChild(new CreateShaderCase(m_context,	"create_vertex_shader",		"Create vertex shader object",		glu::SHADERTYPE_VERTEX));
		createDeleteGroup->addChild(new CreateShaderCase(m_context,	"create_fragment_shader",	"Create fragment shader object",	glu::SHADERTYPE_FRAGMENT));

		createDeleteGroup->addChild(new DeleteShaderCase(m_context,	"delete_vertex_fragment",	"Delete vertex shader and fragment shader"));
	}

	// compile and link
	{
		TestCaseGroup* compileLinkGroup = new TestCaseGroup(m_context, "compile_link", "Compile and link tests");
		addChild(compileLinkGroup);

		compileLinkGroup->addChild(new CompileShaderCase(m_context,	"compile_vertex_shader",	"Compile vertex shader",	glu::SHADERTYPE_VERTEX));
		compileLinkGroup->addChild(new CompileShaderCase(m_context,	"compile_fragment_shader",	"Compile fragment shader",	glu::SHADERTYPE_FRAGMENT));

		compileLinkGroup->addChild(new LinkVertexFragmentCase(m_context,	"link_vertex_fragment",	"Link vertex and fragment shaders"));
	}

	// shader source
	{
		TestCaseGroup* shaderSourceGroup = new TestCaseGroup(m_context, "shader_source", "glShaderSource() tests");
		addChild(shaderSourceGroup);

		for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
		{
			const glu::ShaderType	shaderType		= (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;
			const std::string		shaderTypeName	= getShaderTypeName(shaderType);

			const std::string		caseName		= std::string("replace_source_") + shaderTypeName;
			const std::string		caseDesc		= std::string("Replace source code of ") + shaderTypeName + " shader.";

			shaderSourceGroup->addChild(new ShaderSourceReplaceCase(m_context, caseName.c_str(), caseDesc.c_str(), shaderType));
		}

		for (int stringLengthsInt	= 0; stringLengthsInt < 3; stringLengthsInt++)
		for (int caseNdx = 1; caseNdx <= 3; caseNdx++)
		for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
		{
			const int				numSlices		= 1 << caseNdx;
			const glu::ShaderType	shaderType		= (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;

			const bool				explicitLengths	= (stringLengthsInt != 0);
			const bool				randomNullTerm	= (stringLengthsInt == 2);

			const deUint32			flags			= (explicitLengths	? CASE_EXPLICIT_SOURCE_LENGTHS	: 0)
													| (randomNullTerm	? CASE_RANDOM_NULL_TERMINATED	: 0);

			const std::string		caseName		= "split_source_"
													+ de::toString(numSlices)
													+ (randomNullTerm ? "_random_negative_length" : (explicitLengths ? "_specify_lengths" : "_null_terminated"))
													+ ((shaderType == glu::SHADERTYPE_FRAGMENT) ? "_fragment" : "_vertex");

			const std::string		caseDesc		= std::string((shaderType == glu::SHADERTYPE_FRAGMENT) ? "Fragment" : "Vertex")
													+ " shader source split into "
													+ de::toString(numSlices)
													+ " pieces"
													+ (explicitLengths ? ", using explicitly specified string lengths" : "")
													+ (randomNullTerm ? " with random negative length values" : "");

			shaderSourceGroup->addChild(new ShaderSourceSplitCase(m_context, caseName.c_str(), caseDesc.c_str(), shaderType, numSlices, flags));
		}
	}

	// link status and infolog
	{
		TestCaseGroup* linkStatusGroup = new TestCaseGroup(m_context, "program_state", "Program state persistence tests");
		addChild(linkStatusGroup);

		addProgramStateCase<ProgramStateDetachShaderCase>		(linkStatusGroup,	m_context,	"detach_shader",	"detach shader");
		addProgramStateCase<ProgramStateReattachShaderCase>		(linkStatusGroup,	m_context,	"reattach_shader",	"reattach shader");
		addProgramStateCase<ProgramStateDeleteShaderCase>		(linkStatusGroup,	m_context,	"delete_shader",	"delete shader");
		addProgramStateCase<ProgramStateReplaceShaderCase>		(linkStatusGroup,	m_context,	"replace_shader",	"replace shader object");
		addProgramStateCase<ProgramStateRecompileShaderCase>	(linkStatusGroup,	m_context,	"recompile_shader",	"recompile shader");
		addProgramStateCase<ProgramStateReplaceSourceCase>		(linkStatusGroup,	m_context,	"replace_source",	"replace shader source");
	}

	// program binary
	{
		TestCaseGroup* programBinaryGroup = new TestCaseGroup(m_context, "program_binary", "Program binary API tests");
		addChild(programBinaryGroup);

		{
			TestCaseGroup* simpleCaseGroup = new TestCaseGroup(m_context, "simple", "Simple API tests");
			programBinaryGroup->addChild(simpleCaseGroup);

			simpleCaseGroup->addChild(new ProgramBinarySimpleCase		(m_context,	"get_program_binary_vertex_fragment",	"Get vertex and fragment shader program binary"));
			simpleCaseGroup->addChild(new ProgramBinaryUniformResetCase	(m_context,	"uniform_reset_on_binary_load",			"Verify uniform reset on successful load of program binary"));
		}

		{
			TestCaseGroup* binaryPersistenceGroup = new TestCaseGroup(m_context, "binary_persistence", "Program binary persistence tests");
			programBinaryGroup->addChild(binaryPersistenceGroup);

			addProgramBinaryPersistenceCase<ProgramBinaryPersistenceDetachShaderCase>		(binaryPersistenceGroup,	m_context,	"detach_shader",	"detach shader");
			addProgramBinaryPersistenceCase<ProgramBinaryPersistenceReattachShaderCase>		(binaryPersistenceGroup,	m_context,	"reattach_shader",	"reattach shader");
			addProgramBinaryPersistenceCase<ProgramBinaryPersistenceDeleteShaderCase>		(binaryPersistenceGroup,	m_context,	"delete_shader",	"delete shader");
			addProgramBinaryPersistenceCase<ProgramBinaryPersistenceReplaceShaderCase>		(binaryPersistenceGroup,	m_context,	"replace_shader",	"replace shader object");
			addProgramBinaryPersistenceCase<ProgramBinaryPersistenceRecompileShaderCase>	(binaryPersistenceGroup,	m_context,	"recompile_shader",	"recompile shader");
			addProgramBinaryPersistenceCase<ProgramBinaryPersistenceReplaceSourceCase>		(binaryPersistenceGroup,	m_context,	"replace_source",	"replace shader source");
		}
	}
}

} // Functional
} // gles3
} // deqp