case NO: return no;
case YES: return yes;
case MAYBE: return no | yes;
- default: DE_ASSERT(!"Impossible case");
+ default: DE_FATAL("Impossible case");
}
return Interval();
case QP_TEST_RESULT_RESOURCE_ERROR: return 110;
case QP_TEST_RESULT_INTERNAL_ERROR: return 120;
case QP_TEST_RESULT_CRASH: return 150;
- default: DE_ASSERT(!"Impossible case");
+ default: DE_FATAL("Impossible case");
}
return 0;
}
/* Assertion macro family. */
void deAssertFail(const char* reason, const char* file, int line);
+/* Assertion failure callback. Requires DE_ASSERT_FAILURE_CALLBACK to be defined or otherwise has no effect. */
+typedef void (*deAssertFailureCallbackFunc) (const char* reason, const char* file, int line);
+void deSetAssertFailureCallback (deAssertFailureCallbackFunc callback);
+
DE_INLINE deBool deGetFalse (void) { return DE_FALSE; }
DE_INLINE deBool deGetTrue (void) { return DE_TRUE; }
# define DE_ASSERT(X) /*@ -noeffect*/ ((void)0) /*!< Assertion macro. */
#endif
-/* Assertion failure callback. Requires DE_ASSERT_FAILURE_CALLBACK to be defined or otherwise has no effect. */
-typedef void (*deAssertFailureCallbackFunc) (const char* reason, const char* file, int line);
-void deSetAssertFailureCallback (deAssertFailureCallbackFunc callback);
-
/* Verify macro. Behaves like assert in debug build, but executes statement in release build. */
#if defined(DE_DEBUG)
# define DE_VERIFY(X) do { if ((!deGetFalse() && (X)) ? DE_FALSE : DE_TRUE) deAssertFail(#X, __FILE__, __LINE__); } while(deGetFalse())
# define DE_VERIFY(X) X
#endif
+/* Fatal macro. */
+#if defined(DE_DEBUG) && !defined(DE_COVERAGE_BUILD)
+# define DE_FATAL(MSG) do { deAssertFail("" /* force to string literal */ MSG, __FILE__, __LINE__); } while(deGetFalse())
+#else
+# define DE_FATAL(MSG) /*@ -noeffect*/ ((void)0) /*!< Fatal macro. */
+#endif
+
/** Test assert macro for use in testers (same as DE_ASSERT, but always enabled). */
#define DE_TEST_ASSERT(X) do { if ((!deGetFalse() && (X)) ? DE_FALSE : DE_TRUE) deAssertFail(#X, __FILE__, __LINE__); } while(deGetFalse())
-/** Compile-time assertion macro. */
#if (DE_COMPILER == DE_COMPILER_GCC)
/* GCC 4.8 and newer warns about unused typedefs. */
# define DE_UNUSED_TYPEDEF_ATTR __attribute__((unused))
#else
# define DE_UNUSED_TYPEDEF_ATTR
#endif
+
+/** Compile-time assertion macro. */
#define DE_STATIC_ASSERT(X) typedef char DE_UNIQUE_NAME[(X) ? 1 : -1] DE_UNUSED_TYPEDEF_ATTR
#define DE_HEADER_STATIC_ASSERT(HEADERTOKEN, X) typedef char DE_HEADER_UNIQUE_NAME(HEADERTOKEN)[(X) ? 1 : -1] DE_UNUSED_TYPEDEF_ATTR
#elif (DE_CPU == DE_CPU_ARM) && (DE_COMPILER == DE_COMPILER_MSC)
# define DE_BREAKPOINT() do { printf("Software breakpoint encountered in %s, line %d\n", __FILE__, __LINE__); DebugBreak(); } while (deGetFalse())
#else
-# define DE_BREAKPOINT() DE_ASSERT(!"Software breakpoint encountered!")
+# define DE_BREAKPOINT() DE_FATAL("Software breakpoint encountered!")
#endif
/** Swap two values. */
case DE_IMAGEFORMAT_XRGB8888: return *(deARGB*)addr;
case DE_IMAGEFORMAT_ARGB8888: return *(deARGB*)addr;
default:
- DE_ASSERT(!"deImage_getPixel(): invalid format");
+ DE_FATAL("deImage_getPixel(): invalid format");
return deARGB_black();
}
}
case DE_IMAGEFORMAT_XRGB8888: *(deARGB*)addr = argb; break;
case DE_IMAGEFORMAT_ARGB8888: *(deARGB*)addr = argb; break;
default:
- DE_ASSERT(!"deImage_getPixel(): invalid format");
+ DE_FATAL("deImage_getPixel(): invalid format");
}
}
\
void TYPENAME##_intersectInplace (TYPENAME* a, const TYPENAME* b) \
{ \
- DE_ASSERT(!"Not implemented."); \
+ DE_FATAL("Not implemented."); \
} \
\
deBool TYPENAME##_sum (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
\
void TYPENAME##_differenceInplace (TYPENAME* a, const TYPENAME* b) \
{ \
- DE_ASSERT(!"Not implemented."); \
+ DE_FATAL("Not implemented."); \
} \
\
struct TYPENAME##SetwiseImplementDummy_s { int dummy; }
void TYPENAME##_intersectInplace (TYPENAME* a, const TYPENAME* b) \
{ \
DE_UNREF(a && b); \
- DE_ASSERT(!"Not implemented."); \
+ DE_FATAL("Not implemented."); \
} \
\
deBool TYPENAME##_difference (TYPENAME* to, const TYPENAME* a, const TYPENAME* b) \
if (bsdAddrBufSize < (size_t)result->ai_addrlen)
{
- DE_ASSERT(!"Too small bsdAddr buffer");
+ DE_FATAL("Too small bsdAddr buffer");
freeaddrinfo(result);
return DE_FALSE;
}
if (bsdAddrBufSize < sizeof(struct sockaddr_in))
{
- DE_ASSERT(!"Too small bsdAddr buffer");
+ DE_FATAL("Too small bsdAddr buffer");
return DE_FALSE;
}
if (bsdAddrBufSize < sizeof(struct sockaddr_in6))
{
- DE_ASSERT(!"Too small bsdAddr buffer");
+ DE_FATAL("Too small bsdAddr buffer");
return DE_FALSE;
}
case EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR: return GL_TEXTURE_CUBE_MAP_NEGATIVE_Z;
case EGL_GL_TEXTURE_3D_KHR: return GL_TEXTURE_3D;
case EGL_GL_RENDERBUFFER_KHR: return GL_RENDERBUFFER;
- default: DE_ASSERT(!"Impossible"); return GL_NONE;
+ default: DE_FATAL("Impossible"); return GL_NONE;
}
}
case 1: return EGL_OPENGL_ES_BIT;
case 2: return EGL_OPENGL_ES2_BIT;
case 3: return EGL_OPENGL_ES3_BIT_KHR;
- default: DE_ASSERT(!"Unknown OpenGL ES version");
+ default: DE_FATAL("Unknown OpenGL ES version");
}
default:
- DE_ASSERT(!"Unknown GL API");
+ DE_FATAL("Unknown GL API");
}
return 0;
else if (isDataTypeMatrix(dataType))
return getDataTypeMatrixNumColumns(dataType);
- DE_ASSERT(!"Illegal datatype.");
+ DE_FATAL("Illegal datatype.");
return 0;
}
else if (isDataTypeMatrix(dataType))
return getDataTypeMatrixNumRows(dataType);
- DE_ASSERT(!"Illegal datatype.");
+ DE_FATAL("Illegal datatype.");
return 0;
}
}
}
- DE_ASSERT(!"invalid delete");
+ DE_FATAL("invalid delete");
}
void GLContext::useProgram (deUint32 program)
if (m_uniforms[ndx].name == std::string(name))
return m_uniforms[ndx];
- DE_ASSERT(!"Invalid uniform name, uniform not found.");
+ DE_FATAL("Invalid uniform name, uniform not found.");
return m_uniforms[0];
}
profileMask = GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
break;
default:
- DE_ASSERT(!"Impossible context profile");
+ DE_FATAL("Impossible context profile");
}
const int attribs[] =
case RenderConfig::SURFACETYPE_DONT_CARE:
return GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
default:
- DE_ASSERT(!"Impossible case");
+ DE_FATAL("Impossible case");
}
return 0;
}
switch (surfaceType)
{
case RenderConfig::SURFACETYPE_DONT_CARE:
- DE_ASSERT(!"Impossible case");
+ DE_FATAL("Impossible case");
case RenderConfig::SURFACETYPE_WINDOW:
return new GlxWindow(visual, config);
else if (m_state == STATE_PENDING_DESTROY)
m_state = STATE_READY_FOR_DESTROY;
else
- DE_ASSERT(!"Invalid window state");
+ DE_FATAL("Invalid window state");
}
void Window::markForDestroy (void)
else if (m_state == STATE_IN_USE)
m_state = STATE_PENDING_DESTROY;
else
- DE_ASSERT(!"Invalid window state");
+ DE_FATAL("Invalid window state");
}
bool Window::isPendingDestroy (void) const
else
{
print("ERROR: Window was not available for deletion, leaked tcu::Android::Window!\n");
- DE_ASSERT(!"Window leaked");
+ DE_FATAL("Window leaked");
}
}
}
virtual glu::ContextType getType (void) const { return m_type; }
virtual const glw::Functions& getFunctions (void) const { return m_functions; }
virtual const RenderTarget& getRenderTarget (void) const { return m_emptyTarget; }
- virtual deUint32 getDefaultFramebuffer (void) const { DE_ASSERT(!"No framebuffer"); return 0; }
+ virtual deUint32 getDefaultFramebuffer (void) const { DE_FATAL("No framebuffer"); return 0; }
virtual void postIterate (void);
protected:
}
default:
- DE_ASSERT(!"Unsupported");
+ DE_FATAL("Unsupported");
break;
}
}
if (++m_numEmitted > m_maxVertices)
{
- DE_ASSERT(!"Undefined results, too many vertices emitted.");
+ DE_FATAL("Undefined results, too many vertices emitted.");
return;
}
case VERTEXATTRIBTYPE_PURE_INT8:
case VERTEXATTRIBTYPE_PURE_INT16:
case VERTEXATTRIBTYPE_PURE_INT32:
- DE_ASSERT(!"Invalid read");
+ DE_FATAL("Invalid read");
default:
DE_ASSERT(false);
case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
- DE_ASSERT(!"Invalid read");
+ DE_FATAL("Invalid read");
default:
DE_ASSERT(false);
case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
- DE_ASSERT(!"Invalid read");
+ DE_FATAL("Invalid read");
default:
DE_ASSERT(false);
case EGL_NATIVE_BUFFER_ANDROID:
return createAndroidNativeImageSource(format);
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
return MovePtr<ImageSource>();
}
}
initializeColorRbo(gl, rbo, *ref);
break;
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
break;
case GL_TEXTURE_CUBE_MAP:
- DE_ASSERT(!"TODO");
+ DE_FATAL("TODO");
break;
case GL_RENDERBUFFER:
else if (dataType == TYPE_FLOAT_VEC3) return evalArrayCoordsVec3;
else if (dataType == TYPE_FLOAT_VEC4) return evalArrayCoordsVec4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
else if (dataType == TYPE_FLOAT_VEC3) return evalArrayUniformVec3;
else if (dataType == TYPE_FLOAT_VEC4) return evalArrayUniformVec4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
else if (dataType == TYPE_FLOAT_VEC3) return evalSubscriptVec3;
else if (dataType == TYPE_FLOAT_VEC4) return evalSubscriptVec4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
else if (dataType == TYPE_FLOAT_MAT3) return evalSubscriptMat3;
else if (dataType == TYPE_FLOAT_MAT4) return evalSubscriptMat4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
case 3: return evalLoop3Iters;
}
- DE_ASSERT(!"Invalid loop iteration count.");
+ DE_FATAL("Invalid loop iteration count.");
return NULL;
}
texCfg = &builder.makeConfig<Texture2DArray>();
break;
default:
- DE_ASSERT(!"Impossible case");
+ DE_FATAL("Impossible case");
}
texCfg->internalFormat = getDefaultFormat(target, GL_TEXTURE);
texCfg->width = 64;
return 0;
default:
- DE_ASSERT(!"Unknown format");
+ DE_FATAL("Unknown format");
return 0;
}
}
return glu::TYPE_INT_VEC4;
default:
- DE_ASSERT(!"Unknown format");
+ DE_FATAL("Unknown format");
return glu::TYPE_LAST;
}
}
return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32);
default:
- DE_ASSERT(!"Unknown format");
+ DE_FATAL("Unknown format");
return tcu::TextureFormat();
}
}
else if (dataType == TYPE_FLOAT_VEC3) return evalArrayCoordsVec3;
else if (dataType == TYPE_FLOAT_VEC4) return evalArrayCoordsVec4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
else if (dataType == TYPE_FLOAT_VEC3) return evalArrayUniformVec3;
else if (dataType == TYPE_FLOAT_VEC4) return evalArrayUniformVec4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
else if (dataType == TYPE_FLOAT_VEC3) return evalSubscriptVec3;
else if (dataType == TYPE_FLOAT_VEC4) return evalSubscriptVec4;
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return NULL;
}
case TYPE_FLOAT_MAT4: return evalSubscriptMat4;
default:
- DE_ASSERT(!"Invalid data type.");
+ DE_FATAL("Invalid data type.");
return DE_NULL;
}
}
case 3: return evalLoop3Iters;
}
- DE_ASSERT(!"Invalid loop iteration count.");
+ DE_FATAL("Invalid loop iteration count.");
return NULL;
}
{
DE_UNREF(source);
DE_UNREF(type);
- DE_ASSERT(!"GetErrorCase cannot handle anything other than error codes");
+ DE_FATAL("GetErrorCase cannot handle anything other than error codes");
}
void GetErrorCase::expectError (glw::GLenum error0, glw::GLenum error1)
break;
default:
- DE_ASSERT(!"Invalid identifier");
+ DE_FATAL("Invalid identifier");
}
gl.objectLabel(m_identifier, object, -1, msg);
case GL_FRAMEBUFFER: gl.deleteFramebuffers(1, &object); break;
default:
- DE_ASSERT(!"Invalid identifier");
+ DE_FATAL("Invalid identifier");
}
return STOP;
case CASETYPE_GETERROR: return new GetErrorCase(ctx, name, desc, function);
default:
- DE_ASSERT(!"Invalid type");
+ DE_FATAL("Invalid type");
}
return DE_NULL;
return 0;
default:
- DE_ASSERT(!"Unknown format");
+ DE_FATAL("Unknown format");
return 0;
}
}
return glu::TYPE_INT_VEC4;
default:
- DE_ASSERT(!"Unknown format");
+ DE_FATAL("Unknown format");
return glu::TYPE_LAST;
}
}
return tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT32);
default:
- DE_ASSERT(!"Unknown format");
+ DE_FATAL("Unknown format");
return tcu::TextureFormat();
}
}
return getDataTypeVector(scalarType, size);
}
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
return TYPE_INVALID;
}
case VARYINGINTERPOLATION_CENTROID: return glu::INTERPOLATION_CENTROID;
case VARYINGINTERPOLATION_DEFAULT: return glu::INTERPOLATION_LAST; //!< Last means no qualifier, i.e. default
default:
- DE_ASSERT(!"Invalid interpolation");
+ DE_FATAL("Invalid interpolation");
return glu::INTERPOLATION_LAST;
}
}
case glu::INTERPOLATION_CENTROID: return VARYINGINTERPOLATION_CENTROID;
case glu::INTERPOLATION_LAST: return VARYINGINTERPOLATION_DEFAULT; //!< Last means no qualifier, i.e. default
default:
- DE_ASSERT(!"Invalid interpolation");
+ DE_FATAL("Invalid interpolation");
return VARYINGINTERPOLATION_LAST;
}
}
}
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
if (isDataTypeScalarOrVector(basicType))
oss << exp;
break;
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
}
else if (isDataTypeMatrix(basicType))
}
}
else
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
// Representation for the varyings between vertex and fragment shaders
break;
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
}
msg << "randomly either by name or by location.\n";
break;
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
msg << "In the vertex shader the varyings are qualified ";
case glu::SHADERTYPE_FRAGMENT:
return createShaderProgram(DE_NULL, &src, true);
default:
- DE_ASSERT(!"Impossible case");
+ DE_FATAL("Impossible case");
}
}
return MovePtr<ProgramWrapper>(); // Shut up compiler warnings.
desc << "Varyings have same name, ";
break;
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
describeInterpolation("vertex", vtxInterp, name, desc);
else if (type >= TYPE_SAMPLER_1D_SHADOW && type <= TYPE_SAMPLER_2D_ARRAY_SHADOW)
return TYPE_FLOAT;
else
- DE_ASSERT(!"Unknown sampler type");
+ DE_FATAL("Unknown sampler type");
return TYPE_INVALID;
}
else if (glu::isDataTypeBoolOrBVec(adjustedType))
return float(hash%2);
else
- DE_ASSERT(!"Unkown primitive type");
+ DE_FATAL("Unkown primitive type");
return glu::TYPE_INVALID;
}
return GL_RGBA8UI;
default:
- DE_ASSERT(!"Unsupported (sampler) type");
+ DE_FATAL("Unsupported (sampler) type");
return 0;
}
}
template <>
const char* dataTypeNameOf<Void> (void)
{
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
return DE_NULL;
}
template <>
VarType getVarTypeOf<Void> (Precision)
{
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
return VarType();
}
case glu::PRECISION_LOWP:
return ctx.format.ulp(ret, 2.0);
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
return 0;
}
case glu::PRECISION_LOWP:
return ctx.format.ulp(ret, 2.0);
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
return 0;
case 1:
return new InOutFuncCase<Sig>(context, name, func);
default:
- DE_ASSERT(!"Impossible");
+ DE_FATAL("Impossible");
}
return DE_NULL;
}
if (min < 0 || (size_t)min > std::numeric_limits<T>::max() ||
max < 0 || (size_t)max > std::numeric_limits<T>::max() ||
min > max)
- DE_ASSERT(!"Invalid range");
+ DE_FATAL("Invalid range");
for (int elementNdx = 0; elementNdx < elementCount; ++elementNdx)
{
else if (contextSupports(m_renderCtx.getType(), glu::ApiType::es(3,1)) || glu::isContextTypeGLCore(m_renderCtx.getType()))
useVao = true;
else
- DE_ASSERT(!"Unknown context type");
+ DE_FATAL("Unknown context type");
m_refBuffers = new sglr::ReferenceContextBuffers(m_renderCtx.getRenderTarget().getPixelFormat(), 0, 0, renderTargetWidth, renderTargetHeight, renderTargetSamples);
m_refContext = new sglr::ReferenceContext(limits, m_refBuffers->getColorbuffer(), m_refBuffers->getDepthbuffer(), m_refBuffers->getStencilbuffer());
image = &builder.makeConfig<Texture2D>();
break;
default:
- DE_ASSERT(!"Impossible case");
+ DE_FATAL("Impossible case");
}
image->internalFormat = format;
image->width = width;
case GL_TEXTURE:
return "tex";
default:
- DE_ASSERT(!"Impossible case");
+ DE_FATAL("Impossible case");
}
return ""; // Shut up compiler
}
if (dynamic_cast<const Texture2DArray*>(&img) != DE_NULL)
return GL_TEXTURE_2D_ARRAY;
- DE_ASSERT(!"Impossible image type");
+ DE_FATAL("Impossible image type");
return GL_NONE;
}
gl.bindTexture(glTarget(*tex), 0);
}
else
- DE_ASSERT(!"Impossible image type");
+ DE_FATAL("Impossible image type");
return ret;
}
else if (dynamic_cast<const Texture*>(&cfg) != DE_NULL)
gl.deleteTextures(1, &img);
else
- DE_ASSERT(!"Impossible image type");
+ DE_FATAL("Impossible image type");
}
static void attachAttachment (const Attachment& att, GLenum attPoint,
gl.framebufferTextureLayer(lAtt->target, attPoint,
lAtt->imageName, lAtt->level, lAtt->layer);
else
- DE_ASSERT(!"Impossible attachment type");
+ DE_FATAL("Impossible attachment type");
}
GLenum attachmentType (const Attachment& att)
else if (dynamic_cast<const TextureAttachment*>(&att) != DE_NULL)
return GL_TEXTURE;
- DE_ASSERT(!"Impossible attachment type");
+ DE_FATAL("Impossible attachment type");
return GL_NONE;
}
dynamic_cast<const TextureLayerAttachment*>(&tAtt))
return lAtt->layer;
- DE_ASSERT(!"Impossible attachment type");
+ DE_FATAL("Impossible attachment type");
return 0;
}
case GL_RENDERBUFFER:
return de::lookupDefault(rbos, imgName, DE_NULL);
default:
- DE_ASSERT(!"Bad image type");
+ DE_FATAL("Bad image type");
}
return DE_NULL; // shut up compiler warning
}
break;
default:
- DE_ASSERT(!"Unsupported version");
+ DE_FATAL("Unsupported version");
}
return glu::makeVtxFragSources(tcu::StringTemplate(vtxSource).specialize(params), tcu::StringTemplate(frgSource).specialize(params));
case CLEAR_COLOR_FLOAT:
retval.colorFmt = GL_RGBA16F;
retval.texFmt = tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::HALF_FLOAT);
- DE_ASSERT(!"Floating point clear not implemented");// \todo [2014-1-23 otto] pixel read format & type, nothing guaranteed, need extension...
+ DE_FATAL("Floating point clear not implemented");// \todo [2014-1-23 otto] pixel read format & type, nothing guaranteed, need extension...
break;
case CLEAR_COLOR_INT:
case TYPE_SAMPLER_2D:
case TYPE_SAMPLER_CUBE:
- DE_ASSERT(!"implement!");
+ DE_FATAL("implement!");
break;
default:
{
if (isMultisampleTarget(target) && isSamplerStateTester(tester))
{
- DE_ASSERT(!"Multisample textures have no sampler state");
+ DE_FATAL("Multisample textures have no sampler state");
return DE_NULL;
}
if (target == GL_TEXTURE_BUFFER)
{
- DE_ASSERT(!"Buffer textures have no texture state");
+ DE_FATAL("Buffer textures have no texture state");
return DE_NULL;
}
if (target != GL_TEXTURE_3D && mapTesterToPname(tester) == GL_TEXTURE_WRAP_R)
{
- DE_ASSERT(!"Only 3D textures have wrap r filter");
+ DE_FATAL("Only 3D textures have wrap r filter");
return DE_NULL;
}
params["FRAG_COLOR"] = "dEQP_FragColor";
}
else
- DE_ASSERT(!"Unsupported version");
+ DE_FATAL("Unsupported version");
params["PRECISION"] = glu::getPrecisionName(m_texCoordPrecision);
}
}
else
- DE_ASSERT(!"Unsupported version");
+ DE_FATAL("Unsupported version");
params["SAMPLER_TYPE"] = sampler;
params["LOOKUP"] = lookup;
projects / platform / upstream / VK-GL-CTS.git / commitdiff