/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-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  gl4cDirectStateAccessTexturesTests.cpp
 * \brief Conformance tests for the Direct State Access feature functionality (Texture access part).
 */ /*-----------------------------------------------------------------------------------------------------------*/

/* Uncomment this if SubImageErrorsTest crashes during negative test of TextureSubImage (negative value width/height/depth passed to the function). */
/* #define TURN_OFF_SUB_IMAGE_ERRORS_TEST_OF_NEGATIVE_WIDTH_HEIGHT_OR_DEPTH */

/* Includes. */
#include "gl4cDirectStateAccessTests.hpp"

#include "deSharedPtr.hpp"

#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "gluPixelTransfer.hpp"
#include "gluStrUtil.hpp"

#include "tcuFuzzyImageCompare.hpp"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"

#include "glw.h"
#include "glwFunctions.hpp"

#include <algorithm>
#include <climits>
#include <set>
#include <sstream>
#include <stack>
#include <string>

namespace gl4cts
{
namespace DirectStateAccess
{
namespace Textures
{
/******************************** Creation Test Implementation   ********************************/

/** @brief Creation Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
CreationTest::CreationTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_creation", "Texture Objects Creation Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Creation Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult CreationTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Textures' objects */
	static const glw::GLenum texture_targets[] = { GL_TEXTURE_1D,
												   GL_TEXTURE_2D,
												   GL_TEXTURE_3D,
												   GL_TEXTURE_1D_ARRAY,
												   GL_TEXTURE_2D_ARRAY,
												   GL_TEXTURE_RECTANGLE,
												   GL_TEXTURE_CUBE_MAP,
												   GL_TEXTURE_CUBE_MAP_ARRAY,
												   GL_TEXTURE_BUFFER,
												   GL_TEXTURE_2D_MULTISAMPLE,
												   GL_TEXTURE_2D_MULTISAMPLE_ARRAY };
	static const glw::GLuint texture_targets_count = sizeof(texture_targets) / sizeof(texture_targets[0]);
	static const glw::GLuint textures_count		   = 2;

	glw::GLuint textures_legacy[textures_count]						= {};
	glw::GLuint textures_dsa[texture_targets_count][textures_count] = {};

	try
	{
		/* Check legacy state creation. */
		gl.genTextures(textures_count, textures_legacy);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		for (glw::GLuint i = 0; i < textures_count; ++i)
		{
			if (gl.isTexture(textures_legacy[i]))
			{
				is_ok = false;

				/* Log. */
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message
					<< "GenTextures has created default objects, but it should create only a names."
					<< tcu::TestLog::EndMessage;
			}
		}

		/* Check direct state creation. */
		for (glw::GLuint j = 0; j < texture_targets_count; ++j)
		{
			gl.createTextures(texture_targets[j], textures_count, textures_dsa[j]);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

			for (glw::GLuint i = 0; i < textures_count; ++i)
			{
				if (!gl.isTexture(textures_dsa[j][i]))
				{
					is_ok = false;

					/* Log. */
					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "CreateTextures has not created default objects for target "
						<< glu::getTextureTargetStr(texture_targets[j]) << "." << tcu::TestLog::EndMessage;
				}
			}
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	for (glw::GLuint i = 0; i < textures_count; ++i)
	{
		if (textures_legacy[i])
		{
			gl.deleteTextures(1, &textures_legacy[i]);

			textures_legacy[i] = 0;
		}

		for (glw::GLuint j = 0; j < texture_targets_count; ++j)
		{
			if (textures_dsa[j][i])
			{
				gl.deleteTextures(1, &textures_dsa[j][i]);

				textures_dsa[j][i] = 0;
			}
		}
	}

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/******************************** Reference Data Implementation   *****************************/

/** @brief Internal Format selector.
 *
 *  @tparam T      Type.
 *  @tparam S      Size (# of components).
 *  @tparam N      Is normalized.
 *
 *  @return Internal format.
 */
template <>
glw::GLenum Reference::InternalFormat<glw::GLbyte, 1, false>()
{
	return GL_R8I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLbyte, 2, false>()
{
	return GL_RG8I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLbyte, 3, false>()
{
	return GL_RGB8I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLbyte, 4, false>()
{
	return GL_RGBA8I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 1, false>()
{
	return GL_R8UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 2, false>()
{
	return GL_RG8UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 3, false>()
{
	return GL_RGB8UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 4, false>()
{
	return GL_RGBA8UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLshort, 1, false>()
{
	return GL_R16I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLshort, 2, false>()
{
	return GL_RG16I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLshort, 3, false>()
{
	return GL_RGB16I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLshort, 4, false>()
{
	return GL_RGBA16I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 1, false>()
{
	return GL_R16UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 2, false>()
{
	return GL_RG16UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 3, false>()
{
	return GL_RGB16UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 4, false>()
{
	return GL_RGBA16UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLint, 1, false>()
{
	return GL_R32I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLint, 2, false>()
{
	return GL_RG32I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLint, 3, false>()
{
	return GL_RGB32I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLint, 4, false>()
{
	return GL_RGBA32I;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLuint, 1, false>()
{
	return GL_R32UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLuint, 2, false>()
{
	return GL_RG32UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLuint, 3, false>()
{
	return GL_RGB32UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLuint, 4, false>()
{
	return GL_RGBA32UI;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 1, true>()
{
	return GL_R8;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 2, true>()
{
	return GL_RG8;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 3, true>()
{
	return GL_RGB8;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLubyte, 4, true>()
{
	return GL_RGBA8;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 1, true>()
{
	return GL_R16;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 2, true>()
{
	return GL_RG16;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 3, true>()
{
	return GL_RGB16;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLushort, 4, true>()
{
	return GL_RGBA16;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLfloat, 1, true>()
{
	return GL_R32F;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLfloat, 2, true>()
{
	return GL_RG32F;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLfloat, 3, true>()
{
	return GL_RGB32F;
}

template <>
glw::GLenum Reference::InternalFormat<glw::GLfloat, 4, true>()
{
	return GL_RGBA32F;
}

/** @brief Format selector.
 *
 *  @tparam S      Size (# of components).
 *  @tparam N      Is normalized.
 *
 *  @return format.
 */
template <>
glw::GLenum Reference::Format<1, false>()
{
	return GL_RED_INTEGER;
}

template <>
glw::GLenum Reference::Format<2, false>()
{
	return GL_RG_INTEGER;
}

template <>
glw::GLenum Reference::Format<3, false>()
{
	return GL_RGB_INTEGER;
}

template <>
glw::GLenum Reference::Format<4, false>()
{
	return GL_RGBA_INTEGER;
}

template <>
glw::GLenum Reference::Format<1, true>()
{
	return GL_RED;
}

template <>
glw::GLenum Reference::Format<2, true>()
{
	return GL_RG;
}

template <>
glw::GLenum Reference::Format<3, true>()
{
	return GL_RGB;
}

template <>
glw::GLenum Reference::Format<4, true>()
{
	return GL_RGBA;
}

/** @brief Type selector.
 *
 *  @tparam T      Type.
 *
 *  @return Type.
 */
template <>
glw::GLenum Reference::Type<glw::GLbyte>()
{
	return GL_BYTE;
}

template <>
glw::GLenum Reference::Type<glw::GLubyte>()
{
	return GL_UNSIGNED_BYTE;
}

template <>
glw::GLenum Reference::Type<glw::GLshort>()
{
	return GL_SHORT;
}

template <>
glw::GLenum Reference::Type<glw::GLushort>()
{
	return GL_UNSIGNED_SHORT;
}

template <>
glw::GLenum Reference::Type<glw::GLint>()
{
	return GL_INT;
}

template <>
glw::GLenum Reference::Type<glw::GLuint>()
{
	return GL_UNSIGNED_INT;
}

template <>
glw::GLenum Reference::Type<glw::GLfloat>()
{
	return GL_FLOAT;
}

/** @brief Reference data selector.
 *
 *  @tparam T      Type.
 *  @tparam N      Is normalized.
 *
 *  @return Reference data.
 */

/* RGBA8I */
template <>
const glw::GLbyte* Reference::ReferenceData<glw::GLbyte, false>()
{
	static const glw::GLbyte reference[s_reference_count] = {
		0,  -1,  2,  -3,  4,  -5,  6,  -7,  8,  -9,  10, -11, 12, -13, 14, -15, 16, -17, 18, -19, 20, -21, 22, -23,
		24, -25, 26, -27, 28, -29, 30, -31, 32, -33, 34, -35, 36, -37, 38, -39, 40, -41, 42, -43, 44, -45, 46, -47,
		48, -49, 50, -51, 52, -53, 54, -55, 56, -57, 58, -59, 60, -61, 62, -63, 64, -65, 66, -67, 68, -69, 70, -71,
		72, -73, 74, -75, 76, -77, 78, -79, 80, -81, 82, -83, 84, -85, 86, -87, 88, -89, 90, -91, 92, -93, 94, -95
	};
	return reference;
}

/* RGBA8UI */
template <>
const glw::GLubyte* Reference::ReferenceData<glw::GLubyte, false>()
{
	static const glw::GLubyte reference[s_reference_count] = {
		0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
		24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
		72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95
	};
	return reference;
}

/* RGBA16I */
template <>
const glw::GLshort* Reference::ReferenceData<glw::GLshort, false>()
{
	static const glw::GLshort reference[s_reference_count] = {
		0,  -1,  2,  -3,  4,  -5,  6,  -7,  8,  -9,  10, -11, 12, -13, 14, -15, 16, -17, 18, -19, 20, -21, 22, -23,
		24, -25, 26, -27, 28, -29, 30, -31, 32, -33, 34, -35, 36, -37, 38, -39, 40, -41, 42, -43, 44, -45, 46, -47,
		48, -49, 50, -51, 52, -53, 54, -55, 56, -57, 58, -59, 60, -61, 62, -63, 64, -65, 66, -67, 68, -69, 70, -71,
		72, -73, 74, -75, 76, -77, 78, -79, 80, -81, 82, -83, 84, -85, 86, -87, 88, -89, 90, -91, 92, -93, 94, -95
	};
	return reference;
}

/* RGBA16UI */
template <>
const glw::GLushort* Reference::ReferenceData<glw::GLushort, false>()
{
	static const glw::GLushort reference[s_reference_count] = {
		0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
		24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
		72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95
	};
	return reference;
}

/* RGBA32I */
template <>
const glw::GLint* Reference::ReferenceData<glw::GLint, false>()
{
	static const glw::GLint reference[s_reference_count] = {
		0,  -1,  2,  -3,  4,  -5,  6,  -7,  8,  -9,  10, -11, 12, -13, 14, -15, 16, -17, 18, -19, 20, -21, 22, -23,
		24, -25, 26, -27, 28, -29, 30, -31, 32, -33, 34, -35, 36, -37, 38, -39, 40, -41, 42, -43, 44, -45, 46, -47,
		48, -49, 50, -51, 52, -53, 54, -55, 56, -57, 58, -59, 60, -61, 62, -63, 64, -65, 66, -67, 68, -69, 70, -71,
		72, -73, 74, -75, 76, -77, 78, -79, 80, -81, 82, -83, 84, -85, 86, -87, 88, -89, 90, -91, 92, -93, 94, -95
	};
	return reference;
}

/* RGBA32UI */
template <>
const glw::GLuint* Reference::ReferenceData<glw::GLuint, false>()
{
	static const glw::GLuint reference[s_reference_count] = {
		0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
		24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
		72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95
	};
	return reference;
}

/* RGBA8 */
template <>
const glw::GLubyte* Reference::ReferenceData<glw::GLubyte, true>()
{
	static const glw::GLubyte reference[s_reference_count] = {
		0,   2,   5,   8,   10,  13,  16,  18,  21,  24,  26,  29,  32,  34,  37,  40,  42,  45,  48,  51,
		53,  56,  59,  61,  64,  67,  69,  72,  75,  77,  80,  83,  85,  88,  91,  93,  96,  99,  102, 104,
		107, 110, 112, 115, 118, 120, 123, 126, 128, 131, 134, 136, 139, 142, 144, 147, 150, 153, 155, 158,
		161, 163, 166, 169, 171, 174, 177, 179, 182, 185, 187, 190, 193, 195, 198, 201, 204, 206, 209, 212,
		214, 217, 220, 222, 225, 228, 230, 233, 236, 238, 241, 244, 246, 249, 252, 255
	};
	return reference;
}

/* RGBA16 */
template <>
const glw::GLushort* Reference::ReferenceData<glw::GLushort, true>()
{
	static const glw::GLushort reference[s_reference_count] = {
		0,	 689,   1379,  2069,  2759,  3449,  4139,  4828,  5518,  6208,  6898,  7588,  8278,  8967,  9657,  10347,
		11037, 11727, 12417, 13107, 13796, 14486, 15176, 15866, 16556, 17246, 17935, 18625, 19315, 20005, 20695, 21385,
		22074, 22764, 23454, 24144, 24834, 25524, 26214, 26903, 27593, 28283, 28973, 29663, 30353, 31042, 31732, 32422,
		33112, 33802, 34492, 35181, 35871, 36561, 37251, 37941, 38631, 39321, 40010, 40700, 41390, 42080, 42770, 43460,
		44149, 44839, 45529, 46219, 46909, 47599, 48288, 48978, 49668, 50358, 51048, 51738, 52428, 53117, 53807, 54497,
		55187, 55877, 56567, 57256, 57946, 58636, 59326, 60016, 60706, 61395, 62085, 62775, 63465, 64155, 64845, 65535
	};
	return reference;
}

/* RGBA32F */
template <>
const glw::GLfloat* Reference::ReferenceData<glw::GLfloat, true>()
{
	static const glw::GLfloat reference[s_reference_count] = {
		0.f,		   0.0105263158f, 0.0210526316f, 0.0315789474f, 0.0421052632f, 0.0526315789f,
		0.0631578947f, 0.0736842105f, 0.0842105263f, 0.0947368421f, 0.1052631579f, 0.1157894737f,
		0.1263157895f, 0.1368421053f, 0.1473684211f, 0.1578947368f, 0.1684210526f, 0.1789473684f,
		0.1894736842f, 0.2f,		  0.2105263158f, 0.2210526316f, 0.2315789474f, 0.2421052632f,
		0.2526315789f, 0.2631578947f, 0.2736842105f, 0.2842105263f, 0.2947368421f, 0.3052631579f,
		0.3157894737f, 0.3263157895f, 0.3368421053f, 0.3473684211f, 0.3578947368f, 0.3684210526f,
		0.3789473684f, 0.3894736842f, 0.4f,			 0.4105263158f, 0.4210526316f, 0.4315789474f,
		0.4421052632f, 0.4526315789f, 0.4631578947f, 0.4736842105f, 0.4842105263f, 0.4947368421f,
		0.5052631579f, 0.5157894737f, 0.5263157895f, 0.5368421053f, 0.5473684211f, 0.5578947368f,
		0.5684210526f, 0.5789473684f, 0.5894736842f, 0.6f,			0.6105263158f, 0.6210526316f,
		0.6315789474f, 0.6421052632f, 0.6526315789f, 0.6631578947f, 0.6736842105f, 0.6842105263f,
		0.6947368421f, 0.7052631579f, 0.7157894737f, 0.7263157895f, 0.7368421053f, 0.7473684211f,
		0.7578947368f, 0.7684210526f, 0.7789473684f, 0.7894736842f, 0.8f,		   0.8105263158f,
		0.8210526316f, 0.8315789474f, 0.8421052632f, 0.8526315789f, 0.8631578947f, 0.8736842105f,
		0.8842105263f, 0.8947368421f, 0.9052631579f, 0.9157894737f, 0.9263157895f, 0.9368421053f,
		0.9473684211f, 0.9578947368f, 0.9684210526f, 0.9789473684f, 0.9894736842f, 1.f
	};
	return reference;
}

/* Total number of reference components. */
glw::GLuint Reference::ReferenceDataCount()
{
	return s_reference_count;
}

/* Total number of reference size in basic machine units. */
template <typename T>
glw::GLuint Reference::ReferenceDataSize()
{
	return Reference::ReferenceDataCount() * sizeof(T);
}

/** @brief Comparison function (for floats).
 *
 *  @param [in] a      First element.
 *  @param [in] b      Second element.
 *
 *  @return Comparison result.
 */
template <>
bool Reference::Compare<glw::GLfloat>(const glw::GLfloat a, const glw::GLfloat b)
{
	if (de::abs(a - b) < 1.f / 256.f)
	{
		return true;
	}
	return false;
}

/** @brief Comparison function (integer).
 *
 *  @param [in] a      First element.
 *  @param [in] b      Second element.
 *
 *  @return Comparison result.
 */
template <typename T>
bool Reference::Compare(const T a, const T b)
{
	return a == b;
}

/******************************** Buffer Test Implementation   ********************************/

/** @brief Buffer Test constructor.
 *
 *  @tparam T      Type.
 *  @tparam S      Size.
 *  @tparam N      Is normalized.
 *
 *  @param [in] context     OpenGL context.
 *  @param [in] name     Name of the test.
 */
template <typename T, glw::GLint S, bool N>
BufferTest<T, S, N>::BufferTest(deqp::Context& context, const char* name)
	: deqp::TestCase(context, name, "Texture Buffer Objects Test")
	, m_fbo(0)
	, m_rbo(0)
	, m_po(0)
	, m_to(0)
	, m_bo(0)
	, m_vao(0)
{
	/* Intentionally left blank. */
}

/** @brief Count of reference data to be teted.
 *
 *  @return Count.
 */
template <typename T, glw::GLint S, bool N>
glw::GLuint BufferTest<T, S, N>::TestReferenceDataCount()
{
	return s_fbo_size_x * S;
}

/** @brief Size of reference data to be teted..
 *
 *  @return Size.
 */
template <typename T, glw::GLint S, bool N>
glw::GLuint BufferTest<T, S, N>::TestReferenceDataSize()
{
	return static_cast<glw::GLint>(TestReferenceDataCount() * sizeof(T));
}

/** @brief Create buffer textuew.
 *
 *  @param [in] use_range_version       Uses TextureBufferRange instead TextureBuffer.
 *
 *  @return True if succeded, false otherwise.
 */
template <typename T, glw::GLint S, bool N>
bool BufferTest<T, S, N>::CreateBufferTexture(bool use_range_version)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Objects creation. */
	gl.genTextures(1, &m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

	gl.bindTexture(GL_TEXTURE_BUFFER, m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.genBuffers(1, &m_bo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers has failed");

	gl.bindBuffer(GL_TEXTURE_BUFFER, m_bo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

	/* Data setup. */
	if (use_range_version)
	{
		glw::GLint alignment = 1;

		gl.getIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &alignment);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv has failed");

		const glw::GLuint b_offset = alignment;
		const glw::GLuint b_size   = TestReferenceDataSize() + b_offset;

		gl.bufferData(GL_TEXTURE_BUFFER, b_size, NULL, GL_STATIC_DRAW);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData has failed");

		gl.bufferSubData(GL_TEXTURE_BUFFER, b_offset, TestReferenceDataSize(), ReferenceData<T, N>());
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferSubdata has failed");

		gl.textureBufferRange(m_to, InternalFormat<T, S, N>(), m_bo, b_offset, TestReferenceDataSize());
	}
	else
	{
		gl.bufferData(GL_TEXTURE_BUFFER, TestReferenceDataSize(), ReferenceData<T, N>(), GL_STATIC_DRAW);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData has failed");

		gl.textureBuffer(m_to, InternalFormat<T, S, N>(), m_bo);
	}

	/* Error checking. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		/* Log. */
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << (use_range_version ? ("glTextureBufferRange") : ("glTextureBuffer"))
			<< " unexpectedly generated error " << glu::getErrorStr(error) << " during test of internal format "
			<< glu::getTextureFormatStr(InternalFormat<T, S, N>()) << "." << tcu::TestLog::EndMessage;

		CleanBufferTexture();

		return false;
	}

	return true;
}

/** @brief Function prepares framebuffer with internal format color attachment.
 *         Viewport is set up. Content of the framebuffer is cleared.
 *
 *  @note The function may throw if unexpected error has occured.
 *
 *  @return if the framebuffer returned is supported
 */
template <typename T, glw::GLint S, bool N>
bool BufferTest<T, S, N>::PrepareFramebuffer(const glw::GLenum internal_format)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.genRenderbuffers(1, &m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.renderbufferStorage(GL_RENDERBUFFER, internal_format, s_fbo_size_x, s_fbo_size_y);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");

	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNSUPPORTED)
			throw tcu::NotSupportedError("unsupported framebuffer configuration");
		else
			throw 0;
	}

	gl.viewport(0, 0, s_fbo_size_x, s_fbo_size_y);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	/* Clear framebuffer's content. */
	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");

	return true;
}

/** @brief Create program.
 *
 *  @param [in] variable_declaration    Choose variable declaration of the fragment shader.
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::PrepareProgram(const glw::GLchar* variable_declaration)
{
	/* Shortcut for GL functionality */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	struct Shader
	{
		glw::GLchar const* source[3];
		glw::GLsizei const count;
		glw::GLenum const  type;
		glw::GLuint		   id;
	} shader[] = {
		{ { s_vertex_shader, NULL, NULL }, 1, GL_VERTEX_SHADER, 0 },
		{ { s_fragment_shader_head, variable_declaration, s_fragment_shader_tail }, 3, GL_FRAGMENT_SHADER, 0 }
	};

	glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);

	try
	{
		/* Create program. */
		m_po = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");

		/* Shader compilation. */

		for (glw::GLuint i = 0; i < shader_count; ++i)
		{
			{
				shader[i].id = gl.createShader(shader[i].type);

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

				gl.attachShader(m_po, shader[i].id);

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

				gl.shaderSource(shader[i].id, shader[i].count, shader[i].source, NULL);

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

				gl.compileShader(shader[i].id);

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

				glw::GLint status = GL_FALSE;

				gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

				if (GL_FALSE == status)
				{
					glw::GLint log_size = 0;
					gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
					GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

					glw::GLchar* log_text = new glw::GLchar[log_size];

					gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);

					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "Shader compilation has failed.\n"
						<< "Shader type: " << glu::getShaderTypeStr(shader[i].type) << "\n"
						<< "Shader compilation error log:\n"
						<< log_text << "\n"
						<< "Shader source code:\n"
						<< shader[i].source[0] << (shader[i].source[1] ? shader[i].source[1] : "")
						<< (shader[i].source[2] ? shader[i].source[2] : "") << "\n"
						<< tcu::TestLog::EndMessage;

					delete[] log_text;

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

					throw 0;
				}
			}
		}

		/* Link. */
		gl.linkProgram(m_po);

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

		glw::GLint status = GL_FALSE;

		gl.getProgramiv(m_po, GL_LINK_STATUS, &status);

		if (GL_TRUE == status)
		{
			for (glw::GLuint i = 0; i < shader_count; ++i)
			{
				if (shader[i].id)
				{
					gl.detachShader(m_po, shader[i].id);

					GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
				}
			}
		}
		else
		{
			glw::GLint log_size = 0;

			gl.getProgramiv(m_po, GL_INFO_LOG_LENGTH, &log_size);

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

			glw::GLchar* log_text = new glw::GLchar[log_size];

			gl.getProgramInfoLog(m_po, log_size, NULL, &log_text[0]);

			m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n"
												<< log_text << "\n"
												<< tcu::TestLog::EndMessage;

			delete[] log_text;

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

			throw 0;
		}
	}
	catch (...)
	{
		if (m_po)
		{
			gl.deleteProgram(m_po);

			m_po = 0;
		}
	}

	for (glw::GLuint i = 0; i < shader_count; ++i)
	{
		if (0 != shader[i].id)
		{
			gl.deleteShader(shader[i].id);

			shader[i].id = 0;
		}
	}

	if (0 == m_po)
	{
		throw 0;
	}
}

/** @brief Create VAO.
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::PrepareVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genVertexArrays(1, &m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays has failed");

	gl.bindVertexArray(m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray has failed");
}

/** @brief Test's draw function.
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::Draw()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.useProgram(m_po);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram has failed");

	gl.activeTexture(GL_TEXTURE0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.bindTextureUnit(0, m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays has failed");
}

/** @brief Compre results with the reference.
 *
 *  @return True if equal, false otherwise.
 */
template <typename T, glw::GLint S, bool N>
bool BufferTest<T, S, N>::Check()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Fetching data. */
	std::vector<T> result(TestReferenceDataCount());

	gl.pixelStorei(GL_UNPACK_ALIGNMENT, sizeof(T));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	gl.pixelStorei(GL_PACK_ALIGNMENT, sizeof(T));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	gl.readnPixels(0, 0, s_fbo_size_x, s_fbo_size_y, Format<S, N>(), Type<T>(), TestReferenceDataSize(),
				   (glw::GLvoid*)(&result[0]));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels has failed");

	/* Comparison. */
	bool is_ok = true;

	for (glw::GLuint i = 0; i < TestReferenceDataCount(); ++i)
	{
		if (!Compare<T>(result[i], ReferenceData<T, N>()[i]))
		{
			is_ok = false;

			break;
		}
	}

	return is_ok;
}

/** @brief Test function.
 *
 *  @param [in] use_range_version   Uses TextureBufferRange instead TextureBuffer.
 *
 *  @return True if succeeded, false otherwise.
 */
template <typename T, glw::GLint S, bool N>
bool BufferTest<T, S, N>::Test(bool use_range_version)
{
	/* Setup. */
	if (!PrepareFramebuffer(InternalFormat<T, S, N>()))
	{
		/**
                 * If the framebuffer it not supported, means that the
                 * tested combination is unsupported for this driver,
                 * but allowed to be unsupported by OpenGL spec, so we
                 * just skip.
                 */
		CleanFramebuffer();
		CleanErrors();

		return true;
	}

	if (!CreateBufferTexture(use_range_version))
	{
		CleanFramebuffer();
		CleanErrors();

		return false;
	}

	/* Action. */
	Draw();

	/* Compare results with reference. */
	bool result = Check();

	/* Cleanup. */
	CleanFramebuffer();
	CleanBufferTexture();
	CleanErrors();

	/* Pass result. */
	return result;
}

/** @brief Clean GL objects
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::CleanBufferTexture()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Texture. */
	if (m_to)
	{
		gl.deleteTextures(1, &m_to);

		m_to = 0;
	}

	/* Texture buffer. */
	if (m_bo)
	{
		gl.deleteBuffers(1, &m_bo);

		m_bo = 0;
	}
}

/** @brief Clean GL objects
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::CleanFramebuffer()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Framebuffer. */
	if (m_fbo)
	{
		gl.deleteFramebuffers(1, &m_fbo);

		m_fbo = 0;
	}

	/* Renderbuffer. */
	if (m_rbo)
	{
		gl.deleteRenderbuffers(1, &m_rbo);

		m_rbo = 0;
	}
}

/** @brief Clean GL objects
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::CleanProgram()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Program. */
	if (m_po)
	{
		gl.useProgram(0);

		gl.deleteProgram(m_po);

		m_po = 0;
	}
}

/** @brief Clean errors.
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::CleanErrors()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Query all errors until GL_NO_ERROR occure. */
	while (GL_NO_ERROR != gl.getError())
		;
}

/** @brief Clean GL objects
 */
template <typename T, glw::GLint S, bool N>
void BufferTest<T, S, N>::CleanVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (m_vao)
	{
		gl.bindVertexArray(0);

		gl.deleteVertexArrays(1, &m_vao);

		m_vao = 0;
	}
}

/** @brief Iterate Buffer Test cases.
 *
 *  @return Iteration result.
 */
template <typename T, glw::GLint S, bool N>
tcu::TestNode::IterateResult BufferTest<T, S, N>::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		PrepareVertexArray();

		PrepareProgram(FragmentShaderDeclaration());

		for (glw::GLuint i = 0; i < 2; ++i)
		{
			bool use_range = (i == 1);
			is_ok &= Test(use_range);
			CleanErrors();
		}

		CleanProgram();
	}
	catch (tcu::NotSupportedError& e)
	{
		throw e;
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	CleanBufferTexture();
	CleanFramebuffer();
	CleanProgram();
	CleanErrors();
	CleanVertexArray();

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/* Vertex shader source code. */
template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_vertex_shader = "#version 450\n"
														  "\n"
														  "void main()\n"
														  "{\n"
														  "    switch(gl_VertexID)\n"
														  "    {\n"
														  "        case 0:\n"
														  "            gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
														  "            break;\n"
														  "        case 1:\n"
														  "            gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
														  "            break;\n"
														  "        case 2:\n"
														  "            gl_Position = vec4(-1.0,-1.0, 0.0, 1.0);\n"
														  "            break;\n"
														  "        case 3:\n"
														  "            gl_Position = vec4( 1.0,-1.0, 0.0, 1.0);\n"
														  "            break;\n"
														  "    }\n"
														  "}\n";

/* Fragment shader source program. */
template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_head = "#version 450\n"
																 "\n"
																 "layout(pixel_center_integer) in vec4 gl_FragCoord;\n"
																 "\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_fdecl_lowp = "uniform samplerBuffer texture_input;\n"
																	   "out     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_idecl_lowp = "uniform isamplerBuffer texture_input;\n"
																	   "out     ivec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_udecl_lowp = "uniform usamplerBuffer texture_input;\n"
																	   "out     uvec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_fdecl_mediump = "uniform samplerBuffer texture_input;\n"
																		  "out     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_idecl_mediump = "uniform isamplerBuffer texture_input;\n"
																		  "out     ivec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_udecl_mediump = "uniform usamplerBuffer texture_input;\n"
																		  "out     uvec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_fdecl_highp = "uniform samplerBuffer texture_input;\n"
																		"out     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_idecl_highp = "uniform isamplerBuffer texture_input;\n"
																		"out     ivec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_udecl_highp = "uniform usamplerBuffer texture_input;\n"
																		"out     uvec4          texture_output;\n";

template <typename T, glw::GLint S, bool N>
const glw::GLchar* BufferTest<T, S, N>::s_fragment_shader_tail =
	"\n"
	"void main()\n"
	"{\n"
	"    texture_output = texelFetch(texture_input, int(gl_FragCoord.x));\n"
	"}\n";

template class BufferTest<glw::GLbyte, 1, false>;
template class BufferTest<glw::GLbyte, 2, false>;
template class BufferTest<glw::GLbyte, 4, false>;

template class BufferTest<glw::GLubyte, 1, false>;
template class BufferTest<glw::GLubyte, 2, false>;
template class BufferTest<glw::GLubyte, 4, false>;
template class BufferTest<glw::GLubyte, 1, true>;
template class BufferTest<glw::GLubyte, 2, true>;
template class BufferTest<glw::GLubyte, 4, true>;

template class BufferTest<glw::GLshort, 1, false>;
template class BufferTest<glw::GLshort, 2, false>;
template class BufferTest<glw::GLshort, 4, false>;

template class BufferTest<glw::GLushort, 1, false>;
template class BufferTest<glw::GLushort, 2, false>;
template class BufferTest<glw::GLushort, 4, false>;
template class BufferTest<glw::GLushort, 1, true>;
template class BufferTest<glw::GLushort, 2, true>;
template class BufferTest<glw::GLushort, 4, true>;

template class BufferTest<glw::GLint, 1, false>;
template class BufferTest<glw::GLint, 2, false>;
template class BufferTest<glw::GLint, 3, false>;
template class BufferTest<glw::GLint, 4, false>;

template class BufferTest<glw::GLuint, 1, false>;
template class BufferTest<glw::GLuint, 2, false>;
template class BufferTest<glw::GLuint, 3, false>;
template class BufferTest<glw::GLuint, 4, false>;

template class BufferTest<glw::GLfloat, 1, true>;
template class BufferTest<glw::GLfloat, 2, true>;
template class BufferTest<glw::GLfloat, 3, true>;
template class BufferTest<glw::GLfloat, 4, true>;

/******************************** Storage and SubImage Test Implementation   ********************************/

/** @brief Storage Test constructor.
 *
 *  @tparam T      Type.
 *  @tparam S      Size.
 *  @tparam N      Is normalized.
 *  @tparam D      Texture dimension.
 *  @tparam I      Choose between SubImage and Storage tests.
 *
 *  @param [in] context     OpenGL context.
 *  @param [in] name        Name of the test.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
StorageAndSubImageTest<T, S, N, D, I>::StorageAndSubImageTest(deqp::Context& context, const char* name)
	: deqp::TestCase(context, name, "Texture Storage and SubImage Test")
	, m_fbo(0)
	, m_rbo(0)
	, m_po(0)
	, m_to(0)
	, m_vao(0)
{
	/* Intentionally left blank. */
}

/** @brief Count of reference data to be teted.
 *
 *  @return Count.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
glw::GLuint StorageAndSubImageTest<T, S, N, D, I>::TestReferenceDataCount()
{
	return 2 /* 1D */ * ((D > 1) ? 3 : 1) /* 2D */ * ((D > 2) ? 4 : 1) /* 3D */ * S /* components */;
}

/** @brief Size of reference data to be teted.
 *
 *  @tparam T      Type.
 *  @tparam S      Size (# of components).
 *  @tparam D      Texture dimenisons.
 *
 *  @return Size.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
glw::GLuint StorageAndSubImageTest<T, S, N, D, I>::TestReferenceDataSize()
{
	return static_cast<glw::GLint>(TestReferenceDataCount() * sizeof(T));
}

/** @brief Height, width or depth of reference data to be teted.
 *
 *  @return Height, width or depth.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
glw::GLuint StorageAndSubImageTest<T, S, N, D, I>::TestReferenceDataHeight()
{
	switch (D)
	{
	case 2:
	case 3:
		return 3;
	default:
		return 1;
	}
}

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
glw::GLuint StorageAndSubImageTest<T, S, N, D, I>::TestReferenceDataDepth()
{
	switch (D)
	{
	case 3:
		return 4;
	default:
		return 1;
	}
}

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
glw::GLuint StorageAndSubImageTest<T, S, N, D, I>::TestReferenceDataWidth()
{
	return 2;
}

/** @brief Fragment shader declaration selector.
 *
 *  @return Frgment shader source code part.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::FragmentShaderDeclaration()
{
	if (typeid(T) == typeid(glw::GLbyte))
	{
		switch (D)
		{
		case 1:
			return s_fragment_shader_1D_idecl_lowp;
		case 2:
			return s_fragment_shader_2D_idecl_lowp;
		case 3:
			return s_fragment_shader_3D_idecl_lowp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLubyte))
	{
		if (N)
		{
			switch (D)
			{
			case 1:
				return s_fragment_shader_1D_fdecl_lowp;
			case 2:
				return s_fragment_shader_2D_fdecl_lowp;
			case 3:
				return s_fragment_shader_3D_fdecl_lowp;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
		else
		{
			switch (D)
			{
			case 1:
				return s_fragment_shader_1D_udecl_lowp;
			case 2:
				return s_fragment_shader_2D_udecl_lowp;
			case 3:
				return s_fragment_shader_3D_udecl_lowp;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
	}

	if (typeid(T) == typeid(glw::GLshort))
	{
		switch (D)
		{
		case 1:
			return s_fragment_shader_1D_idecl_mediump;
		case 2:
			return s_fragment_shader_2D_idecl_mediump;
		case 3:
			return s_fragment_shader_3D_idecl_mediump;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLushort))
	{
		if (N)
		{
			switch (D)
			{
			case 1:
				return s_fragment_shader_1D_fdecl_mediump;
			case 2:
				return s_fragment_shader_2D_fdecl_mediump;
			case 3:
				return s_fragment_shader_3D_fdecl_mediump;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
		else
		{
			switch (D)
			{
			case 1:
				return s_fragment_shader_1D_udecl_mediump;
			case 2:
				return s_fragment_shader_2D_udecl_mediump;
			case 3:
				return s_fragment_shader_3D_udecl_mediump;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
	}

	if (typeid(T) == typeid(glw::GLint))
	{
		switch (D)
		{
		case 1:
			return s_fragment_shader_1D_idecl_highp;
		case 2:
			return s_fragment_shader_2D_idecl_highp;
		case 3:
			return s_fragment_shader_3D_idecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLuint))
	{
		switch (D)
		{
		case 1:
			return s_fragment_shader_1D_udecl_highp;
		case 2:
			return s_fragment_shader_2D_udecl_highp;
		case 3:
			return s_fragment_shader_3D_udecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	switch (D)
	{
	case 1:
		return s_fragment_shader_1D_fdecl_highp;
	case 2:
		return s_fragment_shader_2D_fdecl_highp;
	case 3:
		return s_fragment_shader_3D_fdecl_highp;
	default:
		DE_FATAL("invalid texture dimension");
		return DE_NULL;
	}
}

/** @brief Fragment shader tail selector.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @return Frgment shader source code part.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::FragmentShaderTail()
{
	switch (D)
	{
	case 1:
		return s_fragment_shader_1D_tail;
	case 2:
		return s_fragment_shader_2D_tail;
	case 3:
		return s_fragment_shader_3D_tail;
	default:
		DE_FATAL("invalid texture dimension");
		return DE_NULL;
	}
}

/** @brief Texture target selector.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @return Texture target.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
glw::GLenum StorageAndSubImageTest<T, S, N, D, I>::TextureTarget()
{
	switch (D)
	{
	case 1:
		return GL_TEXTURE_1D;
	case 2:
		return GL_TEXTURE_2D;
	case 3:
		return GL_TEXTURE_3D;
	default:
		DE_FATAL("invalid texture dimension");
		return DE_NULL;
	}
}

/** @brief TextureStorage* wrapper.
 *
 *  @return true if succeed (in legacy always or throw), false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
bool StorageAndSubImageTest<T, S, N, D, I>::TextureStorage(glw::GLenum target, glw::GLuint texture, glw::GLsizei levels,
														   glw::GLenum internalformat, glw::GLsizei width,
														   glw::GLsizei height, glw::GLsizei depth)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (I)
	{
		switch (D)
		{
		case 1:
			gl.texStorage1D(target, levels, internalformat, width);
			break;
		case 2:
			gl.texStorage2D(target, levels, internalformat, width, height);
			break;
		case 3:
			gl.texStorage3D(target, levels, internalformat, width, height, depth);
			break;
		default:
			DE_FATAL("invalid texture dimension");
		}

		/* TextureSubImage* (not TextureStorage*) is tested */
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage*() has failed");
		return true;
	}
	else
	{
		switch (D)
		{
		case 1:
			gl.textureStorage1D(texture, levels, internalformat, width);
			break;
		case 2:
			gl.textureStorage2D(texture, levels, internalformat, width, height);
			break;
		case 3:
			gl.textureStorage3D(texture, levels, internalformat, width, height, depth);
			break;
		default:
			DE_FATAL("invalid texture dimension");
		}

		glw::GLenum error;
		if (GL_NO_ERROR != (error = gl.getError()))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "glTextureStorage" << D << "D unexpectedly generated error " << glu::getErrorStr(error)
				<< " during test with levels " << levels << ", internal format " << internalformat
				<< " width=" << width << " height=" << height << " depth=" << depth
				<< "." << tcu::TestLog::EndMessage;

			CleanTexture();
			CleanErrors();

			return false;
		}

		return true;
	}
}

/** @brief TextureSubImage* wrapper.
 *
 *  @return true if suuceed (in legacy always or throw), false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
bool StorageAndSubImageTest<T, S, N, D, I>::TextureSubImage(glw::GLenum target, glw::GLuint texture, glw::GLint level,
															glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth,
															glw::GLenum format, glw::GLenum type, const glw::GLvoid* data)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (I)
	{
		switch (D)
		{
		case 1:
			gl.textureSubImage1D(texture, level, 0, width, format, type, data);
			break;
		case 2:
			gl.textureSubImage2D(texture, level, 0, 0, width, height, format, type, data);
			break;
		case 3:
			gl.textureSubImage3D(texture, level, 0, 0, 0, width, height, depth, format, type, data);
			break;
		default:
			DE_FATAL("invalid texture dimension");
		}

		glw::GLenum error;
		if (GL_NO_ERROR != (error = gl.getError()))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "glTextureSubImage" << D << "D unexpectedly generated error " << glu::getErrorStr(error)
				<< " during test with level " << level << ", width=" << width << ", height=" << height << ", depth=" << depth
				<< " format " << glu::getTextureFormatStr(format) << " and type " << glu::getTypeStr(type) << "."
				<< tcu::TestLog::EndMessage;

			CleanTexture();
			CleanErrors();

			return false;
		}

		return true;
	}
	else
	{
		switch (D)
		{
		case 1:
			gl.texSubImage1D(target, level, 0, width, format, type, data);
			break;
		case 2:
			gl.texSubImage2D(target, level, 0, 0, width, height, format, type, data);
			break;
		case 3:
			gl.texSubImage3D(target, level, 0, 0, 0, width, height, depth, format, type, data);
			break;
		default:
			DE_FATAL("invalid texture dimension");
		}

		/* TextureStorage* (not TextureSubImage) is tested */
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexSubImage*() has failed");
		return true;
	}
}

/** @brief Create texture.
 *
 *  @tparam T      Type.
 *  @tparam S      Size (# of components).
 *  @tparam N      Is normalized.
 *  @tparam D      Dimmensions.
 *  @tparam I      Test SubImage or Storage.
 *
 *  @return True if succeded, false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
bool StorageAndSubImageTest<T, S, N, D, I>::CreateTexture()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Objects creation. */
	gl.genTextures(1, &m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

	gl.bindTexture(TextureTarget(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	/* Storage creation. */
	if (TextureStorage(TextureTarget(), m_to, 1, InternalFormat<T, S, N>(), TestReferenceDataWidth(),
					   TestReferenceDataHeight(), TestReferenceDataDepth()))
	{
		/* Data setup. */
		if (TextureSubImage(TextureTarget(), m_to, 0, TestReferenceDataWidth(), TestReferenceDataHeight(), TestReferenceDataDepth(),
							Format<S, N>(), Type<T>(), ReferenceData<T, N>()))
		{
			glTexParameteri(TextureTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
			glTexParameteri(TextureTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
			return true;
		}
	}

	CleanTexture();

	return false;
}

/** @brief Compre results with the reference.
 *
 *  @return True if equal, false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
bool StorageAndSubImageTest<T, S, N, D, I>::Check()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Fetching data. */
	std::vector<T> result(TestReferenceDataCount());

	glw::GLuint fbo_size_x = 0;

	switch (D)
	{
	case 1:
		fbo_size_x = 2;
		break;
	case 2:
		fbo_size_x = 2 * 3;
		break;
	case 3:
		fbo_size_x = 2 * 3 * 4;
		break;
	default:
		throw 0;
	}

	gl.readnPixels(0, 0, fbo_size_x, 1, Format<S, N>(), Type<T>(), TestReferenceDataSize(),
				   (glw::GLvoid*)(&result[0]));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels has failed");

	/* Comparison. */
	for (glw::GLuint i = 0; i < TestReferenceDataCount(); ++i)
	{
		if (!Compare<T>(result[i], ReferenceData<T, N>()[i]))
		{
			return false;
		}
	}

	return true;
}

/** @brief Test case function.
 *
 *  @return True if test succeeded, false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
bool StorageAndSubImageTest<T, S, N, D, I>::Test()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.pixelStorei(GL_UNPACK_ALIGNMENT, sizeof(T));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	gl.pixelStorei(GL_PACK_ALIGNMENT, sizeof(T));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	/* Setup. */
	PrepareFramebuffer(InternalFormat<T, S, N>());

	if (!CreateTexture())
	{
		return false;
	}

	/* Action. */
	Draw();

	/* Compare results with reference. */
	bool result = Check();

	/* Cleanup. */
	CleanTexture();
	CleanFramebuffer();
	CleanErrors();

	/* Pass result. */
	return result;
}

/** @brief Function prepares framebuffer with internal format color attachment.
 *         Viewport is set up. Content of the framebuffer is cleared.
 *
 *  @note The function may throw if unexpected error has occured.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::PrepareFramebuffer(const glw::GLenum internal_format)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.genRenderbuffers(1, &m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	glw::GLuint fbo_size_x = 0;

	switch (D)
	{
	case 1:
		fbo_size_x = 2;
		break;
	case 2:
		fbo_size_x = 2 * 3;
		break;
	case 3:
		fbo_size_x = 2 * 3 * 4;
		break;
	default:
		throw 0;
	}

	gl.renderbufferStorage(GL_RENDERBUFFER, internal_format, fbo_size_x, 1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");

	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNSUPPORTED)
			throw tcu::NotSupportedError("unsupported framebuffer configuration");
		else
			throw 0;
	}

	gl.viewport(0, 0, fbo_size_x, 1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	/* Clear framebuffer's content. */
	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
}

/** @brief Prepare program
 *
 *  @param [in] variable_declaration      Variables declaration part of fragment shader source code.
 *  @param [in] tail                      Tail part of fragment shader source code.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::PrepareProgram(const glw::GLchar* variable_declaration, const glw::GLchar* tail)
{
	/* Shortcut for GL functionality */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	struct Shader
	{
		glw::GLchar const* source[3];
		glw::GLsizei const count;
		glw::GLenum const  type;
		glw::GLuint		   id;
	} shader[] = { { { s_vertex_shader, NULL, NULL }, 1, GL_VERTEX_SHADER, 0 },
				   { { s_fragment_shader_head, variable_declaration, tail }, 3, GL_FRAGMENT_SHADER, 0 } };

	glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);

	try
	{
		/* Create program. */
		m_po = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");

		/* Shader compilation. */

		for (glw::GLuint i = 0; i < shader_count; ++i)
		{
			{
				shader[i].id = gl.createShader(shader[i].type);

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

				gl.attachShader(m_po, shader[i].id);

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

				gl.shaderSource(shader[i].id, shader[i].count, shader[i].source, NULL);

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

				gl.compileShader(shader[i].id);

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

				glw::GLint status = GL_FALSE;

				gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

				if (GL_FALSE == status)
				{
					glw::GLint log_size = 0;
					gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
					GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

					glw::GLchar* log_text = new glw::GLchar[log_size];

					gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);

					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "Shader compilation has failed.\n"
						<< "Shader type: " << glu::getShaderTypeStr(shader[i].type) << "\n"
						<< "Shader compilation error log:\n"
						<< log_text << "\n"
						<< "Shader source code:\n"
						<< shader[i].source[0] << (shader[i].source[1] ? shader[i].source[1] : "")
						<< (shader[i].source[2] ? shader[i].source[2] : "") << "\n"
						<< tcu::TestLog::EndMessage;

					delete[] log_text;

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

					throw 0;
				}
			}
		}

		/* Link. */
		gl.linkProgram(m_po);

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

		glw::GLint status = GL_FALSE;

		gl.getProgramiv(m_po, GL_LINK_STATUS, &status);

		if (GL_TRUE == status)
		{
			for (glw::GLuint i = 0; i < shader_count; ++i)
			{
				if (shader[i].id)
				{
					gl.detachShader(m_po, shader[i].id);

					GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
				}
			}
		}
		else
		{
			glw::GLint log_size = 0;

			gl.getProgramiv(m_po, GL_INFO_LOG_LENGTH, &log_size);

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

			glw::GLchar* log_text = new glw::GLchar[log_size];

			gl.getProgramInfoLog(m_po, log_size, NULL, &log_text[0]);

			m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n"
												<< log_text << "\n"
												<< tcu::TestLog::EndMessage;

			delete[] log_text;

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

			throw 0;
		}
	}
	catch (...)
	{
		if (m_po)
		{
			gl.deleteProgram(m_po);

			m_po = 0;
		}
	}

	for (glw::GLuint i = 0; i < shader_count; ++i)
	{
		if (0 != shader[i].id)
		{
			gl.deleteShader(shader[i].id);

			shader[i].id = 0;
		}
	}

	if (0 == m_po)
	{
		throw 0;
	}
}

/** @brief Prepare VAO.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::PrepareVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genVertexArrays(1, &m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays has failed");

	gl.bindVertexArray(m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray has failed");
}

/** @brief Test's draw call.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::Draw()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.useProgram(m_po);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram has failed");

	gl.activeTexture(GL_TEXTURE0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.bindTextureUnit(0, m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays has failed");
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::CleanTexture()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Texture. */
	if (m_to)
	{
		gl.deleteTextures(1, &m_to);

		m_to = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::CleanFramebuffer()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Framebuffer. */
	if (m_fbo)
	{
		gl.deleteFramebuffers(1, &m_fbo);

		m_fbo = 0;
	}

	/* Renderbuffer. */
	if (m_rbo)
	{
		gl.deleteRenderbuffers(1, &m_rbo);

		m_rbo = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::CleanProgram()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Program. */
	if (m_po)
	{
		gl.useProgram(0);

		gl.deleteProgram(m_po);

		m_po = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::CleanErrors()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Query all errors until GL_NO_ERROR occure. */
	while (GL_NO_ERROR != gl.getError())
		;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
void StorageAndSubImageTest<T, S, N, D, I>::CleanVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (m_vao)
	{
		gl.bindVertexArray(0);

		gl.deleteVertexArrays(1, &m_vao);

		m_vao = 0;
	}
}

/** @brief Iterate Storage Test cases.
 *
 *  @return Iteration result.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
tcu::TestNode::IterateResult StorageAndSubImageTest<T, S, N, D, I>::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		PrepareVertexArray();
		PrepareProgram(FragmentShaderDeclaration(), FragmentShaderTail());
		is_ok = Test();
	}
	catch (tcu::NotSupportedError& e)
	{
		throw e;
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	CleanTexture();
	CleanFramebuffer();
	CleanProgram();
	CleanErrors();
	CleanVertexArray();

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/* Vertex shader source code. */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_vertex_shader =
	"#version 450\n"
	"\n"
	"void main()\n"
	"{\n"
	"    switch(gl_VertexID)\n"
	"    {\n"
	"        case 0:\n"
	"            gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
	"            break;\n"
	"        case 1:\n"
	"            gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
	"            break;\n"
	"        case 2:\n"
	"            gl_Position = vec4(-1.0,-1.0, 0.0, 1.0);\n"
	"            break;\n"
	"        case 3:\n"
	"            gl_Position = vec4( 1.0,-1.0, 0.0, 1.0);\n"
	"            break;\n"
	"    }\n"
	"}\n";

/* Fragment shader source program. */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_head =
	"#version 450\n"
	"\n"
	"layout(pixel_center_integer) in vec4 gl_FragCoord;\n"
	"\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_fdecl_lowp =
	"uniform  sampler1D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_idecl_lowp =
	"uniform isampler1D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_udecl_lowp =
	"uniform usampler1D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_fdecl_mediump =
	"uniform  sampler1D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_idecl_mediump =
	"uniform isampler1D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_udecl_mediump =
	"uniform usampler1D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_fdecl_highp =
	"uniform  sampler1D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_idecl_highp =
	"uniform isampler1D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_udecl_highp =
	"uniform usampler1D texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_fdecl_lowp =
	"uniform  sampler2D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_idecl_lowp =
	"uniform isampler2D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_udecl_lowp =
	"uniform usampler2D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_fdecl_mediump =
	"uniform  sampler2D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_idecl_mediump =
	"uniform isampler2D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_udecl_mediump =
	"uniform usampler2D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_fdecl_highp =
	"uniform  sampler2D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_idecl_highp =
	"uniform isampler2D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_udecl_highp =
	"uniform usampler2D texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_fdecl_lowp =
	"uniform  sampler3D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_idecl_lowp =
	"uniform isampler3D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_udecl_lowp =
	"uniform usampler3D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_fdecl_mediump =
	"uniform  sampler3D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_idecl_mediump =
	"uniform isampler3D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_udecl_mediump =
	"uniform usampler3D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_fdecl_highp =
	"uniform  sampler3D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_idecl_highp =
	"uniform isampler3D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_udecl_highp =
	"uniform usampler3D texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_1D_tail =
	"\n"
	"void main()\n"
	"{\n"
	"    texture_output = texelFetch(texture_input, int(gl_FragCoord.x), 0);\n"
	"}\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_2D_tail =
	"\n"
	"void main()\n"
	"{\n"
	"    texture_output = texelFetch(texture_input, ivec2(int(gl_FragCoord.x) % 2, int(floor(gl_FragCoord.x / 2))), "
	"0);\n"
	"}\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
const glw::GLchar* StorageAndSubImageTest<T, S, N, D, I>::s_fragment_shader_3D_tail =
	"\n"
	"void main()\n"
	"{\n"
	"    texture_output = texelFetch(texture_input, ivec3(int(gl_FragCoord.x) % 2, int(floor(gl_FragCoord.x / 2)) % 3, "
	"int(floor(gl_FragCoord.x / 2 / 3))), 0);\n"
	"}\n";

template class StorageAndSubImageTest<glw::GLbyte, 1, false, 1, false>;
template class StorageAndSubImageTest<glw::GLbyte, 2, false, 1, false>;
template class StorageAndSubImageTest<glw::GLbyte, 4, false, 1, false>;
template class StorageAndSubImageTest<glw::GLbyte, 1, false, 2, false>;
template class StorageAndSubImageTest<glw::GLbyte, 2, false, 2, false>;
template class StorageAndSubImageTest<glw::GLbyte, 4, false, 2, false>;
template class StorageAndSubImageTest<glw::GLbyte, 1, false, 3, false>;
template class StorageAndSubImageTest<glw::GLbyte, 2, false, 3, false>;
template class StorageAndSubImageTest<glw::GLbyte, 4, false, 3, false>;

template class StorageAndSubImageTest<glw::GLubyte, 1, false, 1, false>;
template class StorageAndSubImageTest<glw::GLubyte, 2, false, 1, false>;
template class StorageAndSubImageTest<glw::GLubyte, 4, false, 1, false>;
template class StorageAndSubImageTest<glw::GLubyte, 1, false, 2, false>;
template class StorageAndSubImageTest<glw::GLubyte, 2, false, 2, false>;
template class StorageAndSubImageTest<glw::GLubyte, 4, false, 2, false>;
template class StorageAndSubImageTest<glw::GLubyte, 1, false, 3, false>;
template class StorageAndSubImageTest<glw::GLubyte, 2, false, 3, false>;
template class StorageAndSubImageTest<glw::GLubyte, 4, false, 3, false>;

template class StorageAndSubImageTest<glw::GLubyte, 1, true, 1, false>;
template class StorageAndSubImageTest<glw::GLubyte, 2, true, 1, false>;
template class StorageAndSubImageTest<glw::GLubyte, 4, true, 1, false>;
template class StorageAndSubImageTest<glw::GLubyte, 1, true, 2, false>;
template class StorageAndSubImageTest<glw::GLubyte, 2, true, 2, false>;
template class StorageAndSubImageTest<glw::GLubyte, 4, true, 2, false>;
template class StorageAndSubImageTest<glw::GLubyte, 1, true, 3, false>;
template class StorageAndSubImageTest<glw::GLubyte, 2, true, 3, false>;
template class StorageAndSubImageTest<glw::GLubyte, 4, true, 3, false>;

template class StorageAndSubImageTest<glw::GLshort, 1, false, 1, false>;
template class StorageAndSubImageTest<glw::GLshort, 2, false, 1, false>;
template class StorageAndSubImageTest<glw::GLshort, 4, false, 1, false>;
template class StorageAndSubImageTest<glw::GLshort, 1, false, 2, false>;
template class StorageAndSubImageTest<glw::GLshort, 2, false, 2, false>;
template class StorageAndSubImageTest<glw::GLshort, 4, false, 2, false>;
template class StorageAndSubImageTest<glw::GLshort, 1, false, 3, false>;
template class StorageAndSubImageTest<glw::GLshort, 2, false, 3, false>;
template class StorageAndSubImageTest<glw::GLshort, 4, false, 3, false>;

template class StorageAndSubImageTest<glw::GLushort, 1, false, 1, false>;
template class StorageAndSubImageTest<glw::GLushort, 2, false, 1, false>;
template class StorageAndSubImageTest<glw::GLushort, 4, false, 1, false>;
template class StorageAndSubImageTest<glw::GLushort, 1, false, 2, false>;
template class StorageAndSubImageTest<glw::GLushort, 2, false, 2, false>;
template class StorageAndSubImageTest<glw::GLushort, 4, false, 2, false>;
template class StorageAndSubImageTest<glw::GLushort, 1, false, 3, false>;
template class StorageAndSubImageTest<glw::GLushort, 2, false, 3, false>;
template class StorageAndSubImageTest<glw::GLushort, 4, false, 3, false>;

template class StorageAndSubImageTest<glw::GLushort, 1, true, 1, false>;
template class StorageAndSubImageTest<glw::GLushort, 2, true, 1, false>;
template class StorageAndSubImageTest<glw::GLushort, 4, true, 1, false>;
template class StorageAndSubImageTest<glw::GLushort, 1, true, 2, false>;
template class StorageAndSubImageTest<glw::GLushort, 2, true, 2, false>;
template class StorageAndSubImageTest<glw::GLushort, 4, true, 2, false>;
template class StorageAndSubImageTest<glw::GLushort, 1, true, 3, false>;
template class StorageAndSubImageTest<glw::GLushort, 2, true, 3, false>;
template class StorageAndSubImageTest<glw::GLushort, 4, true, 3, false>;

template class StorageAndSubImageTest<glw::GLint, 1, false, 1, false>;
template class StorageAndSubImageTest<glw::GLint, 2, false, 1, false>;
template class StorageAndSubImageTest<glw::GLint, 3, false, 1, false>;
template class StorageAndSubImageTest<glw::GLint, 4, false, 1, false>;
template class StorageAndSubImageTest<glw::GLint, 1, false, 2, false>;
template class StorageAndSubImageTest<glw::GLint, 2, false, 2, false>;
template class StorageAndSubImageTest<glw::GLint, 3, false, 2, false>;
template class StorageAndSubImageTest<glw::GLint, 4, false, 2, false>;
template class StorageAndSubImageTest<glw::GLint, 1, false, 3, false>;
template class StorageAndSubImageTest<glw::GLint, 2, false, 3, false>;
template class StorageAndSubImageTest<glw::GLint, 3, false, 3, false>;
template class StorageAndSubImageTest<glw::GLint, 4, false, 3, false>;

template class StorageAndSubImageTest<glw::GLuint, 1, false, 1, false>;
template class StorageAndSubImageTest<glw::GLuint, 2, false, 1, false>;
template class StorageAndSubImageTest<glw::GLuint, 3, false, 1, false>;
template class StorageAndSubImageTest<glw::GLuint, 4, false, 1, false>;
template class StorageAndSubImageTest<glw::GLuint, 1, false, 2, false>;
template class StorageAndSubImageTest<glw::GLuint, 2, false, 2, false>;
template class StorageAndSubImageTest<glw::GLuint, 3, false, 2, false>;
template class StorageAndSubImageTest<glw::GLuint, 4, false, 2, false>;
template class StorageAndSubImageTest<glw::GLuint, 1, false, 3, false>;
template class StorageAndSubImageTest<glw::GLuint, 2, false, 3, false>;
template class StorageAndSubImageTest<glw::GLuint, 3, false, 3, false>;
template class StorageAndSubImageTest<glw::GLuint, 4, false, 3, false>;

template class StorageAndSubImageTest<glw::GLfloat, 1, true, 1, false>;
template class StorageAndSubImageTest<glw::GLfloat, 2, true, 1, false>;
template class StorageAndSubImageTest<glw::GLfloat, 3, true, 1, false>;
template class StorageAndSubImageTest<glw::GLfloat, 4, true, 1, false>;
template class StorageAndSubImageTest<glw::GLfloat, 1, true, 2, false>;
template class StorageAndSubImageTest<glw::GLfloat, 2, true, 2, false>;
template class StorageAndSubImageTest<glw::GLfloat, 3, true, 2, false>;
template class StorageAndSubImageTest<glw::GLfloat, 4, true, 2, false>;
template class StorageAndSubImageTest<glw::GLfloat, 1, true, 3, false>;
template class StorageAndSubImageTest<glw::GLfloat, 2, true, 3, false>;
template class StorageAndSubImageTest<glw::GLfloat, 3, true, 3, false>;
template class StorageAndSubImageTest<glw::GLfloat, 4, true, 3, false>;

template class StorageAndSubImageTest<glw::GLbyte, 1, false, 1, true>;
template class StorageAndSubImageTest<glw::GLbyte, 2, false, 1, true>;
template class StorageAndSubImageTest<glw::GLbyte, 4, false, 1, true>;
template class StorageAndSubImageTest<glw::GLbyte, 1, false, 2, true>;
template class StorageAndSubImageTest<glw::GLbyte, 2, false, 2, true>;
template class StorageAndSubImageTest<glw::GLbyte, 4, false, 2, true>;
template class StorageAndSubImageTest<glw::GLbyte, 1, false, 3, true>;
template class StorageAndSubImageTest<glw::GLbyte, 2, false, 3, true>;
template class StorageAndSubImageTest<glw::GLbyte, 4, false, 3, true>;

template class StorageAndSubImageTest<glw::GLubyte, 1, false, 1, true>;
template class StorageAndSubImageTest<glw::GLubyte, 2, false, 1, true>;
template class StorageAndSubImageTest<glw::GLubyte, 4, false, 1, true>;
template class StorageAndSubImageTest<glw::GLubyte, 1, false, 2, true>;
template class StorageAndSubImageTest<glw::GLubyte, 2, false, 2, true>;
template class StorageAndSubImageTest<glw::GLubyte, 4, false, 2, true>;
template class StorageAndSubImageTest<glw::GLubyte, 1, false, 3, true>;
template class StorageAndSubImageTest<glw::GLubyte, 2, false, 3, true>;
template class StorageAndSubImageTest<glw::GLubyte, 4, false, 3, true>;

template class StorageAndSubImageTest<glw::GLubyte, 1, true, 1, true>;
template class StorageAndSubImageTest<glw::GLubyte, 2, true, 1, true>;
template class StorageAndSubImageTest<glw::GLubyte, 4, true, 1, true>;
template class StorageAndSubImageTest<glw::GLubyte, 1, true, 2, true>;
template class StorageAndSubImageTest<glw::GLubyte, 2, true, 2, true>;
template class StorageAndSubImageTest<glw::GLubyte, 4, true, 2, true>;
template class StorageAndSubImageTest<glw::GLubyte, 1, true, 3, true>;
template class StorageAndSubImageTest<glw::GLubyte, 2, true, 3, true>;
template class StorageAndSubImageTest<glw::GLubyte, 4, true, 3, true>;

template class StorageAndSubImageTest<glw::GLshort, 1, false, 1, true>;
template class StorageAndSubImageTest<glw::GLshort, 2, false, 1, true>;
template class StorageAndSubImageTest<glw::GLshort, 4, false, 1, true>;
template class StorageAndSubImageTest<glw::GLshort, 1, false, 2, true>;
template class StorageAndSubImageTest<glw::GLshort, 2, false, 2, true>;
template class StorageAndSubImageTest<glw::GLshort, 4, false, 2, true>;
template class StorageAndSubImageTest<glw::GLshort, 1, false, 3, true>;
template class StorageAndSubImageTest<glw::GLshort, 2, false, 3, true>;
template class StorageAndSubImageTest<glw::GLshort, 4, false, 3, true>;

template class StorageAndSubImageTest<glw::GLushort, 1, false, 1, true>;
template class StorageAndSubImageTest<glw::GLushort, 2, false, 1, true>;
template class StorageAndSubImageTest<glw::GLushort, 4, false, 1, true>;
template class StorageAndSubImageTest<glw::GLushort, 1, false, 2, true>;
template class StorageAndSubImageTest<glw::GLushort, 2, false, 2, true>;
template class StorageAndSubImageTest<glw::GLushort, 4, false, 2, true>;
template class StorageAndSubImageTest<glw::GLushort, 1, false, 3, true>;
template class StorageAndSubImageTest<glw::GLushort, 2, false, 3, true>;
template class StorageAndSubImageTest<glw::GLushort, 4, false, 3, true>;

template class StorageAndSubImageTest<glw::GLushort, 1, true, 1, true>;
template class StorageAndSubImageTest<glw::GLushort, 2, true, 1, true>;
template class StorageAndSubImageTest<glw::GLushort, 4, true, 1, true>;
template class StorageAndSubImageTest<glw::GLushort, 1, true, 2, true>;
template class StorageAndSubImageTest<glw::GLushort, 2, true, 2, true>;
template class StorageAndSubImageTest<glw::GLushort, 4, true, 2, true>;
template class StorageAndSubImageTest<glw::GLushort, 1, true, 3, true>;
template class StorageAndSubImageTest<glw::GLushort, 2, true, 3, true>;
template class StorageAndSubImageTest<glw::GLushort, 4, true, 3, true>;

template class StorageAndSubImageTest<glw::GLint, 1, false, 1, true>;
template class StorageAndSubImageTest<glw::GLint, 2, false, 1, true>;
template class StorageAndSubImageTest<glw::GLint, 3, false, 1, true>;
template class StorageAndSubImageTest<glw::GLint, 4, false, 1, true>;
template class StorageAndSubImageTest<glw::GLint, 1, false, 2, true>;
template class StorageAndSubImageTest<glw::GLint, 2, false, 2, true>;
template class StorageAndSubImageTest<glw::GLint, 3, false, 2, true>;
template class StorageAndSubImageTest<glw::GLint, 4, false, 2, true>;
template class StorageAndSubImageTest<glw::GLint, 1, false, 3, true>;
template class StorageAndSubImageTest<glw::GLint, 2, false, 3, true>;
template class StorageAndSubImageTest<glw::GLint, 3, false, 3, true>;
template class StorageAndSubImageTest<glw::GLint, 4, false, 3, true>;

template class StorageAndSubImageTest<glw::GLuint, 1, false, 1, true>;
template class StorageAndSubImageTest<glw::GLuint, 2, false, 1, true>;
template class StorageAndSubImageTest<glw::GLuint, 3, false, 1, true>;
template class StorageAndSubImageTest<glw::GLuint, 4, false, 1, true>;
template class StorageAndSubImageTest<glw::GLuint, 1, false, 2, true>;
template class StorageAndSubImageTest<glw::GLuint, 2, false, 2, true>;
template class StorageAndSubImageTest<glw::GLuint, 3, false, 2, true>;
template class StorageAndSubImageTest<glw::GLuint, 4, false, 2, true>;
template class StorageAndSubImageTest<glw::GLuint, 1, false, 3, true>;
template class StorageAndSubImageTest<glw::GLuint, 2, false, 3, true>;
template class StorageAndSubImageTest<glw::GLuint, 3, false, 3, true>;
template class StorageAndSubImageTest<glw::GLuint, 4, false, 3, true>;

template class StorageAndSubImageTest<glw::GLfloat, 1, true, 1, true>;
template class StorageAndSubImageTest<glw::GLfloat, 2, true, 1, true>;
template class StorageAndSubImageTest<glw::GLfloat, 3, true, 1, true>;
template class StorageAndSubImageTest<glw::GLfloat, 4, true, 1, true>;
template class StorageAndSubImageTest<glw::GLfloat, 1, true, 2, true>;
template class StorageAndSubImageTest<glw::GLfloat, 2, true, 2, true>;
template class StorageAndSubImageTest<glw::GLfloat, 3, true, 2, true>;
template class StorageAndSubImageTest<glw::GLfloat, 4, true, 2, true>;
template class StorageAndSubImageTest<glw::GLfloat, 1, true, 3, true>;
template class StorageAndSubImageTest<glw::GLfloat, 2, true, 3, true>;
template class StorageAndSubImageTest<glw::GLfloat, 3, true, 3, true>;
template class StorageAndSubImageTest<glw::GLfloat, 4, true, 3, true>;

/******************************** Storage Multisample Test Implementation   ********************************/

/** @brief Storage Multisample Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
StorageMultisampleTest<T, S, N, D>::StorageMultisampleTest(deqp::Context& context, const char* name)
	: deqp::TestCase(context, name, "Texture Storage Multisample Test")
	, m_fbo_ms(0)
	, m_fbo_aux(0)
	, m_to_ms(0)
	, m_po_ms(0)
	, m_po_aux(0)
	, m_to(0)
	, m_to_aux(0)
	, m_vao(0)
{
	/* Intentionally left blank. */
}

/** @brief Count of reference data to be teted.
 *
 *  @return Count.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLuint StorageMultisampleTest<T, S, N, D>::TestReferenceDataCount()
{
	return 2 /* 1D */ * ((D > 1) ? 3 : 1) /* 2D */ * ((D > 2) ? 4 : 1) /* 3D */ * S /* components */;
}

/** @brief Size of reference data to be teted.
 *
 *  @return Size.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLuint StorageMultisampleTest<T, S, N, D>::TestReferenceDataSize()
{
	return TestReferenceDataCount() * sizeof(T);
}

/** @brief Height, width or depth of reference data to be teted.
 *
 *  @return Height, width or depth.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLuint StorageMultisampleTest<T, S, N, D>::TestReferenceDataHeight()
{
	switch(D)
	{
	case 3:
	case 2:
		return 3;
	default:
		return 1;
	}
}

template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLuint StorageMultisampleTest<T, S, N, D>::TestReferenceDataDepth()
{
	switch(D)
	{
	case 3:
		return 4;
	default:
		return 1;
	}
}

template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLuint	StorageMultisampleTest<T, S, N, D>::TestReferenceDataWidth()
{
	return 2;
}

/** @brief Fragment shader declaration selector.
 *
 *  @return Frgment shader source code part.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::FragmentShaderDeclarationMultisample()
{
	if (typeid(T) == typeid(glw::GLbyte))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_ms_2D_idecl_lowp;
		case 3:
			return s_fragment_shader_ms_3D_idecl_lowp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLubyte))
	{
		if (N)
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_ms_2D_fdecl_lowp;
			case 3:
				return s_fragment_shader_ms_3D_fdecl_lowp;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
		else
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_ms_2D_udecl_lowp;
			case 3:
				return s_fragment_shader_ms_3D_udecl_lowp;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
	}

	if (typeid(T) == typeid(glw::GLshort))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_ms_2D_idecl_mediump;
		case 3:
			return s_fragment_shader_ms_3D_idecl_mediump;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLushort))
	{
		if (N)
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_ms_2D_fdecl_mediump;
			case 3:
				return s_fragment_shader_ms_3D_fdecl_mediump;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
		else
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_ms_2D_udecl_mediump;
			case 3:
				return s_fragment_shader_ms_3D_udecl_mediump;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
	}

	if (typeid(T) == typeid(glw::GLint))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_ms_2D_idecl_highp;
		case 3:
			return s_fragment_shader_ms_3D_idecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLuint))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_ms_2D_udecl_highp;
		case 3:
			return s_fragment_shader_ms_3D_udecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLfloat))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_ms_2D_fdecl_highp;
		case 3:
			return s_fragment_shader_ms_3D_fdecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	DE_FATAL("invalid type");
	return DE_NULL;
}

/** @brief Fragment shader declaration selector.
 *
 *  @return Frgment shader source code part.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::FragmentShaderDeclarationAuxiliary()
{
	if (typeid(T) == typeid(glw::GLbyte))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_aux_2D_idecl_lowp;
		case 3:
			return s_fragment_shader_aux_3D_idecl_lowp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLubyte))
	{
		if (N)
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_aux_2D_fdecl_lowp;
			case 3:
				return s_fragment_shader_aux_3D_fdecl_lowp;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
		else
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_aux_2D_udecl_lowp;
			case 3:
				return s_fragment_shader_aux_3D_udecl_lowp;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
	}

	if (typeid(T) == typeid(glw::GLshort))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_aux_2D_idecl_mediump;
		case 3:
			return s_fragment_shader_aux_3D_idecl_mediump;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLushort))
	{
		if (N)
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_aux_2D_fdecl_mediump;
			case 3:
				return s_fragment_shader_aux_3D_fdecl_mediump;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
		else
		{
			switch (D)
			{
			case 2:
				return s_fragment_shader_aux_2D_udecl_mediump;
			case 3:
				return s_fragment_shader_aux_3D_udecl_mediump;
			default:
				DE_FATAL("invalid texture dimension");
				return DE_NULL;
			}
		}
	}

	if (typeid(T) == typeid(glw::GLint))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_aux_2D_idecl_highp;
		case 3:
			return s_fragment_shader_aux_3D_idecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLuint))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_aux_2D_udecl_highp;
		case 3:
			return s_fragment_shader_aux_3D_udecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	if (typeid(T) == typeid(glw::GLfloat))
	{
		switch (D)
		{
		case 2:
			return s_fragment_shader_aux_2D_fdecl_highp;
		case 3:
			return s_fragment_shader_aux_3D_fdecl_highp;
		default:
			DE_FATAL("invalid texture dimension");
			return DE_NULL;
		}
	}

	DE_FATAL("invalid type");
	return DE_NULL;
}

/** @brief Fragment shader tail selector.
 *
 *  @return Frgment shader source code part.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::FragmentShaderTail()
{
	switch (D)
	{
	case 2:
		return s_fragment_shader_tail_2D;
	case 3:
		return s_fragment_shader_tail_3D;
	default:
		DE_FATAL("invalid texture dimension");
		return DE_NULL;
	}
}

/** @brief Multisample texture target selector.
 *
 *  @return Texture target.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLenum StorageMultisampleTest<T, S, N, D>::MultisampleTextureTarget()
{
	switch (D)
	{
	case 2:
		return GL_TEXTURE_2D_MULTISAMPLE;
	case 3:
		return GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
	default:
		DE_FATAL("invalid texture dimension");
		return DE_NULL;
	}
}

/** @brief Input texture target selector.
 *
 *  @return Texture target.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLenum StorageMultisampleTest<T, S, N, D>::InputTextureTarget()
{
	switch (D)
	{
	case 2:
		return GL_TEXTURE_2D;
	case 3:
		return GL_TEXTURE_2D_ARRAY;
	default:
		DE_FATAL("invalid texture dimension");
		return DE_NULL;
	}
}

/** @brief Prepare texture data for input texture.
 *
 *  @note parameters as passed to texImage*
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::InputTextureImage(const glw::GLenum internal_format, const glw::GLuint width,
														   const glw::GLuint height, const glw::GLuint depth,
														   const glw::GLenum format, const glw::GLenum type,
														   const glw::GLvoid* data)
{
	(void)depth;
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Data setup. */
	switch (D)
	{
	case 2:
		gl.texImage2D(InputTextureTarget(), 0, internal_format, width, height, 0, format, type, data);
		break;
	case 3:
		gl.texImage3D(InputTextureTarget(), 0, internal_format, width, height, depth, 0, format, type, data);
		break;
	default:
		DE_FATAL("invalid texture dimension");
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage has failed");
}

/** @brief Create texture.
 *
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CreateInputTexture()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Objects creation. */
	gl.genTextures(1, &m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

	gl.bindTexture(InputTextureTarget(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	/* Data setup. */
	InputTextureImage(InternalFormat<T, S, N>(), TestReferenceDataWidth(), TestReferenceDataHeight(),
					  TestReferenceDataDepth(), Format<S, N>(), Type<T>(), ReferenceData<T, N>());

	/* Parameter setup. */
	gl.texParameteri(InputTextureTarget(), GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameteri(InputTextureTarget(), GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");
}

/** @brief Compre results with the reference.
 *
 *  @return True if equal, false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
bool StorageMultisampleTest<T, S, N, D>::Check()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Fetching data fro auxiliary texture. */
	std::vector<T> result(TestReferenceDataCount());

	gl.bindTexture(InputTextureTarget() /* Auxiliary target is the same as input. */, m_to_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.getTexImage(InputTextureTarget() /* Auxiliary target is the same as input. */, 0, Format<S, N>(), Type<T>(),
				   (glw::GLvoid*)(&result[0]));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexImage has failed");

	/* Comparison. */
	for (glw::GLuint i = 0; i < TestReferenceDataCount(); ++i)
	{
		if (!Compare<T>(result[i], ReferenceData<T, N>()[i]))
		{
			return false;
		}
	}

	return true;
}

/** @brief Test case function.
 *
 *  @return True if test succeeded, false otherwise.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
bool StorageMultisampleTest<T, S, N, D>::Test()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Setup. */
	gl.pixelStorei(GL_UNPACK_ALIGNMENT, sizeof(T));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	gl.pixelStorei(GL_PACK_ALIGNMENT, sizeof(T));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	CreateInputTexture();

	if (!PrepareFramebufferMultisample(InternalFormat<T, S, N>()))
	{
		CleanInputTexture();

		return false;
	}

	PrepareFramebufferAuxiliary(InternalFormat<T, S, N>());

	/* Action. */
	Draw();

	/* Compare results with reference. */
	bool result = Check();

	/* Cleanup. */
	CleanAuxiliaryTexture();
	CleanFramebuffers();
	CleanInputTexture();
	CleanErrors();

	/* Pass result. */
	return result;
}

/** @brief Function prepares framebuffer with internal format color attachment.
 *         Viewport is set up. Content of the framebuffer is cleared.
 *
 *  @note The function may throw if unexpected error has occured.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
bool StorageMultisampleTest<T, S, N, D>::PrepareFramebufferMultisample(const glw::GLenum internal_format)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.genTextures(1, &m_to_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.bindTexture(MultisampleTextureTarget(), m_to_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	switch (D)
	{
	case 2:
		gl.textureStorage2DMultisample(m_to_ms, 1, internal_format, TestReferenceDataWidth(),
									   TestReferenceDataHeight(), false);
		break;
	case 3:
		gl.textureStorage3DMultisample(m_to_ms, 1, internal_format, TestReferenceDataWidth(),
									   TestReferenceDataHeight(), TestReferenceDataDepth(), false);
		break;
	default:
		DE_FATAL("invalid texture dimension");
		return false;
	}

	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		CleanFramebuffers();

		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "glTextureStorageMultisample unexpectedly generated error "
			<< glu::getErrorStr(error) << " during the test of internal format "
			<< glu::getTextureFormatStr(internal_format) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	switch (D)
	{
	case 2:
		gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_to_ms, 0);
		break;
	case 3:
		for (glw::GLuint i = 0; i < TestReferenceDataDepth(); ++i)
		{
			gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, m_to_ms, 0, i);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTextureLayer call failed.");
		}
		break;
	default:
		DE_FATAL("invalid texture dimension");
		return false;
	}
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNSUPPORTED)
			throw tcu::NotSupportedError("unsupported framebuffer configuration");
		else
			throw 0;
	}

	gl.viewport(0, 0, TestReferenceDataWidth(), TestReferenceDataHeight());
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	/* Clear framebuffer's content. */
	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");

	return true;
}

/** @brief Function prepares framebuffer with internal format color attachment.
 *         Viewport is set up. Content of the framebuffer is cleared.
 *
 *  @note The function may throw if unexpected error has occured.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::PrepareFramebufferAuxiliary(const glw::GLenum internal_format)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.genTextures(1, &m_to_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.bindTexture(InputTextureTarget(), m_to_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	switch (D)
	{
	case 2:
		gl.textureStorage2D(m_to_aux, 1, internal_format, TestReferenceDataWidth(), TestReferenceDataHeight());
		break;
	case 3:
		gl.textureStorage3D(m_to_aux, 1, internal_format, TestReferenceDataWidth(), TestReferenceDataHeight(),
							TestReferenceDataDepth());
		break;
	default:
		DE_FATAL("invalid texture dimension");
	}
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2D call failed.");

	/* Parameter setup. */
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");

	switch (D)
	{
	case 2:
		gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_aux, 0);
		break;
	case 3:
		for (glw::GLuint i = 0; i < TestReferenceDataDepth(); ++i)
		{
			gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, m_to_aux, 0, i);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTextureLayer call failed.");
		}
		break;
	default:
		DE_FATAL("invalid texture dimension");
	}
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_UNSUPPORTED)
			throw tcu::NotSupportedError("unsupported framebuffer configuration");
		else
			throw 0;
	}

	gl.viewport(0, 0, TestReferenceDataWidth(), TestReferenceDataHeight());
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	/* Clear framebuffer's content. */
	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
}

/** @brief Prepare program
 *
 *  @param [in] variable_declaration      Variables declaration part of fragment shader source code.
 *  @param [in] tail                      Tail part of fragment shader source code.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
glw::GLuint StorageMultisampleTest<T, S, N, D>::PrepareProgram(const glw::GLchar* variable_declaration, const glw::GLchar* tail)
{
	/* Shortcut for GL functionality */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	struct Shader
	{
		glw::GLchar const* source[3];
		glw::GLsizei const count;
		glw::GLenum const  type;
		glw::GLuint		   id;
	} shader[] = { { { s_vertex_shader, NULL, NULL }, 1, GL_VERTEX_SHADER, 0 },
				   { { s_fragment_shader_head, variable_declaration, tail }, 3, GL_FRAGMENT_SHADER, 0 } };

	glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);

	glw::GLuint po = 0;

	try
	{
		/* Create program. */
		po = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");

		/* Shader compilation. */

		for (glw::GLuint i = 0; i < shader_count; ++i)
		{
			{
				shader[i].id = gl.createShader(shader[i].type);

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

				gl.attachShader(po, shader[i].id);

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

				gl.shaderSource(shader[i].id, shader[i].count, shader[i].source, NULL);

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

				gl.compileShader(shader[i].id);

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

				glw::GLint status = GL_FALSE;

				gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

				if (GL_FALSE == status)
				{
					glw::GLint log_size = 0;
					gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
					GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

					glw::GLchar* log_text = new glw::GLchar[log_size];

					gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);

					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "Shader compilation has failed.\n"
						<< "Shader type: " << glu::getShaderTypeStr(shader[i].type) << "\n"
						<< "Shader compilation error log:\n"
						<< log_text << "\n"
						<< "Shader source code:\n"
						<< shader[i].source[0] << (shader[i].source[1] ? shader[i].source[1] : "")
						<< (shader[i].source[2] ? shader[i].source[2] : "") << "\n"
						<< tcu::TestLog::EndMessage;

					delete[] log_text;

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

					throw 0;
				}
			}
		}

		/* Link. */
		gl.linkProgram(po);

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

		glw::GLint status = GL_FALSE;

		gl.getProgramiv(po, GL_LINK_STATUS, &status);

		if (GL_TRUE == status)
		{
			for (glw::GLuint i = 0; i < shader_count; ++i)
			{
				if (shader[i].id)
				{
					gl.detachShader(po, shader[i].id);

					GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
				}
			}
		}
		else
		{
			glw::GLint log_size = 0;

			gl.getProgramiv(po, GL_INFO_LOG_LENGTH, &log_size);

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

			glw::GLchar* log_text = new glw::GLchar[log_size];

			gl.getProgramInfoLog(po, log_size, NULL, &log_text[0]);

			m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n"
												<< log_text << "\n"
												<< tcu::TestLog::EndMessage;

			delete[] log_text;

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

			throw 0;
		}
	}
	catch (...)
	{
		if (po)
		{
			gl.deleteProgram(po);

			po = 0;
		}
	}

	for (glw::GLuint i = 0; i < shader_count; ++i)
	{
		if (0 != shader[i].id)
		{
			gl.deleteShader(shader[i].id);

			shader[i].id = 0;
		}
	}

	if (0 == po)
	{
		throw 0;
	}

	return po;
}

/** @brief Prepare VAO.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::PrepareVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genVertexArrays(1, &m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays has failed");

	gl.bindVertexArray(m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray has failed");
}

/** @brief Draw call
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::Draw()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare multisample texture using draw call. */

	/* Prepare framebuffer with multisample texture. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer has failed");

	/* Use first program program. */
	gl.useProgram(m_po_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram has failed");

	/* Prepare texture to be drawn with. */
	gl.activeTexture(GL_TEXTURE0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.bindTexture(InputTextureTarget(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.uniform1i(gl.getUniformLocation(m_po_ms, "texture_input"), 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i or glGetUniformLocation has failed");

	for (glw::GLuint i = 0; i < TestReferenceDataDepth(); ++i)
	{
		/* Select layer. */
		gl.drawBuffer(GL_COLOR_ATTACHMENT0 + i);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawBuffer has failed");

		if (D == 3)
		{
			gl.uniform1i(gl.getUniformLocation(m_po_aux, "texture_layer"), i);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i or glGetUniformLocation has failed");
		}

		/* Draw. */
		gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays has failed");
	}

	/* Copy multisample texture to auxiliary texture using draw call. */

	/* Prepare framebuffer with auxiliary texture. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer has failed");

	/* Use first program program. */
	gl.useProgram(m_po_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram has failed");

	/* Prepare texture to be drawn with. */
	gl.activeTexture(GL_TEXTURE0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.bindTexture(MultisampleTextureTarget(), m_to_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture has failed");

	gl.bindTextureUnit(0, m_to);

	gl.uniform1i(gl.getUniformLocation(m_po_aux, "texture_input"), 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i or glGetUniformLocation has failed");

	/* For each texture layer. */
	for (glw::GLuint i = 0; i < TestReferenceDataDepth(); ++i)
	{
		/* Select layer. */
		gl.drawBuffer(GL_COLOR_ATTACHMENT0 + i);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawBuffer has failed");

		if (D == 3)
		{
			gl.uniform1i(gl.getUniformLocation(m_po_aux, "texture_layer"), i);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i or glGetUniformLocation has failed");
		}

		/* Draw. */
		gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays has failed");
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CleanInputTexture()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Texture. */
	if (m_to)
	{
		gl.deleteTextures(1, &m_to);

		m_to = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CleanAuxiliaryTexture()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (m_to_aux)
	{
		gl.deleteTextures(1, &m_to_aux);

		m_to_aux = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CleanFramebuffers()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Mulitsample framebuffer. */
	if (m_fbo_ms)
	{
		gl.deleteFramebuffers(1, &m_fbo_ms);

		m_fbo_ms = 0;
	}

	/* Mulitsample texture. */
	if (m_to_ms)
	{
		gl.deleteTextures(1, &m_to_ms);

		m_to_ms = 0;
	}

	/* Auxiliary framebuffer. */
	if (m_fbo_aux)
	{
		gl.deleteFramebuffers(1, &m_fbo_aux);

		m_fbo_aux = 0;
	}

	/* Auxiliary texture. */
	if (m_to_aux)
	{
		gl.deleteTextures(1, &m_to_aux);

		m_to_aux = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CleanPrograms()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Binding point. */
	gl.useProgram(0);

	/* Multisample texture preparation program. */
	if (m_po_ms)
	{
		gl.deleteProgram(m_po_ms);

		m_po_ms = 0;
	}

	/* Auxiliary texture preparation program. */
	if (m_po_aux)
	{
		gl.deleteProgram(m_po_aux);

		m_po_aux = 0;
	}
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CleanErrors()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Query all errors until GL_NO_ERROR occure. */
	while (GL_NO_ERROR != gl.getError())
		;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
void StorageMultisampleTest<T, S, N, D>::CleanVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (m_vao)
	{
		gl.bindVertexArray(0);

		gl.deleteVertexArrays(1, &m_vao);

		m_vao = 0;
	}
}

/** @brief Iterate Storage Multisample Test cases.
 *
 *  @return Iteration result.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
tcu::TestNode::IterateResult StorageMultisampleTest<T, S, N, D>::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		PrepareVertexArray();

		//  gl.enable(GL_MULTISAMPLE);

		m_po_ms  = PrepareProgram(FragmentShaderDeclarationMultisample(), FragmentShaderTail());
		m_po_aux = PrepareProgram(FragmentShaderDeclarationAuxiliary(), FragmentShaderTail());

		is_ok = Test();
	}
	catch (tcu::NotSupportedError& e)
	{
		throw e;
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	CleanInputTexture();
	CleanAuxiliaryTexture();
	CleanFramebuffers();
	CleanPrograms();
	CleanErrors();
	CleanVertexArray();
	gl.disable(GL_MULTISAMPLE);

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/* Vertex shader source code. */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_vertex_shader =
	"#version 450\n"
	"\n"
	"void main()\n"
	"{\n"
	"    switch(gl_VertexID)\n"
	"    {\n"
	"        case 0:\n"
	"            gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
	"            break;\n"
	"        case 1:\n"
	"            gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
	"            break;\n"
	"        case 2:\n"
	"            gl_Position = vec4(-1.0,-1.0, 0.0, 1.0);\n"
	"            break;\n"
	"        case 3:\n"
	"            gl_Position = vec4( 1.0,-1.0, 0.0, 1.0);\n"
	"            break;\n"
	"    }\n"
	"}\n";

/* Fragment shader source program. */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_head =
	"#version 450\n"
	"\n"
	"layout(pixel_center_integer) in vec4 gl_FragCoord;\n"
	"\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_fdecl_lowp =
	"uniform  sampler2D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_idecl_lowp =
	"uniform isampler2D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_udecl_lowp =
	"uniform usampler2D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_fdecl_mediump =
	"uniform  sampler2D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_idecl_mediump =
	"uniform isampler2D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_udecl_mediump =
	"uniform usampler2D texture_input;\nout     uvec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_fdecl_highp =
	"uniform  sampler2D texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_idecl_highp =
	"uniform isampler2D texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_2D_udecl_highp =
	"uniform usampler2D texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_fdecl_lowp =
	"uniform  sampler2DArray texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_idecl_lowp =
	"uniform isampler2DArray texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_udecl_lowp =
	"uniform usampler2DArray texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_fdecl_mediump =
	"uniform  sampler2DArray texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_idecl_mediump =
	"uniform isampler2DArray texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_udecl_mediump =
	"uniform usampler2DArray texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_fdecl_highp =
	"uniform  sampler2DArray texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_idecl_highp =
	"uniform isampler2DArray texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_ms_3D_udecl_highp =
	"uniform usampler2DArray texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_fdecl_lowp =
	"uniform  sampler2DMS texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_idecl_lowp =
	"uniform isampler2DMS texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_udecl_lowp =
	"uniform usampler2DMS texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_fdecl_mediump =
	"uniform  sampler2DMS texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_idecl_mediump =
	"uniform isampler2DMS texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_udecl_mediump =
	"uniform usampler2DMS texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_fdecl_highp =
	"uniform  sampler2DMS texture_input;\nout     vec4          texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_idecl_highp =
	"uniform isampler2DMS texture_input;\nout     ivec4         texture_output;\n";
template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_2D_udecl_highp =
	"uniform usampler2DMS texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_fdecl_lowp =
	"uniform  sampler2DMSArray texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_idecl_lowp =
	"uniform isampler2DMSArray texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_udecl_lowp =
	"uniform usampler2DMSArray texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_fdecl_mediump =
	"uniform  sampler2DMSArray texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_idecl_mediump =
	"uniform isampler2DMSArray texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_udecl_mediump =
	"uniform usampler2DMSArray texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_fdecl_highp =
	"uniform  sampler2DMSArray texture_input;\nout     vec4          texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_idecl_highp =
	"uniform isampler2DMSArray texture_input;\nout     ivec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_aux_3D_udecl_highp =
	"uniform usampler2DMSArray texture_input;\nout     uvec4         texture_output;\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_tail_2D =
	"\n"
	"void main()\n"
	"{\n"
	"    texture_output = texelFetch(texture_input, ivec2(gl_FragCoord.xy), 0);\n"
	"}\n";

template <typename T, glw::GLint S, bool N, glw::GLuint D>
const glw::GLchar* StorageMultisampleTest<T, S, N, D>::s_fragment_shader_tail_3D =
	"\n"
	"uniform int texture_layer;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    texture_output = texelFetch(texture_input, ivec3(gl_FragCoord.xy, texture_layer), 0);\n"
	"}\n";

template class StorageMultisampleTest<glw::GLbyte, 1, false, 2>;
template class StorageMultisampleTest<glw::GLbyte, 2, false, 2>;
template class StorageMultisampleTest<glw::GLbyte, 4, false, 2>;
template class StorageMultisampleTest<glw::GLbyte, 1, false, 3>;
template class StorageMultisampleTest<glw::GLbyte, 2, false, 3>;
template class StorageMultisampleTest<glw::GLbyte, 4, false, 3>;

template class StorageMultisampleTest<glw::GLubyte, 1, false, 2>;
template class StorageMultisampleTest<glw::GLubyte, 2, false, 2>;
template class StorageMultisampleTest<glw::GLubyte, 4, false, 2>;
template class StorageMultisampleTest<glw::GLubyte, 1, false, 3>;
template class StorageMultisampleTest<glw::GLubyte, 2, false, 3>;
template class StorageMultisampleTest<glw::GLubyte, 4, false, 3>;

template class StorageMultisampleTest<glw::GLubyte, 1, true, 2>;
template class StorageMultisampleTest<glw::GLubyte, 2, true, 2>;
template class StorageMultisampleTest<glw::GLubyte, 4, true, 2>;
template class StorageMultisampleTest<glw::GLubyte, 1, true, 3>;
template class StorageMultisampleTest<glw::GLubyte, 2, true, 3>;
template class StorageMultisampleTest<glw::GLubyte, 4, true, 3>;

template class StorageMultisampleTest<glw::GLshort, 1, false, 2>;
template class StorageMultisampleTest<glw::GLshort, 2, false, 2>;
template class StorageMultisampleTest<glw::GLshort, 4, false, 2>;
template class StorageMultisampleTest<glw::GLshort, 1, false, 3>;
template class StorageMultisampleTest<glw::GLshort, 2, false, 3>;
template class StorageMultisampleTest<glw::GLshort, 4, false, 3>;

template class StorageMultisampleTest<glw::GLushort, 1, false, 2>;
template class StorageMultisampleTest<glw::GLushort, 2, false, 2>;
template class StorageMultisampleTest<glw::GLushort, 4, false, 2>;
template class StorageMultisampleTest<glw::GLushort, 1, false, 3>;
template class StorageMultisampleTest<glw::GLushort, 2, false, 3>;
template class StorageMultisampleTest<glw::GLushort, 4, false, 3>;

template class StorageMultisampleTest<glw::GLushort, 1, true, 2>;
template class StorageMultisampleTest<glw::GLushort, 2, true, 2>;
template class StorageMultisampleTest<glw::GLushort, 4, true, 2>;
template class StorageMultisampleTest<glw::GLushort, 1, true, 3>;
template class StorageMultisampleTest<glw::GLushort, 2, true, 3>;
template class StorageMultisampleTest<glw::GLushort, 4, true, 3>;

template class StorageMultisampleTest<glw::GLint, 1, false, 2>;
template class StorageMultisampleTest<glw::GLint, 2, false, 2>;
template class StorageMultisampleTest<glw::GLint, 3, false, 2>;
template class StorageMultisampleTest<glw::GLint, 4, false, 2>;
template class StorageMultisampleTest<glw::GLint, 1, false, 3>;
template class StorageMultisampleTest<glw::GLint, 2, false, 3>;
template class StorageMultisampleTest<glw::GLint, 3, false, 3>;
template class StorageMultisampleTest<glw::GLint, 4, false, 3>;

template class StorageMultisampleTest<glw::GLuint, 1, false, 2>;
template class StorageMultisampleTest<glw::GLuint, 2, false, 2>;
template class StorageMultisampleTest<glw::GLuint, 3, false, 2>;
template class StorageMultisampleTest<glw::GLuint, 4, false, 2>;
template class StorageMultisampleTest<glw::GLuint, 1, false, 3>;
template class StorageMultisampleTest<glw::GLuint, 2, false, 3>;
template class StorageMultisampleTest<glw::GLuint, 3, false, 3>;
template class StorageMultisampleTest<glw::GLuint, 4, false, 3>;

template class StorageMultisampleTest<glw::GLfloat, 1, true, 2>;
template class StorageMultisampleTest<glw::GLfloat, 2, true, 2>;
template class StorageMultisampleTest<glw::GLfloat, 3, true, 2>;
template class StorageMultisampleTest<glw::GLfloat, 4, true, 2>;
template class StorageMultisampleTest<glw::GLfloat, 1, true, 3>;
template class StorageMultisampleTest<glw::GLfloat, 2, true, 3>;
template class StorageMultisampleTest<glw::GLfloat, 3, true, 3>;
template class StorageMultisampleTest<glw::GLfloat, 4, true, 3>;

/******************************** Compressed SubImage Test Implementation   ********************************/

/* Compressed m_reference data for unsupported compression formats */

static const unsigned char data_0x8dbb_2D_8[] = {
	34, 237, 94, 207,
	252, 29, 75, 25
};

static const unsigned char data_0x8dbb_3D_32[] = {
	34, 237, 94, 207,
	252, 29, 75, 25,
	34, 237, 44, 173,
	101, 230, 139, 254,
	34, 237, 176, 88,
	174, 127, 248, 206,
	34, 237, 127, 209,
	211, 203, 100, 150
};

static const unsigned char data_0x8dbc_2D_8[] = {
	127, 0, 233, 64,
	0, 42, 71, 231
};

static const unsigned char data_0x8dbc_3D_32[] = {
	127, 0, 233, 64,
	0, 42, 71, 231,
	127, 0, 20, 227,
	162, 33, 246, 1,
	127, 0, 143, 57,
	86, 0, 136, 53,
	127, 0, 192, 62,
	48, 69, 29, 138
};

static const unsigned char data_0x8dbd_2D_16[] = {
	34, 237, 94, 207,
	252, 29, 75, 25,
	28, 242, 94, 111,
	44, 101, 35, 145
};

static const unsigned char data_0x8dbd_3D_64[] = {
	34, 237, 94, 207,
	252, 29, 75, 25,
	28, 242, 94, 111,
	44, 101, 35, 145,
	34, 237, 44, 173,
	101, 230, 139, 254,
	28, 242, 170, 45,
	98, 236, 202, 228,
	34, 237, 176, 88,
	174, 127, 248, 206,
	28, 242, 164, 148,
	178, 25, 252, 206,
	34, 237, 127, 209,
	211, 203, 100, 150,
	28, 242, 79, 216,
	149, 3, 101, 87
};

static const unsigned char data_0x8dbe_2D_16[] = {
	127, 0, 233, 64,
	0, 42, 71, 231,
	127, 0, 233, 144,
	23, 163, 100, 115
};

static const unsigned char data_0x8dbe_3D_64[] = {
	127, 0, 233, 64,
	0, 42, 71, 231,
	127, 0, 233, 144,
	23, 163, 100, 115,
	127, 0, 20, 227,
	162, 33, 246, 1,
	127, 0, 94, 98,
	190, 84, 55, 1,
	127, 0, 143, 57,
	86, 0, 136, 53,
	127, 0, 163, 45,
	113, 232, 131, 53,
	127, 0, 192, 62,
	48, 69, 29, 138,
	127, 0, 128, 182,
	138, 61, 157, 204
};

static const unsigned char data_0x8e8c_2D_16[] = {
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 89, 143,
	140, 166, 183, 113
};

static const unsigned char data_0x8e8c_3D_64[] = {
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 89, 143,
	140, 166, 183, 113,
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 55, 48,
	102, 244, 186, 241,
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 231, 54,
	211, 92, 240, 14,
	144, 121, 253, 241,
	193, 15, 152, 153,
	153, 153, 25, 41,
	102, 244, 248, 135
};

static const unsigned char data_0x8e8d_2D_16[] = {
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 89, 143,
	140, 166, 183, 113
};

static const unsigned char data_0x8e8d_3D_64[] = {
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 89, 143,
	140, 166, 183, 113,
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 55, 48,
	102, 244, 186, 241,
	144, 43, 143, 15,
	254, 15, 152, 153,
	153, 153, 231, 54,
	211, 92, 240, 14,
	144, 121, 253, 241,
	193, 15, 152, 153,
	153, 153, 25, 41,
	102, 244, 248, 135
};

static const unsigned char data_0x8e8e_2D_16[] = {
	67, 155, 82, 120,
	142, 7, 31, 124,
	224, 255, 165, 221,
	239, 223, 122, 223
};

static const unsigned char data_0x8e8e_3D_64[] = {
	67, 155, 82, 120,
	142, 7, 31, 124,
	224, 255, 165, 221,
	239, 223, 122, 223,
	35, 30, 124, 240,
	209, 166, 20, 158,
	11, 250, 24, 21,
	0, 2, 34, 2,
	35, 30, 124, 240,
	209, 166, 20, 158,
	5, 88, 2, 1,
	34, 165, 0, 241,
	35, 30, 124, 240,
	209, 166, 20, 158,
	33, 34, 32, 0,
	81, 129, 175, 80
};

static const unsigned char data_0x8e8f_2D_16[] = {
	131, 54, 165, 148,
	26, 47, 62, 248,
	176, 254, 149, 203,
	222, 206, 187, 173
};

static const unsigned char data_0x8e8f_3D_64[] = {
	131, 54, 165, 148,
	26, 47, 62, 248,
	176, 254, 149, 203,
	222, 206, 187, 173,
	99, 188, 248, 224,
	163, 77, 41, 165,
	24, 250, 36, 70,
	18, 20, 53, 3,
	99, 188, 248, 224,
	163, 77, 41, 165,
	42, 68, 19, 18,
	67, 166, 16, 244,
	99, 188, 248, 224,
	163, 77, 41, 165,
	48, 83, 65, 33,
	100, 66, 175, 65
};

static const unsigned char data_GL_COMPRESSED_R11_EAC_2D_8[] = {
	146, 253, 99, 81,
	202, 222, 63, 243
};

static const unsigned char data_GL_COMPRESSED_R11_EAC_3D_32[] = {
	146, 253, 99, 81,
	202, 222, 63, 243,
	146, 253, 169, 188,
	102, 31, 246, 55,
	146, 253, 123, 247,
	62, 71, 139, 131,
	146, 253, 248, 63,
	248, 208, 230, 213
};

static const unsigned char data_GL_COMPRESSED_RG11_EAC_2D_16[] = {
	146, 253, 99, 81,
	202, 222, 63, 243,
	140, 254, 110, 0,
	160, 130, 207, 180
};

static const unsigned char data_GL_COMPRESSED_RG11_EAC_3D_64[] = {
	146, 253, 99, 81,
	202, 222, 63, 243,
	140, 254, 110, 0,
	160, 130, 207, 180,
	146, 253, 169, 188,
	102, 31, 246, 55,
	140, 254, 2, 73,
	46, 104, 102, 39,
	146, 253, 123, 247,
	62, 71, 139, 131,
	140, 254, 155, 121,
	68, 17, 1, 27,
	146, 253, 248, 63,
	248, 208, 230, 213,
	140, 254, 240, 60,
	19, 214, 73, 0
};

static const unsigned char data_GL_COMPRESSED_RGB8_ETC2_2D_8[] = {
	168, 122, 150, 252,
	234, 35, 0, 0
};

static const unsigned char data_GL_COMPRESSED_RGB8_ETC2_3D_32[] = {
	168, 122, 150, 252,
	234, 35, 0, 0,
	168, 122, 150, 253,
	31, 140, 0, 0,
	138, 167, 105, 252,
	196, 87, 0, 0,
	138, 167, 105, 253,
	49, 248, 0, 0
};

static const unsigned char data_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_2D_8[] = {
	83, 83, 75, 252,
	240, 240, 15, 4
};

static const unsigned char data_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_3D_32[] = {
	83, 83, 75, 252,
	240, 240, 15, 4,
	107, 99, 99, 253,
	240, 240, 14, 15,
	135, 135, 135, 252,
	240, 240, 15, 15,
	108, 108, 108, 253,
	240, 248, 11, 11
};

static const unsigned char data_GL_COMPRESSED_RGBA8_ETC2_EAC_2D_16[] = {
	127, 245, 255, 244,
	146, 255, 244, 146,
	168, 122, 150, 252,
	234, 35, 0, 0
};

static const unsigned char data_GL_COMPRESSED_RGBA8_ETC2_EAC_3D_64[] = {
	127, 245, 255, 244,
	146, 255, 244, 146,
	168, 122, 150, 252,
	234, 35, 0, 0,
	127, 245, 255, 244,
	146, 255, 244, 146,
	168, 122, 150, 253,
	31, 140, 0, 0,
	127, 245, 255, 244,
	146, 255, 244, 146,
	138, 167, 105, 252,
	196, 87, 0, 0,
	127, 245, 255, 244,
	146, 255, 244, 146,
	138, 167, 105, 253,
	49, 248, 0, 0
};

static const unsigned char data_GL_COMPRESSED_SIGNED_R11_EAC_2D_8[] = {
	73, 221, 99, 81,
	201, 222, 63, 241
};

static const unsigned char data_GL_COMPRESSED_SIGNED_R11_EAC_3D_32[] = {
	73, 221, 99, 81,
	201, 222, 63, 241,
	73, 221, 165, 156,
	102, 31, 246, 55,
	73, 221, 59, 247,
	62, 39, 139, 131,
	73, 221, 248, 63,
	248, 208, 226, 205
};

static const unsigned char data_GL_COMPRESSED_SIGNED_RG11_EAC_2D_16[] = {
	73, 221, 99, 81,
	201, 222, 63, 241,
	66, 191, 110, 0,
	96, 131, 77, 180
};

static const unsigned char data_GL_COMPRESSED_SIGNED_RG11_EAC_3D_64[] = {
	73, 221, 99, 81,
	201, 222, 63, 241,
	66, 191, 110, 0,
	96, 131, 77, 180,
	73, 221, 165, 156,
	102, 31, 246, 55,
	66, 191, 2, 73,
	54, 100, 102, 38,
	73, 221, 59, 247,
	62, 39, 139, 131,
	66, 191, 155, 105,
	132, 16, 129, 27,
	73, 221, 248, 63,
	248, 208, 226, 205,
	66, 191, 208, 60,
	11, 218, 73, 0
};

static const unsigned char data_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_2D_16[] = {
	127, 245, 255, 244,
	146, 255, 244, 146,
	150, 122, 168, 252,
	234, 35, 0, 0
};

static const unsigned char data_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_3D_64[] = {
	127, 245, 255, 244,
	146, 255, 244, 146,
	150, 122, 168, 252,
	234, 35, 0, 0,
	127, 245, 255, 244,
	146, 255, 244, 146,
	150, 122, 168, 253,
	31, 140, 0, 0,
	127, 245, 255, 244,
	146, 255, 244, 146,
	105, 167, 138, 252,
	196, 87, 0, 0,
	127, 245, 255, 244,
	146, 255, 244, 146,
	105, 167, 138, 253,
	49, 248, 0, 0
};

static const unsigned char data_GL_COMPRESSED_SRGB8_ETC2_2D_8[] = {
	168, 122, 150, 252,
	234, 35, 0, 0
};

static const unsigned char data_GL_COMPRESSED_SRGB8_ETC2_3D_32[] = {
	168, 122, 150, 252,
	234, 35, 0, 0,
	168, 122, 150, 253,
	31, 140, 0, 0,
	138, 167, 105, 252,
	196, 87, 0, 0,
	138, 167, 105, 253,
	49, 248, 0, 0
};

static const unsigned char data_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_2D_8[] = {
	75, 83, 83, 252,
	240, 240, 15, 4
};

static const unsigned char data_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_3D_32[] = {
	75, 83, 83, 252,
	240, 240, 15, 4,
	99, 99, 107, 253,
	240, 240, 14, 15,
	135, 135, 135, 252,
	240, 240, 15, 15,
	108, 108, 108, 253,
	240, 248, 11, 11
};

/** @brief Compressed SubImage Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
CompressedSubImageTest::CompressedSubImageTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_compressed_subimage", "Texture Compressed SubImage Test")
	, m_to(0)
	, m_to_aux(0)
	, m_compressed_texture_data(DE_NULL)
	, m_reference(DE_NULL)
	, m_result(DE_NULL)
	, m_reference_size(0)
	, m_reference_internalformat(0)
{
	/* Intentionally left blank. */
}

/** @brief Create texture.
 *
 *  @param [in] target      Texture target.
 */
void CompressedSubImageTest::CreateTextures(glw::GLenum target)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Auxiliary texture (for content creation). */
	gl.genTextures(1, &m_to_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

	gl.bindTexture(target, m_to_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	/* Test texture (for data upload). */
	gl.genTextures(1, &m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

	gl.bindTexture(target, m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");
}

/** @brief Texture target selector.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @return Texture target.
 */
template <>
glw::GLenum CompressedSubImageTest::TextureTarget<1>()
{
	return GL_TEXTURE_1D;
}

template <>
glw::GLenum CompressedSubImageTest::TextureTarget<2>()
{
	return GL_TEXTURE_2D;
}

template <>
glw::GLenum CompressedSubImageTest::TextureTarget<3>()
{
	return GL_TEXTURE_2D_ARRAY;
}

/** @brief Prepare texture data for the auxiliary texture.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @note parameters as passed to texImage*
 *
 *  @return False if the internal format is unsupported for online compression, True otherwise
 */
template <>
bool CompressedSubImageTest::TextureImage<1>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.texImage1D(TextureTarget<1>(), 0, internalformat, s_texture_width, 0, GL_RGBA, GL_UNSIGNED_BYTE, s_texture_data);

	/* Online compression may be unsupported for some formats */
	GLenum error = gl.getError();
	if (error == GL_INVALID_OPERATION)
		return false;

	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	return true;
}

/** @brief Prepare texture data for the auxiliary texture.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @note parameters as passed to texImage*
 *
 *  @return False if the internal format is unsupported for online compression, True otherwise
 */
template <>
bool CompressedSubImageTest::TextureImage<2>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.texImage2D(TextureTarget<2>(), 0, internalformat, s_texture_width, s_texture_height, 0, GL_RGBA,
				  GL_UNSIGNED_BYTE, s_texture_data);

	/* Online compression may be unsupported for some formats */
	GLenum error = gl.getError();
	if (error == GL_INVALID_OPERATION)
		return false;

	GLU_EXPECT_NO_ERROR(error, "glTexImage2D has failed");

	return true;
}

/** @brief Prepare texture data for the auxiliary texture.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @note parameters as passed to texImage*
 *
 *  @return False if the internal format is unsupported for online compression, True otherwise
 */
template <>
bool CompressedSubImageTest::TextureImage<3>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.texImage3D(TextureTarget<3>(), 0, internalformat, s_texture_width, s_texture_height, s_texture_depth, 0, GL_RGBA,
				  GL_UNSIGNED_BYTE, s_texture_data);

	/* Online compression may be unsupported for some formats */
	GLenum error = gl.getError();
	if (error == GL_INVALID_OPERATION)
		return false;

	GLU_EXPECT_NO_ERROR(error, "glTexImage3D has failed");

	return true;
}

/** @brief Prepare texture data for the auxiliary texture.
 *
 *  @tparam D      Texture dimensions.
 *
 *  @note parameters as passed to compressedTexImage*
 */
template <>
void CompressedSubImageTest::CompressedTexImage<1>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.compressedTexImage1D(TextureTarget<1>(), 0, internalformat, s_texture_width, 0, m_reference_size,
							m_compressed_texture_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage1D has failed");
}

/** @brief Prepare texture data for the auxiliary texture.
 *
 *  @tparam D      Texture dimensions.
 *
 *  @note parameters as passed to compressedTexImage*
 */
template <>
void CompressedSubImageTest::CompressedTexImage<2>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.compressedTexImage2D(TextureTarget<2>(), 0, internalformat, s_texture_width, s_texture_height, 0,
							m_reference_size, m_compressed_texture_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage2D has failed");
}

/** @brief Prepare texture data for the auxiliary texture.
 *
 *  @tparam D      Texture dimensions.
 *
 *  @note parameters as passed to compressedTexImage*
 */
template <>
void CompressedSubImageTest::CompressedTexImage<3>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.compressedTexImage3D(TextureTarget<3>(), 0, internalformat, s_texture_width, s_texture_height, s_texture_depth,
							0, m_reference_size, m_compressed_texture_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage3D has failed");
}

/** @brief Prepare texture data for the compressed texture.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @return True if tested function succeeded, false otherwise.
 */
template <>
bool CompressedSubImageTest::CompressedTextureSubImage<1>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Load texture image with tested function. */
	if (m_reference_size)
	{
		for (glw::GLuint block = 0; block < s_block_count; ++block)
		{
			gl.compressedTextureSubImage1D(m_to, 0, s_texture_width * block, s_texture_width, internalformat,
										   m_reference_size, m_compressed_texture_data);
		}
	}
	else
	{
		/* For 1D version there is no specific compressed texture internal format spcified in OpenGL 4.5 core profile documentation.
		 Only implementation depended specific internalformats may provide this functionality. As a result there may be no reference data to be substituted.
		 Due to this reason there is no use of CompressedTextureSubImage1D and particulary it cannot be tested. */
		return true;
	}

	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "glCompressedTextureSubImage1D unexpectedly generated error "
			<< glu::getErrorStr(error) << " during the test with internal format "
			<< glu::getTextureFormatStr(internalformat) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Prepare texture data for the compressed texture.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @param [in] internalformat      Texture internal format.
 *
 *  @return True if tested function succeeded, false otherwise.
 */
template <>
bool CompressedSubImageTest::CompressedTextureSubImage<2>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	for (glw::GLuint y = 0; y < s_block_2d_size_y; ++y)
	{
		for (glw::GLuint x = 0; x < s_block_2d_size_x; ++x)
		{
			/* Load texture image with tested function. */
			gl.compressedTextureSubImage2D(m_to, 0, s_texture_width * x, s_texture_height * y, s_texture_width,
										   s_texture_height, internalformat, m_reference_size,
										   m_compressed_texture_data);
		}
	}
	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "glCompressedTextureSubImage2D unexpectedly generated error "
			<< glu::getErrorStr(error) << " during the test with internal format "
			<< glu::getTextureFormatStr(internalformat) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Prepare texture data for the compressed texture.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @param [in] internalformat      Texture internal format.
 *
 *  @return True if tested function succeeded, false otherwise.
 */
template <>
bool CompressedSubImageTest::CompressedTextureSubImage<3>(glw::GLint internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	for (glw::GLuint z = 0; z < s_block_3d_size; ++z)
	{
		for (glw::GLuint y = 0; y < s_block_3d_size; ++y)
		{
			for (glw::GLuint x = 0; x < s_block_3d_size; ++x)
			{
				/* Load texture image with tested function. */
				gl.compressedTextureSubImage3D(m_to, 0, s_texture_width * x, s_texture_height * y, s_texture_depth * z,
											   s_texture_width, s_texture_height, s_texture_depth, internalformat,
											   m_reference_size, m_compressed_texture_data);
			}
		}
	}

	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "glCompressedTextureSubImage2D unexpectedly generated error "
			<< glu::getErrorStr(error) << " during the test with internal format "
			<< glu::getTextureFormatStr(internalformat) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}
	return true;
}

struct CompressedData
{
	glw::GLenum iformat;
	const unsigned char *data;
	int data_size;
	int dimensions;
};

static CompressedData compressed_images[] =
{
	/* 2D images */

	{GL_COMPRESSED_RED_RGTC1, data_0x8dbb_2D_8, sizeof data_0x8dbb_2D_8, 2},
	{GL_COMPRESSED_SIGNED_RED_RGTC1, data_0x8dbc_2D_8, sizeof data_0x8dbc_2D_8, 2},
	{GL_COMPRESSED_RG_RGTC2, data_0x8dbd_2D_16, sizeof data_0x8dbd_2D_16, 2},
	{GL_COMPRESSED_SIGNED_RG_RGTC2, data_0x8dbe_2D_16, sizeof data_0x8dbe_2D_16, 2},
	{GL_COMPRESSED_RGBA_BPTC_UNORM, data_0x8e8c_2D_16, sizeof data_0x8e8c_2D_16, 2},
	{GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, data_0x8e8d_2D_16, sizeof data_0x8e8d_2D_16, 2},
	{GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, data_0x8e8e_2D_16, sizeof data_0x8e8e_2D_16, 2},
	{GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, data_0x8e8f_2D_16, sizeof data_0x8e8f_2D_16, 2},
	{GL_COMPRESSED_RGB8_ETC2, data_GL_COMPRESSED_RGB8_ETC2_2D_8,
			sizeof data_GL_COMPRESSED_RGB8_ETC2_2D_8, 2},
	{GL_COMPRESSED_SRGB8_ETC2, data_GL_COMPRESSED_SRGB8_ETC2_2D_8,
			sizeof data_GL_COMPRESSED_SRGB8_ETC2_2D_8, 2},
	{GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
			data_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_2D_8,
			sizeof data_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_2D_8, 2},
	{GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
			data_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_2D_8,
			sizeof data_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_2D_8, 2},
	{GL_COMPRESSED_RGBA8_ETC2_EAC, data_GL_COMPRESSED_RGBA8_ETC2_EAC_2D_16,
			sizeof data_GL_COMPRESSED_RGBA8_ETC2_EAC_2D_16, 2},
	{GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, data_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_2D_16,
			sizeof data_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_2D_16, 2},
	{GL_COMPRESSED_R11_EAC, data_GL_COMPRESSED_R11_EAC_2D_8,
			sizeof data_GL_COMPRESSED_R11_EAC_2D_8, 2},
	{GL_COMPRESSED_SIGNED_R11_EAC, data_GL_COMPRESSED_SIGNED_R11_EAC_2D_8,
			sizeof data_GL_COMPRESSED_SIGNED_R11_EAC_2D_8, 2},
	{GL_COMPRESSED_RG11_EAC, data_GL_COMPRESSED_RG11_EAC_2D_16,
			sizeof data_GL_COMPRESSED_SIGNED_RG11_EAC_2D_16, 2},
	{GL_COMPRESSED_SIGNED_RG11_EAC, data_GL_COMPRESSED_SIGNED_RG11_EAC_2D_16,
			sizeof data_GL_COMPRESSED_SIGNED_RG11_EAC_2D_16, 2},

	/* 3D images */

	{0x8dbb, data_0x8dbb_3D_32, sizeof data_0x8dbb_3D_32, 3},
	{0x8dbc, data_0x8dbc_3D_32, sizeof data_0x8dbc_3D_32, 3},
	{0x8dbd, data_0x8dbd_3D_64, sizeof data_0x8dbd_3D_64, 3},
	{0x8dbe, data_0x8dbe_3D_64, sizeof data_0x8dbe_3D_64, 3},
	{0x8e8c, data_0x8e8c_3D_64, sizeof data_0x8e8c_3D_64, 3},
	{0x8e8d, data_0x8e8d_3D_64, sizeof data_0x8e8d_3D_64, 3},
	{0x8e8e, data_0x8e8e_3D_64, sizeof data_0x8e8e_3D_64, 3},
	{0x8e8f, data_0x8e8f_3D_64, sizeof data_0x8e8f_3D_64, 3},
	{GL_COMPRESSED_RGB8_ETC2, data_GL_COMPRESSED_RGB8_ETC2_3D_32,
			sizeof data_GL_COMPRESSED_RGB8_ETC2_3D_32, 3},
	{GL_COMPRESSED_SRGB8_ETC2, data_GL_COMPRESSED_SRGB8_ETC2_3D_32,
			sizeof data_GL_COMPRESSED_SRGB8_ETC2_3D_32, 3},
	{GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
			data_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_3D_32,
			sizeof data_GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_3D_32, 3},
	{GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
			data_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_3D_32,
			sizeof data_GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_3D_32, 3},
	{GL_COMPRESSED_R11_EAC, data_GL_COMPRESSED_R11_EAC_3D_32,
			sizeof data_GL_COMPRESSED_R11_EAC_3D_32, 3},
	{GL_COMPRESSED_SIGNED_R11_EAC, data_GL_COMPRESSED_SIGNED_R11_EAC_3D_32,
			sizeof data_GL_COMPRESSED_SIGNED_R11_EAC_3D_32, 3},

	{GL_COMPRESSED_RGBA8_ETC2_EAC, data_GL_COMPRESSED_RGBA8_ETC2_EAC_3D_64,
			sizeof data_GL_COMPRESSED_RGBA8_ETC2_EAC_3D_64, 3},
	{GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, data_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_3D_64,
			sizeof data_GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_3D_64, 3},
	{GL_COMPRESSED_RG11_EAC, data_GL_COMPRESSED_RG11_EAC_3D_64,
			sizeof data_GL_COMPRESSED_RG11_EAC_3D_64, 3},
	{GL_COMPRESSED_SIGNED_RG11_EAC, data_GL_COMPRESSED_SIGNED_RG11_EAC_3D_64,
			sizeof data_GL_COMPRESSED_SIGNED_RG11_EAC_3D_64, 3}
};

/** @brief Prepare the reference data.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @return False if the internal format is unsupported for online compression, True otherwise
 */
template <glw::GLuint D>
bool CompressedSubImageTest::PrepareReferenceData(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Using OpenGL to compress raw data. */
	gl.bindTexture(TextureTarget<D>(), m_to_aux);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	glw::GLint is_compressed_texture = 0;
	glw::GLint compressed_texture_size = 0;

	/* Sanity checks. */
	if ((DE_NULL != m_reference) || (DE_NULL != m_compressed_texture_data))
	{
		throw 0;
	}

	/* "if" path is taken when there is no support for online compression for the format
	 * and we upload compressed data directly */
	if (!TextureImage<D>(internalformat))
	{
		for (unsigned int i=0; i<sizeof compressed_images / sizeof *compressed_images; i++)
		{
			if (internalformat == compressed_images[i].iformat
					&& D == compressed_images[i].dimensions)
			{
				is_compressed_texture = 1;
				compressed_texture_size = compressed_images[i].data_size;

				m_reference_size = compressed_texture_size;
				m_reference_internalformat = compressed_images[i].iformat;

				m_reference = new glw::GLubyte[compressed_texture_size];
				m_compressed_texture_data = new glw::GLubyte[compressed_texture_size];

				memcpy(m_reference, compressed_images[i].data, compressed_texture_size);
				memcpy(m_compressed_texture_data, compressed_images[i].data, compressed_texture_size);
			}
		}

		if (!is_compressed_texture)
			return false;

		PrepareCompressedStorage<D>(m_reference_internalformat);
	}
	else
	{
		/* Check that really compressed texture. */
		gl.getTexLevelParameteriv(TextureTarget<D>(), 0, GL_TEXTURE_COMPRESSED, &is_compressed_texture);

		if (is_compressed_texture)
		{
			/* Query texture size. */
			gl.getTexLevelParameteriv(TextureTarget<D>(), 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &compressed_texture_size);

			/* If compressed then download. */
			if (compressed_texture_size)
			{
				/* Prepare storage. */
				m_compressed_texture_data = new glw::GLubyte[compressed_texture_size];

				if (DE_NULL != m_compressed_texture_data)
				{
					m_reference_size = compressed_texture_size;
				}
				else
				{
					throw 0;
				}

				/* Download the source compressed texture image. */
				gl.getCompressedTexImage(TextureTarget<D>(), 0, m_compressed_texture_data);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");

				// Upload the source compressed texture image to the texture object.
				// Some compressed texture format can be emulated by the driver (like the ETC2/EAC formats)
				// The compressed data sent by CompressedTexImage will be stored uncompressed by the driver
				// and will be re-compressed if the application call glGetCompressedTexImage.
				// The compression/decompression is not lossless, so when this happen it's possible for the source
				// and destination (from glGetCompressedTexImage) compressed data to be different.
				// To avoid that we will store both the source (in m_compressed_texture_data) and the destination
				// (in m_reference). The destination will be used later to make sure getCompressedTextureSubImage
				// return the expected value
				CompressedTexImage<D>(internalformat);

				m_reference = new glw::GLubyte[m_reference_size];

				if (DE_NULL == m_reference)
				{
					throw 0;
				}

				/* Download compressed texture image. */
				gl.getCompressedTexImage(TextureTarget<D>(), 0, m_reference);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");
			}
		}

		PrepareStorage<D>(internalformat);
	}

	return true;
}

/** @brief Prepare texture storage.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @param [in] internalformat      Texture internal format.
 */
template <>
void CompressedSubImageTest::PrepareStorage<1>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.bindTexture(TextureTarget<1>(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage1D(TextureTarget<1>(), 0, internalformat, s_texture_width * s_block_count, 0, GL_RGBA, GL_UNSIGNED_BYTE,
				  NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");
}

/** @brief Prepare texture storage.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @param [in] internalformat      Texture internal format.
 */
template <>
void CompressedSubImageTest::PrepareStorage<2>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.bindTexture(TextureTarget<2>(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(TextureTarget<2>(), 0, internalformat, s_texture_width * s_block_2d_size_x,
				  s_texture_height * s_block_2d_size_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");
}

/** @brief Prepare texture storage.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @param [in] internalformat      Texture internal format.
 */
template <>
void CompressedSubImageTest::PrepareStorage<3>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.bindTexture(TextureTarget<3>(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage3D(TextureTarget<3>(), 0, internalformat, s_texture_width * s_block_3d_size,
				  s_texture_height * s_block_3d_size, s_texture_depth * s_block_3d_size, 0, GL_RGBA, GL_UNSIGNED_BYTE,
				  NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");
}

/** @brief Prepare compressed texture storage.
 * @tparam D		Texture dimensions.
 *
 * @tparam [in] internalformat		Texture internal format.
 */
template <>
void CompressedSubImageTest::PrepareCompressedStorage<1>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality */
	const glw::Functions &gl = m_context.getRenderContext().getFunctions();

	gl.bindTexture(TextureTarget<1>(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.compressedTexImage1D(TextureTarget<1>(), 0, internalformat, s_texture_width * s_block_count,
			0, s_texture_width * s_block_count, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage1D has failed");
}

/** @brief Prepare compressed texture storage.
 * @tparam D		Texture dimensions.
 *
 * @tparam [in] internalformat		Texture internal format.
 */
template <>
void CompressedSubImageTest::PrepareCompressedStorage<2>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality */
	const glw::Functions &gl = m_context.getRenderContext().getFunctions();

	gl.bindTexture(TextureTarget<2>(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	GLsizei size_x = s_texture_width * s_block_2d_size_x;
	GLsizei size_y = s_texture_height * s_block_2d_size_y;
	GLsizei size = m_reference_size * s_block_2d_size_x * s_block_2d_size_y;

	gl.compressedTexImage2D(TextureTarget<2>(), 0, internalformat, size_x, size_y,
			0, size, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage2D has failed");
}

/** @brief Prepare compressed texture storage.
 * @tparam D		Texture dimensions.
 *
 * @tparam [in] internalformat		Texture internal format.
 */
template <>
void CompressedSubImageTest::PrepareCompressedStorage<3>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality */
	const glw::Functions &gl = m_context.getRenderContext().getFunctions();

	gl.bindTexture(TextureTarget<3>(), m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	GLsizei size_x = s_texture_width * s_block_3d_size;
	GLsizei size_y = s_texture_height * s_block_3d_size;
	GLsizei size_z = s_texture_depth * s_block_3d_size;
	GLsizei size = m_reference_size * s_block_3d_size * s_block_3d_size * s_block_3d_size;

	gl.compressedTexImage3D(TextureTarget<3>(), 0, internalformat, size_x, size_y, size_z, 0,
			size, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage3D has failed");
}

/** @brief Compare results with the reference.
 *
 *  @tparam T      Type.
 *  @tparam S      Size (# of components).
 *  @tparam N      Is normalized.
 *
 *  @param [in] internalformat      Texture internal format.
 *
 *  @return True if equal, false otherwise.
 */
template <glw::GLuint D>
bool CompressedSubImageTest::CheckData(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check texture content with reference. */
	m_result = new glw::GLubyte[m_reference_size * s_block_count];

	if (DE_NULL == m_result)
	{
		throw 0;
	}

	gl.getCompressedTexImage(TextureTarget<D>(), 0, m_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");
	for (glw::GLuint block = 0; block < s_block_count; ++block)
	{
		for (glw::GLuint i = 0; i < m_reference_size; ++i)
		{
			if (m_reference[i] != m_result[block * m_reference_size + i])
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "glCompressedTextureSubImage*D created texture with data "
					<< DataToString(m_reference_size, m_reference) << " however texture contains data "
					<< DataToString(m_reference_size, &(m_result[block * m_reference_size])) << ". Texture target was "
					<< glu::getTextureTargetStr(TextureTarget<D>()) << " and internal format was "
					<< glu::getTextureFormatStr(internalformat) << ". Test fails." << tcu::TestLog::EndMessage;

				return false;
			}
		}
	}

	return true;
}

/** @brief Compare results with the reference.
 *
 *  @tparam T      Type.
 *  @tparam S      Size (# of components).
 *  @tparam N      Is normalized.
 *
 *  @param [in] internalformat      Texture internal format.
 *
 *  @return True if equal, false otherwise.
 */
template <>
bool CompressedSubImageTest::CheckData<3>(glw::GLenum internalformat)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check texture content with reference. */
	m_result = new glw::GLubyte[m_reference_size * s_block_count];

	if (DE_NULL == m_result)
	{
		throw 0;
	}

	gl.getCompressedTexImage(TextureTarget<3>(), 0, m_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");

	glw::GLuint reference_layer_size = m_reference_size / s_texture_depth;

	for (glw::GLuint i = 0; i < m_reference_size * s_block_count; ++i)
	{
		// we will read the result one bytes at the time and compare with the reference
		// for each bytes of the result image we need to figure out which byte in the reference image it corresponds to
		glw::GLuint refIdx		= i % reference_layer_size;
		glw::GLuint refLayerIdx = (i / (reference_layer_size * s_block_3d_size * s_block_3d_size)) % s_texture_depth;
		if (m_reference[refLayerIdx * reference_layer_size + refIdx] != m_result[i])
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "glCompressedTextureSubImage3D created texture with data "
				<< DataToString(reference_layer_size, &(m_reference[refLayerIdx * reference_layer_size]))
				<< " however texture contains data "
				<< DataToString(reference_layer_size, &(m_result[i % reference_layer_size])) << ". Texture target was "
				<< glu::getTextureTargetStr(TextureTarget<3>()) << " and internal format was "
				<< glu::getTextureFormatStr(internalformat) << ". Test fails." << tcu::TestLog::EndMessage;

			return false;
		}
	}

	return true;
}
/** @brief Test case function.
 *
 *  @tparam D       Number of texture dimensions.
 *
 *  @param [in] internal format     Texture internal format.
 *
 *  @param [in] can be unsupported     If the format may not support online compression
 *
 *  @return True if test succeeded, false otherwise.
 */
template <glw::GLuint D>
bool CompressedSubImageTest::Test(glw::GLenum internalformat, bool can_be_unsupported)
{
	/* Create texture image. */
	CreateTextures(TextureTarget<D>());

	if (!PrepareReferenceData<D>(internalformat))
	{
		CleanAll();
		return can_be_unsupported;
	}

	/* Setup data with CompressedTextureSubImage<D>D function and check for errors. */
	if (!CompressedTextureSubImage<D>(internalformat))
	{
		CleanAll();

		return false;
	}

	/* If compressed reference data was generated than compare values. */
	if (m_reference)
	{
		if (!CheckData<D>(internalformat))
		{
			CleanAll();

			return false;
		}
	}

	CleanAll();

	return true;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void CompressedSubImageTest::CleanAll()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Textures. */
	if (m_to)
	{
		gl.deleteTextures(1, &m_to);

		m_to = 0;
	}

	if (m_to_aux)
	{
		gl.deleteTextures(1, &m_to_aux);

		m_to_aux = 0;
	}

	/* Reference data storage. */
	if (DE_NULL != m_reference)
	{
		delete[] m_reference;

		m_reference = DE_NULL;
	}

	if (DE_NULL != m_compressed_texture_data)
	{
		delete[] m_compressed_texture_data;

		m_compressed_texture_data = DE_NULL;
	}

	if (DE_NULL != m_result)
	{
		delete[] m_result;

		m_result = DE_NULL;
	}

	m_reference_size = 0;

	/* Errors. */
	while (GL_NO_ERROR != gl.getError())
		;
}

/** @brief Convert raw data into string for logging purposes.
 *
 *  @param [in] count      Count of the data.
 *  @param [in] data       Raw data.
 *
 *  @return String representation of data.
 */
std::string CompressedSubImageTest::DataToString(glw::GLuint count, const glw::GLubyte data[])
{
	std::string data_str = "[";

	for (glw::GLuint i = 0; i < count; ++i)
	{
		std::stringstream int_sstream;

		int_sstream << unsigned(data[i]);

		data_str.append(int_sstream.str());

		if (i + 1 < count)
		{
			data_str.append(", ");
		}
		else
		{
			data_str.append("]");
		}
	}

	return data_str;
}

/** @brief Iterate Compressed SubImage Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult CompressedSubImageTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		is_ok &= Test<1>(GL_COMPRESSED_RGB, false);

		is_ok &= Test<2>(GL_COMPRESSED_RED_RGTC1, false);
		is_ok &= Test<2>(GL_COMPRESSED_SIGNED_RED_RGTC1, false);
		is_ok &= Test<2>(GL_COMPRESSED_RG_RGTC2, false);
		is_ok &= Test<2>(GL_COMPRESSED_SIGNED_RG_RGTC2, false);
		is_ok &= Test<2>(GL_COMPRESSED_RGBA_BPTC_UNORM, false);
		is_ok &= Test<2>(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, false);
		is_ok &= Test<2>(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, false);
		is_ok &= Test<2>(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, false);
		is_ok &= Test<2>(GL_COMPRESSED_RGB8_ETC2, true);
		is_ok &= Test<2>(GL_COMPRESSED_SRGB8_ETC2, true);
		is_ok &= Test<2>(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, true);
		is_ok &= Test<2>(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, true);
		is_ok &= Test<2>(GL_COMPRESSED_RGBA8_ETC2_EAC, true);
		is_ok &= Test<2>(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, true);
		is_ok &= Test<2>(GL_COMPRESSED_R11_EAC, true);
		is_ok &= Test<2>(GL_COMPRESSED_SIGNED_R11_EAC, true);
		is_ok &= Test<2>(GL_COMPRESSED_RG11_EAC, true);
		is_ok &= Test<2>(GL_COMPRESSED_SIGNED_RG11_EAC, true);

		is_ok &= Test<3>(GL_COMPRESSED_RED_RGTC1, false);
		is_ok &= Test<3>(GL_COMPRESSED_SIGNED_RED_RGTC1, false);
		is_ok &= Test<3>(GL_COMPRESSED_RG_RGTC2, false);
		is_ok &= Test<3>(GL_COMPRESSED_SIGNED_RG_RGTC2, false);
		is_ok &= Test<3>(GL_COMPRESSED_RGBA_BPTC_UNORM, false);
		is_ok &= Test<3>(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, false);
		is_ok &= Test<3>(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, false);
		is_ok &= Test<3>(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, false);
		is_ok &= Test<3>(GL_COMPRESSED_RGB8_ETC2, true);
		is_ok &= Test<3>(GL_COMPRESSED_SRGB8_ETC2, true);
		is_ok &= Test<3>(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, true);
		is_ok &= Test<3>(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, true);
		is_ok &= Test<3>(GL_COMPRESSED_RGBA8_ETC2_EAC, true);
		is_ok &= Test<3>(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, true);
		is_ok &= Test<3>(GL_COMPRESSED_R11_EAC, true);
		is_ok &= Test<3>(GL_COMPRESSED_SIGNED_R11_EAC, true);
		is_ok &= Test<3>(GL_COMPRESSED_RG11_EAC, true);
		is_ok &= Test<3>(GL_COMPRESSED_SIGNED_RG11_EAC, true);
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	CleanAll();

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** Reference data. */
const glw::GLubyte CompressedSubImageTest::s_texture_data[] = {
	0x00, 0x00, 0x00, 0xFF, 0x7f, 0x7f, 0x7f, 0x00, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x88, 0x00, 0x15, 0xFF, 0xed, 0x1c, 0x24, 0x00, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x00, 0x00,
	0xc8, 0xbf, 0xe7, 0xFF, 0x70, 0x92, 0xbe, 0x00, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0x00,
	0xa3, 0x49, 0xa4, 0xFF, 0x3f, 0x48, 0xcc, 0x00, 0x00, 0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0x00,

	0xa3, 0x49, 0xa4, 0xFF, 0xc8, 0xbf, 0xe7, 0x00, 0x88, 0x00, 0x15, 0xff, 0x00, 0x00, 0x00, 0x00,
	0x3f, 0x48, 0xcc, 0xFF, 0x70, 0x92, 0xbe, 0x00, 0xed, 0x1c, 0x24, 0xff, 0x7f, 0x7f, 0x7f, 0x00,
	0x00, 0xa2, 0xe8, 0xFF, 0x99, 0xd9, 0xea, 0x00, 0xff, 0x7f, 0x27, 0xff, 0xc3, 0xc3, 0xc3, 0x00,
	0x22, 0xb1, 0x4c, 0xFF, 0xb5, 0xe6, 0x1d, 0x00, 0xff, 0xf2, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00,

	0x22, 0xb1, 0x4c, 0xFF, 0x00, 0xa2, 0xe8, 0x00, 0x3f, 0x48, 0xcc, 0xff, 0xa3, 0x49, 0xa4, 0x00,
	0xb5, 0xe6, 0x1d, 0xFF, 0x99, 0xd9, 0xea, 0x00, 0x70, 0x92, 0xbe, 0xff, 0xc8, 0xbf, 0xe7, 0x00,
	0xff, 0xf2, 0x00, 0xFF, 0xff, 0x7f, 0x27, 0x00, 0xed, 0x1c, 0x24, 0xff, 0x88, 0x00, 0x15, 0x00,
	0xff, 0xff, 0xff, 0xFF, 0xc3, 0xc3, 0xc3, 0x00, 0x7f, 0x7f, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00,

	0xff, 0xff, 0xff, 0xFF, 0xff, 0xf2, 0x00, 0x00, 0xb5, 0xe6, 0x1d, 0xff, 0x22, 0xb1, 0x4c, 0x00,
	0xc3, 0xc3, 0xc3, 0xFF, 0xff, 0x7f, 0x27, 0x00, 0x99, 0xd9, 0xea, 0xff, 0x00, 0xa2, 0xe8, 0x00,
	0x7f, 0x7f, 0x7f, 0xFF, 0xed, 0x1c, 0x24, 0x00, 0x70, 0x92, 0xbe, 0xff, 0x3f, 0x48, 0xcc, 0x00,
	0x00, 0x00, 0x00, 0xFF, 0x88, 0x00, 0x15, 0x00, 0xc8, 0xbf, 0xe7, 0xff, 0xa3, 0x49, 0xa4, 0x00
};

/** Reference data parameters. */
const glw::GLuint CompressedSubImageTest::s_texture_width   = 4;
const glw::GLuint CompressedSubImageTest::s_texture_height  = 4;
const glw::GLuint CompressedSubImageTest::s_texture_depth   = 4;
const glw::GLuint CompressedSubImageTest::s_block_count		= 8;
const glw::GLuint CompressedSubImageTest::s_block_2d_size_x = 4;
const glw::GLuint CompressedSubImageTest::s_block_2d_size_y = 2;
const glw::GLuint CompressedSubImageTest::s_block_3d_size   = 2;

/******************************** Copy SubImage Test Implementation   ********************************/

/** @brief Compressed SubImage Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
CopyTest::CopyTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_copy", "Texture Copy Test")
	, m_fbo(0)
	, m_to_src(0)
	, m_to_dst(0)
	, m_result(DE_NULL)
{
	/* Intentionally left blank. */
}

/** @brief Texture target selector.
 *
 *  @tparam D      Texture dimenisons.
 *
 *  @return Texture target.
 */
template <>
glw::GLenum CopyTest::TextureTarget<1>()
{
	return GL_TEXTURE_1D;
}
template <>
glw::GLenum CopyTest::TextureTarget<2>()
{
	return GL_TEXTURE_2D;
}
template <>
glw::GLenum CopyTest::TextureTarget<3>()
{
	return GL_TEXTURE_3D;
}

/** @brief Copy texture, check errors and log.
 *
 *  @note Parameters as passed to CopyTextureSubImage*D
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool CopyTest::CopyTextureSubImage1DAndCheckErrors(glw::GLuint texture, glw::GLint level, glw::GLint xoffset,
												   glw::GLint x, glw::GLint y, glw::GLsizei width)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");

	gl.copyTextureSubImage1D(texture, level, xoffset, x, y, width);

	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message
											<< "glCopyTextureSubImage1D unexpectedly generated error "
											<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Copy texture, check errors and log.
 *
 *  @note Parameters as passed to CopyTextureSubImage*D
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool CopyTest::CopyTextureSubImage2DAndCheckErrors(glw::GLuint texture, glw::GLint level, glw::GLint xoffset,
												   glw::GLint yoffset, glw::GLint x, glw::GLint y, glw::GLsizei width,
												   glw::GLsizei height)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");

	gl.copyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);

	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message
											<< "glCopyTextureSubImage2D unexpectedly generated error "
											<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Copy texture, check errors and log.
 *
 *  @note Parameters as passed to CopyTextureSubImage*D
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool CopyTest::CopyTextureSubImage3DAndCheckErrors(glw::GLuint texture, glw::GLint level, glw::GLint xoffset,
												   glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y,
												   glw::GLsizei width, glw::GLsizei height)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.readBuffer(GL_COLOR_ATTACHMENT0 + zoffset);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");

	gl.copyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);

	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message
											<< "glCopyTextureSubImage3D unexpectedly generated error "
											<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Create texture.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateSourceTexture<1>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genTextures(1, &m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindTexture(TextureTarget<1>(), m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.texImage1D(TextureTarget<1>(), 0, GL_RGBA8, s_texture_width, 0, GL_RGBA, GL_UNSIGNED_BYTE, s_texture_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D call failed.");
}

/** @brief Create texture.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateSourceTexture<2>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genTextures(1, &m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindTexture(TextureTarget<2>(), m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.texImage2D(TextureTarget<2>(), 0, GL_RGBA8, s_texture_width, s_texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
				  s_texture_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D call failed.");
}

/** @brief Create texture.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateSourceTexture<3>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genTextures(1, &m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindTexture(TextureTarget<3>(), m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.texImage3D(TextureTarget<3>(), 0, GL_RGBA8, s_texture_width, s_texture_height, s_texture_depth, 0, GL_RGBA,
				  GL_UNSIGNED_BYTE, s_texture_data);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D call failed.");
}

/** @brief Create texture.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateDestinationTexture<1>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genTextures(1, &m_to_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindTexture(TextureTarget<1>(), m_to_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.texImage1D(TextureTarget<1>(), 0, GL_RGBA8, s_texture_width, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D call failed.");
}

/** @brief Create texture.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateDestinationTexture<2>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genTextures(1, &m_to_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindTexture(TextureTarget<2>(), m_to_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.texImage2D(TextureTarget<2>(), 0, GL_RGBA8, s_texture_width, s_texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
				  DE_NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D call failed.");
}

/** @brief Create texture.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateDestinationTexture<3>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genTextures(1, &m_to_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindTexture(TextureTarget<3>(), m_to_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.texImage3D(TextureTarget<3>(), 0, GL_RGBA8, s_texture_width, s_texture_height, s_texture_depth, 0, GL_RGBA,
				  GL_UNSIGNED_BYTE, DE_NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D call failed.");
}

/** @brief Create framebuffer.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateSourceFramebuffer<1>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.framebufferTexture1D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, TextureTarget<1>(), m_to_src, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture1D call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	gl.viewport(0, 0, s_texture_width, 1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}

/** @brief Create framebuffer.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateSourceFramebuffer<2>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, TextureTarget<2>(), m_to_src, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture1D call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	gl.viewport(0, 0, s_texture_width, s_texture_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}

/** @brief Create framebuffer.
 *
 *  @tparam D      Dimmensions.
 */
template <>
void CopyTest::CreateSourceFramebuffer<3>()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	for (glw::GLuint i = 0; i < s_texture_depth; ++i)
	{
		gl.framebufferTexture3D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + i, TextureTarget<3>(), m_to_src, 0, i);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture1D call failed.");
	}

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	gl.viewport(0, 0, s_texture_width, s_texture_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");
}

/** @brief Dispatch function to create test objects */
template <glw::GLuint D>
void				  CopyTest::CreateAll()
{
	CreateSourceTexture<D>();
	CreateSourceFramebuffer<D>();
	CreateDestinationTexture<D>();
}

/** @brief Test function */
template <>
bool CopyTest::Test<1>()
{
	CreateAll<1>();

	bool result = true;

	result &= CopyTextureSubImage1DAndCheckErrors(m_to_dst, 0, 0, 0, 0, s_texture_width / 2);
	result &= CopyTextureSubImage1DAndCheckErrors(m_to_dst, 0, s_texture_width / 2, s_texture_width / 2, 0,
												  s_texture_width / 2);

	result &= CheckData(TextureTarget<1>(), 4 /* RGBA */ * s_texture_width);

	CleanAll();

	return result;
}

/** @brief Test function */
template <>
bool CopyTest::Test<2>()
{
	CreateAll<2>();

	bool result = true;

	result &= CopyTextureSubImage2DAndCheckErrors(m_to_dst, 0, 0, 0, 0, 0, s_texture_width / 2, s_texture_height / 2);
	result &= CopyTextureSubImage2DAndCheckErrors(m_to_dst, 0, s_texture_width / 2, 0, s_texture_width / 2, 0,
												  s_texture_width / 2, s_texture_height / 2);
	result &= CopyTextureSubImage2DAndCheckErrors(m_to_dst, 0, 0, s_texture_height / 2, 0, s_texture_height / 2,
												  s_texture_width / 2, s_texture_height / 2);
	result &=
		CopyTextureSubImage2DAndCheckErrors(m_to_dst, 0, s_texture_width / 2, s_texture_height / 2, s_texture_width / 2,
											s_texture_height / 2, s_texture_width / 2, s_texture_height / 2);

	result &= CheckData(TextureTarget<2>(), 4 /* RGBA */ * s_texture_width * s_texture_height);

	CleanAll();

	return result;
}

/** @brief Test function */
template <>
bool CopyTest::Test<3>()
{
	CreateAll<3>();

	bool result = true;

	for (glw::GLuint i = 0; i < s_texture_depth; ++i)
	{
		result &=
			CopyTextureSubImage3DAndCheckErrors(m_to_dst, 0, 0, 0, i, 0, 0, s_texture_width / 2, s_texture_height / 2);
		result &= CopyTextureSubImage3DAndCheckErrors(m_to_dst, 0, s_texture_width / 2, 0, i, s_texture_width / 2, 0,
													  s_texture_width / 2, s_texture_height / 2);
		result &= CopyTextureSubImage3DAndCheckErrors(m_to_dst, 0, 0, s_texture_height / 2, i, 0, s_texture_height / 2,
													  s_texture_width / 2, s_texture_height / 2);
		result &= CopyTextureSubImage3DAndCheckErrors(m_to_dst, 0, s_texture_width / 2, s_texture_height / 2, i,
													  s_texture_width / 2, s_texture_height / 2, s_texture_width / 2,
													  s_texture_height / 2);
	}

	result &= CheckData(TextureTarget<3>(), 4 /* RGBA */ * s_texture_width * s_texture_height * s_texture_depth);

	CleanAll();

	return result;
}

/** @brief Compre results with the reference.
 *
 *  @param [in] target      Texture target.
 *  @param [in] size        Size of the buffer.
 *
 *  @return True if equal, false otherwise.
 */
bool CopyTest::CheckData(glw::GLenum target, glw::GLuint size)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check texture content with reference. */
	m_result = new glw::GLubyte[size];

	if (DE_NULL == m_result)
	{
		throw 0;
	}

	gl.getTexImage(target, 0, GL_RGBA, GL_UNSIGNED_BYTE, m_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");

	for (glw::GLuint i = 0; i < size; ++i)
	{
		if (s_texture_data[i] != m_result[i])
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "glCopyTextureSubImage*D created texture with data "
				<< DataToString(size, s_texture_data) << " however texture contains data "
				<< DataToString(size, m_result) << ". Texture target was " << glu::getTextureTargetStr(target)
				<< ". Test fails." << tcu::TestLog::EndMessage;

			return false;
		}
	}

	return true;
}

/** @brief Convert raw data into string for logging purposes.
 *
 *  @param [in] count      Count of the data.
 *  @param [in] data       Raw data.
 *
 *  @return String representation of data.
 */
std::string CopyTest::DataToString(glw::GLuint count, const glw::GLubyte data[])
{
	std::string data_str = "[";

	for (glw::GLuint i = 0; i < count; ++i)
	{
		std::stringstream int_sstream;

		int_sstream << unsigned(data[i]);

		data_str.append(int_sstream.str());

		if (i + 1 < count)
		{
			data_str.append(", ");
		}
		else
		{
			data_str.append("]");
		}
	}

	return data_str;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void CopyTest::CleanAll()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	if (m_fbo)
	{
		gl.deleteFramebuffers(1, &m_fbo);

		m_fbo = 0;
	}

	if (m_to_src)
	{
		gl.deleteTextures(1, &m_to_src);

		m_to_src = 0;
	}

	if (m_to_dst)
	{
		gl.deleteTextures(1, &m_to_dst);

		m_to_dst = 0;
	}

	if (DE_NULL == m_result)
	{
		delete[] m_result;

		m_result = DE_NULL;
	}

	while (GL_NO_ERROR != gl.getError())
		;
}

/** @brief Iterate Copy Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult CopyTest::iterate()
{
	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		is_ok &= Test<1>();
		is_ok &= Test<2>();
		is_ok &= Test<3>();
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	CleanAll();

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** Reference data. */
const glw::GLubyte CopyTest::s_texture_data[] = {
	0x00, 0x00, 0x00, 0xFF, 0x7f, 0x7f, 0x7f, 0x00, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0x00,
	0x88, 0x00, 0x15, 0xFF, 0xed, 0x1c, 0x24, 0x00, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x00, 0x00,
	0xc8, 0xbf, 0xe7, 0xFF, 0x70, 0x92, 0xbe, 0x00, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0x00,
	0xa3, 0x49, 0xa4, 0xFF, 0x3f, 0x48, 0xcc, 0x00, 0x00, 0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0x00,

	0xa3, 0x49, 0xa4, 0xFF, 0xc8, 0xbf, 0xe7, 0x00, 0x88, 0x00, 0x15, 0xff, 0x00, 0x00, 0x00, 0x00,
	0x3f, 0x48, 0xcc, 0xFF, 0x70, 0x92, 0xbe, 0x00, 0xed, 0x1c, 0x24, 0xff, 0x7f, 0x7f, 0x7f, 0x00,
	0x00, 0xa2, 0xe8, 0xFF, 0x99, 0xd9, 0xea, 0x00, 0xff, 0x7f, 0x27, 0xff, 0xc3, 0xc3, 0xc3, 0x00,
	0x22, 0xb1, 0x4c, 0xFF, 0xb5, 0xe6, 0x1d, 0x00, 0xff, 0xf2, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00,

	0x22, 0xb1, 0x4c, 0xFF, 0x00, 0xa2, 0xe8, 0x00, 0x3f, 0x48, 0xcc, 0xff, 0xa3, 0x49, 0xa4, 0x00,
	0xb5, 0xe6, 0x1d, 0xFF, 0x99, 0xd9, 0xea, 0x00, 0x70, 0x92, 0xbe, 0xff, 0xc8, 0xbf, 0xe7, 0x00,
	0xff, 0xf2, 0x00, 0xFF, 0xff, 0x7f, 0x27, 0x00, 0xed, 0x1c, 0x24, 0xff, 0x88, 0x00, 0x15, 0x00,
	0xff, 0xff, 0xff, 0xFF, 0xc3, 0xc3, 0xc3, 0x00, 0x7f, 0x7f, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00,

	0xff, 0xff, 0xff, 0xFF, 0xff, 0xf2, 0x00, 0x00, 0xb5, 0xe6, 0x1d, 0xff, 0x22, 0xb1, 0x4c, 0x00,
	0xc3, 0xc3, 0xc3, 0xFF, 0xff, 0x7f, 0x27, 0x00, 0x99, 0xd9, 0xea, 0xff, 0x00, 0xa2, 0xe8, 0x00,
	0x7f, 0x7f, 0x7f, 0xFF, 0xed, 0x1c, 0x24, 0x00, 0x70, 0x92, 0xbe, 0xff, 0x3f, 0x48, 0xcc, 0x00,
	0x00, 0x00, 0x00, 0xFF, 0x88, 0x00, 0x15, 0x00, 0xc8, 0xbf, 0xe7, 0xff, 0xa3, 0x49, 0xa4, 0x00
};

/** Reference data parameters. */
const glw::GLuint CopyTest::s_texture_width  = 4;
const glw::GLuint CopyTest::s_texture_height = 4;
const glw::GLuint CopyTest::s_texture_depth  = 4;

/******************************** Get Set Parameter Test Implementation   ********************************/

/** @brief Get Set Parameter Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
GetSetParameterTest::GetSetParameterTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_get_set_parameter", "Texture Get Set Parameter Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Get Set Parameter Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult GetSetParameterTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Texture. */
	glw::GLuint texture = 0;

	try
	{
		gl.genTextures(1, &texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_3D, texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		{
			glw::GLenum name	  = GL_DEPTH_STENCIL_TEXTURE_MODE;
			glw::GLint  value_src = GL_DEPTH_COMPONENT;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_BASE_LEVEL;
			glw::GLint  value_src = 2;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum  name		  = GL_TEXTURE_BORDER_COLOR;
			glw::GLfloat value_src[4] = { 0.25, 0.5, 0.75, 1.0 };
			glw::GLfloat value_dst[4] = {};

			gl.textureParameterfv(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameterfv", name);

			gl.getTextureParameterfv(texture, name, value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameterfv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name		 = GL_TEXTURE_BORDER_COLOR;
			glw::GLint  value_src[4] = { 0, 64, -64, -32 };
			glw::GLint  value_dst[4] = {};

			gl.textureParameterIiv(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameterIiv", name);

			gl.getTextureParameterIiv(texture, name, value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameterIiv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name		 = GL_TEXTURE_BORDER_COLOR;
			glw::GLuint value_src[4] = { 0, 64, 128, 192 };
			glw::GLuint value_dst[4] = {};

			gl.textureParameterIuiv(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameterIuiv", name);

			gl.getTextureParameterIuiv(texture, name, value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameterIuiv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_COMPARE_FUNC;
			glw::GLint  value_src = GL_LEQUAL;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_COMPARE_MODE;
			glw::GLint  value_src = GL_COMPARE_REF_TO_TEXTURE;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum  name	  = GL_TEXTURE_LOD_BIAS;
			glw::GLfloat value_src = -2.f;
			glw::GLfloat value_dst = 0.f;

			gl.textureParameterf(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameterf", name);

			gl.getTextureParameterfv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameterfv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MIN_FILTER;
			glw::GLint  value_src = GL_LINEAR_MIPMAP_NEAREST;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MAG_FILTER;
			glw::GLint  value_src = GL_NEAREST;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MIN_LOD;
			glw::GLint  value_src = -100;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MAX_LOD;
			glw::GLint  value_src = 100;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MAX_LEVEL;
			glw::GLint  value_src = 100;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_R;
			glw::GLint  value_src = GL_BLUE;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_G;
			glw::GLint  value_src = GL_ALPHA;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_B;
			glw::GLint  value_src = GL_RED;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_A;
			glw::GLint  value_src = GL_GREEN;
			glw::GLint  value_dst = 0;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name		 = GL_TEXTURE_SWIZZLE_RGBA;
			glw::GLint  value_src[4] = { GL_ZERO, GL_ONE, GL_ZERO, GL_ONE };
			glw::GLint  value_dst[4] = {};

			gl.textureParameteriv(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_WRAP_S;
			glw::GLint  value_src = GL_MIRROR_CLAMP_TO_EDGE;
			glw::GLint  value_dst = 11;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_WRAP_T;
			glw::GLint  value_src = GL_CLAMP_TO_EDGE;
			glw::GLint  value_dst = 11;

			gl.textureParameteri(texture, name, value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_WRAP_R;
			glw::GLint  value_src = GL_CLAMP_TO_EDGE;
			glw::GLint  value_dst = 11;

			gl.textureParameteriv(texture, name, &value_src);
			is_ok &= CheckErrorAndLog("glTextureParameteri", name);

			gl.getTextureParameteriv(texture, name, &value_dst);
			is_ok &= CheckErrorAndLog("glGetTextureParameteriv", name);

			is_ok &= CompareAndLog(value_src, value_dst, name);
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture)
	{
		gl.deleteTextures(1, &texture);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Check for errors and log.
 *
 *  @param [in] fname     Name of the function (to be logged).
 *  @param [in] pname     Parameter name with which function was called.
 *
 *  @return True if no error, false otherwise.
 */
bool GetSetParameterTest::CheckErrorAndLog(const glw::GLchar* fname, glw::GLenum pname)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check errors. */
	glw::GLenum error;

	if (GL_NO_ERROR != (error = gl.getError()))
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << fname << " unexpectedly generated error "
											<< glu::getErrorStr(error) << " during test of pname "
											<< glu::getTextureParameterStr(pname) << ". Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool GetSetParameterTest::CompareAndLog(glw::GLint value_src, glw::GLint value_dst, glw::GLenum pname)
{
	if (value_src != value_dst)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Queried value of pname "
											<< glu::getTextureParameterStr(pname) << " is equal to " << value_dst
											<< ", however " << value_src << " was expected. Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool GetSetParameterTest::CompareAndLog(glw::GLuint value_src, glw::GLuint value_dst, glw::GLenum pname)
{
	if (value_src != value_dst)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Queried value of pname "
											<< glu::getTextureParameterStr(pname) << " is equal to " << value_dst
											<< ", however " << value_src << " was expected. Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool GetSetParameterTest::CompareAndLog(glw::GLfloat value_src, glw::GLfloat value_dst, glw::GLenum pname)
{
	if (de::abs(value_src - value_dst) > 0.0125 /* Precision */)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Queried value of pname "
											<< glu::getTextureParameterStr(pname) << " is equal to " << value_dst
											<< ", however " << value_src << " was expected. Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool GetSetParameterTest::CompareAndLog(glw::GLint value_src[4], glw::GLint value_dst[4], glw::GLenum pname)
{
	if ((value_src[0] != value_dst[0]) || (value_src[1] != value_dst[1]) || (value_src[2] != value_dst[2]) ||
		(value_src[3] != value_dst[3]))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Queried value of pname " << glu::getTextureParameterStr(pname)
			<< " is equal to [" << value_dst[0] << ", " << value_dst[1] << ", " << value_dst[2] << ", " << value_dst[3]
			<< "], however " << value_src[0] << ", " << value_src[1] << ", " << value_src[2] << ", " << value_src[3]
			<< "] was expected. Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool GetSetParameterTest::CompareAndLog(glw::GLuint value_src[4], glw::GLuint value_dst[4], glw::GLenum pname)
{
	if ((value_src[0] != value_dst[0]) || (value_src[1] != value_dst[1]) || (value_src[2] != value_dst[2]) ||
		(value_src[3] != value_dst[3]))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Queried value of pname " << glu::getTextureParameterStr(pname)
			<< " is equal to [" << value_dst[0] << ", " << value_dst[1] << ", " << value_dst[2] << ", " << value_dst[3]
			<< "], however " << value_src[0] << ", " << value_src[1] << ", " << value_src[2] << ", " << value_src[3]
			<< "] was expected. Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool GetSetParameterTest::CompareAndLog(glw::GLfloat value_src[4], glw::GLfloat value_dst[4], glw::GLenum pname)
{
	if ((de::abs(value_src[0] - value_dst[0]) > 0.0125 /* Precision */) ||
		(de::abs(value_src[1] - value_dst[1]) > 0.0125 /* Precision */) ||
		(de::abs(value_src[2] - value_dst[2]) > 0.0125 /* Precision */) ||
		(de::abs(value_src[3] - value_dst[3]) > 0.0125 /* Precision */))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Queried value of pname " << glu::getTextureParameterStr(pname)
			<< " is equal to [" << value_dst[0] << ", " << value_dst[1] << ", " << value_dst[2] << ", " << value_dst[3]
			<< "], however " << value_src[0] << ", " << value_src[1] << ", " << value_src[2] << ", " << value_src[3]
			<< "] was expected. Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/******************************** Defaults Test Implementation   ********************************/

/** @brief Defaults Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
DefaultsTest::DefaultsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_defaults", "Texture Defaults Test")
{
	/* Intentionally left blank. */
}

/** @brief Defaults Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult DefaultsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Texture. */
	glw::GLuint texture = 0;

	try
	{
		gl.createTextures(GL_TEXTURE_3D, 1, &texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		{
			glw::GLenum name	  = GL_DEPTH_STENCIL_TEXTURE_MODE;
			glw::GLint  value_ref = GL_DEPTH_COMPONENT;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_BASE_LEVEL;
			glw::GLint  value_ref = 0;
			glw::GLint  value_dst = 1;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum  name		  = GL_TEXTURE_BORDER_COLOR;
			glw::GLfloat value_ref[4] = { 0.f, 0.f, 0.f, 0.f };
			glw::GLfloat value_dst[4] = {};

			gl.getTextureParameterfv(texture, name, value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_COMPARE_FUNC;
			glw::GLint  value_ref = GL_LEQUAL;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_COMPARE_MODE;
			glw::GLint  value_ref = GL_NONE;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum  name	  = GL_TEXTURE_LOD_BIAS;
			glw::GLfloat value_ref = 0.f;
			glw::GLfloat value_dst = 0.f;

			gl.getTextureParameterfv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MIN_FILTER;
			glw::GLint  value_ref = GL_NEAREST_MIPMAP_LINEAR;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MAG_FILTER;
			glw::GLint  value_ref = GL_LINEAR;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MIN_LOD;
			glw::GLint  value_ref = -1000;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MAX_LOD;
			glw::GLint  value_ref = 1000;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_MAX_LEVEL;
			glw::GLint  value_ref = 1000;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_R;
			glw::GLint  value_ref = GL_RED;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_G;
			glw::GLint  value_ref = GL_GREEN;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_B;
			glw::GLint  value_ref = GL_BLUE;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_SWIZZLE_A;
			glw::GLint  value_ref = GL_ALPHA;
			glw::GLint  value_dst = 0;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_WRAP_S;
			glw::GLint  value_ref = GL_REPEAT;
			glw::GLint  value_dst = 11;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_WRAP_T;
			glw::GLint  value_ref = GL_REPEAT;
			glw::GLint  value_dst = 11;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}

		{
			glw::GLenum name	  = GL_TEXTURE_WRAP_R;
			glw::GLint  value_ref = GL_REPEAT;
			glw::GLint  value_dst = 11;

			gl.getTextureParameteriv(texture, name, &value_dst);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTextureParameter has failed");

			is_ok &= CompareAndLog(value_ref, value_dst, name);
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture)
	{
		gl.deleteTextures(1, &texture);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool DefaultsTest::CompareAndLog(glw::GLint value_ref, glw::GLint value_dst, glw::GLenum pname)
{
	if (value_ref != value_dst)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Queried value of pname "
											<< glu::getTextureParameterStr(pname) << " is equal to " << value_dst
											<< ", however " << value_ref << " was expected. Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool DefaultsTest::CompareAndLog(glw::GLuint value_ref, glw::GLuint value_dst, glw::GLenum pname)
{
	if (value_ref != value_dst)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Queried value of pname "
											<< glu::getTextureParameterStr(pname) << " is equal to " << value_dst
											<< ", however " << value_ref << " was expected. Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool DefaultsTest::CompareAndLog(glw::GLfloat value_ref, glw::GLfloat value_dst, glw::GLenum pname)
{
	if (de::abs(value_ref - value_dst) > 0.0125 /* Precision */)
	{
		m_context.getTestContext().getLog() << tcu::TestLog::Message << "Queried value of pname "
											<< glu::getTextureParameterStr(pname) << " is equal to " << value_dst
											<< ", however " << value_ref << " was expected. Test fails."
											<< tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool DefaultsTest::CompareAndLog(glw::GLint value_ref[4], glw::GLint value_dst[4], glw::GLenum pname)
{
	if ((value_ref[0] != value_dst[0]) || (value_ref[1] != value_dst[1]) || (value_ref[2] != value_dst[2]) ||
		(value_ref[3] != value_dst[3]))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Queried value of pname " << glu::getTextureParameterStr(pname)
			<< " is equal to [" << value_dst[0] << ", " << value_dst[1] << ", " << value_dst[2] << ", " << value_dst[3]
			<< "], however " << value_ref[0] << ", " << value_ref[1] << ", " << value_ref[2] << ", " << value_ref[3]
			<< "] was expected. Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool DefaultsTest::CompareAndLog(glw::GLuint value_ref[4], glw::GLuint value_dst[4], glw::GLenum pname)
{
	if ((value_ref[0] != value_dst[0]) || (value_ref[1] != value_dst[1]) || (value_ref[2] != value_dst[2]) ||
		(value_ref[3] != value_dst[3]))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Queried value of pname " << glu::getTextureParameterStr(pname)
			<< " is equal to [" << value_dst[0] << ", " << value_dst[1] << ", " << value_dst[2] << ", " << value_dst[3]
			<< "], however " << value_ref[0] << ", " << value_ref[1] << ", " << value_ref[2] << ", " << value_ref[3]
			<< "] was expected. Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/** @brief Compare queried value of parameter with the expected vale.
 *
 *  @param [in] value_src           First value.
 *  @param [in] value_dst           Second value.
 *  @param [in] pname               Parameter name.
 *
 *  @return True if no error was generated by CopyTextureSubImage*D, false otherwise
 */
bool DefaultsTest::CompareAndLog(glw::GLfloat value_ref[4], glw::GLfloat value_dst[4], glw::GLenum pname)
{
	if ((de::abs(value_ref[0] - value_dst[0]) > 0.0125 /* Precision */) ||
		(de::abs(value_ref[1] - value_dst[1]) > 0.0125 /* Precision */) ||
		(de::abs(value_ref[2] - value_dst[2]) > 0.0125 /* Precision */) ||
		(de::abs(value_ref[3] - value_dst[3]) > 0.0125 /* Precision */))
	{
		m_context.getTestContext().getLog()
			<< tcu::TestLog::Message << "Queried value of pname " << glu::getTextureParameterStr(pname)
			<< " is equal to [" << value_dst[0] << ", " << value_dst[1] << ", " << value_dst[2] << ", " << value_dst[3]
			<< "], however " << value_ref[0] << ", " << value_ref[1] << ", " << value_ref[2] << ", " << value_ref[3]
			<< "] was expected. Test fails." << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/******************************** Generate Mipmap Test Implementation   ********************************/

/** @brief Generate Mipmap Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
GenerateMipmapTest::GenerateMipmapTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_generate_mipmaps", "Textures Generate Mipmap Test")
{
	/* Intentionally left blank. */
}

/** @brief Generate Mipmap Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult GenerateMipmapTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Texture and cpu results storage. */
	glw::GLuint   texture = 0;
	glw::GLubyte* result  = DE_NULL;

	try
	{
		/* Prepare texture. */
		gl.genTextures(1, &texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_1D, texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage1D(GL_TEXTURE_1D, 0, GL_R8, s_texture_width, 0, GL_RED, GL_UNSIGNED_BYTE, s_texture_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

		/* Generate mipmaps with tested function. */
		gl.generateTextureMipmap(texture);

		glw::GLenum error = GL_NO_ERROR;

		if (GL_NO_ERROR != (error = gl.getError()))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "GenerateTextureMipmap unexpectedly generated error "
				<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

			is_ok = false;
		}

		/* Continue only if mipmaps has been generated. */
		if (is_ok)
		{
			result = new glw::GLubyte[s_texture_width];

			if (DE_NULL == result)
			{
				throw 0;
			}

			/* For each mipmap. */
			for (glw::GLuint i = 0, j = s_texture_width;
				 i < s_texture_width_log - 1 /* Do not test single pixel mipmap. */; ++i, j /= 2)
			{
				/* Check mipmap size. */
				glw::GLint mipmap_size = 0;

				gl.getTexLevelParameteriv(GL_TEXTURE_1D, i, GL_TEXTURE_WIDTH, &mipmap_size);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

				if (mipmap_size != (glw::GLint)j)
				{
					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message
						<< "GenerateTextureMipmap unexpectedly generated mipmap with improper size. Mipmap size is "
						<< mipmap_size << ", but " << j << " was expected. Test fails." << tcu::TestLog::EndMessage;

					is_ok = false;

					break;
				}

				/* Fetch data. */
				gl.getTexImage(GL_TEXTURE_1D, i, GL_RED, GL_UNSIGNED_BYTE, result);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexImage has failed");

				/* Make comparison. */
				for (glw::GLuint k = 0; k < j - 1; ++k)
				{
					if (((glw::GLint)result[k + 1]) - ((glw::GLint)result[k]) < 0)
					{
						m_context.getTestContext().getLog() << tcu::TestLog::Message
															<< "GenerateTextureMipmap unexpectedly generated improper "
															   "mipmap (not descending). Test fails."
															<< tcu::TestLog::EndMessage;

						is_ok = false;

						break;
					}
				}
			}
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture)
	{
		gl.deleteTextures(1, &texture);
	}

	if (DE_NULL != result)
	{
		delete[] result;
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** Reference data. */
const glw::GLubyte GenerateMipmapTest::s_texture_data[] = {
	0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,
	22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,
	44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,
	66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,  84,  85,  86,  87,
	88,  89,  90,  91,  92,  93,  94,  95,  96,  97,  98,  99,  100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
	110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
	132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
	154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
	176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197,
	198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
	220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241,
	242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
};

/** Reference data parameters. */
const glw::GLuint GenerateMipmapTest::s_texture_width	 = 256;
const glw::GLuint GenerateMipmapTest::s_texture_width_log = 8;

/******************************** Bind Unit Test Implementation   ********************************/

/** @brief Bind Unit Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
BindUnitTest::BindUnitTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_bind_unit", "Textures Bind Unit Test")
	, m_po(0)
	, m_fbo(0)
	, m_rbo(0)
	, m_vao(0)
	, m_result(DE_NULL)
{
	m_to[0] = 0;
	m_to[1] = 0;
	m_to[2] = 0;
	m_to[3] = 0;
}

/** @brief Bind Unit Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult BindUnitTest::iterate()
{
	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		CreateProgram();
		CreateTextures();
		CreateFrambuffer();
		CreateVertexArray();
		is_ok &= Draw();
		is_ok &= Check();
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	CleanAll();

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Create test program.
 */
void BindUnitTest::CreateProgram()
{
	/* Shortcut for GL functionality */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	struct Shader
	{
		glw::GLchar const* source;
		glw::GLenum const  type;
		glw::GLuint		   id;
	} shader[] = { { s_vertex_shader, GL_VERTEX_SHADER, 0 }, { s_fragment_shader, GL_FRAGMENT_SHADER, 0 } };

	glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);

	try
	{
		/* Create program. */
		m_po = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");

		/* Shader compilation. */

		for (glw::GLuint i = 0; i < shader_count; ++i)
		{
			if (DE_NULL != shader[i].source)
			{
				shader[i].id = gl.createShader(shader[i].type);

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

				gl.attachShader(m_po, shader[i].id);

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

				gl.shaderSource(shader[i].id, 1, &shader[i].source, NULL);

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

				gl.compileShader(shader[i].id);

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

				glw::GLint status = GL_FALSE;

				gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

				if (GL_FALSE == status)
				{
					glw::GLint log_size = 0;
					gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
					GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");

					glw::GLchar* log_text = new glw::GLchar[log_size];

					gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);

					m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader compilation has failed.\n"
														<< "Shader type: " << glu::getShaderTypeStr(shader[i].type)
														<< "\n"
														<< "Shader compilation error log:\n"
														<< log_text << "\n"
														<< "Shader source code:\n"
														<< shader[i].source << "\n"
														<< tcu::TestLog::EndMessage;

					delete[] log_text;

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

					throw 0;
				}
			}
		}

		/* Link. */
		gl.linkProgram(m_po);

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

		glw::GLint status = GL_FALSE;

		gl.getProgramiv(m_po, GL_LINK_STATUS, &status);

		if (GL_TRUE == status)
		{
			for (glw::GLuint i = 0; i < shader_count; ++i)
			{
				if (shader[i].id)
				{
					gl.detachShader(m_po, shader[i].id);

					GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
				}
			}
		}
		else
		{
			glw::GLint log_size = 0;

			gl.getProgramiv(m_po, GL_INFO_LOG_LENGTH, &log_size);

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

			glw::GLchar* log_text = new glw::GLchar[log_size];

			gl.getProgramInfoLog(m_po, log_size, NULL, &log_text[0]);

			m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n"
												<< log_text << "\n"
												<< tcu::TestLog::EndMessage;

			delete[] log_text;

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

			throw 0;
		}
	}
	catch (...)
	{
		if (m_po)
		{
			gl.deleteProgram(m_po);

			m_po = 0;
		}
	}

	for (glw::GLuint i = 0; i < shader_count; ++i)
	{
		if (0 != shader[i].id)
		{
			gl.deleteShader(shader[i].id);

			shader[i].id = 0;
		}
	}

	if (0 == m_po)
	{
		throw 0;
	}
}

/** @brief Create texture.
 */
void BindUnitTest::CreateTextures()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare texture. */
	gl.genTextures(4, m_to);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

	/* Setup pixel sotre modes.*/
	gl.pixelStorei(GL_UNPACK_ALIGNMENT, sizeof(glw::GLubyte));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	gl.pixelStorei(GL_PACK_ALIGNMENT, sizeof(glw::GLubyte));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	/* Red texture. */
	gl.bindTexture(GL_TEXTURE_2D, m_to[0]);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, GL_R8, s_texture_width, s_texture_height, 0, GL_RED, GL_UNSIGNED_BYTE,
				  s_texture_data_r);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");

	/* Green texture. */
	gl.bindTexture(GL_TEXTURE_2D, m_to[1]);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, GL_R8, s_texture_width, s_texture_height, 0, GL_RED, GL_UNSIGNED_BYTE,
				  s_texture_data_g);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");

	/* Blue texture. */
	gl.bindTexture(GL_TEXTURE_2D, m_to[2]);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, GL_R8, s_texture_width, s_texture_height, 0, GL_RED, GL_UNSIGNED_BYTE,
				  s_texture_data_b);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");

	/* Alpha texture. */
	gl.bindTexture(GL_TEXTURE_2D, m_to[3]);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, GL_R8, s_texture_width, s_texture_height, 0, GL_RED, GL_UNSIGNED_BYTE,
				  s_texture_data_a);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");
}

/** @brief Create framebuffer.
 */
void BindUnitTest::CreateFrambuffer()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Prepare framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.genRenderbuffers(1, &m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, s_texture_width, s_texture_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");

	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	gl.viewport(0, 0, s_texture_width, s_texture_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	/* Clear framebuffer's content. */
	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");
}

/** @brief Create vertex array object.
 */
void BindUnitTest::CreateVertexArray()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genVertexArrays(1, &m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call has failed.");

	gl.bindVertexArray(m_vao);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call has failed.");
}

bool BindUnitTest::Draw()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Setup program. */
	gl.useProgram(m_po);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call has failed.");

	/* Bind textures to proper units and setup program's samplers. */
	for (glw::GLuint i = 0; i < 4; ++i)
	{
		/* Tested binding funcion. */
		gl.bindTextureUnit(i, m_to[i]);

		/* Check for errors. */
		glw::GLenum error = GL_NO_ERROR;

		if (GL_NO_ERROR != (error = gl.getError()))
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "BindTextureUnit unexpectedly generated error " << glu::getErrorStr(error)
				<< " when binding texture " << m_to[i] << " to texture unit " << i << ". Test fails."
				<< tcu::TestLog::EndMessage;

			return false;
		}

		/* Sampler setup. */
		gl.uniform1i(gl.getUniformLocation(m_po, s_fragment_shader_samplers[i]), i);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation or glUniform1i call has failed.");
	}

	/* Draw call. */
	gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call has failed.");

	return true;
}

/** @brief Compare results with reference.
 *
 *  @return True if equal, false otherwise.
 */
bool BindUnitTest::Check()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Setup storage for results. */
	m_result = new glw::GLubyte[s_texture_count_rgba];

	/* Setup pixel sotre modes.*/
	gl.pixelStorei(GL_UNPACK_ALIGNMENT, sizeof(glw::GLubyte));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	gl.pixelStorei(GL_PACK_ALIGNMENT, sizeof(glw::GLubyte));
	GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei has failed");

	/* Query framebuffer's image. */
	gl.readPixels(0, 0, s_texture_width, s_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, m_result);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call has failed.");

	/* Compare values with reference. */
	for (glw::GLuint i = 0; i < s_texture_count_rgba; ++i)
	{
		if (s_texture_data_rgba[i] != m_result[i])
		{
			m_context.getTestContext().getLog()
				<< tcu::TestLog::Message << "Framebuffer data " << DataToString(s_texture_count_rgba, m_result)
				<< " does not match the reference values " << DataToString(s_texture_count_rgba, s_texture_data_rgba)
				<< "." << tcu::TestLog::EndMessage;

			return false;
		}
	}

	return true;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void BindUnitTest::CleanAll()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Release GL objects. */
	if (m_po)
	{
		gl.useProgram(0);

		gl.deleteProgram(m_po);

		m_po = 0;
	}

	if (m_to[0] || m_to[1] || m_to[2] || m_to[3])
	{
		gl.deleteTextures(4, m_to);

		m_to[0] = 0;
		m_to[1] = 0;
		m_to[2] = 0;
		m_to[3] = 0;
	}

	if (m_fbo)
	{
		gl.deleteFramebuffers(1, &m_fbo);

		m_fbo = 0;
	}

	if (m_rbo)
	{
		gl.deleteRenderbuffers(1, &m_rbo);

		m_rbo = 0;
	}

	/* Release heap. */
	if (DE_NULL != m_result)
	{
		delete[] m_result;
	}

	/* Erros clean-up. */
	while (GL_NO_ERROR != gl.getError())
		;
}

/** @brief Convert raw data into string for logging purposes.
 *
 *  @param [in] count      Count of the data.
 *  @param [in] data       Raw data.
 *
 *  @return String representation of data.
 */
std::string BindUnitTest::DataToString(glw::GLuint count, const glw::GLubyte data[])
{
	std::string data_str = "[";

	for (glw::GLuint i = 0; i < count; ++i)
	{
		std::stringstream int_sstream;

		int_sstream << unsigned(data[i]);

		data_str.append(int_sstream.str());

		if (i + 1 < count)
		{
			data_str.append(", ");
		}
		else
		{
			data_str.append("]");
		}
	}

	return data_str;
}

/** Reference data and parameters. */
const glw::GLubyte BindUnitTest::s_texture_data_r[]	= { 0, 4, 8, 12, 16, 20 };
const glw::GLubyte BindUnitTest::s_texture_data_g[]	= { 1, 5, 9, 13, 17, 21 };
const glw::GLubyte BindUnitTest::s_texture_data_b[]	= { 2, 6, 10, 14, 18, 22 };
const glw::GLubyte BindUnitTest::s_texture_data_a[]	= { 3, 7, 11, 15, 19, 23 };
const glw::GLubyte BindUnitTest::s_texture_data_rgba[] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11,
														   12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23 };
const glw::GLuint BindUnitTest::s_texture_width		 = 2;
const glw::GLuint BindUnitTest::s_texture_height	 = 3;
const glw::GLuint BindUnitTest::s_texture_count_rgba = sizeof(s_texture_data_rgba) / sizeof(s_texture_data_rgba[0]);

/* Vertex shader source code. */
const glw::GLchar* BindUnitTest::s_vertex_shader = "#version 450\n"
												   "\n"
												   "void main()\n"
												   "{\n"
												   "    switch(gl_VertexID)\n"
												   "    {\n"
												   "        case 0:\n"
												   "            gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
												   "            break;\n"
												   "        case 1:\n"
												   "            gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
												   "            break;\n"
												   "        case 2:\n"
												   "            gl_Position = vec4(-1.0,-1.0, 0.0, 1.0);\n"
												   "            break;\n"
												   "        case 3:\n"
												   "            gl_Position = vec4( 1.0,-1.0, 0.0, 1.0);\n"
												   "            break;\n"
												   "    }\n"
												   "}\n";

/* Fragment shader source program. */
const glw::GLchar* BindUnitTest::s_fragment_shader =
	"#version 450\n"
	"\n"
	"layout(pixel_center_integer) in vec4 gl_FragCoord;\n"
	"\n"
	"uniform sampler2D texture_input_r;\n"
	"uniform sampler2D texture_input_g;\n"
	"uniform sampler2D texture_input_b;\n"
	"uniform sampler2D texture_input_a;\n"
	"\n"
	"out     vec4      color_output;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    color_output = vec4(texelFetch(texture_input_r, ivec2(gl_FragCoord.xy), 0).r,\n"
	"                        texelFetch(texture_input_g, ivec2(gl_FragCoord.xy), 0).r,\n"
	"                        texelFetch(texture_input_b, ivec2(gl_FragCoord.xy), 0).r,\n"
	"                        texelFetch(texture_input_a, ivec2(gl_FragCoord.xy), 0).r);\n"
	"}\n";

const glw::GLchar* BindUnitTest::s_fragment_shader_samplers[4] = { "texture_input_r", "texture_input_g",
																   "texture_input_b", "texture_input_a" };

/******************************** Get Image Test Implementation   ********************************/

/** @brief Get Image Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
GetImageTest::GetImageTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_get_image", "Textures Get Image Test")
{
	/* Intentionally left blank */
}

/** Reference data. */
const glw::GLubyte GetImageTest::s_texture_data[] = { 0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3,
													  0xff, 0xff, 0xff, 0xff, 0xff, 0x88, 0x0,  0x15, 0xff, 0xed, 0x1c,
													  0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff, 0xc8,
													  0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff,
													  0xb5, 0xe6, 0x1d, 0xff, 0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc,
													  0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff };

/** Reference data (compressed). */
const glw::GLubyte GetImageTest::s_texture_data_compressed[] = { 0x90, 0x2b, 0x8f, 0x0f, 0xfe, 0x0f, 0x98, 0x99,
																 0x99, 0x99, 0x59, 0x8f, 0x8c, 0xa6, 0xb7, 0x71 };

/** Reference data parameters. */
const glw::GLuint GetImageTest::s_texture_width			  = 4;
const glw::GLuint GetImageTest::s_texture_height		  = 4;
const glw::GLuint GetImageTest::s_texture_size			  = sizeof(s_texture_data);
const glw::GLuint GetImageTest::s_texture_size_compressed = sizeof(s_texture_data_compressed);
const glw::GLuint GetImageTest::s_texture_count			  = s_texture_size / sizeof(s_texture_data[0]);
const glw::GLuint GetImageTest::s_texture_count_compressed =
	s_texture_size_compressed / sizeof(s_texture_data_compressed[0]);

/** @brief Get Image Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult GetImageTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint  texture									   = 0;
	glw::GLubyte result[s_texture_count]					   = {};
	glw::GLubyte result_compressed[s_texture_count_compressed] = {};

	try
	{
		/* Uncompressed case. */
		{
			/* Texture initiation. */
			gl.genTextures(1, &texture);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

			gl.bindTexture(GL_TEXTURE_2D, texture);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

			gl.texImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, s_texture_width, s_texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
						  s_texture_data);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

			/* Quering image with tested function. */
			gl.getTextureImage(texture, 0, GL_RGBA, GL_UNSIGNED_BYTE, sizeof(result), result);

			/* Check for errors. */
			glw::GLenum error = GL_NO_ERROR;

			if (GL_NO_ERROR != (error = gl.getError()))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "GetTextureImage unexpectedly generated error "
					<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

				is_ok = false;
			}
			else
			{
				/* No error, so compare images. */
				for (glw::GLuint i = 0; i < s_texture_count; ++i)
				{
					if (s_texture_data[i] != result[i])
					{
						m_context.getTestContext().getLog() << tcu::TestLog::Message << "GetTextureImage returned "
															<< DataToString(s_texture_count, result) << ", but "
															<< DataToString(s_texture_count, s_texture_data)
															<< " was expected. Test fails." << tcu::TestLog::EndMessage;

						is_ok = false;

						break;
					}
				}
			}
		}

		/* Clean up texture .*/
		gl.deleteTextures(1, &texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		texture = 0;

		/* Compressed case. */
		{
			/* Texture initiation. */
			gl.genTextures(1, &texture);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

			gl.bindTexture(GL_TEXTURE_2D, texture);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

			gl.compressedTexImage2D(GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_BPTC_UNORM, s_texture_width, s_texture_height,
									0, s_texture_size_compressed, s_texture_data_compressed);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage2D has failed");

			/* Quering image with tested function. */
			gl.getCompressedTextureImage(texture, 0, s_texture_count_compressed * sizeof(result_compressed[0]),
										 result_compressed);

			/* Check for errors. */
			glw::GLenum error = GL_NO_ERROR;

			if (GL_NO_ERROR != (error = gl.getError()))
			{
				m_context.getTestContext().getLog()
					<< tcu::TestLog::Message << "GetCompressedTextureImage unexpectedly generated error "
					<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

				is_ok = false;
			}
			else
			{
				/* No error, so compare images. */
				for (glw::GLuint i = 0; i < s_texture_count_compressed; ++i)
				{
					if (s_texture_data_compressed[i] != result_compressed[i])
					{
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "GetCompressedTextureImage returned "
							<< DataToString(s_texture_count_compressed, result_compressed) << ", but "
							<< DataToString(s_texture_count_compressed, s_texture_data_compressed)
							<< " was expected. Test fails." << tcu::TestLog::EndMessage;

						is_ok = false;

						break;
					}
				}
			}
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture)
	{
		gl.deleteTextures(1, &texture);
	}

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Convert raw data into string for logging purposes.
 *
 *  @param [in] count      Count of the data.
 *  @param [in] data       Raw data.
 *
 *  @return String representation of data.
 */
std::string GetImageTest::DataToString(glw::GLuint count, const glw::GLubyte data[])
{
	std::string data_str = "[";

	for (glw::GLuint i = 0; i < count; ++i)
	{
		std::stringstream int_sstream;

		int_sstream << unsigned(data[i]);

		data_str.append(int_sstream.str());

		if (i + 1 < count)
		{
			data_str.append(", ");
		}
		else
		{
			data_str.append("]");
		}
	}

	return data_str;
}

/******************************** Get Level Parameter Test Implementation   ********************************/

/** @brief Get Level Parameter Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
GetLevelParameterTest::GetLevelParameterTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_get_level_parameter", "Textures Get Level Parameter Test")
{
	/* Intentionally left blank */
}

/** Reference data. */
const glw::GLubyte GetLevelParameterTest::s_texture_data[] = {
	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff,

	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff,

	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff,

	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff
};

/** Reference data parameters. */
const glw::GLuint GetLevelParameterTest::s_texture_width  = 4;
const glw::GLuint GetLevelParameterTest::s_texture_height = 4;
const glw::GLuint GetLevelParameterTest::s_texture_depth  = 4;

/** @brief Get Level Parameter Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult GetLevelParameterTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint texture = 0;

	try
	{
		/* Texture initiation. */
		gl.genTextures(1, &texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_3D, texture);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage3D(GL_TEXTURE_3D, 0, GL_RGBA8, s_texture_width, s_texture_height, s_texture_depth, 0, GL_RGBA,
					  GL_UNSIGNED_BYTE, s_texture_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		gl.texImage3D(GL_TEXTURE_3D, 1, GL_RGBA8, s_texture_width / 2, s_texture_height / 2, s_texture_depth / 2, 0,
					  GL_RGBA, GL_UNSIGNED_BYTE, s_texture_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		static const glw::GLenum pnames[] = {
			GL_TEXTURE_WIDTH,	  GL_TEXTURE_HEIGHT,	 GL_TEXTURE_DEPTH,		 GL_TEXTURE_INTERNAL_FORMAT,
			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_COMPRESSED
		};
		static const glw::GLuint pnames_count = sizeof(pnames) / sizeof(pnames[0]);

		/* Test GetTextureLevelParameteriv. */
		for (glw::GLuint i = 0; i < 2 /* levels */; ++i)
		{
			for (glw::GLuint j = 0; j < pnames_count; ++j)
			{
				glw::GLint result_legacy = 0;
				glw::GLint result_dsa	= 0;

				/* Quering reference value. */
				gl.getTexLevelParameteriv(GL_TEXTURE_3D, i, pnames[j], &result_legacy);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

				/* Quering using DSA function. */
				gl.getTextureLevelParameteriv(texture, i, pnames[j], &result_dsa);

				/* Check for errors. */
				glw::GLenum error = GL_NO_ERROR;

				if (GL_NO_ERROR != (error = gl.getError()))
				{
					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "GetTextureLevelParameteriv unexpectedly generated error "
						<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

					is_ok = false;
				}
				else
				{
					/* Compare values. */
					if (result_legacy != result_dsa)
					{
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "For parameter name "
							<< glu::getTextureLevelParameterStr(pnames[j]) << " GetTextureLevelParameteriv returned "
							<< result_dsa << ", but reference value (queried using GetTexLevelParameteriv) was "
							<< result_legacy << ". Test fails." << tcu::TestLog::EndMessage;

						is_ok = false;
					}
				}
			}
		}

		/* Test GetTextureLevelParameterfv. */
		for (glw::GLuint i = 0; i < 2 /* levels */; ++i)
		{
			for (glw::GLuint j = 0; j < pnames_count; ++j)
			{
				glw::GLfloat result_legacy = 0.f;
				glw::GLfloat result_dsa	= 0.f;

				/* Quering reference value. */
				gl.getTexLevelParameterfv(GL_TEXTURE_3D, i, pnames[j], &result_legacy);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameterfv has failed");

				/* Quering using DSA function. */
				gl.getTextureLevelParameterfv(texture, i, pnames[j], &result_dsa);

				/* Check for errors. */
				glw::GLenum error = GL_NO_ERROR;

				if (GL_NO_ERROR != (error = gl.getError()))
				{
					m_context.getTestContext().getLog()
						<< tcu::TestLog::Message << "GetTextureLevelParameterfv unexpectedly generated error "
						<< glu::getErrorStr(error) << ". Test fails." << tcu::TestLog::EndMessage;

					is_ok = false;
				}
				else
				{
					/* Compare values. */
					if (de::abs(result_legacy - result_dsa) > 0.125 /* Precision. */)
					{
						m_context.getTestContext().getLog()
							<< tcu::TestLog::Message << "For parameter name "
							<< glu::getTextureLevelParameterStr(pnames[j]) << " GetTextureLevelParameterfv returned "
							<< result_dsa << ", but reference value (queried using GetTexLevelParameterfv) was "
							<< result_legacy << ". Test fails." << tcu::TestLog::EndMessage;

						is_ok = false;
					}
				}
			}
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture)
	{
		gl.deleteTextures(1, &texture);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/*********************************** Errors Utility Class *****************************************************/

/** @brief Check for errors and log.
 *
 *  @param [in] context             Test's context.
 *  @param [in] expected_error      Expected error value.
 *  @param [in] function_name       Name of the function (to be logged).
 *  @param [in] log                 Log message.
 *
 *  @return True if error is equal to expected, false otherwise.
 */
bool ErrorsUtilities::CheckErrorAndLog(deqp::Context& context, glw::GLuint expected_error,
									   const glw::GLchar* function_name, const glw::GLchar* log)
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = context.getRenderContext().getFunctions();

	/* Check error. */
	glw::GLenum error = GL_NO_ERROR;

	if (expected_error != (error = gl.getError()))
	{
		context.getTestContext().getLog() << tcu::TestLog::Message << function_name << " generated error "
										  << glu::getErrorStr(error) << " but, " << glu::getErrorStr(expected_error)
										  << " was expected if " << log << tcu::TestLog::EndMessage;

		return false;
	}

	return true;
}

/******************************** Creation Errors Test Implementation   ********************************/

/** @brief Creation Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
CreationErrorsTest::CreationErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_creation_errors", "Texture Objects Creation Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Creation Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult CreationErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Textures' objects */
	glw::GLuint texture = 0;

	try
	{
		/* Not a target test. */
		gl.createTextures(NotATarget(), 1, &texture);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glCreateTextures",
								  "target is not one of the allowable values.");

		if (texture)
		{
			gl.deleteTextures(1, &texture);

			texture = 0;
		}

		/* Negative number of textures. */
		gl.createTextures(GL_TEXTURE_2D, -1, &texture);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCreateTextures", "n is negative.");
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture)
	{
		gl.deleteTextures(1, &texture);
	}

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Function retruns enum which is not a texture target.
 */
glw::GLenum CreationErrorsTest::NotATarget()
{
	static const glw::GLenum texture_targets[] = { GL_TEXTURE_1D,
												   GL_TEXTURE_2D,
												   GL_TEXTURE_3D,
												   GL_TEXTURE_1D_ARRAY,
												   GL_TEXTURE_2D_ARRAY,
												   GL_TEXTURE_RECTANGLE,
												   GL_TEXTURE_CUBE_MAP,
												   GL_TEXTURE_CUBE_MAP_ARRAY,
												   GL_TEXTURE_BUFFER,
												   GL_TEXTURE_2D_MULTISAMPLE,
												   GL_TEXTURE_2D_MULTISAMPLE_ARRAY };

	glw::GLenum not_a_target = 0;
	bool		is_target	= true;

	while (is_target)
	{
		not_a_target++;

		is_target = false;

		for (glw::GLuint i = 0; i < sizeof(texture_targets) / sizeof(texture_targets[0]); ++i)
		{
			if (texture_targets[i] == not_a_target)
			{
				is_target = true;
				break;
			}
		}
	}

	return not_a_target;
}

/******************************** Texture Buffer Errors Test Implementation   ********************************/

/** @brief Texture Buffer Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
BufferErrorsTest::BufferErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_buffer_errors", "Texture Buffer Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Texture Buffer Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult BufferErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Textures' objects */
	glw::GLuint texture_buffer = 0;
	glw::GLuint texture_1D	 = 0;
	glw::GLuint buffer		   = 0;

	static const glw::GLubyte data[4]   = { 1, 2, 3, 4 };
	static const glw::GLuint  data_size = sizeof(data);

	try
	{
		/* Auxiliary objects setup. */
		gl.createTextures(GL_TEXTURE_BUFFER, 1, &texture_buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

		gl.createTextures(GL_TEXTURE_1D, 1, &texture_1D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

		gl.createBuffers(1, &buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers has failed");

		gl.namedBufferData(buffer, data_size, data, GL_STATIC_COPY);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData has failed");

		/*  Check that INVALID_OPERATION is generated by glTextureBuffer if texture
		 is not the name of an existing texture object. */
		{
			glw::GLuint not_a_texture = 0;

			while (gl.isTexture(++not_a_texture))
				;
			GLU_EXPECT_NO_ERROR(gl.getError(), "glIsTexture has failed");

			gl.textureBuffer(not_a_texture, GL_RGBA8, buffer);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureBuffer",
									  "texture is not the name of an existing texture object.");
		}

		/*  Check that INVALID_ENUM is generated by glTextureBuffer if the effective
		 target of texture is not TEXTURE_BUFFER. */
		{
			gl.textureBuffer(texture_1D, GL_RGBA8, buffer);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureBuffer",
									  "the effective target of texture is not TEXTURE_BUFFER.");
		}

		/*  Check that INVALID_ENUM is generated if internalformat is not one of the
		 sized internal formats described above. */
		{
			gl.textureBuffer(texture_buffer, GL_COMPRESSED_SIGNED_RED_RGTC1, buffer);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureBuffer",
									  "internalformat is not one of the sized internal formats described above..");
		}

		/*  Check that INVALID_OPERATION is generated if buffer is not zero and is
		 not the name of an existing buffer object. */
		{
			glw::GLuint not_a_buffer = 0;

			while (gl.isBuffer(++not_a_buffer))
				;
			GLU_EXPECT_NO_ERROR(gl.getError(), "glIsBuffer has failed");

			gl.textureBuffer(texture_buffer, GL_RGBA8, not_a_buffer);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureBuffer",
									  "buffer is not zero and is not the name of an existing buffer object.");
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture_1D)
	{
		gl.deleteTextures(1, &texture_1D);
	}

	if (texture_buffer)
	{
		gl.deleteTextures(1, &texture_buffer);
	}

	if (buffer)
	{
		gl.deleteBuffers(1, &buffer);
	}

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/******************************** Texture Buffer Range Errors Test Implementation   ********************************/

/** @brief Texture Buffer Range Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
BufferRangeErrorsTest::BufferRangeErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_buffer_range_errors", "Texture Buffer Range Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Texture Buffer Range Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult BufferRangeErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Textures' objects */
	glw::GLuint texture_buffer = 0;
	glw::GLuint texture_1D	 = 0;
	glw::GLuint buffer		   = 0;

	static const glw::GLubyte data[4]   = { 1, 2, 3, 4 };
	static const glw::GLuint  data_size = sizeof(data);

	try
	{
		/* Auxiliary objects setup. */
		gl.createTextures(GL_TEXTURE_BUFFER, 1, &texture_buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

		gl.createTextures(GL_TEXTURE_1D, 1, &texture_1D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

		gl.createBuffers(1, &buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers has failed");

		gl.namedBufferData(buffer, data_size, data, GL_STATIC_COPY);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData has failed");

		/*  Check that INVALID_OPERATION is generated by TextureBufferRange if
		 texture is not the name of an existing texture object.*/
		{
			glw::GLuint not_a_texture = 0;

			while (gl.isTexture(++not_a_texture))
				;
			GLU_EXPECT_NO_ERROR(gl.getError(), "glIsTexture has failed");

			gl.textureBufferRange(not_a_texture, GL_RGBA8, buffer, 0, data_size);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureBufferRange",
									  "texture is not the name of an existing texture object.");
		}

		/*  Check that INVALID_ENUM is generated by TextureBufferRange if the
		 effective target of texture is not TEXTURE_BUFFER. */
		{
			gl.textureBufferRange(texture_1D, GL_RGBA8, buffer, 0, data_size);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureBufferRange",
									  "the effective target of texture is not TEXTURE_BUFFER.");
		}

		/*  Check that INVALID_ENUM is generated by TextureBufferRange if
		 internalformat is not one of the sized internal formats described above. */
		{
			gl.textureBufferRange(texture_buffer, GL_COMPRESSED_SIGNED_RED_RGTC1, buffer, 0, data_size);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureBufferRange",
									  "internalformat is not one of the supported sized internal formats.");
		}

		/*  Check that INVALID_OPERATION is generated by TextureBufferRange if
		 buffer is not zero and is not the name of an existing buffer object. */
		{
			glw::GLuint not_a_buffer = 0;

			while (gl.isBuffer(++not_a_buffer))
				;
			GLU_EXPECT_NO_ERROR(gl.getError(), "glIsBuffer has failed");

			gl.textureBufferRange(texture_buffer, GL_RGBA8, not_a_buffer, 0, data_size);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureBufferRange",
									  "buffer is not zero and is not the name of an existing buffer object.");
		}

		/* Check that INVALID_VALUE is generated by TextureBufferRange if offset
		 is negative, if size is less than or equal to zero, or if offset + size
		 is greater than the value of BUFFER_SIZE for buffer. */
		{
			gl.textureBufferRange(texture_buffer, GL_RGBA8, buffer, -1, data_size);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureBufferRange", "offset is negative.");

			gl.textureBufferRange(texture_buffer, GL_RGBA8, buffer, 0, 0);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureBufferRange", "size is zero.");

			gl.textureBufferRange(texture_buffer, GL_RGBA8, buffer, 0, -1);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureBufferRange", "size is negative.");

			gl.textureBufferRange(texture_buffer, GL_RGBA8, buffer, 0, data_size * 16);

			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureBufferRange",
									  "size is greater than the value of BUFFER_SIZE for buffer.");
		}

		/* Check that INVALID_VALUE is generated by TextureBufferRange if offset is
		 not an integer multiple of the value of TEXTURE_BUFFER_OFFSET_ALIGNMENT. */
		{
			glw::GLint gl_texture_buffer_offset_alignment = 0;

			gl.getIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &gl_texture_buffer_offset_alignment);

			/* If alignmet is 1 we cannot do anything. Error situtation is impossible then. */
			if (gl_texture_buffer_offset_alignment > 1)
			{
				gl.textureBufferRange(texture_buffer, GL_RGBA8, buffer, 1, data_size - 1);

				is_ok &= CheckErrorAndLog(
					m_context, GL_INVALID_VALUE, "glTextureBufferRange",
					"offset is not an integer multiple of the value of TEXTURE_BUFFER_OFFSET_ALIGNMENT.");
			}
		}
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture_1D)
	{
		gl.deleteTextures(1, &texture_1D);
	}

	if (texture_buffer)
	{
		gl.deleteTextures(1, &texture_buffer);
	}

	if (buffer)
	{
		gl.deleteBuffers(1, &buffer);
	}

	/* Errors clean up. */
	while (gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/******************************** Texture Storage Errors Test Implementation   ********************************/

/** @brief Texture Storage Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
StorageErrorsTest::StorageErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_storage_errors", "Texture Storage Errors Test")
	, m_to_1D(0)
	, m_to_1D_array(0)
	, m_to_2D(0)
	, m_to_2D_array(0)
	, m_to_3D(0)
	, m_to_2D_ms(0)
	, m_to_2D_ms_immutable(0)
	, m_to_3D_ms(0)
	, m_to_3D_ms_immutable(0)
	, m_to_invalid(0)
	, m_internalformat_invalid(0)
	, m_max_texture_size(1)
	, m_max_samples(1)
	, m_max_array_texture_layers(1)
{
	/* Intentionally left blank. */
}

/** @brief Iterate Texture Storage Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult StorageErrorsTest::iterate()
{
	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		Prepare();

		is_ok &= Test1D();
		is_ok &= Test2D();
		is_ok &= Test3D();
		is_ok &= Test2DMultisample();
		is_ok &= Test3DMultisample();
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	Clean();

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Prepare test objects.
 */
void StorageErrorsTest::Prepare()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Auxiliary objects setup. */

	/* 1D */
	gl.createTextures(GL_TEXTURE_1D, 1, &m_to_1D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 1D ARRAY */
	gl.createTextures(GL_TEXTURE_1D_ARRAY, 1, &m_to_1D_array);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 2D */
	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_2D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 2D ARRAY */
	gl.createTextures(GL_TEXTURE_2D_ARRAY, 1, &m_to_2D_array);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 3D */
	gl.createTextures(GL_TEXTURE_3D, 1, &m_to_3D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 2D Multisample */
	gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE, 1, &m_to_2D_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 2D Multisample with storage */
	gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE, 1, &m_to_2D_ms_immutable);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage2DMultisample(m_to_2D_ms_immutable, 1, GL_R8, 16, 16, false);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2DMultisample has failed");

	/* 3D Multisample */
	gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 1, &m_to_3D_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 3D Multisample with storage */
	gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE_ARRAY, 1, &m_to_3D_ms_immutable);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage3DMultisample(m_to_3D_ms_immutable, 1, GL_R8, 16, 16, 16, false);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2DMultisample has failed");

	/* Invalid values */

	/* invalid texture object */
	while (gl.isTexture(++m_to_invalid))
		;
	GLU_EXPECT_NO_ERROR(gl.getError(), "glIsTexture has failed");

	/* invalid internal format */
	static const glw::GLenum all_internal_formats[] = { GL_R8,
														GL_R8_SNORM,
														GL_R16,
														GL_R16_SNORM,
														GL_RG8,
														GL_RG8_SNORM,
														GL_RG16,
														GL_RG16_SNORM,
														GL_R3_G3_B2,
														GL_RGB4,
														GL_RGB5,
														GL_RGB565,
														GL_RGB8,
														GL_RGB8_SNORM,
														GL_RGB10,
														GL_RGB12,
														GL_RGB16,
														GL_RGB16_SNORM,
														GL_RGBA2,
														GL_RGBA4,
														GL_RGB5_A1,
														GL_RGBA8,
														GL_RGBA8_SNORM,
														GL_RGB10_A2,
														GL_RGB10_A2UI,
														GL_RGBA12,
														GL_RGBA16,
														GL_RGBA16_SNORM,
														GL_SRGB8,
														GL_SRGB8_ALPHA8,
														GL_R16F,
														GL_RG16F,
														GL_RGB16F,
														GL_RGBA16F,
														GL_R32F,
														GL_RG32F,
														GL_RGB32F,
														GL_RGBA32F,
														GL_R11F_G11F_B10F,
														GL_RGB9_E5,
														GL_R8I,
														GL_R8UI,
														GL_R16I,
														GL_R16UI,
														GL_R32I,
														GL_R32UI,
														GL_RG8I,
														GL_RG8UI,
														GL_RG16I,
														GL_RG16UI,
														GL_RG32I,
														GL_RG32UI,
														GL_RGB8I,
														GL_RGB8UI,
														GL_RGB16I,
														GL_RGB16UI,
														GL_RGB32I,
														GL_RGB32UI,
														GL_RGBA8I,
														GL_RGBA8UI,
														GL_RGBA16I,
														GL_RGBA16UI,
														GL_RGBA32I,
														GL_RGBA32UI,
														GL_COMPRESSED_RED,
														GL_COMPRESSED_RG,
														GL_COMPRESSED_RGB,
														GL_COMPRESSED_RGBA,
														GL_COMPRESSED_SRGB,
														GL_COMPRESSED_SRGB_ALPHA,
														GL_COMPRESSED_RED_RGTC1,
														GL_COMPRESSED_SIGNED_RED_RGTC1,
														GL_COMPRESSED_RG_RGTC2,
														GL_COMPRESSED_SIGNED_RG_RGTC2,
														GL_COMPRESSED_RGBA_BPTC_UNORM,
														GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM,
														GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT,
														GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT,
														GL_COMPRESSED_RGB8_ETC2,
														GL_COMPRESSED_SRGB8_ETC2,
														GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
														GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
														GL_COMPRESSED_RGBA8_ETC2_EAC,
														GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
														GL_COMPRESSED_R11_EAC,
														GL_COMPRESSED_SIGNED_R11_EAC,
														GL_COMPRESSED_RG11_EAC,
														GL_COMPRESSED_SIGNED_RG11_EAC,
														GL_DEPTH_COMPONENT16,
														GL_DEPTH_COMPONENT24,
														GL_DEPTH_COMPONENT32,
														GL_DEPTH_COMPONENT32F,
														GL_DEPTH24_STENCIL8,
														GL_DEPTH32F_STENCIL8,
														GL_STENCIL_INDEX1,
														GL_STENCIL_INDEX4,
														GL_STENCIL_INDEX8,
														GL_STENCIL_INDEX16 };

	static const glw::GLuint all_internal_formats_count =
		sizeof(all_internal_formats) / sizeof(all_internal_formats[0]);

	bool is_valid			 = true;
	m_internalformat_invalid = 0;

	while (is_valid)
	{
		is_valid = false;
		m_internalformat_invalid++;
		for (glw::GLuint i = 0; i < all_internal_formats_count; ++i)
		{
			if (all_internal_formats[i] == m_internalformat_invalid)
			{
				is_valid = true;
				break;
			}
		}
	}

	/* Maximum texture size.*/
	gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &m_max_texture_size);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv has failed");

	/* Maximum number of samples. */
	gl.getInternalformativ(GL_RENDERBUFFER, GL_R8, GL_SAMPLES, 1, &m_max_samples);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetInternalformativ has failed");

	/* Maximum number of array texture layers. */
	gl.getIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, &m_max_array_texture_layers);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv has failed");
}

/** @brief Test TextureStorage1D
 *
 *  @return Test result.
 */
bool StorageErrorsTest::Test1D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/*  Check that INVALID_OPERATION is generated by TextureStorage1D if texture
	 is not the name of an existing texture object. */
	{
		gl.textureStorage1D(m_to_invalid, 1, GL_R8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage1D",
								  "texture is not the name of an existing texture object.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage1D if
	 internalformat is not a valid sized internal format. */
	{
		gl.textureStorage1D(m_to_1D, 1, m_internalformat_invalid, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureStorage1D",
								  "internalformat is not a valid sized internal format.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage1D if target or
	 the effective target of texture is not one of the accepted targets
	 described above. */
	{
		gl.textureStorage1D(m_to_2D, 1, GL_R8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage1D",
								  "the effective target of texture is not one of the accepted targets.");
	}

	/*  Check that INVALID_VALUE is generated by TextureStorage1D if width or
	 levels are less than 1. */
	{
		gl.textureStorage1D(m_to_1D, 0, GL_R8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage1D", "levels is less than 1.");

		gl.textureStorage1D(m_to_1D, 1, GL_R8, 0);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage1D", "width is less than 1.");
	}

	/*  Check that INVALID_OPERATION is generated by TextureStorage1D if levels
	 is greater than log2(width)+1. */
	{
		gl.textureStorage1D(m_to_1D, 8, GL_R8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage1D",
								  "levels is greater than log2(width)+1.");
	}

	return is_ok;
}

/** @brief Test TextureStorage2D
 *
 *  @return Test result.
 */
bool StorageErrorsTest::Test2D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/*  Check that INVALID_OPERATION is generated by TextureStorage2D if
	 texture is not the name of an existing texture object. */
	{
		gl.textureStorage2D(m_to_invalid, 1, GL_R8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2D",
								  "texture is not the name of an existing texture object.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage2D if
	 internalformat is not a valid sized internal format. */
	{
		gl.textureStorage2D(m_to_2D, 1, m_internalformat_invalid, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureStorage2D",
								  "internalformat is not a valid sized internal format.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage2D if target or
	 the effective target of texture is not one of the accepted targets
	 described above. */
	{
		gl.textureStorage2D(m_to_1D, 1, GL_R8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2D",
								  "the effective target of texture is not one of the accepted targets.");
	}

	/*  Check that INVALID_VALUE is generated by TextureStorage2D if width,
	 height or levels are less than 1. */
	{
		gl.textureStorage2D(m_to_2D, 0, GL_R8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2D", "levels is less than 1.");

		gl.textureStorage2D(m_to_2D, 1, GL_R8, 0, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2D", "width is less than 1.");

		gl.textureStorage2D(m_to_2D, 1, GL_R8, 8, 0);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2D", "height is less than 1.");
	}

	/* Check that INVALID_OPERATION is generated by TextureStorage2D if target
	 is TEXTURE_1D_ARRAY or PROXY_TEXTURE_1D_ARRAY and levels is greater than
	 log2(width)+1. */
	{
		gl.textureStorage2D(m_to_1D_array, 8, GL_R8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2D",
								  "target is TEXTURE_1D_ARRAY and levels is greater than log2(width)+1.");
	}

	/*  Check that INVALID_OPERATION is generated by TextureStorage2D if target
	 is not TEXTURE_1D_ARRAY or PROXY_TEXTURE_1D_ARRAY and levels is greater
	 than log2(max(width, height))+1.  */
	{
		gl.textureStorage2D(m_to_2D, 8, GL_R8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2D",
								  "target is TEXTURE_2D and levels is greater than log2(max(width, height))+1.");
	}

	return is_ok;
}

/** @brief Test TextureStorage3D
 *
 *  @return Test result.
 */
bool StorageErrorsTest::Test3D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/*  Check that INVALID_OPERATION is generated by TextureStorage3D if texture
	 is not the name of an existing texture object. */
	{
		gl.textureStorage3D(m_to_invalid, 1, GL_R8, 8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3D",
								  "texture is not the name of an existing texture object.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage3D if
	 internalformat is not a valid sized internal format. */
	{
		gl.textureStorage3D(m_to_3D, 1, m_internalformat_invalid, 8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureStorage3D",
								  "internalformat is not a valid sized internal format.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage3D if target or
	 the effective target of texture is not one of the accepted targets
	 described above. */
	{
		gl.textureStorage3D(m_to_1D, 1, GL_R8, 8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3D",
								  "the effective target of texture is not one of the accepted targets.");
	}

	/*  Check that INVALID_VALUE is generated by TextureStorage3D if width,
	 height, depth or levels are less than 1. */
	{
		gl.textureStorage3D(m_to_3D, 0, GL_R8, 8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3D", "levels is less than 1.");

		gl.textureStorage3D(m_to_3D, 1, GL_R8, 0, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3D", "width is less than 1.");

		gl.textureStorage3D(m_to_3D, 1, GL_R8, 8, 0, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3D", "height is less than 1.");

		gl.textureStorage3D(m_to_3D, 1, GL_R8, 8, 8, 0);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3D", "depth is less than 1.");
	}

	/* Check that INVALID_OPERATION is generated by TextureStorage3D if target
	 is TEXTURE_3D or PROXY_TEXTURE_3D and levels is greater than
	 log2(max(width, height, depth))+1. */
	{
		gl.textureStorage3D(m_to_3D, 8, GL_R8, 8, 8, 8);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3D",
								  "target is TEXTURE_3D and levels is greater than log2(max(width, height, depth))+1.");
	}

	/*  Check that INVALID_OPERATION is generated by TextureStorage3D if target
	 is TEXTURE_2D_ARRAY, PROXY_TEXTURE_2D_ARRAY, TEXURE_CUBE_ARRAY,
	 or PROXY_TEXTURE_CUBE_MAP_ARRAY and levels is greater than
	 log2(max(width, height))+1.  */
	{
		gl.textureStorage3D(m_to_2D_array, 6, GL_R8, 8, 8, 256);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3D",
								  "target is TEXTURE_2D_ARRAY and levels is greater than log2(max(width, height))+1.");
	}

	return is_ok;
}

/** @brief Test TextureStorage2DMultisample
 *
 *  @return Test result.
 */
bool StorageErrorsTest::Test2DMultisample()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/*  Check that INVALID_OPERATION is generated by TextureStorage2DMultisample
	 if texture is not the name of an existing texture object. */
	{
		gl.textureStorage2DMultisample(m_to_invalid, 1, GL_R8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2DMultisample",
								  "texture is not the name of an existing texture object.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage2DMultisample if
	 internalformat is not a valid color-renderable, depth-renderable or
	 stencil-renderable format. */
	{
		gl.textureStorage2DMultisample(m_to_2D_ms, 1, m_internalformat_invalid, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureStorage2DMultisample",
								  "internalformat is not a valid sized internal format.");
	}

	/*  Check that INVALID_OPERATION is generated by TextureStorage2DMultisample if
	 target or the effective target of texture is not one of the accepted
	 targets described above. */
	{
		gl.textureStorage2DMultisample(m_to_1D, 1, GL_R8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2DMultisample",
								  "the effective target of texture is not one of the accepted targets.");
	}

	/* Check that INVALID_VALUE is generated by TextureStorage2DMultisample if
	 width or height are less than 1 or greater than the value of
	 MAX_TEXTURE_SIZE. */
	{
		gl.textureStorage2DMultisample(m_to_2D_ms, 1, GL_R8, 0, 8, false);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2DMultisample", "width is less than 1.");

		gl.textureStorage2DMultisample(m_to_2D_ms, 1, GL_R8, 8, 0, false);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2DMultisample", "height is less than 1.");

		gl.textureStorage2DMultisample(m_to_2D_ms, 1, GL_R8, m_max_texture_size * 2, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2DMultisample",
								  "width is greater than the value of MAX_TEXTURE_SIZE.");

		gl.textureStorage2DMultisample(m_to_2D_ms, 1, GL_R8, 8, m_max_texture_size * 2, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage2DMultisample",
								  "height is greater than the value of MAX_TEXTURE_SIZE.");
	}

	/* Check that INVALID_OPERATION is generated by TextureStorage2DMultisample if
	 samples is greater than the value of MAX_SAMPLES. */
	{
		gl.textureStorage2DMultisample(m_to_2D_ms, m_max_samples * 2, GL_R8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2DMultisample",
								  "samples is greater than the value of MAX_SAMPLES.");
	}

	/* Check that INVALID_OPERATION is generated by TextureStorage2DMultisample
	 if the value of TEXTURE_IMMUTABLE_FORMAT for the texture bound to target
	 is not FALSE. */
	{
		gl.textureStorage2DMultisample(m_to_2D_ms_immutable, 1, GL_R8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage2DMultisample",
								  "samples is greater than the value of MAX_SAMPLES.");
	}

	return is_ok;
}

/** @brief Test TextureStorage3DMultisample
 *
 *  @return Test result.
 */
bool StorageErrorsTest::Test3DMultisample()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/*  Check that INVALID_OPERATION is generated by TextureStorage3DMultisample
	 if texture is not the name of an existing texture object. */
	{
		gl.textureStorage3DMultisample(m_to_invalid, 1, GL_R8, 8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3DMultisample",
								  "texture is not the name of an existing texture object.");
	}

	/*  Check that INVALID_ENUM is generated by TextureStorage3DMultisample if
	 internalformat is not a valid color-renderable, depth-renderable or
	 stencil-renderable format. */
	{
		gl.textureStorage3DMultisample(m_to_3D_ms, 1, m_internalformat_invalid, 8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureStorage3DMultisample",
								  "internalformat is not a valid sized internal format.");
	}

	/*  Check that INVALID_OPERATION is generated by TextureStorage3DMultisample if
	 target or the effective target of texture is not one of the accepted
	 targets described above. */
	{
		gl.textureStorage3DMultisample(m_to_1D, 1, GL_R8, 8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3DMultisample",
								  "the effective target of texture is not one of the accepted targets.");
	}

	/* Check that INVALID_VALUE is generated by TextureStorage3DMultisample if
	 width or height are less than 1 or greater than the value of
	 MAX_TEXTURE_SIZE. */
	{
		gl.textureStorage3DMultisample(m_to_3D_ms, 1, GL_R8, 0, 8, 8, false);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3DMultisample", "width is less than 1.");

		gl.textureStorage3DMultisample(m_to_3D_ms, 1, GL_R8, 8, 0, 8, false);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3DMultisample", "height is less than 1.");

		gl.textureStorage3DMultisample(m_to_3D_ms, 1, GL_R8, m_max_texture_size * 2, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3DMultisample",
								  "width is greater than the value of MAX_TEXTURE_SIZE.");

		gl.textureStorage3DMultisample(m_to_3D_ms, 1, GL_R8, 8, m_max_texture_size * 2, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3DMultisample",
								  "height is greater than the value of MAX_TEXTURE_SIZE.");
	}

	/* Check that INVALID_VALUE is generated by TextureStorage3DMultisample if
	 depth is less than 1 or greater than the value of
	 MAX_ARRAY_TEXTURE_LAYERS. */
	{
		gl.textureStorage3DMultisample(m_to_3D_ms, 1, GL_R8, 8, 8, 0, false);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3DMultisample", "depth is less than 1.");

		gl.textureStorage3DMultisample(m_to_3D_ms, 1, GL_R8, 8, 8, m_max_array_texture_layers * 2, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureStorage3DMultisample",
								  "depth is greater than the value of MAX_ARRAY_TEXTURE_LAYERS.");
	}

	/* Check that INVALID_VALUE is generated by TextureStorage3DMultisample if
	 samples is greater than the maximum number of samples reported for GL_R8 */
	{
		gl.textureStorage3DMultisample(m_to_3D_ms, m_max_samples * 2, GL_R8, 8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3DMultisample",
								  "samples is greater than the value of MAX_SAMPLES.");
	}

	/* Check that INVALID_OPERATION is generated by TextureStorage3DMultisample
	 if the value of TEXTURE_IMMUTABLE_FORMAT for the texture bound to target
	 is not FALSE. */
	{
		gl.textureStorage3DMultisample(m_to_3D_ms_immutable, 1, GL_R8, 8, 8, 8, false);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureStorage3DMultisample",
								  "samples is greater than the value of MAX_SAMPLES.");
	}

	return is_ok;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void StorageErrorsTest::Clean()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Cleanup. */
	if (m_to_1D)
	{
		gl.deleteTextures(1, &m_to_1D);

		m_to_1D = 0;
	}

	if (m_to_1D_array)
	{
		gl.deleteTextures(1, &m_to_1D_array);

		m_to_1D_array = 0;
	}

	if (m_to_2D)
	{
		gl.deleteTextures(1, &m_to_2D);

		m_to_2D = 0;
	}

	if (m_to_2D_array)
	{
		gl.deleteTextures(1, &m_to_2D_array);

		m_to_2D_array = 0;
	}

	if (m_to_3D)
	{
		gl.deleteTextures(1, &m_to_3D);

		m_to_3D = 0;
	}

	if (m_to_2D_ms)
	{
		gl.deleteTextures(1, &m_to_2D_ms);

		m_to_2D_ms = 0;
	}

	if (m_to_2D_ms_immutable)
	{
		gl.deleteTextures(1, &m_to_2D_ms_immutable);

		m_to_2D_ms_immutable = 0;
	}

	if (m_to_3D_ms)
	{
		gl.deleteTextures(1, &m_to_3D_ms);

		m_to_3D_ms = 0;
	}

	if (m_to_3D_ms_immutable)
	{
		gl.deleteTextures(1, &m_to_3D_ms_immutable);

		m_to_3D_ms_immutable = 0;
	}

	m_to_invalid			   = 0;
	m_internalformat_invalid   = 0;
	m_max_texture_size		   = 1;
	m_max_samples			   = 1;
	m_max_array_texture_layers = 1;

	while (GL_NO_ERROR != gl.getError())
		;
}

/******************************** Texture SubImage Errors Test Implementation   ********************************/

/** @brief Texture SubImage Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
SubImageErrorsTest::SubImageErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_subimage_errors", "Texture SubImage Errors Test")
	, m_to_1D_empty(0)
	, m_to_2D_empty(0)
	, m_to_3D_empty(0)
	, m_to_1D(0)
	, m_to_2D(0)
	, m_to_3D(0)
	, m_to_1D_compressed(0)
	, m_to_2D_compressed(0)
	, m_to_3D_compressed(0)
	, m_to_rectangle_compressed(0)
	, m_to_invalid(0)
	, m_bo(0)
	, m_format_invalid(0)
	, m_type_invalid(0)
	, m_max_texture_size(1)
	, m_reference_compressed_1D(DE_NULL)
	, m_reference_compressed_2D(DE_NULL)
	, m_reference_compressed_3D(DE_NULL)
	, m_reference_compressed_rectangle(DE_NULL)
	, m_reference_compressed_1D_size(0)
	, m_reference_compressed_2D_size(0)
	, m_reference_compressed_3D_size(0)
	, m_reference_compressed_rectangle_size(0)
	, m_reference_compressed_1D_format(0)
	, m_reference_compressed_2D_format(0)
	, m_reference_compressed_3D_format(0)
	, m_reference_compressed_rectangle_format(0)
	, m_not_matching_compressed_1D_format(0)
	, m_not_matching_compressed_1D_size(0)
	, m_not_matching_compressed_2D_format(0)
	, m_not_matching_compressed_2D_size(0)
	, m_not_matching_compressed_3D_format(0)
	, m_not_matching_compressed_3D_size(0)
{
	/* Intentionally left blank. */
}

/** @brief Iterate Texture SubImage Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult SubImageErrorsTest::iterate()
{
	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		Prepare();

		is_ok &= Test1D();
		is_ok &= Test2D();
		is_ok &= Test3D();
		is_ok &= Test1DCompressed();
		is_ok &= Test2DCompressed();
		is_ok &= Test3DCompressed();
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	Clean();

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Prepare test's objects.
 */
void SubImageErrorsTest::Prepare()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Auxiliary objects setup. */

	/* 1D */
	gl.createTextures(GL_TEXTURE_1D, 1, &m_to_1D_empty);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 2D */
	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_2D_empty);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 3D */
	gl.createTextures(GL_TEXTURE_3D, 1, &m_to_3D_empty);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 1D */
	gl.createTextures(GL_TEXTURE_1D, 1, &m_to_1D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_1D, m_to_1D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage1D(GL_TEXTURE_1D, 0, s_reference_internalformat, s_reference_width, 0, s_reference_format,
				  GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	/* 2D */
	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_2D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_2D, m_to_2D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, s_reference_internalformat, s_reference_width, s_reference_height, 0,
				  s_reference_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	/* 3D */
	gl.createTextures(GL_TEXTURE_3D, 1, &m_to_3D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_3D, m_to_3D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage3D(GL_TEXTURE_3D, 0, s_reference_internalformat, s_reference_width, s_reference_height,
				  s_reference_depth, 0, s_reference_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	/* 1D Compressed */
	gl.createTextures(GL_TEXTURE_1D, 1, &m_to_1D_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_1D, m_to_1D_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage1D(GL_TEXTURE_1D, 0, s_reference_internalformat_compressed, s_reference_width, 0, s_reference_format,
				  GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	glw::GLint is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_1D, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_1D, 0, GL_TEXTURE_INTERNAL_FORMAT, &m_reference_compressed_1D_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_reference_compressed_1D_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_1D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &m_reference_compressed_1D_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		if (m_reference_compressed_1D_size)
		{
			m_reference_compressed_1D = new glw::GLubyte[m_reference_compressed_1D_size];

			gl.getCompressedTexImage(GL_TEXTURE_1D, 0, m_reference_compressed_1D);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");
		}
	}

	/* 2D Compressed */
	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_2D_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_2D, m_to_2D_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, s_reference_internalformat_compressed, s_reference_width, s_reference_height, 0,
				  s_reference_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

	is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &m_reference_compressed_2D_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_reference_compressed_2D_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, &m_reference_compressed_2D_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		if (m_reference_compressed_2D_size)
		{
			m_reference_compressed_2D = new glw::GLubyte[m_reference_compressed_2D_size];

			gl.getCompressedTexImage(GL_TEXTURE_2D, 0, m_reference_compressed_2D);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");
		}
	}

	/* 3D Compressed */
	gl.createTextures(GL_TEXTURE_2D_ARRAY, 1, &m_to_3D_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_to_3D_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage3D(GL_TEXTURE_2D_ARRAY, 0, s_reference_internalformat_compressed, s_reference_width, s_reference_height,
				  s_reference_depth, 0, s_reference_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage3D has failed");

	is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_INTERNAL_FORMAT,
								  &m_reference_compressed_3D_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_reference_compressed_3D_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_2D_ARRAY, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
								  &m_reference_compressed_3D_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		if (m_reference_compressed_3D_size)
		{
			m_reference_compressed_3D = new glw::GLubyte[m_reference_compressed_3D_size];

			gl.getCompressedTexImage(GL_TEXTURE_2D_ARRAY, 0, m_reference_compressed_3D);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");
		}
	}

	/* RECTANGLE Compressed */
	gl.createTextures(GL_TEXTURE_RECTANGLE, 1, &m_to_rectangle_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_RECTANGLE, m_to_rectangle_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_RECTANGLE, 0, s_reference_internalformat_compressed, s_reference_width, s_reference_height,
				  0, s_reference_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

	is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_RECTANGLE, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_RECTANGLE, 0, GL_TEXTURE_INTERNAL_FORMAT,
								  &m_reference_compressed_rectangle_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_reference_compressed_rectangle_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_RECTANGLE, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
								  &m_reference_compressed_rectangle_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		if (m_reference_compressed_rectangle_size)
		{
			m_reference_compressed_rectangle = new glw::GLubyte[m_reference_compressed_rectangle_size];

			gl.getCompressedTexImage(GL_TEXTURE_RECTANGLE, 0, m_reference_compressed_rectangle);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glGetCompressedTexImage has failed");
		}
	}

	/* Buffer object */
	gl.createBuffers(1, &m_bo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateBuffers has failed");

	gl.namedBufferData(m_bo, s_reference_size, s_reference, GL_STATIC_COPY);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData has failed");

	/* Invalid values */

	/* invalid texture object */
	while (gl.isTexture(++m_to_invalid))
		;
	GLU_EXPECT_NO_ERROR(gl.getError(), "glIsTexture has failed");

	/* invalid internal format */
	static const glw::GLenum all_formats[] = { GL_STENCIL_INDEX,
											   GL_DEPTH_COMPONENT,
											   GL_DEPTH_STENCIL,
											   GL_RED,
											   GL_GREEN,
											   GL_BLUE,
											   GL_RG,
											   GL_RGB,
											   GL_RGBA,
											   GL_BGR,
											   GL_BGRA,
											   GL_RED_INTEGER,
											   GL_GREEN_INTEGER,
											   GL_BLUE_INTEGER,
											   GL_RG_INTEGER,
											   GL_RGB_INTEGER,
											   GL_RGBA_INTEGER,
											   GL_BGR_INTEGER,
											   GL_BGRA_INTEGER };

	static const glw::GLuint all_internal_formats_count = sizeof(all_formats) / sizeof(all_formats[0]);

	bool is_valid	= true;
	m_format_invalid = 0;

	while (is_valid)
	{
		is_valid = false;
		m_format_invalid++;
		for (glw::GLuint i = 0; i < all_internal_formats_count; ++i)
		{
			if (all_formats[i] == m_format_invalid)
			{
				is_valid = true;
				break;
			}
		}
	}

	/* Invalid type. */
	static const glw::GLenum all_types[] = { GL_UNSIGNED_BYTE,
											 GL_BYTE,
											 GL_UNSIGNED_SHORT,
											 GL_SHORT,
											 GL_UNSIGNED_INT,
											 GL_INT,
											 GL_HALF_FLOAT,
											 GL_FLOAT,
											 GL_UNSIGNED_BYTE_3_3_2,
											 GL_UNSIGNED_BYTE_2_3_3_REV,
											 GL_UNSIGNED_SHORT_5_6_5,
											 GL_UNSIGNED_SHORT_5_6_5_REV,
											 GL_UNSIGNED_SHORT_4_4_4_4,
											 GL_UNSIGNED_SHORT_4_4_4_4_REV,
											 GL_UNSIGNED_SHORT_5_5_5_1,
											 GL_UNSIGNED_SHORT_1_5_5_5_REV,
											 GL_UNSIGNED_INT_8_8_8_8,
											 GL_UNSIGNED_INT_8_8_8_8_REV,
											 GL_UNSIGNED_INT_10_10_10_2,
											 GL_UNSIGNED_INT_2_10_10_10_REV,
											 GL_UNSIGNED_INT_24_8,
											 GL_UNSIGNED_INT_10F_11F_11F_REV,
											 GL_UNSIGNED_INT_5_9_9_9_REV,
											 GL_FLOAT_32_UNSIGNED_INT_24_8_REV };

	static const glw::GLuint all_types_count = sizeof(all_types) / sizeof(all_types[0]);

	is_valid	   = true;
	m_type_invalid = 0;

	while (is_valid)
	{
		is_valid = false;
		m_type_invalid++;
		for (glw::GLuint i = 0; i < all_types_count; ++i)
		{
			if (all_types[i] == m_type_invalid)
			{
				is_valid = true;
				break;
			}
		}
	}

	/* Maximum texture size.*/
	gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &m_max_texture_size);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv has failed");

	glw::GLenum not_matching_format					   = GL_RED;
	glw::GLenum not_matching_internalformat_compressed = GL_COMPRESSED_RED;

	/* 1D Compressed with a non matching format. We need to do all the allocation to get the correct image size */
	glw::GLuint to_1D_compressed_not_matching;

	gl.createTextures(GL_TEXTURE_1D, 1, &to_1D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_1D, to_1D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage1D(GL_TEXTURE_1D, 0, not_matching_internalformat_compressed, s_reference_width, 0, s_reference_format,
				  GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage1D has failed");

	is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_1D, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_1D, 0, GL_TEXTURE_INTERNAL_FORMAT, &m_not_matching_compressed_1D_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_not_matching_compressed_1D_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_1D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
								  &m_not_matching_compressed_1D_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");
	}

	gl.deleteTextures(1, &to_1D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 2D Compressed with a non matching format. We need to do all the allocation to get the correct image size */
	glw::GLuint to_2D_compressed_not_matching;

	gl.createTextures(GL_TEXTURE_2D, 1, &to_2D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_2D, to_2D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage2D(GL_TEXTURE_2D, 0, not_matching_internalformat_compressed, s_reference_width, s_reference_height, 0,
				  not_matching_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

	is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_INTERNAL_FORMAT, &m_not_matching_compressed_2D_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_not_matching_compressed_2D_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
								  &m_not_matching_compressed_2D_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");
	}

	gl.deleteTextures(1, &to_2D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 3D Compressed with a non matching format. We need to do all the allocation to get the correct image size */
	glw::GLuint to_3D_compressed_not_matching;

	gl.createTextures(GL_TEXTURE_3D, 1, &to_3D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.bindTexture(GL_TEXTURE_3D, to_3D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

	gl.texImage3D(GL_TEXTURE_3D, 0, not_matching_internalformat_compressed, s_reference_width, s_reference_height,
				  s_reference_depth, 0, not_matching_format, GL_UNSIGNED_BYTE, s_reference);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage3D has failed");

	is_compressed = 0;

	gl.getTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_COMPRESSED, &is_compressed);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTetTexLevelParameteriv has failed");

	if (is_compressed)
	{
		gl.getTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_INTERNAL_FORMAT, &m_not_matching_compressed_3D_format);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");

		m_not_matching_compressed_3D_size = 0;

		gl.getTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
								  &m_not_matching_compressed_3D_size);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetTexLevelParameteriv has failed");
	}

	gl.deleteTextures(1, &to_3D_compressed_not_matching);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");
}

/** @brief Test (negative) of TextureSubImage1D
 *
 *  @return Test result.
 */
bool SubImageErrorsTest::Test1D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Check that INVALID_OPERATION is generated by TextureSubImage1D if
	 texture is not the name of an existing texture object. */
	{
		gl.textureSubImage1D(m_to_invalid, 0, 0, s_reference_width, s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_ENUM is generated by TextureSubImage1D if format is
	 not an accepted format constant. */
	{
		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, m_format_invalid, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureSubImage1D",
								  "format is not an accepted format constant.");
	}

	/* Check that INVALID_ENUM is generated by TextureSubImage1D if type is not
	 an accepted type constant. */
	{
		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, m_type_invalid, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureSubImage1D",
								  "type is not an accepted type constant.");
	}

	/* Check that INVALID_VALUE is generated by TextureSubImage1D if level is
	 less than 0. */
	{
		gl.textureSubImage1D(m_to_1D, -1, 0, s_reference_width, s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D", "level is less than 0.");
	}

	/* Check that INVALID_VALUE may be generated by TextureSubImage1D if level
	 is greater than log2 max, where max is the returned value of
	 MAX_TEXTURE_SIZE. */
	{
		gl.textureSubImage1D(m_to_1D, m_max_texture_size, 0, s_reference_width, s_reference_format, s_reference_type,
							 s_reference);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D",
							 "level is greater than log2 max, where max is the returned value of MAX_TEXTURE_SIZE.");
	}

	/* Check that INVALID_VALUE is generated by TextureSubImage1D if
	 xoffset<-b, or if (xoffset+width)>(w-b), where w is the TEXTURE_WIDTH,
	 and b is the width of the TEXTURE_BORDER of the texture image being
	 modified. Note that w includes twice the border width. */
	{
		gl.textureSubImage1D(m_to_1D, 0, -1, s_reference_width, s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D",
								  "xoffset<-b, where b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage1D(m_to_1D, 0, 1, s_reference_width + 1, s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_VALUE, "glTextureSubImage1D",
			"(xoffset+width)>(w-b), where w is the TEXTURE_WIDTH, b is the width of the TEXTURE_BORDER.");
	}

	/*Check that INVALID_VALUE is generated by TextureSubImage1D if width is less than 0. */
	{
#ifndef TURN_OFF_SUB_IMAGE_ERRORS_TEST_OF_NEGATIVE_WIDTH_HEIGHT_OR_DEPTH
		gl.textureSubImage1D(m_to_1D, 0, 0, -1, s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D", "width is less than 0.");
#endif
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage1D if type
	 is one of UNSIGNED_BYTE_3_3_2, UNSIGNED_BYTE_2_3_3_REV,
	 UNSIGNED_SHORT_5_6_5, or UNSIGNED_SHORT_5_6_5_REV and format is not RGB. */
	{
		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_BYTE_3_3_2, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_BYTE_3_3_2 and format is not RGB.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_BYTE_2_3_3_REV,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_BYTE_2_3_3_REV and format is not RGB.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_SHORT_5_6_5,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_SHORT_5_6_5 and format is not RGB.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_SHORT_5_6_5_REV,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_SHORT_5_6_5_REV and format is not RGB.");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage1D if type
	 is one of UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_4_4_4_4_REV,
	 UNSIGNED_SHORT_5_5_5_1, UNSIGNED_SHORT_1_5_5_5_REV,
	 UNSIGNED_INT_8_8_8_8, UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2,
	 or UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA. */
	{
		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_SHORT_4_4_4_4,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_SHORT_4_4_4_4 and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_SHORT_4_4_4_4_REV,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_SHORT_4_4_4_4_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_SHORT_5_5_5_1,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_SHORT_5_5_5_1 and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_SHORT_1_5_5_5_REV,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_SHORT_1_5_5_5_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_INT_8_8_8_8,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_INT_8_8_8_8 and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_INT_8_8_8_8_REV,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_INT_8_8_8_8_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_INT_10_10_10_2,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_INT_10_10_10_2 and format is neither RGBA nor BGRA.");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, GL_UNSIGNED_INT_2_10_10_10_REV,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "type is UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA.");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage1D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and the buffer object's data store is currently mapped. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.mapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_READ_WRITE);

		if (GL_NO_ERROR == gl.getError())
		{
			gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, s_reference_type, NULL);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
									  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and "
									  "the buffer object's data store is currently mapped.");

			gl.unmapBuffer(GL_PIXEL_UNPACK_BUFFER);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
		}
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage1D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and the data would be unpacked from the buffer object such that the
	 memory reads required would exceed the data store size. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, s_reference_type,
							 glu::BufferOffsetAsPointer(s_reference_size * 2));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and the "
								  "data would be unpacked from the buffer object such that the memory reads required "
								  "would exceed the data store size.");

		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage1D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and pixels is not evenly divisible into the number of bytes needed to
	 store in memory a datum indicated by type. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.textureSubImage1D(m_to_1D, 0, 0, s_reference_width, s_reference_format, s_reference_type,
							 glu::BufferOffsetAsPointer(1));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage1D",
								  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and pixels "
								  "is not evenly divisible into the number of bytes needed to store in memory a datum "
								  "indicated by type.");

		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureSubImage2D
 *
 *  @return Test result.
 */
bool SubImageErrorsTest::Test2D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Check that INVALID_OPERATION is generated by TextureSubImage2D if
	 texture is not the name of an existing texture object. */
	{
		gl.textureSubImage2D(m_to_invalid, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_ENUM is generated by TextureSubImage2D if format is
	 not an accepted format constant. */
	{
		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, m_format_invalid,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureSubImage2D",
								  "format is not an accepted format constant.");
	}

	/* Check that INVALID_ENUM is generated by TextureSubImage2D if type is not
	 an accepted type constant. */
	{
		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 m_type_invalid, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureSubImage2D",
								  "type is not an accepted type constant.");
	}

	/* Check that INVALID_VALUE is generated by TextureSubImage2D if level is
	 less than 0. */
	{
		gl.textureSubImage2D(m_to_2D, -1, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage2D", "level is less than 0.");
	}

	/* Check that INVALID_VALUE may be generated by TextureSubImage2D if level
	 is greater than log2 max, where max is the returned value of
	 MAX_TEXTURE_SIZE. */
	{
		gl.textureSubImage2D(m_to_2D, m_max_texture_size, 0, 0, s_reference_width, s_reference_height,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage2D",
							 "level is greater than log2 max, where max is the returned value of MAX_TEXTURE_SIZE.");
	}

	/* Check that INVALID_VALUE may be generated by TextureSubImage2D if level
	 is greater than log2 max, where max is the returned value of
	 MAX_TEXTURE_SIZE.
	 Check that INVALID_VALUE is generated by TextureSubImage2D if
	 xoffset<-b, (xoffset+width)>(w-b), yoffset<-b, or
	 (yoffset+height)>(h-b), where w is the TEXTURE_WIDTH, h is the
	 TEXTURE_HEIGHT, and b is the border width of the texture image being
	 modified. Note that w and h include twice the border width. */
	{
		gl.textureSubImage2D(m_to_2D, 0, -1, 0, s_reference_width, s_reference_height, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage2D",
								  "xoffset<-b, where b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage2D(m_to_2D, 0, 1, 0, s_reference_width + 1, s_reference_height, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_VALUE, "glTextureSubImage2D",
			"(xoffset+width)>(w-b), where w is the TEXTURE_WIDTH, b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage2D(m_to_2D, 0, 0, -1, s_reference_width, s_reference_height, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage2D",
								  "yoffset<-b, where b is the height of the TEXTURE_BORDER.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 1, s_reference_width + 1, s_reference_height, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_VALUE, "glTextureSubImage2D",
			"(yoffset+height)>(h-b), where h is the TEXTURE_HEIGHT, b is the width of the TEXTURE_BORDER.");
	}

	/*Check that INVALID_VALUE is generated by TextureSubImage2D if width or height is less than 0. */
	{
#ifndef TURN_OFF_SUB_IMAGE_ERRORS_TEST_OF_NEGATIVE_WIDTH_HEIGHT_OR_DEPTH
		gl.textureSubImage2D(m_to_2D, 0, 0, 0, -1, s_reference_height, s_reference_format, s_reference_type,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage2D", "width is less than 0.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, -1, s_reference_format, s_reference_type,
							 s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage2D", "height is less than 0.");
#endif
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage2D if type
	 is one of UNSIGNED_BYTE_3_3_2, UNSIGNED_BYTE_2_3_3_REV,
	 UNSIGNED_SHORT_5_6_5, or UNSIGNED_SHORT_5_6_5_REV and format is not RGB. */
	{
		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_BYTE_3_3_2, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_BYTE_3_3_2 and format is not RGB.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_BYTE_2_3_3_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_BYTE_2_3_3_REV and format is not RGB.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_SHORT_5_6_5, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_SHORT_5_6_5 and format is not RGB.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_SHORT_5_6_5_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_SHORT_5_6_5_REV and format is not RGB.");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage2D if type
	 is one of UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_4_4_4_4_REV,
	 UNSIGNED_SHORT_5_5_5_1, UNSIGNED_SHORT_1_5_5_5_REV,
	 UNSIGNED_INT_8_8_8_8, UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2,
	 or UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA. */
	{
		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_SHORT_4_4_4_4, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_SHORT_4_4_4_4 and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_SHORT_4_4_4_4_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_SHORT_4_4_4_4_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_SHORT_5_5_5_1, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_SHORT_5_5_5_1 and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_SHORT_1_5_5_5_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_SHORT_1_5_5_5_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_INT_8_8_8_8, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_INT_8_8_8_8 and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_INT_8_8_8_8_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_INT_8_8_8_8_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_INT_10_10_10_2, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_INT_10_10_10_2 and format is neither RGBA nor BGRA.");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 GL_UNSIGNED_INT_2_10_10_10_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "type is UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA.");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage2D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and the buffer object's data store is currently mapped. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.mapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_READ_WRITE);

		if (GL_NO_ERROR == gl.getError())
		{
			gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
								 s_reference_type, NULL);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
									  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and "
									  "the buffer object's data store is currently mapped.");

			gl.unmapBuffer(GL_PIXEL_UNPACK_BUFFER);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
		}
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage2D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and the data would be unpacked from the buffer object such that the
	 memory reads required would exceed the data store size. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 s_reference_type, glu::BufferOffsetAsPointer(s_reference_size * 2));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and the "
								  "data would be unpacked from the buffer object such that the memory reads required "
								  "would exceed the data store size.");

		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage2D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and pixels is not evenly divisible into the number of bytes needed to
	 store in memory a datum indicated by type. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.textureSubImage2D(m_to_2D, 0, 0, 0, s_reference_width, s_reference_height, s_reference_format,
							 s_reference_type, glu::BufferOffsetAsPointer(1));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage2D",
								  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and pixels "
								  "is not evenly divisible into the number of bytes needed to store in memory a datum "
								  "indicated by type.");

		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureSubImage3D
 *
 *  @return Test result.
 */
bool SubImageErrorsTest::Test3D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Check that INVALID_OPERATION is generated by TextureSubImage3D if
	 texture is not the name of an existing texture object. */
	{
		gl.textureSubImage3D(m_to_invalid, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_ENUM is generated by TextureSubImage3D if format is
	 not an accepted format constant. */
	{
		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 m_format_invalid, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureSubImage3D",
								  "format is not an accepted format constant.");
	}

	/* Check that INVALID_ENUM is generated by TextureSubImage3D if type is not
	 an accepted type constant. */
	{
		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, m_type_invalid, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureSubImage3D",
								  "type is not an accepted type constant.");
	}

	/* Check that INVALID_VALUE is generated by TextureSubImage3D if level is
	 less than 0. */
	{
		gl.textureSubImage3D(m_to_3D, -1, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage3D", "level is less than 0.");
	}

	/* Check that INVALID_VALUE may be generated by TextureSubImage1D if level
	 is greater than log2 max, where max is the returned value of
	 MAX_TEXTURE_SIZE. */
	{
		gl.textureSubImage3D(m_to_3D, m_max_texture_size, 0, 0, 0, s_reference_width, s_reference_height,
							 s_reference_depth, s_reference_format, s_reference_type, s_reference);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
							 "level is greater than log2 max, where max is the returned value of MAX_TEXTURE_SIZE.");
	}

	/* Check that INVALID_VALUE is generated by TextureSubImage3D if
	 xoffset<-b, (xoffset+width)>(w-b), yoffset<-b, or
	 (yoffset+height)>(h-b), or zoffset<-b, or (zoffset+depth)>(d-b), where w
	 is the TEXTURE_WIDTH, h is the TEXTURE_HEIGHT, d is the TEXTURE_DEPTH
	 and b is the border width of the texture image being modified. Note
	 that w, h, and d include twice the border width. */
	{
		gl.textureSubImage3D(m_to_3D, 0, -1, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
								  "xoffset<-b, where b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage3D(m_to_3D, 0, 1, 0, 0, s_reference_width + 1, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
			"(xoffset+width)>(w-b), where w is the TEXTURE_WIDTH, b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage3D(m_to_3D, 0, 0, -1, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
								  "yoffset<-b, where b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 1, 0, s_reference_width + 1, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
			"(yoffset+height)>(h-b), where h is the TEXTURE_HEIGHT, b is the width of the TEXTURE_BORDER.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, -1, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
								  "zoffset<-b, where b is the depth of the TEXTURE_BORDER.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 1, s_reference_width + 1, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_VALUE, "glTextureSubImage3D",
			"(zoffset+width)>(d-b), where d is the TEXTURE_DEPTH, b is the width of the TEXTURE_BORDER.");
	}

	/*Check that INVALID_VALUE is generated by TextureSubImage3D if width or height or depth is less than 0. */
	{
#ifndef TURN_OFF_SUB_IMAGE_ERRORS_TEST_OF_NEGATIVE_WIDTH_HEIGHT_OR_DEPTH
		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, -1, s_reference_height, s_reference_depth, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D", "width is less than 0.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, -1, s_reference_depth, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D", "height is less than 0.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, -1, s_reference_format,
							 s_reference_type, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureSubImage1D", "depth is less than 0.");
#endif
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage3D if type
	 is one of UNSIGNED_BYTE_3_3_2, UNSIGNED_BYTE_2_3_3_REV,
	 UNSIGNED_SHORT_5_6_5, or UNSIGNED_SHORT_5_6_5_REV and format is not RGB. */
	{
		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_BYTE_3_3_2, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_BYTE_3_3_2 and format is not RGB.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_BYTE_2_3_3_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_BYTE_2_3_3_REV and format is not RGB.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_SHORT_5_6_5, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_SHORT_5_6_5 and format is not RGB.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_SHORT_5_6_5_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_SHORT_5_6_5_REV and format is not RGB.");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage3D if type
	 is one of UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_4_4_4_4_REV,
	 UNSIGNED_SHORT_5_5_5_1, UNSIGNED_SHORT_1_5_5_5_REV,
	 UNSIGNED_INT_8_8_8_8, UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2,
	 or UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA. */
	{
		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_SHORT_4_4_4_4, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_SHORT_4_4_4_4 and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_SHORT_4_4_4_4_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_SHORT_4_4_4_4_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_SHORT_5_5_5_1, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_SHORT_5_5_5_1 and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_SHORT_1_5_5_5_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_SHORT_1_5_5_5_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_INT_8_8_8_8, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_INT_8_8_8_8 and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_INT_8_8_8_8_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_INT_8_8_8_8_REV and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_INT_10_10_10_2, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_INT_10_10_10_2 and format is neither RGBA nor BGRA.");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, GL_UNSIGNED_INT_2_10_10_10_REV, s_reference);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "type is UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA.");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage3D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and the buffer object's data store is currently mapped. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.mapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_READ_WRITE);

		if (GL_NO_ERROR == gl.getError())
		{
			gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
								 s_reference_format, s_reference_type, NULL);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
									  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and "
									  "the buffer object's data store is currently mapped.");

			gl.unmapBuffer(GL_PIXEL_UNPACK_BUFFER);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
		}
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage3D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and the data would be unpacked from the buffer object such that the
	 memory reads required would exceed the data store size. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, glu::BufferOffsetAsPointer(s_reference_size * 2));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and the "
								  "data would be unpacked from the buffer object such that the memory reads required "
								  "would exceed the data store size.");

		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}

	/* Check that INVALID_OPERATION is generated by TextureSubImage3D if a
	 non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
	 and pixels is not evenly divisible into the number of bytes needed to
	 store in memory a datum indicated by type. */
	{
		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.textureSubImage3D(m_to_3D, 0, 0, 0, 0, s_reference_width, s_reference_height, s_reference_depth,
							 s_reference_format, s_reference_type, glu::BufferOffsetAsPointer(1));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureSubImage3D",
								  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and pixels "
								  "is not evenly divisible into the number of bytes needed to store in memory a datum "
								  "indicated by type.");

		gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureSubImage1DCompressed
 *
 *  @return Test result.
 */
bool SubImageErrorsTest::Test1DCompressed()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Do tests only if compressed 1D textures are supported. */
	if (DE_NULL != m_reference_compressed_1D)
	{
		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
		 if texture is not the name of an existing texture object. */
		{
			gl.compressedTextureSubImage1D(m_to_invalid, 0, 0, s_reference_width, m_reference_compressed_1D_format,
										   m_reference_compressed_1D_size, m_reference_compressed_1D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage1D",
									  "texture is not the name of an existing texture object.");
		}

		/* Check that INVALID_ENUM is generated by CompressedTextureSubImage1D if
		 internalformat is not one of the generic compressed internal formats:
		 COMPRESSED_RED, COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA.
		 COMPRESSED_SRGB, or COMPRESSED_SRGB_ALPHA. */
		{
			/* GL_COMPRESSED_RG_RGTC2 is not 1D as specification says. */
			gl.compressedTextureSubImage1D(m_to_1D_compressed, 0, 0, s_reference_width, GL_COMPRESSED_RG_RGTC2,
										   m_reference_compressed_1D_size, m_reference_compressed_1D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glCompressedTextureSubImage1D",
									  "internalformat is of the generic compressed internal formats: COMPRESSED_RED, "
									  "COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA. COMPRESSED_SRGB, or "
									  "COMPRESSED_SRGB_ALPHA.");
		}

		/* Check that INVALID_OPERATION is generated if format does not match the
		 internal format of the texture image being modified, since these
		 commands do not provide for image format conversion. */
		{
			gl.compressedTextureSubImage1D(m_to_1D_compressed, 0, 0, s_reference_width,
										   m_not_matching_compressed_1D_format, m_not_matching_compressed_1D_size,
										   m_reference_compressed_1D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage1D",
									  "format does not match the internal format of the texture image being modified, "
									  "since these commands do not provide for image format conversion.");
		}

		/* Check that INVALID_VALUE is generated by CompressedTextureSubImage1D if
		 imageSize is not consistent with the format, dimensions, and contents of
		 the specified compressed image data. */
		{
			gl.compressedTextureSubImage1D(m_to_1D_compressed, 0, 0, s_reference_width,
										   m_reference_compressed_1D_format, m_reference_compressed_1D_size - 1,
										   m_reference_compressed_1D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCompressedTextureSubImage1D",
									  "imageSize is not consistent with the format, dimensions, and contents of the "
									  "specified compressed image data.");
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
		 if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
		 target and the buffer object's data store is currently mapped. */
		{
			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.mapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_READ_WRITE);

			if (GL_NO_ERROR == gl.getError())
			{
				gl.compressedTextureSubImage1D(m_to_1D_compressed, 0, 0, s_reference_width,
											   m_reference_compressed_1D_format, m_reference_compressed_1D_size, NULL);
				is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage1D",
										  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target "
										  "and the buffer object's data store is currently mapped.");

				gl.unmapBuffer(GL_PIXEL_UNPACK_BUFFER);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

				gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
			}
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
		 if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
		 target and the data would be unpacked from the buffer object such that
		 the memory reads required would exceed the data store size. */
		{
			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.compressedTextureSubImage1D(m_to_1D_compressed, 0, 0, s_reference_width,
										   m_reference_compressed_1D_format, m_reference_compressed_1D_size,
										   glu::BufferOffsetAsPointer(s_reference_size * 2));
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage1D",
									  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and "
									  "the buffer object's data store is currently mapped.");

			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
		}
	}

	return is_ok;
}

/** @brief Test (negative) of TextureSubImage2DCompressed
 *
 *  @return Test result.
 */
bool SubImageErrorsTest::Test2DCompressed()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Do tests only if compressed 2D textures are supported. */
	if (DE_NULL != m_reference_compressed_2D)
	{
		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
		 if texture is not the name of an existing texture object. */
		{
			gl.compressedTextureSubImage2D(m_to_invalid, 0, 0, 0, s_reference_width, s_reference_height,
										   m_reference_compressed_2D_format, m_reference_compressed_2D_size,
										   m_reference_compressed_2D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage2D",
									  "texture is not the name of an existing texture object.");
		}

		/* Check that INVALID_ENUM is generated by CompressedTextureSubImage2D if
		 internalformat is of the generic compressed internal formats:
		 COMPRESSED_RED, COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA.
		 COMPRESSED_SRGB, or COMPRESSED_SRGB_ALPHA. */
		{
			gl.compressedTextureSubImage2D(m_to_2D_compressed, 0, 0, 0, s_reference_width, s_reference_height,
										   GL_COMPRESSED_RG, m_reference_compressed_2D_size, m_reference_compressed_2D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glCompressedTextureSubImage2D",
									  "internalformat is of the generic compressed internal formats: COMPRESSED_RED, "
									  "COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA. COMPRESSED_SRGB, or "
									  "COMPRESSED_SRGB_ALPHA.");
		}

		/* Check that INVALID_OPERATION is generated if format does not match the
		 internal format of the texture image being modified, since these
		 commands do not provide for image format conversion. */
		{
			gl.compressedTextureSubImage2D(m_to_2D_compressed, 0, 0, 0, s_reference_width, s_reference_height,
										   m_not_matching_compressed_2D_format, m_not_matching_compressed_2D_size,
										   m_reference_compressed_2D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage2D",
									  "format does not match the internal format of the texture image being modified, "
									  "since these commands do not provide for image format conversion.");
		}

		/* Check that INVALID_VALUE is generated by CompressedTextureSubImage2D if
		 imageSize is not consistent with the format, dimensions, and contents of
		 the specified compressed image data. */
		{
			gl.compressedTextureSubImage2D(m_to_2D_compressed, 0, 0, 0, s_reference_width, s_reference_height,
										   m_reference_compressed_2D_format, m_reference_compressed_2D_size - 1,
										   m_reference_compressed_2D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCompressedTextureSubImage2D",
									  "imageSize is not consistent with the format, dimensions, and contents of the "
									  "specified compressed image data.");
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
		 if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
		 target and the buffer object's data store is currently mapped. */
		{
			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.mapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_READ_WRITE);

			if (GL_NO_ERROR == gl.getError())
			{
				gl.compressedTextureSubImage2D(m_to_2D_compressed, 0, 0, 0, s_reference_width, s_reference_height,
											   m_reference_compressed_2D_format, m_reference_compressed_2D_size, NULL);
				is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage2D",
										  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target "
										  "and the buffer object's data store is currently mapped.");

				gl.unmapBuffer(GL_PIXEL_UNPACK_BUFFER);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

				gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
			}
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
		 if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
		 target and the data would be unpacked from the buffer object such that
		 the memory reads required would exceed the data store size. */
		{
			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.compressedTextureSubImage2D(m_to_2D_compressed, 0, 0, 0, s_reference_width, s_reference_height,
										   m_reference_compressed_2D_format, m_reference_compressed_2D_size,
										   glu::BufferOffsetAsPointer(s_reference_size * 2));
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage2D",
									  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and "
									  "the buffer object's data store is currently mapped.");

			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
		 if the effective target is TEXTURE_RECTANGLE. */
		if (DE_NULL !=
			m_reference_compressed_rectangle) /* Do test only if rectangle compressed texture is supported by the implementation. */
		{
			gl.compressedTextureSubImage2D(m_to_rectangle_compressed, 0, 0, 0, s_reference_width, s_reference_height,
										   m_reference_compressed_rectangle_format,
										   m_reference_compressed_rectangle_size, m_reference_compressed_rectangle);

			if (m_context.getContextInfo().isExtensionSupported("GL_NV_texture_rectangle_compressed"))
			{
				is_ok &= CheckErrorAndLog(m_context, GL_NO_ERROR, "glCompressedTextureSubImage2D",
										  "a rectangle texture object is used with this function.");
			}
			else
			{
				is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage2D",
										  "a rectangle texture object is used with this function.");
			}
		}
	}

	return is_ok;
}

/** @brief Test (negative) of TextureSubImage3DCompressed
 *
 *  @return Test result.
 */
bool SubImageErrorsTest::Test3DCompressed()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Do tests only if compressed 3D textures are supported. */
	if (DE_NULL != m_reference_compressed_3D)
	{
		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
		 if texture is not the name of an existing texture object. */
		{
			gl.compressedTextureSubImage3D(m_to_invalid, 0, 0, 0, 0, s_reference_width, s_reference_height,
										   s_reference_depth, m_reference_compressed_3D_format,
										   m_reference_compressed_3D_size, m_reference_compressed_3D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage3D",
									  "texture is not the name of an existing texture object.");
		}

		/* Check that INVALID_ENUM is generated by CompressedTextureSubImage3D if
		 internalformat is of the generic compressed internal formats:
		 COMPRESSED_RED, COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA.
		 COMPRESSED_SRGB, or COMPRESSED_SRGB_ALPHA. */
		{
			gl.compressedTextureSubImage3D(m_to_3D_compressed, 0, 0, 0, 0, s_reference_width, s_reference_height,
										   s_reference_depth, GL_COMPRESSED_RG, m_reference_compressed_3D_size,
										   m_reference_compressed_3D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glCompressedTextureSubImage3D",
									  "internalformat is of the generic compressed internal formats: COMPRESSED_RED, "
									  "COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA. COMPRESSED_SRGB, or "
									  "COMPRESSED_SRGB_ALPHA.");
		}

		/* Check that INVALID_OPERATION is generated if format does not match the
		 internal format of the texture image being modified, since these
		 commands do not provide for image format conversion. */
		{
			gl.compressedTextureSubImage3D(m_to_3D_compressed, 0, 0, 0, 0, s_reference_width, s_reference_height,
										   s_reference_depth, m_not_matching_compressed_3D_format,
										   m_not_matching_compressed_3D_size, m_reference_compressed_3D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage3D",
									  "format does not match the internal format of the texture image being modified, "
									  "since these commands do not provide for image format conversion.");
		}

		/* Check that INVALID_VALUE is generated by CompressedTextureSubImage3D if
		 imageSize is not consistent with the format, dimensions, and contents of
		 the specified compressed image data. */
		{
			gl.compressedTextureSubImage3D(m_to_3D_compressed, 0, 0, 0, 0, s_reference_width, s_reference_height,
										   s_reference_depth, m_reference_compressed_3D_format,
										   m_reference_compressed_3D_size - 1, m_reference_compressed_3D);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCompressedTextureSubImage3D",
									  "imageSize is not consistent with the format, dimensions, and contents of the "
									  "specified compressed image data.");
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
		 if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
		 target and the buffer object's data store is currently mapped. */
		{
			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.mapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_READ_WRITE);

			if (GL_NO_ERROR == gl.getError())
			{
				gl.compressedTextureSubImage3D(m_to_3D_compressed, 0, 0, 0, 0, s_reference_width, s_reference_height,
											   s_reference_depth, m_reference_compressed_3D_format,
											   m_reference_compressed_3D_size, NULL);
				is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage3D",
										  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target "
										  "and the buffer object's data store is currently mapped.");

				gl.unmapBuffer(GL_PIXEL_UNPACK_BUFFER);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

				gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
			}
		}

		/* Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
		 if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
		 target and the data would be unpacked from the buffer object such that
		 the memory reads required would exceed the data store size. */
		{
			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, m_bo);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

			gl.compressedTextureSubImage3D(m_to_3D_compressed, 0, 0, 0, 0, s_reference_width, s_reference_height,
										   s_reference_depth, m_reference_compressed_3D_format,
										   m_reference_compressed_3D_size, glu::BufferOffsetAsPointer(s_reference_size * 2));
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCompressedTextureSubImage3D",
									  "a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target and "
									  "the buffer object's data store is currently mapped.");

			gl.bindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
		}
	}

	return is_ok;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void SubImageErrorsTest::Clean()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Cleanup. */
	if (m_to_1D_empty)
	{
		gl.deleteTextures(1, &m_to_1D_empty);

		m_to_1D_empty = 0;
	}

	if (m_to_2D_empty)
	{
		gl.deleteTextures(1, &m_to_2D_empty);

		m_to_2D_empty = 0;
	}

	if (m_to_3D_empty)
	{
		gl.deleteTextures(1, &m_to_3D_empty);

		m_to_3D_empty = 0;
	}

	if (m_to_1D)
	{
		gl.deleteTextures(1, &m_to_1D);

		m_to_1D = 0;
	}

	if (m_to_2D)
	{
		gl.deleteTextures(1, &m_to_2D);

		m_to_2D = 0;
	}

	if (m_to_3D)
	{
		gl.deleteTextures(1, &m_to_3D);

		m_to_3D = 0;
	}

	if (m_to_1D_compressed)
	{
		gl.deleteTextures(1, &m_to_1D_compressed);

		m_to_1D_compressed = 0;
	}

	if (m_to_2D_compressed)
	{
		gl.deleteTextures(1, &m_to_2D_compressed);

		m_to_2D_compressed = 0;
	}

	if (m_to_3D_compressed)
	{
		gl.deleteTextures(1, &m_to_3D_compressed);

		m_to_3D_compressed = 0;
	}

	if (m_to_rectangle_compressed)
	{
		gl.deleteTextures(1, &m_to_rectangle_compressed);

		m_to_rectangle_compressed = 0;
	}

	if (m_bo)
	{
		gl.deleteBuffers(1, &m_bo);

		m_bo = 0;
	}

	m_to_invalid	   = 0;
	m_format_invalid   = 0;
	m_type_invalid	 = 0;
	m_max_texture_size = 1;

	if (DE_NULL != m_reference_compressed_1D)
	{
		delete[] m_reference_compressed_1D;

		m_reference_compressed_1D = NULL;
	}

	if (DE_NULL != m_reference_compressed_2D)
	{
		delete[] m_reference_compressed_2D;

		m_reference_compressed_2D = NULL;
	}

	if (DE_NULL != m_reference_compressed_3D)
	{
		delete[] m_reference_compressed_3D;

		m_reference_compressed_3D = NULL;
	}

	if (DE_NULL != m_reference_compressed_rectangle)
	{
		delete[] m_reference_compressed_rectangle;

		m_reference_compressed_rectangle = NULL;
	}

	m_reference_compressed_1D_format		= 0;
	m_reference_compressed_2D_format		= 0;
	m_reference_compressed_3D_format		= 0;
	m_reference_compressed_rectangle_format = 0;
	m_reference_compressed_1D_size			= 0;
	m_reference_compressed_2D_size			= 0;
	m_reference_compressed_3D_size			= 0;
	m_reference_compressed_rectangle_size   = 0;
	m_not_matching_compressed_1D_format		= 0;
	m_not_matching_compressed_1D_size		= 0;
	m_not_matching_compressed_2D_format		= 0;
	m_not_matching_compressed_2D_size		= 0;
	m_not_matching_compressed_3D_format		= 0;
	m_not_matching_compressed_3D_size		= 0;

	while (GL_NO_ERROR != gl.getError())
		;
}

/** Reference data */
const glw::GLushort SubImageErrorsTest::s_reference[] = {
	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff,

	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff,

	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff,

	0x0,  0x0,  0x0,  0xff, 0x7f, 0x7f, 0x7f, 0xff, 0xc3, 0xc3, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff,
	0x88, 0x0,  0x15, 0xff, 0xed, 0x1c, 0x24, 0xff, 0xff, 0x7f, 0x27, 0xff, 0xff, 0xf2, 0x0,  0xff,
	0xc8, 0xbf, 0xe7, 0xff, 0x70, 0x92, 0xbe, 0xff, 0x99, 0xd9, 0xea, 0xff, 0xb5, 0xe6, 0x1d, 0xff,
	0xa3, 0x49, 0xa4, 0xff, 0x3f, 0x48, 0xcc, 0xff, 0x0,  0xa2, 0xe8, 0xff, 0x22, 0xb1, 0x4c, 0xff
};

/** Reference data parameters. */
const glw::GLuint SubImageErrorsTest::s_reference_size						= sizeof(s_reference);
const glw::GLuint SubImageErrorsTest::s_reference_width						= 4;
const glw::GLuint SubImageErrorsTest::s_reference_height					= 4;
const glw::GLuint SubImageErrorsTest::s_reference_depth						= 4;
const glw::GLenum SubImageErrorsTest::s_reference_internalformat			= GL_RG8;
const glw::GLenum SubImageErrorsTest::s_reference_internalformat_compressed = GL_COMPRESSED_RG;
const glw::GLenum SubImageErrorsTest::s_reference_format = GL_RG; /* !Must not be a RGB, RGBA, or BGRA */
const glw::GLenum SubImageErrorsTest::s_reference_type   = GL_UNSIGNED_SHORT;

/******************************** Copy Errors Test Implementation   ********************************/

/** @brief Copy Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
CopyErrorsTest::CopyErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_copy_errors", "Texture Copy Errors Test")
	, m_fbo(0)
	, m_fbo_ms(0)
	, m_fbo_incomplete(0)
	, m_to_src(0)
	, m_to_src_ms(0)
	, m_to_1D_dst(0)
	, m_to_2D_dst(0)
	, m_to_3D_dst(0)
	, m_to_invalid(0)
{
	/* Intentionally left blank. */
}

/** @brief Iterate Copy Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult CopyErrorsTest::iterate()
{
	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		Prepare();

		is_ok &= Test1D();
		is_ok &= Test2D();
		is_ok &= Test3D();
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	Clean();

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Prepare test's objects and values.
 */
void CopyErrorsTest::Prepare()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Auxiliary objects setup. */

	/* Framebuffer. */
	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_src);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage2D(m_to_src, 1, s_internalformat, s_width, s_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2D has failed");

	gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_src, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture1D call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	gl.viewport(0, 0, s_width, s_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");

	/* Framebuffer Multisample. */
	gl.genFramebuffers(1, &m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE, 1, &m_to_src_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage2DMultisample(m_to_src_ms, 1, s_internalformat, s_width, s_height, false);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2DMultisample has failed");

	gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_to_src_ms, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture1D call failed.");

	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
	{
		throw 0;
	}

	gl.viewport(0, 0, s_width, s_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport call failed.");

	gl.clear(GL_COLOR_BUFFER_BIT);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glClear call failed.");

	/* Framebuffer Incomplete. */
	gl.createFramebuffers(1, &m_fbo_incomplete);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glcreateFramebuffers call failed.");

	/* 1D */
	gl.createTextures(GL_TEXTURE_1D, 1, &m_to_1D_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage1D(m_to_1D_dst, 1, s_internalformat, s_width);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2D has failed");

	/* 2D */
	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_2D_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage2D(m_to_2D_dst, 1, s_internalformat, s_width, s_height);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2D has failed");

	/* 3D */
	gl.createTextures(GL_TEXTURE_3D, 1, &m_to_3D_dst);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	gl.textureStorage3D(m_to_3D_dst, 1, s_internalformat, s_width, s_height, s_depth);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2D has failed");

	/* invalid texture object */
	while (gl.isTexture(++m_to_invalid))
		;
	GLU_EXPECT_NO_ERROR(gl.getError(), "glIsTexture has failed");
}

/** @brief Test (negative) of CopyTextureSubImage1D
 *
 *  @return Test result.
 */
bool CopyErrorsTest::Test1D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Bind framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_incomplete);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_FRAMEBUFFER_OPERATION is generated by
	 CopyTextureSubImage1D if the object bound to READ_FRAMEBUFFER_BINDING is
	 not framebuffer complete. */
	{
		gl.copyTextureSubImage1D(m_to_1D_dst, 0, 0, 0, 0, s_width);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_FRAMEBUFFER_OPERATION, "glCopyTextureSubImage1D",
								  "the object bound to READ_FRAMEBUFFER_BINDING is not framebuffer complete.");
	}

	/* Bind framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage1D if
	 texture is not the name of an existing texture object, or if the
	 effective target of texture is not TEXTURE_1D. */
	{
		gl.copyTextureSubImage1D(m_to_invalid, 0, 0, 0, 0, s_width);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage1D",
								  "texture is not the name of an existing texture object.");

		gl.copyTextureSubImage1D(m_to_2D_dst, 0, 0, 0, 0, s_width);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage1D",
								  "the effective target of texture is not TEXTURE_1D.");
	}

	/* Check that INVALID_VALUE is generated by CopyTextureSubImage1D if level is less than 0. */
	{
		gl.copyTextureSubImage1D(m_to_1D_dst, -1, 0, 0, 0, s_width);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage1D", "level is less than 0.");
	}

	/* Check that INVALID_VALUE is generated by CopyTextureSubImage1D if
	 xoffset<0, or (xoffset+width)>w, where w is the TEXTURE_WIDTH of the
	 texture image being modified. */
	{
		gl.copyTextureSubImage1D(m_to_1D_dst, 0, -1, 0, 0, s_width);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage1D", "xoffset<0.");

		gl.copyTextureSubImage1D(m_to_1D_dst, 0, 1, 0, 0, s_width);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage1D",
							 "(xoffset+width)>w, where w is the TEXTURE_WIDTH of the texture image being modified.");
	}

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage1D if
	 the read buffer is NONE. */
	gl.readBuffer(GL_NONE);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	{
		gl.copyTextureSubImage1D(m_to_1D_dst, 0, 0, 0, 0, s_width);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage1D", "the read buffer is NONE.");
	}

	/* Bind multisample framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage1D if
	 the effective value of SAMPLE_BUFFERS for the read
	 framebuffer is one. */
	{
		gl.copyTextureSubImage1D(m_to_1D_dst, 0, 0, 0, 0, s_width);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage1D",
								  "the effective value of SAMPLE_BUFFERS for the read framebuffer is one.");
	}

	return is_ok;
}

/** @brief Test (negative) of CopyTextureSubImage2D
 *
 *  @return Test result.
 */
bool CopyErrorsTest::Test2D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Bind framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_incomplete);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_FRAMEBUFFER_OPERATION is generated by
	 CopyTextureSubImage2D if the object bound to READ_FRAMEBUFFER_BINDING is
	 not framebuffer complete. */
	{
		gl.copyTextureSubImage2D(m_to_2D_dst, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_FRAMEBUFFER_OPERATION, "glCopyTextureSubImage2D",
								  "the object bound to READ_FRAMEBUFFER_BINDING is not framebuffer complete.");
	}

	/* Bind framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage2D if
	 texture is not the name of an existing texture object, or if the
	 effective target of texture is not TEXTURE_2D. */
	{
		gl.copyTextureSubImage2D(m_to_invalid, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage2D",
								  "texture is not the name of an existing texture object.");

		gl.copyTextureSubImage2D(m_to_1D_dst, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage2D",
			"the effective target of does not correspond to one of the texture targets supported by the function..");
	}

	/* Check that INVALID_VALUE is generated by CopyTextureSubImage2D if level is less than 0. */
	{
		gl.copyTextureSubImage2D(m_to_2D_dst, -1, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage2D", "level is less than 0.");
	}

	/* Check that INVALID_VALUE is generated by CopyTextureSubImage2D if
	 xoffset<0, (xoffset+width)>w, yoffset<0, or (yoffset+height)>0, where w
	 is the TEXTURE_WIDTH, h is the TEXTURE_HEIGHT and of the texture image
	 being modified. */
	{
		gl.copyTextureSubImage2D(m_to_2D_dst, 0, -1, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage2D", "xoffset<0.");

		gl.copyTextureSubImage2D(m_to_2D_dst, 0, 1, 0, 0, 0, s_width, s_height);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage2D",
							 "(xoffset+width)>w, where w is the TEXTURE_WIDTH of the texture image being modified.");

		gl.copyTextureSubImage2D(m_to_2D_dst, 0, 0, -1, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage2D", "yoffset<0.");

		gl.copyTextureSubImage2D(m_to_2D_dst, 0, 0, 1, 0, 0, s_width, s_height);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage2D",
							 "(yoffset+height)>h, where h is the TEXTURE_HEIGHT of the texture image being modified.");
	}

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage2D if
	 the read buffer is NONE. */
	gl.readBuffer(GL_NONE);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	{
		gl.copyTextureSubImage2D(m_to_2D_dst, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage2D", "the read buffer is NONE.");
	}

	/* Bind multisample framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage2D if
	 the effective value of SAMPLE_BUFFERS for the read
	 framebuffer is one. */
	{
		gl.copyTextureSubImage2D(m_to_2D_dst, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage2D",
								  "the effective value of SAMPLE_BUFFERS for the read framebuffer is one.");
	}

	return is_ok;
}

/** @brief Test (negative) of CopyTextureSubImage3D
 *
 *  @return Test result.
 */
bool CopyErrorsTest::Test3D()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Bind framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_incomplete);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_FRAMEBUFFER_OPERATION is generated by
	 CopyTextureSubImage3D if the object bound to READ_FRAMEBUFFER_BINDING is
	 not framebuffer complete. */
	{
		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_FRAMEBUFFER_OPERATION, "glCopyTextureSubImage3D",
								  "the object bound to READ_FRAMEBUFFER_BINDING is not framebuffer complete.");
	}

	/* Bind framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage3D if
	 texture is not the name of an existing texture object, or if the
	 effective target of texture is not supported by the function. */
	{
		gl.copyTextureSubImage3D(m_to_invalid, 0, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage3D",
								  "texture is not the name of an existing texture object.");

		gl.copyTextureSubImage3D(m_to_1D_dst, 0, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage3D",
			"the effective target of does not correspond to one of the texture targets supported by the function..");
	}

	/* Check that INVALID_VALUE is generated by CopyTextureSubImage3D if level is less than 0. */
	{
		gl.copyTextureSubImage3D(m_to_3D_dst, -1, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D", "level is less than 0.");
	}

	/* Check that INVALID_VALUE is generated by CopyTextureSubImage3D if
	 xoffset<0, (xoffset+width)>w, yoffset<0, (yoffset+height)>h, zoffset<0,
	 or (zoffset+1)>d, where w is the TEXTURE_WIDTH, h is the TEXTURE_HEIGHT,
	 d is the TEXTURE_DEPTH and of the texture image being modified. Note
	 that w, h, and d include twice the border width.  */
	{
		gl.copyTextureSubImage3D(m_to_3D_dst, 0, -1, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D", "xoffset<0.");

		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 1, 0, 0, 0, 0, s_width, s_height);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D",
							 "(xoffset+width)>w, where w is the TEXTURE_WIDTH of the texture image being modified.");

		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, -1, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D", "yoffset<0.");

		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, 1, 0, 0, 0, s_width, s_height);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D",
							 "(yoffset+height)>h, where h is the TEXTURE_HEIGHT of the texture image being modified.");

		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, 0, -1, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D", "zoffset<0.");

		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, 0, s_depth + 1, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glCopyTextureSubImage3D",
								  "(zoffset+1)>d, where d is the TEXTURE_DEPTH of the texture image being modified.");
	}

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage3D if
	 the read buffer is NONE. */
	gl.readBuffer(GL_NONE);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	{
		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage3D", "the read buffer is NONE.");
	}

	/* Bind multisample framebuffer. */
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.readBuffer(GL_COLOR_ATTACHMENT0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	/* Check that INVALID_OPERATION is generated by CopyTextureSubImage3D if
	 the effective value of SAMPLE_BUFFERS for the read
	 framebuffer is one. */
	{
		gl.copyTextureSubImage3D(m_to_3D_dst, 0, 0, 0, 0, 0, 0, s_width, s_height);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glCopyTextureSubImage3D",
								  "the effective value of SAMPLE_BUFFERS for the read framebuffer is one.");
	}

	return is_ok;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void CopyErrorsTest::Clean()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Cleanup. */
	if (m_fbo)
	{
		gl.deleteFramebuffers(1, &m_fbo);

		m_fbo = 0;
	}

	if (m_fbo_ms)
	{
		gl.deleteFramebuffers(1, &m_fbo_ms);

		m_fbo_ms = 0;
	}

	if (m_fbo_incomplete)
	{
		gl.deleteFramebuffers(1, &m_fbo_incomplete);

		m_fbo_incomplete = 0;
	}

	if (m_to_src)
	{
		gl.deleteTextures(1, &m_to_src);

		m_to_src = 0;
	}

	if (m_to_src_ms)
	{
		gl.deleteTextures(1, &m_to_src_ms);

		m_to_src_ms = 0;
	}

	if (m_to_1D_dst)
	{
		gl.deleteTextures(1, &m_to_1D_dst);

		m_to_1D_dst = 0;
	}

	if (m_to_2D_dst)
	{
		gl.deleteTextures(1, &m_to_2D_dst);

		m_to_2D_dst = 0;
	}

	if (m_to_3D_dst)
	{
		gl.deleteTextures(1, &m_to_3D_dst);

		m_to_3D_dst = 0;
	}

	m_to_invalid = 0;

	while (GL_NO_ERROR != gl.getError())
		;
}

/* Test's parameters. */
const glw::GLuint CopyErrorsTest::s_width		   = 4;
const glw::GLuint CopyErrorsTest::s_height		   = 4;
const glw::GLuint CopyErrorsTest::s_depth		   = 4;
const glw::GLuint CopyErrorsTest::s_internalformat = GL_RGBA8;

/******************************** Parameter Setup Errors Test Implementation   ********************************/

/** @brief Parameter Setup Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
ParameterSetupErrorsTest::ParameterSetupErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_parameter_setup_errors", "Texture Parameter Setup Errors Test")
	, m_to_2D(0)
	, m_to_2D_ms(0)
	, m_to_rectangle(0)
	, m_to_invalid(0)
	, m_pname_invalid(0)
	, m_depth_stencil_mode_invalid(0)
{
	/* Intentionally left blank. */
}

/** @brief Iterate Parameter Setup Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult ParameterSetupErrorsTest::iterate()
{
	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	try
	{
		Prepare();

		is_ok &= Testf();
		is_ok &= Testi();
		is_ok &= Testfv();
		is_ok &= Testiv();
		is_ok &= TestIiv();
		is_ok &= TestIuiv();
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	Clean();

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** @brief Test's preparations.
 */
void ParameterSetupErrorsTest::Prepare()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Auxiliary objects setup. */

	/* 2D */
	gl.createTextures(GL_TEXTURE_2D, 1, &m_to_2D);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* 3D */
	gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE, 1, &m_to_2D_ms);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* RECTANGLE */
	gl.createTextures(GL_TEXTURE_RECTANGLE, 1, &m_to_rectangle);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateTextures has failed");

	/* Invalid texture object. */
	while (gl.isTexture(++m_to_invalid))
		;
	GLU_EXPECT_NO_ERROR(gl.getError(), "glIsTexture has failed");

	/* Invalid parameter name. */
	glw::GLenum all_pnames[] = { GL_DEPTH_STENCIL_TEXTURE_MODE,
								 GL_TEXTURE_BASE_LEVEL,
								 GL_TEXTURE_COMPARE_FUNC,
								 GL_TEXTURE_COMPARE_MODE,
								 GL_TEXTURE_LOD_BIAS,
								 GL_TEXTURE_MIN_FILTER,
								 GL_TEXTURE_MAG_FILTER,
								 GL_TEXTURE_MIN_LOD,
								 GL_TEXTURE_MAX_LOD,
								 GL_TEXTURE_MAX_LEVEL,
								 GL_TEXTURE_SWIZZLE_R,
								 GL_TEXTURE_SWIZZLE_G,
								 GL_TEXTURE_SWIZZLE_B,
								 GL_TEXTURE_SWIZZLE_A,
								 GL_TEXTURE_WRAP_S,
								 GL_TEXTURE_WRAP_T,
								 GL_TEXTURE_WRAP_R,
								 GL_TEXTURE_BORDER_COLOR,
								 GL_TEXTURE_SWIZZLE_RGBA };
	glw::GLuint all_pnames_count = sizeof(all_pnames) / sizeof(all_pnames[0]);

	bool is_valid = true;

	while (is_valid)
	{
		is_valid = false;
		++m_pname_invalid;

		for (glw::GLuint i = 0; i < all_pnames_count; ++i)
		{
			if (all_pnames[i] == m_pname_invalid)
			{
				is_valid = true;

				break;
			}
		}
	}

	/* Invalid depth stencil mode name. */
	glw::GLenum all_depth_stencil_modes[]	 = { GL_DEPTH_COMPONENT, GL_STENCIL_INDEX };
	glw::GLuint all_depth_stencil_modes_count = sizeof(all_depth_stencil_modes) / sizeof(all_depth_stencil_modes[0]);

	is_valid = true;

	while (is_valid)
	{
		is_valid = false;
		++m_depth_stencil_mode_invalid;

		for (glw::GLuint i = 0; i < all_depth_stencil_modes_count; ++i)
		{
			if (all_depth_stencil_modes[i] == m_depth_stencil_mode_invalid)
			{
				is_valid = true;

				break;
			}
		}
	}
}

/** @brief Test (negative) of TextureParameterf
 *
 *  @return Test result.
 */
bool ParameterSetupErrorsTest::Testf()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Check that INVALID_ENUM is generated by TextureParameter* if pname is
	 not one of the accepted defined values. */
	{
		gl.textureParameterf(m_to_2D, m_pname_invalid, 1.f);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterf",
								  "pname is not one of the accepted defined values.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if params
	 should have a defined constant value (based on the value of pname) and
	 does not. */
	{
		gl.textureParameterf(m_to_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, (glw::GLfloat)m_depth_stencil_mode_invalid);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterf",
							 "params should have a defined constant value (based on the value of pname) and does not.");
	}
	/* Check that INVALID_ENUM is generated if TextureParameter{if} is called
	 for a non-scalar parameter (pname TEXTURE_BORDER_COLOR or
	 TEXTURE_SWIZZLE_RGBA). */
	{
		gl.textureParameterf(m_to_2D, GL_TEXTURE_BORDER_COLOR, 1.f);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterf",
							 "called for a non-scalar parameter (pname TEXTURE_BORDER_COLOR or TEXTURE_SWIZZLE_RGBA).");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states. */
	{
		gl.textureParameterf(m_to_2D_ms, GL_TEXTURE_LOD_BIAS, 1.f);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterf",
								  "the  effective target is either TEXTURE_2D_MULTISAMPLE or  "
								  "TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and either of pnames
	 TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
	 MIRRORED_REPEAT or REPEAT. */
	{
		gl.textureParameterf(m_to_rectangle, GL_TEXTURE_WRAP_S, GL_MIRROR_CLAMP_TO_EDGE);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterf",
								  "the effective target is TEXTURE_RECTANGLE and either of pnames TEXTURE_WRAP_S or "
								  "TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE, MIRRORED_REPEAT or REPEAT.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
	 set to a value other than NEAREST or LINEAR (no mipmap filtering is
	 permitted). */
	{
		gl.textureParameterf(m_to_rectangle, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterf",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is set to a "
								  "value other than NEAREST or LINEAR (no mipmap filtering is permitted).");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
	 value other than zero. */
	{
		gl.textureParameterf(m_to_2D_ms, GL_TEXTURE_BASE_LEVEL, 1.f);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterf",
							 "the effective target is either TEXTURE_2D_MULTISAMPLE or TEXTURE_2D_MULTISAMPLE_ARRAY, "
							 "and pname TEXTURE_BASE_LEVEL is set to a value other than zero.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if
	 texture is not the name of an existing texture object. */
	{
		gl.textureParameterf(m_to_invalid, GL_TEXTURE_LOD_BIAS, 1.f);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterf",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
	 set to any value other than zero. */
	{
		gl.textureParameterf(m_to_rectangle, GL_TEXTURE_BASE_LEVEL, 1.f);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterf",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is set to "
								  "any value other than zero. ");
	}

	/* Check that INVALID_VALUE is generated by TextureParameter* if pname is
	 TEXTURE_BASE_LEVEL or TEXTURE_MAX_LEVEL, and param or params is
	 negative. */
	{
		gl.textureParameterf(m_to_2D, GL_TEXTURE_BASE_LEVEL, -1.f);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameterf",
								  "pname is TEXTURE_BASE_LEVEL and param is negative.");

		gl.textureParameterf(m_to_2D, GL_TEXTURE_MAX_LEVEL, -1.f);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameterf",
								  "pname is TEXTURE_MAX_LEVEL and param is negative.");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureParameteri
 *
 *  @return Test result.
 */
bool ParameterSetupErrorsTest::Testi()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	/* Check that INVALID_ENUM is generated by TextureParameter* if pname is
	 not one of the accepted defined values. */
	{
		gl.textureParameteri(m_to_2D, m_pname_invalid, 1);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteri",
								  "pname is not one of the accepted defined values.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if params
	 should have a defined constant value (based on the value of pname) and
	 does not. */
	{
		gl.textureParameteri(m_to_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, m_depth_stencil_mode_invalid);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteri",
							 "params should have a defined constant value (based on the value of pname) and does not.");
	}
	/* Check that INVALID_ENUM is generated if TextureParameter{if} is called
	 for a non-scalar parameter (pname TEXTURE_BORDER_COLOR or
	 TEXTURE_SWIZZLE_RGBA). */
	{
		gl.textureParameteri(m_to_2D, GL_TEXTURE_BORDER_COLOR, 1);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteri",
							 "called for a non-scalar parameter (pname TEXTURE_BORDER_COLOR or TEXTURE_SWIZZLE_RGBA).");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states. */
	{
		gl.textureParameteri(m_to_2D_ms, GL_TEXTURE_LOD_BIAS, 1);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteri",
								  "the  effective target is either TEXTURE_2D_MULTISAMPLE or  "
								  "TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and either of pnames
	 TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
	 MIRRORED_REPEAT or REPEAT. */
	{
		gl.textureParameteri(m_to_rectangle, GL_TEXTURE_WRAP_S, GL_MIRROR_CLAMP_TO_EDGE);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteri",
								  "the effective target is TEXTURE_RECTANGLE and either of pnames TEXTURE_WRAP_S or "
								  "TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE, MIRRORED_REPEAT or REPEAT.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
	 set to a value other than NEAREST or LINEAR (no mipmap filtering is
	 permitted). */
	{
		gl.textureParameteri(m_to_rectangle, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteri",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is set to a "
								  "value other than NEAREST or LINEAR (no mipmap filtering is permitted).");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
	 value other than zero. */
	{
		gl.textureParameteri(m_to_2D_ms, GL_TEXTURE_BASE_LEVEL, 1);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteri",
							 "the effective target is either TEXTURE_2D_MULTISAMPLE or TEXTURE_2D_MULTISAMPLE_ARRAY, "
							 "and pname TEXTURE_BASE_LEVEL is set to a value other than zero.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if
	 texture is not the name of an existing texture object. */
	{
		gl.textureParameteri(m_to_invalid, GL_TEXTURE_LOD_BIAS, 1);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteri",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
	 set to any value other than zero. */
	{
		gl.textureParameteri(m_to_rectangle, GL_TEXTURE_BASE_LEVEL, 1);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteri",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is set to "
								  "any value other than zero. ");
	}

	/* Check that INVALID_VALUE is generated by TextureParameter* if pname is
	 TEXTURE_BASE_LEVEL or TEXTURE_MAX_LEVEL, and param or params is
	 negative. */
	{
		gl.textureParameteri(m_to_2D, GL_TEXTURE_BASE_LEVEL, -1);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameteri",
								  "pname is TEXTURE_BASE_LEVEL and param is negative.");

		gl.textureParameteri(m_to_2D, GL_TEXTURE_MAX_LEVEL, -1);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameteri",
								  "pname is TEXTURE_MAX_LEVEL and param is negative.");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureParameterfv
 *
 *  @return Test result.
 */
bool ParameterSetupErrorsTest::Testfv()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	glw::GLfloat one						= 1.f;
	glw::GLfloat minus_one					= -1.f;
	glw::GLfloat depth_stencil_mode_invalid = (glw::GLfloat)m_depth_stencil_mode_invalid;
	glw::GLfloat wrap_invalid				= (glw::GLfloat)GL_MIRROR_CLAMP_TO_EDGE;
	glw::GLfloat min_filter_invalid			= (glw::GLfloat)GL_NEAREST_MIPMAP_NEAREST;

	/* Check that INVALID_ENUM is generated by TextureParameter* if pname is
	 not one of the accepted defined values. */
	{
		gl.textureParameterfv(m_to_2D, m_pname_invalid, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterfv",
								  "pname is not one of the accepted defined values.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if params
	 should have a defined constant value (based on the value of pname) and
	 does not. */
	{
		gl.textureParameterfv(m_to_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &depth_stencil_mode_invalid);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterfv",
							 "params should have a defined constant value (based on the value of pname) and does not.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states. */
	{
		gl.textureParameterfv(m_to_2D_ms, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterfv",
								  "the  effective target is either TEXTURE_2D_MULTISAMPLE or  "
								  "TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and either of pnames
	 TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
	 MIRRORED_REPEAT or REPEAT. */
	{
		gl.textureParameterfv(m_to_rectangle, GL_TEXTURE_WRAP_S, &wrap_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterfv",
								  "the effective target is TEXTURE_RECTANGLE and either of pnames TEXTURE_WRAP_S or "
								  "TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE, MIRRORED_REPEAT or REPEAT.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
	 set to a value other than NEAREST or LINEAR (no mipmap filtering is
	 permitted). */
	{
		gl.textureParameterfv(m_to_rectangle, GL_TEXTURE_MIN_FILTER, &min_filter_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterfv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is set to a "
								  "value other than NEAREST or LINEAR (no mipmap filtering is permitted).");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
	 value other than zero. */
	{
		gl.textureParameterfv(m_to_2D_ms, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterfv",
							 "the effective target is either TEXTURE_2D_MULTISAMPLE or TEXTURE_2D_MULTISAMPLE_ARRAY, "
							 "and pname TEXTURE_BASE_LEVEL is set to a value other than zero.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if
	 texture is not the name of an existing texture object. */
	{
		gl.textureParameterfv(m_to_invalid, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterfv",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
	 set to any value other than zero. */
	{
		gl.textureParameterfv(m_to_rectangle, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterfv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is set to "
								  "any value other than zero. ");
	}

	/* Check that INVALID_VALUE is generated by TextureParameter* if pname is
	 TEXTURE_BASE_LEVEL or TEXTURE_MAX_LEVEL, and param or params is
	 negative. */
	{
		gl.textureParameterfv(m_to_2D, GL_TEXTURE_BASE_LEVEL, &minus_one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameterfv",
								  "pname is TEXTURE_BASE_LEVEL and param is negative.");

		gl.textureParameterfv(m_to_2D, GL_TEXTURE_MAX_LEVEL, &minus_one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameterfv",
								  "pname is TEXTURE_MAX_LEVEL and param is negative.");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureParameteriv
 *
 *  @return Test result.
 */
bool ParameterSetupErrorsTest::Testiv()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	glw::GLint one						  = 1;
	glw::GLint minus_one				  = -1;
	glw::GLint depth_stencil_mode_invalid = (glw::GLint)m_depth_stencil_mode_invalid;
	glw::GLint wrap_invalid				  = (glw::GLint)GL_MIRROR_CLAMP_TO_EDGE;
	glw::GLint min_filter_invalid		  = (glw::GLint)GL_NEAREST_MIPMAP_NEAREST;

	/* Check that INVALID_ENUM is generated by TextureParameter* if pname is
	 not one of the accepted defined values. */
	{
		gl.textureParameteriv(m_to_2D, m_pname_invalid, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteriv",
								  "pname is not one of the accepted defined values.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if params
	 should have a defined constant value (based on the value of pname) and
	 does not. */
	{
		gl.textureParameteriv(m_to_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &depth_stencil_mode_invalid);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteriv",
							 "params should have a defined constant value (based on the value of pname) and does not.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states. */
	{
		gl.textureParameteriv(m_to_2D_ms, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteriv",
								  "the  effective target is either TEXTURE_2D_MULTISAMPLE or  "
								  "TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and either of pnames
	 TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
	 MIRRORED_REPEAT or REPEAT. */
	{
		gl.textureParameteriv(m_to_rectangle, GL_TEXTURE_WRAP_S, &wrap_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteriv",
								  "the effective target is TEXTURE_RECTANGLE and either of pnames TEXTURE_WRAP_S or "
								  "TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE, MIRRORED_REPEAT or REPEAT.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
	 set to a value other than NEAREST or LINEAR (no mipmap filtering is
	 permitted). */
	{
		gl.textureParameteriv(m_to_rectangle, GL_TEXTURE_MIN_FILTER, &min_filter_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameteriv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is set to a "
								  "value other than NEAREST or LINEAR (no mipmap filtering is permitted).");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
	 value other than zero. */
	{
		gl.textureParameteriv(m_to_2D_ms, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteriv",
							 "the effective target is either TEXTURE_2D_MULTISAMPLE or TEXTURE_2D_MULTISAMPLE_ARRAY, "
							 "and pname TEXTURE_BASE_LEVEL is set to a value other than zero.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if
	 texture is not the name of an existing texture object. */
	{
		gl.textureParameteriv(m_to_invalid, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteriv",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
	 set to any value other than zero. */
	{
		gl.textureParameteriv(m_to_rectangle, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameteriv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is set to "
								  "any value other than zero. ");
	}

	/* Check that INVALID_VALUE is generated by TextureParameter* if pname is
	 TEXTURE_BASE_LEVEL or TEXTURE_MAX_LEVEL, and param or params is
	 negative. */
	{
		gl.textureParameteriv(m_to_2D, GL_TEXTURE_BASE_LEVEL, &minus_one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameteriv",
								  "pname is TEXTURE_BASE_LEVEL and param is negative.");

		gl.textureParameteriv(m_to_2D, GL_TEXTURE_MAX_LEVEL, &minus_one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameteriv",
								  "pname is TEXTURE_MAX_LEVEL and param is negative.");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureParameterIiv
 *
 *  @return Test result.
 */
bool ParameterSetupErrorsTest::TestIiv()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	glw::GLint one						  = 1;
	glw::GLint minus_one				  = -1;
	glw::GLint depth_stencil_mode_invalid = (glw::GLint)m_depth_stencil_mode_invalid;
	glw::GLint wrap_invalid				  = (glw::GLint)GL_MIRROR_CLAMP_TO_EDGE;
	glw::GLint min_filter_invalid		  = (glw::GLint)GL_NEAREST_MIPMAP_NEAREST;

	/* Check that INVALID_ENUM is generated by TextureParameter* if pname is
	 not one of the accepted defined values. */
	{
		gl.textureParameterIiv(m_to_2D, m_pname_invalid, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIiv",
								  "pname is not one of the accepted defined values.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if params
	 should have a defined constant value (based on the value of pname) and
	 does not. */
	{
		gl.textureParameterIiv(m_to_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &depth_stencil_mode_invalid);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIiv",
							 "params should have a defined constant value (based on the value of pname) and does not.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states. */
	{
		gl.textureParameterIiv(m_to_2D_ms, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIiv",
								  "the  effective target is either TEXTURE_2D_MULTISAMPLE or  "
								  "TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and either of pnames
	 TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
	 MIRRORED_REPEAT or REPEAT. */
	{
		gl.textureParameterIiv(m_to_rectangle, GL_TEXTURE_WRAP_S, &wrap_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIiv",
								  "the effective target is TEXTURE_RECTANGLE and either of pnames TEXTURE_WRAP_S or "
								  "TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE, MIRRORED_REPEAT or REPEAT.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
	 set to a value other than NEAREST or LINEAR (no mipmap filtering is
	 permitted). */
	{
		gl.textureParameterIiv(m_to_rectangle, GL_TEXTURE_MIN_FILTER, &min_filter_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIiv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is set to a "
								  "value other than NEAREST or LINEAR (no mipmap filtering is permitted).");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
	 value other than zero. */
	{
		gl.textureParameterIiv(m_to_2D_ms, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIiv",
							 "the effective target is either TEXTURE_2D_MULTISAMPLE or TEXTURE_2D_MULTISAMPLE_ARRAY, "
							 "and pname TEXTURE_BASE_LEVEL is set to a value other than zero.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if
	 texture is not the name of an existing texture object. */
	{
		gl.textureParameterIiv(m_to_invalid, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIiv",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
	 set to any value other than zero. */
	{
		gl.textureParameterIiv(m_to_rectangle, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIiv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is set to "
								  "any value other than zero. ");
	}

	/* Check that INVALID_VALUE is generated by TextureParameter* if pname is
	 TEXTURE_BASE_LEVEL or TEXTURE_MAX_LEVEL, and param or params is
	 negative. */
	{
		gl.textureParameterIiv(m_to_2D, GL_TEXTURE_BASE_LEVEL, &minus_one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameterIiv",
								  "pname is TEXTURE_BASE_LEVEL and param is negative.");

		gl.textureParameterIiv(m_to_2D, GL_TEXTURE_MAX_LEVEL, &minus_one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glTextureParameterIiv",
								  "pname is TEXTURE_MAX_LEVEL and param is negative.");
	}

	return is_ok;
}

/** @brief Test (negative) of TextureParameterIuiv
 *
 *  @return Test result.
 */
bool ParameterSetupErrorsTest::TestIuiv()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Result. */
	bool is_ok = true;

	glw::GLuint one						   = 1;
	glw::GLuint depth_stencil_mode_invalid = (glw::GLint)m_depth_stencil_mode_invalid;
	glw::GLuint wrap_invalid			   = (glw::GLint)GL_MIRROR_CLAMP_TO_EDGE;
	glw::GLuint min_filter_invalid		   = (glw::GLint)GL_NEAREST_MIPMAP_NEAREST;

	/* Check that INVALID_ENUM is generated by TextureParameter* if pname is
	 not one of the accepted defined values. */
	{
		gl.textureParameterIuiv(m_to_2D, m_pname_invalid, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIuiv",
								  "pname is not one of the accepted defined values.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if params
	 should have a defined constant value (based on the value of pname) and
	 does not. */
	{
		gl.textureParameterIuiv(m_to_2D, GL_DEPTH_STENCIL_TEXTURE_MODE, &depth_stencil_mode_invalid);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIuiv",
							 "params should have a defined constant value (based on the value of pname) and does not.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states. */
	{
		gl.textureParameterIuiv(m_to_2D_ms, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIuiv",
								  "the  effective target is either TEXTURE_2D_MULTISAMPLE or  "
								  "TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and either of pnames
	 TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
	 MIRRORED_REPEAT or REPEAT. */
	{
		gl.textureParameterIuiv(m_to_rectangle, GL_TEXTURE_WRAP_S, &wrap_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIuiv",
								  "the effective target is TEXTURE_RECTANGLE and either of pnames TEXTURE_WRAP_S or "
								  "TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE, MIRRORED_REPEAT or REPEAT.");
	}

	/* Check that INVALID_ENUM is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
	 set to a value other than NEAREST or LINEAR (no mipmap filtering is
	 permitted). */
	{
		gl.textureParameterIuiv(m_to_rectangle, GL_TEXTURE_MIN_FILTER, &min_filter_invalid);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glTextureParameterIuiv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is set to a "
								  "value other than NEAREST or LINEAR (no mipmap filtering is permitted).");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is either TEXTURE_2D_MULTISAMPLE or
	 TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
	 value other than zero. */
	{
		gl.textureParameterIuiv(m_to_2D_ms, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIuiv",
							 "the effective target is either TEXTURE_2D_MULTISAMPLE or TEXTURE_2D_MULTISAMPLE_ARRAY, "
							 "and pname TEXTURE_BASE_LEVEL is set to a value other than zero.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if
	 texture is not the name of an existing texture object. */
	{
		gl.textureParameterIuiv(m_to_invalid, GL_TEXTURE_LOD_BIAS, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIuiv",
								  "texture is not the name of an existing texture object.");
	}

	/* Check that INVALID_OPERATION is generated by TextureParameter* if the
	 effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
	 set to any value other than zero. */
	{
		gl.textureParameterIuiv(m_to_rectangle, GL_TEXTURE_BASE_LEVEL, &one);

		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glTextureParameterIuiv",
								  "the effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is set to "
								  "any value other than zero. ");
	}

	return is_ok;
}

/** @brief Clean GL objects, test variables and GL errors.
 */
void ParameterSetupErrorsTest::Clean()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Cleanup. */
	if (m_to_2D)
	{
		gl.deleteTextures(1, &m_to_2D);

		m_to_2D = 0;
	}

	if (m_to_2D_ms)
	{
		gl.deleteTextures(1, &m_to_2D_ms);

		m_to_2D_ms = 0;
	}

	if (m_to_rectangle)
	{
		gl.deleteTextures(1, &m_to_rectangle);

		m_to_rectangle = 0;
	}

	if (m_to_invalid)
	{
		gl.deleteTextures(1, &m_to_invalid);

		m_to_invalid = 0;
	}

	m_to_invalid	= 0;
	m_pname_invalid = 0;

	while (GL_NO_ERROR != gl.getError())
		;
}

/******************************** Generate Mipmap Errors Test Implementation   ********************************/

/** @brief Generate Mipmap Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
GenerateMipmapErrorsTest::GenerateMipmapErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_generate_mipmap_errors", "Texture Generate Mipmap Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Generate Mipmap Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult GenerateMipmapErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint texture_invalid = 0;
	glw::GLuint texture_cube	= 0;

	try
	{
		/* Preparations. */

		/* incomplete cube map */
		gl.genTextures(1, &texture_cube);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_CUBE_MAP, texture_cube);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, s_reference_internalformat, s_reference_width,
					  s_reference_height, 0, s_reference_format, s_reference_type, s_reference_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		/* invalid texture */
		while (gl.isTexture(++texture_invalid))
			;

		/* Check that INVALID_OPERATION is generated by GenerateTextureMipmap if
		 texture is not the name of an existing texture object. */
		gl.generateTextureMipmap(texture_invalid);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGenerateTextureMipmap",
								  "texture is not the name of an existing texture object.");

		/* Check that INVALID_OPERATION is generated by GenerateTextureMipmap if
		 target is TEXTURE_CUBE_MAP or TEXTURE_CUBE_MAP_ARRAY, and the specified
		 texture object is not cube complete or cube array complete,
		 respectively. */
		gl.generateTextureMipmap(texture_cube);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGenerateTextureMipmap",
								  "target is TEXTURE_CUBE_MAP or TEXTURE_CUBE_MAP_ARRAY, and the specified texture "
								  "object is not cube complete or cube array complete, respectively.");
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture_cube)
	{
		gl.deleteTextures(1, &texture_cube);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/** Reference data. */
const glw::GLubyte GenerateMipmapErrorsTest::s_reference_data[] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
																	0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF };

/** Reference data parameters. */
const glw::GLuint GenerateMipmapErrorsTest::s_reference_width		   = 4;
const glw::GLuint GenerateMipmapErrorsTest::s_reference_height		   = 4;
const glw::GLenum GenerateMipmapErrorsTest::s_reference_internalformat = GL_R8;
const glw::GLenum GenerateMipmapErrorsTest::s_reference_format		   = GL_RED;
const glw::GLenum GenerateMipmapErrorsTest::s_reference_type		   = GL_UNSIGNED_BYTE;

/******************************** Bind Unit Errors Test Implementation   ********************************/

/** @brief Bind Unit Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
BindUnitErrorsTest::BindUnitErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_bind_unit_errors", "Texture Bind Unit Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief IterateBind Unit Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult BindUnitErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint texture_invalid = 0;

	try
	{
		/* Prepare invalid texture */
		while (gl.isTexture(++texture_invalid))
			;

		/* incomplete cube map */

		/* Check that INVALID_OPERATION error is generated if texture is not zero
		 or the name of an existing texture object. */
		gl.bindTextureUnit(0, texture_invalid);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glBindTextureUnit",
								  "texture is not zero or the name of an existing texture object.");
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/******************************** Image Query Errors Test Implementation   ********************************/

/** @brief Image Query Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
ImageQueryErrorsTest::ImageQueryErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_image_query_errors", "Texture Image Query Errors Test")
{
	/* Intentionally left blank. */
}

/** Reference data. */
const glw::GLuint ImageQueryErrorsTest::s_reference_data[] = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
															   0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF };

/** Reference data parameters. */
const glw::GLuint ImageQueryErrorsTest::s_reference_width					  = 4;
const glw::GLuint ImageQueryErrorsTest::s_reference_height					  = 4;
const glw::GLuint ImageQueryErrorsTest::s_reference_size					  = sizeof(s_reference_data);
const glw::GLenum ImageQueryErrorsTest::s_reference_internalformat			  = GL_R8;
const glw::GLenum ImageQueryErrorsTest::s_reference_internalformat_int		  = GL_R8I;
const glw::GLenum ImageQueryErrorsTest::s_reference_internalformat_compressed = GL_COMPRESSED_RED_RGTC1;
const glw::GLenum ImageQueryErrorsTest::s_reference_format					  = GL_RED;
const glw::GLenum ImageQueryErrorsTest::s_reference_type					  = GL_UNSIGNED_INT;

/** @brief Iterate Image Query Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult ImageQueryErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint buffer										  = 0;
	glw::GLuint texture_invalid								  = 0;
	glw::GLuint texture_2D									  = 0;
	glw::GLuint texture_2D_int								  = 0;
	glw::GLuint texture_2D_ms								  = 0;
	glw::GLuint texture_2D_stencil							  = 0;
	glw::GLuint texture_2D_compressed						  = 0;
	glw::GLuint texture_cube								  = 0;
	glw::GLuint texture_rectangle							  = 0;
	glw::GLint  max_level									  = 0;
	char		store[s_reference_size * 6 /* for cubemap */] = {};

	try
	{
		/* Preparations. */

		/* Buffer. */
		gl.createBuffers(1, &buffer);

		gl.namedBufferData(buffer, s_reference_size + 1, NULL, GL_STATIC_COPY);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glNamedBufferData has failed");

		/* 2D texture */
		gl.genTextures(1, &texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_2D, texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage2D(GL_TEXTURE_2D, 0, s_reference_internalformat, s_reference_width, s_reference_height, 0,
					  s_reference_format, s_reference_type, s_reference_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		/* 2D texture */
		gl.genTextures(1, &texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_2D, texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage2D(GL_TEXTURE_2D, 0, s_reference_internalformat, s_reference_width, s_reference_height, 0,
					  s_reference_format, s_reference_type, s_reference_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		/* incomplete cube map */
		gl.genTextures(1, &texture_cube);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_CUBE_MAP, texture_cube);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0, s_reference_internalformat, s_reference_width,
					  s_reference_height, 0, s_reference_format, s_reference_type, s_reference_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		/* 2D multisample */
		gl.createTextures(GL_TEXTURE_2D_MULTISAMPLE, 1, &texture_2D_ms);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.textureStorage2DMultisample(texture_2D_ms, 1, s_reference_internalformat, s_reference_width,
									   s_reference_height, false);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2DMultisample has failed");

		/* 2D stencil */
		gl.createTextures(GL_TEXTURE_2D, 1, &texture_2D_stencil);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.textureStorage2D(texture_2D_stencil, 1, GL_STENCIL_INDEX8, s_reference_width, s_reference_height);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTextureStorage2DMultisample has failed");

		/* 2D compressed texture  */
		gl.genTextures(1, &texture_2D_compressed);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_2D, texture_2D_compressed);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage2D(GL_TEXTURE_2D, 0, s_reference_internalformat_compressed, s_reference_width, s_reference_height, 0,
					  s_reference_format, s_reference_type, s_reference_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &max_level); /* assuming that x > log(x) */
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv has failed");

		/* Rectangle texture */
		gl.genTextures(1, &texture_rectangle);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_RECTANGLE, texture_rectangle);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texImage2D(GL_TEXTURE_RECTANGLE, 0, s_reference_internalformat, s_reference_width, s_reference_height, 0,
					  s_reference_format, s_reference_type, s_reference_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		/* invalid texture */
		while (gl.isTexture(++texture_invalid))
			;

		/* Tests. */

		/* Check that INVALID_OPERATION is generated by GetTextureImage functions if
		 resulting texture target is not an accepted value TEXTURE_1D,
		 TEXTURE_2D, TEXTURE_3D, TEXTURE_1D_ARRAY, TEXTURE_2D_ARRAY,
		 TEXTURE_CUBE_MAP_ARRAY, TEXTURE_RECTANGLE, and TEXTURE_CUBE_MAP. */
		gl.getTextureImage(texture_2D_ms, 0, s_reference_format, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "resulting texture target is not an accepted value TEXTURE_1D, TEXTURE_2D, "
								  "TEXTURE_3D, TEXTURE_1D_ARRAY, TEXTURE_2D_ARRAY, TEXTURE_CUBE_MAP_ARRAY, "
								  "TEXTURE_RECTANGLE, and TEXTURE_CUBE_MAP.");

		/* Check that INVALID_OPERATION is generated by GetTextureImage
		 if texture is not the name of an existing texture object. */
		gl.getTextureImage(texture_invalid, 0, s_reference_format, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "texture is not the name of an existing texture object.");

		/* Check that INVALID_OPERATION error is generated by GetTextureImage if
		 the effective target is TEXTURE_CUBE_MAP or TEXTURE_CUBE_MAP_ARRAY, and
		 the texture object is not cube complete or cube array complete,
		 respectively. */
		gl.getTextureImage(texture_cube, 0, s_reference_format, s_reference_type, s_reference_size * 6, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "the effective target is TEXTURE_CUBE_MAP and the texture object is not cube "
								  "complete or cube array complete, respectively.");

		/* Check that GL_INVALID_VALUE is generated if level is less than 0 or
		 larger than the maximum allowable level. */
		gl.getTextureImage(texture_2D, -1, s_reference_format, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureImage", "level is less than 0.");

		gl.getTextureImage(texture_2D, max_level, s_reference_format, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureImage",
								  "level is larger than the maximum allowable level.");

		/* Check that INVALID_VALUE error is generated if level is non-zero and the
		 effective target is TEXTURE_RECTANGLE. */
		gl.getTextureImage(texture_rectangle, 1, s_reference_format, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureImage",
								  "level is non-zero and the effective target is TEXTURE_RECTANGLE.");

		/* Check that INVALID_OPERATION error is generated if any of the following
		 mismatches between format and the internal format of the texture image
		 exist:
		 -  format is a color format (one of the formats in table 8.3 whose
		 target is the color buffer) and the base internal format of the
		 texture image is not a color format.
		 -  format is DEPTH_COMPONENT and the base internal format is  not
		 DEPTH_COMPONENT or DEPTH_STENCIL
		 -  format is DEPTH_STENCIL and the base internal format is not
		 DEPTH_STENCIL
		 -  format is STENCIL_INDEX and the base internal format is not
		 STENCIL_INDEX or DEPTH_STENCIL
		 -  format is one of the integer formats in table 8.3 and the internal
		 format of the texture image is not integer, or format is not one of
		 the integer formats in table 8.3 and the internal format is integer. */
		gl.getTextureImage(texture_2D_stencil, 0, s_reference_format /* red */, s_reference_type, s_reference_size,
						   store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "format is a color format (one of the formats in table 8.3 whose target is the color "
								  "buffer) and the base internal format of the texture image is not a color format.");

		gl.getTextureImage(texture_2D, 0, GL_DEPTH_COMPONENT, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_OPERATION, "glGetTextureImage",
			"format is DEPTH_COMPONENT and the base internal format is not DEPTH_COMPONENT or DEPTH_STENCIL.");

		gl.getTextureImage(texture_2D, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "format is DEPTH_STENCIL and the base internal format is not DEPTH_STENCIL.");

		gl.getTextureImage(texture_2D, 0, GL_STENCIL_INDEX, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_OPERATION, "glGetTextureImage",
			"format is STENCIL_INDEX and the base internal format is not STENCIL_INDEX or DEPTH_STENCIL.");

		gl.getTextureImage(texture_2D, 0, GL_RED_INTEGER, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "format is one of the integer formats in table 8.3 and the internal format of the "
								  "texture image is not integer.");

		gl.getTextureImage(texture_2D_int, 0, GL_RED, s_reference_type, s_reference_size, store);
		is_ok &= CheckErrorAndLog(
			m_context, GL_INVALID_OPERATION, "glGetTextureImage",
			"format is not one of the integer formats in table 8.3 and the internal format is integer.");

		/* Check that INVALID_OPERATION error is generated if a pixel pack buffer
		 object is bound and packing the texture image into the buffer's memory
		 would exceed the size of the buffer. */
		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.getTextureImage(texture_2D, 0, s_reference_format, s_reference_type, s_reference_size,
						   glu::BufferOffsetAsPointer(1 * sizeof(GLuint)));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "a pixel pack buffer object is bound and packing the texture image into the buffer's "
								  "memory would exceed the size of the buffer.");

		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		/* Check that INVALID_OPERATION error is generated if a pixel pack buffer
		 object is bound and pixels is not evenly divisible by the number of
		 basic machine units needed to store in memory the GL data type
		 corresponding to type (see table 8.2). */
		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.getTextureImage(texture_2D, 0, s_reference_format, s_reference_type, s_reference_size,
						   glu::BufferOffsetAsPointer(1));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "a pixel pack buffer object is bound and pixels is not evenly divisible by the "
								  "number of basic machine units needed to store in memory the GL data type "
								  "corresponding to type (see table 8.2).");

		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		/* Check that INVALID_OPERATION error is generated by GetTextureImage if
		 the buffer size required to store the requested data is greater than
		 bufSize. */
		gl.getTextureImage(texture_2D, 0, s_reference_format, s_reference_type,
						   s_reference_size - sizeof(s_reference_data[0]), store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureImage",
								  "the buffer size required to store the requested data is greater than bufSize.");

		/* Check that INVALID_OPERATION is generated by GetCompressedTextureImage
		 if texture is not the name of an existing texture object. */
		gl.getCompressedTextureImage(texture_invalid, 0, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetCompressedTextureImage",
								  "texture is not the name of an existing texture object.");

		/* Check that INVALID_VALUE is generated by GetCompressedTextureImage if
		 level is less than zero or greater than the maximum number of LODs
		 permitted by the implementation. */
		gl.getCompressedTextureImage(texture_2D_compressed, -1, s_reference_size, store);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetCompressedTextureImage", "level is less than zero.");

		gl.getCompressedTextureImage(texture_2D_compressed, max_level, s_reference_size, store);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetCompressedTextureImage",
								  "level is greater than the maximum number of LODs permitted by the implementation.");

		/* Check that INVALID_OPERATION is generated if GetCompressedTextureImage
		 is used to retrieve a texture that is in an uncompressed internal
		 format. */
		gl.getCompressedTextureImage(texture_2D, 0, s_reference_size, store);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetCompressedTextureImage",
							 "the function is used to retrieve a texture that is in an uncompressed internal format.");

		/* Check that INVALID_OPERATION is generated by GetCompressedTextureImage
		 if a non-zero buffer object name is bound to the PIXEL_PACK_BUFFER
		 target, the buffer storage was not initialized with BufferStorage using
		 MAP_PERSISTENT_BIT flag, and the buffer object's data store is currently
		 mapped. */
		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.mapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_WRITE);

		if (GL_NO_ERROR == gl.getError())
		{
			gl.getCompressedTextureImage(texture_2D_compressed, 0, s_reference_size, NULL);
			is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetCompressedTextureImage",
									  "a non-zero buffer object name is bound to the PIXEL_PACK_BUFFER target, the "
									  "buffer storage was not initialized with BufferStorage using MAP_PERSISTENT_BIT "
									  "flag, and the buffer object's data store is currently mapped.");

			gl.unmapBuffer(GL_PIXEL_PACK_BUFFER);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer has failed");
		}
		else
		{
			throw 0;
		}

		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		/* Check that INVALID_OPERATION is generated by GetCompressedTextureImage
		 if a non-zero buffer object name is bound to the PIXEL_PACK_BUFFER
		 target and the data would be packed to the buffer object such that the
		 memory writes required would exceed the data store size. */
		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");

		gl.getCompressedTextureImage(texture_2D_compressed, 0, s_reference_size, glu::BufferOffsetAsPointer(s_reference_size - 1));
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetCompressedTextureImage",
								  "a non-zero buffer object name is bound to the PIXEL_PACK_BUFFER target and the data "
								  "would be packed to the buffer object such that the memory writes required would "
								  "exceed the data store size.");

		gl.bindBuffer(GL_PIXEL_PACK_BUFFER, 0);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer has failed");
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (buffer)
	{
		gl.deleteBuffers(1, &buffer);
	}

	if (texture_2D)
	{
		gl.deleteTextures(1, &texture_2D);
	}

	if (texture_2D_int)
	{
		gl.deleteTextures(1, &texture_2D_int);
	}

	if (texture_2D_stencil)
	{
		gl.deleteTextures(1, &texture_2D_stencil);
	}

	if (texture_2D_ms)
	{
		gl.deleteTextures(1, &texture_2D_ms);
	}

	if (texture_2D_compressed)
	{
		gl.deleteTextures(1, &texture_2D_compressed);
	}

	if (texture_cube)
	{
		gl.deleteTextures(1, &texture_cube);
	}

	if (texture_rectangle)
	{
		gl.deleteTextures(1, &texture_rectangle);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/******************************** Level Parameter Query Errors Test Implementation   ********************************/

/** @brief Image Query Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
LevelParameterErrorsTest::LevelParameterErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_level_parameter_errors", "Texture Level Parameter Query Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Level Parameter Query Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult LevelParameterErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint texture_2D		= 0;
	glw::GLuint texture_invalid = 0;
	glw::GLint  max_level		= 0;
	glw::GLenum pname_invalid   = 0;

	glw::GLfloat storef[4] = {};
	glw::GLint   storei[4] = {};

	try
	{
		/* Preparations. */

		/* 2D texture */
		gl.genTextures(1, &texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		gl.bindTexture(GL_TEXTURE_2D, texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture has failed");

		gl.texStorage2D(GL_TEXTURE_2D, 1, GL_R8, 1, 1);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D has failed");

		/* Limits. */
		gl.getIntegerv(GL_MAX_TEXTURE_SIZE, &max_level); /* assuming that x > log(x) */
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv has failed");

		/* invalid texture */
		while (gl.isTexture(++texture_invalid))
			;

		/* invalid pname */
		glw::GLenum all_pnames[] = { GL_TEXTURE_WIDTH,
									 GL_TEXTURE_HEIGHT,
									 GL_TEXTURE_DEPTH,
									 GL_TEXTURE_SAMPLES,
									 GL_TEXTURE_FIXED_SAMPLE_LOCATIONS,
									 GL_TEXTURE_INTERNAL_FORMAT,
									 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_RED_TYPE,
									 GL_TEXTURE_GREEN_TYPE,
									 GL_TEXTURE_BLUE_TYPE,
									 GL_TEXTURE_ALPHA_TYPE,
									 GL_TEXTURE_DEPTH_TYPE,
									 GL_TEXTURE_COMPRESSED,
									 GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
									 GL_TEXTURE_BUFFER_DATA_STORE_BINDING,
									 GL_TEXTURE_BUFFER_OFFSET,
									 GL_TEXTURE_BUFFER_SIZE };

		glw::GLuint all_pnames_count = sizeof(all_pnames) / sizeof(all_pnames[0]);

		bool is_valid = true;

		while (is_valid)
		{
			is_valid = false;

			++pname_invalid;

			for (glw::GLuint i = 0; i < all_pnames_count; ++i)
			{
				if (all_pnames[i] == pname_invalid)
				{
					is_valid = true;

					break;
				}
			}
		}

		/* Tests. */

		/* Check that INVALID_OPERATION is generated by GetTextureLevelParameterfv
		 and GetTextureLevelParameteriv functions if texture is not the name of
		 an existing texture object. */
		gl.getTextureLevelParameterfv(texture_invalid, 0, GL_TEXTURE_WIDTH, storef);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureLevelParameterfv",
								  "texture is not the name of an existing texture object.");

		gl.getTextureLevelParameteriv(texture_invalid, 0, GL_TEXTURE_WIDTH, storei);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureLevelParameteriv",
								  "texture is not the name of an existing texture object.");

		/* Check that INVALID_VALUE is generated by GetTextureLevelParameter* if
		 level is less than 0. */
		gl.getTextureLevelParameterfv(texture_2D, -1, GL_TEXTURE_WIDTH, storef);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureLevelParameterfv", "level is less than 0.");

		gl.getTextureLevelParameteriv(texture_2D, -1, GL_TEXTURE_WIDTH, storei);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureLevelParameteriv", "level is less than 0.");

		/* Check that INVALID_ENUM error is generated by GetTextureLevelParameter*
		 if pname is not one of supported constants. */
		gl.getTextureLevelParameterfv(texture_2D, 0, pname_invalid, storef);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glGetTextureLevelParameterfv",
								  "pname is not one of supported constants.");

		gl.getTextureLevelParameteriv(texture_2D, 0, pname_invalid, storei);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glGetTextureLevelParameteriv",
								  "pname is not one of supported constants.");

		/* Check that INVALID_VALUE may be generated if level is greater than
		 log2 max, where max is the returned value of MAX_TEXTURE_SIZE. */
		gl.getTextureLevelParameterfv(texture_2D, max_level, GL_TEXTURE_WIDTH, storef);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureLevelParameterfv",
							 "level is greater than log2 max, where max is the returned value of MAX_TEXTURE_SIZE.");

		gl.getTextureLevelParameteriv(texture_2D, max_level, GL_TEXTURE_WIDTH, storei);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_VALUE, "glGetTextureLevelParameteriv",
							 "level is greater than log2 max, where max is the returned value of MAX_TEXTURE_SIZE.");

		/* Check that INVALID_OPERATION is generated by GetTextureLevelParameter*
		 if TEXTURE_COMPRESSED_IMAGE_SIZE is queried on texture images with an
		 uncompressed internal format or on proxy targets. */
		gl.getTextureLevelParameterfv(texture_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, storef);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureLevelParameterfv",
								  "TEXTURE_COMPRESSED_IMAGE_SIZE is queried on texture images with an uncompressed "
								  "internal format or on proxy targets.");

		gl.getTextureLevelParameteriv(texture_2D, 0, GL_TEXTURE_COMPRESSED_IMAGE_SIZE, storei);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureLevelParameteriv",
								  "TEXTURE_COMPRESSED_IMAGE_SIZE is queried on texture images with an uncompressed "
								  "internal format or on proxy targets.");
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture_2D)
	{
		gl.deleteTextures(1, &texture_2D);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

/******************************** Parameter Query Errors Test Implementation   ********************************/

/** @brief Parameter Query Errors Test constructor.
 *
 *  @param [in] context     OpenGL context.
 */
ParameterErrorsTest::ParameterErrorsTest(deqp::Context& context)
	: deqp::TestCase(context, "textures_parameter_errors", "Texture Parameter Query Errors Test")
{
	/* Intentionally left blank. */
}

/** @brief Iterate Parameter Query Errors Test cases.
 *
 *  @return Iteration result.
 */
tcu::TestNode::IterateResult ParameterErrorsTest::iterate()
{
	/* Shortcut for GL functionality. */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Get context setup. */
	bool is_at_least_gl_45 = (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)));
	bool is_arb_direct_state_access = m_context.getContextInfo().isExtensionSupported("GL_ARB_direct_state_access");

	if ((!is_at_least_gl_45) && (!is_arb_direct_state_access))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");

		return STOP;
	}

	/* Running tests. */
	bool is_ok	= true;
	bool is_error = false;

	/* Objects. */
	glw::GLuint texture_2D		= 0;
	glw::GLuint texture_buffer  = 0;
	glw::GLuint texture_invalid = 0;
	glw::GLenum pname_invalid   = 0;

	glw::GLfloat storef[4] = {};
	glw::GLint   storei[4] = {};
	glw::GLuint  storeu[4] = {};

	try
	{
		/* Preparations. */

		/* 2D texture */
		gl.createTextures(GL_TEXTURE_2D, 1, &texture_2D);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		/* Buffer texture */
		gl.createTextures(GL_TEXTURE_BUFFER, 1, &texture_buffer);
		GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures has failed");

		/* invalid texture */
		while (gl.isTexture(++texture_invalid))
			;

		/* invalid pname */
		glw::GLenum all_pnames[] = { GL_IMAGE_FORMAT_COMPATIBILITY_TYPE,
									 GL_TEXTURE_IMMUTABLE_FORMAT,
									 GL_TEXTURE_IMMUTABLE_LEVELS,
									 GL_TEXTURE_TARGET,
									 GL_TEXTURE_VIEW_MIN_LEVEL,
									 GL_TEXTURE_VIEW_NUM_LEVELS,
									 GL_TEXTURE_VIEW_MIN_LAYER,
									 GL_TEXTURE_VIEW_NUM_LAYERS,
									 GL_DEPTH_STENCIL_TEXTURE_MODE,
									 GL_DEPTH_COMPONENT,
									 GL_STENCIL_INDEX,
									 GL_TEXTURE_BASE_LEVEL,
									 GL_TEXTURE_BORDER_COLOR,
									 GL_TEXTURE_COMPARE_MODE,
									 GL_TEXTURE_COMPARE_FUNC,
									 GL_TEXTURE_LOD_BIAS,
									 GL_TEXTURE_MAG_FILTER,
									 GL_TEXTURE_MAX_LEVEL,
									 GL_TEXTURE_MAX_LOD,
									 GL_TEXTURE_MIN_FILTER,
									 GL_TEXTURE_MIN_LOD,
									 GL_TEXTURE_SWIZZLE_R,
									 GL_TEXTURE_SWIZZLE_G,
									 GL_TEXTURE_SWIZZLE_B,
									 GL_TEXTURE_SWIZZLE_A,
									 GL_TEXTURE_SWIZZLE_RGBA,
									 GL_TEXTURE_WRAP_S,
									 GL_TEXTURE_WRAP_T,
									 GL_TEXTURE_WRAP_R };

		glw::GLuint all_pnames_count = sizeof(all_pnames) / sizeof(all_pnames[0]);

		bool is_valid = true;

		while (is_valid)
		{
			is_valid = false;

			++pname_invalid;

			for (glw::GLuint i = 0; i < all_pnames_count; ++i)
			{
				if (all_pnames[i] == pname_invalid)
				{
					is_valid = true;

					break;
				}
			}
		}

		/* Tests. */

		/* Check that INVALID_ENUM is generated by glGetTextureParameter* if pname
		 is not an accepted value. */
		gl.getTextureParameterfv(texture_2D, pname_invalid, storef);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glGetTextureParameterfv", "pname is not an accepted value.");

		gl.getTextureParameterIiv(texture_2D, pname_invalid, storei);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glGetTextureParameterIiv", "pname is not an accepted value.");

		gl.getTextureParameterIuiv(texture_2D, pname_invalid, storeu);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glGetTextureParameterIuiv",
								  "pname is not an accepted value.");

		gl.getTextureParameteriv(texture_2D, pname_invalid, storei);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_ENUM, "glGetTextureParameteriv", "pname is not an accepted value.");

		/* Check that INVALID_OPERATION is generated by glGetTextureParameter* if
		 texture is not the name of an existing texture object. */
		gl.getTextureParameterfv(texture_invalid, GL_TEXTURE_TARGET, storef);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameterfv",
								  "texture is not the name of an existing texture object.");

		gl.getTextureParameterIiv(texture_invalid, GL_TEXTURE_TARGET, storei);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameterIiv",
								  "texture is not the name of an existing texture object.");

		gl.getTextureParameterIuiv(texture_invalid, GL_TEXTURE_TARGET, storeu);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameterIuiv",
								  "texture is not the name of an existing texture object.");

		gl.getTextureParameteriv(texture_invalid, GL_TEXTURE_TARGET, storei);
		is_ok &= CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameteriv",
								  "texture is not the name of an existing texture object.");

		/* Check that INVALID_OPERATION error is generated if the effective target is
		 not one of the supported texture targets (eg. TEXTURE_BUFFER). */
		gl.getTextureParameterfv(texture_buffer, GL_TEXTURE_TARGET, storef);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameterfv",
							 "the effective target is not one of the supported texture targets (eg. TEXTURE_BUFFER).");

		gl.getTextureParameterIiv(texture_buffer, GL_TEXTURE_TARGET, storei);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameterIiv",
							 "the effective target is not one of the supported texture targets (eg. TEXTURE_BUFFER).");

		gl.getTextureParameterIuiv(texture_buffer, GL_TEXTURE_TARGET, storeu);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameterIuiv",
							 "the effective target is not one of the supported texture targets (eg. TEXTURE_BUFFER).");

		gl.getTextureParameteriv(texture_buffer, GL_TEXTURE_TARGET, storei);
		is_ok &=
			CheckErrorAndLog(m_context, GL_INVALID_OPERATION, "glGetTextureParameteriv",
							 "the effective target is not one of the supported texture targets (eg. TEXTURE_BUFFER).");
	}
	catch (...)
	{
		is_ok	= false;
		is_error = true;
	}

	/* Cleanup. */
	if (texture_2D)
	{
		gl.deleteTextures(1, &texture_2D);
	}

	if (texture_buffer)
	{
		gl.deleteTextures(1, &texture_buffer);
	}

	while (GL_NO_ERROR != gl.getError())
		;

	/* Result's setup. */
	if (is_ok)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		if (is_error)
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_INTERNAL_ERROR, "Error");
		}
		else
		{
			m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
		}
	}

	return STOP;
}

} /* Textures namespace. */
} /* DirectStateAccess namespace. */
} /* gl4cts namespace. */