bool SortConfig::operator()(const Config &x, const Config &y) const
{
#define SORT(attribute) \
if (x.attribute != y.attribute) \
{ \
return x.attribute < y.attribute; \
}
META_ASSERT(EGL_NONE < EGL_SLOW_CONFIG && EGL_SLOW_CONFIG < EGL_NON_CONFORMANT_CONFIG);
SORT(mConfigCaveat);
META_ASSERT(EGL_RGB_BUFFER < EGL_LUMINANCE_BUFFER);
SORT(mColorBufferType);
// By larger total number of color bits, only considering those that are requested to be > 0.
EGLint xComponentsSize = wantedComponentsSize(x);
EGLint yComponentsSize = wantedComponentsSize(y);
if (xComponentsSize != yComponentsSize)
{
return xComponentsSize > yComponentsSize;
}
SORT(mBufferSize);
SORT(mSampleBuffers);
SORT(mSamples);
SORT(mDepthSize);
SORT(mStencilSize);
SORT(mAlphaMaskSize);
SORT(mNativeVisualType);
SORT(mConfigID);
#undef SORT
return false;
}
bool ValidateGetVertexAttribParameters(GLenum pname, int clientVersion)
{
switch (pname)
{
case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
case GL_VERTEX_ATTRIB_ARRAY_SIZE:
case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
case GL_VERTEX_ATTRIB_ARRAY_TYPE:
case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
case GL_CURRENT_VERTEX_ATTRIB:
return true;
case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
// Don't verify ES3 context because GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE uses
// the same constant.
META_ASSERT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
return true;
case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
return ((clientVersion >= 3) ? true : gl::error(GL_INVALID_ENUM, false));
default:
return gl::error(GL_INVALID_ENUM, false);
}
}
bool ValidQueryType(const Context *context, GLenum queryType)
{
META_ASSERT(GL_ANY_SAMPLES_PASSED == GL_ANY_SAMPLES_PASSED_EXT);
META_ASSERT(GL_ANY_SAMPLES_PASSED_CONSERVATIVE == GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT);
switch (queryType)
{
case GL_ANY_SAMPLES_PASSED:
case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
return true;
case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
return (context->getClientVersion() >= 3);
default:
return false;
}
}
bool ValidFramebufferTarget(GLenum target)
{
META_ASSERT(GL_DRAW_FRAMEBUFFER_ANGLE == GL_DRAW_FRAMEBUFFER && GL_READ_FRAMEBUFFER_ANGLE == GL_READ_FRAMEBUFFER);
switch (target)
{
case GL_FRAMEBUFFER: return true;
case GL_READ_FRAMEBUFFER: return true;
case GL_DRAW_FRAMEBUFFER: return true;
default: return false;
}
}
Error ValidateCreateContext(Display *display, Config *configuration, gl::Context *shareContext,
const AttributeMap& attributes)
{
Error error = ValidateConfig(display, configuration);
if (error.isError())
{
return error;
}
// Get the requested client version (default is 1) and check it is 2 or 3.
EGLint clientMajorVersion = 1;
EGLint clientMinorVersion = 0;
EGLint contextFlags = 0;
bool resetNotification = false;
bool robustAccess = false;
for (AttributeMap::const_iterator attributeIter = attributes.begin(); attributeIter != attributes.end(); attributeIter++)
{
EGLint attribute = attributeIter->first;
EGLint value = attributeIter->second;
switch (attribute)
{
case EGL_CONTEXT_CLIENT_VERSION:
clientMajorVersion = value;
break;
case EGL_CONTEXT_MINOR_VERSION:
clientMinorVersion = value;
break;
case EGL_CONTEXT_FLAGS_KHR:
contextFlags = value;
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
// Only valid for OpenGL (non-ES) contexts
return Error(EGL_BAD_ATTRIBUTE);
case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
if (!display->getExtensions().createContextRobustness)
{
return Error(EGL_BAD_ATTRIBUTE);
}
if (value != EGL_TRUE && value != EGL_FALSE)
{
return Error(EGL_BAD_ATTRIBUTE);
}
robustAccess = (value == EGL_TRUE);
break;
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR:
META_ASSERT(EGL_LOSE_CONTEXT_ON_RESET_EXT == EGL_LOSE_CONTEXT_ON_RESET_KHR);
META_ASSERT(EGL_NO_RESET_NOTIFICATION_EXT == EGL_NO_RESET_NOTIFICATION_KHR);
// same as EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT, fall through
case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
if (!display->getExtensions().createContextRobustness)
{
return Error(EGL_BAD_ATTRIBUTE);
}
if (value == EGL_LOSE_CONTEXT_ON_RESET_EXT)
{
resetNotification = true;
}
else if (value != EGL_NO_RESET_NOTIFICATION_EXT)
{
return Error(EGL_BAD_ATTRIBUTE);
}
break;
default:
return Error(EGL_BAD_ATTRIBUTE);
}
}
if ((clientMajorVersion != 2 && clientMajorVersion != 3) || clientMinorVersion != 0)
{
return Error(EGL_BAD_CONFIG);
}
if (clientMajorVersion == 3 && !(configuration->conformant & EGL_OPENGL_ES3_BIT_KHR))
{
return Error(EGL_BAD_CONFIG);
}
// Note: EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR does not apply to ES
const EGLint validContextFlags = (EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR |
EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR);
if ((contextFlags & ~validContextFlags) != 0)
{
return Error(EGL_BAD_ATTRIBUTE);
}
if ((contextFlags & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) > 0)
{
robustAccess = true;
}
if (robustAccess)
{
// Unimplemented
return Error(EGL_BAD_CONFIG);
}
if (shareContext)
{
// Shared context is invalid or is owned by another display
if (!display->isValidContext(shareContext))
{
return Error(EGL_BAD_MATCH);
}
if (shareContext->isResetNotificationEnabled() != resetNotification)
{
return Error(EGL_BAD_MATCH);
}
if (shareContext->getClientVersion() != clientMajorVersion)
{
return Error(EGL_BAD_CONTEXT);
}
}
return Error(EGL_SUCCESS);
}
void TestIfAssertDisabled(TheType IF_MOD_ASSERT_REPORTS(type))
{
int a=1;
EXPECT_NO_FAILURE;
MOD_ASSERT_G(type, ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
MOD_ASSERT_PG(a, type, ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
MOD_ASSERT_GO(type, ++a, "++a", ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
MOD_ASSERT_PGO(a, type, ++a, "++a", ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
// the condition should still be evaluated,
// so a should increase
MOD_VERIFY_G(type, ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
MOD_VERIFY_PG(a, type, ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 3));
MOD_VERIFY_GO(type, ++a, "++a", ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 4));
MOD_VERIFY_PGO(a, type, ++a, "++a", ++a==0);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 5));
Inc inc_a(a);
int rv = 0;
a=0;
rv = MOD_VERIFY_VG(type, a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VPG((a), type, a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VGO(type, inc_a, "++a", a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VPGO((a), type, inc_a, "++a", a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VNPG(type, a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VSPG((a), type, a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VNPGO(type, inc_a, "++a", a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VSPGO((a), type, inc_a, "++a", a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv = MOD_VERIFY_VG(type, rbvMORE(a++,1));
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
META_ASSERT(rbEQUAL(rv, 0));
}
void TestIfAssertEnabled(TheType IF_MOD_ASSERT_REPORTS(type))
{
int a=1;
EXPECT_ASSERT_G(false, "++a==0", NULL, NULL, type, NULL);
MOD_ASSERT_G(type, ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
EXPECT_ASSERT_G(false, "++a==0", NULL, CreateParameterList()("a", 3), type, NULL);
MOD_ASSERT_PG(a, type, ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 3));
EXPECT_ASSERT_G(false, "++a==0", NULL, NULL, type, "++a");
MOD_ASSERT_GO(type, ++a, "++a", ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 4));
EXPECT_ASSERT_G(false, "++a==0", NULL, CreateParameterList()("a", 5), type, "++a");
MOD_ASSERT_PGO(a, type, ++a, "++a", ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 5));
a=1;
// the condition should still be evaluated,
// so a should increase
EXPECT_ASSERT_G(false, "++a==0", NULL, NULL, type, NULL);
MOD_VERIFY_G(type, ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
EXPECT_ASSERT_G(false, "++a==0", NULL, CreateParameterList()("a", 3), type, NULL);
MOD_VERIFY_PG(a, type, ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 3));
EXPECT_ASSERT_G(false, "++a==0", NULL, NULL, type, "++a");
MOD_VERIFY_GO(type, ++a, "++a", ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 4));
EXPECT_ASSERT_G(false, "++a==0", NULL, CreateParameterList()("a", 5), type, "++a");
MOD_VERIFY_PGO(a, type, ++a, "++a", ++a==0);
META_ASSERT(CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 5));
// in the macros that return a value, the order of evaluation
// of the condition and the expressions is undefined,
// so we use a different variable
IF_MOD_ASSERT_REPORTS(int n=27;)
void TestIfCheckDisabled(TheType IF_MOD_CHECK_REPORTS(type))
{
int a=1;
// the condition should still be evaluated,
// so a should increase
// the condition always fails, so it's increased twice
MOD_CHECK_G(type, ++a==0, ++a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 3));
MOD_CHECK_PG(a, type, ++a==0, ++a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 5));
MOD_CHECK_GO(type, ++a, "++a", ++a==0, ++a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 7));
MOD_CHECK_PGO(a, type, ++a, "++a", ++a==0, ++a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 9));
Inc inc_a(a);
int rv=0;
a=0;
rv=MOD_CHECK_VG(type, a++, inc_a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv=MOD_CHECK_VPG((a), type, a++, inc_a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv=MOD_CHECK_VGO(type, inc_a, "++a", a++, inc_a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv=MOD_CHECK_VPGO((a), type, inc_a, "++a", a++, inc_a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
META_ASSERT(rbEQUAL(rv, 0));
a=0;
rv=MOD_CHECK_VG(type, rbvMORE(a++, 1), inc_a);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 2));
META_ASSERT(rbEQUAL(rv, 0));
bool b;
a=0;
b=MOD_CHECK_BG(type, a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
a=0;
b=MOD_CHECK_BPG((a), type, a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
a=0;
b=MOD_CHECK_BGO(type, inc_a, "++a", a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
a=0;
b=MOD_CHECK_BPGO((a), type, inc_a, "++a", a++);
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
a=0;
b=MOD_CHECK_BG(type, rbvMORE(a++, 0));
META_ASSERT(!CheckLoggerCalled());
META_ASSERT(rbEQUAL(a, 1));
}
void* CheckNotGUIThread(void*)
{
META_ASSERT(!ModAssert::IsGUIThread());
return (void*)0;
}
static DWORD WINAPI CheckNotGUIThread(LPVOID )
{
META_ASSERT(!ModAssert::IsGUIThread());
return 0;
}
virtual ExitCode Entry()
{
META_ASSERT(!ModAssert::IsGUIThread());
return 0;
}
