blob: e9d9b3d2c8104d53d0955134a9292c2aa4b0e4f4 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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 "teglQueryContextTests.hpp"
#include "teglRenderCase.hpp"
#include "teglRenderCase.hpp"
#include "egluCallLogWrapper.hpp"
#include "egluStrUtil.hpp"
#include "tcuCommandLine.hpp"
#include "tcuTestLog.hpp"
#include "tcuTestContext.hpp"
#include "egluUtil.hpp"
#include "egluNativeDisplay.hpp"
#include "egluNativeWindow.hpp"
#include "egluNativePixmap.hpp"
#include "eglwLibrary.hpp"
#include "eglwEnums.hpp"
#include "deUniquePtr.hpp"
#include "deSTLUtil.hpp"
#include <vector>
namespace deqp
{
namespace egl
{
using std::vector;
using eglu::ConfigInfo;
using tcu::TestLog;
using namespace eglw;
static EGLint getClientTypeFromAPIBit (EGLint apiBit)
{
switch (apiBit)
{
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;
}
}
static EGLint getMinClientMajorVersion (EGLint apiBit)
{
switch (apiBit)
{
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 SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
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 (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
const Library& egl = m_eglTestCtx.getLibrary();
TestLog& log = m_testCtx.getLog();
DE_UNREF(display);
DE_UNREF(surface);
DE_UNREF(config);
enableLogging(true);
const EGLContext gotContext = eglGetCurrentContext();
EGLU_CHECK_MSG(egl, "eglGetCurrentContext");
if (gotContext == context)
{
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
else if (gotContext == EGL_NO_CONTEXT)
{
log << TestLog::Message << " Fail, got EGL_NO_CONTEXT" << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected EGL_NO_CONTEXT");
}
else if (gotContext != context)
{
log << TestLog::Message << " Fail, call returned the wrong context. Expected: " << tcu::toHex(context) << ", got: " << tcu::toHex(gotContext) << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid context");
}
enableLogging(false);
}
};
class GetCurrentSurfaceCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
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 (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
const Library& egl = m_eglTestCtx.getLibrary();
TestLog& log = m_testCtx.getLog();
DE_UNREF(display);
DE_UNREF(context);
DE_UNREF(config);
enableLogging(true);
const EGLContext gotReadSurface = eglGetCurrentSurface(EGL_READ);
EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_READ)");
const EGLContext gotDrawSurface = eglGetCurrentSurface(EGL_DRAW);
EGLU_CHECK_MSG(egl, "eglGetCurrentSurface(EGL_DRAW)");
if (gotReadSurface == surface && gotDrawSurface == surface)
{
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
else
{
log << TestLog::Message << " Fail, read surface: " << tcu::toHex(gotReadSurface)
<< ", draw surface: " << tcu::toHex(gotDrawSurface)
<< ", expected: " << tcu::toHex(surface) << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid surface");
}
enableLogging(false);
}
};
class GetCurrentDisplayCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
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 (EGLDisplay display, EGLContext context, EGLSurface surface, const Config& config)
{
const Library& egl = m_eglTestCtx.getLibrary();
TestLog& log = m_testCtx.getLog();
DE_UNREF(surface && context);
DE_UNREF(config);
enableLogging(true);
const EGLDisplay gotDisplay = eglGetCurrentDisplay();
EGLU_CHECK_MSG(egl, "eglGetCurrentDisplay");
if (gotDisplay == display)
{
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
else if (gotDisplay == EGL_NO_DISPLAY)
{
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)
{
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");
}
enableLogging(false);
}
};
class QueryContextCase : public SingleContextRenderCase, private eglu::CallLogWrapper
{
public:
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 (EGLDisplay display, EGLContext context, EGLint attrib)
{
const Library& egl = m_eglTestCtx.getLibrary();
EGLint value;
EGLU_CHECK_CALL(egl, queryContext(display, context, attrib, &value));
return value;
}
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 = eglu::getVersion(egl, display);
DE_UNREF(surface);
enableLogging(true);
// Config ID
{
const EGLint configID = getContextAttrib(display, context, EGL_CONFIG_ID);
const EGLint surfaceConfigID = eglu::getConfigAttribInt(egl, display, config.config, EGL_CONFIG_ID);
if (configID != surfaceConfigID)
{
log << TestLog::Message << " Fail, config ID doesn't match the one used to create the context." << TestLog::EndMessage;
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid config ID");
}
}
// Client API type
if (version >= eglu::Version(1, 2))
{
const EGLint clientType = getContextAttrib(display, context, EGL_CONTEXT_CLIENT_TYPE);
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");
}
}
// Client API version
if (version >= eglu::Version(1, 3))
{
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 (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");
}
}
// Render buffer
if (version >= eglu::Version(1, 2))
{
const EGLint renderBuffer = getContextAttrib(display, context, EGL_RENDER_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 (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 (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");
}
}
enableLogging(false);
log << TestLog::Message << " Pass" << TestLog::EndMessage;
}
};
class QueryAPICase : public TestCase, private eglu::CallLogWrapper
{
public:
QueryAPICase (EglTestContext& eglTestCtx, const char* name, const char* description)
: TestCase (eglTestCtx, name, description)
, CallLogWrapper(eglTestCtx.getLibrary(), eglTestCtx.getTestContext().getLog())
{
}
void init (void)
{
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
}
IterateResult iterate (void)
{
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 && (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 && !(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");
}
}
for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(apis); ndx++)
{
const EGLenum api = apis[ndx];
log << TestLog::Message << TestLog::EndMessage;
if (de::contains(supportedAPIs.begin(), supportedAPIs.end(), api))
{
egl.bindAPI(api);
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");
}
}
else
{
log << TestLog::Message << eglu::getAPIStr(api) << " not supported." << TestLog::EndMessage;
}
}
enableLogging(false);
eglTerminate(display);
return STOP;
}
};
QueryContextTests::QueryContextTests (EglTestContext& eglTestCtx)
: TestCaseGroup(eglTestCtx, "query_context", "Rendering context query tests")
{
}
QueryContextTests::~QueryContextTests (void)
{
}
template<class QueryContextClass>
void createQueryContextGroups (EglTestContext& eglTestCtx, tcu::TestCaseGroup* group)
{
std::vector<RenderFilterList> filterLists;
getDefaultRenderFilterLists(filterLists, eglu::FilterList());
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)
{
{
tcu::TestCaseGroup* simpleGroup = new tcu::TestCaseGroup(m_testCtx, "simple", "Simple API tests");
addChild(simpleGroup);
simpleGroup->addChild(new QueryAPICase(m_eglTestCtx, "query_api", "eglQueryAPI() test"));
}
// eglGetCurrentContext
{
tcu::TestCaseGroup* getCurrentContextGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_context", "eglGetCurrentContext() tests");
addChild(getCurrentContextGroup);
createQueryContextGroups<GetCurrentContextCase>(m_eglTestCtx, getCurrentContextGroup);
}
// eglGetCurrentSurface
{
tcu::TestCaseGroup* getCurrentSurfaceGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_surface", "eglGetCurrentSurface() tests");
addChild(getCurrentSurfaceGroup);
createQueryContextGroups<GetCurrentSurfaceCase>(m_eglTestCtx, getCurrentSurfaceGroup);
}
// eglGetCurrentDisplay
{
tcu::TestCaseGroup* getCurrentDisplayGroup = new tcu::TestCaseGroup(m_testCtx, "get_current_display", "eglGetCurrentDisplay() tests");
addChild(getCurrentDisplayGroup);
createQueryContextGroups<GetCurrentDisplayCase>(m_eglTestCtx, getCurrentDisplayGroup);
}
// eglQueryContext
{
tcu::TestCaseGroup* queryContextGroup = new tcu::TestCaseGroup(m_testCtx, "query_context", "eglQueryContext() tests");
addChild(queryContextGroup);
createQueryContextGroups<QueryContextCase>(m_eglTestCtx, queryContextGroup);
}
}
} // egl
} // deqp