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.
1335 lines
46 KiB
1335 lines
46 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 EGL EGL_KHR_fence_sync and EGL_KHR_reusable_sync tests |
|
*//*--------------------------------------------------------------------*/ |
|
|
|
#include "teglSyncTests.hpp" |
|
|
|
#include "egluNativeWindow.hpp" |
|
#include "egluStrUtil.hpp" |
|
#include "egluUtil.hpp" |
|
|
|
#include "eglwLibrary.hpp" |
|
#include "eglwEnums.hpp" |
|
|
|
#include "tcuTestLog.hpp" |
|
#include "tcuCommandLine.hpp" |
|
|
|
#include "gluDefs.hpp" |
|
|
|
#include "glwFunctions.hpp" |
|
#include "glwEnums.hpp" |
|
|
|
#include <vector> |
|
#include <string> |
|
#include <sstream> |
|
#include <set> |
|
|
|
using std::vector; |
|
using std::string; |
|
using std::set; |
|
|
|
using tcu::TestLog; |
|
|
|
using namespace eglw; |
|
using namespace glw; |
|
|
|
namespace deqp |
|
{ |
|
namespace egl |
|
{ |
|
namespace |
|
{ |
|
|
|
const char* getSyncTypeName (EGLenum syncType) |
|
{ |
|
switch (syncType) |
|
{ |
|
case EGL_SYNC_FENCE_KHR: return "EGL_SYNC_FENCE_KHR"; |
|
case EGL_SYNC_REUSABLE_KHR: return "EGL_SYNC_REUSABLE_KHR"; |
|
default: |
|
DE_ASSERT(DE_FALSE); |
|
return "<Unknown>"; |
|
} |
|
} |
|
|
|
class SyncTest : public TestCase |
|
{ |
|
public: |
|
enum Extension |
|
{ |
|
EXTENSION_NONE = 0, |
|
EXTENSION_WAIT_SYNC = (0x1 << 0), |
|
EXTENSION_FENCE_SYNC = (0x1 << 1), |
|
EXTENSION_REUSABLE_SYNC = (0x1 << 2) |
|
}; |
|
SyncTest (EglTestContext& eglTestCtx, EGLenum syncType, Extension extensions, bool useCurrentContext, const char* name, const char* description); |
|
~SyncTest (void); |
|
|
|
void init (void); |
|
void deinit (void); |
|
|
|
protected: |
|
const EGLenum m_syncType; |
|
const Extension m_extensions; |
|
const bool m_useCurrentContext; |
|
|
|
glw::Functions m_gl; |
|
|
|
EGLDisplay m_eglDisplay; |
|
EGLConfig m_eglConfig; |
|
EGLSurface m_eglSurface; |
|
eglu::NativeWindow* m_nativeWindow; |
|
EGLContext m_eglContext; |
|
EGLSyncKHR m_sync; |
|
}; |
|
|
|
SyncTest::SyncTest (EglTestContext& eglTestCtx, EGLenum syncType, Extension extensions, bool useCurrentContext, const char* name, const char* description) |
|
: TestCase (eglTestCtx, name, description) |
|
, m_syncType (syncType) |
|
, m_extensions (extensions) |
|
, m_useCurrentContext (useCurrentContext) |
|
, m_eglDisplay (EGL_NO_DISPLAY) |
|
, m_eglSurface (EGL_NO_SURFACE) |
|
, m_nativeWindow (DE_NULL) |
|
, m_eglContext (EGL_NO_CONTEXT) |
|
, m_sync (EGL_NO_SYNC_KHR) |
|
{ |
|
} |
|
|
|
SyncTest::~SyncTest (void) |
|
{ |
|
SyncTest::deinit(); |
|
} |
|
|
|
void requiredEGLExtensions (const Library& egl, EGLDisplay display, SyncTest::Extension requiredExtensions) |
|
{ |
|
SyncTest::Extension foundExtensions = SyncTest::EXTENSION_NONE; |
|
std::istringstream extensionStream(egl.queryString(display, EGL_EXTENSIONS)); |
|
string extension; |
|
|
|
EGLU_CHECK_MSG(egl, "eglQueryString(display, EGL_EXTENSIONS)"); |
|
|
|
while (std::getline(extensionStream, extension, ' ')) |
|
{ |
|
if (extension == "EGL_KHR_fence_sync") |
|
foundExtensions = (SyncTest::Extension)(foundExtensions | SyncTest::EXTENSION_FENCE_SYNC); |
|
else if (extension == "EGL_KHR_reusable_sync") |
|
foundExtensions = (SyncTest::Extension)(foundExtensions | SyncTest::EXTENSION_REUSABLE_SYNC); |
|
else if (extension == "EGL_KHR_wait_sync") |
|
foundExtensions = (SyncTest::Extension)(foundExtensions | SyncTest::EXTENSION_WAIT_SYNC); |
|
} |
|
|
|
{ |
|
const SyncTest::Extension missingExtensions = (SyncTest::Extension)((foundExtensions & requiredExtensions) ^ requiredExtensions); |
|
|
|
if ((missingExtensions & SyncTest::EXTENSION_FENCE_SYNC) != 0) |
|
TCU_THROW(NotSupportedError, "EGL_KHR_fence_sync not supported"); |
|
|
|
if ((missingExtensions & SyncTest::EXTENSION_REUSABLE_SYNC) != 0) |
|
TCU_THROW(NotSupportedError, "EGL_KHR_reusable_sync not supported"); |
|
|
|
if ((missingExtensions & SyncTest::EXTENSION_WAIT_SYNC) != 0) |
|
TCU_THROW(NotSupportedError, "EGL_KHR_wait_sync not supported"); |
|
} |
|
} |
|
|
|
void requiredGLESExtensions (const glw::Functions& gl) |
|
{ |
|
bool found = false; |
|
std::istringstream extensionStream((const char*)gl.getString(GL_EXTENSIONS)); |
|
string extension; |
|
|
|
GLU_CHECK_GLW_MSG(gl, "glGetString(GL_EXTENSIONS)"); |
|
|
|
while (std::getline(extensionStream, extension, ' ')) |
|
{ |
|
if (extension == "GL_OES_EGL_sync") |
|
found = true; |
|
} |
|
|
|
if (!found) |
|
TCU_THROW(NotSupportedError, "GL_OES_EGL_sync not supported"); |
|
} |
|
|
|
SyncTest::Extension getSyncTypeExtension (EGLenum syncType) |
|
{ |
|
switch (syncType) |
|
{ |
|
case EGL_SYNC_FENCE_KHR: return SyncTest::EXTENSION_FENCE_SYNC; |
|
case EGL_SYNC_REUSABLE_KHR: return SyncTest::EXTENSION_REUSABLE_SYNC; |
|
default: |
|
DE_ASSERT(DE_FALSE); |
|
return SyncTest::EXTENSION_NONE; |
|
} |
|
} |
|
|
|
void SyncTest::init (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
const eglu::NativeWindowFactory& windowFactory = eglu::selectNativeWindowFactory(m_eglTestCtx.getNativeDisplayFactory(), m_testCtx.getCommandLine()); |
|
|
|
const EGLint displayAttribList[] = |
|
{ |
|
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, |
|
EGL_SURFACE_TYPE, EGL_WINDOW_BIT, |
|
EGL_ALPHA_SIZE, 1, |
|
EGL_NONE |
|
}; |
|
|
|
const EGLint contextAttribList[] = |
|
{ |
|
EGL_CONTEXT_CLIENT_VERSION, 2, |
|
EGL_NONE |
|
}; |
|
|
|
m_eglDisplay = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay()); |
|
m_eglConfig = eglu::chooseSingleConfig(egl, m_eglDisplay, displayAttribList); |
|
|
|
m_eglTestCtx.initGLFunctions(&m_gl, glu::ApiType::es(2,0)); |
|
|
|
{ |
|
const Extension syncTypeExtension = getSyncTypeExtension(m_syncType); |
|
requiredEGLExtensions(egl, m_eglDisplay, (Extension)(m_extensions | syncTypeExtension)); |
|
} |
|
|
|
if (m_useCurrentContext) |
|
{ |
|
// Create context |
|
EGLU_CHECK_CALL(egl, bindAPI(EGL_OPENGL_ES_API)); |
|
m_eglContext = egl.createContext(m_eglDisplay, m_eglConfig, EGL_NO_CONTEXT, contextAttribList); |
|
EGLU_CHECK_MSG(egl, "Failed to create GLES2 context"); |
|
|
|
// Create surface |
|
m_nativeWindow = windowFactory.createWindow(&m_eglTestCtx.getNativeDisplay(), m_eglDisplay, m_eglConfig, DE_NULL, eglu::WindowParams(480, 480, eglu::parseWindowVisibility(m_testCtx.getCommandLine()))); |
|
m_eglSurface = eglu::createWindowSurface(m_eglTestCtx.getNativeDisplay(), *m_nativeWindow, m_eglDisplay, m_eglConfig, DE_NULL); |
|
|
|
EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglContext)); |
|
|
|
requiredGLESExtensions(m_gl); |
|
} |
|
} |
|
|
|
void SyncTest::deinit (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
|
|
if (m_eglDisplay != EGL_NO_DISPLAY) |
|
{ |
|
if (m_sync != EGL_NO_SYNC_KHR) |
|
{ |
|
EGLU_CHECK_CALL(egl, destroySyncKHR(m_eglDisplay, m_sync)); |
|
m_sync = EGL_NO_SYNC_KHR; |
|
} |
|
|
|
EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
|
|
|
if (m_eglContext != EGL_NO_CONTEXT) |
|
{ |
|
EGLU_CHECK_CALL(egl, destroyContext(m_eglDisplay, m_eglContext)); |
|
m_eglContext = EGL_NO_CONTEXT; |
|
} |
|
|
|
if (m_eglSurface != EGL_NO_SURFACE) |
|
{ |
|
EGLU_CHECK_CALL(egl, destroySurface(m_eglDisplay, m_eglSurface)); |
|
m_eglSurface = EGL_NO_SURFACE; |
|
} |
|
|
|
delete m_nativeWindow; |
|
m_nativeWindow = DE_NULL; |
|
|
|
egl.terminate(m_eglDisplay); |
|
m_eglDisplay = EGL_NO_DISPLAY; |
|
} |
|
} |
|
|
|
class CreateNullAttribsTest : public SyncTest |
|
{ |
|
public: |
|
CreateNullAttribsTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_null_attribs", "create_null_attribs") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class CreateEmptyAttribsTest : public SyncTest |
|
{ |
|
public: |
|
CreateEmptyAttribsTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_empty_attribs", "create_empty_attribs") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
|
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
const EGLint attribList[] = |
|
{ |
|
EGL_NONE |
|
}; |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, attribList); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", { EGL_NONE })" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class CreateInvalidDisplayTest : public SyncTest |
|
{ |
|
public: |
|
CreateInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_display", "create_invalid_display") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(EGL_NO_DISPLAY, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(EGL_NO_DISPLAY, " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_DISPLAY) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(m_sync == EGL_NO_SYNC_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class CreateInvalidTypeTest : public SyncTest |
|
{ |
|
public: |
|
CreateInvalidTypeTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_type", "create_invalid_type") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, EGL_NONE, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", EGL_NONE, NULL)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_ATTRIBUTE) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(m_sync == EGL_NO_SYNC_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class CreateInvalidAttribsTest : public SyncTest |
|
{ |
|
public: |
|
CreateInvalidAttribsTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_attribs", "create_invalid_attribs") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
EGLint attribs[] = { |
|
2, 3, 4, 5, |
|
EGL_NONE |
|
}; |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, attribs); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", { 2, 3, 4, 5, EGL_NONE })" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_ATTRIBUTE) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(m_sync == EGL_NO_SYNC_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class CreateInvalidContextTest : public SyncTest |
|
{ |
|
public: |
|
CreateInvalidContextTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "create_invalid_context", "create_invalid_context") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
log << TestLog::Message << "eglMakeCurrent(" << m_eglDisplay << ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << TestLog::EndMessage; |
|
EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_MATCH) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_MATCH" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(m_sync == EGL_NO_SYNC_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class ClientWaitNoTimeoutTest : public SyncTest |
|
{ |
|
public: |
|
ClientWaitNoTimeoutTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_no_timeout", "wait_no_timeout") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, 0, 0); |
|
log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, 0)" << TestLog::EndMessage; |
|
|
|
if (m_syncType == EGL_SYNC_FENCE_KHR) |
|
TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR || status == EGL_TIMEOUT_EXPIRED_KHR); |
|
else if (m_syncType == EGL_SYNC_REUSABLE_KHR) |
|
TCU_CHECK(status == EGL_TIMEOUT_EXPIRED_KHR); |
|
else |
|
DE_ASSERT(DE_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
|
|
}; |
|
|
|
class ClientWaitForeverTest : public SyncTest |
|
{ |
|
public: |
|
ClientWaitForeverTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_forever", "wait_forever") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
if (m_syncType == EGL_SYNC_REUSABLE_KHR) |
|
{ |
|
EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR); |
|
log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()"); |
|
} |
|
else if (m_syncType == EGL_SYNC_FENCE_KHR) |
|
{ |
|
GLU_CHECK_GLW_CALL(m_gl, flush()); |
|
log << TestLog::Message << "glFlush()" << TestLog::EndMessage; |
|
} |
|
else |
|
DE_ASSERT(DE_FALSE); |
|
|
|
EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, 0, EGL_FOREVER_KHR); |
|
log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, EGL_FOREVER_KHR)" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR); |
|
EGLU_CHECK_MSG(egl, "eglClientWaitSyncKHR()"); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class ClientWaitNoContextTest : public SyncTest |
|
{ |
|
public: |
|
ClientWaitNoContextTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_no_context", "wait_no_Context") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
|
|
if (m_syncType == EGL_SYNC_REUSABLE_KHR) |
|
{ |
|
EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR); |
|
log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()"); |
|
} |
|
else if (m_syncType == EGL_SYNC_FENCE_KHR) |
|
{ |
|
GLU_CHECK_GLW_CALL(m_gl, flush()); |
|
log << TestLog::Message << "glFlush()" << TestLog::EndMessage; |
|
} |
|
else |
|
DE_ASSERT(DE_FALSE); |
|
|
|
log << TestLog::Message << "eglMakeCurrent(" << m_eglDisplay << ", EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)" << TestLog::EndMessage; |
|
EGLU_CHECK_CALL(egl, makeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT)); |
|
|
|
EGLint result = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, 0, EGL_FOREVER_KHR); |
|
log << TestLog::Message << result << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, EGL_FOREVER_KHR)" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(result == EGL_CONDITION_SATISFIED_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class ClientWaitForeverFlushTest : public SyncTest |
|
{ |
|
public: |
|
ClientWaitForeverFlushTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_forever_flush", "wait_forever_flush") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
if (m_syncType == EGL_SYNC_REUSABLE_KHR) |
|
{ |
|
EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR); |
|
log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()"); |
|
} |
|
|
|
EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR); |
|
log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR)" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class ClientWaitInvalidDisplayTest : public SyncTest |
|
{ |
|
public: |
|
ClientWaitInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_invalid_display", "wait_invalid_display") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint status = egl.clientWaitSyncKHR(EGL_NO_DISPLAY, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR); |
|
log << TestLog::Message << status << " = eglClientWaitSyncKHR(EGL_NO_DISPLAY, " << m_sync << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_DISPLAY) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(status == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class ClientWaitInvalidSyncTest : public SyncTest |
|
{ |
|
public: |
|
ClientWaitInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "wait_invalid_sync", "wait_invalid_sync") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, EGL_NO_SYNC_KHR, 0, EGL_FOREVER_KHR); |
|
log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR, 0, EGL_FOREVER_KHR)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_PARAMETER) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(status == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncTypeTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncTypeTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_type", "get_type") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint type = 0; |
|
EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_TYPE_KHR, &type)); |
|
log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_TYPE_KHR, {" << type << "})" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(type == ((EGLint)m_syncType)); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncStatusTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncStatusTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_status", "get_status") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint status = 0; |
|
EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_STATUS_KHR, &status)); |
|
log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_STATUS_KHR, {" << status << "})" << TestLog::EndMessage; |
|
|
|
if (m_syncType == EGL_SYNC_FENCE_KHR) |
|
TCU_CHECK(status == EGL_SIGNALED_KHR || status == EGL_UNSIGNALED_KHR); |
|
else if (m_syncType == EGL_SYNC_REUSABLE_KHR) |
|
TCU_CHECK(status == EGL_UNSIGNALED_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncStatusSignaledTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncStatusSignaledTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_status_signaled", "get_status_signaled") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
if (m_syncType == EGL_SYNC_REUSABLE_KHR) |
|
{ |
|
EGLBoolean ret = egl.signalSyncKHR(m_eglDisplay, m_sync, EGL_SIGNALED_KHR); |
|
log << TestLog::Message << ret << " = eglSignalSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SIGNALED_KHR)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglSignalSyncKHR()"); |
|
} |
|
else if (m_syncType == EGL_SYNC_FENCE_KHR) |
|
{ |
|
GLU_CHECK_GLW_CALL(m_gl, finish()); |
|
log << TestLog::Message << "glFinish()" << TestLog::EndMessage; |
|
} |
|
else |
|
DE_ASSERT(DE_FALSE); |
|
|
|
{ |
|
EGLint status = egl.clientWaitSyncKHR(m_eglDisplay, m_sync, EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR); |
|
log << TestLog::Message << status << " = eglClientWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_FLUSH_COMMANDS_BIT_KHR, EGL_FOREVER_KHR)" << TestLog::EndMessage; |
|
TCU_CHECK(status == EGL_CONDITION_SATISFIED_KHR); |
|
} |
|
|
|
EGLint status = 0; |
|
EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_STATUS_KHR, &status)); |
|
log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_STATUS_KHR, {" << status << "})" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(status == EGL_SIGNALED_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncConditionTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncConditionTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_condition", "get_condition") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint condition = 0; |
|
EGLU_CHECK_CALL(egl, getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_CONDITION_KHR, &condition)); |
|
log << TestLog::Message << "eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_CONDITION_KHR, {" << condition << "})" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(condition == EGL_SYNC_PRIOR_COMMANDS_COMPLETE_KHR); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncInvalidDisplayTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"get_invalid_display", "get_invalid_display") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint condition = 0xF0F0F; |
|
EGLBoolean result = egl.getSyncAttribKHR(EGL_NO_DISPLAY, m_sync, EGL_SYNC_CONDITION_KHR, &condition); |
|
log << TestLog::Message << result << " = eglGetSyncAttribKHR(EGL_NO_DISPLAY, " << m_sync << ", EGL_SYNC_CONDITION_KHR, {" << condition << "})" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_DISPLAY) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(result == EGL_FALSE); |
|
TCU_CHECK(condition == 0xF0F0F); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncInvalidSyncTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType)\ |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR, "get_invalid_sync", "get_invalid_sync") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
EGLint condition = 0xF0F0F; |
|
EGLBoolean result = egl.getSyncAttribKHR(m_eglDisplay, EGL_NO_SYNC_KHR, EGL_SYNC_CONDITION_KHR, &condition); |
|
log << TestLog::Message << result << " = eglGetSyncAttribKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR, EGL_SYNC_CONDITION_KHR, {" << condition << "})" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_PARAMETER) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(result == EGL_FALSE); |
|
TCU_CHECK(condition == 0xF0F0F); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncInvalidAttributeTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncInvalidAttributeTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"get_invalid_attribute", "get_invalid_attribute") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint condition = 0xF0F0F; |
|
EGLBoolean result = egl.getSyncAttribKHR(m_eglDisplay, m_sync, EGL_NONE, &condition); |
|
log << TestLog::Message << result << " = eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_NONE, {" << condition << "})" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_ATTRIBUTE) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_ATTRIBUTE" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(result == EGL_FALSE); |
|
TCU_CHECK(condition == 0xF0F0F); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class GetSyncInvalidValueTest : public SyncTest |
|
{ |
|
public: |
|
GetSyncInvalidValueTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"get_invalid_value", "get_invalid_value") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLBoolean result = egl.getSyncAttribKHR(m_eglDisplay, m_sync, EGL_SYNC_TYPE_KHR, NULL); |
|
log << TestLog::Message << result << " = eglGetSyncAttribKHR(" << m_eglDisplay << ", " << m_sync << ", EGL_SYNC_CONDITION_KHR, NULL)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_PARAMETER) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(result == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class DestroySyncTest : public SyncTest |
|
{ |
|
public: |
|
DestroySyncTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"destroy", "destroy") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << "eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
log << TestLog::Message << "eglDestroySyncKHR(" << m_eglDisplay << ", " << m_sync << ")" << TestLog::EndMessage; |
|
EGLU_CHECK_CALL(egl, destroySyncKHR(m_eglDisplay, m_sync)); |
|
m_sync = EGL_NO_SYNC_KHR; |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class DestroySyncInvalidDislayTest : public SyncTest |
|
{ |
|
public: |
|
DestroySyncInvalidDislayTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest(eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"destroy_invalid_display", "destroy_invalid_display") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << "eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLBoolean result = egl.destroySyncKHR(EGL_NO_DISPLAY, m_sync); |
|
log << TestLog::Message << result << " = eglDestroySyncKHR(EGL_NO_DISPLAY, " << m_sync << ")" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_DISPLAY) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(result == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class DestroySyncInvalidSyncTest : public SyncTest |
|
{ |
|
public: |
|
DestroySyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_NONE, syncType != EGL_SYNC_REUSABLE_KHR,"destroy_invalid_sync", "destroy_invalid_sync") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
EGLBoolean result = egl.destroySyncKHR(m_eglDisplay, EGL_NO_SYNC_KHR); |
|
log << TestLog::Message << result << " = eglDestroySyncKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_PARAMETER) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(result == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class WaitSyncTest : public SyncTest |
|
{ |
|
public: |
|
WaitSyncTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server", "wait_server") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint status = egl.waitSyncKHR(m_eglDisplay, m_sync, 0); |
|
log << TestLog::Message << status << " = eglWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0, 0)" << TestLog::EndMessage; |
|
|
|
TCU_CHECK(status == EGL_TRUE); |
|
|
|
GLU_CHECK_GLW_CALL(m_gl, finish()); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
|
|
}; |
|
|
|
class WaitSyncInvalidDisplayTest : public SyncTest |
|
{ |
|
public: |
|
WaitSyncInvalidDisplayTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server_invalid_display", "wait_server_invalid_display") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint status = egl.waitSyncKHR(EGL_NO_DISPLAY, m_sync, 0); |
|
log << TestLog::Message << status << " = eglWaitSyncKHR(EGL_NO_DISPLAY, " << m_sync << ", 0)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_DISPLAY) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_DISPLAY" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(status == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class WaitSyncInvalidSyncTest : public SyncTest |
|
{ |
|
public: |
|
WaitSyncInvalidSyncTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server_invalid_sync", "wait_server_invalid_sync") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
EGLint status = egl.waitSyncKHR(m_eglDisplay, EGL_NO_SYNC_KHR, 0); |
|
log << TestLog::Message << status << " = eglWaitSyncKHR(" << m_eglDisplay << ", EGL_NO_SYNC_KHR, 0)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_PARAMETER) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(status == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
class WaitSyncInvalidFlagTest : public SyncTest |
|
{ |
|
public: |
|
WaitSyncInvalidFlagTest (EglTestContext& eglTestCtx, EGLenum syncType) |
|
: SyncTest (eglTestCtx, syncType, SyncTest::EXTENSION_WAIT_SYNC, true, "wait_server_invalid_flag", "wait_server_invalid_flag") |
|
{ |
|
} |
|
|
|
IterateResult iterate (void) |
|
{ |
|
const Library& egl = m_eglTestCtx.getLibrary(); |
|
TestLog& log = m_testCtx.getLog(); |
|
|
|
m_sync = egl.createSyncKHR(m_eglDisplay, m_syncType, NULL); |
|
log << TestLog::Message << m_sync << " = eglCreateSyncKHR(" << m_eglDisplay << ", " << getSyncTypeName(m_syncType) << ", NULL)" << TestLog::EndMessage; |
|
EGLU_CHECK_MSG(egl, "eglCreateSyncKHR()"); |
|
|
|
EGLint status = egl.waitSyncKHR(m_eglDisplay, m_sync, 0xFFFFFFFF); |
|
log << TestLog::Message << status << " = eglWaitSyncKHR(" << m_eglDisplay << ", " << m_sync << ", 0xFFFFFFFF)" << TestLog::EndMessage; |
|
|
|
EGLint error = egl.getError(); |
|
log << TestLog::Message << error << " = eglGetError()" << TestLog::EndMessage; |
|
|
|
if (error != EGL_BAD_PARAMETER) |
|
{ |
|
log << TestLog::Message << "Unexpected error '" << eglu::getErrorStr(error) << "' expected EGL_BAD_PARAMETER" << TestLog::EndMessage; |
|
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail"); |
|
return STOP; |
|
} |
|
|
|
TCU_CHECK(status == EGL_FALSE); |
|
|
|
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
|
return STOP; |
|
} |
|
}; |
|
|
|
} // anonymous |
|
|
|
FenceSyncTests::FenceSyncTests (EglTestContext& eglTestCtx) |
|
: TestCaseGroup (eglTestCtx, "fence_sync", "EGL_KHR_fence_sync extension tests") |
|
{ |
|
} |
|
|
|
void FenceSyncTests::init (void) |
|
{ |
|
// Add valid API test |
|
{ |
|
TestCaseGroup* const valid = new TestCaseGroup(m_eglTestCtx, "valid", "Valid function calls"); |
|
|
|
// eglCreateSyncKHR tests |
|
valid->addChild(new CreateNullAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new CreateEmptyAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglClientWaitSyncKHR tests |
|
valid->addChild(new ClientWaitNoTimeoutTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new ClientWaitForeverTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new ClientWaitNoContextTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new ClientWaitForeverFlushTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglGetSyncAttribKHR tests |
|
valid->addChild(new GetSyncTypeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new GetSyncStatusTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new GetSyncStatusSignaledTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
valid->addChild(new GetSyncConditionTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglDestroySyncKHR tests |
|
valid->addChild(new DestroySyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglWaitSyncKHR tests |
|
valid->addChild(new WaitSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
addChild(valid); |
|
} |
|
|
|
// Add negative API tests |
|
{ |
|
TestCaseGroup* const invalid = new TestCaseGroup(m_eglTestCtx, "invalid", "Invalid function calls"); |
|
|
|
// eglCreateSyncKHR tests |
|
invalid->addChild(new CreateInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new CreateInvalidTypeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new CreateInvalidAttribsTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new CreateInvalidContextTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglClientWaitSyncKHR tests |
|
invalid->addChild(new ClientWaitInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new ClientWaitInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglGetSyncAttribKHR tests |
|
invalid->addChild(new GetSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new GetSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new GetSyncInvalidAttributeTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new GetSyncInvalidValueTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglDestroySyncKHR tests |
|
invalid->addChild(new DestroySyncInvalidDislayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new DestroySyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
// eglWaitSyncKHR tests |
|
invalid->addChild(new WaitSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new WaitSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
invalid->addChild(new WaitSyncInvalidFlagTest(m_eglTestCtx, EGL_SYNC_FENCE_KHR)); |
|
|
|
addChild(invalid); |
|
} |
|
} |
|
|
|
ReusableSyncTests::ReusableSyncTests (EglTestContext& eglTestCtx) |
|
: TestCaseGroup (eglTestCtx, "reusable_sync", "EGL_KHR_reusable_sync extension tests") |
|
{ |
|
} |
|
|
|
void ReusableSyncTests::init (void) |
|
{ |
|
// Add valid API test |
|
{ |
|
TestCaseGroup* const valid = new TestCaseGroup(m_eglTestCtx, "valid", "Valid function calls"); |
|
|
|
// eglCreateSyncKHR tests |
|
valid->addChild(new CreateNullAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
valid->addChild(new CreateEmptyAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglClientWaitSyncKHR tests |
|
valid->addChild(new ClientWaitNoTimeoutTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
valid->addChild(new ClientWaitForeverTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
valid->addChild(new ClientWaitNoContextTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
valid->addChild(new ClientWaitForeverFlushTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglGetSyncAttribKHR tests |
|
valid->addChild(new GetSyncTypeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
valid->addChild(new GetSyncStatusTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
valid->addChild(new GetSyncStatusSignaledTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglDestroySyncKHR tests |
|
valid->addChild(new DestroySyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglWaitSyncKHR tests |
|
valid->addChild(new WaitSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
addChild(valid); |
|
} |
|
|
|
// Add negative API tests |
|
{ |
|
TestCaseGroup* const invalid = new TestCaseGroup(m_eglTestCtx, "invalid", "Invalid function calls"); |
|
|
|
// eglCreateSyncKHR tests |
|
invalid->addChild(new CreateInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new CreateInvalidTypeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new CreateInvalidAttribsTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglClientWaitSyncKHR tests |
|
invalid->addChild(new ClientWaitInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new ClientWaitInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglGetSyncAttribKHR tests |
|
invalid->addChild(new GetSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new GetSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new GetSyncInvalidAttributeTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new GetSyncInvalidValueTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglDestroySyncKHR tests |
|
invalid->addChild(new DestroySyncInvalidDislayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new DestroySyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
// eglWaitSyncKHR tests |
|
invalid->addChild(new WaitSyncInvalidDisplayTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new WaitSyncInvalidSyncTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
invalid->addChild(new WaitSyncInvalidFlagTest(m_eglTestCtx, EGL_SYNC_REUSABLE_KHR)); |
|
|
|
addChild(invalid); |
|
} |
|
} |
|
|
|
} // egl |
|
} // deqp
|
|
|