You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
609 lines
18 KiB
609 lines
18 KiB
/*-------------------------------------------------------------------------
|
|
* 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 "egluUtil.hpp"
|
|
#include "eglwLibrary.hpp"
|
|
#include "eglwEnums.hpp"
|
|
#include "deRandom.hpp"
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
namespace deqp
|
|
{
|
|
namespace egl
|
|
{
|
|
|
|
using eglu::ConfigInfo;
|
|
using tcu::TestLog;
|
|
using namespace eglw;
|
|
|
|
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.getLibrary(), eglTestCtx.getTestContext().getLog())
|
|
, m_display (EGL_NO_DISPLAY)
|
|
{
|
|
}
|
|
|
|
void init (void)
|
|
{
|
|
DE_ASSERT(m_display == EGL_NO_DISPLAY);
|
|
m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
|
|
}
|
|
|
|
void deinit (void)
|
|
{
|
|
m_eglTestCtx.getLibrary().terminate(m_display);
|
|
m_display = EGL_NO_DISPLAY;
|
|
}
|
|
|
|
void checkGetConfigsBounds (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(m_display, &buffer[0], numConfigRequested, &numConfigReturned);
|
|
eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
|
|
|
|
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();
|
|
EGLint numConfigAll;
|
|
|
|
enableLogging(true);
|
|
|
|
eglGetConfigs(m_display, 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(rnd, numConfigAll, rnd.getInt(0, numConfigAll));
|
|
log << TestLog::Message << TestLog::EndMessage;
|
|
}
|
|
|
|
checkGetConfigsBounds(rnd, numConfigAll, -1);
|
|
}
|
|
else
|
|
{
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "No configs");
|
|
}
|
|
|
|
enableLogging(false);
|
|
|
|
return STOP;
|
|
}
|
|
|
|
protected:
|
|
EGLDisplay m_display;
|
|
};
|
|
|
|
class GetConfigAttribCase : public TestCase, protected eglu::CallLogWrapper
|
|
{
|
|
public:
|
|
GetConfigAttribCase (EglTestContext& eglTestCtx, const char* name, const char* description);
|
|
|
|
void init (void);
|
|
void deinit (void);
|
|
IterateResult iterate (void);
|
|
|
|
EGLint getValue (EGLConfig config, EGLenum attrib, bool logValue=true);
|
|
|
|
virtual void executeTest (EGLConfig config) = 0;
|
|
|
|
protected:
|
|
EGLDisplay m_display;
|
|
|
|
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.getLibrary(), eglTestCtx.getTestContext().getLog())
|
|
, m_display (EGL_NO_DISPLAY)
|
|
{
|
|
}
|
|
|
|
void GetConfigAttribCase::init (void)
|
|
{
|
|
DE_ASSERT(m_display == EGL_NO_DISPLAY);
|
|
m_display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
|
|
m_configs = eglu::getConfigs(m_eglTestCtx.getLibrary(), m_display);
|
|
m_configsIter = m_configs.begin();
|
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
|
|
}
|
|
|
|
void GetConfigAttribCase::deinit (void)
|
|
{
|
|
m_eglTestCtx.getLibrary().terminate(m_display);
|
|
m_display = EGL_NO_DISPLAY;
|
|
}
|
|
|
|
tcu::TestNode::IterateResult GetConfigAttribCase::iterate (void)
|
|
{
|
|
tcu::TestLog& log = m_testCtx.getLog();
|
|
|
|
if (m_configsIter == m_configs.end())
|
|
{
|
|
log << TestLog::Message << "No configs available." << TestLog::EndMessage;
|
|
return STOP;
|
|
}
|
|
|
|
{
|
|
const EGLConfig config = *m_configsIter;
|
|
EGLint id;
|
|
|
|
eglGetConfigAttrib(m_display, config, EGL_CONFIG_ID, &id);
|
|
eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
|
|
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();
|
|
EGLint value;
|
|
|
|
eglGetConfigAttrib(m_display, config, attrib, &value);
|
|
eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
|
|
|
|
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)
|
|
{
|
|
const bool isRGBBuffer = value == EGL_RGB_BUFFER;
|
|
const bool isLuminanceBuffer = value == EGL_LUMINANCE_BUFFER;
|
|
const bool isYuvBuffer = value == EGL_YUV_BUFFER_EXT;
|
|
const bool hasYuvSupport = eglu::hasExtension(m_eglTestCtx.getLibrary(), m_display, "EGL_EXT_yuv_surface");
|
|
|
|
if (!(isRGBBuffer || isLuminanceBuffer || (isYuvBuffer && hasYuvSupport)))
|
|
{
|
|
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();
|
|
eglu::Version version = eglu::getVersion(m_eglTestCtx.getLibrary(), m_display);
|
|
|
|
if (!isAttributePresent(version, m_attrib))
|
|
{
|
|
log << TestLog::Message << eglu::getConfigAttribStr(m_attrib) << " not supported by this EGL version";
|
|
}
|
|
else
|
|
{
|
|
EGLint value;
|
|
|
|
enableLogging(true);
|
|
|
|
eglGetConfigAttrib(m_display, config, m_attrib, &value);
|
|
eglu::checkError(eglGetError(), DE_NULL, __FILE__, __LINE__);
|
|
|
|
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
|