ASTCSUPPORTLEVEL_FULL
};
-static inline ASTCSupportLevel getASTCSupportLevel (const glu::ContextInfo& contextInfo)
+static inline ASTCSupportLevel getASTCSupportLevel (const glu::ContextInfo& contextInfo, const glu::RenderContext& renderCtx)
{
+ const bool isES32 = glu::contextSupports(renderCtx.getType(), glu::ApiType::es(3, 2));
+
const vector<string>& extensions = contextInfo.getExtensions();
ASTCSupportLevel maxLevel = ASTCSUPPORTLEVEL_NONE;
for (int extNdx = 0; extNdx < (int)extensions.size(); extNdx++)
{
const string& ext = extensions[extNdx];
-
- maxLevel = de::max(maxLevel, ext == "GL_KHR_texture_compression_astc_ldr" ? ASTCSUPPORTLEVEL_LDR
- : ext == "GL_KHR_texture_compression_astc_hdr" ? ASTCSUPPORTLEVEL_HDR
- : ext == "GL_OES_texture_compression_astc" ? ASTCSUPPORTLEVEL_FULL
- : ASTCSUPPORTLEVEL_NONE);
+ if (isES32)
+ {
+ maxLevel = de::max(maxLevel, ext == "GL_KHR_texture_compression_astc_hdr" ? ASTCSUPPORTLEVEL_HDR
+ : ext == "GL_OES_texture_compression_astc" ? ASTCSUPPORTLEVEL_FULL
+ : ASTCSUPPORTLEVEL_LDR);
+ }
+ else
+ {
+ maxLevel = de::max(maxLevel, ext == "GL_KHR_texture_compression_astc_ldr" ? ASTCSUPPORTLEVEL_LDR
+ : ext == "GL_KHR_texture_compression_astc_hdr" ? ASTCSUPPORTLEVEL_HDR
+ : ext == "GL_OES_texture_compression_astc" ? ASTCSUPPORTLEVEL_FULL
+ : ASTCSUPPORTLEVEL_NONE);
+ }
}
return maxLevel;
const tcu::RenderTarget& renderTarget = m_context.getRenderTarget();
TestLog& log = m_context.getTestContext().getLog();
- m_astcSupport = getASTCSupportLevel(m_context.getContextInfo());
+ m_astcSupport = getASTCSupportLevel(m_context.getContextInfo(), m_context.getRenderContext());
m_colorScale = colorScale;
m_colorBias = colorBias;
throw glu::Error((int)err, (string("Got ") + glu::getErrorStr(err).toString()).c_str(), DE_NULL, __FILE__, __LINE__);
}
-static bool isRequiredFormat (deUint32 format)
+static bool isRequiredFormat (deUint32 format, glu::RenderContext& renderContext)
{
switch (format)
{
case GL_STENCIL_INDEX8:
return true;
+ // Float formats
+ case GL_RGBA32F:
+ case GL_RGB32F:
+ case GL_R11F_G11F_B10F:
+ case GL_RG32F:
+ case GL_R32F:
+ return glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));;
+
default:
return false;
}
}
-static std::vector<std::string> getEnablingExtensions (deUint32 format)
+static std::vector<std::string> getEnablingExtensions (deUint32 format, glu::RenderContext& renderContext)
{
- std::vector<std::string> out;
+ const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
+ std::vector<std::string> out;
- DE_ASSERT(!isRequiredFormat(format));
+ DE_ASSERT(!isRequiredFormat(format, renderContext));
switch (format)
{
case GL_R11F_G11F_B10F:
case GL_RG32F:
case GL_R32F:
- out.push_back("GL_EXT_color_buffer_float");
+ if (!isES32)
+ out.push_back("GL_EXT_color_buffer_float");
default:
break;
void FboTestCase::checkFormatSupport (deUint32 sizedFormat)
{
- const bool isCoreFormat = isRequiredFormat(sizedFormat);
- const std::vector<std::string> requiredExts = (!isCoreFormat) ? getEnablingExtensions(sizedFormat) : std::vector<std::string>();
+ const bool isCoreFormat = isRequiredFormat(sizedFormat, m_context.getRenderContext());
+ const std::vector<std::string> requiredExts = (!isCoreFormat) ? getEnablingExtensions(sizedFormat, m_context.getRenderContext()) : std::vector<std::string>();
// Check that we don't try to use invalid formats.
DE_ASSERT(isCoreFormat || !requiredExts.empty());
class IsEnabledStateTestCase : public TestCase, private glu::CallLogWrapper
{
public:
- IsEnabledStateTestCase (Context& context, QueryType verifier, const char* name, const char* description, glw::GLenum targetName, bool initial)
+ IsEnabledStateTestCase (Context& context, QueryType verifier, const char* name, const char* description, glw::GLenum targetName, bool initial, glu::ApiType minimumContextVersion)
: TestCase (context, name, description)
, glu::CallLogWrapper (context.getRenderContext().getFunctions(), context.getTestContext().getLog())
, m_targetName (targetName)
, m_initial (initial)
, m_verifier (verifier)
+ , m_minimumVersion (minimumContextVersion)
{
}
IterateResult iterate (void)
{
+ TCU_CHECK_AND_THROW(NotSupportedError, contextSupports(m_context.getRenderContext().getType(), m_minimumVersion), "This test requires a higher context version.");
+
tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
enableLogging(true);
const glw::GLenum m_targetName;
const bool m_initial;
const QueryType m_verifier;
+ const glu::ApiType m_minimumVersion;
};
} // anonymous
void BooleanStateQueryTests::init (void)
{
+ const bool isDebugContext = (m_context.getRenderContext().getType().getFlags() & glu::CONTEXT_DEBUG) != 0;
+
static const QueryType isEnabledVerifiers[] =
{
QUERY_ISENABLED,
const char* description;
glw::GLenum targetName;
bool value;
- };
- const StateBoolean isEnableds[] =
- {
- { "sample_mask", "SAMPLE_MASK", GL_SAMPLE_MASK, false},
+ glu::ApiType minimumContext;
};
- for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(isEnableds); testNdx++)
{
- FOR_EACH_VERIFIER(isEnabledVerifiers, new IsEnabledStateTestCase(m_context, verifier, (std::string(isEnableds[testNdx].name) + "_" + verifierSuffix).c_str(), isEnableds[testNdx].description, isEnableds[testNdx].targetName, isEnableds[testNdx].value));
+ const StateBoolean isEnableds[] =
+ {
+ { "sample_mask", "SAMPLE_MASK", GL_SAMPLE_MASK, false, glu::ApiType::es(3, 1)},
+ { "sample_shading", "SAMPLE_SHADING", GL_SAMPLE_SHADING, false, glu::ApiType::es(3, 2)},
+ { "debug_output", "DEBUG_OUTPUT", GL_DEBUG_OUTPUT, isDebugContext, glu::ApiType::es(3, 2)},
+ { "debug_output_synchronous", "DEBUG_OUTPUT_SYNCHRONOUS", GL_DEBUG_OUTPUT_SYNCHRONOUS, false, glu::ApiType::es(3, 2)},
+ };
+
+ for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(isEnableds); testNdx++)
+ {
+ FOR_EACH_VERIFIER(isEnabledVerifiers, new IsEnabledStateTestCase(m_context, verifier, (std::string(isEnableds[testNdx].name) + "_" + verifierSuffix).c_str(), isEnableds[testNdx].description, isEnableds[testNdx].targetName, isEnableds[testNdx].value, isEnableds[testNdx].minimumContext));
+ }
}
#undef FOR_EACH_VERIFIER
const tcu::CompressedTexFormat compressedFormat = glu::mapGLCompressedTexFormat(info.getFormat());
const tcu::TextureFormat decompressedFormat = tcu::getUncompressedFormat(compressedFormat);
const IVec3 size = info.getSize();
+ const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
+
de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(renderContext));
tcu::TexDecompressionParams decompressParams;
{
if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_hdr"))
decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_HDR);
- else if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
+ else if (isES32 || ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR);
else
DE_ASSERT(false);
const int texelBlockSize = getTexelBlockSize(info.getFormat());
const IVec3 texelBlockPixelSize = getTexelBlockPixelSize(info.getFormat());
+ const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
+
vector<tcu::PixelBufferAccess> levelAccesses[6];
vector<ArrayBuffer<deUint8> > levelDatas[6];
de::UniquePtr<glu::ContextInfo> ctxInfo (glu::ContextInfo::create(renderContext));
{
if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_hdr"))
decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_HDR);
- else if (ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
+ else if (isES32 || ctxInfo->isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
decompressParams = tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR);
else
DE_ASSERT(false);
deinit();
}
-void checkFormatSupport (glu::ContextInfo& info, deUint32 format, deUint32 target)
+void checkFormatSupport (glu::ContextInfo& info, deUint32 format, deUint32 target, glu::RenderContext& ctx)
{
+ const bool isES32 = glu::contextSupports(ctx.getType(), glu::ApiType::es(3, 2));
+
if (glu::isCompressedFormat(format))
{
if (isAstcFormat(glu::mapGLCompressedTexFormat(format)))
{
if (target == GL_TEXTURE_3D)
TCU_THROW(NotSupportedError, "TEXTURE_3D target requires HDR astc support.");
- if (!info.isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
+ if (!isES32 && !info.isExtensionSupported("GL_KHR_texture_compression_astc_ldr"))
TCU_THROW(NotSupportedError, "Compressed astc texture not supported.");
}
}
void CopyImageTest::init (void)
{
de::UniquePtr<glu::ContextInfo> ctxInfo(glu::ContextInfo::create(m_context.getRenderContext()));
+ const bool isES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
- if (!ctxInfo->isExtensionSupported("GL_EXT_copy_image"))
+ if (!isES32 && !ctxInfo->isExtensionSupported("GL_EXT_copy_image"))
throw tcu::NotSupportedError("Extension GL_EXT_copy_image not supported.", "", __FILE__, __LINE__);
- checkFormatSupport(*ctxInfo, m_srcImageInfo.getFormat(), m_srcImageInfo.getTarget());
- checkFormatSupport(*ctxInfo, m_dstImageInfo.getFormat(), m_dstImageInfo.getTarget());
+ checkFormatSupport(*ctxInfo, m_srcImageInfo.getFormat(), m_srcImageInfo.getTarget(), m_context.getRenderContext());
+ checkFormatSupport(*ctxInfo, m_dstImageInfo.getFormat(), m_dstImageInfo.getTarget(), m_context.getRenderContext());
{
SeedBuilder builder;
compressedTextureFormatViewClasses[VIEWCLASS_ETC2_EAC_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
// VIEWCLASS_ASTC_4x4_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_4x4_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_4x4);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_4x4_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4);
// VIEWCLASS_ASTC_5x4_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_5x4_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_5x4);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x4_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4);
// VIEWCLASS_ASTC_5x5_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_5x5_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_5x5);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_5x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5);
// VIEWCLASS_ASTC_6x5_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_6x5_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_6x5);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5);
// VIEWCLASS_ASTC_6x6_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_6x6_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_6x6);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_6x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6);
// VIEWCLASS_ASTC_8x5_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x5_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x5);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5);
// VIEWCLASS_ASTC_8x6_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x6_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x6);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6);
// VIEWCLASS_ASTC_8x8_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x8_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_8x8);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_8x8_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8);
// VIEWCLASS_ASTC_10x5_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x5_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x5);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x5_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5);
// VIEWCLASS_ASTC_10x6_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x6_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x6);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x6_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6);
// VIEWCLASS_ASTC_10x8_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x8_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x8);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x8_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8);
// VIEWCLASS_ASTC_10x10_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x10_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_10x10);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_10x10_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10);
// VIEWCLASS_ASTC_12x10_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_12x10_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_12x10);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x10_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10);
// VIEWCLASS_ASTC_12x12_RGBA
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_12x12_KHR);
- compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA].push_back(GL_COMPRESSED_RGBA_ASTC_12x12);
+ compressedTextureFormatViewClasses[VIEWCLASS_ASTC_12x12_RGBA].push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12);
// Mixed view classes
mixedViewClasses[VIEWCLASS_128_BITS] = pair<vector<deUint32>, vector<deUint32> >();
mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC);
mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RG11_EAC);
mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SIGNED_RG11_EAC);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_4x4_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_5x4_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_5x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_6x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_6x6_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x6_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x8_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x6_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x8_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x10_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_12x10_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_12x12_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR);
- mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_4x4);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_5x4);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_5x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_6x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_6x6);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x6);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_8x8);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x6);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x8);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_10x10);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_12x10);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_RGBA_ASTC_12x12);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10);
+ mixedViewClasses[VIEWCLASS_128_BITS].second.push_back(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12);
// 64 bits
protected:
void preCheck (void)
{
- if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_cube_map_array"))
- throw tcu::NotSupportedError("GL_EXT_texture_cube_map_array not supported");
+ if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_cube_map_array"))
+ TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_texture_cube_map_array or a context version equal or higher than 3.2");
checkFormatSupport(m_format);
}
throw glu::Error((int)err, (string("Got ") + glu::getErrorStr(err).toString()).c_str(), DE_NULL, __FILE__, __LINE__);
}
-static bool isRequiredFormat (deUint32 format)
+static bool isRequiredFormat (deUint32 format, glu::RenderContext& renderContext)
{
+ const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
switch (format)
{
// Color-renderable formats
case GL_STENCIL_INDEX8:
return true;
+ // Float format
+ case GL_RGBA32F:
+ case GL_RGB32F:
+ case GL_R11F_G11F_B10F:
+ case GL_RG32F:
+ case GL_R32F:
+ return isES32;
+
+
default:
return false;
}
}
-static std::vector<std::string> getEnablingExtensions (deUint32 format)
+static std::vector<std::string> getEnablingExtensions (deUint32 format, glu::RenderContext& renderContext)
{
- std::vector<std::string> out;
+ const bool isES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
+ std::vector<std::string> out;
- DE_ASSERT(!isRequiredFormat(format));
+ DE_ASSERT(!isRequiredFormat(format, renderContext));
switch (format)
{
case GL_R11F_G11F_B10F:
case GL_RG32F:
case GL_R32F:
- out.push_back("GL_EXT_color_buffer_float");
+ if (!isES32)
+ out.push_back("GL_EXT_color_buffer_float");
break;
default:
void FboTestCase::checkFormatSupport (deUint32 sizedFormat)
{
- const bool isCoreFormat = isRequiredFormat(sizedFormat);
- const std::vector<std::string> requiredExts = (!isCoreFormat) ? getEnablingExtensions(sizedFormat) : std::vector<std::string>();
+ const bool isCoreFormat = isRequiredFormat(sizedFormat, m_context.getRenderContext());
+ const std::vector<std::string> requiredExts = (!isCoreFormat) ? getEnablingExtensions(sizedFormat, m_context.getRenderContext()) : std::vector<std::string>();
// Check that we don't try to use invalid formats.
DE_ASSERT(isCoreFormat || !requiredExts.empty());
}
}
+void isExtensionSupported (Context& context, std::string extensionName)
+{
+ if (extensionName == "GL_EXT_draw_buffers_indexed" || extensionName == "GL_KHR_blend_equation_advanced")
+ {
+ if (!contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !context.getContextInfo().isExtensionSupported(extensionName.c_str()))
+ TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
+ }
+ else if (!context.getContextInfo().isExtensionSupported(extensionName.c_str()))
+ TCU_THROW(NotSupportedError, (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
+}
+
class SampleMaskCase : public TestCase
{
public:
void EnableBlendCase::init (void)
{
- if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
- throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__);
+ isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
EnableBlendCase::IterateResult EnableBlendCase::iterate (void)
void ColorMaskCase::init (void)
{
- if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
- throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__);
+ isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
ColorMaskCase::IterateResult ColorMaskCase::iterate (void)
void BlendFuncCase::init (void)
{
- if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
- throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__);
+ isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
BlendFuncCase::IterateResult BlendFuncCase::iterate (void)
void BlendEquationCase::init (void)
{
- if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
- throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__);
+ isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}
BlendEquationCase::IterateResult BlendEquationCase::iterate (void)
void BlendEquationAdvancedCase::init (void)
{
- if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
- throw tcu::NotSupportedError("Extension GL_EXT_draw_buffers_indexed not supported", "", __FILE__, __LINE__);
-
- if (!m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
- throw tcu::NotSupportedError("Extension GL_KHR_blend_equation_advanced not supported", "", __FILE__, __LINE__);
+ isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
+ isExtensionSupported(m_context, "GL_KHR_blend_equation_advanced");
}
BlendEquationAdvancedCase::IterateResult BlendEquationAdvancedCase::iterate (void)
const deUint32 blendEquationAdvanced[] =
{
- GL_MULTIPLY_KHR,
- GL_SCREEN_KHR,
- GL_OVERLAY_KHR,
- GL_DARKEN_KHR,
- GL_LIGHTEN_KHR,
- GL_COLORDODGE_KHR,
- GL_COLORBURN_KHR,
- GL_HARDLIGHT_KHR,
- GL_SOFTLIGHT_KHR,
- GL_DIFFERENCE_KHR,
- GL_EXCLUSION_KHR,
- GL_HSL_HUE_KHR,
- GL_HSL_SATURATION_KHR,
- GL_HSL_COLOR_KHR,
- GL_HSL_LUMINOSITY_KHR
+ GL_MULTIPLY,
+ GL_SCREEN,
+ GL_OVERLAY,
+ GL_DARKEN,
+ GL_LIGHTEN,
+ GL_COLORDODGE,
+ GL_COLORBURN,
+ GL_HARDLIGHT,
+ GL_SOFTLIGHT,
+ GL_DIFFERENCE,
+ GL_EXCLUSION,
+ GL_HSL_HUE,
+ GL_HSL_SATURATION,
+ GL_HSL_COLOR,
+ GL_HSL_LUMINOSITY
};
glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingCommon", "After setting common");
- gl.glBlendEquation(GL_SCREEN_KHR);
+ gl.glBlendEquation(GL_SCREEN);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
- verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN_KHR, m_verifierType);
+ verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
- verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN_KHR, m_verifierType);
+ verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);
- gl.glBlendEquation(GL_MULTIPLY_KHR);
+ gl.glBlendEquation(GL_MULTIPLY);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
- verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY_KHR, m_verifierType);
+ verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
- verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY_KHR, m_verifierType);
+ verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY, m_verifierType);
}
{
const tcu::ScopedLogSection section (m_testCtx.getLog(), "AfterResettingIndexedSeparateWithCommon", "After resetting indexed separate with common");
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);
- gl.glBlendEquation(GL_LIGHTEN_KHR);
+ gl.glBlendEquation(GL_LIGHTEN);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
- verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN_KHR, m_verifierType);
+ verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN, m_verifierType);
for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
- verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN_KHR, m_verifierType);
+ verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN, m_verifierType);
}
result.setTestContextResult(m_testCtx);
FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_count_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_COUNT", GL_MAX_COMPUTE_WORK_GROUP_COUNT, tcu::IVec3(65535,65535,65535), verifier))
FOR_EACH_VERIFIER(new MinValueIndexed3Case (m_context, (std::string() + "max_compute_work_group_size_" + verifierSuffix).c_str(), "Test MAX_COMPUTE_WORK_GROUP_SIZE", GL_MAX_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(128, 128, 64), verifier))
- FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_BINDING", GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
+ FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_BINDING", GL_ATOMIC_COUNTER_BUFFER_BINDING, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "atomic_counter_buffer_start_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_START", GL_ATOMIC_COUNTER_BUFFER_START, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "atomic_counter_buffer_size_" + verifierSuffix).c_str(), "Test ATOMIC_COUNTER_BUFFER_SIZE", GL_ATOMIC_COUNTER_BUFFER_SIZE, GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
- FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "shader_storager_buffer_binding_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_BINDING", GL_SHADER_STORAGE_BUFFER_BINDING, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
- FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "shader_storager_buffer_start_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_START", GL_SHADER_STORAGE_BUFFER_START, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
- FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "shader_storager_buffer_size_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_SIZE", GL_SHADER_STORAGE_BUFFER_SIZE, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
+ FOR_EACH_VERIFIER(new BufferBindingCase (m_context, (std::string() + "shader_storage_buffer_binding_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_BINDING", GL_SHADER_STORAGE_BUFFER_BINDING, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
+ FOR_EACH_VERIFIER(new BufferStartCase (m_context, (std::string() + "shader_storage_buffer_start_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_START", GL_SHADER_STORAGE_BUFFER_START, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
+ FOR_EACH_VERIFIER(new BufferSizeCase (m_context, (std::string() + "shader_storage_buffer_size_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_SIZE", GL_SHADER_STORAGE_BUFFER_SIZE, GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
FOR_EACH_VERIFIER(new ImageBindingNameCase (m_context, (std::string() + "image_binding_name_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_NAME", verifier))
FOR_EACH_VERIFIER(new ImageBindingLevelCase (m_context, (std::string() + "image_binding_level_" + verifierSuffix).c_str(), "Test IMAGE_BINDING_LEVEL", verifier))
void FormatSamplesCase::init (void)
{
- const bool isTextureTarget = (m_target == GL_TEXTURE_2D_MULTISAMPLE) ||
- (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
+ const bool isTextureTarget = (m_target == GL_TEXTURE_2D_MULTISAMPLE) ||
+ (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
+ const bool isES32 = contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
- if (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
- throw tcu::NotSupportedError("Test requires OES_texture_storage_multisample_2d_array extension");
+ if (!isES32 && m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
+ TCU_THROW(NotSupportedError, "Test requires OES_texture_storage_multisample_2d_array extension or a context version equal or higher than 3.2");
// stencil8 textures are not supported without GL_OES_texture_stencil8 extension
- if (isTextureTarget && m_internalFormat == GL_STENCIL_INDEX8 && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_stencil8"))
- throw tcu::NotSupportedError("Test requires GL_OES_texture_stencil8 extension");
+ if (!isES32 && isTextureTarget && m_internalFormat == GL_STENCIL_INDEX8 && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_stencil8"))
+ TCU_THROW(NotSupportedError, "Test requires GL_OES_texture_stencil8 extension or a context version equal or higher than 3.2");
}
FormatSamplesCase::IterateResult FormatSamplesCase::iterate (void)
{
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
+ bool isFloatFormat = false;
bool error = false;
glw::GLint maxSamples = 0;
glw::GLint numSampleCounts = 0;
+ const bool isES32 = contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
+
+ if (!isES32)
+ {
+ if (m_internalFormat == GL_RGBA16F || m_internalFormat == GL_R32F || m_internalFormat == GL_RG32F || m_internalFormat == GL_RGBA32F || m_internalFormat == GL_R16F || m_internalFormat == GL_RG16F || m_internalFormat == GL_R11F_G11F_B10F)
+ {
+ TCU_THROW(NotSupportedError, "The internal format is not supported in a context lower than 3.2");
+ }
+ }
+ else if (m_internalFormat == GL_RGBA16F || m_internalFormat == GL_R32F || m_internalFormat == GL_RG32F || m_internalFormat == GL_RGBA32F)
+ {
+ isFloatFormat = true;
+ }
// Lowest limit
{
m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
- if (numSampleCounts < 1)
+ if (!isFloatFormat)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
- error = true;
+ if (numSampleCounts < 1)
+ {
+ m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
+ error = true;
+ }
}
}
tcu::MessageBuilder samplesMsg(&m_testCtx.getLog());
std::vector<glw::GLint> samples;
- if (numSampleCounts > 0)
+ if (numSampleCounts > 0 || isFloatFormat)
{
samples.resize(numSampleCounts, -1);
}
// maxSamples must be supported
- if (samples[0] < maxSamples)
+ if (!isFloatFormat)
{
- m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: MAX_*_SAMPLES must be supported." << tcu::TestLog::EndMessage;
- error = true;
+ if (samples[0] < maxSamples)
+ {
+ m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: MAX_*_SAMPLES must be supported." << tcu::TestLog::EndMessage;
+ error = true;
+ }
}
}
{ "rgba32i", GL_RGBA32I, FormatSamplesCase::FORMAT_INT },
{ "rgba32ui", GL_RGBA32UI, FormatSamplesCase::FORMAT_INT },
+ // float formats
+ { "r16f", GL_R16F, FormatSamplesCase::FORMAT_COLOR },
+ { "rg16f", GL_RG16F, FormatSamplesCase::FORMAT_COLOR },
+ { "rgba16f", GL_RGBA16F, FormatSamplesCase::FORMAT_COLOR },
+ { "r32f", GL_R32F, FormatSamplesCase::FORMAT_INT },
+ { "rg32f", GL_RG32F, FormatSamplesCase::FORMAT_INT },
+ { "rgba32f", GL_RGBA32F, FormatSamplesCase::FORMAT_INT },
+ { "r11f_g11f_b10f", GL_R11F_G11F_B10F, FormatSamplesCase::FORMAT_COLOR },
+
// depth renderable
{ "depth_component16", GL_DEPTH_COMPONENT16, FormatSamplesCase::FORMAT_DEPTH_STENCIL },
{ "depth_component24", GL_DEPTH_COMPONENT24, FormatSamplesCase::FORMAT_DEPTH_STENCIL },
#include "es31fNegativeFragmentApiTests.hpp"
#include "gluCallLogWrapper.hpp"
+#include "gluContextInfo.hpp"
+#include "gluRenderContext.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"
ctx.endSection();
}
+void blend_equationi (NegativeTestContext& ctx)
+{
+ glw::GLint maxDrawBuffers = -1;
+
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !ctx.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
+ throw tcu::NotSupportedError("GL_KHR_blend_equation_advanced is not supported", DE_NULL, __FILE__, __LINE__);
+
+ ctx.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
+ ctx.beginSection("GL_INVALID_ENUM is generated if mode is not GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MAX or GL_MIN.");
+ ctx.glBlendEquationi(0, -1);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ ctx.beginSection("GL_INVALID_VALUE is generated if buf is not in the range zero to the value of MAX_DRAW_BUFFERS minus one.");
+ ctx.glBlendEquationi(-1, GL_FUNC_ADD);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.glBlendEquationi(maxDrawBuffers, GL_FUNC_ADD);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+}
+
+void blend_equation_separatei (NegativeTestContext& ctx)
+{
+ glw::GLint maxDrawBuffers = -1;
+
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !ctx.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
+ throw tcu::NotSupportedError("GL_KHR_blend_equation_advanced is not supported", DE_NULL, __FILE__, __LINE__);
+
+ ctx.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
+ ctx.beginSection("GL_INVALID_ENUM is generated if modeRGB is not GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MAX or GL_MIN.");
+ ctx.glBlendEquationSeparatei(0, -1, GL_FUNC_ADD);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ ctx.beginSection("GL_INVALID_ENUM is generated if modeAlpha is not GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MAX or GL_MIN.");
+ ctx.glBlendEquationSeparatei(0, GL_FUNC_ADD, -1);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ ctx.beginSection("GL_INVALID_VALUE is generated if buf is not in the range zero to the value of MAX_DRAW_BUFFERS minus one.");
+ ctx.glBlendEquationSeparatei(-1, GL_FUNC_ADD, GL_FUNC_ADD);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.glBlendEquationSeparatei(maxDrawBuffers, GL_FUNC_ADD, GL_FUNC_ADD);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+}
+
void blend_func (NegativeTestContext& ctx)
{
ctx.beginSection("GL_INVALID_ENUM is generated if either sfactor or dfactor is not an accepted value.");
ctx.endSection();
}
+void blend_funci (NegativeTestContext& ctx)
+{
+ glw::GLint maxDrawBuffers = -1;
+
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !ctx.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
+ throw tcu::NotSupportedError("GL_KHR_blend_equation_advanced is not supported", DE_NULL, __FILE__, __LINE__);
+
+ ctx.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
+ ctx.beginSection("GL_INVALID_ENUM is generated if either sfactor or dfactor is not an accepted value.");
+ ctx.glBlendFunci(0, -1, GL_ONE);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.glBlendFunci(0, GL_ONE, -1);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ ctx.beginSection("GL_INVALID_VALUE is generated if buf is not in the range zero to the value of MAX_DRAW_BUFFERS minus one.");
+ ctx.glBlendFunci(-1, GL_ONE, GL_ONE);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.glBlendFunci(maxDrawBuffers, GL_ONE, GL_ONE);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+}
+
+void blend_func_separatei (NegativeTestContext& ctx)
+{
+ glw::GLint maxDrawBuffers = -1;
+
+ if (!glu::contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !ctx.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
+ throw tcu::NotSupportedError("GL_KHR_blend_equation_advanced is not supported", DE_NULL, __FILE__, __LINE__);
+
+ ctx.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
+ ctx.beginSection("GL_INVALID_ENUM is generated if srcRGB, dstRGB, srcAlpha, or dstAlpha is not an accepted value.");
+ ctx.glBlendFuncSeparatei(0, -1, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.glBlendFuncSeparatei(0, GL_ZERO, -1, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.glBlendFuncSeparatei(0, GL_ZERO, GL_ONE, -1, GL_ONE_MINUS_SRC_COLOR);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.glBlendFuncSeparatei(0, GL_ZERO, GL_ONE, GL_SRC_COLOR, -1);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ ctx.beginSection("GL_INVALID_VALUE is generated if buf is not in the range zero to the value of MAX_DRAW_BUFFERS minus one.");
+ ctx.glBlendFuncSeparatei(-1, GL_ONE, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.glBlendFuncSeparatei(maxDrawBuffers, GL_ONE, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+}
+
// Rasterization API functions
void cull_face (NegativeTestContext& ctx)
{
{
FunctionContainer funcs[] =
{
- {scissor, "scissor", "Invalid glScissor() usage" },
- {depth_func, "depth_func", "Invalid glDepthFunc() usage" },
- {viewport, "viewport", "Invalid glViewport() usage" },
- {stencil_func, "stencil_func", "Invalid glStencilFunc() usage" },
- {stencil_func_separate, "stencil_func_separate", "Invalid glStencilFuncSeparate() usage" },
- {stencil_op, "stencil_op", "Invalid glStencilOp() usage" },
- {stencil_op_separate, "stencil_op_separate", "Invalid glStencilOpSeparate() usage" },
- {stencil_mask_separate, "stencil_mask_separate", "Invalid glStencilMaskSeparate() usage" },
- {blend_equation, "blend_equation", "Invalid glBlendEquation() usage" },
- {blend_equation_separate, "blend_equation_separate", "Invalid glBlendEquationSeparate() usage"},
- {blend_func, "blend_func", "Invalid glBlendFunc() usage" },
- {blend_func_separate, "blend_func_separate", "Invalid glBlendFuncSeparate() usage" },
- {cull_face, "cull_face", "Invalid glCullFace() usage" },
- {front_face, "front_face", "Invalid glFrontFace() usage" },
- {line_width, "line_width", "Invalid glLineWidth() usage" },
- {gen_queries, "gen_queries", "Invalid glGenQueries() usage" },
- {begin_query, "begin_query", "Invalid glBeginQuery() usage" },
- {end_query, "end_query", "Invalid glEndQuery() usage" },
- {delete_queries, "delete_queries", "Invalid glDeleteQueries() usage" },
- {fence_sync, "fence_sync", "Invalid glFenceSync() usage" },
- {wait_sync, "wait_sync", "Invalid glWaitSync() usage" },
- {client_wait_sync, "client_wait_sync", "Invalid glClientWaitSync() usage" },
- {delete_sync, "delete_sync", "Invalid glDeleteSync() usage" },
+ {scissor, "scissor", "Invalid glScissor() usage" },
+ {depth_func, "depth_func", "Invalid glDepthFunc() usage" },
+ {viewport, "viewport", "Invalid glViewport() usage" },
+ {stencil_func, "stencil_func", "Invalid glStencilFunc() usage" },
+ {stencil_func_separate, "stencil_func_separate", "Invalid glStencilFuncSeparate() usage" },
+ {stencil_op, "stencil_op", "Invalid glStencilOp() usage" },
+ {stencil_op_separate, "stencil_op_separate", "Invalid glStencilOpSeparate() usage" },
+ {stencil_mask_separate, "stencil_mask_separate", "Invalid glStencilMaskSeparate() usage" },
+ {blend_equation, "blend_equation", "Invalid glBlendEquation() usage" },
+ {blend_equationi, "blend_equationi", "Invalid glBlendEquationi() usage" },
+ {blend_equation_separate, "blend_equation_separate", "Invalid glBlendEquationSeparate() usage" },
+ {blend_equation_separatei, "blend_equation_separatei", "Invalid glBlendEquationSeparatei() usage" },
+ {blend_func, "blend_func", "Invalid glBlendFunc() usage" },
+ {blend_funci, "blend_funci", "Invalid glBlendFunci() usage" },
+ {blend_func_separate, "blend_func_separate", "Invalid glBlendFuncSeparate() usage" },
+ {blend_func_separatei, "blend_func_separatei", "Invalid glBlendFuncSeparatei() usage" },
+ {cull_face, "cull_face", "Invalid glCullFace() usage" },
+ {front_face, "front_face", "Invalid glFrontFace() usage" },
+ {line_width, "line_width", "Invalid glLineWidth() usage" },
+ {gen_queries, "gen_queries", "Invalid glGenQueries() usage" },
+ {begin_query, "begin_query", "Invalid glBeginQuery() usage" },
+ {end_query, "end_query", "Invalid glEndQuery() usage" },
+ {delete_queries, "delete_queries", "Invalid glDeleteQueries() usage" },
+ {fence_sync, "fence_sync", "Invalid glFenceSync() usage" },
+ {wait_sync, "wait_sync", "Invalid glWaitSync() usage" },
+ {client_wait_sync, "client_wait_sync", "Invalid glClientWaitSync() usage" },
+ {delete_sync, "delete_sync", "Invalid glDeleteSync() usage" },
};
return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
#include "gluShaderProgram.hpp"
#include "gluCallLogWrapper.hpp"
+#include "gluContextInfo.hpp"
+#include "gluRenderContext.hpp"
namespace deqp
void shader_binary (NegativeTestContext& ctx)
{
std::vector<deInt32> binaryFormats;
+ deBool shaderBinarySupported = !binaryFormats.empty();
+ GLuint shaders[2];
+ GLuint shaderPair[2];
+ GLuint nonProgram[2];
+ GLuint shaderProgram[2];
{
deInt32 numFormats = 0x1234;
}
}
- deBool shaderBinarySupported = !binaryFormats.empty();
if (!shaderBinarySupported)
ctx.getLog() << TestLog::Message << "// Shader binaries not supported." << TestLog::EndMessage;
else
ctx.getLog() << TestLog::Message << "// Shader binaries supported" << TestLog::EndMessage;
- GLuint shaders[2];
- shaders[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
- shaders[1] = ctx.glCreateShader(GL_VERTEX_SHADER);
+ shaders[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
+ shaders[1] = ctx.glCreateShader(GL_VERTEX_SHADER);
+ shaderPair[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
+ shaderPair[1] = ctx.glCreateShader(GL_FRAGMENT_SHADER);
+ nonProgram[0] = -1;
+ nonProgram[1] = -1;
+ shaderProgram[0] = ctx.glCreateShader(GL_VERTEX_SHADER);
+ shaderProgram[1] = ctx.glCreateProgram();
ctx.beginSection("GL_INVALID_ENUM is generated if binaryFormat is not an accepted value.");
ctx.glShaderBinary(1, &shaders[0], -1, 0, 0);
ctx.glShaderBinary(2, &shaders[0], binaryFormats[0], 0, 0);
ctx.expectError(GL_INVALID_OPERATION, GL_INVALID_VALUE);
ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_VALUE is generated if count or length is negative.");
+ ctx.glShaderBinary(2, &shaderPair[0], binaryFormats[0], 0, -1);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.glShaderBinary(-1, &shaderPair[0], binaryFormats[0], 0, 0);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_VALUE is generated if shaders contains anything other than shader or program objects.");
+ ctx.glShaderBinary(2, &nonProgram[0], binaryFormats[0], 0, 0);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if shaders refers to a program object.");
+ ctx.glShaderBinary(2, &shaderProgram[0], binaryFormats[0], 0, 0);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
}
ctx.glDeleteShader(shaders[0]);
void delete_program (NegativeTestContext& ctx)
{
+ GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
+
ctx.beginSection("GL_INVALID_VALUE is generated if program is not a value generated by OpenGL.");
ctx.glDeleteProgram(-1);
ctx.expectError(GL_INVALID_VALUE);
ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if program is not zero and is the name of a shader object.");
+ ctx.glDeleteProgram(shader);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.glDeleteShader(shader);
}
void validate_program (NegativeTestContext& ctx)
void program_parameteri (NegativeTestContext& ctx)
{
- GLuint program = ctx.glCreateProgram();
+ GLuint program = ctx.glCreateProgram();
+ GLuint shader = ctx.glCreateShader(GL_VERTEX_SHADER);
ctx.beginSection("GL_INVALID_VALUE is generated if program is not the name of an existing program object.");
- ctx.glProgramParameteri (0, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
- ctx.expectError (GL_INVALID_VALUE);
+ ctx.glProgramParameteri(0, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+ ctx.expectError(GL_INVALID_VALUE);
ctx.endSection();
- ctx.beginSection("GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT.");
- ctx.glProgramParameteri (program, -1, GL_TRUE);
- ctx.expectError (GL_INVALID_ENUM);
+ ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
+ ctx.glProgramParameteri(shader, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL_TRUE);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_ENUM is generated if pname is not GL_PROGRAM_BINARY_RETRIEVABLE_HINT or PROGRAM_SEPARABLE.");
+ ctx.glProgramParameteri(program, -1, GL_TRUE);
+ ctx.expectError(GL_INVALID_ENUM);
ctx.endSection();
ctx.beginSection("GL_INVALID_VALUE is generated if value is not GL_FALSE or GL_TRUE.");
- ctx.glProgramParameteri (program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2);
- ctx.expectError (GL_INVALID_VALUE);
+ ctx.glProgramParameteri(program, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, 2);
+ ctx.expectError(GL_INVALID_VALUE);
ctx.endSection();
ctx.glDeleteProgram(program);
+ ctx.glDeleteShader(shader);
}
void gen_samplers (NegativeTestContext& ctx)
ctx.glDeleteSamplers(1, &sampler);
}
+void get_sampler_parameterIiv (NegativeTestContext& ctx)
+{
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
+ throw tcu::NotSupportedError("glGetSamplerParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__);
+
+ GLuint sampler = 0x1234;
+ GLint borderColor = 0x1234;
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers.");
+ ctx.glGetSamplerParameterIiv(sampler, GL_TEXTURE_BORDER_COLOR, &borderColor);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.glGenSamplers(1, &sampler);
+
+ ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
+ ctx.glGetSamplerParameterIiv(sampler, -1, &borderColor);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+
+ ctx.glDeleteSamplers(1, &sampler);
+}
+
+void get_sampler_parameterIuiv (NegativeTestContext& ctx)
+{
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
+ throw tcu::NotSupportedError("glGetSamplerParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__);
+
+ GLuint sampler = 0x1234;
+ GLuint borderColor = 0x1234;
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object returned from a previous call to ctx.glGenSamplers.");
+ ctx.glGetSamplerParameterIuiv(sampler, GL_TEXTURE_BORDER_COLOR, &borderColor);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.glGenSamplers(1, &sampler);
+
+ ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted value.");
+ ctx.glGetSamplerParameterIuiv(sampler, -1, &borderColor);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+
+ ctx.glDeleteSamplers(1, &sampler);
+}
+
void sampler_parameteri (NegativeTestContext& ctx)
{
- GLuint sampler = 0;
- ctx.glGenSamplers (1, &sampler);
+ GLuint sampler = 0;
+
+ ctx.glGenSamplers(1, &sampler);
ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
- ctx.glSamplerParameteri (-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
- ctx.expectError (GL_INVALID_OPERATION);
+ ctx.glSamplerParameteri(-1, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+ ctx.expectError(GL_INVALID_OPERATION);
ctx.endSection();
ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
- ctx.glSamplerParameteri (sampler, GL_TEXTURE_WRAP_S, -1);
- ctx.expectError (GL_INVALID_ENUM);
+ ctx.glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, -1);
+ ctx.expectError(GL_INVALID_ENUM);
ctx.endSection();
+ if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
+ {
+ ctx.beginSection("GL_INVALID_ENUM is generated if glSamplerParameteri is called for a non-scalar parameter.");
+ ctx.glSamplerParameteri(sampler, GL_TEXTURE_BORDER_COLOR, 0);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ }
+
ctx.glDeleteSamplers(1, &sampler);
}
void sampler_parameterf (NegativeTestContext& ctx)
{
- GLuint sampler = 0;
- ctx.glGenSamplers (1, &sampler);
+ GLuint sampler = 0;
+
+ ctx.glGenSamplers(1, &sampler);
ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
- ctx.glSamplerParameterf (-1, GL_TEXTURE_MIN_LOD, -1000.0f);
- ctx.expectError (GL_INVALID_OPERATION);
+ ctx.glSamplerParameterf(-1, GL_TEXTURE_MIN_LOD, -1000.0f);
+ ctx.expectError(GL_INVALID_OPERATION);
ctx.endSection();
ctx.beginSection("GL_INVALID_ENUM is generated if params should have a defined constant value (based on the value of pname) and does not.");
- ctx.glSamplerParameterf (sampler, GL_TEXTURE_WRAP_S, -1.0f);
- ctx.expectError (GL_INVALID_ENUM);
+ ctx.glSamplerParameterf(sampler, GL_TEXTURE_WRAP_S, -1.0f);
+ ctx.expectError(GL_INVALID_ENUM);
ctx.endSection();
+ if (contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
+ {
+ ctx.beginSection("GL_INVALID_ENUM is generated if glSamplerParameterf is called for a non-scalar parameter.");
+ ctx.glSamplerParameteri(sampler, GL_TEXTURE_BORDER_COLOR, 0);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+ }
+
ctx.glDeleteSamplers(1, &sampler);
}
ctx.glDeleteSamplers(1, &sampler);
}
+void sampler_parameterIiv (NegativeTestContext& ctx)
+{
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
+ throw tcu::NotSupportedError("glSamplerParameterIiv is not supported.", DE_NULL, __FILE__, __LINE__);
+
+ GLuint sampler;
+ GLint color[] = {0, 0, 0, 0};
+
+ ctx.glGenSamplers(1, &sampler);
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
+ ctx.glSamplerParameterIiv(-1, GL_TEXTURE_BORDER_COLOR, color);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted sampler state name.");
+ ctx.glSamplerParameterIiv(sampler, -1, color);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+}
+
+void sampler_parameterIuiv (NegativeTestContext& ctx)
+{
+ if (!contextSupports(ctx.getRenderContext().getType(), glu::ApiType::es(3, 2)))
+ throw tcu::NotSupportedError("glSamplerParameterIuiv is not supported.", DE_NULL, __FILE__, __LINE__);
+
+ GLuint sampler;
+ GLuint color[] = {0, 0, 0, 0};
+
+ ctx.glGenSamplers(1, &sampler);
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if sampler is not the name of a sampler object previously returned from a call to ctx.glGenSamplers.");
+ ctx.glSamplerParameterIuiv(-1, GL_TEXTURE_BORDER_COLOR, color);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_ENUM is generated if pname is not an accepted sampler state name.");
+ ctx.glSamplerParameterIuiv(sampler, -1, color);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+}
+
// Shader data commands
void get_attrib_location (NegativeTestContext& ctx)
void uniform_block_binding (NegativeTestContext& ctx)
{
- glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));
+ GLint maxUniformBufferBindings = -1;
+ GLint numActiveUniforms = -1;
+ GLint numActiveBlocks = -1;
+ GLuint shader = -1;
+ glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(uniformBlockVertSource, uniformTestFragSource));
- ctx.glUseProgram (program.getProgram());
+ shader = ctx.glCreateShader(GL_VERTEX_SHADER);
+ ctx.glUseProgram(program.getProgram());
- GLint maxUniformBufferBindings = -1;
- GLint numActiveUniforms = -1;
- GLint numActiveBlocks = -1;
- ctx.glGetIntegerv (GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
- ctx.glGetProgramiv (program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
- ctx.glGetProgramiv (program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
+ ctx.glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &maxUniformBufferBindings);
+ ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORMS, &numActiveUniforms);
+ ctx.glGetProgramiv(program.getProgram(), GL_ACTIVE_UNIFORM_BLOCKS, &numActiveBlocks);
ctx.getLog() << TestLog::Message << "// GL_MAX_UNIFORM_BUFFER_BINDINGS = " << maxUniformBufferBindings << TestLog::EndMessage;
ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORMS = " << numActiveUniforms << TestLog::EndMessage;
ctx.getLog() << TestLog::Message << "// GL_ACTIVE_UNIFORM_BLOCKS = " << numActiveBlocks << TestLog::EndMessage;
ctx.glUniformBlockBinding(-1, 0, 0);
ctx.expectError(GL_INVALID_VALUE);
ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
+ ctx.glUniformBlockBinding(shader, 0, 0);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.glDeleteShader(shader);
}
// ctx.glUniform*f
ctx.glDeleteBuffers (1, &buf);
ctx.glDeleteTransformFeedbacks (2, tfID);
ctx.expectError (GL_NO_ERROR);
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if id has been deleted with glDeleteTransformFeedback().");
+ ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_OPERATION is generated if id is not 0 or a value returned from glGenTransformFeedbacks().");
+ ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, -1);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.endSection();
}
void delete_transform_feedbacks (NegativeTestContext& ctx)
{
- GLuint id = 0;
+ GLuint id = 0;
+ GLuint tfID[2];
+ deUint32 buf = 0x1234;
+ const char* tfVarying = "gl_Position";
+ glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
+
+ ctx.glGenBuffers(1, &buf);
ctx.glGenTransformFeedbacks(1, &id);
+ ctx.glGenTransformFeedbacks(2, tfID);
ctx.beginSection("GL_INVALID_VALUE is generated if n is negative.");
ctx.glDeleteTransformFeedbacks(-1, &id);
ctx.expectError(GL_INVALID_VALUE);
ctx.endSection();
+ ctx.beginSection("GL_INVALID_OPERATION is generated if the transform feedback operation for any object named by ids is currently active.");
+ ctx.glUseProgram(program.getProgram());
+ ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+ ctx.glLinkProgram(program.getProgram());
+ ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[0]);
+ ctx.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, buf);
+ ctx.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 32, DE_NULL, GL_DYNAMIC_DRAW);
+ ctx.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, buf);
+ ctx.glBeginTransformFeedback(GL_TRIANGLES);
+ ctx.expectError(GL_NO_ERROR);
+
+ ctx.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, tfID[1]);
+ ctx.expectError(GL_INVALID_OPERATION);
+
+ ctx.glDeleteTransformFeedbacks(2, tfID);
+ ctx.expectError(GL_INVALID_OPERATION);
+
+ ctx.glEndTransformFeedback();
+ ctx.expectError(GL_NO_ERROR);
+ ctx.endSection();
+
+
ctx.glDeleteTransformFeedbacks(1, &id);
+ ctx.glDeleteTransformFeedbacks(2, tfID);
+ ctx.glDeleteBuffers(1, &buf);
+
}
void begin_transform_feedback (NegativeTestContext& ctx)
void transform_feedback_varyings (NegativeTestContext& ctx)
{
- GLuint tfID = 0;
- glu::ShaderProgram program(ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
- const char* tfVarying = "gl_Position";
- GLint maxTransformFeedbackSeparateAttribs = 0;
+ GLuint tfID = 0;
+ GLuint shader = -1;
+ glu::ShaderProgram program (ctx.getRenderContext(), glu::makeVtxFragSources(vertexShaderSource, fragmentShaderSource));
+ const char* tfVarying = "gl_Position";
+ GLint maxTransformFeedbackSeparateAttribs = 0;
ctx.glGenTransformFeedbacks (1, &tfID);
ctx.expectError (GL_NO_ERROR);
ctx.expectError (GL_INVALID_VALUE);
ctx.endSection();
+ ctx.beginSection("GL_INVALID_OPERATION is generated if program is the name of a shader object.");
+ shader = ctx.glCreateShader(GL_VERTEX_SHADER);
+ ctx.glTransformFeedbackVaryings(shader, 1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+ ctx.expectError(GL_INVALID_OPERATION);
+ ctx.glDeleteShader(shader);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_VALUE is generated if count is negative.");
+ ctx.glTransformFeedbackVaryings(program.getProgram(), -1, &tfVarying, GL_INTERLEAVED_ATTRIBS);
+ ctx.expectError(GL_INVALID_VALUE);
+ ctx.endSection();
+
+ ctx.beginSection("GL_INVALID_ENUM is generated if bufferMode is not SEPARATE_ATTRIBS or INTERLEAVED_ATTRIBS.");
+ ctx.glTransformFeedbackVaryings(program.getProgram(), 1, &tfVarying, 0);
+ ctx.expectError(GL_INVALID_ENUM);
+ ctx.endSection();
+
ctx.beginSection("GL_INVALID_VALUE is generated if bufferMode is GL_SEPARATE_ATTRIBS and count is greater than GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS.");
ctx.glGetIntegerv (GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, &maxTransformFeedbackSeparateAttribs);
ctx.glTransformFeedbackVaryings (program.getProgram(), maxTransformFeedbackSeparateAttribs+1, &tfVarying, GL_SEPARATE_ATTRIBS);
ctx.glDeleteTransformFeedbacks (1, &tfID);
ctx.expectError (GL_NO_ERROR);
+
+}
+
+void link_compute_shader (NegativeTestContext& ctx)
+{
+ const char* computeShaderSource = "#version 320 es\n"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+ {
+ const GLenum shaderTypes[] = {
+ GL_VERTEX_SHADER,
+ GL_FRAGMENT_SHADER,
+ GL_GEOMETRY_SHADER,
+ GL_TESS_CONTROL_SHADER,
+ GL_TESS_EVALUATION_SHADER
+ };
+
+ ctx.beginSection("Compute Shader linked with shader of other kind.");
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ndx++)
+ {
+ GLint linkStatus = -1;
+ GLuint program = ctx.glCreateProgram();
+ GLuint computeShader = ctx.glCreateShader(GL_COMPUTE_SHADER);
+ GLuint otherShader = ctx.glCreateShader(shaderTypes[ndx]);
+ const char* otherShaderSource = (shaderTypes[ndx] != GL_GEOMETRY_SHADER) ?
+ computeShaderSource :
+ "#version 320 es\n"
+ "layout(max_vertices = 3) out;\n"
+ "void main(void){}\n\0";
+
+ ctx.glShaderSource(computeShader, 1, &computeShaderSource, DE_NULL);
+ ctx.glShaderSource(otherShader, 1, &otherShaderSource, DE_NULL);
+ ctx.glCompileShader(computeShader);
+ ctx.glCompileShader(otherShader);
+ ctx.glAttachShader(program, computeShader);
+ ctx.glAttachShader(program, otherShader);
+ ctx.glLinkProgram(program);
+ ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+ ctx.glDeleteShader(otherShader);
+ ctx.glDeleteShader(computeShader);
+ ctx.glDeleteProgram(program);
+ if (linkStatus != GL_FALSE)
+ ctx.fail("Program should not have linked");
+ }
+ ctx.endSection();
+ }
+ {
+ const char* computeShaderSource310 = "#version 310 es\n"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+ GLint linkStatus = -1;
+ GLuint program = ctx.glCreateProgram();
+ GLuint computeShader = ctx.glCreateShader(GL_COMPUTE_SHADER);
+ GLuint computeShader310 = ctx.glCreateShader(GL_FRAGMENT_SHADER);
+
+ ctx.glShaderSource(computeShader, 1, &computeShaderSource, DE_NULL);
+ ctx.glShaderSource(computeShader310, 1, &computeShaderSource310, DE_NULL);
+ ctx.beginSection("Compute Shader should not be linked with shaders of different version.");
+ ctx.glCompileShader(computeShader);
+ ctx.glCompileShader(computeShader310);
+ ctx.glAttachShader(program, computeShader);
+ ctx.glAttachShader(program, computeShader310);
+ ctx.glLinkProgram(program);
+ ctx.glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+ ctx.glDeleteShader(computeShader310);
+ ctx.glDeleteShader(computeShader);
+ ctx.glDeleteProgram(program);
+ if (linkStatus != GL_FALSE)
+ ctx.fail("Program should not have linked");
+ ctx.endSection();
+ }
+}
+
+void compile_compute_shader_helper (NegativeTestContext& ctx, const char** computeShaderSource, GLint* compileStatus)
+{
+ GLuint shader = ctx.glCreateShader(GL_COMPUTE_SHADER);
+
+ *compileStatus = -1;
+ ctx.glShaderSource(shader, 1, computeShaderSource, DE_NULL);
+ ctx.glCompileShader(shader);
+ ctx.glGetShaderiv(shader, GL_COMPILE_STATUS, compileStatus);
+ ctx.glDeleteShader(shader);
+}
+
+void compile_compute_shader (NegativeTestContext& ctx)
+{
+ GLint compileStatus;
+ ctx.beginSection("Compile Computer Shader");
+
+ {
+ const char* computeShaderSource = "#version 300 es\n"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+
+ compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
+ if (compileStatus != GL_FALSE)
+ ctx.fail("Compute Shader should not have compiled with #version 300 es.");
+ }
+ {
+ const char* computeShaderSource = "#version 310 es\n"
+ "buffer SSBO { vec4 data }"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+
+ compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
+ if (compileStatus != GL_FALSE)
+ ctx.fail("Compute Shader should not have compiled: incorrect SSBO syntax.");
+ }
+ {
+ const char* computeShaderSource = "#version 310 es\n"
+ "buffer SSBO { vec4 data;};"
+ "uniform mat4 data;"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+
+ compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
+ if (compileStatus != GL_FALSE)
+ ctx.fail("Compute Shader should not have compiled: buffer variable redefinition.");
+ }
+ {
+ const char* computeShaderSource = "#version 310 es\n"
+ "buffer SSBO { vec4 data[]; vec4 moreData;};"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+
+ compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
+ if (compileStatus != GL_FALSE)
+ ctx.fail("Compute Shader should not have compiled: unspecified length buffer member not at the end.");
+ }
+ {
+ const char* computeShaderSource = "#version 310 es\n"
+ "in vec4 data;"
+ "void main (void)\n"
+ "{\n"
+ "}\n\0";
+
+ compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
+ if (compileStatus != GL_FALSE)
+ ctx.fail("Compute Shader should not have compiled: input qualifier used.");
+ }
+ {
+ const char* computeShaderSource = "#version 310 es\n"
+ "shared uint data = 0;";
+
+ compile_compute_shader_helper(ctx, &computeShaderSource, &compileStatus);
+ if (compileStatus != GL_FALSE)
+ ctx.fail("Compute Shader should not have compiled: shared-qualified variable initialized.");
+ }
+ ctx.endSection();
}
std::vector<FunctionContainer> getNegativeShaderApiTestFunctions ()
{delete_samplers, "delete_samplers", "Invalid glDeleteSamplers() usage" },
{get_sampler_parameteriv, "get_sampler_parameteriv", "Invalid glGetSamplerParameteriv() usage" },
{get_sampler_parameterfv, "get_sampler_parameterfv", "Invalid glGetSamplerParameterfv() usage" },
+ {get_sampler_parameterIiv, "get_sampler_parameterIiv", "Invalid glGetSamplerParameterIiv() usage" },
+ {get_sampler_parameterIuiv, "get_sampler_parameterIuiv", "Invalid glGetSamplerParameterIuiv() usage" },
{sampler_parameteri, "sampler_parameteri", "Invalid glSamplerParameteri() usage" },
{sampler_parameteriv, "sampler_parameteriv", "Invalid glSamplerParameteriv() usage" },
{sampler_parameterf, "sampler_parameterf", "Invalid glSamplerParameterf() usage" },
{sampler_parameterfv, "sampler_parameterfv", "Invalid glSamplerParameterfv() usage" },
+ {sampler_parameterIiv, "sampler_parameterIiv", "Invalid glSamplerParameterIiv() usage" },
+ {sampler_parameterIuiv, "sampler_parameterIuiv", "Invalid glSamplerParameterIuiv() usage" },
{get_attrib_location, "get_attrib_location", "Invalid glGetAttribLocation() usage" },
{get_uniform_location, "get_uniform_location", "Invalid glGetUniformLocation() usage" },
{bind_attrib_location, "bind_attrib_location", "Invalid glBindAttribLocation() usage" },
{end_transform_feedback, "end_transform_feedback", "Invalid glEndTransformFeedback() usage" },
{get_transform_feedback_varying, "get_transform_feedback_varying", "Invalid glGetTransformFeedbackVarying() usage"},
{transform_feedback_varyings, "transform_feedback_varyings", "Invalid glTransformFeedbackVaryings() usage" },
+ {compile_compute_shader, "compile_compute_shader", "Invalid Compute Shader compilation" },
+ {link_compute_shader, "link_compute_shader", "Invalid Compute Shader linkage" },
};
return std::vector<FunctionContainer>(DE_ARRAY_BEGIN(funcs), DE_ARRAY_END(funcs));
projects / platform / upstream / VK-GL-CTS.git / commitdiff