/*-------------------------------------------------------------------------
 * 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  es31cTextureStorageMultisampleGetTexLevelParameterifvTests.cpp
 * \brief Verifies glGetTexLevelParameter(if)v() entry points work correctly.
 *        (ES3.1 only)
 */ /*-------------------------------------------------------------------*/

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

#include <algorithm>
#include <map>
#include <string>
#include <vector>

namespace glcts
{
/** Constructor.
 *
 *  @param context CTS context handle.
 **/
MultisampleTextureGetTexLevelParametervFunctionalTest::MultisampleTextureGetTexLevelParametervFunctionalTest(
	Context& context)
	: TestCase(context, "functional_test", "Verifies glGetTexLevelParameter{if}v() entry-points "
										   "work correctly for all ES3.1 texture targets.")
	, gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
	, to_2d(0)
	, to_2d_array(0)
	, to_2d_multisample(0)
	, to_2d_multisample_array(0)
	, to_3d(0)
	, to_cubemap(0)
{
	/* Left blank on purpose */
}

/** Deinitializes GL ES objects used by the test */
void MultisampleTextureGetTexLevelParametervFunctionalTest::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

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

		to_2d = 0;
	}

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

		to_2d_array = 0;
	}

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

		to_2d_multisample = 0;
	}

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

		to_2d_multisample_array = 0;
	}

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

		to_3d = 0;
	}

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

		to_cubemap = 0;
	}

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

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing.
 */
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervFunctionalTest::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();

	/* Retrieve maximum number of sample supported by the implementation for GL_RGB565 internalformat
	 * used for GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES texture target.
	 */
	glw::GLint max_rgb565_internalformat_samples = 0;

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_RGB565, GL_SAMPLES, 1,
							   &max_rgb565_internalformat_samples);
		GLU_EXPECT_NO_ERROR(gl.getError(),
							"Could not retrieve maximum supported amount of samples for RGB565 internalformat");
	}

	/* Set up texture property descriptors. We'll use these later to set up texture objects
	 * in an automated manner.
	 */
	_texture_properties texture_2d_array_properties;
	_texture_properties texture_2d_multisample_array_properties;
	_texture_properties texture_2d_multisample_properties;
	_texture_properties texture_2d_properties;
	_texture_properties texture_3d_properties;
	_texture_properties texture_cm_face_properties;

	_texture_properties* texture_descriptors_with_extension[] = { &texture_2d_array_properties,
																  &texture_2d_multisample_array_properties,
																  &texture_2d_multisample_properties,
																  &texture_2d_properties,
																  &texture_3d_properties,
																  &texture_cm_face_properties };

	_texture_properties* texture_descriptors_without_extension[] = { &texture_2d_array_properties,
																	 &texture_2d_multisample_properties,
																	 &texture_2d_properties, &texture_3d_properties,
																	 &texture_cm_face_properties };

	unsigned int		  n_texture_descriptors = 0;
	_texture_properties** texture_descriptors   = NULL;

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		n_texture_descriptors =
			sizeof(texture_descriptors_with_extension) / sizeof(texture_descriptors_with_extension[0]);
		texture_descriptors = texture_descriptors_with_extension;
	}
	else
	{
		n_texture_descriptors =
			sizeof(texture_descriptors_without_extension) / sizeof(texture_descriptors_without_extension[0]);
		texture_descriptors = texture_descriptors_without_extension;
	}

	/* GL_TEXTURE_2D */
	texture_2d_properties.format		 = GL_DEPTH_STENCIL;
	texture_2d_properties.height		 = 16;
	texture_2d_properties.internalformat = GL_DEPTH24_STENCIL8;
	texture_2d_properties.is_2d_texture  = true;
	texture_2d_properties.target		 = GL_TEXTURE_2D;
	texture_2d_properties.to_id_ptr		 = &to_2d;
	texture_2d_properties.type			 = GL_UNSIGNED_INT_24_8;
	texture_2d_properties.width			 = 16;

	texture_2d_properties.expected_compressed		  = GL_FALSE;
	texture_2d_properties.expected_texture_alpha_size = 0;
	texture_2d_properties.expected_texture_alpha_types.push_back(GL_NONE);
	texture_2d_properties.expected_texture_blue_size = 0;
	texture_2d_properties.expected_texture_blue_types.push_back(GL_NONE);
	texture_2d_properties.expected_texture_depth	  = 1;
	texture_2d_properties.expected_texture_depth_size = 24;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_properties.expected_texture_depth_types.push_back(GL_UNSIGNED_INT);
	texture_2d_properties.expected_texture_depth_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_properties.expected_texture_fixed_sample_locations = GL_TRUE;
	texture_2d_properties.expected_texture_green_size			  = 0;
	texture_2d_properties.expected_texture_green_types.push_back(GL_NONE);
	texture_2d_properties.expected_texture_height		   = 16;
	texture_2d_properties.expected_texture_internal_format = GL_DEPTH24_STENCIL8;
	texture_2d_properties.expected_texture_red_size		   = 0;
	texture_2d_properties.expected_texture_red_types.push_back(GL_NONE);
	texture_2d_properties.expected_texture_samples		= 0;
	texture_2d_properties.expected_texture_shared_size  = 0;
	texture_2d_properties.expected_texture_stencil_size = 8;
	texture_2d_properties.expected_texture_width		= 16;

	/* GL_TEXTURE_2D_ARRAY */
	texture_2d_array_properties.depth		   = 32;
	texture_2d_array_properties.format		   = GL_RGBA;
	texture_2d_array_properties.height		   = 32;
	texture_2d_array_properties.internalformat = GL_RGBA8;
	texture_2d_array_properties.is_2d_texture  = false;
	texture_2d_array_properties.target		   = GL_TEXTURE_2D_ARRAY;
	texture_2d_array_properties.to_id_ptr	  = &to_2d_array;
	texture_2d_array_properties.type		   = GL_UNSIGNED_BYTE;
	texture_2d_array_properties.width		   = 32;

	texture_2d_array_properties.expected_compressed			= GL_FALSE;
	texture_2d_array_properties.expected_texture_alpha_size = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_array_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_array_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_INT);
	texture_2d_array_properties.expected_texture_blue_size = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_INT);
	texture_2d_array_properties.expected_texture_depth		= 32;
	texture_2d_array_properties.expected_texture_depth_size = 0;
	texture_2d_array_properties.expected_texture_depth_types.push_back(GL_NONE);
	texture_2d_array_properties.expected_texture_fixed_sample_locations = GL_TRUE;
	texture_2d_array_properties.expected_texture_green_size				= 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_INT);
	texture_2d_array_properties.expected_texture_height			 = 32;
	texture_2d_array_properties.expected_texture_internal_format = GL_RGBA8;
	texture_2d_array_properties.expected_texture_red_size		 = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_INT);
	texture_2d_array_properties.expected_texture_samples	  = 0;
	texture_2d_array_properties.expected_texture_shared_size  = 0;
	texture_2d_array_properties.expected_texture_stencil_size = 0;
	texture_2d_array_properties.expected_texture_width		  = 32;

	/* GL_TEXTURE_2D_MULTISAMPLE */
	texture_2d_multisample_properties.fixedsamplelocations   = GL_FALSE;
	texture_2d_multisample_properties.format				 = GL_RGBA_INTEGER;
	texture_2d_multisample_properties.height				 = 8;
	texture_2d_multisample_properties.internalformat		 = GL_RGBA8UI;
	texture_2d_multisample_properties.is_2d_texture			 = true;
	texture_2d_multisample_properties.is_multisample_texture = true;
	texture_2d_multisample_properties.samples				 = 1;
	texture_2d_multisample_properties.target				 = GL_TEXTURE_2D_MULTISAMPLE;
	texture_2d_multisample_properties.to_id_ptr				 = &to_2d_multisample;
	texture_2d_multisample_properties.type					 = GL_UNSIGNED_INT;
	texture_2d_multisample_properties.width					 = 8;

	texture_2d_multisample_properties.expected_compressed		  = GL_FALSE;
	texture_2d_multisample_properties.expected_texture_alpha_size = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_properties.expected_texture_blue_size = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_properties.expected_texture_depth	  = 1;
	texture_2d_multisample_properties.expected_texture_depth_size = 0;
	texture_2d_multisample_properties.expected_texture_depth_types.push_back(GL_NONE);
	texture_2d_multisample_properties.expected_texture_fixed_sample_locations = GL_FALSE;
	texture_2d_multisample_properties.expected_texture_green_size			  = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_properties.expected_texture_green_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_properties.expected_texture_green_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_properties.expected_texture_height		   = 8;
	texture_2d_multisample_properties.expected_texture_internal_format = GL_RGBA8UI;
	texture_2d_multisample_properties.expected_texture_red_size		   = 8;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_properties.expected_texture_red_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_properties.expected_texture_red_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_properties.expected_texture_samples		= 1;
	texture_2d_multisample_properties.expected_texture_shared_size  = 0;
	texture_2d_multisample_properties.expected_texture_stencil_size = 0;
	texture_2d_multisample_properties.expected_texture_width		= 8;

	/* GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES */
	texture_2d_multisample_array_properties.depth				   = 4; /* note: test spec missed this bit */
	texture_2d_multisample_array_properties.fixedsamplelocations   = GL_TRUE;
	texture_2d_multisample_array_properties.format				   = GL_RGB;
	texture_2d_multisample_array_properties.height				   = 4;
	texture_2d_multisample_array_properties.internalformat		   = GL_RGB565;
	texture_2d_multisample_array_properties.is_2d_texture		   = false;
	texture_2d_multisample_array_properties.is_multisample_texture = true;
	texture_2d_multisample_array_properties.samples				   = max_rgb565_internalformat_samples;
	texture_2d_multisample_array_properties.target				   = GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
	texture_2d_multisample_array_properties.to_id_ptr			   = &to_2d_multisample_array;
	texture_2d_multisample_array_properties.type				   = GL_UNSIGNED_BYTE;
	texture_2d_multisample_array_properties.width				   = 4;

	texture_2d_multisample_array_properties.expected_compressed			= GL_FALSE;
	texture_2d_multisample_array_properties.expected_texture_alpha_size = 0;
	texture_2d_multisample_array_properties.expected_texture_alpha_types.push_back(GL_NONE);
	texture_2d_multisample_array_properties.expected_texture_blue_size = 5;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_array_properties.expected_texture_depth		= 4;
	texture_2d_multisample_array_properties.expected_texture_depth_size = 0;
	texture_2d_multisample_array_properties.expected_texture_depth_types.push_back(GL_NONE);
	texture_2d_multisample_array_properties.expected_texture_fixed_sample_locations = GL_TRUE;
	texture_2d_multisample_array_properties.expected_texture_green_size				= 6;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_array_properties.expected_texture_height			 = 4;
	texture_2d_multisample_array_properties.expected_texture_internal_format = GL_RGB565;
	texture_2d_multisample_array_properties.expected_texture_red_size		 = 5;
	/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
	texture_2d_multisample_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_NORMALIZED);
	texture_2d_multisample_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_INT);
	texture_2d_multisample_array_properties.expected_texture_samples	  = max_rgb565_internalformat_samples;
	texture_2d_multisample_array_properties.expected_texture_shared_size  = 0;
	texture_2d_multisample_array_properties.expected_texture_stencil_size = 0;
	texture_2d_multisample_array_properties.expected_texture_width		  = 4;

	/* GL_TEXTURE_3D */
	texture_3d_properties.depth			 = 2;
	texture_3d_properties.format		 = GL_RGB;
	texture_3d_properties.height		 = 2;
	texture_3d_properties.internalformat = GL_RGB9_E5;
	texture_3d_properties.is_2d_texture  = false;
	texture_3d_properties.target		 = GL_TEXTURE_3D;
	texture_3d_properties.to_id_ptr		 = &to_3d;
	texture_3d_properties.type			 = GL_FLOAT;
	texture_3d_properties.width			 = 2;

	texture_3d_properties.expected_compressed		  = GL_FALSE;
	texture_3d_properties.expected_texture_alpha_size = 0;
	texture_3d_properties.expected_texture_alpha_types.push_back(GL_NONE);
	texture_3d_properties.expected_texture_blue_size = 9;
	texture_3d_properties.expected_texture_blue_types.push_back(GL_FLOAT);
	texture_3d_properties.expected_texture_depth	  = 2;
	texture_3d_properties.expected_texture_depth_size = 0;
	texture_3d_properties.expected_texture_depth_types.push_back(GL_NONE);
	texture_3d_properties.expected_texture_fixed_sample_locations = GL_TRUE;
	texture_3d_properties.expected_texture_green_size			  = 9;
	texture_3d_properties.expected_texture_green_types.push_back(GL_FLOAT);
	texture_3d_properties.expected_texture_height		   = 2;
	texture_3d_properties.expected_texture_internal_format = GL_RGB9_E5;
	texture_3d_properties.expected_texture_red_size		   = 9;
	texture_3d_properties.expected_texture_red_types.push_back(GL_FLOAT);
	texture_3d_properties.expected_texture_samples		= 0;
	texture_3d_properties.expected_texture_shared_size  = 5;
	texture_3d_properties.expected_texture_stencil_size = 0;
	texture_3d_properties.expected_texture_width		= 2;

	/* GL_TEXTURE_CUBE_MAP_* */
	texture_cm_face_properties.format		  = GL_RGB_INTEGER;
	texture_cm_face_properties.height		  = 1;
	texture_cm_face_properties.internalformat = GL_RGB16I;
	texture_cm_face_properties.is_cm_texture  = true;
	texture_cm_face_properties.target		  = GL_TEXTURE_CUBE_MAP;
	texture_cm_face_properties.to_id_ptr	  = &to_cubemap;
	texture_cm_face_properties.type			  = GL_SHORT;
	texture_cm_face_properties.width		  = 1;

	texture_cm_face_properties.expected_compressed		   = GL_FALSE;
	texture_cm_face_properties.expected_texture_alpha_size = 0;
	texture_cm_face_properties.expected_texture_alpha_types.push_back(GL_NONE);
	texture_cm_face_properties.expected_texture_blue_size = 16;
	texture_cm_face_properties.expected_texture_blue_types.push_back(GL_INT);
	texture_cm_face_properties.expected_texture_depth	  = 1;
	texture_cm_face_properties.expected_texture_depth_size = 0;
	texture_cm_face_properties.expected_texture_depth_types.push_back(GL_NONE);
	texture_cm_face_properties.expected_texture_fixed_sample_locations = GL_TRUE;
	texture_cm_face_properties.expected_texture_green_size			   = 16;
	texture_cm_face_properties.expected_texture_green_types.push_back(GL_INT);
	texture_cm_face_properties.expected_texture_height			= 1;
	texture_cm_face_properties.expected_texture_internal_format = GL_RGB16I;
	texture_cm_face_properties.expected_texture_red_size		= 16;
	texture_cm_face_properties.expected_texture_red_types.push_back(GL_INT);
	texture_cm_face_properties.expected_texture_samples		 = 0;
	texture_cm_face_properties.expected_texture_shared_size  = 0;
	texture_cm_face_properties.expected_texture_stencil_size = 0;
	texture_cm_face_properties.expected_texture_width		 = 1;

	/* The test needs to be run in two iterations:
	 *
	 * a) In first run,  we need to test immutable textures;
	 * b) In second one, mutable textures should be used.
	 */
	for (unsigned int n_iteration = 0; n_iteration < 2 /* immutable/mutable textures */; ++n_iteration)
	{
		bool is_immutable_run = (n_iteration == 0);

		/* Generate texture object IDs */
		gl.genTextures(1, &to_2d);
		gl.genTextures(1, &to_2d_array);
		gl.genTextures(1, &to_2d_multisample);
		gl.genTextures(1, &to_2d_multisample_array);
		gl.genTextures(1, &to_3d);
		gl.genTextures(1, &to_cubemap);

		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTexture() call(s) failed.");

		/* Configure texture storage for each target. */
		for (unsigned int n_descriptor = 0; n_descriptor < n_texture_descriptors; ++n_descriptor)
		{
			const _texture_properties* texture_ptr = texture_descriptors[n_descriptor];

			/* Multisample texture targets are not supported by glTexImage*D() API in ES3.1.
			 * Skip two iterations so that we follow the requirement.
			 */
			if (!is_immutable_run && (texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE ||
									  texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES))
			{
				continue;
			}

			/* Bind the ID to processed texture target */
			gl.bindTexture(texture_ptr->target, *texture_ptr->to_id_ptr);

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

			/* Set up texture storage */
			if (is_immutable_run)
			{
				if (texture_ptr->is_2d_texture)
				{
					if (texture_ptr->is_multisample_texture)
					{
						gl.texStorage2DMultisample(texture_ptr->target, texture_ptr->samples,
												   texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
												   texture_ptr->fixedsamplelocations);

						GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample() call failed");
					}
					else
					{
						gl.texStorage2D(texture_ptr->target, 1, /* levels */
										texture_ptr->internalformat, texture_ptr->width, texture_ptr->height);

						GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed");
					}
				}
				else if (texture_ptr->is_cm_texture)
				{
					gl.texStorage2D(GL_TEXTURE_CUBE_MAP, 1, /* levels */
									texture_ptr->internalformat, texture_ptr->width, texture_ptr->height);

					GLU_EXPECT_NO_ERROR(gl.getError(),
										"glTexStorage2D() call failed for GL_TEXTURE_CUBE_MAP texture target");
				}
				else
				{
					if (texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES)
					{
						if (gl_oes_texture_storage_multisample_2d_array_supported)
						{
							gl.texStorage3DMultisample(texture_ptr->target, texture_ptr->samples,
													   texture_ptr->internalformat, texture_ptr->width,
													   texture_ptr->height, texture_ptr->depth,
													   texture_ptr->fixedsamplelocations);

							GLU_EXPECT_NO_ERROR(gl.getError(), "gltexStorage3DMultisample() call failed");
						}
						else
						{
							TCU_FAIL("Invalid texture target is being used.");
						}
					}
					else
					{
						/* Must be a single-sampled 2D array or 3D texture */
						gl.texStorage3D(texture_ptr->target, 1, /* levels */
										texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
										texture_ptr->depth);

						GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage3D() call failed");
					}
				}
			} /* if (!is_immutable_run) */
			else
			{
				/* Mutable run */
				if (texture_ptr->is_2d_texture)
				{
					gl.texImage2D(texture_ptr->target, 0,												   /* level */
								  texture_ptr->internalformat, texture_ptr->width, texture_ptr->height, 0, /* border */
								  texture_ptr->format, texture_ptr->type, NULL);						   /* pixels */

					GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D() call failed");
				}
				else if (texture_ptr->is_cm_texture)
				{
					const glw::GLenum cm_texture_targets[] = {
						GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
						GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
					};
					const unsigned int n_cm_texture_targets =
						sizeof(cm_texture_targets) / sizeof(cm_texture_targets[0]);

					for (unsigned int n_cm_texture_target = 0; n_cm_texture_target < n_cm_texture_targets;
						 ++n_cm_texture_target)
					{
						glw::GLenum texture_target = cm_texture_targets[n_cm_texture_target];

						gl.texImage2D(texture_target, 0, /* level */
									  texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
									  0,											 /* border */
									  texture_ptr->format, texture_ptr->type, NULL); /* pixels */

						GLU_EXPECT_NO_ERROR(gl.getError(),
											"glTexImage2D() call failed for a cube-map face texture target");
					} /* for (all cube-map texture targets) */
				}
				else
				{
					/* Must be a 2D array texture or 3D texture */
					gl.texImage3D(texture_ptr->target, 0, /* level */
								  texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
								  texture_ptr->depth, 0,						 /* border */
								  texture_ptr->format, texture_ptr->type, NULL); /* pixels */

					GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage3D() call failed");
				}
			}
		} /* for (all texture descriptors) */

		/* Check if correct values are reported for all texture properties described in
		 * the spec.
		 */
		typedef std::map<glw::GLenum, const _texture_properties*> target_to_texture_properties_map;
		typedef target_to_texture_properties_map::const_iterator target_to_texture_properties_map_const_iterator;

		const glw::GLenum pnames[] = { GL_TEXTURE_RED_TYPE,
									   GL_TEXTURE_GREEN_TYPE,
									   GL_TEXTURE_BLUE_TYPE,
									   GL_TEXTURE_ALPHA_TYPE,
									   GL_TEXTURE_DEPTH_TYPE,
									   GL_TEXTURE_RED_SIZE,
									   GL_TEXTURE_GREEN_SIZE,
									   GL_TEXTURE_BLUE_SIZE,
									   GL_TEXTURE_ALPHA_SIZE,
									   GL_TEXTURE_DEPTH_SIZE,
									   GL_TEXTURE_STENCIL_SIZE,
									   GL_TEXTURE_SHARED_SIZE,
									   GL_TEXTURE_COMPRESSED,
									   GL_TEXTURE_INTERNAL_FORMAT,
									   GL_TEXTURE_WIDTH,
									   GL_TEXTURE_HEIGHT,
									   GL_TEXTURE_DEPTH,
									   GL_TEXTURE_SAMPLES,
									   GL_TEXTURE_FIXED_SAMPLE_LOCATIONS };
		const unsigned int				 n_pnames = sizeof(pnames) / sizeof(pnames[0]);
		target_to_texture_properties_map targets;

		targets[GL_TEXTURE_2D]					= &texture_2d_properties;
		targets[GL_TEXTURE_2D_ARRAY]			= &texture_2d_array_properties;
		targets[GL_TEXTURE_2D_MULTISAMPLE]		= &texture_2d_multisample_properties;
		targets[GL_TEXTURE_3D]					= &texture_3d_properties;
		targets[GL_TEXTURE_CUBE_MAP_NEGATIVE_X] = &texture_cm_face_properties;
		targets[GL_TEXTURE_CUBE_MAP_NEGATIVE_Y] = &texture_cm_face_properties;
		targets[GL_TEXTURE_CUBE_MAP_NEGATIVE_Z] = &texture_cm_face_properties;
		targets[GL_TEXTURE_CUBE_MAP_POSITIVE_X] = &texture_cm_face_properties;
		targets[GL_TEXTURE_CUBE_MAP_POSITIVE_Y] = &texture_cm_face_properties;
		targets[GL_TEXTURE_CUBE_MAP_POSITIVE_Z] = &texture_cm_face_properties;

		if (gl_oes_texture_storage_multisample_2d_array_supported)
		{
			targets[GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES] = &texture_2d_multisample_array_properties;
		}

		for (target_to_texture_properties_map_const_iterator target_iterator = targets.begin();
			 target_iterator != targets.end(); target_iterator++)
		{
			glw::GLenum				   target	  = target_iterator->first;
			const _texture_properties* texture_ptr = target_iterator->second;

			/* Multisample texture targets are not supported by glTexImage*D() API in ES3.1.
			 * Skip two iterations so that we follow the requirement.
			 */
			if (m_context.getRenderContext().getType().getAPI() == glu::ApiType::es(3, 1) && !is_immutable_run &&
				(texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE ||
				 texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES))
			{
				continue;
			}

			for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname)
			{
				glw::GLenum pname = pnames[n_pname];

				/* Run the check in two stages:
				 *
				 * a) Use glGetTexLevelParameteriv() in first run;
				 * b) Use glGetTexLevelParameterfv() in the other run;
				 */
				for (unsigned int n_stage = 0; n_stage < 2 /* stages */; ++n_stage)
				{
					glw::GLfloat float_value = 0.0f;
					glw::GLint   int_value   = 0;

					/* Check if the retrieved value is correct */
					glw::GLenum				expected_error_code = GL_NO_ERROR;
					std::vector<glw::GLint> expected_int_values;

					switch (pname)
					{
					case GL_TEXTURE_RED_TYPE:
					{
						/* Return value is implementation-dependent and not enforced by spec.
						 * For this pname, more that one value could be valid. */
						expected_int_values = texture_ptr->expected_texture_red_types;

						break;
					}

					case GL_TEXTURE_GREEN_TYPE:
					{
						/* Return value is implementation-dependent and not enforced by spec.
						 * For this pname, more that one value could be valid. */
						expected_int_values = texture_ptr->expected_texture_green_types;

						break;
					}

					case GL_TEXTURE_BLUE_TYPE:
					{
						/* Return value is implementation-dependent and not enforced by spec.
						 * For this pname, more that one value could be valid. */
						expected_int_values = texture_ptr->expected_texture_blue_types;

						break;
					}

					case GL_TEXTURE_ALPHA_TYPE:
					{
						/* Return value is implementation-dependent and not enforced by spec.
						 * For this pname, more that one value could be valid. */
						expected_int_values = texture_ptr->expected_texture_alpha_types;

						break;
					}

					case GL_TEXTURE_DEPTH_TYPE:
					{
						/* Return value is implementation-dependent and not enforced by spec.
						 * For this pname, more that one value could be valid. */
						expected_int_values = texture_ptr->expected_texture_depth_types;

						break;
					}

					case GL_TEXTURE_RED_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_red_size);

						break;
					}

					case GL_TEXTURE_GREEN_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_green_size);

						break;
					}

					case GL_TEXTURE_BLUE_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_blue_size);

						break;
					}

					case GL_TEXTURE_ALPHA_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_alpha_size);

						break;
					}

					case GL_TEXTURE_DEPTH_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_depth_size);

						break;
					}

					case GL_TEXTURE_STENCIL_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_stencil_size);

						break;
					}

					case GL_TEXTURE_SHARED_SIZE:
					{
						/* Return value is implementation-dependent and not enforced by spec,
						 * but it can't be less that expected_int_value */
						expected_int_values.push_back(texture_ptr->expected_texture_shared_size);

						break;
					}

					case GL_TEXTURE_COMPRESSED:
					{
						expected_int_values.push_back(texture_ptr->expected_compressed);

						break;
					}

					case GL_TEXTURE_INTERNAL_FORMAT:
					{
						expected_int_values.push_back(texture_ptr->expected_texture_internal_format);

						break;
					}

					case GL_TEXTURE_WIDTH:
					{
						expected_int_values.push_back(texture_ptr->expected_texture_width);

						break;
					}

					case GL_TEXTURE_HEIGHT:
					{
						expected_int_values.push_back(texture_ptr->expected_texture_height);

						break;
					}

					case GL_TEXTURE_DEPTH:
					{
						expected_int_values.push_back(texture_ptr->expected_texture_depth);

						break;
					}

					case GL_TEXTURE_SAMPLES:
					{
						expected_int_values.push_back(texture_ptr->expected_texture_samples);

						break;
					}

					case GL_TEXTURE_FIXED_SAMPLE_LOCATIONS:
					{
						expected_int_values.push_back(texture_ptr->expected_texture_fixed_sample_locations);

						break;
					}

					default:
					{
						m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized pname [" << pname << "]"
										   << tcu::TestLog::EndMessage;

						TCU_FAIL("Unrecognized pname");
					}
					} /* switch (pname) */

					/* Do the actual call. If we're expecting an error, make sure it was generated.
					 * Otherwise, confirm no error was generated by the call */
					glw::GLenum error_code = GL_NO_ERROR;

					if (n_stage == 0)
					{
						/* call glGetTexLevelParameteriv() */
						gl.getTexLevelParameteriv(target, 0 /* level */, pname, &int_value);

						error_code = gl.getError();
						if (error_code != expected_error_code)
						{
							m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameteriv() for pname ["
											   << pname << "]"
											   << " and target [" << target << "]"
											   << " generated an invalid error code [" << error_code << "]"
											   << tcu::TestLog::EndMessage;

							TCU_FAIL("Error calling glGetTexLevelParameteriv()");
						} /* if (error_code != GL_NO_ERROR) */
					}	 /* if (n_stage == 0) */
					else
					{
						/* call glGetTexLevelParameterfv() */
						gl.getTexLevelParameterfv(target, 0 /* level */, pname, &float_value);

						error_code = gl.getError();
						if (error_code != expected_error_code)
						{
							m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameteriv() for pname ["
											   << pname << "]"
											   << " and target [" << target << "]"
											   << " generated an invalid error code [" << error_code << "]"
											   << tcu::TestLog::EndMessage;

							TCU_FAIL("Error calling glGetTexLevelParameterfv()");
						} /* if (error_code != GL_NO_ERROR) */

						/* Cast the result to an integer - this is fine since none of the properties we are
						 * querying is FP.
						 **/
						DE_ASSERT(float_value == (float)(int)float_value);
						int_value = (int)float_value;
					}

					/* Check the result value only if no error was expected */
					if (expected_error_code == GL_NO_ERROR)
					{
						switch (pname)
						{
						case GL_TEXTURE_RED_SIZE:
						case GL_TEXTURE_GREEN_SIZE:
						case GL_TEXTURE_BLUE_SIZE:
						case GL_TEXTURE_ALPHA_SIZE:
						case GL_TEXTURE_DEPTH_SIZE:
						case GL_TEXTURE_STENCIL_SIZE:
						case GL_TEXTURE_SHARED_SIZE:
						case GL_TEXTURE_SAMPLES:
						{
							/* For some pnames with size, value range is valid.
							 * For example for GL_RGB16I and GL_TEXTURE_RED_SIZE implementation may return 16 or 32,
							 * which will still comply with the spec.
							 * In such case we check if returned value is no less than 16.
							 */
							if (expected_int_values.at(0) > int_value)
							{
								m_testCtx.getLog() << tcu::TestLog::Message << "Too small value reported for pname ["
												   << pname << "]"
												   << " and target [" << target << "]"
												   << " expected not less than:[" << expected_int_values.at(0) << "]"
												   << " retrieved:[" << int_value << "]" << tcu::TestLog::EndMessage;

								TCU_FAIL("Invalid value reported.");
							}
							break;
						}

						case GL_TEXTURE_COMPRESSED:
						case GL_TEXTURE_INTERNAL_FORMAT:
						case GL_TEXTURE_WIDTH:
						case GL_TEXTURE_HEIGHT:
						case GL_TEXTURE_DEPTH:
						case GL_TEXTURE_FIXED_SAMPLE_LOCATIONS:
						{
							if (expected_int_values.at(0) != int_value)
							{
								m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for pname ["
												   << pname << "]"
												   << " and target [" << target << "]"
												   << " expected:[" << expected_int_values.at(0) << "]"
												   << " retrieved:[" << int_value << "]" << tcu::TestLog::EndMessage;

								TCU_FAIL("Invalid value reported.");
							}
							break;
						}

						case GL_TEXTURE_RED_TYPE:
						case GL_TEXTURE_GREEN_TYPE:
						case GL_TEXTURE_BLUE_TYPE:
						case GL_TEXTURE_ALPHA_TYPE:
						case GL_TEXTURE_DEPTH_TYPE:
						{
							/* For some pnames with types, more than one value could be valid.
							 * For example for GL_DEPTH24_STENCIL8 and GL_DEPTH_TYPE query, the returned value is implementation
							 * dependent, some implementations return GL_UNSIGNED_NORMALIZED, other may return GL_UNSIGNED_INT
							 * depending on hardware specific representation of depth.
							 */

							std::vector<glw::GLint>::iterator expected_value_it =
								find(expected_int_values.begin(), expected_int_values.end(), int_value);

							if (expected_value_it == expected_int_values.end())
							{
								std::ostringstream expected_values_string_stream;

								for (std::vector<glw::GLint>::iterator it = expected_int_values.begin();
									 it != expected_int_values.end(); ++it)
								{
									if (it != expected_int_values.begin())
									{
										expected_values_string_stream << ", ";
									}

									expected_values_string_stream << *it;
								}

								m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for pname ["
												   << pname << "]"
												   << " and target [" << target << "]"
												   << " expected:[" << expected_values_string_stream.str() << "]"
												   << " retrieved:[" << int_value << "]" << tcu::TestLog::EndMessage;

								TCU_FAIL("Invalid value reported.");
							}
							break;
						}

						default:
						{
							m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized pname [" << pname << "]"
											   << tcu::TestLog::EndMessage;

							TCU_FAIL("Unrecognized pname");
						} /* default: */
						} /* switch (pname) */
					}	 /* if (expected_error_code == GL_NO_ERROR) */
				}		  /* for (all stages) */
			}			  /* for (all properties) */
		}				  /* for (all texture targets) */

		/* Iteration finished - clean up. */
		for (unsigned int n_descriptor = 0; n_descriptor < n_texture_descriptors; ++n_descriptor)
		{
			const _texture_properties* texture_ptr = texture_descriptors[n_descriptor];

			/* Release the texture object */
			gl.bindTexture(texture_ptr->target, 0);
			gl.deleteTextures(1, texture_ptr->to_id_ptr);

			GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteTextures() call failed");

			/* Assign a new object to the ID */
			gl.genTextures(1, texture_ptr->to_id_ptr);

			GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed");
		} /* for (all texture descriptors) */
	}	 /* for (immutable & mutable textures) */

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

	return STOP;
}

/** Constructor.
 *
 *  @param context CTS context handle.
 **/
MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest::
	MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest(Context& context)
	: TestCase(context, "functional_max_lod_test", "Verifies glGetTexLevelParameter{if}v() entry-points work "
												   "correctly when info about maximum LOD is requested.")
	, gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
	, to_id(0)
{
	/* Left blank on purpose */
}

/** Deinitializes GL ES objects used by the test */
void MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

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

		to_id = 0;
	}

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

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing.
 */
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest::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();
	int					  number_of_iterations = 0;

	/* Generate a texture object and bind id to a 2D multisample texture target */
	gl.genTextures(1, &to_id);
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a texture object");

	if (gl_oes_texture_storage_multisample_2d_array_supported)
	{
		/* Run in two iterations:
		 *
		 * a) Texture storage initialized with glTexStorage2DMultisample();
		 * b) Texture storage initialized with gltexStorage3DMultisample().
		 */
		number_of_iterations = 2;
	}
	else
	{
		/* Run in one iteration:
		 *
		 * a) Texture storage initialized with glTexStorage2DMultisample();
		 */
		number_of_iterations = 1;
	}

	/* Run in two iterations:
	 *
	 * a) Texture storage initialized with glTexStorage2DMultisample();
	 * b) Texture storage initialized with gltexStorage3DMultisample().
	 */
	for (int n_iteration = 0; n_iteration < number_of_iterations; ++n_iteration)
	{
		bool	  is_2d_multisample_iteration = (n_iteration == 0);
		const int max_lod =
			0; /* For multisample textures only lod=0 is valid, queries for lod > 0 will always return GL_NONE, as those lods are not defined for such texture */
		glw::GLenum texture_target =
			(n_iteration == 0) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;

		/* Set up texture storage */
		if (is_2d_multisample_iteration)
		{
			gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, /* samples */
									   GL_RGBA8, 16,				 /* width */
									   16,							 /* height */
									   GL_FALSE);					 /* fixedsamplelocations */

			GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample() call failed");
		} /* if (is_2d_multisample_iteration) */
		else
		{
			gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 1, /* samples */
									   GL_RGBA8, 16,						   /* width */
									   16,									   /* height */
									   16,									   /* depth */
									   GL_FALSE);							   /* fixedsamplelocations */

			GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample() call failed");
		}

		/* Check all glGetTexLevelParameter*() entry-points */
		for (int n_api_call = 0; n_api_call < 2 /* iv(), fv() */; ++n_api_call)
		{
			float	  float_value			   = 0;
			glw::GLint red_size				   = 0;
			glw::GLint red_type				   = 0;
			glw::GLint texture_internal_format = GL_NONE;
			glw::GLint texture_samples		   = 0;

			switch (n_api_call)
			{
			case 0:
			{
				gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_RED_TYPE, &red_type);
				gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_RED_SIZE, &red_size);
				gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_INTERNAL_FORMAT,
										  &texture_internal_format);
				gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_SAMPLES, &texture_samples);

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

				break;
			}

			case 1:
			{
				gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_RED_TYPE, &float_value);
				red_type = (glw::GLint)float_value;

				gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_RED_SIZE, &float_value);
				red_size = (glw::GLint)float_value;

				gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_INTERNAL_FORMAT, &float_value);
				texture_internal_format = (glw::GLint)float_value;

				gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_SAMPLES, &float_value);
				texture_samples = (glw::GLint)float_value;

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

				break;
			}

			default:
				TCU_FAIL("Unrecognized API call index");
			}

			/* Make sure the retrieved values are valid
			 *
			 * NOTE: The original test case did not make much sense in this regard. */
			if (red_type != GL_UNSIGNED_NORMALIZED)
			{
				m_testCtx.getLog() << tcu::TestLog::Message
								   << "Invalid value returned for a GL_TEXTURE_RED_TYPE query: "
								   << "expected:GL_UNSIGNED_NORMALIZED, retrieved:" << red_type
								   << tcu::TestLog::EndMessage;

				TCU_FAIL("Invalid value returned for a GL_TEXTURE_RED_TYPE query");
			}

			if (red_size != 8)
			{
				m_testCtx.getLog() << tcu::TestLog::Message
								   << "Invalid value returned for a GL_TEXTURE_RED_SIZE query: "
								   << "expected:8, retrieved:" << red_size << tcu::TestLog::EndMessage;

				TCU_FAIL("Invalid value returned for a GL_TEXTURE_RED_SIZE query");
			}

			if (texture_internal_format != GL_RGBA8)
			{
				m_testCtx.getLog() << tcu::TestLog::Message
								   << "Invalid value returned for a GL_TEXTURE_INTERNAL_FORMAT query: "
								   << "expected:GL_RGBA8, retrieved:" << texture_internal_format
								   << tcu::TestLog::EndMessage;

				TCU_FAIL("Invalid value returned for a GL_TEXTURE_INTERNAL_FORMAT query");
			}

			/* Implementation is allowed to return more samples than requested */
			if (texture_samples < 1)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value returned for a GL_TEXTURE_SAMPLES query: "
								   << "expected:1, retrieved:" << texture_samples << tcu::TestLog::EndMessage;

				TCU_FAIL("Invalid value returned for a GL_TEXTURE_SAMPLES query");
			}
		} /* for (both API call types) */

		/* Re-create the texture object and bind it to 2D multisample array texture target */
		gl.deleteTextures(1, &to_id);
		to_id = 0;

		/* Prepare for the next iteration (if needed). */
		if (n_iteration == 0 && number_of_iterations == 2)
		{
			gl.genTextures(1, &to_id);
			gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id);
		}

		GLU_EXPECT_NO_ERROR(gl.getError(), "Could not re-create the texture object.");
	} /* for (all iterations) */

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

	return STOP;
}

/** Constructor.
 *
 *  @param context CTS context handle.
 **/
MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest::
	MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest(Context& context)
	: TestCase(context, "invalid_texture_target_rejected", "Verifies glGetTexLevelParameter{if}v() rejects invalid "
														   "texture target by generating GL_INVALID_ENUM error.")
	, float_data(0.0f)
	, int_data(0)
{
	/* Left blank on purpose */
}

/** Deinitializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest::deinit()
{
	/* Call base class' deinit() */
	TestCase::deinit();
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing.
 */
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest::iterate()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Call glGetTexLevelParameteriv() with invalid texture target. */
	gl.getTexLevelParameteriv(GL_TEXTURE_WIDTH /* invalid value */, 0, /* level */
							  GL_TEXTURE_RED_TYPE, &int_data);

	/* Expect GL_INVALID_ENUM error code. */
	TCU_CHECK_MSG(gl.getError() == GL_INVALID_ENUM,
				  "glGetTexLevelParameteriv() did not generate GL_INVALID_ENUM error.");

	/* Call glGetTexLevelParameterfv() with invalid texture target. */
	gl.getTexLevelParameterfv(GL_TEXTURE_WIDTH /* invalid value */, 0, /* level */
							  GL_TEXTURE_RED_TYPE, &float_data);

	/* Expect GL_INVALID_ENUM error code. */
	TCU_CHECK_MSG(gl.getError() == GL_INVALID_ENUM,
				  "glGetTexLevelParameterfv() did not generate GL_INVALID_ENUM error.");

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	return STOP;
}

/** Constructor.
 *
 *  @param context CTS context handle.
 **/
MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest::
	MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest(Context& context)
	: TestCase(context, "invalid_value_argument_rejected", "Verifies glGetTexLevelParameter{if}v() rejects invalid "
														   "value argument by generating GL_INVALID_VALUE error.")
	, float_data(0.0f)
	, int_data(0)
{
	/* Left blank on purpose */
}

/** Deinitializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest::deinit()
{
	/* Call base class' deinit() */
	TestCase::deinit();
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing.
 */
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest::iterate()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Call glGetTexLevelParameteriv() with invalid value argument. */
	gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, /* level */
							  GL_SIGNED_NORMALIZED /* invalid value */, &int_data);

	/* From spec:
	 * An INVALID_ENUM error is generated if pname is not one of the symbolic values in tables 6.12.
	 */

	/* Expect INVALID_ENUM error code. */
	glw::GLenum error_code = gl.getError();

	TCU_CHECK_MSG(error_code == GL_INVALID_ENUM, "glGetTexLevelParameteriv() did not generate GL_INVALID_ENUM error.");

	/* Call glGetTexLevelParameterfv() with invalid value argument. */
	gl.getTexLevelParameterfv(GL_TEXTURE_2D, 0, /* level */
							  GL_SIGNED_NORMALIZED /* invalid value */, &float_data);

	/* Expect INVALID_ENUM error code. */
	error_code = gl.getError();

	TCU_CHECK_MSG(error_code == GL_INVALID_ENUM, "glGetTexLevelParameterfv() did not generate GL_INVALID_ENUM error.");

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	return STOP;
}

/** Constructor.
 *
 *  @param context CTS context handle.
 **/
MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::
	MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest(Context& context)
	: TestCase(context, "negative_lod_is_rejected_test", "Verifies glGetTexLevelParameter{if}v() rejects negative "
														 "<lod> by generating GL_INVALID_VALUE error.")
	, float_data(0.0f)
	, int_data(0)
	, to_id(0)
{
	/* Left blank on purpose */
}

/** Deinitializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Bind default texture object to GL_TEXTURE_2D_MULTISAMPLE texture target. */
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);

	/* Delete texture object. */
	gl.deleteTextures(1, &to_id);

	to_id = 0;

	/* Check if no error was generated. */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Texture object deletion failed.");

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

/** Initializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::initInternals()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Generate texture object id. */
	gl.genTextures(1, &to_id);

	/* Bind generated texture object ID to GL_TEXTURE_2D_MULTISAMPLE texture target. */
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id);

	/* Check if no error was generated. */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Texture object initialization failed.");
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing.
 */
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::iterate()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	initInternals();

	/* Set up texture storage. */
	gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, /* samples */
							   GL_RGBA8, 16,				 /* width */
							   16,							 /* height */
							   GL_FALSE);

	/* Check if no error was generated. */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Texture object initialization failed.");

	/* Call glGetTexLevelParameteriv() with negative lod. */
	gl.getTexLevelParameteriv(GL_TEXTURE_2D_MULTISAMPLE, -1 /* negative lod */, GL_TEXTURE_RED_TYPE, &int_data);

	/* Expect GL_INVALID_VALUE error code. */
	TCU_CHECK_MSG(gl.getError() == GL_INVALID_VALUE,
				  "glGetTexLevelParameteriv() did not generate GL_INVALID_VALUE error.");

	/* Call glGetTexLevelParameterfv() with negative lod. */
	gl.getTexLevelParameterfv(GL_TEXTURE_2D_MULTISAMPLE, -1 /* negative lod */, GL_TEXTURE_RED_TYPE, &float_data);

	/* Expect GL_INVALID_VALUE error code. */
	TCU_CHECK_MSG(gl.getError() == GL_INVALID_VALUE,
				  "glGetTexLevelParameterfv() did not generate GL_INVALID_VALUE error.");

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

	return STOP;
}
} /* glcts namespace */