Google Git
Sign in
fuchsia / third_party / vulkan-cts / 780edbd7f64c8eb3e6df37610ae6684095810933 / . / external / openglcts / modules / gles31 / es31cTextureStorageMultisampleGetTexLevelParameterifvTests.cpp
blob: 9bb978ca366a3794b50fb73261e95edb40b6f25b [file] [log] [blame]
/*-------------------------------------------------------------------------
* OpenGL Conformance Test Suite
* -----------------------------
*
* Copyright (c) 2014-2016 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/ /*!
* \file
* \brief
*/ /*-------------------------------------------------------------------*/
/**
*/ /*!
* \file es31cTextureStorageMultisampleGetTexLevelParameterifvTests.cpp
* \brief Verifies glGetTexLevelParameter(if)v() entry points work correctly.
* (ES3.1 only)
*/ /*-------------------------------------------------------------------*/
#include "es31cTextureStorageMultisampleGetTexLevelParameterifvTests.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuTestLog.hpp"
#include <algorithm>
#include <map>
#include <string>
#include <vector>
namespace glcts
{
/** Constructor.
*
* @param context CTS context handle.
**/
MultisampleTextureGetTexLevelParametervFunctionalTest::MultisampleTextureGetTexLevelParametervFunctionalTest(
Context& context)
: TestCase(context, "functional_test", "Verifies glGetTexLevelParameter{if}v() entry-points "
"work correctly for all ES3.1 texture targets.")
, gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
, to_2d(0)
, to_2d_array(0)
, to_2d_multisample(0)
, to_2d_multisample_array(0)
, to_3d(0)
, to_cubemap(0)
{
/* Left blank on purpose */
}
/** Deinitializes GL ES objects used by the test */
void MultisampleTextureGetTexLevelParametervFunctionalTest::deinit()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (to_2d != 0)
{
gl.deleteTextures(1, &to_2d);
to_2d = 0;
}
if (to_2d_array != 0)
{
gl.deleteTextures(1, &to_2d_array);
to_2d_array = 0;
}
if (to_2d_multisample != 0)
{
gl.deleteTextures(1, &to_2d_multisample);
to_2d_multisample = 0;
}
if (to_2d_multisample_array != 0)
{
gl.deleteTextures(1, &to_2d_multisample_array);
to_2d_multisample_array = 0;
}
if (to_3d != 0)
{
gl.deleteTextures(1, &to_3d);
to_3d = 0;
}
if (to_cubemap != 0)
{
gl.deleteTextures(1, &to_cubemap);
to_cubemap = 0;
}
/* Call base class' deinit() */
TestCase::deinit();
}
/** Executes test iteration.
*
* @return Returns STOP when test has finished executing.
*/
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervFunctionalTest::iterate()
{
gl_oes_texture_storage_multisample_2d_array_supported =
m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Retrieve maximum number of sample supported by the implementation for GL_RGB565 internalformat
* used for GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES texture target.
*/
glw::GLint max_rgb565_internalformat_samples = 0;
if (gl_oes_texture_storage_multisample_2d_array_supported)
{
gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_RGB565, GL_SAMPLES, 1,
&max_rgb565_internalformat_samples);
GLU_EXPECT_NO_ERROR(gl.getError(),
"Could not retrieve maximum supported amount of samples for RGB565 internalformat");
}
/* Set up texture property descriptors. We'll use these later to set up texture objects
* in an automated manner.
*/
_texture_properties texture_2d_array_properties;
_texture_properties texture_2d_multisample_array_properties;
_texture_properties texture_2d_multisample_properties;
_texture_properties texture_2d_properties;
_texture_properties texture_3d_properties;
_texture_properties texture_cm_face_properties;
_texture_properties* texture_descriptors_with_extension[] = { &texture_2d_array_properties,
&texture_2d_multisample_array_properties,
&texture_2d_multisample_properties,
&texture_2d_properties,
&texture_3d_properties,
&texture_cm_face_properties };
_texture_properties* texture_descriptors_without_extension[] = { &texture_2d_array_properties,
&texture_2d_multisample_properties,
&texture_2d_properties, &texture_3d_properties,
&texture_cm_face_properties };
unsigned int n_texture_descriptors = 0;
_texture_properties** texture_descriptors = NULL;
if (gl_oes_texture_storage_multisample_2d_array_supported)
{
n_texture_descriptors =
sizeof(texture_descriptors_with_extension) / sizeof(texture_descriptors_with_extension[0]);
texture_descriptors = texture_descriptors_with_extension;
}
else
{
n_texture_descriptors =
sizeof(texture_descriptors_without_extension) / sizeof(texture_descriptors_without_extension[0]);
texture_descriptors = texture_descriptors_without_extension;
}
/* GL_TEXTURE_2D */
texture_2d_properties.format = GL_DEPTH_STENCIL;
texture_2d_properties.height = 16;
texture_2d_properties.internalformat = GL_DEPTH24_STENCIL8;
texture_2d_properties.is_2d_texture = true;
texture_2d_properties.target = GL_TEXTURE_2D;
texture_2d_properties.to_id_ptr = &to_2d;
texture_2d_properties.type = GL_UNSIGNED_INT_24_8;
texture_2d_properties.width = 16;
texture_2d_properties.expected_compressed = GL_FALSE;
texture_2d_properties.expected_texture_alpha_size = 0;
texture_2d_properties.expected_texture_alpha_types.push_back(GL_NONE);
texture_2d_properties.expected_texture_blue_size = 0;
texture_2d_properties.expected_texture_blue_types.push_back(GL_NONE);
texture_2d_properties.expected_texture_depth = 1;
texture_2d_properties.expected_texture_depth_size = 24;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_properties.expected_texture_depth_types.push_back(GL_UNSIGNED_INT);
texture_2d_properties.expected_texture_depth_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_properties.expected_texture_fixed_sample_locations = GL_TRUE;
texture_2d_properties.expected_texture_green_size = 0;
texture_2d_properties.expected_texture_green_types.push_back(GL_NONE);
texture_2d_properties.expected_texture_height = 16;
texture_2d_properties.expected_texture_internal_format = GL_DEPTH24_STENCIL8;
texture_2d_properties.expected_texture_red_size = 0;
texture_2d_properties.expected_texture_red_types.push_back(GL_NONE);
texture_2d_properties.expected_texture_samples = 0;
texture_2d_properties.expected_texture_shared_size = 0;
texture_2d_properties.expected_texture_stencil_size = 8;
texture_2d_properties.expected_texture_width = 16;
/* GL_TEXTURE_2D_ARRAY */
texture_2d_array_properties.depth = 32;
texture_2d_array_properties.format = GL_RGBA;
texture_2d_array_properties.height = 32;
texture_2d_array_properties.internalformat = GL_RGBA8;
texture_2d_array_properties.is_2d_texture = false;
texture_2d_array_properties.target = GL_TEXTURE_2D_ARRAY;
texture_2d_array_properties.to_id_ptr = &to_2d_array;
texture_2d_array_properties.type = GL_UNSIGNED_BYTE;
texture_2d_array_properties.width = 32;
texture_2d_array_properties.expected_compressed = GL_FALSE;
texture_2d_array_properties.expected_texture_alpha_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_array_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_array_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_INT);
texture_2d_array_properties.expected_texture_blue_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_INT);
texture_2d_array_properties.expected_texture_depth = 32;
texture_2d_array_properties.expected_texture_depth_size = 0;
texture_2d_array_properties.expected_texture_depth_types.push_back(GL_NONE);
texture_2d_array_properties.expected_texture_fixed_sample_locations = GL_TRUE;
texture_2d_array_properties.expected_texture_green_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_INT);
texture_2d_array_properties.expected_texture_height = 32;
texture_2d_array_properties.expected_texture_internal_format = GL_RGBA8;
texture_2d_array_properties.expected_texture_red_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_INT);
texture_2d_array_properties.expected_texture_samples = 0;
texture_2d_array_properties.expected_texture_shared_size = 0;
texture_2d_array_properties.expected_texture_stencil_size = 0;
texture_2d_array_properties.expected_texture_width = 32;
/* GL_TEXTURE_2D_MULTISAMPLE */
texture_2d_multisample_properties.fixedsamplelocations = GL_FALSE;
texture_2d_multisample_properties.format = GL_RGBA_INTEGER;
texture_2d_multisample_properties.height = 8;
texture_2d_multisample_properties.internalformat = GL_RGBA8UI;
texture_2d_multisample_properties.is_2d_texture = true;
texture_2d_multisample_properties.is_multisample_texture = true;
texture_2d_multisample_properties.samples = 1;
texture_2d_multisample_properties.target = GL_TEXTURE_2D_MULTISAMPLE;
texture_2d_multisample_properties.to_id_ptr = &to_2d_multisample;
texture_2d_multisample_properties.type = GL_UNSIGNED_INT;
texture_2d_multisample_properties.width = 8;
texture_2d_multisample_properties.expected_compressed = GL_FALSE;
texture_2d_multisample_properties.expected_texture_alpha_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_properties.expected_texture_alpha_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_properties.expected_texture_blue_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_properties.expected_texture_depth = 1;
texture_2d_multisample_properties.expected_texture_depth_size = 0;
texture_2d_multisample_properties.expected_texture_depth_types.push_back(GL_NONE);
texture_2d_multisample_properties.expected_texture_fixed_sample_locations = GL_FALSE;
texture_2d_multisample_properties.expected_texture_green_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_properties.expected_texture_green_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_properties.expected_texture_green_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_properties.expected_texture_height = 8;
texture_2d_multisample_properties.expected_texture_internal_format = GL_RGBA8UI;
texture_2d_multisample_properties.expected_texture_red_size = 8;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_properties.expected_texture_red_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_properties.expected_texture_red_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_properties.expected_texture_samples = 1;
texture_2d_multisample_properties.expected_texture_shared_size = 0;
texture_2d_multisample_properties.expected_texture_stencil_size = 0;
texture_2d_multisample_properties.expected_texture_width = 8;
/* GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES */
texture_2d_multisample_array_properties.depth = 4; /* note: test spec missed this bit */
texture_2d_multisample_array_properties.fixedsamplelocations = GL_TRUE;
texture_2d_multisample_array_properties.format = GL_RGB;
texture_2d_multisample_array_properties.height = 4;
texture_2d_multisample_array_properties.internalformat = GL_RGB565;
texture_2d_multisample_array_properties.is_2d_texture = false;
texture_2d_multisample_array_properties.is_multisample_texture = true;
texture_2d_multisample_array_properties.samples = max_rgb565_internalformat_samples;
texture_2d_multisample_array_properties.target = GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
texture_2d_multisample_array_properties.to_id_ptr = &to_2d_multisample_array;
texture_2d_multisample_array_properties.type = GL_UNSIGNED_BYTE;
texture_2d_multisample_array_properties.width = 4;
texture_2d_multisample_array_properties.expected_compressed = GL_FALSE;
texture_2d_multisample_array_properties.expected_texture_alpha_size = 0;
texture_2d_multisample_array_properties.expected_texture_alpha_types.push_back(GL_NONE);
texture_2d_multisample_array_properties.expected_texture_blue_size = 5;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_array_properties.expected_texture_blue_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_array_properties.expected_texture_depth = 4;
texture_2d_multisample_array_properties.expected_texture_depth_size = 0;
texture_2d_multisample_array_properties.expected_texture_depth_types.push_back(GL_NONE);
texture_2d_multisample_array_properties.expected_texture_fixed_sample_locations = GL_TRUE;
texture_2d_multisample_array_properties.expected_texture_green_size = 6;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_array_properties.expected_texture_green_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_array_properties.expected_texture_height = 4;
texture_2d_multisample_array_properties.expected_texture_internal_format = GL_RGB565;
texture_2d_multisample_array_properties.expected_texture_red_size = 5;
/* Return value is implementation-dependent. For current input values GL_UNSIGNED_INT and GL_UNSIGNED_NORMALIZED are valid */
texture_2d_multisample_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_NORMALIZED);
texture_2d_multisample_array_properties.expected_texture_red_types.push_back(GL_UNSIGNED_INT);
texture_2d_multisample_array_properties.expected_texture_samples = max_rgb565_internalformat_samples;
texture_2d_multisample_array_properties.expected_texture_shared_size = 0;
texture_2d_multisample_array_properties.expected_texture_stencil_size = 0;
texture_2d_multisample_array_properties.expected_texture_width = 4;
/* GL_TEXTURE_3D */
texture_3d_properties.depth = 2;
texture_3d_properties.format = GL_RGB;
texture_3d_properties.height = 2;
texture_3d_properties.internalformat = GL_RGB9_E5;
texture_3d_properties.is_2d_texture = false;
texture_3d_properties.target = GL_TEXTURE_3D;
texture_3d_properties.to_id_ptr = &to_3d;
texture_3d_properties.type = GL_FLOAT;
texture_3d_properties.width = 2;
texture_3d_properties.expected_compressed = GL_FALSE;
texture_3d_properties.expected_texture_alpha_size = 0;
texture_3d_properties.expected_texture_alpha_types.push_back(GL_NONE);
texture_3d_properties.expected_texture_blue_size = 9;
texture_3d_properties.expected_texture_blue_types.push_back(GL_FLOAT);
texture_3d_properties.expected_texture_depth = 2;
texture_3d_properties.expected_texture_depth_size = 0;
texture_3d_properties.expected_texture_depth_types.push_back(GL_NONE);
texture_3d_properties.expected_texture_fixed_sample_locations = GL_TRUE;
texture_3d_properties.expected_texture_green_size = 9;
texture_3d_properties.expected_texture_green_types.push_back(GL_FLOAT);
texture_3d_properties.expected_texture_height = 2;
texture_3d_properties.expected_texture_internal_format = GL_RGB9_E5;
texture_3d_properties.expected_texture_red_size = 9;
texture_3d_properties.expected_texture_red_types.push_back(GL_FLOAT);
texture_3d_properties.expected_texture_samples = 0;
texture_3d_properties.expected_texture_shared_size = 5;
texture_3d_properties.expected_texture_stencil_size = 0;
texture_3d_properties.expected_texture_width = 2;
/* GL_TEXTURE_CUBE_MAP_* */
texture_cm_face_properties.format = GL_RGB_INTEGER;
texture_cm_face_properties.height = 1;
texture_cm_face_properties.internalformat = GL_RGB16I;
texture_cm_face_properties.is_cm_texture = true;
texture_cm_face_properties.target = GL_TEXTURE_CUBE_MAP;
texture_cm_face_properties.to_id_ptr = &to_cubemap;
texture_cm_face_properties.type = GL_SHORT;
texture_cm_face_properties.width = 1;
texture_cm_face_properties.expected_compressed = GL_FALSE;
texture_cm_face_properties.expected_texture_alpha_size = 0;
texture_cm_face_properties.expected_texture_alpha_types.push_back(GL_NONE);
texture_cm_face_properties.expected_texture_blue_size = 16;
texture_cm_face_properties.expected_texture_blue_types.push_back(GL_INT);
texture_cm_face_properties.expected_texture_depth = 1;
texture_cm_face_properties.expected_texture_depth_size = 0;
texture_cm_face_properties.expected_texture_depth_types.push_back(GL_NONE);
texture_cm_face_properties.expected_texture_fixed_sample_locations = GL_TRUE;
texture_cm_face_properties.expected_texture_green_size = 16;
texture_cm_face_properties.expected_texture_green_types.push_back(GL_INT);
texture_cm_face_properties.expected_texture_height = 1;
texture_cm_face_properties.expected_texture_internal_format = GL_RGB16I;
texture_cm_face_properties.expected_texture_red_size = 16;
texture_cm_face_properties.expected_texture_red_types.push_back(GL_INT);
texture_cm_face_properties.expected_texture_samples = 0;
texture_cm_face_properties.expected_texture_shared_size = 0;
texture_cm_face_properties.expected_texture_stencil_size = 0;
texture_cm_face_properties.expected_texture_width = 1;
/* The test needs to be run in two iterations:
*
* a) In first run, we need to test immutable textures;
* b) In second one, mutable textures should be used.
*/
for (unsigned int n_iteration = 0; n_iteration < 2 /* immutable/mutable textures */; ++n_iteration)
{
bool is_immutable_run = (n_iteration == 0);
/* Generate texture object IDs */
gl.genTextures(1, &to_2d);
gl.genTextures(1, &to_2d_array);
gl.genTextures(1, &to_2d_multisample);
gl.genTextures(1, &to_2d_multisample_array);
gl.genTextures(1, &to_3d);
gl.genTextures(1, &to_cubemap);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTexture() call(s) failed.");
/* Configure texture storage for each target. */
for (unsigned int n_descriptor = 0; n_descriptor < n_texture_descriptors; ++n_descriptor)
{
const _texture_properties* texture_ptr = texture_descriptors[n_descriptor];
/* Multisample texture targets are not supported by glTexImage*D() API in ES3.1.
* Skip two iterations so that we follow the requirement.
*/
if (!is_immutable_run && (texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE ||
texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES))
{
continue;
}
/* Bind the ID to processed texture target */
gl.bindTexture(texture_ptr->target, *texture_ptr->to_id_ptr);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed");
/* Set up texture storage */
if (is_immutable_run)
{
if (texture_ptr->is_2d_texture)
{
if (texture_ptr->is_multisample_texture)
{
gl.texStorage2DMultisample(texture_ptr->target, texture_ptr->samples,
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
texture_ptr->fixedsamplelocations);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample() call failed");
}
else
{
gl.texStorage2D(texture_ptr->target, 1, /* levels */
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed");
}
}
else if (texture_ptr->is_cm_texture)
{
gl.texStorage2D(GL_TEXTURE_CUBE_MAP, 1, /* levels */
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height);
GLU_EXPECT_NO_ERROR(gl.getError(),
"glTexStorage2D() call failed for GL_TEXTURE_CUBE_MAP texture target");
}
else
{
if (texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES)
{
if (gl_oes_texture_storage_multisample_2d_array_supported)
{
gl.texStorage3DMultisample(texture_ptr->target, texture_ptr->samples,
texture_ptr->internalformat, texture_ptr->width,
texture_ptr->height, texture_ptr->depth,
texture_ptr->fixedsamplelocations);
GLU_EXPECT_NO_ERROR(gl.getError(), "gltexStorage3DMultisample() call failed");
}
else
{
TCU_FAIL("Invalid texture target is being used.");
}
}
else
{
/* Must be a single-sampled 2D array or 3D texture */
gl.texStorage3D(texture_ptr->target, 1, /* levels */
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
texture_ptr->depth);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage3D() call failed");
}
}
} /* if (!is_immutable_run) */
else
{
/* Mutable run */
if (texture_ptr->is_2d_texture)
{
gl.texImage2D(texture_ptr->target, 0, /* level */
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height, 0, /* border */
texture_ptr->format, texture_ptr->type, NULL); /* pixels */
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage2D() call failed");
}
else if (texture_ptr->is_cm_texture)
{
const glw::GLenum cm_texture_targets[] = {
GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
};
const unsigned int n_cm_texture_targets =
sizeof(cm_texture_targets) / sizeof(cm_texture_targets[0]);
for (unsigned int n_cm_texture_target = 0; n_cm_texture_target < n_cm_texture_targets;
++n_cm_texture_target)
{
glw::GLenum texture_target = cm_texture_targets[n_cm_texture_target];
gl.texImage2D(texture_target, 0, /* level */
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
0, /* border */
texture_ptr->format, texture_ptr->type, NULL); /* pixels */
GLU_EXPECT_NO_ERROR(gl.getError(),
"glTexImage2D() call failed for a cube-map face texture target");
} /* for (all cube-map texture targets) */
}
else
{
/* Must be a 2D array texture or 3D texture */
gl.texImage3D(texture_ptr->target, 0, /* level */
texture_ptr->internalformat, texture_ptr->width, texture_ptr->height,
texture_ptr->depth, 0, /* border */
texture_ptr->format, texture_ptr->type, NULL); /* pixels */
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexImage3D() call failed");
}
}
} /* for (all texture descriptors) */
/* Check if correct values are reported for all texture properties described in
* the spec.
*/
typedef std::map<glw::GLenum, const _texture_properties*> target_to_texture_properties_map;
typedef target_to_texture_properties_map::const_iterator target_to_texture_properties_map_const_iterator;
const glw::GLenum pnames[] = { GL_TEXTURE_RED_TYPE,
GL_TEXTURE_GREEN_TYPE,
GL_TEXTURE_BLUE_TYPE,
GL_TEXTURE_ALPHA_TYPE,
GL_TEXTURE_DEPTH_TYPE,
GL_TEXTURE_RED_SIZE,
GL_TEXTURE_GREEN_SIZE,
GL_TEXTURE_BLUE_SIZE,
GL_TEXTURE_ALPHA_SIZE,
GL_TEXTURE_DEPTH_SIZE,
GL_TEXTURE_STENCIL_SIZE,
GL_TEXTURE_SHARED_SIZE,
GL_TEXTURE_COMPRESSED,
GL_TEXTURE_INTERNAL_FORMAT,
GL_TEXTURE_WIDTH,
GL_TEXTURE_HEIGHT,
GL_TEXTURE_DEPTH,
GL_TEXTURE_SAMPLES,
GL_TEXTURE_FIXED_SAMPLE_LOCATIONS };
const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]);
target_to_texture_properties_map targets;
targets[GL_TEXTURE_2D] = &texture_2d_properties;
targets[GL_TEXTURE_2D_ARRAY] = &texture_2d_array_properties;
targets[GL_TEXTURE_2D_MULTISAMPLE] = &texture_2d_multisample_properties;
targets[GL_TEXTURE_3D] = &texture_3d_properties;
targets[GL_TEXTURE_CUBE_MAP_NEGATIVE_X] = &texture_cm_face_properties;
targets[GL_TEXTURE_CUBE_MAP_NEGATIVE_Y] = &texture_cm_face_properties;
targets[GL_TEXTURE_CUBE_MAP_NEGATIVE_Z] = &texture_cm_face_properties;
targets[GL_TEXTURE_CUBE_MAP_POSITIVE_X] = &texture_cm_face_properties;
targets[GL_TEXTURE_CUBE_MAP_POSITIVE_Y] = &texture_cm_face_properties;
targets[GL_TEXTURE_CUBE_MAP_POSITIVE_Z] = &texture_cm_face_properties;
if (gl_oes_texture_storage_multisample_2d_array_supported)
{
targets[GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES] = &texture_2d_multisample_array_properties;
}
for (target_to_texture_properties_map_const_iterator target_iterator = targets.begin();
target_iterator != targets.end(); target_iterator++)
{
glw::GLenum target = target_iterator->first;
const _texture_properties* texture_ptr = target_iterator->second;
/* Multisample texture targets are not supported by glTexImage*D() API in ES3.1.
* Skip two iterations so that we follow the requirement.
*/
if (m_context.getRenderContext().getType().getAPI() == glu::ApiType::es(3, 1) && !is_immutable_run &&
(texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE ||
texture_ptr->target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES))
{
continue;
}
for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname)
{
glw::GLenum pname = pnames[n_pname];
/* Run the check in two stages:
*
* a) Use glGetTexLevelParameteriv() in first run;
* b) Use glGetTexLevelParameterfv() in the other run;
*/
for (unsigned int n_stage = 0; n_stage < 2 /* stages */; ++n_stage)
{
glw::GLfloat float_value = 0.0f;
glw::GLint int_value = 0;
/* Check if the retrieved value is correct */
glw::GLenum expected_error_code = GL_NO_ERROR;
std::vector<glw::GLint> expected_int_values;
switch (pname)
{
case GL_TEXTURE_RED_TYPE:
{
/* Return value is implementation-dependent and not enforced by spec.
* For this pname, more that one value could be valid. */
expected_int_values = texture_ptr->expected_texture_red_types;
break;
}
case GL_TEXTURE_GREEN_TYPE:
{
/* Return value is implementation-dependent and not enforced by spec.
* For this pname, more that one value could be valid. */
expected_int_values = texture_ptr->expected_texture_green_types;
break;
}
case GL_TEXTURE_BLUE_TYPE:
{
/* Return value is implementation-dependent and not enforced by spec.
* For this pname, more that one value could be valid. */
expected_int_values = texture_ptr->expected_texture_blue_types;
break;
}
case GL_TEXTURE_ALPHA_TYPE:
{
/* Return value is implementation-dependent and not enforced by spec.
* For this pname, more that one value could be valid. */
expected_int_values = texture_ptr->expected_texture_alpha_types;
break;
}
case GL_TEXTURE_DEPTH_TYPE:
{
/* Return value is implementation-dependent and not enforced by spec.
* For this pname, more that one value could be valid. */
expected_int_values = texture_ptr->expected_texture_depth_types;
break;
}
case GL_TEXTURE_RED_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_red_size);
break;
}
case GL_TEXTURE_GREEN_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_green_size);
break;
}
case GL_TEXTURE_BLUE_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_blue_size);
break;
}
case GL_TEXTURE_ALPHA_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_alpha_size);
break;
}
case GL_TEXTURE_DEPTH_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_depth_size);
break;
}
case GL_TEXTURE_STENCIL_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_stencil_size);
break;
}
case GL_TEXTURE_SHARED_SIZE:
{
/* Return value is implementation-dependent and not enforced by spec,
* but it can't be less that expected_int_value */
expected_int_values.push_back(texture_ptr->expected_texture_shared_size);
break;
}
case GL_TEXTURE_COMPRESSED:
{
expected_int_values.push_back(texture_ptr->expected_compressed);
break;
}
case GL_TEXTURE_INTERNAL_FORMAT:
{
expected_int_values.push_back(texture_ptr->expected_texture_internal_format);
break;
}
case GL_TEXTURE_WIDTH:
{
expected_int_values.push_back(texture_ptr->expected_texture_width);
break;
}
case GL_TEXTURE_HEIGHT:
{
expected_int_values.push_back(texture_ptr->expected_texture_height);
break;
}
case GL_TEXTURE_DEPTH:
{
expected_int_values.push_back(texture_ptr->expected_texture_depth);
break;
}
case GL_TEXTURE_SAMPLES:
{
expected_int_values.push_back(texture_ptr->expected_texture_samples);
break;
}
case GL_TEXTURE_FIXED_SAMPLE_LOCATIONS:
{
expected_int_values.push_back(texture_ptr->expected_texture_fixed_sample_locations);
break;
}
default:
{
m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized pname [" << pname << "]"
<< tcu::TestLog::EndMessage;
TCU_FAIL("Unrecognized pname");
}
} /* switch (pname) */
/* Do the actual call. If we're expecting an error, make sure it was generated.
* Otherwise, confirm no error was generated by the call */
glw::GLenum error_code = GL_NO_ERROR;
if (n_stage == 0)
{
/* call glGetTexLevelParameteriv() */
gl.getTexLevelParameteriv(target, 0 /* level */, pname, &int_value);
error_code = gl.getError();
if (error_code != expected_error_code)
{
m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameteriv() for pname ["
<< pname << "]"
<< " and target [" << target << "]"
<< " generated an invalid error code [" << error_code << "]"
<< tcu::TestLog::EndMessage;
TCU_FAIL("Error calling glGetTexLevelParameteriv()");
} /* if (error_code != GL_NO_ERROR) */
} /* if (n_stage == 0) */
else
{
/* call glGetTexLevelParameterfv() */
gl.getTexLevelParameterfv(target, 0 /* level */, pname, &float_value);
error_code = gl.getError();
if (error_code != expected_error_code)
{
m_testCtx.getLog() << tcu::TestLog::Message << "glGetTexLevelParameteriv() for pname ["
<< pname << "]"
<< " and target [" << target << "]"
<< " generated an invalid error code [" << error_code << "]"
<< tcu::TestLog::EndMessage;
TCU_FAIL("Error calling glGetTexLevelParameterfv()");
} /* if (error_code != GL_NO_ERROR) */
/* Cast the result to an integer - this is fine since none of the properties we are
* querying is FP.
**/
DE_ASSERT(float_value == (float)(int)float_value);
int_value = (int)float_value;
}
/* Check the result value only if no error was expected */
if (expected_error_code == GL_NO_ERROR)
{
switch (pname)
{
case GL_TEXTURE_RED_SIZE:
case GL_TEXTURE_GREEN_SIZE:
case GL_TEXTURE_BLUE_SIZE:
case GL_TEXTURE_ALPHA_SIZE:
case GL_TEXTURE_DEPTH_SIZE:
case GL_TEXTURE_STENCIL_SIZE:
case GL_TEXTURE_SHARED_SIZE:
case GL_TEXTURE_SAMPLES:
{
/* For some pnames with size, value range is valid.
* For example for GL_RGB16I and GL_TEXTURE_RED_SIZE implementation may return 16 or 32,
* which will still comply with the spec.
* In such case we check if returned value is no less than 16.
*/
if (expected_int_values.at(0) > int_value)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Too small value reported for pname ["
<< pname << "]"
<< " and target [" << target << "]"
<< " expected not less than:[" << expected_int_values.at(0) << "]"
<< " retrieved:[" << int_value << "]" << tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value reported.");
}
break;
}
case GL_TEXTURE_COMPRESSED:
case GL_TEXTURE_INTERNAL_FORMAT:
case GL_TEXTURE_WIDTH:
case GL_TEXTURE_HEIGHT:
case GL_TEXTURE_DEPTH:
case GL_TEXTURE_FIXED_SAMPLE_LOCATIONS:
{
if (expected_int_values.at(0) != int_value)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for pname ["
<< pname << "]"
<< " and target [" << target << "]"
<< " expected:[" << expected_int_values.at(0) << "]"
<< " retrieved:[" << int_value << "]" << tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value reported.");
}
break;
}
case GL_TEXTURE_RED_TYPE:
case GL_TEXTURE_GREEN_TYPE:
case GL_TEXTURE_BLUE_TYPE:
case GL_TEXTURE_ALPHA_TYPE:
case GL_TEXTURE_DEPTH_TYPE:
{
/* For some pnames with types, more than one value could be valid.
* For example for GL_DEPTH24_STENCIL8 and GL_DEPTH_TYPE query, the returned value is implementation
* dependent, some implementations return GL_UNSIGNED_NORMALIZED, other may return GL_UNSIGNED_INT
* depending on hardware specific representation of depth.
*/
std::vector<glw::GLint>::iterator expected_value_it =
find(expected_int_values.begin(), expected_int_values.end(), int_value);
if (expected_value_it == expected_int_values.end())
{
std::ostringstream expected_values_string_stream;
for (std::vector<glw::GLint>::iterator it = expected_int_values.begin();
it != expected_int_values.end(); ++it)
{
if (it != expected_int_values.begin())
{
expected_values_string_stream << ", ";
}
expected_values_string_stream << *it;
}
m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value reported for pname ["
<< pname << "]"
<< " and target [" << target << "]"
<< " expected:[" << expected_values_string_stream.str() << "]"
<< " retrieved:[" << int_value << "]" << tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value reported.");
}
break;
}
default:
{
m_testCtx.getLog() << tcu::TestLog::Message << "Unrecognized pname [" << pname << "]"
<< tcu::TestLog::EndMessage;
TCU_FAIL("Unrecognized pname");
} /* default: */
} /* switch (pname) */
} /* if (expected_error_code == GL_NO_ERROR) */
} /* for (all stages) */
} /* for (all properties) */
} /* for (all texture targets) */
/* Iteration finished - clean up. */
for (unsigned int n_descriptor = 0; n_descriptor < n_texture_descriptors; ++n_descriptor)
{
const _texture_properties* texture_ptr = texture_descriptors[n_descriptor];
/* Release the texture object */
gl.bindTexture(texture_ptr->target, 0);
gl.deleteTextures(1, texture_ptr->to_id_ptr);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteTextures() call failed");
/* Assign a new object to the ID */
gl.genTextures(1, texture_ptr->to_id_ptr);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed");
} /* for (all texture descriptors) */
} /* for (immutable & mutable textures) */
/* All done */
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
/** Constructor.
*
* @param context CTS context handle.
**/
MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest::
MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest(Context& context)
: TestCase(context, "functional_max_lod_test", "Verifies glGetTexLevelParameter{if}v() entry-points work "
"correctly when info about maximum LOD is requested.")
, gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
, to_id(0)
{
/* Left blank on purpose */
}
/** Deinitializes GL ES objects used by the test */
void MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest::deinit()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
if (to_id != 0)
{
gl.deleteTextures(1, &to_id);
to_id = 0;
}
/* Call base class' deinit() */
TestCase::deinit();
}
/** Executes test iteration.
*
* @return Returns STOP when test has finished executing.
*/
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervWorksForMaximumLodTest::iterate()
{
gl_oes_texture_storage_multisample_2d_array_supported =
m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
int number_of_iterations = 0;
/* Generate a texture object and bind id to a 2D multisample texture target */
gl.genTextures(1, &to_id);
gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create a texture object");
if (gl_oes_texture_storage_multisample_2d_array_supported)
{
/* Run in two iterations:
*
* a) Texture storage initialized with glTexStorage2DMultisample();
* b) Texture storage initialized with gltexStorage3DMultisample().
*/
number_of_iterations = 2;
}
else
{
/* Run in one iteration:
*
* a) Texture storage initialized with glTexStorage2DMultisample();
*/
number_of_iterations = 1;
}
/* Run in two iterations:
*
* a) Texture storage initialized with glTexStorage2DMultisample();
* b) Texture storage initialized with gltexStorage3DMultisample().
*/
for (int n_iteration = 0; n_iteration < number_of_iterations; ++n_iteration)
{
bool is_2d_multisample_iteration = (n_iteration == 0);
const int max_lod =
0; /* For multisample textures only lod=0 is valid, queries for lod > 0 will always return GL_NONE, as those lods are not defined for such texture */
glw::GLenum texture_target =
(n_iteration == 0) ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES;
/* Set up texture storage */
if (is_2d_multisample_iteration)
{
gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, /* samples */
GL_RGBA8, 16, /* width */
16, /* height */
GL_FALSE); /* fixedsamplelocations */
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample() call failed");
} /* if (is_2d_multisample_iteration) */
else
{
gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 1, /* samples */
GL_RGBA8, 16, /* width */
16, /* height */
16, /* depth */
GL_FALSE); /* fixedsamplelocations */
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample() call failed");
}
/* Check all glGetTexLevelParameter*() entry-points */
for (int n_api_call = 0; n_api_call < 2 /* iv(), fv() */; ++n_api_call)
{
float float_value = 0;
glw::GLint red_size = 0;
glw::GLint red_type = 0;
glw::GLint texture_internal_format = GL_NONE;
glw::GLint texture_samples = 0;
switch (n_api_call)
{
case 0:
{
gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_RED_TYPE, &red_type);
gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_RED_SIZE, &red_size);
gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_INTERNAL_FORMAT,
&texture_internal_format);
gl.getTexLevelParameteriv(texture_target, max_lod, GL_TEXTURE_SAMPLES, &texture_samples);
GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glGetTexLevelParameteriv() call failed.");
break;
}
case 1:
{
gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_RED_TYPE, &float_value);
red_type = (glw::GLint)float_value;
gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_RED_SIZE, &float_value);
red_size = (glw::GLint)float_value;
gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_INTERNAL_FORMAT, &float_value);
texture_internal_format = (glw::GLint)float_value;
gl.getTexLevelParameterfv(texture_target, max_lod, GL_TEXTURE_SAMPLES, &float_value);
texture_samples = (glw::GLint)float_value;
GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glGetTexLevelParameterfv() call failed.");
break;
}
default:
TCU_FAIL("Unrecognized API call index");
}
/* Make sure the retrieved values are valid
*
* NOTE: The original test case did not make much sense in this regard. */
if (red_type != GL_UNSIGNED_NORMALIZED)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Invalid value returned for a GL_TEXTURE_RED_TYPE query: "
<< "expected:GL_UNSIGNED_NORMALIZED, retrieved:" << red_type
<< tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value returned for a GL_TEXTURE_RED_TYPE query");
}
if (red_size != 8)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Invalid value returned for a GL_TEXTURE_RED_SIZE query: "
<< "expected:8, retrieved:" << red_size << tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value returned for a GL_TEXTURE_RED_SIZE query");
}
if (texture_internal_format != GL_RGBA8)
{
m_testCtx.getLog() << tcu::TestLog::Message
<< "Invalid value returned for a GL_TEXTURE_INTERNAL_FORMAT query: "
<< "expected:GL_RGBA8, retrieved:" << texture_internal_format
<< tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value returned for a GL_TEXTURE_INTERNAL_FORMAT query");
}
/* Implementation is allowed to return more samples than requested */
if (texture_samples < 1)
{
m_testCtx.getLog() << tcu::TestLog::Message << "Invalid value returned for a GL_TEXTURE_SAMPLES query: "
<< "expected:1, retrieved:" << texture_samples << tcu::TestLog::EndMessage;
TCU_FAIL("Invalid value returned for a GL_TEXTURE_SAMPLES query");
}
} /* for (both API call types) */
/* Re-create the texture object and bind it to 2D multisample array texture target */
gl.deleteTextures(1, &to_id);
to_id = 0;
/* Prepare for the next iteration (if needed). */
if (n_iteration == 0 && number_of_iterations == 2)
{
gl.genTextures(1, &to_id);
gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id);
}
GLU_EXPECT_NO_ERROR(gl.getError(), "Could not re-create the texture object.");
} /* for (all iterations) */
/* All done */
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
/** Constructor.
*
* @param context CTS context handle.
**/
MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest::
MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest(Context& context)
: TestCase(context, "invalid_texture_target_rejected", "Verifies glGetTexLevelParameter{if}v() rejects invalid "
"texture target by generating GL_INVALID_ENUM error.")
, float_data(0.0f)
, int_data(0)
{
/* Left blank on purpose */
}
/** Deinitializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest::deinit()
{
/* Call base class' deinit() */
TestCase::deinit();
}
/** Executes test iteration.
*
* @return Returns STOP when test has finished executing.
*/
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervInvalidTextureTargetRejectedTest::iterate()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Call glGetTexLevelParameteriv() with invalid texture target. */
gl.getTexLevelParameteriv(GL_TEXTURE_WIDTH /* invalid value */, 0, /* level */
GL_TEXTURE_RED_TYPE, &int_data);
/* Expect GL_INVALID_ENUM error code. */
TCU_CHECK_MSG(gl.getError() == GL_INVALID_ENUM,
"glGetTexLevelParameteriv() did not generate GL_INVALID_ENUM error.");
/* Call glGetTexLevelParameterfv() with invalid texture target. */
gl.getTexLevelParameterfv(GL_TEXTURE_WIDTH /* invalid value */, 0, /* level */
GL_TEXTURE_RED_TYPE, &float_data);
/* Expect GL_INVALID_ENUM error code. */
TCU_CHECK_MSG(gl.getError() == GL_INVALID_ENUM,
"glGetTexLevelParameterfv() did not generate GL_INVALID_ENUM error.");
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
/** Constructor.
*
* @param context CTS context handle.
**/
MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest::
MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest(Context& context)
: TestCase(context, "invalid_value_argument_rejected", "Verifies glGetTexLevelParameter{if}v() rejects invalid "
"value argument by generating GL_INVALID_VALUE error.")
, float_data(0.0f)
, int_data(0)
{
/* Left blank on purpose */
}
/** Deinitializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest::deinit()
{
/* Call base class' deinit() */
TestCase::deinit();
}
/** Executes test iteration.
*
* @return Returns STOP when test has finished executing.
*/
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervInvalidValueArgumentRejectedTest::iterate()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Call glGetTexLevelParameteriv() with invalid value argument. */
gl.getTexLevelParameteriv(GL_TEXTURE_2D, 0, /* level */
GL_SIGNED_NORMALIZED /* invalid value */, &int_data);
/* From spec:
* An INVALID_ENUM error is generated if pname is not one of the symbolic values in tables 6.12.
*/
/* Expect INVALID_ENUM error code. */
glw::GLenum error_code = gl.getError();
TCU_CHECK_MSG(error_code == GL_INVALID_ENUM, "glGetTexLevelParameteriv() did not generate GL_INVALID_ENUM error.");
/* Call glGetTexLevelParameterfv() with invalid value argument. */
gl.getTexLevelParameterfv(GL_TEXTURE_2D, 0, /* level */
GL_SIGNED_NORMALIZED /* invalid value */, &float_data);
/* Expect INVALID_ENUM error code. */
error_code = gl.getError();
TCU_CHECK_MSG(error_code == GL_INVALID_ENUM, "glGetTexLevelParameterfv() did not generate GL_INVALID_ENUM error.");
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
/** Constructor.
*
* @param context CTS context handle.
**/
MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::
MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest(Context& context)
: TestCase(context, "negative_lod_is_rejected_test", "Verifies glGetTexLevelParameter{if}v() rejects negative "
"<lod> by generating GL_INVALID_VALUE error.")
, float_data(0.0f)
, int_data(0)
, to_id(0)
{
/* Left blank on purpose */
}
/** Deinitializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::deinit()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Bind default texture object to GL_TEXTURE_2D_MULTISAMPLE texture target. */
gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
/* Delete texture object. */
gl.deleteTextures(1, &to_id);
to_id = 0;
/* Check if no error was generated. */
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture object deletion failed.");
/* Call base class' deinit() */
TestCase::deinit();
}
/** Initializes ES objects created during test execution */
void MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::initInternals()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
/* Generate texture object id. */
gl.genTextures(1, &to_id);
/* Bind generated texture object ID to GL_TEXTURE_2D_MULTISAMPLE texture target. */
gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id);
/* Check if no error was generated. */
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture object initialization failed.");
}
/** Executes test iteration.
*
* @return Returns STOP when test has finished executing.
*/
tcu::TestNode::IterateResult MultisampleTextureGetTexLevelParametervNegativeLodIsRejectedTest::iterate()
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
initInternals();
/* Set up texture storage. */
gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 1, /* samples */
GL_RGBA8, 16, /* width */
16, /* height */
GL_FALSE);
/* Check if no error was generated. */
GLU_EXPECT_NO_ERROR(gl.getError(), "Texture object initialization failed.");
/* Call glGetTexLevelParameteriv() with negative lod. */
gl.getTexLevelParameteriv(GL_TEXTURE_2D_MULTISAMPLE, -1 /* negative lod */, GL_TEXTURE_RED_TYPE, &int_data);
/* Expect GL_INVALID_VALUE error code. */
TCU_CHECK_MSG(gl.getError() == GL_INVALID_VALUE,
"glGetTexLevelParameteriv() did not generate GL_INVALID_VALUE error.");
/* Call glGetTexLevelParameterfv() with negative lod. */
gl.getTexLevelParameterfv(GL_TEXTURE_2D_MULTISAMPLE, -1 /* negative lod */, GL_TEXTURE_RED_TYPE, &float_data);
/* Expect GL_INVALID_VALUE error code. */
TCU_CHECK_MSG(gl.getError() == GL_INVALID_VALUE,
"glGetTexLevelParameterfv() did not generate GL_INVALID_VALUE error.");
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
return STOP;
}
} /* glcts namespace */