xref: /external/deqp/modules/gles2/functional/es2fIntegerStateQueryTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 2.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 State Query tests.
 *//*--------------------------------------------------------------------*/

#include "es2fIntegerStateQueryTests.hpp"
#include "es2fApiCase.hpp"
#include "glsStateQueryUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluContextInfo.hpp"
#include "tcuRenderTarget.hpp"
#include "deRandom.hpp"
#include "glwEnums.hpp"

using namespace glw; // GLint and other GL types
using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;

#ifndef GL_SLUMINANCE_NV
#define	GL_SLUMINANCE_NV 0x8C46
#endif
#ifndef GL_SLUMINANCE_ALPHA_NV
#define	GL_SLUMINANCE_ALPHA_NV 0x8C44
#endif
#ifndef GL_BGR_NV
#define GL_BGR_NV 0x80E0
#endif

namespace deqp
{
namespace gles2
{
namespace Functional
{
namespace IntegerStateQueryVerifiers
{

// StateVerifier

class StateVerifier : protected glu::CallLogWrapper
{
public:
						StateVerifier						(const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
	virtual				~StateVerifier						(); // make GCC happy

	const char*			getTestNamePostfix					(void) const;

	virtual void		verifyInteger						(tcu::TestContext& testCtx, GLenum name, GLint reference)																																= DE_NULL;
	virtual void		verifyInteger4						(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)																		= DE_NULL;
	virtual void		verifyInteger4Mask					(tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)	= DE_NULL;
	virtual void		verifyIntegerGreaterOrEqual			(tcu::TestContext& testCtx, GLenum name, GLint reference)																																= DE_NULL;
	virtual void		verifyUnsignedIntegerGreaterOrEqual	(tcu::TestContext& testCtx, GLenum name, GLuint reference)																																= DE_NULL;
	virtual void		verifyIntegerGreaterOrEqual2		(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)																											= DE_NULL;
	virtual void		verifyIntegerAnyOf					(tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)																								= DE_NULL;
	virtual void		verifyStencilMaskInitial			(tcu::TestContext& testCtx, GLenum name, int stencilBits)																																= DE_NULL;

private:
	const char*	const	m_testNamePostfix;
};

StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
	: glu::CallLogWrapper	(gl, log)
	, m_testNamePostfix		(testNamePostfix)
{
	enableLogging(true);
}

StateVerifier::~StateVerifier ()
{
}

const char* StateVerifier::getTestNamePostfix (void) const
{
	return m_testNamePostfix;
}

// GetBooleanVerifier

class GetBooleanVerifier : public StateVerifier
{
public:
			GetBooleanVerifier					(const glw::Functions& gl, tcu::TestLog& log);
	void	verifyInteger						(tcu::TestContext& testCtx, GLenum name, GLint reference);
	void	verifyInteger4						(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
	void	verifyInteger4Mask					(tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
	void	verifyIntegerGreaterOrEqual			(tcu::TestContext& testCtx, GLenum name, GLint reference);
	void	verifyUnsignedIntegerGreaterOrEqual	(tcu::TestContext& testCtx, GLenum name, GLuint reference);
	void	verifyIntegerGreaterOrEqual2		(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
	void	verifyIntegerAnyOf					(tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
	void	verifyStencilMaskInitial			(tcu::TestContext& testCtx, GLenum name, int stencilBits);
};

GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
	: StateVerifier(gl, log, "_getboolean")
{
}

void GetBooleanVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean> state;
	glGetBooleanv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;

	if (state != expectedGLState)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (expectedGLState==GL_TRUE ? "GL_TRUE" : "GL_FALSE") << "; got " << (state == GL_TRUE ? "GL_TRUE" : (state == GL_FALSE ? "GL_FALSE" : "non-boolean")) << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
	}
}

void GetBooleanVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
{
	verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
}

void GetBooleanVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
	glGetBooleanv(name, boolVector4);

	if (!boolVector4.verifyValidity(testCtx))
		return;

	const GLboolean referenceAsGLBoolean[] =
	{
		reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
		reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
		reference2 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
		reference3 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
	};

	if ((enableRef0 && (boolVector4[0] != referenceAsGLBoolean[0])) ||
		(enableRef1 && (boolVector4[1] != referenceAsGLBoolean[1])) ||
		(enableRef2 && (boolVector4[2] != referenceAsGLBoolean[2])) ||
		(enableRef3 && (boolVector4[3] != referenceAsGLBoolean[3])))
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected "
			<< (enableRef0 ? (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
			<< (enableRef1 ? (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
			<< (enableRef2 ? (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
			<< (enableRef3 ? (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") : " - ") << TestLog::EndMessage;

		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
	}
}

void GetBooleanVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean> state;
	glGetBooleanv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
		return;

	if (state == GL_FALSE) // state is zero
	{
		if (reference > 0) // and reference is greater than zero?
		{
			testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
			if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
				testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
		}
	}
	else
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
	}
}

void GetBooleanVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean> state;
	glGetBooleanv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
		return;

	if (state == GL_FALSE) // state is zero
	{
		if (reference > 0) // and reference is greater than zero?
		{
			testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
			if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
				testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
		}
	}
	else
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
	}
}

void GetBooleanVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean[2]> boolVector;
	glGetBooleanv(name, boolVector);

	if (!boolVector.verifyValidity(testCtx))
		return;

	const GLboolean referenceAsGLBoolean[2] =
	{
		reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
		reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE
	};

	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(referenceAsGLBoolean); ++ndx)
	{
		if (boolVector[ndx] == GL_TRUE) // state is non-zero, could be greater than any integer
		{
			continue;
		}
		else if (boolVector[ndx] == GL_FALSE) // state is zero
		{
			if (referenceAsGLBoolean[ndx] > 0) // and reference is greater than zero?
			{
				testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
				if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
					testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
			}
		}
		else
		{
			testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
			if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
				testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
		}
	}
}

void GetBooleanVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean> state;
	glGetBooleanv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	for (size_t ndx = 0; ndx < referencesLength; ++ndx)
	{
		const GLboolean expectedGLState = references[ndx] ? GL_TRUE : GL_FALSE;

		if (state == expectedGLState)
			return;
	}

	testCtx.getLog() << TestLog::Message << "// ERROR: got " << (state==GL_TRUE ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
	if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
		testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
}

void GetBooleanVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
{
	// if stencilBits == 0, the mask is allowed to be either GL_TRUE or GL_FALSE
	// otherwise it must be GL_TRUE
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLboolean> state;
	glGetBooleanv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (stencilBits > 0 && state != GL_TRUE)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
	}
}

//GetIntegerVerifier

class GetIntegerVerifier : public StateVerifier
{
public:
			GetIntegerVerifier			(const glw::Functions& gl, tcu::TestLog& log);
	void	verifyInteger						(tcu::TestContext& testCtx, GLenum name, GLint reference);
	void	verifyInteger4						(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
	void	verifyInteger4Mask					(tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
	void	verifyIntegerGreaterOrEqual			(tcu::TestContext& testCtx, GLenum name, GLint reference);
	void	verifyUnsignedIntegerGreaterOrEqual	(tcu::TestContext& testCtx, GLenum name, GLuint reference);
	void	verifyIntegerGreaterOrEqual2		(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
	void	verifyIntegerAnyOf					(tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
	void	verifyStencilMaskInitial			(tcu::TestContext& testCtx, GLenum name, int stencilBits);
};

GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
	: StateVerifier(gl, log, "_getinteger")
{
}

void GetIntegerVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint> state;
	glGetIntegerv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (state != reference)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
	}
}

void GetIntegerVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
{
	verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
}

void GetIntegerVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint[4]> intVector4;
	glGetIntegerv(name, intVector4);

	if (!intVector4.verifyValidity(testCtx))
		return;

	if ((enableRef0 && (intVector4[0] != reference0)) ||
		(enableRef1 && (intVector4[1] != reference1)) ||
		(enableRef2 && (intVector4[2] != reference2)) ||
		(enableRef3 && (intVector4[3] != reference3)))
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected "
			<< (enableRef0?"":"(") << reference0 << (enableRef0?"":")") << ", "
			<< (enableRef1?"":"(") << reference1 << (enableRef1?"":")") << ", "
			<< (enableRef2?"":"(") << reference2 << (enableRef2?"":")") << ", "
			<< (enableRef3?"":"(") << reference3 << (enableRef3?"":")")	<< TestLog::EndMessage;


		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
	}
}

void GetIntegerVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint> state;
	glGetIntegerv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (state < reference)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << state << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
	}
}

void GetIntegerVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint> state;
	glGetIntegerv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (GLuint(state) < reference)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << GLuint(state) << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
	}
}

void GetIntegerVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint[2]> intVector2;
	glGetIntegerv(name, intVector2);

	if (!intVector2.verifyValidity(testCtx))
		return;

	if (intVector2[0] < reference0 || intVector2[1] < reference1)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference0 << ", " << reference1 << "; got " << intVector2[0] << ", " << intVector2[0] << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
	}
}

void GetIntegerVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint> state;
	glGetIntegerv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	for (size_t ndx = 0; ndx < referencesLength; ++ndx)
	{
		const GLint expectedGLState = references[ndx];

		if (state == expectedGLState)
			return;
	}

	testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
	if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
		testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
}

void GetIntegerVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLint> state;
	glGetIntegerv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	const GLint reference = (1 << stencilBits) - 1;

	if ((state & reference) != reference) // the least significant stencilBits bits should be on
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected minimum mask of " << reference << "; got " << state << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid mask value");
	}
}

//GetFloatVerifier

class GetFloatVerifier : public StateVerifier
{
public:
			GetFloatVerifier					(const glw::Functions& gl, tcu::TestLog& log);
	void	verifyInteger						(tcu::TestContext& testCtx, GLenum name, GLint reference);
	void	verifyInteger4						(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
	void	verifyInteger4Mask					(tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
	void	verifyIntegerGreaterOrEqual			(tcu::TestContext& testCtx, GLenum name, GLint reference);
	void	verifyUnsignedIntegerGreaterOrEqual	(tcu::TestContext& testCtx, GLenum name, GLuint reference);
	void	verifyIntegerGreaterOrEqual2		(tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
	void	verifyIntegerAnyOf					(tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
	void	verifyStencilMaskInitial			(tcu::TestContext& testCtx, GLenum name, int stencilBits);
};

GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
	: StateVerifier(gl, log, "_getfloat")
{
}

void GetFloatVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
{
	using tcu::TestLog;

	const GLfloat referenceAsFloat = GLfloat(reference);
	DE_ASSERT(reference == GLint(referenceAsFloat)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests

	StateQueryMemoryWriteGuard<GLfloat> state;
	glGetFloatv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (state != referenceAsFloat)
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected " << referenceAsFloat << "; got " << state << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
	}
}

void GetFloatVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
{
	verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
}

void GetFloatVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLfloat[4]> floatVector4;
	glGetFloatv(name, floatVector4);

	if (!floatVector4.verifyValidity(testCtx))
		return;

	if ((enableRef0 && (floatVector4[0] != GLfloat(reference0))) ||
		(enableRef1 && (floatVector4[1] != GLfloat(reference1))) ||
		(enableRef2 && (floatVector4[2] != GLfloat(reference2))) ||
		(enableRef3 && (floatVector4[3] != GLfloat(reference3))))
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected "
			<< (enableRef0?"":"(") << GLfloat(reference0) << (enableRef0?"":")") << ", "
			<< (enableRef1?"":"(") << GLfloat(reference1) << (enableRef1?"":")") << ", "
			<< (enableRef2?"":"(") << GLfloat(reference2) << (enableRef2?"":")") << ", "
			<< (enableRef3?"":"(") << GLfloat(reference3) << (enableRef3?"":")") << TestLog::EndMessage;

		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
	}
}

void GetFloatVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLfloat> state;
	glGetFloatv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (state < GLfloat(reference))
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
	}
}

void GetFloatVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLfloat> state;
	glGetFloatv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	if (GLuint(state) < GLfloat(reference))
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << GLuint(state) << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
	}
}

void GetFloatVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLfloat[2]> floatVector2;
	glGetFloatv(name, floatVector2);

	if (!floatVector2.verifyValidity(testCtx))
		return;

	if (floatVector2[0] < GLfloat(reference0) || floatVector2[1] < GLfloat(reference1))
	{
		testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference0) << ", " << GLfloat(reference1) << "; got " << floatVector2[0] << ", " << floatVector2[1] << TestLog::EndMessage;
		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
	}
}

void GetFloatVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
{
	using tcu::TestLog;

	StateQueryMemoryWriteGuard<GLfloat> state;
	glGetFloatv(name, &state);

	if (!state.verifyValidity(testCtx))
		return;

	for (size_t ndx = 0; ndx < referencesLength; ++ndx)
	{
		const GLfloat expectedGLState = GLfloat(references[ndx]);
		DE_ASSERT(references[ndx] == GLint(expectedGLState)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests

		if (state == expectedGLState)
			return;
	}

	testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
	if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
		testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
}

void GetFloatVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
{
	// checking the mask bits with float doesn't make much sense because of conversion errors
	// just verify that the value is greater or equal to the minimum value
	const GLint reference = (1 << stencilBits) - 1;
	verifyIntegerGreaterOrEqual(testCtx, name, reference);
}

} // IntegerStateQueryVerifiers

namespace
{

using namespace IntegerStateQueryVerifiers;

static const char* testVertSource					=	"void main (void)\n"
														"{\n"
														"	gl_Position = vec4(0.0);\n"
														"}\n";
static const char* testFragSource					=	"void main (void)\n"
														"{\n"
														"	gl_FragColor = vec4(0.0);\n"
														"}\n";

class ConstantMinimumValueTestCase : public ApiCase
{
public:
	ConstantMinimumValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, GLint minValue)
		: ApiCase		(context, name, description)
		, m_targetName	(targetName)
		, m_minValue	(minValue)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyUnsignedIntegerGreaterOrEqual(m_testCtx, m_targetName, m_minValue);
		expectError(GL_NO_ERROR);
	}

private:
	GLenum			m_targetName;
	GLint			m_minValue;
	StateVerifier*	m_verifier;
};

class SampleBuffersTestCase : public ApiCase
{
public:
	SampleBuffersTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		const int expectedSampleBuffers = (m_context.getRenderTarget().getNumSamples() > 1) ? 1 : 0;

		m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples()) << ", expecting GL_SAMPLE_BUFFERS to be " << expectedSampleBuffers << tcu::TestLog::EndMessage;

		m_verifier->verifyInteger(m_testCtx, GL_SAMPLE_BUFFERS, expectedSampleBuffers);
		expectError(GL_NO_ERROR);
	}

private:
	StateVerifier*	m_verifier;
};

class SamplesTestCase : public ApiCase
{
public:
	SamplesTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		// MSAA?
		if (m_context.getRenderTarget().getNumSamples() > 1)
		{
			m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples()) << tcu::TestLog::EndMessage;

			m_verifier->verifyInteger(m_testCtx, GL_SAMPLES, m_context.getRenderTarget().getNumSamples());
			expectError(GL_NO_ERROR);
		}
		else
		{
			const glw::GLint validSamples[] = {0, 1};

			m_log << tcu::TestLog::Message << "Expecting GL_SAMPLES to be 0 or 1" << tcu::TestLog::EndMessage;

			m_verifier->verifyIntegerAnyOf(m_testCtx, GL_SAMPLES, validSamples, DE_LENGTH_OF_ARRAY(validSamples));
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
};

class HintTestCase : public ApiCase
{
public:
	HintTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName)
		: ApiCase		(context, name, description)
		, m_targetName	(targetName)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
		expectError(GL_NO_ERROR);

		glHint(m_targetName, GL_NICEST);
		m_verifier->verifyInteger(m_testCtx, m_targetName, GL_NICEST);
		expectError(GL_NO_ERROR);

		glHint(m_targetName, GL_FASTEST);
		m_verifier->verifyInteger(m_testCtx, m_targetName, GL_FASTEST);
		expectError(GL_NO_ERROR);

		glHint(m_targetName, GL_DONT_CARE);
		m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
		expectError(GL_NO_ERROR);
	}

private:
	GLenum		m_targetName;
	StateVerifier*	m_verifier;
};

class DepthFuncTestCase : public ApiCase
{
public:
	DepthFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, GL_LESS);
		expectError(GL_NO_ERROR);

		const GLenum depthFunctions[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GREATER, GL_GEQUAL, GL_NOTEQUAL};
		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthFunctions); ndx++)
		{
			glDepthFunc(depthFunctions[ndx]);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, depthFunctions[ndx]);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
};

class CullFaceTestCase : public ApiCase
{
public:
	CullFaceTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, GL_BACK);
		expectError(GL_NO_ERROR);

		const GLenum cullFaces[] = {GL_FRONT, GL_BACK, GL_FRONT_AND_BACK};
		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cullFaces); ndx++)
		{
			glCullFace(cullFaces[ndx]);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, cullFaces[ndx]);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
};

class FrontFaceTestCase : public ApiCase
{
public:
	FrontFaceTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, GL_CCW);
		expectError(GL_NO_ERROR);

		const GLenum frontFaces[] = {GL_CW, GL_CCW};
		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(frontFaces); ndx++)
		{
			glFrontFace(frontFaces[ndx]);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, frontFaces[ndx]);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
};

class ViewPortTestCase : public ApiCase
{
public:
	ViewPortTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		de::Random rnd(0xabcdef);

		GLint maxViewportDimensions[2] = {0};
		glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions);

		// verify initial value of first two values
		m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
		expectError(GL_NO_ERROR);

		const int numIterations = 120;
		for (int i = 0; i < numIterations; ++i)
		{
			GLint x			= rnd.getInt(-64000, 64000);
			GLint y			= rnd.getInt(-64000, 64000);
			GLsizei width	= rnd.getInt(0, maxViewportDimensions[0]);
			GLsizei height	= rnd.getInt(0, maxViewportDimensions[1]);

			glViewport(x, y, width, height);
			m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
};

class ScissorBoxTestCase : public ApiCase
{
public:
	ScissorBoxTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		de::Random rnd(0xabcdef);

		// verify initial value
		m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
		expectError(GL_NO_ERROR);

		const int numIterations = 120;
		for (int i = 0; i < numIterations; ++i)
		{
			GLint left		= rnd.getInt(-64000, 64000);
			GLint bottom	= rnd.getInt(-64000, 64000);
			GLsizei width	= rnd.getInt(0, 64000);
			GLsizei height	= rnd.getInt(0, 64000);

			glScissor(left, bottom, width, height);
			m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, left, bottom, width, height);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
};

class MaxViewportDimsTestCase : public ApiCase
{
public:
	MaxViewportDimsTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyIntegerGreaterOrEqual2(m_testCtx, GL_MAX_VIEWPORT_DIMS, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
		expectError(GL_NO_ERROR);
	}
private:
	StateVerifier*	m_verifier;
};

class StencilRefTestCase : public ApiCase
{
public:
	StencilRefTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_testTargetName	(testTargetName)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
		expectError(GL_NO_ERROR);

		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int ref = 1 << stencilBit;

			glStencilFunc(GL_ALWAYS, ref, 0); // mask should not affect the REF
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
			expectError(GL_NO_ERROR);

			glStencilFunc(GL_ALWAYS, ref, ref);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
};

class StencilRefSeparateTestCase : public ApiCase
{
public:
	StencilRefSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace)
		: ApiCase					(context, name, description)
		, m_verifier				(verifier)
		, m_testTargetName			(testTargetName)
		, m_stencilFuncTargetFace	(stencilFuncTargetFace)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
		expectError(GL_NO_ERROR);

		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int ref = 1 << stencilBit;

			glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, 0);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
			expectError(GL_NO_ERROR);

			glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, ref);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
	GLenum		m_stencilFuncTargetFace;
};

class StencilOpTestCase : public ApiCase
{
public:
	StencilOpTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName)
		: ApiCase					(context, name, description)
		, m_verifier				(verifier)
		, m_stencilOpName			(stencilOpName)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_stencilOpName, GL_KEEP);
		expectError(GL_NO_ERROR);

		const GLenum stencilOpValues[] = {GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilOpValues); ++ndx)
		{
			SetStencilOp(stencilOpValues[ndx]);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_stencilOpName, stencilOpValues[ndx]);
			expectError(GL_NO_ERROR);
		}
	}

protected:
	virtual void SetStencilOp (GLenum stencilOpValue)
	{
		switch (m_stencilOpName)
		{
		case GL_STENCIL_FAIL:
		case GL_STENCIL_BACK_FAIL:
			glStencilOp(stencilOpValue, GL_KEEP, GL_KEEP);
			break;

		case GL_STENCIL_PASS_DEPTH_FAIL:
		case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
			glStencilOp(GL_KEEP, stencilOpValue, GL_KEEP);
			break;

		case GL_STENCIL_PASS_DEPTH_PASS:
		case GL_STENCIL_BACK_PASS_DEPTH_PASS:
			glStencilOp(GL_KEEP, GL_KEEP, stencilOpValue);
			break;

		default:
			DE_ASSERT(false && "should not happen");
			break;
		}
	}

	StateVerifier*				m_verifier;
	GLenum					m_stencilOpName;
};

class StencilOpSeparateTestCase : public StencilOpTestCase
{
public:
	StencilOpSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName, GLenum stencilOpFace)
		: StencilOpTestCase		(context, verifier, name, description, stencilOpName)
		, m_stencilOpFace		(stencilOpFace)
	{
	}

private:
	void SetStencilOp (GLenum stencilOpValue)
	{
		switch (m_stencilOpName)
		{
		case GL_STENCIL_FAIL:
		case GL_STENCIL_BACK_FAIL:
			glStencilOpSeparate(m_stencilOpFace, stencilOpValue, GL_KEEP, GL_KEEP);
			break;

		case GL_STENCIL_PASS_DEPTH_FAIL:
		case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
			glStencilOpSeparate(m_stencilOpFace, GL_KEEP, stencilOpValue, GL_KEEP);
			break;

		case GL_STENCIL_PASS_DEPTH_PASS:
		case GL_STENCIL_BACK_PASS_DEPTH_PASS:
			glStencilOpSeparate(m_stencilOpFace, GL_KEEP, GL_KEEP, stencilOpValue);
			break;

		default:
			DE_ASSERT(false && "should not happen");
			break;
		}
	}

	GLenum		m_stencilOpFace;
};

class StencilFuncTestCase : public ApiCase
{
public:
	StencilFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, GL_ALWAYS);
		expectError(GL_NO_ERROR);

		const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
		{
			glStencilFunc(stencilfuncValues[ndx], 0, 0);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, stencilfuncValues[ndx]);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_STENCIL_BACK_FUNC, stencilfuncValues[ndx]);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
};

class StencilFuncSeparateTestCase : public ApiCase
{
public:
	StencilFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilFuncName, GLenum stencilFuncFace)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_stencilFuncName	(stencilFuncName)
		, m_stencilFuncFace	(stencilFuncFace)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, GL_ALWAYS);
		expectError(GL_NO_ERROR);

		const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
		{
			glStencilFuncSeparate(m_stencilFuncFace, stencilfuncValues[ndx], 0, 0);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, stencilfuncValues[ndx]);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_stencilFuncName;
	GLenum		m_stencilFuncFace;
};

class StencilMaskTestCase : public ApiCase
{
public:
	StencilMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_testTargetName	(testTargetName)
	{
	}

	void test (void)
	{
		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
		expectError(GL_NO_ERROR);

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int mask = 1 << stencilBit;

			glStencilFunc(GL_ALWAYS, 0, mask);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
};

class StencilMaskSeparateTestCase : public ApiCase
{
public:
	StencilMaskSeparateTestCase	(Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace)
		: ApiCase					(context, name, description)
		, m_verifier				(verifier)
		, m_testTargetName			(testTargetName)
		, m_stencilFuncTargetFace	(stencilFuncTargetFace)
	{
	}

	void test (void)
	{
		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
		expectError(GL_NO_ERROR);

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int mask = 1 << stencilBit;

			glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, 0, mask);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
	GLenum		m_stencilFuncTargetFace;
};

class StencilWriteMaskTestCase : public ApiCase
{
public:
	StencilWriteMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_testTargetName	(testTargetName)
	{
	}

	void test (void)
	{
		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int mask = 1 << stencilBit;

			glStencilMask(mask);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
};

class StencilWriteMaskSeparateTestCase : public ApiCase
{
public:
	StencilWriteMaskSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilTargetFace)
		: ApiCase				(context, name, description)
		, m_verifier			(verifier)
		, m_testTargetName		(testTargetName)
		, m_stencilTargetFace	(stencilTargetFace)
	{
	}

	void test (void)
	{
		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int mask = 1 << stencilBit;

			glStencilMaskSeparate(m_stencilTargetFace, mask);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
			expectError(GL_NO_ERROR);
		}
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
	GLenum		m_stencilTargetFace;
};

class PixelStoreAlignTestCase : public ApiCase
{
public:
	PixelStoreAlignTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_testTargetName	(testTargetName)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_testTargetName, 4);
		expectError(GL_NO_ERROR);

		const int alignments[] = {1, 2, 4, 8};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(alignments); ++ndx)
		{
			const int referenceValue = alignments[ndx];

			glPixelStorei(m_testTargetName, referenceValue);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
	GLenum		m_testTargetName;
};

class BlendFuncTestCase : public ApiCase
{
public:
	BlendFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_testTargetName	(testTargetName)
		, m_initialValue	(initialValue)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
		expectError(GL_NO_ERROR);

		const GLenum blendFuncValues[] =
		{
			GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR,
			GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR,
			GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA,
			GL_SRC_ALPHA_SATURATE
		};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
		{
			const GLenum referenceValue = blendFuncValues[ndx];

			//GL_SRC_ALPHA_SATURATE is ony allowed for srcRGB or srcA
			if (referenceValue == GL_SRC_ALPHA_SATURATE &&
				!(m_testTargetName == GL_BLEND_SRC_RGB || m_testTargetName == GL_BLEND_SRC_ALPHA))
				continue;

			SetBlendFunc(referenceValue);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
			expectError(GL_NO_ERROR);
		}
	}
protected:
	virtual void SetBlendFunc (GLenum func)
	{
		switch (m_testTargetName)
		{
		case GL_BLEND_SRC_RGB:
		case GL_BLEND_SRC_ALPHA:
			glBlendFunc(func, GL_ZERO);
			break;

		case GL_BLEND_DST_RGB:
		case GL_BLEND_DST_ALPHA:
			glBlendFunc(GL_ZERO, func);
			break;

		default:
			DE_ASSERT(false && "should not happen");
			break;
		}
	}

	StateVerifier*		m_verifier;
	GLenum			m_testTargetName;
	int				m_initialValue;
};

class BlendFuncSeparateTestCase : public BlendFuncTestCase
{
public:
	BlendFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
		: BlendFuncTestCase	(context, verifier, name, description, testTargetName, initialValue)
	{
	}

	void SetBlendFunc (GLenum func)
	{
		switch (m_testTargetName)
		{
		case GL_BLEND_SRC_RGB:
			glBlendFuncSeparate(func, GL_ZERO, GL_ZERO, GL_ZERO);
			break;

		case GL_BLEND_DST_RGB:
			glBlendFuncSeparate(GL_ZERO, func, GL_ZERO, GL_ZERO);
			break;

		case GL_BLEND_SRC_ALPHA:
			glBlendFuncSeparate(GL_ZERO, GL_ZERO, func, GL_ZERO);
			break;

		case GL_BLEND_DST_ALPHA:
			glBlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, func);
			break;

		default:
			DE_ASSERT(false && "should not happen");
			break;
		}
	}
};

class BlendEquationTestCase : public ApiCase
{
public:
	BlendEquationTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
		: ApiCase			(context, name, description)
		, m_verifier		(verifier)
		, m_testTargetName	(testTargetName)
		, m_initialValue	(initialValue)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
		expectError(GL_NO_ERROR);

		const GLenum blendFuncValues[] =
		{
			GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT
		};

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
		{
			const GLenum referenceValue = blendFuncValues[ndx];

			SetBlendEquation(referenceValue);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
			expectError(GL_NO_ERROR);
		}
	}
protected:
	virtual void SetBlendEquation (GLenum equation)
	{
		glBlendEquation(equation);
	}

	StateVerifier*		m_verifier;
	GLenum			m_testTargetName;
	int				m_initialValue;
};

class BlendEquationSeparateTestCase : public BlendEquationTestCase
{
public:
	BlendEquationSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
		: BlendEquationTestCase	(context, verifier, name, description, testTargetName, initialValue)
	{
	}

protected:
	void SetBlendEquation (GLenum equation)
	{
		switch (m_testTargetName)
		{
		case GL_BLEND_EQUATION_RGB:
			glBlendEquationSeparate(equation, GL_FUNC_ADD);
			break;

		case GL_BLEND_EQUATION_ALPHA:
			glBlendEquationSeparate(GL_FUNC_ADD, equation);
			break;

		default:
			DE_ASSERT(false && "should not happen");
			break;
		}
	}
};

class ImplementationArrayTestCase : public ApiCase
{
public:
	ImplementationArrayTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum testTargetLengthTargetName, int minValue)
		: ApiCase						(context, name, description)
		, m_verifier					(verifier)
		, m_testTargetName				(testTargetName)
		, m_testTargetLengthTargetName	(testTargetLengthTargetName)
		, m_minValue					(minValue)
	{
	}

	void test (void)
	{
		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, m_testTargetLengthTargetName, m_minValue);
		expectError(GL_NO_ERROR);

		GLint targetArrayLength = 0;
		glGetIntegerv(m_testTargetLengthTargetName, &targetArrayLength);
		expectError(GL_NO_ERROR);

		if (targetArrayLength)
		{
			std::vector<GLint> queryResult;
			queryResult.resize(targetArrayLength, 0);

			glGetIntegerv(m_testTargetName, &queryResult[0]);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*		m_verifier;
	GLenum			m_testTargetName;
	GLenum			m_testTargetLengthTargetName;
	int				m_minValue;
};

class CurrentProgramBindingTestCase : public ApiCase
{
public:
	CurrentProgramBindingTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_CURRENT_PROGRAM, 0);
		expectError(GL_NO_ERROR);

		{
			GLuint shaderVert = glCreateShader(GL_VERTEX_SHADER);
			glShaderSource(shaderVert, 1, &testVertSource, DE_NULL);
			glCompileShader(shaderVert);
			expectError(GL_NO_ERROR);
			GLint compileStatus;
			glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
			checkBooleans(compileStatus, GL_TRUE);

			GLuint shaderFrag = glCreateShader(GL_FRAGMENT_SHADER);
			glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL);
			glCompileShader(shaderFrag);
			expectError(GL_NO_ERROR);
			glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
			checkBooleans(compileStatus, GL_TRUE);

			GLuint shaderProg = glCreateProgram();
			glAttachShader(shaderProg, shaderVert);
			glAttachShader(shaderProg, shaderFrag);
			glLinkProgram(shaderProg);
			expectError(GL_NO_ERROR);
			GLint linkStatus;
			glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
			checkBooleans(linkStatus, GL_TRUE);

			glUseProgram(shaderProg);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_CURRENT_PROGRAM, shaderProg);
			expectError(GL_NO_ERROR);

			glDeleteShader(shaderVert);
			glDeleteShader(shaderFrag);
			glDeleteProgram(shaderProg);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_CURRENT_PROGRAM, shaderProg);
			expectError(GL_NO_ERROR);
		}

		glUseProgram(0);
		expectError(GL_NO_ERROR);
		m_verifier->verifyInteger(m_testCtx, GL_CURRENT_PROGRAM, 0);
		expectError(GL_NO_ERROR);
	}

private:
	StateVerifier*		m_verifier;
};

class BufferBindingTestCase : public ApiCase
{
public:
	BufferBindingTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum bufferBindingName, GLenum bufferType)
		: ApiCase				(context, name, description)
		, m_verifier			(verifier)
		, m_bufferBindingName	(bufferBindingName)
		, m_bufferType			(bufferType)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_bufferBindingName, 0);
		expectError(GL_NO_ERROR);

		GLuint bufferObject = 0;
		glGenBuffers(1, &bufferObject);
		expectError(GL_NO_ERROR);

		glBindBuffer(m_bufferType, bufferObject);
		m_verifier->verifyInteger(m_testCtx, m_bufferBindingName, bufferObject);
		expectError(GL_NO_ERROR);

		glDeleteBuffers(1, &bufferObject);
		m_verifier->verifyInteger(m_testCtx, m_bufferBindingName, 0);
		expectError(GL_NO_ERROR);
	}

private:
	StateVerifier*		m_verifier;
	GLenum			m_bufferBindingName;
	GLenum			m_bufferType;
};

class StencilClearValueTestCase : public ApiCase
{
public:
	StencilClearValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, 0);
		expectError(GL_NO_ERROR);

		const int stencilBits = m_context.getRenderTarget().getStencilBits();

		for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
		{
			const int ref = 1 << stencilBit;

			glClearStencil(ref);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, ref);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*	m_verifier;
};

class ActiveTextureTestCase : public ApiCase
{
public:
	ActiveTextureTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0);
		expectError(GL_NO_ERROR);

		GLint textureUnits = 0;
		glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &textureUnits);
		expectError(GL_NO_ERROR);

		for (int ndx = 0; ndx < textureUnits; ++ndx)
		{
			glActiveTexture(GL_TEXTURE0 + ndx);
			expectError(GL_NO_ERROR);

			m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0 + ndx);
			expectError(GL_NO_ERROR);
		}
	}

private:
	StateVerifier*		m_verifier;
};

class RenderbufferBindingTestCase : public ApiCase
{
public:
	RenderbufferBindingTestCase	(Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_RENDERBUFFER_BINDING, 0);
		expectError(GL_NO_ERROR);

		GLuint renderBuffer = 0;
		glGenRenderbuffers(1, &renderBuffer);
		expectError(GL_NO_ERROR);

		glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer);
		expectError(GL_NO_ERROR);

		m_verifier->verifyInteger(m_testCtx, GL_RENDERBUFFER_BINDING, renderBuffer);
		expectError(GL_NO_ERROR);

		glDeleteRenderbuffers(1, &renderBuffer);
		m_verifier->verifyInteger(m_testCtx, GL_RENDERBUFFER_BINDING, 0);
		expectError(GL_NO_ERROR);
	}

private:
	StateVerifier*		m_verifier;
};

class TextureBindingTestCase : public ApiCase
{
public:
	TextureBindingTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testBindingName, GLenum textureType)
		: ApiCase				(context, name, description)
		, m_verifier			(verifier)
		, m_testBindingName		(testBindingName)
		, m_textureType			(textureType)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, m_testBindingName, 0);
		expectError(GL_NO_ERROR);

		GLuint texture = 0;
		glGenTextures(1, &texture);
		expectError(GL_NO_ERROR);

		glBindTexture(m_textureType, texture);
		m_verifier->verifyInteger(m_testCtx, m_testBindingName, texture);

		glDeleteTextures(1, &texture);
		expectError(GL_NO_ERROR);

		m_verifier->verifyInteger(m_testCtx, m_testBindingName, 0);
		expectError(GL_NO_ERROR);
	}
private:
	StateVerifier*	m_verifier;
	GLenum		m_testBindingName;
	GLenum		m_textureType;
};

class FrameBufferBindingTestCase : public ApiCase
{
public:
	FrameBufferBindingTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyInteger(m_testCtx, GL_FRAMEBUFFER_BINDING, 0);
		expectError(GL_NO_ERROR);

		GLuint framebufferId = 0;
		glGenFramebuffers(1, &framebufferId);
		expectError(GL_NO_ERROR);

		glBindFramebuffer(GL_FRAMEBUFFER, framebufferId);
		expectError(GL_NO_ERROR);

		m_verifier->verifyInteger(m_testCtx, GL_FRAMEBUFFER_BINDING, framebufferId);
		expectError(GL_NO_ERROR);

		glBindFramebuffer(GL_FRAMEBUFFER, 0);
		expectError(GL_NO_ERROR);

		m_verifier->verifyInteger(m_testCtx, GL_FRAMEBUFFER_BINDING, 0);
		expectError(GL_NO_ERROR);

		glBindFramebuffer(GL_FRAMEBUFFER, framebufferId);
		glDeleteFramebuffers(1, &framebufferId);
		expectError(GL_NO_ERROR);

		m_verifier->verifyInteger(m_testCtx, GL_FRAMEBUFFER_BINDING, 0);
		expectError(GL_NO_ERROR);
	}

private:
	StateVerifier*	m_verifier;
};

class ImplementationColorReadTestCase : public ApiCase
{
public:
	ImplementationColorReadTestCase	(Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		const GLint defaultColorTypes[] =
		{
			GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_5_6_5
		};
		const GLint defaultColorFormats[] =
		{
			GL_RGBA, GL_RGB, GL_ALPHA
		};

		std::vector<GLint> validColorTypes;
		std::vector<GLint> validColorFormats;

		// Defined by the spec

		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorTypes); ++ndx)
			validColorTypes.push_back(defaultColorTypes[ndx]);
		for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorFormats); ++ndx)
			validColorFormats.push_back(defaultColorFormats[ndx]);

		// Extensions

		if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888") ||
			m_context.getContextInfo().isExtensionSupported("GL_APPLE_texture_format_BGRA8888"))
			validColorFormats.push_back(GL_BGRA);

		if (m_context.getContextInfo().isExtensionSupported("GL_EXT_read_format_bgra"))
		{
			validColorFormats.push_back(GL_BGRA);
			validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
			validColorTypes.push_back(GL_UNSIGNED_SHORT_1_5_5_5_REV);
		}

		if (m_context.getContextInfo().isExtensionSupported("GL_IMG_read_format"))
		{
			validColorFormats.push_back(GL_BGRA);
			validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
		}

		if (m_context.getContextInfo().isExtensionSupported("GL_NV_sRGB_formats"))
		{
			validColorFormats.push_back(GL_SLUMINANCE_NV);
			validColorFormats.push_back(GL_SLUMINANCE_ALPHA_NV);
		}

		if (m_context.getContextInfo().isExtensionSupported("GL_NV_bgr"))
		{
			validColorFormats.push_back(GL_BGR_NV);
		}

		if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_rg"))
		{
			validColorFormats.push_back(GL_RED);
			validColorFormats.push_back(GL_RG);
		}

		m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_TYPE,	&validColorTypes[0],	validColorTypes.size());
		m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_FORMAT,	&validColorFormats[0],	validColorFormats.size());
		expectError(GL_NO_ERROR);
	}

private:
	StateVerifier*	m_verifier;
};

class BufferComponentSizeCase : public ApiCase
{
public:
	BufferComponentSizeCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
		: ApiCase		(context, name, description)
		, m_verifier	(verifier)
	{
	}

	void test (void)
	{
		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_RED_BITS,		m_context.getRenderTarget().getPixelFormat().redBits);
		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_BLUE_BITS,	m_context.getRenderTarget().getPixelFormat().blueBits);
		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_GREEN_BITS,	m_context.getRenderTarget().getPixelFormat().greenBits);
		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_ALPHA_BITS,	m_context.getRenderTarget().getPixelFormat().alphaBits);
		expectError(GL_NO_ERROR);

		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_DEPTH_BITS,	m_context.getRenderTarget().getDepthBits());
		m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_STENCIL_BITS,	m_context.getRenderTarget().getStencilBits());
		expectError(GL_NO_ERROR);
	}
private:
	StateVerifier*	m_verifier;
};

#define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK)												\
	for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++)	\
	{																							\
		StateVerifier* verifier = VERIFIERS[_verifierNdx];										\
		CODE_BLOCK;																				\
	}

} // anonymous

IntegerStateQueryTests::IntegerStateQueryTests (Context& context)
	: TestCaseGroup			(context, "integers", "Integer Values")
	, m_verifierBoolean		(DE_NULL)
	, m_verifierInteger		(DE_NULL)
	, m_verifierFloat		(DE_NULL)
{
}

IntegerStateQueryTests::~IntegerStateQueryTests (void)
{
	deinit();
}

void IntegerStateQueryTests::init (void)
{
	DE_ASSERT(m_verifierBoolean == DE_NULL);
	DE_ASSERT(m_verifierInteger == DE_NULL);
	DE_ASSERT(m_verifierFloat == DE_NULL);

	m_verifierBoolean		= new GetBooleanVerifier	(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
	m_verifierInteger		= new GetIntegerVerifier	(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
	m_verifierFloat			= new GetFloatVerifier		(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());

	const struct LimitedStateInteger
	{
		const char*		name;
		const char*		description;
		GLenum			targetName;
		GLint			value;
	} implementationMinLimits[] =
	{
		{ "subpixel_bits",						"SUBPIXEL_BITS has  a minimum value of 4",						GL_SUBPIXEL_BITS,						4	},
		{ "max_texture_size",					"MAX_TEXTURE_SIZE has  a minimum value of 64",					GL_MAX_TEXTURE_SIZE,					64	},
		{ "max_cube_map_texture_size",			"MAX_CUBE_MAP_TEXTURE_SIZE has  a minimum value of 16",			GL_MAX_CUBE_MAP_TEXTURE_SIZE,			16	},
		{ "max_vertex_attribs",					"MAX_VERTEX_ATTRIBS has  a minimum value of 8",					GL_MAX_VERTEX_ATTRIBS,					8	},
		{ "max_vertex_uniform_vectors",			"MAX_VERTEX_UNIFORM_VECTORS has  a minimum value of 128",		GL_MAX_VERTEX_UNIFORM_VECTORS,			128	},
		{ "max_varying_vectors",				"MAX_VARYING_VECTORS has  a minimum value of 8",				GL_MAX_VARYING_VECTORS,					8	},
		{ "max_combined_texture_image_units",	"MAX_COMBINED_TEXTURE_IMAGE_UNITS has  a minimum value of 8",	GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,	8	},
		{ "max_vertex_texture_image_units",		"MAX_VERTEX_TEXTURE_IMAGE_UNITS has  a minimum value of 0",		GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,		0	},
		{ "max_texture_image_units",			"MAX_TEXTURE_IMAGE_UNITS has  a minimum value of 8",			GL_MAX_TEXTURE_IMAGE_UNITS,				8	},
		{ "max_fragment_uniform_vectors",		"MAX_FRAGMENT_UNIFORM_VECTORS has  a minimum value of 16",		GL_MAX_FRAGMENT_UNIFORM_VECTORS,		16	},
		{ "max_renderbuffer_size",				"MAX_RENDERBUFFER_SIZE has  a minimum value of 1",				GL_MAX_RENDERBUFFER_SIZE,				1	},
	};

	// \note implementation defined limits have their own tests so just check the conversions to boolean and float
	StateVerifier* implementationLimitVerifiers[]	= {m_verifierBoolean,						m_verifierFloat};
	StateVerifier* normalVerifiers[]				= {m_verifierBoolean,	m_verifierInteger,	m_verifierFloat};

	for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMinLimits); testNdx++)
		FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new ConstantMinimumValueTestCase(m_context, verifier, (std::string(implementationMinLimits[testNdx].name) + verifier->getTestNamePostfix()).c_str(), implementationMinLimits[testNdx].description, implementationMinLimits[testNdx].targetName, implementationMinLimits[testNdx].value)));

	FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new SampleBuffersTestCase		(m_context,	 verifier, (std::string("sample_buffers")						+ verifier->getTestNamePostfix()).c_str(),		"SAMPLE_BUFFERS")));

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new SamplesTestCase				(m_context,	 verifier, (std::string("samples")								+ verifier->getTestNamePostfix()).c_str(),		"SAMPLES")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new HintTestCase				(m_context,	 verifier, (std::string("generate_mipmap_hint")					+ verifier->getTestNamePostfix()).c_str(),		"GENERATE_MIPMAP_HINT",				GL_GENERATE_MIPMAP_HINT)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthFuncTestCase			(m_context,	 verifier, (std::string("depth_func")							+ verifier->getTestNamePostfix()).c_str(),		"DEPTH_FUNC")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new CullFaceTestCase			(m_context,	 verifier, (std::string("cull_face_mode")						+ verifier->getTestNamePostfix()).c_str(),		"CULL_FACE_MODE")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new FrontFaceTestCase			(m_context,	 verifier, (std::string("front_face_mode")						+ verifier->getTestNamePostfix()).c_str(),		"FRONT_FACE")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new ViewPortTestCase			(m_context,	 verifier, (std::string("viewport")								+ verifier->getTestNamePostfix()).c_str(),		"VIEWPORT")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new ScissorBoxTestCase			(m_context,	 verifier, (std::string("scissor_box")							+ verifier->getTestNamePostfix()).c_str(),		"SCISSOR_BOX")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new MaxViewportDimsTestCase		(m_context,	 verifier, (std::string("max_viewport_dims")					+ verifier->getTestNamePostfix()).c_str(),		"MAX_VIEWPORT_DIMS")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new BufferComponentSizeCase		(m_context,	 verifier, (std::string("buffer_component_size")				+ verifier->getTestNamePostfix()).c_str(),		"x BITS")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase			(m_context,	 verifier, (std::string("stencil_ref")							+ verifier->getTestNamePostfix()).c_str(),		"STENCIL_REF",						GL_STENCIL_REF)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase			(m_context,	 verifier, (std::string("stencil_back_ref")						+ verifier->getTestNamePostfix()).c_str(),		"STENCIL_BACK_REF",					GL_STENCIL_BACK_REF)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase	(m_context,	 verifier, (std::string("stencil_ref_separate")					+ verifier->getTestNamePostfix()).c_str(),		"STENCIL_REF (separate)",			GL_STENCIL_REF,			GL_FRONT)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase	(m_context,	 verifier, (std::string("stencil_ref_separate_both")			+ verifier->getTestNamePostfix()).c_str(),		"STENCIL_REF (separate)",			GL_STENCIL_REF,			GL_FRONT_AND_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase	(m_context,	 verifier, (std::string("stencil_back_ref_separate")			+ verifier->getTestNamePostfix()).c_str(),		"STENCIL_BACK_REF (separate)",		GL_STENCIL_BACK_REF,	GL_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase	(m_context,	 verifier, (std::string("stencil_back_ref_separate_both")		+ verifier->getTestNamePostfix()).c_str(),		"STENCIL_BACK_REF (separate)",		GL_STENCIL_BACK_REF,	GL_FRONT_AND_BACK)));

	const struct NamedStencilOp
	{
		const char*		name;

		const char*		frontDescription;
		GLenum			frontTarget;
		const char*		backDescription;
		GLenum			backTarget;
	} stencilOps[] =
	{
		{ "fail",		"STENCIL_FAIL",				GL_STENCIL_FAIL,			"STENCIL_BACK_FAIL",			GL_STENCIL_BACK_FAIL			},
		{ "depth_fail",	"STENCIL_PASS_DEPTH_FAIL",	GL_STENCIL_PASS_DEPTH_FAIL,	"STENCIL_BACK_PASS_DEPTH_FAIL",	GL_STENCIL_BACK_PASS_DEPTH_FAIL	},
		{ "depth_pass",	"STENCIL_PASS_DEPTH_PASS",	GL_STENCIL_PASS_DEPTH_PASS,	"STENCIL_BACK_PASS_DEPTH_PASS",	GL_STENCIL_BACK_PASS_DEPTH_PASS	}
	};

	for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(stencilOps); testNdx++)
	{
		FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpTestCase			(m_context, verifier, (std::string("stencil_")		+ stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription,	stencilOps[testNdx].frontTarget)));
		FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpTestCase			(m_context, verifier, (std::string("stencil_back_")	+ stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription,	stencilOps[testNdx].backTarget)));

		FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase	(m_context, verifier, (std::string("stencil_")		+ stencilOps[testNdx].name + "_separate_both"	+ verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription,	stencilOps[testNdx].frontTarget,	GL_FRONT_AND_BACK)));
		FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase	(m_context, verifier, (std::string("stencil_back_")	+ stencilOps[testNdx].name + "_separate_both"	+ verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription,		stencilOps[testNdx].backTarget,		GL_FRONT_AND_BACK)));

		FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase	(m_context, verifier, (std::string("stencil_")		+ stencilOps[testNdx].name + "_separate"		+ verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription,	stencilOps[testNdx].frontTarget,	GL_FRONT)));
		FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase	(m_context, verifier, (std::string("stencil_back_")	+ stencilOps[testNdx].name + "_separate"		+ verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription,		stencilOps[testNdx].backTarget,		GL_BACK)));
	}

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncTestCase					(m_context, verifier,	(std::string("stencil_func")								+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_FUNC")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase			(m_context, verifier,	(std::string("stencil_func_separate")						+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_FUNC (separate)",				GL_STENCIL_FUNC,				GL_FRONT)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase			(m_context, verifier,	(std::string("stencil_func_separate_both")					+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_FUNC (separate)",				GL_STENCIL_FUNC,				GL_FRONT_AND_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase			(m_context, verifier,	(std::string("stencil_back_func_separate")					+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_FUNC (separate)",				GL_STENCIL_BACK_FUNC,			GL_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase			(m_context, verifier,	(std::string("stencil_back_func_separate_both")				+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_FUNC (separate)",				GL_STENCIL_BACK_FUNC,			GL_FRONT_AND_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase					(m_context, verifier,	(std::string("stencil_value_mask")							+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_VALUE_MASK",					GL_STENCIL_VALUE_MASK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase					(m_context, verifier,	(std::string("stencil_back_value_mask")						+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_BACK_VALUE_MASK",				GL_STENCIL_BACK_VALUE_MASK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase			(m_context, verifier,	(std::string("stencil_value_mask_separate")					+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_VALUE_MASK (separate)",		GL_STENCIL_VALUE_MASK,			GL_FRONT)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase			(m_context, verifier,	(std::string("stencil_value_mask_separate_both")			+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_VALUE_MASK (separate)",		GL_STENCIL_VALUE_MASK,			GL_FRONT_AND_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase			(m_context, verifier,	(std::string("stencil_back_value_mask_separate")			+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_BACK_VALUE_MASK (separate)",	GL_STENCIL_BACK_VALUE_MASK,		GL_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase			(m_context, verifier,	(std::string("stencil_back_value_mask_separate_both")		+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_BACK_VALUE_MASK (separate)",	GL_STENCIL_BACK_VALUE_MASK,		GL_FRONT_AND_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase			(m_context, verifier,	(std::string("stencil_writemask")							+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_WRITEMASK",					GL_STENCIL_WRITEMASK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase			(m_context, verifier,	(std::string("stencil_back_writemask")						+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_BACK_WRITEMASK",				GL_STENCIL_BACK_WRITEMASK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase	(m_context, verifier,	(std::string("stencil_writemask_separate")					+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_WRITEMASK (separate)",			GL_STENCIL_WRITEMASK,			GL_FRONT)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase	(m_context, verifier,	(std::string("stencil_writemask_separate_both")				+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_WRITEMASK (separate)",			GL_STENCIL_WRITEMASK,			GL_FRONT_AND_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase	(m_context, verifier,	(std::string("stencil_back_writemask_separate")				+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_BACK_WRITEMASK (separate)",	GL_STENCIL_BACK_WRITEMASK,		GL_BACK)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase	(m_context, verifier,	(std::string("stencil_back_writemask_separate_both")		+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_BACK_WRITEMASK (separate)",	GL_STENCIL_BACK_WRITEMASK,		GL_FRONT_AND_BACK)));

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("unpack_alignment")	+ verifier->getTestNamePostfix()).c_str(),	"UNPACK_ALIGNMENT",	GL_UNPACK_ALIGNMENT)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("pack_alignment")		+ verifier->getTestNamePostfix()).c_str(),	"PACK_ALIGNMENT",	GL_PACK_ALIGNMENT)));

	{
		const struct BlendColorState
		{
			const char*	name;
			const char*	description;
			GLenum		target;
			int			initialValue;
		} blendColorStates[] =
		{
			{ "blend_src_rgb",		"BLEND_SRC_RGB",	GL_BLEND_SRC_RGB,		GL_ONE	},
			{ "blend_src_alpha",	"BLEND_SRC_ALPHA",	GL_BLEND_SRC_ALPHA,		GL_ONE	},
			{ "blend_dst_rgb",		"BLEND_DST_RGB",	GL_BLEND_DST_RGB,		GL_ZERO	},
			{ "blend_dst_alpha",	"BLEND_DST_ALPHA",	GL_BLEND_DST_ALPHA,		GL_ZERO	}
		};
		for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendColorStates); testNdx++)
		{
			FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendFuncTestCase			(m_context, verifier, (std::string(blendColorStates[testNdx].name)					+ verifier->getTestNamePostfix()).c_str(),	blendColorStates[testNdx].description,	blendColorStates[testNdx].target,	blendColorStates[testNdx].initialValue)));
			FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendFuncSeparateTestCase	(m_context, verifier, (std::string(blendColorStates[testNdx].name) + "_separate"	+ verifier->getTestNamePostfix()).c_str(),	blendColorStates[testNdx].description,	blendColorStates[testNdx].target,	blendColorStates[testNdx].initialValue)));
		}
	}

	{
		const struct BlendEquationState
		{
			const char*	name;
			const char*	description;
			GLenum		target;
			int			initialValue;
		} blendEquationStates[] =
		{
			{ "blend_equation_rgb",		"BLEND_EQUATION_RGB",	GL_BLEND_EQUATION_RGB,		GL_FUNC_ADD	},
			{ "blend_equation_alpha",	"BLEND_EQUATION_ALPHA",	GL_BLEND_EQUATION_ALPHA,	GL_FUNC_ADD	}
		};
		for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendEquationStates); testNdx++)
		{
			FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendEquationTestCase			(m_context, verifier, (std::string(blendEquationStates[testNdx].name) +				+ verifier->getTestNamePostfix()).c_str(),		blendEquationStates[testNdx].description,	blendEquationStates[testNdx].target,	blendEquationStates[testNdx].initialValue)));
			FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendEquationSeparateTestCase	(m_context, verifier, (std::string(blendEquationStates[testNdx].name) + "_separate"	+ verifier->getTestNamePostfix()).c_str(),		blendEquationStates[testNdx].description,	blendEquationStates[testNdx].target,	blendEquationStates[testNdx].initialValue)));
		}
	}

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationArrayTestCase			(m_context, verifier, (std::string("compressed_texture_formats")	+ verifier->getTestNamePostfix()).c_str(),	"COMPRESSED_TEXTURE_FORMATS",	GL_COMPRESSED_TEXTURE_FORMATS,		GL_NUM_COMPRESSED_TEXTURE_FORMATS,	0)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationArrayTestCase			(m_context, verifier, (std::string("shader_binary_formats")			+ verifier->getTestNamePostfix()).c_str(),	"SHADER_BINARY_FORMATS",		GL_SHADER_BINARY_FORMATS,			GL_NUM_SHADER_BINARY_FORMATS,		0)));

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new BufferBindingTestCase				(m_context, verifier, (std::string("array_buffer_binding")			+ verifier->getTestNamePostfix()).c_str(),	"ARRAY_BUFFER_BINDING",			GL_ARRAY_BUFFER_BINDING,			GL_ARRAY_BUFFER)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new BufferBindingTestCase				(m_context, verifier, (std::string("element_array_buffer_binding")	+ verifier->getTestNamePostfix()).c_str(),	"ELEMENT_ARRAY_BUFFER_BINDING",	GL_ELEMENT_ARRAY_BUFFER_BINDING,	GL_ELEMENT_ARRAY_BUFFER)));

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new CurrentProgramBindingTestCase		(m_context, verifier, (std::string("current_program_binding")		+ verifier->getTestNamePostfix()).c_str(),	"CURRENT_PROGRAM")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilClearValueTestCase			(m_context, verifier, (std::string("stencil_clear_value")			+ verifier->getTestNamePostfix()).c_str(),	"STENCIL_CLEAR_VALUE")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new ActiveTextureTestCase				(m_context, verifier, (std::string("active_texture")				+ verifier->getTestNamePostfix()).c_str(),	"ACTIVE_TEXTURE")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new RenderbufferBindingTestCase			(m_context, verifier, (std::string("renderbuffer_binding")			+ verifier->getTestNamePostfix()).c_str(),	"RENDERBUFFER_BINDING")));

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new TextureBindingTestCase				(m_context, verifier, (std::string("texture_binding_2d")			+ verifier->getTestNamePostfix()).c_str(),	"TEXTURE_BINDING_2D",			GL_TEXTURE_BINDING_2D,			GL_TEXTURE_2D)));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new TextureBindingTestCase				(m_context, verifier, (std::string("texture_binding_cube_map")		+ verifier->getTestNamePostfix()).c_str(),	"TEXTURE_BINDING_CUBE_MAP",		GL_TEXTURE_BINDING_CUBE_MAP,	GL_TEXTURE_CUBE_MAP)));

	FOR_EACH_VERIFIER(normalVerifiers, addChild(new FrameBufferBindingTestCase			(m_context, verifier, (std::string("framebuffer_binding")			+ verifier->getTestNamePostfix()).c_str(),	"DRAW_FRAMEBUFFER_BINDING and READ_FRAMEBUFFER_BINDING")));
	FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationColorReadTestCase		(m_context, verifier, (std::string("implementation_color_read")		+ verifier->getTestNamePostfix()).c_str(),	"IMPLEMENTATION_COLOR_READ_TYPE and IMPLEMENTATION_COLOR_READ_FORMAT")));
}

void IntegerStateQueryTests::deinit (void)
{
	if (m_verifierBoolean)
	{
		delete m_verifierBoolean;
		m_verifierBoolean = DE_NULL;
	}
	if (m_verifierInteger)
	{
		delete m_verifierInteger;
		m_verifierInteger = DE_NULL;
	}
	if (m_verifierFloat)
	{
		delete m_verifierFloat;
		m_verifierFloat = DE_NULL;
	}

	this->TestCaseGroup::deinit();
}

} // Functional
} // gles2
} // deqp