modules/gles31/functional/es31fShaderMultisampleInterpolationStateQueryTests.cpp - platform/external/deqp - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program OpenGL ES 3.1 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 Multisample interpolation state query tests
  *//*--------------------------------------------------------------------*/

 #include "es31fShaderMultisampleInterpolationStateQueryTests.hpp"
 #include "tcuTestLog.hpp"
 #include "gluCallLogWrapper.hpp"
 #include "gluContextInfo.hpp"
 #include "gluRenderContext.hpp"
 #include "glsStateQueryUtil.hpp"
 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"


 namespace deqp
 {
 namespace gles31
 {
 namespace Functional
 {
 namespace
 {

 enum VerifierType
 {
 	VERIFIER_GET_BOOLEAN = 0,
 	VERIFIER_GET_INTEGER,
 	VERIFIER_GET_FLOAT,
 	VERIFIER_GET_INTEGER64,
 };

 static void verifyGreaterOrEqual (VerifierType verifier, glw::GLenum target, float minValue, Context& context)
 {
 	glu::CallLogWrapper gl(context.getRenderContext().getFunctions(), context.getTestContext().getLog());

 	gl.enableLogging(true);

 	switch (verifier)
 	{
 		case VERIFIER_GET_BOOLEAN:
 		{
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLboolean>	value;

 			gl.glGetBooleanv(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getBoolean");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;
 			if (value != GL_TRUE && value != GL_FALSE)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Returned value is not a boolean"<< tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean");
 				return;
 			}

 			if (value > 0.0f && value == GL_FALSE)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Expected GL_TRUE, got GL_FALSE" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		case VERIFIER_GET_INTEGER:
 		{
 			const glw::GLint											refValue = (glw::GLint)deFloatFloor(minValue);
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint>	value;

 			gl.glGetIntegerv(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;

 			context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
 			if (value < refValue)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		case VERIFIER_GET_FLOAT:
 		{
 			const float														refValue = minValue;
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLfloat>	value;

 			gl.glGetFloatv(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFloat");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;

 			context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
 			if (value < refValue)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		case VERIFIER_GET_INTEGER64:
 		{
 			const glw::GLint64												refValue = (glw::GLint64)deFloatFloor(minValue);
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint64>	value;

 			gl.glGetInteger64v(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger64");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;

 			context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
 			if (value < refValue)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		default:
 			DE_ASSERT(false);
 	}
 }

 static void verifyLessOrEqual (VerifierType verifier, glw::GLenum target, float minValue, Context& context)
 {
 	glu::CallLogWrapper gl(context.getRenderContext().getFunctions(), context.getTestContext().getLog());

 	gl.enableLogging(true);

 	switch (verifier)
 	{
 		case VERIFIER_GET_BOOLEAN:
 		{
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLboolean>	value;

 			gl.glGetBooleanv(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getBoolean");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;
 			if (value != GL_TRUE && value != GL_FALSE)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Returned value is not a boolean"<< tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean");
 				return;
 			}

 			if (value < 0.0f && value == GL_FALSE)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Expected GL_TRUE, got GL_FALSE" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		case VERIFIER_GET_INTEGER:
 		{
 			const glw::GLint											refValue = (glw::GLint)deFloatCeil(minValue);
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint>	value;

 			gl.glGetIntegerv(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;

 			context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting less or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
 			if (value > refValue)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		case VERIFIER_GET_FLOAT:
 		{
 			const float														refValue = minValue;
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLfloat>	value;

 			gl.glGetFloatv(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFloat");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;

 			context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
 			if (value > refValue)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		case VERIFIER_GET_INTEGER64:
 		{
 			const glw::GLint64												refValue = (glw::GLint64)deFloatCeil(minValue);
 			gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint64>	value;

 			gl.glGetInteger64v(target, &value);
 			GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger64");

 			if (!value.verifyValidity(context.getTestContext()))
 				return;

 			context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
 			if (value > refValue)
 			{
 				context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
 				context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
 			}
 			break;
 		}

 		default:
 			DE_ASSERT(false);
 	}
 }

 class InterpolationOffsetCase : public TestCase
 {
 public:
 	enum TestType
 	{
 		TEST_MIN_OFFSET = 0,
 		TEST_MAX_OFFSET,

 		TEST_LAST
 	};

 						InterpolationOffsetCase		(Context& context, const char* name, const char* desc, VerifierType verifier, TestType testType);
 						~InterpolationOffsetCase	(void);

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

 private:
 	const VerifierType	m_verifier;
 	const TestType		m_testType;
 };

 InterpolationOffsetCase::InterpolationOffsetCase (Context& context, const char* name, const char* desc, VerifierType verifier, TestType testType)
 	: TestCase		(context, name, desc)
 	, m_verifier	(verifier)
 	, m_testType	(testType)
 {
 	DE_ASSERT(m_testType < TEST_LAST);
 }

 InterpolationOffsetCase::~InterpolationOffsetCase (void)
 {
 }

 void InterpolationOffsetCase::init (void)
 {
 	if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation"))
 		throw tcu::NotSupportedError("Test requires GL_OES_shader_multisample_interpolation extension");
 }

 InterpolationOffsetCase::IterateResult InterpolationOffsetCase::iterate (void)
 {
 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

 	if (m_testType == TEST_MAX_OFFSET)
 		verifyGreaterOrEqual(m_verifier, GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, 0.5, m_context);
 	else if (m_testType == TEST_MIN_OFFSET)
 		verifyLessOrEqual(m_verifier, GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, -0.5, m_context);
 	else
 		DE_ASSERT(false);

 	return STOP;
 }

 class FragmentInterpolationOffsetBitsCase : public TestCase
 {
 public:
 						FragmentInterpolationOffsetBitsCase		(Context& context, const char* name, const char* desc, VerifierType verifier);
 						~FragmentInterpolationOffsetBitsCase	(void);

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

 private:
 	const VerifierType	m_verifier;
 };

 FragmentInterpolationOffsetBitsCase::FragmentInterpolationOffsetBitsCase (Context& context, const char* name, const char* desc, VerifierType verifier)
 	: TestCase		(context, name, desc)
 	, m_verifier	(verifier)
 {
 }

 FragmentInterpolationOffsetBitsCase::~FragmentInterpolationOffsetBitsCase (void)
 {
 }

 void FragmentInterpolationOffsetBitsCase::init (void)
 {
 	if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation"))
 		throw tcu::NotSupportedError("Test requires GL_OES_shader_multisample_interpolation extension");
 }

 FragmentInterpolationOffsetBitsCase::IterateResult FragmentInterpolationOffsetBitsCase::iterate (void)
 {
 	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	verifyGreaterOrEqual(m_verifier, GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, 4.0, m_context);
 	return STOP;
 }

 } // anonymous

 ShaderMultisampleInterpolationStateQueryTests::ShaderMultisampleInterpolationStateQueryTests (Context& context)
 	: TestCaseGroup(context, "multisample_interpolation", "Test multisample interpolation states")
 {
 }

 ShaderMultisampleInterpolationStateQueryTests::~ShaderMultisampleInterpolationStateQueryTests (void)
 {
 }

 void ShaderMultisampleInterpolationStateQueryTests::init (void)
 {
 	static const struct Verifier
 	{
 		VerifierType	verifier;
 		const char*		name;
 		const char*		desc;
 	} verifiers[] =
 	{
 		{ VERIFIER_GET_BOOLEAN,		"get_boolean",		"Test using getBoolean"		},
 		{ VERIFIER_GET_INTEGER,		"get_integer",		"Test using getInteger"		},
 		{ VERIFIER_GET_FLOAT,		"get_float",		"Test using getFloat"		},
 		{ VERIFIER_GET_INTEGER64,	"get_integer64",	"Test using getInteger64"	},
 	};

 	// .min_fragment_interpolation_offset
 	{
 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "min_fragment_interpolation_offset", "Test MIN_FRAGMENT_INTERPOLATION_OFFSET");
 		addChild(group);

 		for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
 			group->addChild(new InterpolationOffsetCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier, InterpolationOffsetCase::TEST_MIN_OFFSET));
 	}

 	// .max_fragment_interpolation_offset
 	{
 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "max_fragment_interpolation_offset", "Test MAX_FRAGMENT_INTERPOLATION_OFFSET");
 		addChild(group);

 		for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
 			group->addChild(new InterpolationOffsetCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier, InterpolationOffsetCase::TEST_MAX_OFFSET));
 	}

 	// .fragment_interpolation_offset_bits
 	{
 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "fragment_interpolation_offset_bits", "Test FRAGMENT_INTERPOLATION_OFFSET_BITS");
 		addChild(group);

 		for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
 			group->addChild(new FragmentInterpolationOffsetBitsCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier));
 	}
 }

 } // Functional
 } // gles31
 } // deqp
	/*-------------------------------------------------------------------------
	* drawElements Quality Program OpenGL ES 3.1 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 Multisample interpolation state query tests
	//--------------------------------------------------------------------*/

	#include "es31fShaderMultisampleInterpolationStateQueryTests.hpp"
	#include "tcuTestLog.hpp"
	#include "gluCallLogWrapper.hpp"
	#include "gluContextInfo.hpp"
	#include "gluRenderContext.hpp"
	#include "glsStateQueryUtil.hpp"
	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"


	namespace deqp
	{
	namespace gles31
	{
	namespace Functional
	{
	namespace
	{

	enum VerifierType
	{
	VERIFIER_GET_BOOLEAN = 0,
	VERIFIER_GET_INTEGER,
	VERIFIER_GET_FLOAT,
	VERIFIER_GET_INTEGER64,
	};

	static void verifyGreaterOrEqual (VerifierType verifier, glw::GLenum target, float minValue, Context& context)
	{
	glu::CallLogWrapper gl(context.getRenderContext().getFunctions(), context.getTestContext().getLog());

	gl.enableLogging(true);

	switch (verifier)
	{
	case VERIFIER_GET_BOOLEAN:
	{
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLboolean> value;

	gl.glGetBooleanv(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getBoolean");

	if (!value.verifyValidity(context.getTestContext()))
	return;
	if (value != GL_TRUE && value != GL_FALSE)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Returned value is not a boolean"<< tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean");
	return;
	}

	if (value > 0.0f && value == GL_FALSE)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Expected GL_TRUE, got GL_FALSE" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	case VERIFIER_GET_INTEGER:
	{
	const glw::GLint refValue = (glw::GLint)deFloatFloor(minValue);
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint> value;

	gl.glGetIntegerv(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger");

	if (!value.verifyValidity(context.getTestContext()))
	return;

	context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
	if (value < refValue)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	case VERIFIER_GET_FLOAT:
	{
	const float refValue = minValue;
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLfloat> value;

	gl.glGetFloatv(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFloat");

	if (!value.verifyValidity(context.getTestContext()))
	return;

	context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
	if (value < refValue)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	case VERIFIER_GET_INTEGER64:
	{
	const glw::GLint64 refValue = (glw::GLint64)deFloatFloor(minValue);
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint64> value;

	gl.glGetInteger64v(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger64");

	if (!value.verifyValidity(context.getTestContext()))
	return;

	context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
	if (value < refValue)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	default:
	DE_ASSERT(false);
	}
	}

	static void verifyLessOrEqual (VerifierType verifier, glw::GLenum target, float minValue, Context& context)
	{
	glu::CallLogWrapper gl(context.getRenderContext().getFunctions(), context.getTestContext().getLog());

	gl.enableLogging(true);

	switch (verifier)
	{
	case VERIFIER_GET_BOOLEAN:
	{
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLboolean> value;

	gl.glGetBooleanv(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getBoolean");

	if (!value.verifyValidity(context.getTestContext()))
	return;
	if (value != GL_TRUE && value != GL_FALSE)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Returned value is not a boolean"<< tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean");
	return;
	}

	if (value < 0.0f && value == GL_FALSE)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Expected GL_TRUE, got GL_FALSE" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	case VERIFIER_GET_INTEGER:
	{
	const glw::GLint refValue = (glw::GLint)deFloatCeil(minValue);
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint> value;

	gl.glGetIntegerv(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger");

	if (!value.verifyValidity(context.getTestContext()))
	return;

	context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting less or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
	if (value > refValue)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	case VERIFIER_GET_FLOAT:
	{
	const float refValue = minValue;
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLfloat> value;

	gl.glGetFloatv(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getFloat");

	if (!value.verifyValidity(context.getTestContext()))
	return;

	context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
	if (value > refValue)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	case VERIFIER_GET_INTEGER64:
	{
	const glw::GLint64 refValue = (glw::GLint64)deFloatCeil(minValue);
	gls::StateQueryUtil::StateQueryMemoryWriteGuard<glw::GLint64> value;

	gl.glGetInteger64v(target, &value);
	GLU_EXPECT_NO_ERROR(gl.glGetError(), "getInteger64");

	if (!value.verifyValidity(context.getTestContext()))
	return;

	context.getTestContext().getLog() << tcu::TestLog::Message << "Expecting greater or equal to " << refValue << ", got " << value << tcu::TestLog::EndMessage;
	if (value > refValue)
	{
	context.getTestContext().getLog() << tcu::TestLog::Message << "Value not in valid range" << tcu::TestLog::EndMessage;
	context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
	}
	break;
	}

	default:
	DE_ASSERT(false);
	}
	}

	class InterpolationOffsetCase : public TestCase
	{
	public:
	enum TestType
	{
	TEST_MIN_OFFSET = 0,
	TEST_MAX_OFFSET,

	TEST_LAST
	};

	InterpolationOffsetCase (Context& context, const char* name, const char* desc, VerifierType verifier, TestType testType);
	~InterpolationOffsetCase (void);

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

	private:
	const VerifierType m_verifier;
	const TestType m_testType;
	};

	InterpolationOffsetCase::InterpolationOffsetCase (Context& context, const char* name, const char* desc, VerifierType verifier, TestType testType)
	: TestCase (context, name, desc)
	, m_verifier (verifier)
	, m_testType (testType)
	{
	DE_ASSERT(m_testType < TEST_LAST);
	}

	InterpolationOffsetCase::~InterpolationOffsetCase (void)
	{
	}

	void InterpolationOffsetCase::init (void)
	{
	if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation"))
	throw tcu::NotSupportedError("Test requires GL_OES_shader_multisample_interpolation extension");
	}

	InterpolationOffsetCase::IterateResult InterpolationOffsetCase::iterate (void)
	{
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	if (m_testType == TEST_MAX_OFFSET)
	verifyGreaterOrEqual(m_verifier, GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, 0.5, m_context);
	else if (m_testType == TEST_MIN_OFFSET)
	verifyLessOrEqual(m_verifier, GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, -0.5, m_context);
	else
	DE_ASSERT(false);

	return STOP;
	}

	class FragmentInterpolationOffsetBitsCase : public TestCase
	{
	public:
	FragmentInterpolationOffsetBitsCase (Context& context, const char* name, const char* desc, VerifierType verifier);
	~FragmentInterpolationOffsetBitsCase (void);

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

	private:
	const VerifierType m_verifier;
	};

	FragmentInterpolationOffsetBitsCase::FragmentInterpolationOffsetBitsCase (Context& context, const char* name, const char* desc, VerifierType verifier)
	: TestCase (context, name, desc)
	, m_verifier (verifier)
	{
	}

	FragmentInterpolationOffsetBitsCase::~FragmentInterpolationOffsetBitsCase (void)
	{
	}

	void FragmentInterpolationOffsetBitsCase::init (void)
	{
	if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation"))
	throw tcu::NotSupportedError("Test requires GL_OES_shader_multisample_interpolation extension");
	}

	FragmentInterpolationOffsetBitsCase::IterateResult FragmentInterpolationOffsetBitsCase::iterate (void)
	{
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	verifyGreaterOrEqual(m_verifier, GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, 4.0, m_context);
	return STOP;
	}

	} // anonymous

	ShaderMultisampleInterpolationStateQueryTests::ShaderMultisampleInterpolationStateQueryTests (Context& context)
	: TestCaseGroup(context, "multisample_interpolation", "Test multisample interpolation states")
	{
	}

	ShaderMultisampleInterpolationStateQueryTests::~ShaderMultisampleInterpolationStateQueryTests (void)
	{
	}

	void ShaderMultisampleInterpolationStateQueryTests::init (void)
	{
	static const struct Verifier
	{
	VerifierType verifier;
	const char* name;
	const char* desc;
	} verifiers[] =
	{
	{ VERIFIER_GET_BOOLEAN, "get_boolean", "Test using getBoolean" },
	{ VERIFIER_GET_INTEGER, "get_integer", "Test using getInteger" },
	{ VERIFIER_GET_FLOAT, "get_float", "Test using getFloat" },
	{ VERIFIER_GET_INTEGER64, "get_integer64", "Test using getInteger64" },
	};

	// .min_fragment_interpolation_offset
	{
	tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "min_fragment_interpolation_offset", "Test MIN_FRAGMENT_INTERPOLATION_OFFSET");
	addChild(group);

	for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
	group->addChild(new InterpolationOffsetCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier, InterpolationOffsetCase::TEST_MIN_OFFSET));
	}

	// .max_fragment_interpolation_offset
	{
	tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "max_fragment_interpolation_offset", "Test MAX_FRAGMENT_INTERPOLATION_OFFSET");
	addChild(group);

	for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
	group->addChild(new InterpolationOffsetCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier, InterpolationOffsetCase::TEST_MAX_OFFSET));
	}

	// .fragment_interpolation_offset_bits
	{
	tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "fragment_interpolation_offset_bits", "Test FRAGMENT_INTERPOLATION_OFFSET_BITS");
	addChild(group);

	for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx)
	group->addChild(new FragmentInterpolationOffsetBitsCase(m_context, verifiers[verifierNdx].name, verifiers[verifierNdx].desc, verifiers[verifierNdx].verifier));
	}
	}

	} // Functional
	} // gles31
	} // deqp