/*-------------------------------------------------------------------------
 * 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  esextcTextureCubeMapArrayGetterCalls.cpp
 * \brief Texture Cube Map Array Getter Calls (Test 6)
 */ /*-------------------------------------------------------------------*/

#include "esextcTextureCubeMapArrayGetterCalls.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
#include <string.h>

namespace glcts
{

/* Properties of a cube-map array texture used by the test */
const glw::GLuint  TextureCubeMapArrayGetterCalls::m_depth		  = 6;
const glw::GLsizei TextureCubeMapArrayGetterCalls::m_height		  = 64;
const glw::GLsizei TextureCubeMapArrayGetterCalls::m_width		  = 64;
const glw::GLuint  TextureCubeMapArrayGetterCalls::m_n_components = 4;

/* Name strings for GetTexParameter*() pnames */
const char* TextureCubeMapArrayGetterCalls::getStringForGetTexParameterPname(glw::GLenum pname)
{
	if (pname == GL_TEXTURE_BASE_LEVEL)
		return "GL_TEXTURE_BASE_LEVEL";
	if (pname == GL_TEXTURE_MAX_LEVEL)
		return "GL_TEXTURE_MAX_LEVEL";
	if (pname == GL_TEXTURE_MIN_FILTER)
		return "GL_TEXTURE_MIN_FILTER";
	if (pname == GL_TEXTURE_MAG_FILTER)
		return "GL_TEXTURE_MAG_FILTER";
	if (pname == GL_TEXTURE_MIN_LOD)
		return "GL_TEXTURE_MIN_LOD";
	if (pname == GL_TEXTURE_MAX_LOD)
		return "GL_TEXTURE_MAX_LOD";
	if (pname == GL_TEXTURE_SWIZZLE_R)
		return "GL_TEXTURE_SWIZZLE_R";
	if (pname == GL_TEXTURE_SWIZZLE_G)
		return "GL_TEXTURE_SWIZZLE_G";
	if (pname == GL_TEXTURE_SWIZZLE_B)
		return "GL_TEXTURE_SWIZZLE_B";
	if (pname == GL_TEXTURE_SWIZZLE_A)
		return "GL_TEXTURE_SWIZZLE_A";
	if (pname == GL_TEXTURE_WRAP_S)
		return "GL_TEXTURE_WRAP_S";
	if (pname == GL_TEXTURE_WRAP_T)
		return "GL_TEXTURE_WRAP_T";
	if (pname == GL_TEXTURE_WRAP_R)
		return "GL_TEXTURE_WRAP_R";

	return "UNKNOWN PARAMETER NAME";
}

/* Name strings for GetTexLevelParameter*() pnames */
const char* TextureCubeMapArrayGetterCalls::getStringForGetTexLevelParameterPname(glw::GLenum pname)
{
	if (pname == GL_TEXTURE_COMPRESSED)
		return "GL_TEXTURE_COMPRESSED";
	if (pname == GL_TEXTURE_ALPHA_SIZE)
		return "GL_TEXTURE_ALPHA_SIZE";
	if (pname == GL_TEXTURE_BLUE_SIZE)
		return "GL_TEXTURE_BLUE_SIZE";
	if (pname == GL_TEXTURE_GREEN_SIZE)
		return "GL_TEXTURE_GREEN_SIZE";
	if (pname == GL_TEXTURE_RED_SIZE)
		return "GL_TEXTURE_RED_SIZE";
	if (pname == GL_TEXTURE_DEPTH_SIZE)
		return "GL_TEXTURE_DEPTH_SIZE";
	if (pname == GL_TEXTURE_SHARED_SIZE)
		return "GL_TEXTURE_SHARED_SIZE";
	if (pname == GL_TEXTURE_STENCIL_SIZE)
		return "GL_TEXTURE_STENCIL_SIZE";
	if (pname == GL_TEXTURE_ALPHA_TYPE)
		return "GL_TEXTURE_ALPHA_TYPE";
	if (pname == GL_TEXTURE_BLUE_TYPE)
		return "GL_TEXTURE_BLUE_TYPE";
	if (pname == GL_TEXTURE_GREEN_TYPE)
		return "GL_TEXTURE_GREEN_TYPE";
	if (pname == GL_TEXTURE_RED_TYPE)
		return "GL_TEXTURE_RED_TYPE";
	if (pname == GL_TEXTURE_DEPTH_TYPE)
		return "GL_TEXTURE_DEPTH_TYPE";
	if (pname == GL_TEXTURE_INTERNAL_FORMAT)
		return "GL_TEXTURE_INTERNAL_FORMAT";
	if (pname == GL_TEXTURE_WIDTH)
		return "GL_TEXTURE_WIDTH";
	if (pname == GL_TEXTURE_HEIGHT)
		return "GL_TEXTURE_HEIGHT";
	if (pname == GL_TEXTURE_DEPTH)
		return "GL_TEXTURE_DEPTH";

	return "UNKNOWN PARAMETER NAME";
}

/** Constructor
 *
 *  @param context     Test context
 *  @param name        Test case's name
 *  @param description Test case's description
 **/
TextureCubeMapArrayGetterCalls::TextureCubeMapArrayGetterCalls(Context& context, const ExtParameters& extParams,
															   const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_to_id(0)
	, m_test_passed(true)
	, m_expected_alpha_size(0)
	, m_expected_alpha_type(0)
	, m_expected_blue_size(0)
	, m_expected_blue_type(0)
	, m_expected_compressed(0)
	, m_expected_depth_size(0)
	, m_expected_depth_type(0)
	, m_expected_green_size(0)
	, m_expected_green_type(0)
	, m_expected_red_size(0)
	, m_expected_red_type(0)
	, m_expected_shared_size(0)
	, m_expected_stencil_size(0)
	, m_expected_texture_internal_format(0)
{
	/* Nothing to be done here */
}

/** Deinitializes GLES objects created during the test.
 *
 */
void TextureCubeMapArrayGetterCalls::deinit(void)
{
	/* Retrieve ES entry points */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Reset ES state */
	gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, 0);

	/* Release any objects that may have been created during test execution */
	if (m_to_id != 0)
	{
		gl.deleteTextures(1, &m_to_id);

		m_to_id = 0;
	}

	/* Deinitialize base class */
	TestCaseBase::deinit();
}

/** Initializes GLES objects used during the test.
 *
 */
void TextureCubeMapArrayGetterCalls::initTest(void)
{
	/* Only execute if GL_EXT_texture_cube_map_array extension is supported */
	if (!m_is_texture_cube_map_array_supported)
	{
		throw tcu::NotSupportedError(TEXTURE_CUBE_MAP_ARRAY_EXTENSION_NOT_SUPPORTED);
	}

	pnames_for_gettexparameter_default[GL_TEXTURE_BASE_LEVEL] = 0;
	pnames_for_gettexparameter_default[GL_TEXTURE_MAX_LEVEL]  = 1000;
	pnames_for_gettexparameter_default[GL_TEXTURE_MIN_FILTER] = GL_NEAREST_MIPMAP_LINEAR;
	pnames_for_gettexparameter_default[GL_TEXTURE_MAG_FILTER] = GL_LINEAR;
	pnames_for_gettexparameter_default[GL_TEXTURE_MIN_LOD]	= -1000;
	pnames_for_gettexparameter_default[GL_TEXTURE_MAX_LOD]	= 1000;
	pnames_for_gettexparameter_default[GL_TEXTURE_SWIZZLE_R]  = GL_RED;
	pnames_for_gettexparameter_default[GL_TEXTURE_SWIZZLE_G]  = GL_GREEN;
	pnames_for_gettexparameter_default[GL_TEXTURE_SWIZZLE_B]  = GL_BLUE;
	pnames_for_gettexparameter_default[GL_TEXTURE_SWIZZLE_A]  = GL_ALPHA;
	pnames_for_gettexparameter_default[GL_TEXTURE_WRAP_S]	 = GL_REPEAT;
	pnames_for_gettexparameter_default[GL_TEXTURE_WRAP_T]	 = GL_REPEAT;
	pnames_for_gettexparameter_default[GL_TEXTURE_WRAP_R]	 = GL_REPEAT;

	pnames_for_gettexparameter_modified[GL_TEXTURE_BASE_LEVEL] = 1;
	pnames_for_gettexparameter_modified[GL_TEXTURE_MAX_LEVEL]  = 1;
	pnames_for_gettexparameter_modified[GL_TEXTURE_MIN_FILTER] = GL_NEAREST;
	pnames_for_gettexparameter_modified[GL_TEXTURE_MAG_FILTER] = GL_NEAREST;
	pnames_for_gettexparameter_modified[GL_TEXTURE_MIN_LOD]	= -10;
	pnames_for_gettexparameter_modified[GL_TEXTURE_MAX_LOD]	= 10;
	pnames_for_gettexparameter_modified[GL_TEXTURE_SWIZZLE_R]  = GL_GREEN;
	pnames_for_gettexparameter_modified[GL_TEXTURE_SWIZZLE_G]  = GL_BLUE;
	pnames_for_gettexparameter_modified[GL_TEXTURE_SWIZZLE_B]  = GL_ALPHA;
	pnames_for_gettexparameter_modified[GL_TEXTURE_SWIZZLE_A]  = GL_RED;
	pnames_for_gettexparameter_modified[GL_TEXTURE_WRAP_S]	 = GL_CLAMP_TO_EDGE;
	pnames_for_gettexparameter_modified[GL_TEXTURE_WRAP_T]	 = GL_MIRRORED_REPEAT;
	pnames_for_gettexparameter_modified[GL_TEXTURE_WRAP_R]	 = GL_CLAMP_TO_EDGE;

	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_COMPRESSED);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_ALPHA_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_BLUE_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_GREEN_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_RED_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_DEPTH_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_SHARED_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_STENCIL_SIZE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_ALPHA_TYPE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_BLUE_TYPE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_GREEN_TYPE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_RED_TYPE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_DEPTH_TYPE);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_INTERNAL_FORMAT);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_WIDTH);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_HEIGHT);
	pnames_for_gettexlevelparameter.push_back(GL_TEXTURE_DEPTH);
}

/** Executes the test.
 *
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *
 *  Note the function throws exception should an error occur!
 *
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 **/
tcu::TestNode::IterateResult TextureCubeMapArrayGetterCalls::iterate(void)
{
	initTest();

	/* Retrieve ES entry points */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Generate a texture object */
	gl.genTextures(1, &m_to_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate a texture object!");

	/* Bind the texture object to GL_TEXTURE_CUBE_MAP_ARRAY_EXT texture target */
	gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, m_to_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind a texture object!");

	glw::GLubyte texture_data_ubyte[m_width * m_height * m_depth * m_n_components];
	memset(texture_data_ubyte, 0, m_width * m_height * m_depth * m_n_components * sizeof(glw::GLubyte));

	/* Set up mutable texture storage */
	gl.texImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, /* target */
				  0,						 /* level */
				  GL_RGBA8,					 /* internal format */
				  m_width,					 /* width */
				  m_height,					 /* height */
				  m_depth,					 /* depth */
				  0,						 /* border */
				  GL_RGBA,					 /* format */
				  GL_UNSIGNED_BYTE,			 /* type */
				  texture_data_ubyte);		 /* texel data */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create mutable texture storage!");

	gl.texImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, /* target */
				  1,						 /* level */
				  GL_RGBA8,					 /* internal format */
				  m_width,					 /* width */
				  m_height,					 /* height */
				  m_depth,					 /* depth */
				  0,						 /* border */
				  GL_RGBA,					 /* format */
				  GL_UNSIGNED_BYTE,			 /* type */
				  texture_data_ubyte);		 /* texel data */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create mutable texture storage!");

	/* Configure expected values for all properties we will be checking */
	m_expected_compressed			   = GL_FALSE;
	m_expected_alpha_size			   = 8;
	m_expected_alpha_type			   = GL_UNSIGNED_NORMALIZED;
	m_expected_blue_size			   = 8;
	m_expected_blue_type			   = GL_UNSIGNED_NORMALIZED;
	m_expected_green_size			   = 8;
	m_expected_green_type			   = GL_UNSIGNED_NORMALIZED;
	m_expected_red_size				   = 8;
	m_expected_red_type				   = GL_UNSIGNED_NORMALIZED;
	m_expected_depth_size			   = 0;
	m_expected_depth_type			   = GL_NONE;
	m_expected_shared_size			   = 0;
	m_expected_stencil_size			   = 0;
	m_expected_texture_internal_format = GL_RGBA8;

	/* Verify the texture bindings have been updated */
	verifyTextureBindings();

	/* Verify texture parameter values reported by glGetTexParameter*() functions are valid. */
	PNamesMap::iterator pnames_iter = pnames_for_gettexparameter_default.begin();
	PNamesMap::iterator pnames_end  = pnames_for_gettexparameter_default.end();
	for (; pnames_iter != pnames_end; ++pnames_iter)
	{
		verifyGetTexParameter(pnames_iter->first, pnames_iter->second);
	}

	pnames_iter = pnames_for_gettexparameter_modified.begin();
	pnames_end  = pnames_for_gettexparameter_modified.end();
	for (; pnames_iter != pnames_end; ++pnames_iter)
	{
		/* Set property value(s) using glGetTexParameteriv() */
		gl.texParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, pnames_iter->first, &pnames_iter->second);

		if (gl.getError() != GL_NO_ERROR)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "glTexParameteriv() call failed for pname: "
							   << getStringForGetTexParameterPname(pnames_iter->first)
							   << " and value: " << pnames_iter->second << tcu::TestLog::EndMessage;

			TCU_FAIL("glTexParameteriv() call failed");
		}

		verifyGetTexParameter(pnames_iter->first, pnames_iter->second);
	}

	/* Verify texture level parameter values reported by glGetTexLevelParameter*()
	 * functions are valid. */
	verifyGetTexLevelParameters();

	/* Delete a texture object */
	gl.deleteTextures(1, &m_to_id);
	m_to_id = 0;

	/* Generate a texture object */
	gl.genTextures(1, &m_to_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate a texture object!");

	/* Bind the texture object to GL_TEXTURE_CUBE_MAP_ARRAY_EXT texture target */
	gl.bindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, m_to_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind a texture object!");

	/* Set up immutable texture storage */
	gl.texStorage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 2, /* levels */
					GL_RGBA32F,					  /* internal format */
					m_width,					  /* width */
					m_height,					  /* height */
					m_depth);					  /* depth */
	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create an immutable texture storage!");

	/* Update expected values for all the properties we will be checking */
	m_expected_compressed			   = GL_FALSE;
	m_expected_alpha_size			   = 32;
	m_expected_alpha_type			   = GL_FLOAT;
	m_expected_blue_size			   = 32;
	m_expected_blue_type			   = GL_FLOAT;
	m_expected_green_size			   = 32;
	m_expected_green_type			   = GL_FLOAT;
	m_expected_red_size				   = 32;
	m_expected_red_type				   = GL_FLOAT;
	m_expected_depth_size			   = 0;
	m_expected_depth_type			   = GL_NONE;
	m_expected_shared_size			   = 0;
	m_expected_stencil_size			   = 0;
	m_expected_texture_internal_format = GL_RGBA32F;

	/* Verify that texture bindings have been updated */
	verifyTextureBindings();

	/* Verify texture parameter values reported by glGetTexParameter*() functions are valid. */
	pnames_iter = pnames_for_gettexparameter_default.begin();
	pnames_end  = pnames_for_gettexparameter_default.end();
	for (; pnames_iter != pnames_end; ++pnames_iter)
	{
		verifyGetTexParameter(pnames_iter->first, pnames_iter->second);
	}

	pnames_iter = pnames_for_gettexparameter_modified.begin();
	pnames_end  = pnames_for_gettexparameter_modified.end();
	for (; pnames_iter != pnames_end; ++pnames_iter)
	{
		/* Set property value(s) using glGetTexParameteriv() */
		gl.texParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, pnames_iter->first, &pnames_iter->second);

		if (gl.getError() != GL_NO_ERROR)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "glTexParameteriv() call failed for pname: "
							   << getStringForGetTexParameterPname(pnames_iter->first)
							   << " and value: " << pnames_iter->second << tcu::TestLog::EndMessage;

			TCU_FAIL("glTexParameteriv() call failed");
		}

		verifyGetTexParameter(pnames_iter->first, pnames_iter->second);
	}

	/* Verify texture level parameter values reported by glGetTexLevelParameter*()
	 * functions are valid. */
	verifyGetTexLevelParameters();

	if (m_test_passed)
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	else
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");

	return STOP;
}

/** Verifies GL_TEXTURE_CUBE_MAP_ARRAY_EXT texture binding is reported
 *  correctly by glGetBooleanv(), glGetFloatv() and glGetIntegerv().
 *
 *  It is assumed that texture object of id m_to_id is bound to
 *  GL_TEXTURE_CUBE_MAP_ARRAY_EXT texture binding point at the time
 *  of the call.
 *
 **/
void TextureCubeMapArrayGetterCalls::verifyTextureBindings(void)
{
	const glw::Functions& gl		  = m_context.getRenderContext().getFunctions();
	glw::GLboolean		  bool_value  = GL_FALSE;
	const float			  epsilon	 = 1e-5f;
	glw::GLfloat		  float_value = 0.0f;
	glw::GLint			  int_value   = 0;

	/* Check glGetBooleanv() reports a correct value */
	gl.getBooleanv(GL_TEXTURE_BINDING_CUBE_MAP_ARRAY, &bool_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() failed for GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT pname");

	if ((m_to_id == 0 && bool_value != GL_FALSE) || (m_to_id != 0 && bool_value != GL_TRUE))
	{
		m_testCtx.getLog()
			<< tcu::TestLog::Message
			<< "glGetBooleanv() reported an invalid value for GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT pname"
			<< tcu::TestLog::EndMessage;
		m_test_passed = false;
	}

	/* Check glGetFloatv() reports a correct value */
	gl.getFloatv(GL_TEXTURE_BINDING_CUBE_MAP_ARRAY, &float_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() failed for GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT pname");

	if (de::abs(float_value - static_cast<float>(m_to_id)) > epsilon)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "glGetFloatv() reported an invalid value for GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT pname"
						   << tcu::TestLog::EndMessage;
		m_test_passed = false;
	}

	/* Check glGetIntegerv() reports a correct value */
	gl.getIntegerv(GL_TEXTURE_BINDING_CUBE_MAP_ARRAY, &int_value);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT pname");

	if (de::abs(float_value - static_cast<float>(m_to_id)) > epsilon)
	{
		m_testCtx.getLog()
			<< tcu::TestLog::Message
			<< "glGetIntegerv() reported an invalid value for GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT pname"
			<< tcu::TestLog::EndMessage;
		m_test_passed = false;
	}
}

/** Verifies that all texture parameter values reported by corresponding
 *  getter functions are as defined for a texture object currently bound to
 *  GL_TEXTURE_CUBE_MAP_ARRAY_EXT binding point
 **/
void TextureCubeMapArrayGetterCalls::verifyGetTexParameter(glw::GLenum pname, glw::GLint expected_value)
{
	/* Retrieve ES function pointers */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	glw::GLint int_value = 0;

	/* Retrieve property value(s) using glGetTexParameteriv() */
	gl.getTexParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, pname, &int_value);

	if (gl.getError() != GL_NO_ERROR)
	{
		m_testCtx.getLog() << tcu::TestLog::Message
						   << "glGetTexParameteriv() call failed for pname: " << getStringForGetTexParameterPname(pname)
						   << tcu::TestLog::EndMessage;

		TCU_FAIL("glGetTexLevelParameteriv() call failed");
	}

	if (int_value != expected_value)
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexParameteriv() called for pname: "
													   "["
						   << getStringForGetTexParameterPname(pname) << "]"
																		 " returned an invalid value of:"
																		 "["
						   << int_value << "]"
										   ", expected:"
										   "["
						   << expected_value << "]" << tcu::TestLog::EndMessage;

		m_test_passed = false;
	}
}

/** Verifies that all texture level parameter values reported by corresponding
 *  getter functions are as defined for a texture object currently bound to
 *  GL_TEXTURE_CUBE_MAP_ARRAY_EXT binding point
 **/
void TextureCubeMapArrayGetterCalls::verifyGetTexLevelParameters(void)
{
	/* Retrieve ES function pointers */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	glw::GLfloat	   float_value = 0.0f;
	glw::GLint		   int_value   = 0;
	const glw::GLfloat epsilon	 = 1e-5f;

	PNamesVec::iterator pnames_end = pnames_for_gettexlevelparameter.end();
	for (PNamesVec::iterator pnames_iter = pnames_for_gettexlevelparameter.begin(); pnames_iter != pnames_end;
		 ++pnames_iter)
	{
		glw::GLenum pname = *pnames_iter;

		/* Retrieve property value(s) using glGetTexLevelParameteriv() */
		gl.getTexLevelParameteriv(GL_TEXTURE_CUBE_MAP_ARRAY, 0, /* level */
								  pname, &int_value);

		if (gl.getError() != GL_NO_ERROR)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameteriv() call failed for pname: "
							   << getStringForGetTexLevelParameterPname(pname) << tcu::TestLog::EndMessage;

			TCU_FAIL("glGetTexLevelParameteriv() call failed");
		}

		/* Retrieve property value(s) using glGetTexLevelParameterfv() */
		gl.getTexLevelParameterfv(GL_TEXTURE_CUBE_MAP_ARRAY, 0, /* level */
								  pname, &float_value);

		if (gl.getError() != GL_NO_ERROR)
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameterfv() call failed for pname: "
							   << getStringForGetTexLevelParameterPname(pname) << tcu::TestLog::EndMessage;

			TCU_FAIL("glGetTexLevelParameterfv() call failed");
		}

		/* Make sure the property values are valid */
		glw::GLboolean should_use_equal_comparison = true;
		glw::GLint	 expected_property_int_value = 0;

		switch (pname)
		{
		case GL_TEXTURE_ALPHA_SIZE:
		{
			expected_property_int_value = m_expected_alpha_size;
			should_use_equal_comparison = false;
			break;
		}

		case GL_TEXTURE_ALPHA_TYPE:
		{
			expected_property_int_value = m_expected_alpha_type;
			break;
		}

		case GL_TEXTURE_BLUE_SIZE:
		{
			expected_property_int_value = m_expected_blue_size;
			should_use_equal_comparison = false;
			break;
		}

		case GL_TEXTURE_BLUE_TYPE:
		{
			expected_property_int_value = m_expected_blue_type;
			break;
		}

		case GL_TEXTURE_COMPRESSED:
		{
			expected_property_int_value = m_expected_compressed;
			break;
		}

		case GL_TEXTURE_DEPTH:
		{
			expected_property_int_value = m_depth;
			break;
		}

		case GL_TEXTURE_DEPTH_SIZE:
		{
			expected_property_int_value = m_expected_depth_size;
			break;
		}

		case GL_TEXTURE_DEPTH_TYPE:
		{
			expected_property_int_value = m_expected_depth_type;
			break;
		}

		case GL_TEXTURE_GREEN_SIZE:
		{
			expected_property_int_value = m_expected_green_size;
			should_use_equal_comparison = false;
			break;
		}

		case GL_TEXTURE_GREEN_TYPE:
		{
			expected_property_int_value = m_expected_green_type;
			break;
		}

		case GL_TEXTURE_HEIGHT:
		{
			expected_property_int_value = m_height;
			break;
		}

		case GL_TEXTURE_INTERNAL_FORMAT:
		{
			expected_property_int_value = m_expected_texture_internal_format;
			break;
		}

		case GL_TEXTURE_RED_SIZE:
		{
			expected_property_int_value = m_expected_red_size;
			should_use_equal_comparison = false;
			break;
		}

		case GL_TEXTURE_RED_TYPE:
		{
			expected_property_int_value = m_expected_red_type;

			break;
		}

		case GL_TEXTURE_SHARED_SIZE:
		{
			expected_property_int_value = m_expected_shared_size;
			should_use_equal_comparison = false;
			break;
		}

		case GL_TEXTURE_STENCIL_SIZE:
		{
			expected_property_int_value = m_expected_stencil_size;
			break;
		}

		case GL_TEXTURE_WIDTH:
		{
			expected_property_int_value = m_width;
			break;
		}

		default:
		{
			TCU_FAIL("Unrecognized pname");
		}
		} /* switch(pname) */

		if ((should_use_equal_comparison && (expected_property_int_value != int_value)) ||
			(!should_use_equal_comparison && (expected_property_int_value < int_value)))
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameteriv() called for pname: "
														   "["
							   << getStringForGetTexLevelParameterPname(pname) << "]"
																				  " returned an invalid value of:"
																				  "["
							   << int_value << "]"
											   ", expected:"
											   "["
							   << expected_property_int_value << "]" << tcu::TestLog::EndMessage;

			m_test_passed = false;
		}

		glw::GLfloat expected_property_float_value = static_cast<glw::GLfloat>(expected_property_int_value);
		if ((should_use_equal_comparison && (de::abs(float_value - (expected_property_float_value)) > epsilon)) ||
			(!should_use_equal_comparison && (expected_property_float_value < float_value)))
		{
			m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameterfv() called for pname: "
														   "["
							   << getStringForGetTexLevelParameterPname(pname) << "]"
																				  " returned an invalid value of:"
																				  "["
							   << float_value << "]"
												 ", expected:"
												 "["
							   << expected_property_float_value << "]" << tcu::TestLog::EndMessage;

			m_test_passed = false;
		}
	} /* for (all property names) */
}

} // namespace glcts