modules/gles31/functional/es31fInternalFormatQueryTests.cpp - third_party/vulkan-cts - 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 Internal format query tests
  *//*--------------------------------------------------------------------*/

 #include "es31fInternalFormatQueryTests.hpp"
 #include "tcuTestLog.hpp"
 #include "gluRenderContext.hpp"
 #include "gluStrUtil.hpp"
 #include "gluContextInfo.hpp"
 #include "glwFunctions.hpp"
 #include "glwEnums.hpp"

 namespace deqp
 {
 namespace gles31
 {
 namespace Functional
 {
 namespace
 {

 class FormatSamplesCase : public TestCase
 {
 public:
 	enum FormatType
 	{
 		FORMAT_COLOR,
 		FORMAT_INT,
 		FORMAT_DEPTH_STENCIL
 	};

 						FormatSamplesCase	(Context& ctx, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum internalFormat, FormatType type);
 private:
 	void				init				(void);
 	IterateResult		iterate				(void);

 	const glw::GLenum	m_target;
 	const glw::GLenum	m_internalFormat;
 	const FormatType	m_type;
 };

 FormatSamplesCase::FormatSamplesCase (Context& ctx, const char* name, const char* desc, glw::GLenum target, glw::GLenum internalFormat, FormatType type)
 	: TestCase			(ctx, name, desc)
 	, m_target			(target)
 	, m_internalFormat	(internalFormat)
 	, m_type			(type)
 {
 	DE_ASSERT(m_target == GL_TEXTURE_2D_MULTISAMPLE			||
 			  m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY	||
 			  m_target == GL_RENDERBUFFER);
 }

 void FormatSamplesCase::init (void)
 {
 	const bool	isTextureTarget	=	(m_target == GL_TEXTURE_2D_MULTISAMPLE) ||
 									(m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
 	auto		ctxType			= m_context.getRenderContext().getType();
 	const bool	isES32orGL45	= glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
 								  glu::contextSupports(ctxType, glu::ApiType::core(4, 5));

 	if (!isES32orGL45 && m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
 		TCU_THROW(NotSupportedError, "Test requires OES_texture_storage_multisample_2d_array extension or a context version equal or higher than 3.2");

 	// stencil8 textures are not supported without GL_OES_texture_stencil8 extension
 	if (!isES32orGL45 && isTextureTarget && m_internalFormat == GL_STENCIL_INDEX8 && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_stencil8"))
 		TCU_THROW(NotSupportedError, "Test requires GL_OES_texture_stencil8 extension or a context version equal or higher than 3.2");
 }

 FormatSamplesCase::IterateResult FormatSamplesCase::iterate (void)
 {
 	const glw::Functions&	gl				= m_context.getRenderContext().getFunctions();
 	bool					isFloatFormat	= false;
 	bool					error			= false;
 	glw::GLint				maxSamples		= 0;
 	glw::GLint				numSampleCounts	= 0;
 	auto					ctxType			= m_context.getRenderContext().getType();
 	const bool				isES32orGL45	= glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) ||
 											  glu::contextSupports(ctxType, glu::ApiType::core(4, 5));

 	if (!isES32orGL45)
 	{
 		if (m_internalFormat == GL_RGBA16F || m_internalFormat == GL_R32F || m_internalFormat == GL_RG32F || m_internalFormat == GL_RGBA32F || m_internalFormat == GL_R16F || m_internalFormat == GL_RG16F || m_internalFormat == GL_R11F_G11F_B10F)
 		{
 			TCU_THROW(NotSupportedError, "The internal format is not supported in a context lower than 3.2");
 		}
 	}
 	else if (m_internalFormat == GL_RGBA16F || m_internalFormat == GL_R32F || m_internalFormat == GL_RG32F || m_internalFormat == GL_RGBA32F)
 	{
 		isFloatFormat = true;
 	}

 	// Lowest limit
 	{
 		const glw::GLenum samplesEnum = (m_type == FORMAT_COLOR) ? (GL_MAX_COLOR_TEXTURE_SAMPLES) : (m_type == FORMAT_INT) ? (GL_MAX_INTEGER_SAMPLES) : (GL_MAX_DEPTH_TEXTURE_SAMPLES);
 		m_testCtx.getLog() << tcu::TestLog::Message << "Format must support sample count of " << glu::getGettableStateStr(samplesEnum) << tcu::TestLog::EndMessage;

 		gl.getIntegerv(samplesEnum, &maxSamples);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "get MAX_*_SAMPLES");

 		m_testCtx.getLog() << tcu::TestLog::Message << glu::getGettableStateStr(samplesEnum) << " = " << maxSamples << tcu::TestLog::EndMessage;

 		if (maxSamples < 1)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: minimum value of "  << glu::getGettableStateStr(samplesEnum) << " is 1" << tcu::TestLog::EndMessage;
 			error = true;
 		}
 	}

 	// Number of sample counts
 	{
 		gl.getInternalformativ(m_target, m_internalFormat, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

 		m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;

 		if (!isFloatFormat)
 		{
 			if (numSampleCounts < 1)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 				error = true;
 			}
 		}
 	}

 	// Sample counts
 	{
 		tcu::MessageBuilder		samplesMsg	(&m_testCtx.getLog());
 		std::vector<glw::GLint>	samples		(numSampleCounts > 0 ? numSampleCounts : 1);

 		if (numSampleCounts > 0 || isFloatFormat)
 		{
 			gl.getInternalformativ(m_target, m_internalFormat, GL_SAMPLES, numSampleCounts, &samples[0]);
 			GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");
 		}
 		else
 			TCU_FAIL("glGetInternalFormativ() reported 0 supported sample counts");

 		// make a pretty log

 		samplesMsg << "GL_SAMPLES = [";
 		for (size_t ndx = 0; ndx < samples.size(); ++ndx)
 		{
 			if (ndx)
 				samplesMsg << ", ";
 			samplesMsg << samples[ndx];
 		}
 		samplesMsg << "]" << tcu::TestLog::EndMessage;

 		// Samples are in order
 		for (size_t ndx = 1; ndx < samples.size(); ++ndx)
 		{
 			if (samples[ndx-1] <= samples[ndx])
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Samples must be ordered descending." << tcu::TestLog::EndMessage;
 				error = true;
 				break;
 			}
 		}

 		// samples are positive
 		for (size_t ndx = 1; ndx < samples.size(); ++ndx)
 		{
 			if (samples[ndx-1] <= 0)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Only positive SAMPLES allowed." << tcu::TestLog::EndMessage;
 				error = true;
 				break;
 			}
 		}

 		// maxSamples must be supported
 		if (!isFloatFormat)
 		{
 			if (samples[0] < maxSamples)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: MAX_*_SAMPLES must be supported." << tcu::TestLog::EndMessage;
 				error = true;
 			}
 		}
 	}

 	// Result
 	if (!error)
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	else
 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");

 	return STOP;
 }

 class NumSampleCountsBufferCase : public TestCase
 {
 public:
 					NumSampleCountsBufferCase	(Context& ctx, const char* name, const char* desc);

 private:
 	IterateResult	iterate						(void);
 };

 NumSampleCountsBufferCase::NumSampleCountsBufferCase (Context& ctx, const char* name, const char* desc)
 	: TestCase(ctx, name, desc)
 {
 }

 NumSampleCountsBufferCase::IterateResult NumSampleCountsBufferCase::iterate (void)
 {
 	const glw::GLint		defaultValue	= -123; // queries always return positive values
 	const glw::Functions&	gl				= m_context.getRenderContext().getFunctions();
 	bool					error			= false;

 	// Query to larger buffer
 	{
 		glw::GLint buffer[2] = { defaultValue, defaultValue };

 		m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_NUM_SAMPLE_COUNTS to larger-than-needed buffer." << tcu::TestLog::EndMessage;
 		gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 2, buffer);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

 		if (buffer[1] != defaultValue)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: trailing values were modified." << tcu::TestLog::EndMessage;
 			error = true;
 		}
 	}

 	// Query to empty buffer
 	{
 		glw::GLint buffer[1] = { defaultValue };

 		m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_NUM_SAMPLE_COUNTS to zero-sized buffer." << tcu::TestLog::EndMessage;
 		gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 0, buffer);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

 		if (buffer[0] != defaultValue)
 		{
 			m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
 			error = true;
 		}
 	}

 	// Result
 	if (!error)
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	else
 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected buffer modification");

 	return STOP;
 }

 class SamplesBufferCase : public TestCase
 {
 public:
 					SamplesBufferCase	(Context& ctx, const char* name, const char* desc);

 private:
 	IterateResult	iterate				(void);
 };

 SamplesBufferCase::SamplesBufferCase (Context& ctx, const char* name, const char* desc)
 	: TestCase(ctx, name, desc)
 {
 }

 SamplesBufferCase::IterateResult SamplesBufferCase::iterate (void)
 {
 	const glw::GLint		defaultValue	= -123; // queries always return positive values
 	const glw::Functions&	gl				= m_context.getRenderContext().getFunctions();
 	bool					error			= false;

 	glw::GLint				numSampleCounts	= 0;

 	// Number of sample counts
 	{
 		gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
 		GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

 		m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 	}

 	if (numSampleCounts < 1)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 		error = true;
 	}
 	else
 	{
 		// Query to larger buffer
 		{
 			std::vector<glw::GLint> buffer(numSampleCounts + 1, defaultValue);

 			m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to larger-than-needed buffer." << tcu::TestLog::EndMessage;
 			gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, (glw::GLsizei)buffer.size(), &buffer[0]);
 			GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");

 			if (buffer.back() != defaultValue)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: trailing value was modified." << tcu::TestLog::EndMessage;
 				error = true;
 			}
 		}

 		// Query to smaller buffer
 		if (numSampleCounts > 2)
 		{
 			glw::GLint buffer[3] = { defaultValue, defaultValue, defaultValue };

 			m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to buffer with bufSize=2." << tcu::TestLog::EndMessage;
 			gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 2, buffer);
 			GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");

 			if (buffer[2] != defaultValue)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
 				error = true;
 			}
 		}

 		// Query to empty buffer
 		{
 			glw::GLint buffer[1] = { defaultValue };

 			m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to zero-sized buffer." << tcu::TestLog::EndMessage;
 			gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 0, buffer);
 			GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");

 			if (buffer[0] != defaultValue)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
 				error = true;
 			}
 		}
 	}

 	// Result
 	if (!error)
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	else
 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected buffer modification");

 	return STOP;
 }

 } // anonymous

 InternalFormatQueryTests::InternalFormatQueryTests (Context& context)
 	: TestCaseGroup(context, "internal_format", "Internal format queries")
 {
 }

 InternalFormatQueryTests::~InternalFormatQueryTests (void)
 {
 }

 void InternalFormatQueryTests::init (void)
 {
 	static const struct InternalFormat
 	{
 		const char*						name;
 		glw::GLenum						format;
 		FormatSamplesCase::FormatType	type;
 	} internalFormats[] =
 	{
 		// color renderable
 		{ "r8",						GL_R8,					FormatSamplesCase::FORMAT_COLOR			},
 		{ "rg8",					GL_RG8,					FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgb8",					GL_RGB8,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgb565",					GL_RGB565,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgba4",					GL_RGBA4,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgb5_a1",				GL_RGB5_A1,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgba8",					GL_RGBA8,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgb10_a2",				GL_RGB10_A2,			FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgb10_a2ui",				GL_RGB10_A2UI,			FormatSamplesCase::FORMAT_INT			},
 		{ "srgb8_alpha8",			GL_SRGB8_ALPHA8,		FormatSamplesCase::FORMAT_COLOR			},
 		{ "r8i",					GL_R8I,					FormatSamplesCase::FORMAT_INT			},
 		{ "r8ui",					GL_R8UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "r16i",					GL_R16I,				FormatSamplesCase::FORMAT_INT			},
 		{ "r16ui",					GL_R16UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "r32i",					GL_R32I,				FormatSamplesCase::FORMAT_INT			},
 		{ "r32ui",					GL_R32UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg8i",					GL_RG8I,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg8ui",					GL_RG8UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg16i",					GL_RG16I,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg16ui",					GL_RG16UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg32i",					GL_RG32I,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg32ui",					GL_RG32UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "rgba8i",					GL_RGBA8I,				FormatSamplesCase::FORMAT_INT			},
 		{ "rgba8ui",				GL_RGBA8UI,				FormatSamplesCase::FORMAT_INT			},
 		{ "rgba16i",				GL_RGBA16I,				FormatSamplesCase::FORMAT_INT			},
 		{ "rgba16ui",				GL_RGBA16UI,			FormatSamplesCase::FORMAT_INT			},
 		{ "rgba32i",				GL_RGBA32I,				FormatSamplesCase::FORMAT_INT			},
 		{ "rgba32ui",				GL_RGBA32UI,			FormatSamplesCase::FORMAT_INT			},

 		// float formats
 		{ "r16f",					GL_R16F,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rg16f",					GL_RG16F,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "rgba16f",				GL_RGBA16F,				FormatSamplesCase::FORMAT_COLOR			},
 		{ "r32f",					GL_R32F,				FormatSamplesCase::FORMAT_INT			},
 		{ "rg32f",					GL_RG32F,				FormatSamplesCase::FORMAT_INT			},
 		{ "rgba32f",				GL_RGBA32F,				FormatSamplesCase::FORMAT_INT			},
 		{ "r11f_g11f_b10f",			GL_R11F_G11F_B10F,		FormatSamplesCase::FORMAT_COLOR			},

 		// depth renderable
 		{ "depth_component16",		GL_DEPTH_COMPONENT16,	FormatSamplesCase::FORMAT_DEPTH_STENCIL	},
 		{ "depth_component24",		GL_DEPTH_COMPONENT24,	FormatSamplesCase::FORMAT_DEPTH_STENCIL	},
 		{ "depth_component32f",		GL_DEPTH_COMPONENT32F,	FormatSamplesCase::FORMAT_DEPTH_STENCIL	},
 		{ "depth24_stencil8",		GL_DEPTH24_STENCIL8,	FormatSamplesCase::FORMAT_DEPTH_STENCIL	},
 		{ "depth32f_stencil8",		GL_DEPTH32F_STENCIL8,	FormatSamplesCase::FORMAT_DEPTH_STENCIL	},

 		// stencil renderable
 		{ "stencil_index8",			GL_STENCIL_INDEX8,		FormatSamplesCase::FORMAT_DEPTH_STENCIL	}
 		// DEPTH24_STENCIL8,  duplicate
 		// DEPTH32F_STENCIL8  duplicate
 	};

 	static const struct
 	{
 		const char*	name;
 		deUint32	target;
 	} textureTargets[] =
 	{
 		{ "renderbuffer",					GL_RENDERBUFFER					},
 		{ "texture_2d_multisample",			GL_TEXTURE_2D_MULTISAMPLE		},
 		{ "texture_2d_multisample_array",	GL_TEXTURE_2D_MULTISAMPLE_ARRAY	},
 	};

 	for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(textureTargets); ++groupNdx)
 	{
 		tcu::TestCaseGroup* const	group		= new tcu::TestCaseGroup(m_testCtx, textureTargets[groupNdx].name, glu::getInternalFormatTargetName(textureTargets[groupNdx].target));
 		const glw::GLenum			texTarget	= textureTargets[groupNdx].target;

 		addChild(group);

 		for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(internalFormats); ++caseNdx)
 		{
 			const std::string name = std::string(internalFormats[caseNdx].name) + "_samples";
 			const std::string desc = std::string("Verify GL_SAMPLES of ") + internalFormats[caseNdx].name;

 			group->addChild(new FormatSamplesCase(m_context, name.c_str(), desc.c_str(), texTarget, internalFormats[caseNdx].format, internalFormats[caseNdx].type));
 		}
 	}

 	// Check buffer sizes are honored
 	{
 		tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "partial_query", "Query data to too short a buffer");

 		addChild(group);

 		group->addChild(new NumSampleCountsBufferCase	(m_context, "num_sample_counts",	"Query GL_NUM_SAMPLE_COUNTS to too short a buffer"));
 		group->addChild(new SamplesBufferCase			(m_context, "samples",				"Query GL_SAMPLES to too short a buffer"));
 	}
 }

 } // 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 Internal format query tests
	//--------------------------------------------------------------------*/

	#include "es31fInternalFormatQueryTests.hpp"
	#include "tcuTestLog.hpp"
	#include "gluRenderContext.hpp"
	#include "gluStrUtil.hpp"
	#include "gluContextInfo.hpp"
	#include "glwFunctions.hpp"
	#include "glwEnums.hpp"

	namespace deqp
	{
	namespace gles31
	{
	namespace Functional
	{
	namespace
	{

	class FormatSamplesCase : public TestCase
	{
	public:
	enum FormatType
	{
	FORMAT_COLOR,
	FORMAT_INT,
	FORMAT_DEPTH_STENCIL
	};

	FormatSamplesCase (Context& ctx, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum internalFormat, FormatType type);
	private:
	void init (void);
	IterateResult iterate (void);

	const glw::GLenum m_target;
	const glw::GLenum m_internalFormat;
	const FormatType m_type;
	};

	FormatSamplesCase::FormatSamplesCase (Context& ctx, const char* name, const char* desc, glw::GLenum target, glw::GLenum internalFormat, FormatType type)
	: TestCase (ctx, name, desc)
	, m_target (target)
	, m_internalFormat (internalFormat)
	, m_type (type)
	{
	DE_ASSERT(m_target == GL_TEXTURE_2D_MULTISAMPLE \|\|
	m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY \|\|
	m_target == GL_RENDERBUFFER);
	}

	void FormatSamplesCase::init (void)
	{
	const bool isTextureTarget = (m_target == GL_TEXTURE_2D_MULTISAMPLE) \|\|
	(m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
	auto ctxType = m_context.getRenderContext().getType();
	const bool isES32orGL45 = glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) \|\|
	glu::contextSupports(ctxType, glu::ApiType::core(4, 5));

	if (!isES32orGL45 && m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
	TCU_THROW(NotSupportedError, "Test requires OES_texture_storage_multisample_2d_array extension or a context version equal or higher than 3.2");

	// stencil8 textures are not supported without GL_OES_texture_stencil8 extension
	if (!isES32orGL45 && isTextureTarget && m_internalFormat == GL_STENCIL_INDEX8 && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_stencil8"))
	TCU_THROW(NotSupportedError, "Test requires GL_OES_texture_stencil8 extension or a context version equal or higher than 3.2");
	}

	FormatSamplesCase::IterateResult FormatSamplesCase::iterate (void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	bool isFloatFormat = false;
	bool error = false;
	glw::GLint maxSamples = 0;
	glw::GLint numSampleCounts = 0;
	auto ctxType = m_context.getRenderContext().getType();
	const bool isES32orGL45 = glu::contextSupports(ctxType, glu::ApiType::es(3, 2)) \|\|
	glu::contextSupports(ctxType, glu::ApiType::core(4, 5));

	if (!isES32orGL45)
	{
	if (m_internalFormat == GL_RGBA16F \|\| m_internalFormat == GL_R32F \|\| m_internalFormat == GL_RG32F \|\| m_internalFormat == GL_RGBA32F \|\| m_internalFormat == GL_R16F \|\| m_internalFormat == GL_RG16F \|\| m_internalFormat == GL_R11F_G11F_B10F)
	{
	TCU_THROW(NotSupportedError, "The internal format is not supported in a context lower than 3.2");
	}
	}
	else if (m_internalFormat == GL_RGBA16F \|\| m_internalFormat == GL_R32F \|\| m_internalFormat == GL_RG32F \|\| m_internalFormat == GL_RGBA32F)
	{
	isFloatFormat = true;
	}

	// Lowest limit
	{
	const glw::GLenum samplesEnum = (m_type == FORMAT_COLOR) ? (GL_MAX_COLOR_TEXTURE_SAMPLES) : (m_type == FORMAT_INT) ? (GL_MAX_INTEGER_SAMPLES) : (GL_MAX_DEPTH_TEXTURE_SAMPLES);
	m_testCtx.getLog() << tcu::TestLog::Message << "Format must support sample count of " << glu::getGettableStateStr(samplesEnum) << tcu::TestLog::EndMessage;

	gl.getIntegerv(samplesEnum, &maxSamples);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get MAX_*_SAMPLES");

	m_testCtx.getLog() << tcu::TestLog::Message << glu::getGettableStateStr(samplesEnum) << " = " << maxSamples << tcu::TestLog::EndMessage;

	if (maxSamples < 1)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: minimum value of " << glu::getGettableStateStr(samplesEnum) << " is 1" << tcu::TestLog::EndMessage;
	error = true;
	}
	}

	// Number of sample counts
	{
	gl.getInternalformativ(m_target, m_internalFormat, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

	m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;

	if (!isFloatFormat)
	{
	if (numSampleCounts < 1)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
	error = true;
	}
	}
	}

	// Sample counts
	{
	tcu::MessageBuilder samplesMsg (&m_testCtx.getLog());
	std::vector<glw::GLint> samples (numSampleCounts > 0 ? numSampleCounts : 1);

	if (numSampleCounts > 0 \|\| isFloatFormat)
	{
	gl.getInternalformativ(m_target, m_internalFormat, GL_SAMPLES, numSampleCounts, &samples[0]);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");
	}
	else
	TCU_FAIL("glGetInternalFormativ() reported 0 supported sample counts");

	// make a pretty log

	samplesMsg << "GL_SAMPLES = [";
	for (size_t ndx = 0; ndx < samples.size(); ++ndx)
	{
	if (ndx)
	samplesMsg << ", ";
	samplesMsg << samples[ndx];
	}
	samplesMsg << "]" << tcu::TestLog::EndMessage;

	// Samples are in order
	for (size_t ndx = 1; ndx < samples.size(); ++ndx)
	{
	if (samples[ndx-1] <= samples[ndx])
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Samples must be ordered descending." << tcu::TestLog::EndMessage;
	error = true;
	break;
	}
	}

	// samples are positive
	for (size_t ndx = 1; ndx < samples.size(); ++ndx)
	{
	if (samples[ndx-1] <= 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Only positive SAMPLES allowed." << tcu::TestLog::EndMessage;
	error = true;
	break;
	}
	}

	// maxSamples must be supported
	if (!isFloatFormat)
	{
	if (samples[0] < maxSamples)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: MAX_*_SAMPLES must be supported." << tcu::TestLog::EndMessage;
	error = true;
	}
	}
	}

	// Result
	if (!error)
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");

	return STOP;
	}

	class NumSampleCountsBufferCase : public TestCase
	{
	public:
	NumSampleCountsBufferCase (Context& ctx, const char* name, const char* desc);

	private:
	IterateResult iterate (void);
	};

	NumSampleCountsBufferCase::NumSampleCountsBufferCase (Context& ctx, const char* name, const char* desc)
	: TestCase(ctx, name, desc)
	{
	}

	NumSampleCountsBufferCase::IterateResult NumSampleCountsBufferCase::iterate (void)
	{
	const glw::GLint defaultValue = -123; // queries always return positive values
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	bool error = false;

	// Query to larger buffer
	{
	glw::GLint buffer[2] = { defaultValue, defaultValue };

	m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_NUM_SAMPLE_COUNTS to larger-than-needed buffer." << tcu::TestLog::EndMessage;
	gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 2, buffer);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

	if (buffer[1] != defaultValue)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: trailing values were modified." << tcu::TestLog::EndMessage;
	error = true;
	}
	}

	// Query to empty buffer
	{
	glw::GLint buffer[1] = { defaultValue };

	m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_NUM_SAMPLE_COUNTS to zero-sized buffer." << tcu::TestLog::EndMessage;
	gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 0, buffer);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

	if (buffer[0] != defaultValue)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
	error = true;
	}
	}

	// Result
	if (!error)
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected buffer modification");

	return STOP;
	}

	class SamplesBufferCase : public TestCase
	{
	public:
	SamplesBufferCase (Context& ctx, const char* name, const char* desc);

	private:
	IterateResult iterate (void);
	};

	SamplesBufferCase::SamplesBufferCase (Context& ctx, const char* name, const char* desc)
	: TestCase(ctx, name, desc)
	{
	}

	SamplesBufferCase::IterateResult SamplesBufferCase::iterate (void)
	{
	const glw::GLint defaultValue = -123; // queries always return positive values
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	bool error = false;

	glw::GLint numSampleCounts = 0;

	// Number of sample counts
	{
	gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");

	m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
	}

	if (numSampleCounts < 1)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
	error = true;
	}
	else
	{
	// Query to larger buffer
	{
	std::vector<glw::GLint> buffer(numSampleCounts + 1, defaultValue);

	m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to larger-than-needed buffer." << tcu::TestLog::EndMessage;
	gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, (glw::GLsizei)buffer.size(), &buffer[0]);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");

	if (buffer.back() != defaultValue)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: trailing value was modified." << tcu::TestLog::EndMessage;
	error = true;
	}
	}

	// Query to smaller buffer
	if (numSampleCounts > 2)
	{
	glw::GLint buffer[3] = { defaultValue, defaultValue, defaultValue };

	m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to buffer with bufSize=2." << tcu::TestLog::EndMessage;
	gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 2, buffer);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");

	if (buffer[2] != defaultValue)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
	error = true;
	}
	}

	// Query to empty buffer
	{
	glw::GLint buffer[1] = { defaultValue };

	m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to zero-sized buffer." << tcu::TestLog::EndMessage;
	gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 0, buffer);
	GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");

	if (buffer[0] != defaultValue)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
	error = true;
	}
	}
	}

	// Result
	if (!error)
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected buffer modification");

	return STOP;
	}

	} // anonymous

	InternalFormatQueryTests::InternalFormatQueryTests (Context& context)
	: TestCaseGroup(context, "internal_format", "Internal format queries")
	{
	}

	InternalFormatQueryTests::~InternalFormatQueryTests (void)
	{
	}

	void InternalFormatQueryTests::init (void)
	{
	static const struct InternalFormat
	{
	const char* name;
	glw::GLenum format;
	FormatSamplesCase::FormatType type;
	} internalFormats[] =
	{
	// color renderable
	{ "r8", GL_R8, FormatSamplesCase::FORMAT_COLOR },
	{ "rg8", GL_RG8, FormatSamplesCase::FORMAT_COLOR },
	{ "rgb8", GL_RGB8, FormatSamplesCase::FORMAT_COLOR },
	{ "rgb565", GL_RGB565, FormatSamplesCase::FORMAT_COLOR },
	{ "rgba4", GL_RGBA4, FormatSamplesCase::FORMAT_COLOR },
	{ "rgb5_a1", GL_RGB5_A1, FormatSamplesCase::FORMAT_COLOR },
	{ "rgba8", GL_RGBA8, FormatSamplesCase::FORMAT_COLOR },
	{ "rgb10_a2", GL_RGB10_A2, FormatSamplesCase::FORMAT_COLOR },
	{ "rgb10_a2ui", GL_RGB10_A2UI, FormatSamplesCase::FORMAT_INT },
	{ "srgb8_alpha8", GL_SRGB8_ALPHA8, FormatSamplesCase::FORMAT_COLOR },
	{ "r8i", GL_R8I, FormatSamplesCase::FORMAT_INT },
	{ "r8ui", GL_R8UI, FormatSamplesCase::FORMAT_INT },
	{ "r16i", GL_R16I, FormatSamplesCase::FORMAT_INT },
	{ "r16ui", GL_R16UI, FormatSamplesCase::FORMAT_INT },
	{ "r32i", GL_R32I, FormatSamplesCase::FORMAT_INT },
	{ "r32ui", GL_R32UI, FormatSamplesCase::FORMAT_INT },
	{ "rg8i", GL_RG8I, FormatSamplesCase::FORMAT_INT },
	{ "rg8ui", GL_RG8UI, FormatSamplesCase::FORMAT_INT },
	{ "rg16i", GL_RG16I, FormatSamplesCase::FORMAT_INT },
	{ "rg16ui", GL_RG16UI, FormatSamplesCase::FORMAT_INT },
	{ "rg32i", GL_RG32I, FormatSamplesCase::FORMAT_INT },
	{ "rg32ui", GL_RG32UI, FormatSamplesCase::FORMAT_INT },
	{ "rgba8i", GL_RGBA8I, FormatSamplesCase::FORMAT_INT },
	{ "rgba8ui", GL_RGBA8UI, FormatSamplesCase::FORMAT_INT },
	{ "rgba16i", GL_RGBA16I, FormatSamplesCase::FORMAT_INT },
	{ "rgba16ui", GL_RGBA16UI, FormatSamplesCase::FORMAT_INT },
	{ "rgba32i", GL_RGBA32I, FormatSamplesCase::FORMAT_INT },
	{ "rgba32ui", GL_RGBA32UI, FormatSamplesCase::FORMAT_INT },

	// float formats
	{ "r16f", GL_R16F, FormatSamplesCase::FORMAT_COLOR },
	{ "rg16f", GL_RG16F, FormatSamplesCase::FORMAT_COLOR },
	{ "rgba16f", GL_RGBA16F, FormatSamplesCase::FORMAT_COLOR },
	{ "r32f", GL_R32F, FormatSamplesCase::FORMAT_INT },
	{ "rg32f", GL_RG32F, FormatSamplesCase::FORMAT_INT },
	{ "rgba32f", GL_RGBA32F, FormatSamplesCase::FORMAT_INT },
	{ "r11f_g11f_b10f", GL_R11F_G11F_B10F, FormatSamplesCase::FORMAT_COLOR },

	// depth renderable
	{ "depth_component16", GL_DEPTH_COMPONENT16, FormatSamplesCase::FORMAT_DEPTH_STENCIL },
	{ "depth_component24", GL_DEPTH_COMPONENT24, FormatSamplesCase::FORMAT_DEPTH_STENCIL },
	{ "depth_component32f", GL_DEPTH_COMPONENT32F, FormatSamplesCase::FORMAT_DEPTH_STENCIL },
	{ "depth24_stencil8", GL_DEPTH24_STENCIL8, FormatSamplesCase::FORMAT_DEPTH_STENCIL },
	{ "depth32f_stencil8", GL_DEPTH32F_STENCIL8, FormatSamplesCase::FORMAT_DEPTH_STENCIL },

	// stencil renderable
	{ "stencil_index8", GL_STENCIL_INDEX8, FormatSamplesCase::FORMAT_DEPTH_STENCIL }
	// DEPTH24_STENCIL8, duplicate
	// DEPTH32F_STENCIL8 duplicate
	};

	static const struct
	{
	const char* name;
	deUint32 target;
	} textureTargets[] =
	{
	{ "renderbuffer", GL_RENDERBUFFER },
	{ "texture_2d_multisample", GL_TEXTURE_2D_MULTISAMPLE },
	{ "texture_2d_multisample_array", GL_TEXTURE_2D_MULTISAMPLE_ARRAY },
	};

	for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(textureTargets); ++groupNdx)
	{
	tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, textureTargets[groupNdx].name, glu::getInternalFormatTargetName(textureTargets[groupNdx].target));
	const glw::GLenum texTarget = textureTargets[groupNdx].target;

	addChild(group);

	for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(internalFormats); ++caseNdx)
	{
	const std::string name = std::string(internalFormats[caseNdx].name) + "_samples";
	const std::string desc = std::string("Verify GL_SAMPLES of ") + internalFormats[caseNdx].name;

	group->addChild(new FormatSamplesCase(m_context, name.c_str(), desc.c_str(), texTarget, internalFormats[caseNdx].format, internalFormats[caseNdx].type));
	}
	}

	// Check buffer sizes are honored
	{
	tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "partial_query", "Query data to too short a buffer");

	addChild(group);

	group->addChild(new NumSampleCountsBufferCase (m_context, "num_sample_counts", "Query GL_NUM_SAMPLE_COUNTS to too short a buffer"));
	group->addChild(new SamplesBufferCase (m_context, "samples", "Query GL_SAMPLES to too short a buffer"));
	}
	}

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