/*-------------------------------------------------------------------------
 * 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 Texture wrap mode test case
 *
 * \todo [petri]
 * - loop body cases (do different operations inside the loops)
 * - more complex nested loops
 *   * random generated?
 *   * dataflow variations
 *   * mixed loop types
 * -
 *//*--------------------------------------------------------------------*/

#include "es3fShaderLoopTests.hpp"
#include "glsShaderLibrary.hpp"
#include "glsShaderRenderCase.hpp"
#include "gluShaderUtil.hpp"
#include "tcuStringTemplate.hpp"

#include "deStringUtil.hpp"
#include "deInt32.h"
#include "deMemory.h"

#include <map>

using namespace std;
using namespace tcu;
using namespace glu;
using namespace deqp::gls;

namespace deqp
{
namespace gles3
{
namespace Functional
{

// Repeated with for, while, do-while. Examples given as 'for' loops.
// Repeated for const, uniform, dynamic loops.
enum LoopCase
{
	LOOPCASE_EMPTY_BODY = 0,								// for (...) { }
	LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST,		// for (...) { break; <body>; }
	LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST,		// for (...) { <body>; break; }
	LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK,				// for (...) { <body>; if (cond) break; }
	LOOPCASE_SINGLE_STATEMENT,								// for (...) statement;
	LOOPCASE_COMPOUND_STATEMENT,							// for (...) { statement; statement; }
	LOOPCASE_SEQUENCE_STATEMENT,							// for (...) statement, statement;
	LOOPCASE_NO_ITERATIONS,									// for (i=0; i<0; i++) ...
	LOOPCASE_SINGLE_ITERATION,								// for (i=0; i<1; i++) ...
	LOOPCASE_SELECT_ITERATION_COUNT,						// for (i=0; i<a?b:c; i++) ...
	LOOPCASE_CONDITIONAL_CONTINUE,							// for (...) { if (cond) continue; }
	LOOPCASE_UNCONDITIONAL_CONTINUE,						// for (...) { <body>; continue; }
	LOOPCASE_ONLY_CONTINUE,									// for (...) { continue; }
	LOOPCASE_DOUBLE_CONTINUE,								// for (...) { if (cond) continue; <body>; continue; }
	LOOPCASE_CONDITIONAL_BREAK,								// for (...) { if (cond) break; }
	LOOPCASE_UNCONDITIONAL_BREAK,							// for (...) { <body>; break; }
	LOOPCASE_PRE_INCREMENT,									// for (...; ++i) { <body>; }
	LOOPCASE_POST_INCREMENT,								// for (...; i++) { <body>; }
	LOOPCASE_MIXED_BREAK_CONTINUE,
	LOOPCASE_VECTOR_COUNTER,								// for (ivec3 ndx = ...; ndx.x < ndx.y; ndx.x += ndx.z) { ... }
	LOOPCASE_101_ITERATIONS,								// loop for 101 iterations
	LOOPCASE_SEQUENCE,										// two loops in sequence
	LOOPCASE_NESTED,										// two nested loops
	LOOPCASE_NESTED_SEQUENCE,								// two loops in sequence nested inside a third
	LOOPCASE_NESTED_TRICKY_DATAFLOW_1,						// nested loops with tricky data flow
	LOOPCASE_NESTED_TRICKY_DATAFLOW_2,						// nested loops with tricky data flow

	//LOOPCASE_MULTI_DECLARATION,							// for (int i,j,k; ...) ...  -- illegal?

	LOOPCASE_LAST
};

static const char* getLoopCaseName (LoopCase loopCase)
{
	static const char* s_names[] =
	{
		"empty_body",
		"infinite_with_unconditional_break_first",
		"infinite_with_unconditional_break_last",
		"infinite_with_conditional_break",
		"single_statement",
		"compound_statement",
		"sequence_statement",
		"no_iterations",
		"single_iteration",
		"select_iteration_count",
		"conditional_continue",
		"unconditional_continue",
		"only_continue",
		"double_continue",
		"conditional_break",
		"unconditional_break",
		"pre_increment",
		"post_increment",
		"mixed_break_continue",
		"vector_counter",
		"101_iterations",
		"sequence",
		"nested",
		"nested_sequence",
		"nested_tricky_dataflow_1",
		"nested_tricky_dataflow_2"
		//"multi_declaration",
	};

	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPCASE_LAST);
	DE_ASSERT(deInBounds32((int)loopCase, 0, LOOPCASE_LAST));
	return s_names[(int)loopCase];
}

// Complex loop cases.

/*enum LoopBody
{
	LOOPBODY_READ_UNIFORM = 0,
	LOOPBODY_READ_UNIFORM_ARRAY,
	LOOPBODY_READ_
};*/

enum LoopType
{
	LOOPTYPE_FOR = 0,
	LOOPTYPE_WHILE,
	LOOPTYPE_DO_WHILE,

	LOOPTYPE_LAST
};

static const char* getLoopTypeName (LoopType loopType)
{
	static const char* s_names[] =
	{
		"for",
		"while",
		"do_while"
	};

	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPTYPE_LAST);
	DE_ASSERT(deInBounds32((int)loopType, 0, LOOPTYPE_LAST));
	return s_names[(int)loopType];
}

enum LoopCountType
{
	LOOPCOUNT_CONSTANT = 0,
	LOOPCOUNT_UNIFORM,
	LOOPCOUNT_DYNAMIC,

	LOOPCOUNT_LAST
};

static const char* getLoopCountTypeName (LoopCountType countType)
{
	static const char* s_names[] =
	{
		"constant",
		"uniform",
		"dynamic"
	};

	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPCOUNT_LAST);
	DE_ASSERT(deInBounds32((int)countType, 0, LOOPCOUNT_LAST));
	return s_names[(int)countType];
}

static void evalLoop0Iters	(ShaderEvalContext& c) { c.color.xyz()	= c.coords.swizzle(0,1,2); }
static void evalLoop1Iters	(ShaderEvalContext& c) { c.color.xyz()	= c.coords.swizzle(1,2,3); }
static void evalLoop2Iters	(ShaderEvalContext& c) { c.color.xyz()	= c.coords.swizzle(2,3,0); }
static void evalLoop3Iters	(ShaderEvalContext& c) { c.color.xyz()	= c.coords.swizzle(3,0,1); }

static ShaderEvalFunc getLoopEvalFunc (int numIters)
{
	switch (numIters % 4)
	{
		case 0: return evalLoop0Iters;
		case 1:	return evalLoop1Iters;
		case 2:	return evalLoop2Iters;
		case 3:	return evalLoop3Iters;
	}

	DE_FATAL("Invalid loop iteration count.");
	return NULL;
}

// ShaderLoopCase

class ShaderLoopCase : public ShaderRenderCase
{
public:
								ShaderLoopCase			(Context& context, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc, const char* vertShaderSource, const char* fragShaderSource);
	virtual						~ShaderLoopCase			(void);

private:
								ShaderLoopCase			(const ShaderLoopCase&);	// not allowed!
	ShaderLoopCase&				operator=				(const ShaderLoopCase&);	// not allowed!

	virtual void				setup					(int programID);
	virtual void				setupUniforms			(int programID, const Vec4& constCoords);
};

ShaderLoopCase::ShaderLoopCase (Context& context, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc, const char* vertShaderSource, const char* fragShaderSource)
	: ShaderRenderCase(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, description, isVertexCase, evalFunc)
{
	m_vertShaderSource	= vertShaderSource;
	m_fragShaderSource	= fragShaderSource;
}

ShaderLoopCase::~ShaderLoopCase (void)
{
}

void ShaderLoopCase::setup (int programID)
{
	DE_UNREF(programID);
}

void ShaderLoopCase::setupUniforms (int programID, const Vec4& constCoords)
{
	DE_UNREF(programID);
	DE_UNREF(constCoords);
}

// Test case creation.

static ShaderLoopCase* createGenericLoopCase (Context& context, const char* caseName, const char* description, bool isVertexCase, LoopType loopType, LoopCountType loopCountType, Precision loopCountPrecision, DataType loopCountDataType)
{
	std::ostringstream vtx;
	std::ostringstream frag;
	std::ostringstream& op = isVertexCase ? vtx : frag;

	vtx << "#version 300 es\n";
	frag << "#version 300 es\n";

	vtx << "in highp vec4 a_position;\n";
	vtx << "in highp vec4 a_coords;\n";
	frag << "layout(location = 0) out mediump vec4 o_color;\n";

	if (loopCountType == LOOPCOUNT_DYNAMIC)
		vtx << "in mediump float a_one;\n";

	if (isVertexCase)
	{
		vtx << "out mediump vec3 v_color;\n";
		frag << "in mediump vec3 v_color;\n";
	}
	else
	{
		vtx << "out mediump vec4 v_coords;\n";
		frag << "in mediump vec4 v_coords;\n";

		if (loopCountType == LOOPCOUNT_DYNAMIC)
		{
			vtx << "out mediump float v_one;\n";
			frag << "in mediump float v_one;\n";
		}
	}

	// \todo [petri] Pass numLoopIters from outside?
	int		numLoopIters = 3;
	bool	isIntCounter = isDataTypeIntOrIVec(loopCountDataType);

	if (isIntCounter)
	{
		if (loopCountType == LOOPCOUNT_UNIFORM || loopCountType == LOOPCOUNT_DYNAMIC)
			op << "uniform ${COUNTER_PRECISION} int " << getIntUniformName(numLoopIters) << ";\n";
	}
	else
	{
		if (loopCountType == LOOPCOUNT_UNIFORM || loopCountType == LOOPCOUNT_DYNAMIC)
			op << "uniform ${COUNTER_PRECISION} float " << getFloatFractionUniformName(numLoopIters) << ";\n";

		if (numLoopIters != 1)
			op << "uniform ${COUNTER_PRECISION} float uf_one;\n";
	}

	vtx << "\n";
	vtx << "void main()\n";
	vtx << "{\n";
	vtx << "	gl_Position = a_position;\n";

	frag << "\n";
	frag << "void main()\n";
	frag << "{\n";

	if (isVertexCase)
		vtx << "	${PRECISION} vec4 coords = a_coords;\n";
	else
		frag << "	${PRECISION} vec4 coords = v_coords;\n";

	if (loopCountType == LOOPCOUNT_DYNAMIC)
	{
		if (isIntCounter)
		{
			if (isVertexCase)
				vtx << "	${COUNTER_PRECISION} int one = int(a_one + 0.5);\n";
			else
				frag << "	${COUNTER_PRECISION} int one = int(v_one + 0.5);\n";
		}
		else
		{
			if (isVertexCase)
				vtx << "	${COUNTER_PRECISION} float one = a_one;\n";
			else
				frag << "	${COUNTER_PRECISION} float one = v_one;\n";
		}
	}

	// Read array.
	op << "	${PRECISION} vec4 res = coords;\n";

	// Loop iteration count.
	string	iterMaxStr;

	if (isIntCounter)
	{
		if (loopCountType == LOOPCOUNT_CONSTANT)
			iterMaxStr = de::toString(numLoopIters);
		else if (loopCountType == LOOPCOUNT_UNIFORM)
			iterMaxStr = getIntUniformName(numLoopIters);
		else if (loopCountType == LOOPCOUNT_DYNAMIC)
			iterMaxStr = string(getIntUniformName(numLoopIters)) + "*one";
		else
			DE_ASSERT(false);
	}
	else
	{
		if (loopCountType == LOOPCOUNT_CONSTANT)
			iterMaxStr = "1.0";
		else if (loopCountType == LOOPCOUNT_UNIFORM)
			iterMaxStr = "uf_one";
		else if (loopCountType == LOOPCOUNT_DYNAMIC)
			iterMaxStr = "uf_one*one";
		else
			DE_ASSERT(false);
	}

	// Loop operations.
	string initValue		= isIntCounter ? "0" : "0.05";
	string loopCountDeclStr	= "${COUNTER_PRECISION} ${LOOP_VAR_TYPE} ndx = " + initValue;
	string loopCmpStr		= ("ndx < " + iterMaxStr);
	string incrementStr;
	if (isIntCounter)
		incrementStr = "ndx++";
	else
	{
		if (loopCountType == LOOPCOUNT_CONSTANT)
			incrementStr = string("ndx += ") + de::toString(1.0f / (float)numLoopIters);
		else if (loopCountType == LOOPCOUNT_UNIFORM)
			incrementStr = string("ndx += ") + getFloatFractionUniformName(numLoopIters);
		else if (loopCountType == LOOPCOUNT_DYNAMIC)
			incrementStr = string("ndx += ") + getFloatFractionUniformName(numLoopIters) + "*one";
		else
			DE_ASSERT(false);
	}

	// Loop body.
	string loopBody;

	loopBody = "		res = res.yzwx;\n";

	if (loopType == LOOPTYPE_FOR)
	{
		op << "	for (" + loopCountDeclStr + "; " + loopCmpStr + "; " + incrementStr + ")\n";
		op << "	{\n";
		op << loopBody;
		op << "	}\n";
	}
	else if (loopType == LOOPTYPE_WHILE)
	{
		op << "\t" << loopCountDeclStr + ";\n";
		op << "	while (" + loopCmpStr + ")\n";
		op << "	{\n";
		op << loopBody;
		op << "\t\t" + incrementStr + ";\n";
		op << "	}\n";
	}
	else if (loopType == LOOPTYPE_DO_WHILE)
	{
		op << "\t" << loopCountDeclStr + ";\n";
		op << "	do\n";
		op << "	{\n";
		op << loopBody;
		op << "\t\t" + incrementStr + ";\n";
		op << "	} while (" + loopCmpStr + ");\n";
	}
	else
		DE_ASSERT(false);

	if (isVertexCase)
	{
		vtx << "	v_color = res.rgb;\n";
		frag << "	o_color = vec4(v_color.rgb, 1.0);\n";
	}
	else
	{
		vtx << "	v_coords = a_coords;\n";
		frag << "	o_color = vec4(res.rgb, 1.0);\n";

		if (loopCountType == LOOPCOUNT_DYNAMIC)
			vtx << "	v_one = a_one;\n";
	}

	vtx << "}\n";
	frag << "}\n";

	// Fill in shader templates.
	map<string, string> params;
	params.insert(pair<string, string>("LOOP_VAR_TYPE", getDataTypeName(loopCountDataType)));
	params.insert(pair<string, string>("PRECISION", "mediump"));
	params.insert(pair<string, string>("COUNTER_PRECISION", getPrecisionName(loopCountPrecision)));

	StringTemplate vertTemplate(vtx.str().c_str());
	StringTemplate fragTemplate(frag.str().c_str());
	string vertexShaderSource = vertTemplate.specialize(params);
	string fragmentShaderSource = fragTemplate.specialize(params);

	// Create the case.
	ShaderEvalFunc evalFunc = getLoopEvalFunc(numLoopIters);
	return new ShaderLoopCase(context, caseName, description, isVertexCase, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
}

// \todo [petri] Generalize to float as well?
static ShaderLoopCase* createSpecialLoopCase (Context& context, const char* caseName, const char* description, bool isVertexCase, LoopCase loopCase, LoopType loopType, LoopCountType loopCountType)
{
	std::ostringstream vtx;
	std::ostringstream frag;
	std::ostringstream& op = isVertexCase ? vtx : frag;

	vtx << "#version 300 es\n";
	frag << "#version 300 es\n";

	vtx << "in highp vec4 a_position;\n";
	vtx << "in highp vec4 a_coords;\n";
	frag << "layout(location = 0) out mediump vec4 o_color;\n";

	if (loopCountType == LOOPCOUNT_DYNAMIC)
		vtx << "in mediump float a_one;\n";

	// Attribute and varyings.
	if (isVertexCase)
	{
		vtx << "out mediump vec3 v_color;\n";
		frag << "in mediump vec3 v_color;\n";
	}
	else
	{
		vtx << "out mediump vec4 v_coords;\n";
		frag << "in mediump vec4 v_coords;\n";

		if (loopCountType == LOOPCOUNT_DYNAMIC)
		{
			vtx << "out mediump float v_one;\n";
			frag << "in mediump float v_one;\n";
		}
	}

	if (loopCase == LOOPCASE_SELECT_ITERATION_COUNT)
		op << "uniform bool ub_true;\n";

	op << "uniform ${COUNTER_PRECISION} int ui_zero, ui_one, ui_two, ui_three, ui_four, ui_five, ui_six;\n";
	if (loopCase == LOOPCASE_101_ITERATIONS)
		op << "uniform ${COUNTER_PRECISION} int ui_oneHundredOne;\n";

	int iterCount	= 3;	// value to use in loop
	int numIters	= 3;	// actual number of iterations

	vtx << "\n";
	vtx << "void main()\n";
	vtx << "{\n";
	vtx << "	gl_Position = a_position;\n";

	frag << "\n";
	frag << "void main()\n";
	frag << "{\n";

	if (loopCountType == LOOPCOUNT_DYNAMIC)
	{
		if (isVertexCase)
			vtx << "	${COUNTER_PRECISION} int one = int(a_one + 0.5);\n";
		else
			frag << "	${COUNTER_PRECISION} int one = int(v_one + 0.5);\n";
	}

	if (isVertexCase)
		vtx << "	${PRECISION} vec4 coords = a_coords;\n";
	else
		frag << "	${PRECISION} vec4 coords = v_coords;\n";

	// Read array.
	op << "	${PRECISION} vec4 res = coords;\n";

	// Handle all loop types.
	string counterPrecisionStr = "mediump";
	string forLoopStr;
	string whileLoopStr;
	string doWhileLoopPreStr;
	string doWhileLoopPostStr;

	if (loopType == LOOPTYPE_FOR)
	{
		switch (loopCase)
		{
			case LOOPCASE_EMPTY_BODY:
				numIters = 0;
				op << "	${FOR_LOOP} {}\n";
				break;

			case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST:
				numIters = 0;
				op << "	for (;;) { break; res = res.yzwx; }\n";
				break;

			case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST:
				numIters = 1;
				op << "	for (;;) { res = res.yzwx; break; }\n";
				break;

			case LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK:
				numIters = 2;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	for (;;) { res = res.yzwx; if (i == ${ONE}) break; i++; }\n";
				break;

			case LOOPCASE_SINGLE_STATEMENT:
				op << "	${FOR_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_COMPOUND_STATEMENT:
				iterCount	= 2;
				numIters	= 2 * iterCount;
				op << "	${FOR_LOOP} { res = res.yzwx; res = res.yzwx; }\n";
				break;

			case LOOPCASE_SEQUENCE_STATEMENT:
				iterCount	= 2;
				numIters	= 2 * iterCount;
				op << "	${FOR_LOOP} res = res.yzwx, res = res.yzwx;\n";
				break;

			case LOOPCASE_NO_ITERATIONS:
				iterCount	= 0;
				numIters	= 0;
				op << "	${FOR_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_SINGLE_ITERATION:
				iterCount	= 1;
				numIters	= 1;
				op << "	${FOR_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_SELECT_ITERATION_COUNT:
				op << "	for (int i = 0; i < (ub_true ? ${ITER_COUNT} : 0); i++) res = res.yzwx;\n";
				break;

			case LOOPCASE_CONDITIONAL_CONTINUE:
				numIters = iterCount - 1;
				op << "	${FOR_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; }\n";
				break;

			case LOOPCASE_UNCONDITIONAL_CONTINUE:
				op << "	${FOR_LOOP} { res = res.yzwx; continue; }\n";
				break;

			case LOOPCASE_ONLY_CONTINUE:
				numIters = 0;
				op << "	${FOR_LOOP} { continue; }\n";
				break;

			case LOOPCASE_DOUBLE_CONTINUE:
				numIters = iterCount - 1;
				op << "	${FOR_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; continue; }\n";
				break;

			case LOOPCASE_CONDITIONAL_BREAK:
				numIters = 2;
				op << "	${FOR_LOOP} { if (i == ${TWO}) break; res = res.yzwx; }\n";
				break;

			case LOOPCASE_UNCONDITIONAL_BREAK:
				numIters = 1;
				op << "	${FOR_LOOP} { res = res.yzwx; break; }\n";
				break;

			case LOOPCASE_PRE_INCREMENT:
				op << "	for (int i = 0; i < ${ITER_COUNT}; ++i) { res = res.yzwx; }\n";
				break;

			case LOOPCASE_POST_INCREMENT:
				op << "	${FOR_LOOP} { res = res.yzwx; }\n";
				break;

			case LOOPCASE_MIXED_BREAK_CONTINUE:
				numIters	= 2;
				iterCount	= 5;
				op << "	${FOR_LOOP} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; }\n";
				break;

			case LOOPCASE_VECTOR_COUNTER:
				op << "	for (${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0); i.x < i.z; i.x += i.y) { res = res.yzwx; }\n";
				break;

			case LOOPCASE_101_ITERATIONS:
				numIters = iterCount = 101;
				op << "	${FOR_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_SEQUENCE:
				iterCount	= 5;
				numIters	= 5;
				op << "	${COUNTER_PRECISION} int i;\n";
				op << "	for (i = 0; i < ${TWO}; i++) { res = res.yzwx; }\n";
				op << "	for (; i < ${ITER_COUNT}; i++) { res = res.yzwx; }\n";
				break;

			case LOOPCASE_NESTED:
				numIters = 2 * iterCount;
				op << "	for (${COUNTER_PRECISION} int i = 0; i < ${TWO}; i++)\n";
				op << "	{\n";
				op << "		for (${COUNTER_PRECISION} int j = 0; j < ${ITER_COUNT}; j++)\n";
				op << "			res = res.yzwx;\n";
				op << "	}\n";
				break;

			case LOOPCASE_NESTED_SEQUENCE:
				numIters = 3 * iterCount;
				op << "	for (${COUNTER_PRECISION} int i = 0; i < ${ITER_COUNT}; i++)\n";
				op << "	{\n";
				op << "		for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n";
				op << "			res = res.yzwx;\n";
				op << "		for (${COUNTER_PRECISION} int j = 0; j < ${ONE}; j++)\n";
				op << "			res = res.yzwx;\n";
				op << "	}\n";
				break;

			case LOOPCASE_NESTED_TRICKY_DATAFLOW_1:
				numIters = 2;
				op << "	${FOR_LOOP}\n";
				op << "	{\n";
				op << "		res = coords; // ignore outer loop effect \n";
				op << "		for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n";
				op << "			res = res.yzwx;\n";
				op << "	}\n";
				break;

			case LOOPCASE_NESTED_TRICKY_DATAFLOW_2:
				numIters = iterCount;
				op << "	${FOR_LOOP}\n";
				op << "	{\n";
				op << "		res = coords.wxyz;\n";
				op << "		for (${COUNTER_PRECISION} int j = 0; j < ${TWO}; j++)\n";
				op << "			res = res.yzwx;\n";
				op << "		coords = res;\n";
				op << "	}\n";
				break;

			default:
				DE_ASSERT(false);
		}

		if (loopCountType == LOOPCOUNT_CONSTANT)
			forLoopStr = string("for (") + counterPrecisionStr + " int i = 0; i < " + de::toString(iterCount) + "; i++)";
		else if (loopCountType == LOOPCOUNT_UNIFORM)
			forLoopStr = string("for (") + counterPrecisionStr + " int i = 0; i < " + getIntUniformName(iterCount) + "; i++)";
		else if (loopCountType == LOOPCOUNT_DYNAMIC)
			forLoopStr = string("for (") + counterPrecisionStr + " int i = 0; i < one*" + getIntUniformName(iterCount) + "; i++)";
		else
			DE_ASSERT(false);
	}
	else if (loopType == LOOPTYPE_WHILE)
	{
		switch (loopCase)
		{
			case LOOPCASE_EMPTY_BODY:
				numIters = 0;
				op << "	${WHILE_LOOP} {}\n";
				break;

			case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST:
				numIters = 0;
				op << "	while (true) { break; res = res.yzwx; }\n";
				break;

			case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST:
				numIters = 1;
				op << "	while (true) { res = res.yzwx; break; }\n";
				break;

			case LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK:
				numIters = 2;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (true) { res = res.yzwx; if (i == ${ONE}) break; i++; }\n";
				break;

			case LOOPCASE_SINGLE_STATEMENT:
				op << "	${WHILE_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_COMPOUND_STATEMENT:
				iterCount	= 2;
				numIters	= 2 * iterCount;
				op << "	${WHILE_LOOP} { res = res.yzwx; res = res.yzwx; }\n";
				break;

			case LOOPCASE_SEQUENCE_STATEMENT:
				iterCount	= 2;
				numIters	= 2 * iterCount;
				op << "	${WHILE_LOOP} res = res.yzwx, res = res.yzwx;\n";
				break;

			case LOOPCASE_NO_ITERATIONS:
				iterCount	= 0;
				numIters	= 0;
				op << "	${WHILE_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_SINGLE_ITERATION:
				iterCount	= 1;
				numIters	= 1;
				op << "	${WHILE_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_SELECT_ITERATION_COUNT:
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (i < (ub_true ? ${ITER_COUNT} : 0)) { res = res.yzwx; i++; }\n";
				break;

			case LOOPCASE_CONDITIONAL_CONTINUE:
				numIters = iterCount - 1;
				op << "	${WHILE_LOOP} { if (i == ${TWO}) continue; res = res.yzwx; }\n";
				break;

			case LOOPCASE_UNCONDITIONAL_CONTINUE:
				op << "	${WHILE_LOOP} { res = res.yzwx; continue; }\n";
				break;

			case LOOPCASE_ONLY_CONTINUE:
				numIters = 0;
				op << "	${WHILE_LOOP} { continue; }\n";
				break;

			case LOOPCASE_DOUBLE_CONTINUE:
				numIters = iterCount - 1;
				op << "	${WHILE_LOOP} { if (i == ${ONE}) continue; res = res.yzwx; continue; }\n";
				break;

			case LOOPCASE_CONDITIONAL_BREAK:
				numIters = 2;
				op << "	${WHILE_LOOP} { if (i == ${THREE}) break; res = res.yzwx; }\n";
				break;

			case LOOPCASE_UNCONDITIONAL_BREAK:
				numIters = 1;
				op << "	${WHILE_LOOP} { res = res.yzwx; break; }\n";
				break;

			case LOOPCASE_PRE_INCREMENT:
				numIters = iterCount - 1;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (++i < ${ITER_COUNT}) { res = res.yzwx; }\n";
				break;

			case LOOPCASE_POST_INCREMENT:
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (i++ < ${ITER_COUNT}) { res = res.yzwx; }\n";
				break;

			case LOOPCASE_MIXED_BREAK_CONTINUE:
				numIters	= 2;
				iterCount	= 5;
				op << "	${WHILE_LOOP} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; }\n";
				break;

			case LOOPCASE_VECTOR_COUNTER:
				op << "	${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0);\n";
				op << "	while (i.x < i.z) { res = res.yzwx; i.x += i.y; }\n";
				break;

			case LOOPCASE_101_ITERATIONS:
				numIters = iterCount = 101;
				op << "	${WHILE_LOOP} res = res.yzwx;\n";
				break;

			case LOOPCASE_SEQUENCE:
				iterCount	= 6;
				numIters	= iterCount - 1;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (i++ < ${TWO}) { res = res.yzwx; }\n";
				op << "	while (i++ < ${ITER_COUNT}) { res = res.yzwx; }\n"; // \note skips one iteration
				break;

			case LOOPCASE_NESTED:
				numIters = 2 * iterCount;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (i++ < ${TWO})\n";
				op << "	{\n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		while (j++ < ${ITER_COUNT})\n";
				op << "			res = res.yzwx;\n";
				op << "	}\n";
				break;

			case LOOPCASE_NESTED_SEQUENCE:
				numIters = 2 * iterCount;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	while (i++ < ${ITER_COUNT})\n";
				op << "	{\n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		while (j++ < ${ONE})\n";
				op << "			res = res.yzwx;\n";
				op << "		while (j++ < ${THREE})\n"; // \note skips one iteration
				op << "			res = res.yzwx;\n";
				op << "	}\n";
				break;

			case LOOPCASE_NESTED_TRICKY_DATAFLOW_1:
				numIters = 2;
				op << "	${WHILE_LOOP}\n";
				op << "	{\n";
				op << "		res = coords; // ignore outer loop effect \n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		while (j++ < ${TWO})\n";
				op << "			res = res.yzwx;\n";
				op << "	}\n";
				break;

			case LOOPCASE_NESTED_TRICKY_DATAFLOW_2:
				numIters = iterCount;
				op << "	${WHILE_LOOP}\n";
				op << "	{\n";
				op << "		res = coords.wxyz;\n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		while (j++ < ${TWO})\n";
				op << "			res = res.yzwx;\n";
				op << "		coords = res;\n";
				op << "	}\n";
				break;

			default:
				DE_ASSERT(false);
		}

		if (loopCountType == LOOPCOUNT_CONSTANT)
			whileLoopStr = string("\t") + counterPrecisionStr + " int i = 0;\n" + "	while(i++ < " + de::toString(iterCount) + ")";
		else if (loopCountType == LOOPCOUNT_UNIFORM)
			whileLoopStr = string("\t") + counterPrecisionStr + " int i = 0;\n" + "	while(i++ < " + getIntUniformName(iterCount) + ")";
		else if (loopCountType == LOOPCOUNT_DYNAMIC)
			whileLoopStr = string("\t") + counterPrecisionStr + " int i = 0;\n" + "	while(i++ < one*" + getIntUniformName(iterCount) + ")";
		else
			DE_ASSERT(false);
	}
	else
	{
		DE_ASSERT(loopType == LOOPTYPE_DO_WHILE);

		switch (loopCase)
		{
			case LOOPCASE_EMPTY_BODY:
				numIters = 0;
				op << "	${DO_WHILE_PRE} {} ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_FIRST:
				numIters = 0;
				op << "	do { break; res = res.yzwx; } while (true);\n";
				break;

			case LOOPCASE_INFINITE_WITH_UNCONDITIONAL_BREAK_LAST:
				numIters = 1;
				op << "	do { res = res.yzwx; break; } while (true);\n";
				break;

			case LOOPCASE_INFINITE_WITH_CONDITIONAL_BREAK:
				numIters = 2;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do { res = res.yzwx; if (i == ${ONE}) break; i++; } while (true);\n";
				break;

			case LOOPCASE_SINGLE_STATEMENT:
				op << "	${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_COMPOUND_STATEMENT:
				iterCount	= 2;
				numIters	= 2 * iterCount;
				op << "	${DO_WHILE_PRE} { res = res.yzwx; res = res.yzwx; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_SEQUENCE_STATEMENT:
				iterCount	= 2;
				numIters	= 2 * iterCount;
				op << "	${DO_WHILE_PRE} res = res.yzwx, res = res.yzwx; ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_NO_ITERATIONS:
				DE_ASSERT(false);
				break;

			case LOOPCASE_SINGLE_ITERATION:
				iterCount	= 1;
				numIters	= 1;
				op << "	${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_SELECT_ITERATION_COUNT:
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do { res = res.yzwx; } while (++i < (ub_true ? ${ITER_COUNT} : 0));\n";
				break;

			case LOOPCASE_CONDITIONAL_CONTINUE:
				numIters = iterCount - 1;
				op << "	${DO_WHILE_PRE} { if (i == ${TWO}) continue; res = res.yzwx; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_UNCONDITIONAL_CONTINUE:
				op << "	${DO_WHILE_PRE} { res = res.yzwx; continue; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_ONLY_CONTINUE:
				numIters = 0;
				op << "	${DO_WHILE_PRE} { continue; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_DOUBLE_CONTINUE:
				numIters = iterCount - 1;
				op << "	${DO_WHILE_PRE} { if (i == ${TWO}) continue; res = res.yzwx; continue; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_CONDITIONAL_BREAK:
				numIters = 2;
				op << "	${DO_WHILE_PRE} { res = res.yzwx; if (i == ${ONE}) break; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_UNCONDITIONAL_BREAK:
				numIters = 1;
				op << "	${DO_WHILE_PRE} { res = res.yzwx; break; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_PRE_INCREMENT:
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do { res = res.yzwx; } while (++i < ${ITER_COUNT});\n";
				break;

			case LOOPCASE_POST_INCREMENT:
				numIters = iterCount + 1;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do { res = res.yzwx; } while (i++ < ${ITER_COUNT});\n";
				break;

			case LOOPCASE_MIXED_BREAK_CONTINUE:
				numIters	= 2;
				iterCount	= 5;
				op << "	${DO_WHILE_PRE} { if (i == 0) continue; else if (i == 3) break; res = res.yzwx; } ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_VECTOR_COUNTER:
				op << "	${COUNTER_PRECISION} ivec4 i = ivec4(0, 1, ${ITER_COUNT}, 0);\n";
				op << "	do { res = res.yzwx; } while ((i.x += i.y) < i.z);\n";
				break;

			case LOOPCASE_101_ITERATIONS:
				numIters = iterCount = 101;
				op << "	${DO_WHILE_PRE} res = res.yzwx; ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_SEQUENCE:
				iterCount	= 5;
				numIters	= 5;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do { res = res.yzwx; } while (++i < ${TWO});\n";
				op << "	do { res = res.yzwx; } while (++i < ${ITER_COUNT});\n";
				break;

			case LOOPCASE_NESTED:
				numIters = 2 * iterCount;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do\n";
				op << "	{\n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		do\n";
				op << "			res = res.yzwx;\n";
				op << "		while (++j < ${ITER_COUNT});\n";
				op << "	} while (++i < ${TWO});\n";
				break;

			case LOOPCASE_NESTED_SEQUENCE:
				numIters = 3 * iterCount;
				op << "	${COUNTER_PRECISION} int i = 0;\n";
				op << "	do\n";
				op << "	{\n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		do\n";
				op << "			res = res.yzwx;\n";
				op << "		while (++j < ${TWO});\n";
				op << "		do\n";
				op << "			res = res.yzwx;\n";
				op << "		while (++j < ${THREE});\n";
				op << "	} while (++i < ${ITER_COUNT});\n";
				break;

			case LOOPCASE_NESTED_TRICKY_DATAFLOW_1:
				numIters = 2;
				op << "	${DO_WHILE_PRE}\n";
				op << "	{\n";
				op << "		res = coords; // ignore outer loop effect \n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		do\n";
				op << "			res = res.yzwx;\n";
				op << "		while (++j < ${TWO});\n";
				op << "	} ${DO_WHILE_POST}\n";
				break;

			case LOOPCASE_NESTED_TRICKY_DATAFLOW_2:
				numIters = iterCount;
				op << "	${DO_WHILE_PRE}\n";
				op << "	{\n";
				op << "		res = coords.wxyz;\n";
				op << "		${COUNTER_PRECISION} int j = 0;\n";
				op << "		while (j++ < ${TWO})\n";
				op << "			res = res.yzwx;\n";
				op << "		coords = res;\n";
				op << "	} ${DO_WHILE_POST}\n";
				break;

			default:
				DE_ASSERT(false);
		}

		doWhileLoopPreStr = string("\t") + counterPrecisionStr + " int i = 0;\n" + "\tdo ";
		if (loopCountType == LOOPCOUNT_CONSTANT)
			doWhileLoopPostStr = string(" while (++i < ") + de::toString(iterCount) + ");\n";
		else if (loopCountType == LOOPCOUNT_UNIFORM)
			doWhileLoopPostStr = string(" while (++i < ") + getIntUniformName(iterCount) + ");\n";
		else if (loopCountType == LOOPCOUNT_DYNAMIC)
			doWhileLoopPostStr = string(" while (++i < one*") + getIntUniformName(iterCount) + ");\n";
		else
			DE_ASSERT(false);
	}

	// Shader footers.
	if (isVertexCase)
	{
		vtx << "	v_color = res.rgb;\n";
		frag << "	o_color = vec4(v_color.rgb, 1.0);\n";
	}
	else
	{
		vtx << "	v_coords = a_coords;\n";
		frag << "	o_color = vec4(res.rgb, 1.0);\n";

		if (loopCountType == LOOPCOUNT_DYNAMIC)
			vtx << "	v_one = a_one;\n";
	}

	vtx << "}\n";
	frag << "}\n";

	// Constants.
	string oneStr;
	string twoStr;
	string threeStr;
	string iterCountStr;

	if (loopCountType == LOOPCOUNT_CONSTANT)
	{
		oneStr			= "1";
		twoStr			= "2";
		threeStr		= "3";
		iterCountStr	= de::toString(iterCount);
	}
	else if (loopCountType == LOOPCOUNT_UNIFORM)
	{
		oneStr			= "ui_one";
		twoStr			= "ui_two";
		threeStr		= "ui_three";
		iterCountStr	= getIntUniformName(iterCount);
	}
	else if (loopCountType == LOOPCOUNT_DYNAMIC)
	{
		oneStr			= "one*ui_one";
		twoStr			= "one*ui_two";
		threeStr		= "one*ui_three";
		iterCountStr	= string("one*") + getIntUniformName(iterCount);
	}
	else DE_ASSERT(false);

	// Fill in shader templates.
	map<string, string> params;
	params.insert(pair<string, string>("PRECISION", "mediump"));
	params.insert(pair<string, string>("ITER_COUNT", iterCountStr));
	params.insert(pair<string, string>("COUNTER_PRECISION", counterPrecisionStr));
	params.insert(pair<string, string>("FOR_LOOP", forLoopStr));
	params.insert(pair<string, string>("WHILE_LOOP", whileLoopStr));
	params.insert(pair<string, string>("DO_WHILE_PRE", doWhileLoopPreStr));
	params.insert(pair<string, string>("DO_WHILE_POST", doWhileLoopPostStr));
	params.insert(pair<string, string>("ONE", oneStr));
	params.insert(pair<string, string>("TWO", twoStr));
	params.insert(pair<string, string>("THREE", threeStr));

	StringTemplate vertTemplate(vtx.str().c_str());
	StringTemplate fragTemplate(frag.str().c_str());
	string vertexShaderSource = vertTemplate.specialize(params);
	string fragmentShaderSource = fragTemplate.specialize(params);

	// Create the case.
	ShaderEvalFunc evalFunc = getLoopEvalFunc(numIters);
	return new ShaderLoopCase(context, caseName, description, isVertexCase, evalFunc, vertexShaderSource.c_str(), fragmentShaderSource.c_str());
};

// ShaderLoopTests.

ShaderLoopTests::ShaderLoopTests(Context& context)
	: TestCaseGroup(context, "loops", "Loop Tests")
{
}

ShaderLoopTests::~ShaderLoopTests (void)
{
}

void ShaderLoopTests::init (void)
{
	// Loop cases.

	static const ShaderType s_shaderTypes[] =
	{
		SHADERTYPE_VERTEX,
		SHADERTYPE_FRAGMENT
	};

	static const DataType s_countDataType[] =
	{
		TYPE_INT,
		TYPE_FLOAT
	};

	for (int loopType = 0; loopType < LOOPTYPE_LAST; loopType++)
	{
		const char* loopTypeName = getLoopTypeName((LoopType)loopType);

		for (int loopCountType = 0; loopCountType < LOOPCOUNT_LAST; loopCountType++)
		{
			const char* loopCountName = getLoopCountTypeName((LoopCountType)loopCountType);

			string groupName = string(loopTypeName) + "_" + string(loopCountName) + "_iterations";
			string groupDesc = string("Loop tests with ") + loopCountName + " loop counter.";
			TestCaseGroup* group = new TestCaseGroup(m_context, groupName.c_str(), groupDesc.c_str());
			addChild(group);

			// Generic cases.

			for (int precision = 0; precision < PRECISION_LAST; precision++)
			{
				const char* precisionName = getPrecisionName((Precision)precision);

				for (int dataTypeNdx = 0; dataTypeNdx < DE_LENGTH_OF_ARRAY(s_countDataType); dataTypeNdx++)
				{
					DataType loopDataType = s_countDataType[dataTypeNdx];
					const char* dataTypeName = getDataTypeName(loopDataType);

					for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
					{
						ShaderType	shaderType		= s_shaderTypes[shaderTypeNdx];
						const char*	shaderTypeName	= getShaderTypeName(shaderType);
						bool		isVertexCase	= (shaderType == SHADERTYPE_VERTEX);

						string name = string("basic_") + precisionName + "_" + dataTypeName + "_" + shaderTypeName;
						string desc = string(loopTypeName) + " loop with " + precisionName + dataTypeName + " " + loopCountName + " iteration count in " + shaderTypeName + " shader.";
						group->addChild(createGenericLoopCase(m_context, name.c_str(), desc.c_str(), isVertexCase, (LoopType)loopType, (LoopCountType)loopCountType, (Precision)precision, loopDataType));
					}
				}
			}

			// Special cases.

			for (int loopCase = 0; loopCase < LOOPCASE_LAST; loopCase++)
			{
				const char* loopCaseName = getLoopCaseName((LoopCase)loopCase);

				// no-iterations not possible with do-while.
				if ((loopCase == LOOPCASE_NO_ITERATIONS) && (loopType == LOOPTYPE_DO_WHILE))
					continue;

				for (int shaderTypeNdx = 0; shaderTypeNdx < DE_LENGTH_OF_ARRAY(s_shaderTypes); shaderTypeNdx++)
				{
					ShaderType	shaderType		= s_shaderTypes[shaderTypeNdx];
					const char*	shaderTypeName	= getShaderTypeName(shaderType);
					bool		isVertexCase	= (shaderType == SHADERTYPE_VERTEX);

					string name = string(loopCaseName) + "_" + shaderTypeName;
					string desc = string(loopCaseName) + " loop with " + loopTypeName + " iteration count in " + shaderTypeName + " shader.";
					group->addChild(createSpecialLoopCase(m_context, name.c_str(), desc.c_str(), isVertexCase, (LoopCase)loopCase, (LoopType)loopType, (LoopCountType)loopCountType));
				}
			}
		}
	}

	// Additional smaller handwritten tests.
	const std::vector<tcu::TestNode*> children = gls::ShaderLibrary(m_context.getTestContext(), m_context.getRenderContext(), m_context.getContextInfo()).loadShaderFile("shaders/loops.test");
	for (int i = 0; i < (int)children.size(); i++)
		addChild(children[i]);
}

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