/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2014-2016 The Khronos Group Inc.
 *
 * 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
 */ /*-------------------------------------------------------------------*/

/**
 */ /*!
 * \file  es31cTextureStorageMultisampleGLCoverageTests.cpp
 * \brief Implements coverage tests for multisample textures. (ES3.1 only)
 */ /*-------------------------------------------------------------------*/

#include "es31cTextureStorageMultisampleGLCoverageTests.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuTestLog.hpp"

#include <string>
#include <vector>

namespace glcts
{
/** Constructor.
 *
 *  @param context Rendering context handle.
 **/
GLCoverageExtensionSpecificEnumsAreRecognizedTest::GLCoverageExtensionSpecificEnumsAreRecognizedTest(Context& context)
	: TestCase(context, "extension_specific_enums_are_recognized",
			   "GL_MAX_SAMPLE_MASK_WORDS, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_MAX_DEPTH_TEXTURE_SAMPLES"
			   ", GL_MAX_INTEGER_SAMPLES, GL_TEXTURE_BINDING_2D_MULTISAMPLE and"
			   " GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES enums are recognized.")
	, gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
	, to_id_2d_multisample(0)
	, to_id_2d_multisample_array(0)
{
	/* Left blank on purpose */
}

/* Deinitializes ES objects that may have been created while the test executed. */
void GLCoverageExtensionSpecificEnumsAreRecognizedTest::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (to_id_2d_multisample != 0)
	{
		gl.deleteTextures(1, &to_id_2d_multisample);

		to_id_2d_multisample = 0;
	}

	if (to_id_2d_multisample_array != 0)
	{
		gl.deleteTextures(1, &to_id_2d_multisample_array);

		to_id_2d_multisample_array = 0;
	}

	/* Call base class' deinit() */
	TestCase::deinit();
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult GLCoverageExtensionSpecificEnumsAreRecognizedTest::iterate()
{
	gl_oes_texture_storage_multisample_2d_array_supported =
		m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");

	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Iterate through all pnames that need to be verified */
	const glw::GLenum pnames[] = { GL_MAX_SAMPLE_MASK_WORDS, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_MAX_DEPTH_TEXTURE_SAMPLES,
								   GL_MAX_INTEGER_SAMPLES };
	const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]);

	for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname)
	{
		const float epsilon = (float)1e-5;
		glw::GLenum pname   = pnames[n_pname];

		/* Test glGetIntegerv() */
		glw::GLint int_value = -1;

		gl.getIntegerv(pname, &int_value);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error for a valid pname");

		if (int_value < 1)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "An invalid integer value " << int_value
							   << " was reported for pname [" << pname << "]." << tcu::TestLog::EndMessage;

			TCU_FAIL("Invalid integer value reported for pname.");
		}

		/* Test glGetBooleanv() */
		glw::GLboolean bool_value = GL_TRUE;

		gl.getBooleanv(pname, &bool_value);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error for a valid pname");

		if ((int_value != 0 && bool_value == GL_FALSE) || (int_value == 0 && bool_value != GL_FALSE))
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "An invalid boolean value [" << bool_value << "]"
							   << " was reported for pname [" << pname << "]"
							   << " (integer value reported for the same property:" << int_value << ")"
							   << tcu::TestLog::EndMessage;

			TCU_FAIL("Invalid boolean value reported for pname.");
		}

		/* Test glGetFloatv() */
		glw::GLfloat float_value = -1.0f;

		gl.getFloatv(pname, &float_value);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error for a valid pname");

		if (de::abs(float_value - float(int_value)) > epsilon)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "An invalid floating-point value [" << float_value << "]"
							   << " was reported for pname        [" << pname << "]"
							   << " (integer value reported for the same property:" << int_value << ")"
							   << tcu::TestLog::EndMessage;

			TCU_FAIL("Invalid floating-point value reported for pname.");
		}
	} /* for (all pnames) */

	/* Verify default multisample texture bindings are valid */
	glw::GLboolean bool_value  = GL_TRUE;
	const float	epsilon	 = (float)1e-5;
	glw::GLfloat   float_value = 1.0f;
	glw::GLint	 int_value   = 1;

	gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &bool_value);
	gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &float_value);
	gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &int_value);

	GLU_EXPECT_NO_ERROR(gl.getError(),
						"GL_TEXTURE_BINDING_2D_MULTISAMPLE pname was not recognized by one of the glGet*() functions");

	if (bool_value != GL_FALSE || de::abs(float_value) > epsilon || int_value != 0)
	{
		TCU_FAIL("Default GL_TEXTURE_BINDING_2D_MULTISAMPLE value is invalid");
	}

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		bool_value  = GL_TRUE;
		float_value = 1.0f;
		int_value   = 1;

		gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &bool_value);
		gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &float_value);
		gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &int_value);

		GLU_EXPECT_NO_ERROR(
			gl.getError(),
			"GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES pname was not recognized by one of the glGet*() functions");

		if (bool_value != GL_FALSE || de::abs(float_value) > epsilon || int_value != 0)
		{
			TCU_FAIL("Default GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES value is invalid");
		}
	}

	/* Generate two texture objects we will later bind to multisample texture targets to
	 * verify the values reported for corresponding pnames have also changed.
	 */
	gl.genTextures(1, &to_id_2d_multisample);

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		gl.genTextures(1, &to_id_2d_multisample_array);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");

	/* Now bind the IDs to relevant texture targets */
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id_2d_multisample);

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id_2d_multisample_array);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed");

	/* Verify new bindings are reported */
	bool_value  = GL_FALSE;
	float_value = 0.0f;
	int_value   = 0;

	gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &bool_value);
	gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &float_value);
	gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &int_value);

	GLU_EXPECT_NO_ERROR(gl.getError(),
						"GL_TEXTURE_BINDING_2D_MULTISAMPLE pname was not recognized by one of the glGet*() functions");

	glw::GLfloat expected_float_value = float(to_id_2d_multisample);

	if (bool_value != GL_TRUE || de::abs(float_value - expected_float_value) > epsilon ||
		(glw::GLuint)int_value != to_id_2d_multisample)
	{
		TCU_FAIL("GL_TEXTURE_BINDING_2D_MULTISAMPLE value is invalid");
	}

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		bool_value  = GL_FALSE;
		float_value = 0.0f;
		int_value   = 0;

		gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &bool_value);
		gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &float_value);
		gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &int_value);

		GLU_EXPECT_NO_ERROR(
			gl.getError(),
			"GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES pname was not recognized by one of the glGet*() functions");

		expected_float_value = float(to_id_2d_multisample_array);

		if (bool_value != GL_TRUE || de::abs(float_value - expected_float_value) > epsilon ||
			(glw::GLuint)int_value != to_id_2d_multisample_array)
		{
			TCU_FAIL("GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES value is invalid");
		}
	}

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}

/** Constructor.
 *
 *  @param context Rendering context handle.
 **/
GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets::
	GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets(Context& context)
	: TestCase(context, "get_tex_parameter_reports_correct_default_values_for_multisample_texture_targets",
			   "glGetTexParameter*() report correct default values for multisample texture targets.")
	, gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
	, to_id_2d(0)
	, to_id_2d_array(0)
{
	/* Left blank on purpose */
}

/* Deinitializes test-specific ES objects */
void GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (to_id_2d != 0)
	{
		gl.deleteTextures(1, &to_id_2d);

		to_id_2d = 0;
	}

	if (to_id_2d_array != 0)
	{
		gl.deleteTextures(1, &to_id_2d_array);

		to_id_2d_array = 0;
	}

	/* Call base test class' deinit() */
	TestCase::deinit();
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets::
	iterate()
{
	gl_oes_texture_storage_multisample_2d_array_supported =
		m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");

	const float			  epsilon = (float)1e-5;
	const glw::Functions& gl	  = m_context.getRenderContext().getFunctions();

	/* Generate texture objects */
	gl.genTextures(1, &to_id_2d);

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		gl.genTextures(1, &to_id_2d_array);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glGenTextures() call failed");

	/* Bind the texture objects to multisample texture targets */
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id_2d);

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id_2d_array);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glBindTexture() call failed");

	/* Initialize texture storage */
	gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 2, /* samples */
							   GL_RGBA8, 4,					 /* width */
							   4,							 /* height */
							   GL_TRUE);					 /* fixedsamplelocations */

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2, /* samples */
								   GL_RGBA8, 4,							   /* width */
								   4,									   /* height */
								   4,									   /* depth */
								   GL_TRUE);							   /* fixedsamplelocations */
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "Texture storage initialization failed");

	/* List of supported texture targets when the extension is not present. */
	glw::GLenum texture_targets_without_extension[] = { GL_TEXTURE_2D_MULTISAMPLE };

	/* List of supported texture targets when the extension is present. */
	glw::GLenum texture_targets_with_extension[] = { GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES };

	/* Iterate through all the texture targets supported for the specific case. */
	glw::GLenum* texture_targets = NULL;

	unsigned int n_texture_targets = 0;

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		n_texture_targets = sizeof(texture_targets_with_extension) / sizeof(texture_targets_with_extension[0]);
		texture_targets   = texture_targets_with_extension;
	}
	else
	{
		n_texture_targets = sizeof(texture_targets_without_extension) / sizeof(texture_targets_without_extension[0]);
		texture_targets   = texture_targets_without_extension;
	}

	for (unsigned int n_texture_target = 0; n_texture_target < n_texture_targets; ++n_texture_target)
	{
		glw::GLenum target = texture_targets[n_texture_target];

		/* Iterate through all texture parameters */
		const glw::GLenum texture_parameters[] = {
			GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_IMMUTABLE_FORMAT, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_SWIZZLE_R,
			GL_TEXTURE_SWIZZLE_G,  GL_TEXTURE_SWIZZLE_B,		GL_TEXTURE_SWIZZLE_A,

			/* The following are sampler states, hence are left out */

			// GL_TEXTURE_COMPARE_FUNC,
			// GL_TEXTURE_COMPARE_MODE,
			// GL_TEXTURE_MAG_FILTER,
			// GL_TEXTURE_MAX_LOD,
			// GL_TEXTURE_MIN_FILTER,
			// GL_TEXTURE_MIN_LOD,
			// GL_TEXTURE_WRAP_S,
			// GL_TEXTURE_WRAP_T,
			// GL_TEXTURE_WRAP_R
		};
		const unsigned int n_texture_parameters = sizeof(texture_parameters) / sizeof(texture_parameters[0]);

		for (unsigned int n_texture_parameter = 0; n_texture_parameter < n_texture_parameters; ++n_texture_parameter)
		{
			glw::GLenum texture_parameter = texture_parameters[n_texture_parameter];

			/* Query implementation for the parameter values for texture target considered */
			glw::GLint   expected_int_value = 0;
			glw::GLfloat float_value		= 0.0f;
			glw::GLint   int_value			= 0;

			gl.getTexParameterfv(target, texture_parameter, &float_value);
			gl.getTexParameteriv(target, texture_parameter, &int_value);

			GLU_EXPECT_NO_ERROR(gl.getError(), "Either of the glGetTexParameter*() calls generated an error");

			/* Verify the value is valid */
			switch (texture_parameter)
			{
			case GL_TEXTURE_BASE_LEVEL:
				expected_int_value = 0;
				break;
			case GL_TEXTURE_COMPARE_FUNC:
				expected_int_value = GL_LEQUAL;
				break;
			case GL_TEXTURE_COMPARE_MODE:
				expected_int_value = GL_NONE;
				break;
			case GL_TEXTURE_IMMUTABLE_FORMAT:
				expected_int_value = GL_TRUE;
				break;
			case GL_TEXTURE_MAG_FILTER:
				expected_int_value = GL_LINEAR;
				break;
			case GL_TEXTURE_MAX_LEVEL:
				expected_int_value = 1000;
				break;
			case GL_TEXTURE_MAX_LOD:
				expected_int_value = 1000;
				break;
			case GL_TEXTURE_MIN_FILTER:
				expected_int_value = GL_NEAREST_MIPMAP_LINEAR;
				break;
			case GL_TEXTURE_MIN_LOD:
				expected_int_value = -1000;
				break;
			case GL_TEXTURE_SWIZZLE_R:
				expected_int_value = GL_RED;
				break;
			case GL_TEXTURE_SWIZZLE_G:
				expected_int_value = GL_GREEN;
				break;
			case GL_TEXTURE_SWIZZLE_B:
				expected_int_value = GL_BLUE;
				break;
			case GL_TEXTURE_SWIZZLE_A:
				expected_int_value = GL_ALPHA;
				break;
			case GL_TEXTURE_WRAP_S:
				expected_int_value = GL_REPEAT;
				break;
			case GL_TEXTURE_WRAP_T:
				expected_int_value = GL_REPEAT;
				break;
			case GL_TEXTURE_WRAP_R:
				expected_int_value = GL_REPEAT;
				break;

			default:
			{
				TCU_FAIL("Unrecognized texture parameter name");
			}
			} /* switch (texture_parameter) */

			/* Verify integer value the implementation returned */
			if (expected_int_value != int_value)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "Implementation returned an invalid integer value of "
								   << int_value << " instead of the expected value " << expected_int_value
								   << " for property " << texture_parameter << " of texture target " << target
								   << tcu::TestLog::EndMessage;

				TCU_FAIL("Invalid integer value returned by glGetTexParameteriv()");
			}

			/* Verify floating-point value the implementation returned */
			if (de::abs(float(expected_int_value) - float_value) > epsilon)
			{
				m_testCtx.getLog() << tcu::TestLog::Message
								   << "Implementation returned an invalid floating-point value of " << float_value
								   << " instead of the expected value " << expected_int_value << " for property "
								   << texture_parameter << " of texture target " << target << tcu::TestLog::EndMessage;

				TCU_FAIL("Invalid floating-point value returned by glGetTexParameteriv()");
			}
		} /* for (all texture parameters) */
	}	 /* for (all texture targets) */

	/* All done */
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}

/** Constructor.
 *
 *  @param context Rendering context handle.
 **/
GLCoverageGLSampleMaskModeStatusIsReportedCorrectlyTest::GLCoverageGLSampleMaskModeStatusIsReportedCorrectlyTest(
	Context& context)
	: TestCase(context, "gl_sample_mask_mode_status_is_reported_correctly",
			   "glGet*() calls report correct disabled/enabled status of GL_SAMPLE_MASK mode.")
{
	/* Left blank on purpose */
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult GLCoverageGLSampleMaskModeStatusIsReportedCorrectlyTest::iterate()
{
	const float			  epsilon = (float)1e-5;
	const glw::Functions& gl	  = m_context.getRenderContext().getFunctions();

	/* Check GL_SAMPLE_MASK is disabled by default */
	glw::GLint enabled = gl.isEnabled(GL_SAMPLE_MASK);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Unexpected error generated by glIsEnabled(GL_SAMPLE_MASK) call.");

	if (enabled != GL_FALSE)
	{
		TCU_FAIL("GL_SAMPLE_MASK mode is considered enabled by default which is incorrect.");
	}

	/* Verify glGet*() calls also report the mode to be disabled */
	glw::GLboolean bool_value  = GL_TRUE;
	glw::GLfloat   float_value = 1.0f;
	glw::GLint	 int_value   = 1;

	gl.getBooleanv(GL_SAMPLE_MASK, &bool_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error when queried for GL_SAMPLE_MASK property");

	if (bool_value != GL_FALSE)
	{
		TCU_FAIL("Invalid boolean value reported for GL_SAMPLE_MASK property");
	}

	gl.getFloatv(GL_SAMPLE_MASK, &float_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error when queried for GL_SAMPLE_MASK property");

	if (de::abs(float_value - float(GL_FALSE)) > epsilon)
	{
		TCU_FAIL("Invalid float value reported for GL_SAMPLE_MASK property");
	}

	gl.getIntegerv(GL_SAMPLE_MASK, &int_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error when queried for GL_SAMPLE_MASK property");

	if (int_value != GL_FALSE)
	{
		TCU_FAIL("Invalid integer value reported for GL_SAMPLE_MASK property");
	}

	/* Enable GL_SAMPLE_MASK mode */
	gl.enable(GL_SAMPLE_MASK);

	GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_SAMPLE_MASK) call generated an unexpected error");

	/* Verify values reported by glIsEnabled(), as well as GL getters is still correct */
	enabled = gl.isEnabled(GL_SAMPLE_MASK);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glIsEnabled(GL_SAMPLE_MASK) call generated an unexpected error");

	if (enabled != GL_TRUE)
	{
		TCU_FAIL(
			"glIsEnabled(GL_SAMPLE_MASK) did not report GL_TRUE after a successful glEnable(GL_SAMPLE_MASK) call.");
	}

	gl.getBooleanv(GL_SAMPLE_MASK, &bool_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error when queried for GL_SAMPLE_MASK property");

	if (bool_value != GL_TRUE)
	{
		TCU_FAIL("Invalid boolean value reported for GL_SAMPLE_MASK property");
	}

	gl.getFloatv(GL_SAMPLE_MASK, &float_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error when queried for GL_SAMPLE_MASK property");

	if (de::abs(float_value - float(GL_TRUE)) > epsilon)
	{
		TCU_FAIL("Invalid float value reported for GL_SAMPLE_MASK property");
	}

	gl.getIntegerv(GL_SAMPLE_MASK, &int_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error when queried for GL_SAMPLE_MASK property");

	if (int_value != GL_TRUE)
	{
		TCU_FAIL("Invalid integer value reported for GL_SAMPLE_MASK property");
	}

	/* Disable the mode and see if the getters react accordingly */
	gl.disable(GL_SAMPLE_MASK);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable(GL_SAMPLE_MASK) call generated an unexpected error");

	enabled = gl.isEnabled(GL_SAMPLE_MASK);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glIsEnabled(GL_SAMPLE_MASK) call generated an unexpected error");

	if (enabled != GL_FALSE)
	{
		TCU_FAIL(
			"glIsEnabled(GL_SAMPLE_MASK) did not report GL_FALSE after a successful glDisable(GL_SAMPLE_MASK) call.");
	}

	gl.getBooleanv(GL_SAMPLE_MASK, &bool_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error when queried for GL_SAMPLE_MASK property");

	if (bool_value != GL_FALSE)
	{
		TCU_FAIL("Invalid boolean value reported for GL_SAMPLE_MASK property");
	}

	gl.getFloatv(GL_SAMPLE_MASK, &float_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error when queried for GL_SAMPLE_MASK property");

	if (de::abs(float_value - float(GL_FALSE)) > epsilon)
	{
		TCU_FAIL("Invalid float value reported for GL_SAMPLE_MASK property");
	}

	gl.getIntegerv(GL_SAMPLE_MASK, &int_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error when queried for GL_SAMPLE_MASK property");

	if (int_value != GL_FALSE)
	{
		TCU_FAIL("Invalid integer value reported for GL_SAMPLE_MASK property");
	}

	/* All good! */
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}

/** Constructor.
 *
 *  @param context Rendering context handle.
 **/
GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::
	GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest(Context& context)
	: TestCase(context, "gl_tex_parameter_handlers_accept_zero_base_level",
			   "glTexParameter*() calls should not generate an error if zero base "
			   "level is requested for 2D multisample or 2D multisample array texture targets.")
	, are_2d_array_multisample_tos_supported(false)
	, to_id_2d(0)
	, to_id_2d_array(0)
{
	/* Left blank on purpose */
}

/* Deinitializes texture objects created specifically for this test case. */
void GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (to_id_2d != 0)
	{
		gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
		gl.deleteTextures(1, &to_id_2d);
	}

	if (to_id_2d_array != 0)
	{
		gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0);
		gl.deleteTextures(1, &to_id_2d_array);
	}

	/* Call base class' deinit() */
	TestCase::deinit();
}

/* Initializes test instance: creates test-specific texture objects. */
void GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::initInternals()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Generate texture objects */
	gl.genTextures(1, &to_id_2d);

	if (are_2d_array_multisample_tos_supported)
	{
		gl.genTextures(1, &to_id_2d_array);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate texture object(s)");

	/* Bind the texture objects to extension-specific texture targets */
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id_2d);

	if (are_2d_array_multisample_tos_supported)
	{
		gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id_2d_array);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind texture object(s) to corresponding texture target(s).");
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::
	iterate()
{
	are_2d_array_multisample_tos_supported =
		m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");

	initInternals();

	/* Initialize texture storage for 2D multisample texture object */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 2 /* samples */, GL_RGBA8, 4, /* width */
							   4,														/* height */
							   GL_TRUE /* fixedsamplelocations */);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up an immutable 2D multisample texture object");

	/* Initialize texture storage for 2D multisample array texture object */
	if (are_2d_array_multisample_tos_supported)
	{
		gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2 /* samples */, GL_RGBA8, 4 /* width */,
								   4 /* height */, 4 /* depth */, GL_TRUE /* fixedsamplelocations */);

		GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up an immutable 2D multisample array texture object");
	}

	/* Force a zero base level setting for 2D multisample texture using all available glTexParameter*() entry-points */
	glw::GLfloat zero_float = 0.0f;
	glw::GLint   zero_int   = 0;

	gl.texParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 0.0f);
	gl.texParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &zero_float);
	gl.texParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 0);
	gl.texParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &zero_int);

	GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glTexParameter*() call reported an error.");

	/* Do the same for 2D multisample array texture */
	if (are_2d_array_multisample_tos_supported)
	{
		gl.texParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, 0.0f);
		gl.texParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, &zero_float);
		gl.texParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, 0);
		gl.texParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, &zero_int);

		GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glTexParameter*() call reported an error.");
	}

	/* All good! */
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}
} /* glcts namespace */