/*-------------------------------------------------------------------------
* drawElements Quality Program EGL Module
* ---------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* 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 Config query tests.
*//*--------------------------------------------------------------------*/
#include "teglQueryConfigTests.hpp"
#include "teglSimpleConfigCase.hpp"
#include "tcuTestLog.hpp"
#include "tcuTestContext.hpp"
#include "tcuCommandLine.hpp"
#include "egluCallLogWrapper.hpp"
#include "egluStrUtil.hpp"
#include "deRandom.hpp"
#include <string>
#include <vector>
#if !defined(EGL_OPENGL_ES3_BIT_KHR)
# define EGL_OPENGL_ES3_BIT_KHR 0x0040
#endif
namespace deqp
{
namespace egl
{
using eglu::ConfigInfo;
using tcu::TestLog;
static void logConfigAttribute (TestLog& log, EGLenum attrib, EGLint value)
{
log << TestLog::Message << " " << eglu::getConfigAttribName(attrib) << ": " << eglu::getConfigAttribValueStr(attrib, value) << TestLog::EndMessage;
}
static bool isAttributePresent (const eglu::Version& version, EGLenum attribute)
{
switch (attribute)
{
case EGL_CONFORMANT:
if (version < eglu::Version(1, 3)) return false;
break;
case EGL_LUMINANCE_SIZE:
case EGL_ALPHA_MASK_SIZE:
case EGL_COLOR_BUFFER_TYPE:
case EGL_MATCH_NATIVE_PIXMAP:
if (version < eglu::Version(1, 2)) return false;
break;
case EGL_BIND_TO_TEXTURE_RGB:
case EGL_BIND_TO_TEXTURE_RGBA:
case EGL_MAX_SWAP_INTERVAL:
case EGL_MIN_SWAP_INTERVAL:
case EGL_RENDERABLE_TYPE:
if (version < eglu::Version(1, 1)) return false;
break;
default:
break;
}
return true;
}
class GetConfigsBoundsCase : public TestCase, protected eglu::CallLogWrapper
{
public:
GetConfigsBoundsCase (EglTestContext& eglTestCtx, const char* name, const char* description)
: TestCase (eglTestCtx, name, description)
, CallLogWrapper(eglTestCtx.getTestContext().getLog())
{
}
void init (void)
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
void checkGetConfigsBounds(const tcu::egl::Display& display, de::Random& rnd, const int numConfigAll, const int numConfigRequested)
{
tcu::TestLog& log = m_testCtx.getLog();
std::vector<EGLConfig> buffer (numConfigAll + 10);
std::vector<deUint32> magicBuffer ((buffer.size() * sizeof(EGLConfig)) / sizeof(deUint32) + 1);
const EGLConfig* magicConfigs = reinterpret_cast<EGLConfig*>(&magicBuffer[0]);
int numConfigReturned;
// Fill buffers with magic
for (size_t ndx = 0; ndx < magicBuffer.size(); ndx++) magicBuffer[ndx] = rnd.getUint32();
for (size_t ndx = 0; ndx < buffer.size(); ndx++) buffer[ndx] = magicConfigs[ndx];
eglGetConfigs(display.getEGLDisplay(), &buffer[0], numConfigRequested, &numConfigReturned);
TCU_CHECK_EGL();
log << TestLog::Message << numConfigReturned << " configs returned" << TestLog::EndMessage;
// Compare results with stored magic
{
int numOverwritten = 0;
for (size_t ndx = 0; ndx < buffer.size(); ndx++)
{
if (buffer[ndx] == magicConfigs[ndx])
{
numOverwritten = (int)ndx;
break;
}
}
log << TestLog::Message << numOverwritten << " values actually written" << TestLog::EndMessage;
if (numConfigReturned > deMax32(numConfigRequested, 0))
{
log << TestLog::Message << "Fail, more configs returned than requested." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Too many configs returned");
}
if (numOverwritten > deMax32(numConfigReturned, 0))
{
log << TestLog::Message << "Fail, buffer overflow detected." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Buffer overflow");
}
else if (numOverwritten != numConfigReturned)
{
log << TestLog::Message << "Fail, reported number of returned configs differs from number of values written." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Incorrect size");
}
}
}
IterateResult iterate (void)
{
tcu::TestLog& log = m_testCtx.getLog();
tcu::egl::Display& display = m_eglTestCtx.getDisplay();
EGLint numConfigAll;
enableLogging(true);
eglGetConfigs(display.getEGLDisplay(), 0, 0, &numConfigAll);
log << TestLog::Message << numConfigAll << " configs available" << TestLog::EndMessage;
log << TestLog::Message << TestLog::EndMessage;
if (numConfigAll > 0)
{
de::Random rnd (123);
for (int i = 0; i < 5; i++)
{
checkGetConfigsBounds(display, rnd, numConfigAll, rnd.getInt(0, numConfigAll));
log << TestLog::Message << TestLog::EndMessage;
}
checkGetConfigsBounds(display, rnd, numConfigAll, -1);
}
else
{
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "No configs");
}
enableLogging(false);
return STOP;
}
};
class GetConfigAttribCase : public TestCase, protected eglu::CallLogWrapper
{
public:
GetConfigAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description);
void init ();
IterateResult iterate (void);
EGLint getValue (EGLConfig config, EGLenum attrib, bool logValue=true);
virtual void executeTest (EGLConfig config) = 0;
private:
std::vector<EGLConfig> m_configs;
std::vector<EGLConfig>::const_iterator m_configsIter;
};
GetConfigAttribCase::GetConfigAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description)
: TestCase(eglTestCtx, name, description)
, CallLogWrapper(eglTestCtx.getTestContext().getLog())
{
}
void GetConfigAttribCase::init (void)
{
const tcu::egl::Display& display = m_eglTestCtx.getDisplay();
display.getConfigs(m_configs);
m_configsIter = m_configs.begin();
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
tcu::TestNode::IterateResult GetConfigAttribCase::iterate (void)
{
tcu::TestLog& log = m_testCtx.getLog();
tcu::egl::Display& display = m_eglTestCtx.getDisplay();
if (m_configsIter == m_configs.end())
{
log << TestLog::Message << "No configs available." << TestLog::EndMessage;
return STOP;
}
{
const EGLConfig config = *m_configsIter;
EGLint id;
TCU_CHECK_EGL_CALL(eglGetConfigAttrib(display.getEGLDisplay(), config, EGL_CONFIG_ID, &id));
log << TestLog::Message << "Config ID " << id << TestLog::EndMessage;
executeTest(config);
}
log << TestLog::Message << TestLog::EndMessage;
m_configsIter++;
if (m_configsIter == m_configs.end())
return STOP;
else
return CONTINUE;
}
EGLint GetConfigAttribCase::getValue (EGLConfig config, EGLenum attrib, bool logValue)
{
TestLog& log = m_testCtx.getLog();
const tcu::egl::Display& display = m_eglTestCtx.getDisplay();
EGLint value;
eglGetConfigAttrib(display.getEGLDisplay(), config, attrib, &value);
TCU_CHECK_EGL();
if (logValue) logConfigAttribute(log, attrib, value);
return value;
}
class GetConfigAttribSimpleCase : public GetConfigAttribCase
{
public:
GetConfigAttribSimpleCase (EglTestContext& eglTestCtx, const char* name, const char* description, EGLenum attribute)
: GetConfigAttribCase(eglTestCtx, name, description)
, m_attrib(attribute)
{
}
void checkColorBufferType (EGLint value)
{
if (!(value == EGL_RGB_BUFFER || value == EGL_LUMINANCE_BUFFER))
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Message << "Fail, invalid EGL_COLOR_BUFFER_TYPE value" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
}
}
void checkCaveat (EGLint value)
{
if (!(value == EGL_NONE || value == EGL_SLOW_CONFIG || value == EGL_NON_CONFORMANT_CONFIG))
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Message << "Fail, invalid EGL_CONFIG_CAVEAT value" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
}
}
void checkTransparentType (EGLint value)
{
if (!(value == EGL_NONE || value == EGL_TRANSPARENT_RGB))
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Message << "Fail, invalid EGL_TRANSPARENT_TYPE value" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
}
}
void checkBoolean (EGLenum attrib, EGLint value)
{
if (!(value == EGL_FALSE || value == EGL_TRUE))
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Message << "Fail, " << eglu::getConfigAttribStr(attrib) << " should be a boolean value." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
}
}
void checkInteger (EGLenum attrib, EGLint value)
{
if (attrib == EGL_NATIVE_VISUAL_ID || attrib == EGL_NATIVE_VISUAL_TYPE) // Implementation-defined
return;
if (attrib == EGL_CONFIG_ID && value < 1)
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Message << "Fail, config IDs should be positive integer values beginning from 1." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
}
}
void checkSurfaceTypeMask (EGLint value)
{
const EGLint wantedBits = EGL_WINDOW_BIT | EGL_PIXMAP_BIT | EGL_PBUFFER_BIT;
if ((value & wantedBits) == 0)
{
TestLog& log = m_testCtx.getLog();
log << TestLog::Message << "Fail, config does not actually support creation of any surface type?" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
}
}
void checkAttribute (EGLenum attrib, EGLint value)
{
switch (attrib)
{
case EGL_COLOR_BUFFER_TYPE:
checkColorBufferType(value);
break;
case EGL_CONFIG_CAVEAT:
checkCaveat(value);
break;
case EGL_TRANSPARENT_TYPE:
checkTransparentType(value);
break;
case EGL_CONFORMANT:
case EGL_RENDERABLE_TYPE:
// Just print what we know
break;
case EGL_SURFACE_TYPE:
checkSurfaceTypeMask(value);
break;
case EGL_BIND_TO_TEXTURE_RGB:
case EGL_BIND_TO_TEXTURE_RGBA:
case EGL_NATIVE_RENDERABLE:
checkBoolean(attrib, value);
break;
default:
checkInteger(attrib, value);
}
}
void executeTest (EGLConfig config)
{
TestLog& log = m_testCtx.getLog();
const tcu::egl::Display& display = m_eglTestCtx.getDisplay();
if (!isAttributePresent(display.getVersion(), m_attrib))
{
log << TestLog::Message << eglu::getConfigAttribStr(m_attrib) << " not supported by this EGL version";
}
else
{
EGLint value;
enableLogging(true);
eglGetConfigAttrib(display.getEGLDisplay(), config, m_attrib, &value);
TCU_CHECK_EGL();
logConfigAttribute(log, m_attrib, value);
checkAttribute(m_attrib, value);
enableLogging(false);
}
}
private:
EGLenum m_attrib;
};
class GetConfigAttribBufferSizeCase : public GetConfigAttribCase
{
public:
GetConfigAttribBufferSizeCase (EglTestContext& eglTestCtx, const char* name, const char* description)
: GetConfigAttribCase(eglTestCtx, name, description)
{
}
void executeTest (EGLConfig config)
{
TestLog& log = m_testCtx.getLog();
const EGLint colorBufferType = getValue(config, EGL_COLOR_BUFFER_TYPE);
const EGLint bufferSize = getValue(config, EGL_BUFFER_SIZE);
const EGLint redSize = getValue(config, EGL_RED_SIZE);
const EGLint greenSize = getValue(config, EGL_GREEN_SIZE);
const EGLint blueSize = getValue(config, EGL_BLUE_SIZE);
const EGLint luminanceSize = getValue(config, EGL_LUMINANCE_SIZE);
const EGLint alphaSize = getValue(config, EGL_ALPHA_SIZE);
if (alphaSize < 0)
{
log << TestLog::Message << "Fail, alpha size must be zero or positive." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid alpha size");
}
if (colorBufferType == EGL_RGB_BUFFER)
{
if (luminanceSize != 0)
{
log << TestLog::Message << "Fail, luminance size must be zero for an RGB buffer." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid luminance size");
}
if (redSize <= 0 || greenSize <= 0 || blueSize <= 0)
{
log << TestLog::Message << "Fail, RGB component sizes must be positive for an RGB buffer." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color component size");
}
if (bufferSize != (redSize + greenSize + blueSize + alphaSize))
{
log << TestLog::Message << "Fail, buffer size must be equal to the sum of RGB component sizes and alpha size." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid buffer size");
}
}
else if (colorBufferType == EGL_LUMINANCE_BUFFER)
{
if (luminanceSize <= 0)
{
log << TestLog::Message << "Fail, luminance size must be positive for a luminance buffer." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid luminance size");
}
if (redSize != 0 || greenSize != 0 || blueSize != 0)
{
log << TestLog::Message << "Fail, RGB component sizes must be zero for a luminance buffer." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid color component size");
}
if (bufferSize != (luminanceSize + alphaSize))
{
log << TestLog::Message << "Fail, buffer size must be equal to the sum of luminance size and alpha size." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid buffer size");
}
}
}
};
class GetConfigAttribTransparentValueCase : public GetConfigAttribCase
{
public:
GetConfigAttribTransparentValueCase (EglTestContext& eglTestCtx, const char* name, const char* description)
: GetConfigAttribCase(eglTestCtx, name, description)
{
}
void executeTest (EGLConfig config)
{
TestLog& log = m_testCtx.getLog();
const EGLint transparentType = getValue(config, EGL_TRANSPARENT_TYPE);
const EGLint redValue = getValue(config, EGL_TRANSPARENT_RED_VALUE);
const EGLint greenValue = getValue(config, EGL_TRANSPARENT_GREEN_VALUE);
const EGLint blueValue = getValue(config, EGL_TRANSPARENT_BLUE_VALUE);
const EGLint redSize = getValue(config, EGL_RED_SIZE);
const EGLint greenSize = getValue(config, EGL_GREEN_SIZE);
const EGLint blueSize = getValue(config, EGL_BLUE_SIZE);
if (transparentType == EGL_TRANSPARENT_RGB)
{
if ( (redValue < 0 || redValue >= (1 << redSize))
|| (greenValue < 0 || greenValue >= (1 << greenSize))
|| (blueValue < 0 || blueValue >= (1 << blueSize)) )
{
log << TestLog::Message << "Fail, transparent color values must lie between 0 and the maximum component value." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid transparent color value");
}
}
}
};
QueryConfigTests::QueryConfigTests (EglTestContext& eglTestCtx)
: TestCaseGroup(eglTestCtx, "query_config", "Surface config query tests")
{
}
QueryConfigTests::~QueryConfigTests (void)
{
}
void QueryConfigTests::init (void)
{
// eglGetGonfigs
{
tcu::TestCaseGroup* getConfigsGroup = new tcu::TestCaseGroup(m_testCtx, "get_configs", "eglGetConfigs tests");
addChild(getConfigsGroup);
getConfigsGroup->addChild(new GetConfigsBoundsCase(m_eglTestCtx, "get_configs_bounds", "eglGetConfigs bounds checking test"));
}
// eglGetConfigAttrib
{
static const struct
{
EGLenum attribute;
const char* testName;
} attributes[] =
{
{ EGL_BUFFER_SIZE, "buffer_size" },
{ EGL_RED_SIZE, "red_size" },
{ EGL_GREEN_SIZE, "green_size" },
{ EGL_BLUE_SIZE, "blue_size" },
{ EGL_LUMINANCE_SIZE, "luminance_size" },
{ EGL_ALPHA_SIZE, "alpha_size" },
{ EGL_ALPHA_MASK_SIZE, "alpha_mask_size" },
{ EGL_BIND_TO_TEXTURE_RGB, "bind_to_texture_rgb" },
{ EGL_BIND_TO_TEXTURE_RGBA, "bind_to_texture_rgba" },
{ EGL_COLOR_BUFFER_TYPE, "color_buffer_type" },
{ EGL_CONFIG_CAVEAT, "config_caveat" },
{ EGL_CONFIG_ID, "config_id" },
{ EGL_CONFORMANT, "conformant" },
{ EGL_DEPTH_SIZE, "depth_size" },
{ EGL_LEVEL, "level" },
{ EGL_MAX_SWAP_INTERVAL, "max_swap_interval" },
{ EGL_MIN_SWAP_INTERVAL, "min_swap_interval" },
{ EGL_NATIVE_RENDERABLE, "native_renderable" },
{ EGL_NATIVE_VISUAL_TYPE, "native_visual_type" },
{ EGL_RENDERABLE_TYPE, "renderable_type" },
{ EGL_SAMPLE_BUFFERS, "sample_buffers" },
{ EGL_SAMPLES, "samples" },
{ EGL_STENCIL_SIZE, "stencil_size" },
{ EGL_SURFACE_TYPE, "surface_type" },
{ EGL_TRANSPARENT_TYPE, "transparent_type" },
{ EGL_TRANSPARENT_RED_VALUE, "transparent_red_value" },
{ EGL_TRANSPARENT_GREEN_VALUE, "transparent_green_value" },
{ EGL_TRANSPARENT_BLUE_VALUE, "transparent_blue_value" }
};
tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "get_config_attrib", "eglGetConfigAttrib() tests");
addChild(simpleGroup);
for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(attributes); ndx++)
{
simpleGroup->addChild(new GetConfigAttribSimpleCase(m_eglTestCtx, attributes[ndx].testName, "Simple attribute query case", attributes[ndx].attribute));
}
}
// Attribute constraints
{
tcu::TestCaseGroup* constraintsGroup = new tcu::TestCaseGroup(m_testCtx, "constraints", "Attribute constraint tests");
addChild(constraintsGroup);
constraintsGroup->addChild(new GetConfigAttribBufferSizeCase(m_eglTestCtx, "color_buffer_size", "Color buffer component sizes"));
constraintsGroup->addChild(new GetConfigAttribTransparentValueCase(m_eglTestCtx, "transparent_value", "Transparent color value"));
}
}
} // egl
} // deqp