*//*--------------------------------------------------------------------*/
#include "teglQueryContextTests.hpp"
-#include "teglSimpleConfigCase.hpp"
+#include "teglRenderCase.hpp"
#include "teglRenderCase.hpp"
#include "egluCallLogWrapper.hpp"
#include "egluStrUtil.hpp"
#include "egluNativeWindow.hpp"
#include "egluNativePixmap.hpp"
+#include "eglwLibrary.hpp"
+#include "eglwEnums.hpp"
+
#include "deUniquePtr.hpp"
+#include "deSTLUtil.hpp"
#include <vector>
-#include <EGL/eglext.h>
-
-#if !defined(EGL_OPENGL_ES3_BIT_KHR)
-# define EGL_OPENGL_ES3_BIT_KHR 0x0040
-#endif
-#if !defined(EGL_CONTEXT_MAJOR_VERSION_KHR)
-# define EGL_CONTEXT_MAJOR_VERSION_KHR EGL_CONTEXT_CLIENT_VERSION
-#endif
-
namespace deqp
{
namespace egl
{
+using std::vector;
using eglu::ConfigInfo;
using tcu::TestLog;
+using namespace eglw;
-struct ContextCaseInfo
-{
- EGLint surfaceType;
- EGLint clientType;
- EGLint clientVersion;
-};
-
-class ContextCase : public SimpleConfigCase, protected eglu::CallLogWrapper
-{
-public:
- ContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::vector<EGLint>& configIds, EGLint surfaceTypeMask);
- virtual ~ContextCase (void);
-
- void executeForConfig (tcu::egl::Display& display, EGLConfig config);
- void executeForSurface (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, ContextCaseInfo& info);
-
- virtual void executeForContext (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, EGLContext context, ContextCaseInfo& info) = 0;
-
-private:
- EGLint m_surfaceTypeMask;
-};
-
-ContextCase::ContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::vector<EGLint>& configIds, EGLint surfaceTypeMask)
- : SimpleConfigCase (eglTestCtx, name, description, configIds)
- , CallLogWrapper (eglTestCtx.getTestContext().getLog())
- , m_surfaceTypeMask (surfaceTypeMask)
-{
-}
-
-ContextCase::~ContextCase (void)
+static EGLint getClientTypeFromAPIBit (EGLint apiBit)
{
-}
-
-void ContextCase::executeForConfig (tcu::egl::Display& display, EGLConfig config)
-{
- tcu::TestLog& log = m_testCtx.getLog();
- const int width = 64;
- const int height = 64;
- const EGLint configId = display.getConfigAttrib(config, EGL_CONFIG_ID);
- eglu::NativeDisplay& nativeDisplay = m_eglTestCtx.getNativeDisplay();
- bool isOk = true;
- std::string failReason = "";
-
- if (m_surfaceTypeMask & EGL_WINDOW_BIT)
+ switch (apiBit)
{
- log << TestLog::Message << "Creating window surface with config ID " << configId << TestLog::EndMessage;
-
- try
- {
- de::UniquePtr<eglu::NativeWindow> window (m_eglTestCtx.createNativeWindow(display.getEGLDisplay(), config, DE_NULL, width, height, eglu::parseWindowVisibility(m_testCtx.getCommandLine())));
- tcu::egl::WindowSurface surface (display, eglu::createWindowSurface(nativeDisplay, *window, display.getEGLDisplay(), config, DE_NULL));
-
- ContextCaseInfo info;
- info.surfaceType = EGL_WINDOW_BIT;
-
- executeForSurface(m_eglTestCtx.getDisplay(), config, surface.getEGLSurface(), info);
- }
- catch (const tcu::TestError& e)
- {
- log << e;
- isOk = false;
- failReason = e.what();
- }
-
- log << TestLog::Message << TestLog::EndMessage;
+ case EGL_OPENGL_BIT: return EGL_OPENGL_API;
+ case EGL_OPENGL_ES_BIT: return EGL_OPENGL_ES_API;
+ case EGL_OPENGL_ES2_BIT: return EGL_OPENGL_ES_API;
+ case EGL_OPENGL_ES3_BIT: return EGL_OPENGL_ES_API;
+ case EGL_OPENVG_BIT: return EGL_OPENVG_API;
+ default:
+ DE_ASSERT(false);
+ return 0;
}
-
- if (m_surfaceTypeMask & EGL_PIXMAP_BIT)
- {
- log << TestLog::Message << "Creating pixmap surface with config ID " << configId << TestLog::EndMessage;
-
- try
- {
- de::UniquePtr<eglu::NativePixmap> pixmap (m_eglTestCtx.createNativePixmap(display.getEGLDisplay(), config, DE_NULL, width, height));
- tcu::egl::PixmapSurface surface (display, eglu::createPixmapSurface(nativeDisplay, *pixmap, display.getEGLDisplay(), config, DE_NULL));
-
- ContextCaseInfo info;
- info.surfaceType = EGL_PIXMAP_BIT;
-
- executeForSurface(display, config, surface.getEGLSurface(), info);
- }
- catch (const tcu::TestError& e)
- {
- log << e;
- isOk = false;
- failReason = e.what();
- }
-
- log << TestLog::Message << TestLog::EndMessage;
- }
-
- if (m_surfaceTypeMask & EGL_PBUFFER_BIT)
- {
- log << TestLog::Message << "Creating pbuffer surface with config ID " << configId << TestLog::EndMessage;
-
- try
- {
- const EGLint surfaceAttribs[] =
- {
- EGL_WIDTH, width,
- EGL_HEIGHT, height,
- EGL_NONE
- };
-
- tcu::egl::PbufferSurface surface(display, config, surfaceAttribs);
-
- ContextCaseInfo info;
- info.surfaceType = EGL_PBUFFER_BIT;
-
- executeForSurface(display, config, surface.getEGLSurface(), info);
- }
- catch (const tcu::TestError& e)
- {
- log << e;
- isOk = false;
- failReason = e.what();
- }
-
- log << TestLog::Message << TestLog::EndMessage;
- }
-
- if (!isOk && m_testCtx.getTestResult() == QP_TEST_RESULT_PASS)
- m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, failReason.c_str());
}
-void ContextCase::executeForSurface (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, ContextCaseInfo& info)
+static EGLint getMinClientMajorVersion (EGLint apiBit)
{
- TestLog& log = m_testCtx.getLog();
- EGLint apiBits = display.getConfigAttrib(config, EGL_RENDERABLE_TYPE);
-
- static const EGLint es1Attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 1, EGL_NONE };
- static const EGLint es2Attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
- static const EGLint es3Attrs[] = { EGL_CONTEXT_MAJOR_VERSION_KHR, 3, EGL_NONE };
-
- static const struct
- {
- const char* name;
- EGLenum api;
- EGLint apiBit;
- const EGLint* ctxAttrs;
- EGLint apiVersion;
- } apis[] =
- {
- { "OpenGL", EGL_OPENGL_API, EGL_OPENGL_BIT, DE_NULL, 0 },
- { "OpenGL ES 1", EGL_OPENGL_ES_API, EGL_OPENGL_ES_BIT, es1Attrs, 1 },
- { "OpenGL ES 2", EGL_OPENGL_ES_API, EGL_OPENGL_ES2_BIT, es2Attrs, 2 },
- { "OpenGL ES 3", EGL_OPENGL_ES_API, EGL_OPENGL_ES3_BIT_KHR, es3Attrs, 3 },
- { "OpenVG", EGL_OPENVG_API, EGL_OPENVG_BIT, DE_NULL, 0 }
- };
-
- for (int apiNdx = 0; apiNdx < (int)DE_LENGTH_OF_ARRAY(apis); apiNdx++)
+ switch (apiBit)
{
- if ((apiBits & apis[apiNdx].apiBit) == 0)
- continue; // Not supported API
-
- TCU_CHECK_EGL_CALL(eglBindAPI(apis[apiNdx].api));
-
- log << TestLog::Message << "Creating " << apis[apiNdx].name << " context" << TestLog::EndMessage;
-
- const EGLContext context = eglCreateContext(display.getEGLDisplay(), config, EGL_NO_CONTEXT, apis[apiNdx].ctxAttrs);
- TCU_CHECK_EGL();
- TCU_CHECK(context != EGL_NO_CONTEXT);
-
- TCU_CHECK_EGL_CALL(eglMakeCurrent(display.getEGLDisplay(), surface, surface, context));
-
- info.clientType = apis[apiNdx].api;
- info.clientVersion = apis[apiNdx].apiVersion;
-
- executeForContext(display, config, surface, context, info);
-
- // Destroy
- TCU_CHECK_EGL_CALL(eglMakeCurrent(display.getEGLDisplay(), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT));
- TCU_CHECK_EGL_CALL(eglDestroyContext(display.getEGLDisplay(), context));
+ case EGL_OPENGL_BIT: return 1;
+ case EGL_OPENGL_ES_BIT: return 1;
+ case EGL_OPENGL_ES2_BIT: return 2;
+ case EGL_OPENGL_ES3_BIT: return 3;
+ case EGL_OPENVG_BIT: return 1;
+ default:
+ DE_ASSERT(false);
+ return 0;
}
}
-class GetCurrentContextCase : public ContextCase
+class GetCurrentContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
- GetCurrentContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::vector<EGLint>& configIds, EGLint surfaceTypeMask)
- : ContextCase(eglTestCtx, name, description, configIds, surfaceTypeMask)
+ GetCurrentContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
+ : SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
+ , eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
{
}
- void executeForContext (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, EGLContext context, ContextCaseInfo& info)
+ void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
- TestLog& log = m_testCtx.getLog();
+ const Library& egl = m_eglTestCtx.getLibrary();
+ TestLog& log = m_testCtx.getLog();
DE_UNREF(display);
- DE_UNREF(config && surface);
- DE_UNREF(info);
+ DE_UNREF(surface);
+ DE_UNREF(config);
enableLogging(true);
const EGLContext gotContext = eglGetCurrentContext();
- TCU_CHECK_EGL();
+ EGLU_CHECK_MSG(egl, "eglGetCurrentContext");
if (gotContext == context)
{
}
};
-class GetCurrentSurfaceCase : public ContextCase
+class GetCurrentSurfaceCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
- GetCurrentSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::vector<EGLint>& configIds, EGLint surfaceTypeMask)
- : ContextCase(eglTestCtx, name, description, configIds, surfaceTypeMask)
+ GetCurrentSurfaceCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
+ : SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
+ , eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
{
}
- void executeForContext (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, EGLContext context, ContextCaseInfo& info)
+ void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
- TestLog& log = m_testCtx.getLog();
+ const Library& egl = m_eglTestCtx.getLibrary();
+ TestLog& log = m_testCtx.getLog();
DE_UNREF(display);
- DE_UNREF(config && context);
- DE_UNREF(info);
+ DE_UNREF(context);
+ DE_UNREF(config);
enableLogging(true);
const EGLContext gotReadSurface = eglGetCurrentSurface(EGL_READ);
- TCU_CHECK_EGL();
+ EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_READ)");
const EGLContext gotDrawSurface = eglGetCurrentSurface(EGL_DRAW);
- TCU_CHECK_EGL();
+ EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_DRAW)");
if (gotReadSurface == surface && gotDrawSurface == surface)
{
}
};
-class GetCurrentDisplayCase : public ContextCase
+class GetCurrentDisplayCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
- GetCurrentDisplayCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::vector<EGLint>& configIds, EGLint surfaceTypeMask)
- : ContextCase(eglTestCtx, name, description, configIds, surfaceTypeMask)
+ GetCurrentDisplayCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
+ : SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
+ , eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
{
}
- void executeForContext (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, EGLContext context, ContextCaseInfo& info)
+ void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
- TestLog& log = m_testCtx.getLog();
+ const Library& egl = m_eglTestCtx.getLibrary();
+ TestLog& log = m_testCtx.getLog();
- DE_UNREF(config && surface && context);
- DE_UNREF(info);
+ DE_UNREF(surface && context);
+ DE_UNREF(config);
enableLogging(true);
const EGLDisplay gotDisplay = eglGetCurrentDisplay();
- TCU_CHECK_EGL();
+ EGLU_CHECK_MSG(egl, "eglGetCurrentDisplay");
- if (gotDisplay == display.getEGLDisplay())
+ if (gotDisplay == display)
{
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
log << TestLog::Message << " Fail, got EGL_NO_DISPLAY" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected EGL_NO_DISPLAY");
}
- else if (gotDisplay != display.getEGLDisplay())
+ else if (gotDisplay != display)
{
- log << TestLog::Message << " Fail, call returned the wrong display. Expected: " << tcu::toHex(display.getEGLDisplay()) << ", got: " << tcu::toHex(gotDisplay) << TestLog::EndMessage;
+ log << TestLog::Message << " Fail, call returned the wrong display. Expected: " << tcu::toHex(display) << ", got: " << tcu::toHex(gotDisplay) << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid display");
}
}
};
-class QueryContextCase : public ContextCase
+class QueryContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
- QueryContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const std::vector<EGLint>& configIds, EGLint surfaceTypeMask)
- : ContextCase(eglTestCtx, name, description, configIds, surfaceTypeMask)
+ QueryContextCase (EglTestContext& eglTestCtx, const char* name, const char* description, const eglu::FilterList& filters, EGLint surfaceTypeMask)
+ : SingleContextRenderCase (eglTestCtx, name, description, getBuildClientAPIMask(), surfaceTypeMask, filters)
+ , eglu::CallLogWrapper (eglTestCtx.getLibrary(), m_testCtx.getLog())
{
}
- EGLint getContextAttrib (tcu::egl::Display& display, EGLContext context, EGLint attrib)
+ EGLint getContextAttrib (EGLDisplay display, EGLContext context, EGLint attrib)
{
- EGLint value;
- TCU_CHECK_EGL_CALL(eglQueryContext(display.getEGLDisplay(), context, attrib, &value));
+ const Library& egl = m_eglTestCtx.getLibrary();
+ EGLint value;
+ EGLU_CHECK_CALL(egl, queryContext(display, context, attrib, &value));
return value;
}
- void executeForContext (tcu::egl::Display& display, EGLConfig config, EGLSurface surface, EGLContext context, ContextCaseInfo& info)
+ void executeForContext (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
+ const Library& egl = m_eglTestCtx.getLibrary();
TestLog& log = m_testCtx.getLog();
- const eglu::Version version (display.getEGLMajorVersion(), display.getEGLMinorVersion());
+ const eglu::Version version = eglu::getVersion(egl, display);
DE_UNREF(surface);
enableLogging(true);
// Config ID
{
const EGLint configID = getContextAttrib(display, context, EGL_CONFIG_ID);
- const EGLint surfaceConfigID = display.getConfigAttrib(config, EGL_CONFIG_ID);
+ const EGLint surfaceConfigID = eglu::getConfigAttribInt(egl, display, config.config, EGL_CONFIG_ID);
if (configID != surfaceConfigID)
{
{
const EGLint clientType = getContextAttrib(display, context, EGL_CONTEXT_CLIENT_TYPE);
- if (clientType != info.clientType)
+ if (clientType != getClientTypeFromAPIBit(config.apiBits))
{
log << TestLog::Message << " Fail, client API type doesn't match." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid client API type");
const EGLint clientVersion = getContextAttrib(display, context, EGL_CONTEXT_CLIENT_VERSION);
// \todo [2014-10-21 mika] Query actual supported api version from client api to make this check stricter.
- if (info.clientType == EGL_OPENGL_ES_API && ((info.clientVersion == 1 && clientVersion != 1) || clientVersion < info.clientVersion))
+ if (clientVersion < getMinClientMajorVersion(config.apiBits))
{
log << TestLog::Message << " Fail, client API version doesn't match." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid client API version");
{
const EGLint renderBuffer = getContextAttrib(display, context, EGL_RENDER_BUFFER);
- if (info.surfaceType == EGL_PIXMAP_BIT && renderBuffer != EGL_SINGLE_BUFFER)
+ if (config.surfaceTypeBit == EGL_PIXMAP_BIT && renderBuffer != EGL_SINGLE_BUFFER)
{
log << TestLog::Message << " Fail, render buffer should be EGL_SINGLE_BUFFER for a pixmap surface." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
}
- else if (info.surfaceType == EGL_PBUFFER_BIT && renderBuffer != EGL_BACK_BUFFER)
+ else if (config.surfaceTypeBit == EGL_PBUFFER_BIT && renderBuffer != EGL_BACK_BUFFER)
{
log << TestLog::Message << " Fail, render buffer should be EGL_BACK_BUFFER for a pbuffer surface." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
}
- else if (info.surfaceType == EGL_WINDOW_BIT && renderBuffer != EGL_SINGLE_BUFFER && renderBuffer != EGL_BACK_BUFFER)
+ else if (config.surfaceTypeBit == EGL_WINDOW_BIT && renderBuffer != EGL_SINGLE_BUFFER && renderBuffer != EGL_BACK_BUFFER)
{
log << TestLog::Message << " Fail, render buffer should be either EGL_SINGLE_BUFFER or EGL_BACK_BUFFER for a window surface." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid render buffer");
}
};
-class QueryAPICase : public TestCase, protected eglu::CallLogWrapper
+class QueryAPICase : public TestCase, private eglu::CallLogWrapper
{
public:
QueryAPICase (EglTestContext& eglTestCtx, const char* name, const char* description)
- : TestCase(eglTestCtx, name, description)
- , CallLogWrapper(eglTestCtx.getTestContext().getLog())
+ : TestCase (eglTestCtx, name, description)
+ , CallLogWrapper(eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
{
}
IterateResult iterate (void)
{
- tcu::TestLog& log = m_testCtx.getLog();
- const EGLenum apis[] = { EGL_OPENGL_API, EGL_OPENGL_ES_API, EGL_OPENVG_API };
+ const Library& egl = m_eglTestCtx.getLibrary();
+ EGLDisplay display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
+ tcu::TestLog& log = m_testCtx.getLog();
+ const EGLenum apis[] = { EGL_OPENGL_API, EGL_OPENGL_ES_API, EGL_OPENVG_API };
+ const vector<EGLenum> supportedAPIs = eglu::getClientAPIs(egl, display);
enableLogging(true);
{
const EGLenum api = eglQueryAPI();
- if (api != EGL_OPENGL_ES_API && m_eglTestCtx.isAPISupported(EGL_OPENGL_ES_API))
+ if (api != EGL_OPENGL_ES_API && (de::contains(supportedAPIs.begin(), supportedAPIs.end(), EGL_OPENGL_ES_API)))
{
log << TestLog::Message << " Fail, initial value should be EGL_OPENGL_ES_API if OpenGL ES is supported." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default value");
}
- else if(api != EGL_NONE && !m_eglTestCtx.isAPISupported(EGL_OPENGL_ES_API))
+ else if (api != EGL_NONE && !(de::contains(supportedAPIs.begin(), supportedAPIs.end(), EGL_OPENGL_ES_API)))
{
log << TestLog::Message << " Fail, initial value should be EGL_NONE if OpenGL ES is not supported." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid default value");
log << TestLog::Message << TestLog::EndMessage;
- if (m_eglTestCtx.isAPISupported(api))
+ if (de::contains(supportedAPIs.begin(), supportedAPIs.end(), api))
{
- eglBindAPI(api);
+ egl.bindAPI(api);
- if (api != eglQueryAPI())
+ if (api != egl.queryAPI())
{
log << TestLog::Message << " Fail, return value does not match previously bound API." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid return value");
}
enableLogging(false);
+ eglTerminate(display);
return STOP;
}
};
template<class QueryContextClass>
void createQueryContextGroups (EglTestContext& eglTestCtx, tcu::TestCaseGroup* group)
{
- std::vector<RenderConfigIdSet> configSets;
- eglu::FilterList filters;
+ std::vector<RenderFilterList> filterLists;
- getDefaultRenderConfigIdSets(configSets, eglTestCtx.getConfigs(), filters);
+ getDefaultRenderFilterLists(filterLists, eglu::FilterList());
- for (std::vector<RenderConfigIdSet>::const_iterator setIter = configSets.begin(); setIter != configSets.end(); setIter++)
- group->addChild(new QueryContextClass(eglTestCtx, setIter->getName(), "", setIter->getConfigIds(), setIter->getSurfaceTypeMask()));
+ for (std::vector<RenderFilterList>::const_iterator listIter = filterLists.begin(); listIter != filterLists.end(); listIter++)
+ group->addChild(new QueryContextClass(eglTestCtx, listIter->getName(), "", *listIter, listIter->getSurfaceTypeMask()));
}
void QueryContextTests::init (void)
projects / platform / upstream / VK-GL-CTS.git / blobdiff