Merge vk-gl-cts/opengl-cts-4.6.2 into vk-gl-cts/main

Change-Id: I87fcdfdea92e5a3ba36454128ee4e2092c33c4f9

diff --git a/external/openglcts/modules/gl/gl4cSparseBufferTests.cpp b/external/openglcts/modules/gl/gl4cSparseBufferTests.cpp
index f0fd439..bffbaa7 100644 (file)
--- a/external/openglcts/modules/gl/gl4cSparseBufferTests.cpp
+++ b/external/openglcts/modules/gl/gl4cSparseBufferTests.cpp
@@ -885,8 +885,8 @@ void AtomicCounterBufferStorageTestCase::deinitTestCaseIteration()
                m_gl.bindBuffer(GL_ARRAY_BUFFER, m_sparse_bo);
                GLU_EXPECT_NO_ERROR(m_gl.getError(), "glBindBuffer() call failed.");
 
-               m_gl.bufferPageCommitmentARB(GL_ARRAY_BUFFER, 0,                                  /* offset */
-                                                                        m_helper_bo_size_rounded, GL_FALSE); /* commit */
+               m_gl.bufferPageCommitmentARB(GL_ARRAY_BUFFER, m_sparse_bo_data_start_offset_rounded,            /* offset */
+                                                                        m_sparse_bo_data_size_rounded, GL_FALSE); /* commit */
                GLU_EXPECT_NO_ERROR(m_gl.getError(), "glBufferPageCommitmentARB() call failed.");
 
                m_sparse_bo = 0;

diff --git a/external/openglcts/modules/gl/gl4cSparseTexture2Tests.cpp b/external/openglcts/modules/gl/gl4cSparseTexture2Tests.cpp
index b5f1508..49cb243 100644 (file)
--- a/external/openglcts/modules/gl/gl4cSparseTexture2Tests.cpp
+++ b/external/openglcts/modules/gl/gl4cSparseTexture2Tests.cpp
@@ -415,6 +415,26 @@ tcu::TestNode::IterateResult StandardPageSizesTestCase::iterate()
                        const PageSizePair&   format = *formIter;
                        const PageSizeStruct& page   = format.second;
 
+                       if (target == GL_TEXTURE_BUFFER) {
+                               /* filter out invalid texture buffer formats according to ARB_texture_buffer_object */
+                               switch (format.first) {
+                               case GL_RGB10_A2:
+                               case GL_RGB10_A2UI:
+                               case GL_R11F_G11F_B10F:
+                               case GL_RGB9_E5:
+                               case GL_RGB565:
+                               case GL_R8_SNORM:
+                               case GL_RG8_SNORM:
+                               case GL_RGBA8_SNORM:
+                               case GL_R16_SNORM:
+                               case GL_RG16_SNORM:
+                               case GL_RGBA16_SNORM:
+                                       continue;
+                               default:
+                                       break;
+                               }
+                       }
+
                        GLint pageSizeX;
                        GLint pageSizeY;
                        GLint pageSizeZ;
@@ -576,7 +596,7 @@ tcu::TestNode::IterateResult SparseTexture2CommitmentTestCase::iterate()
  * @return target    Structure of token strings
  */
 SparseTexture2CommitmentTestCase::TokenStrings SparseTexture2CommitmentTestCase::createShaderTokens(
-       GLint target, GLint format, GLint sample, const std::string outputBase, const std::string inputBase)
+       GLint target, GLint verifyTarget, GLint format, GLint sample, const std::string outputBase, const std::string inputBase)
 {
        TokenStrings s;
        std::string  prefix;
@@ -847,21 +867,18 @@ SparseTexture2CommitmentTestCase::TokenStrings SparseTexture2CommitmentTestCase:
 
        if (target == GL_TEXTURE_1D)
        {
-               s.outputType = "u" + outputBase + "2D";
                s.inputType  = prefix + inputBase + "1D";
                s.pointType  = "int";
                s.pointDef   = "gl_WorkGroupID.x";
        }
        else if (target == GL_TEXTURE_1D_ARRAY)
        {
-               s.outputType = "u" + outputBase + "2D_ARRAY";
                s.inputType  = prefix + inputBase + "1DArray";
                s.pointType  = "ivec2";
                s.pointDef   = "gl_WorkGroupID.x, gl_WorkGroupID.z";
        }
        else if (target == GL_TEXTURE_2D_ARRAY)
        {
-               s.outputType = "u" + outputBase + "2DArray";
                s.inputType  = prefix + inputBase + "2DArray";
                s.pointType  = "ivec3";
                s.pointDef   = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
@@ -875,14 +892,12 @@ SparseTexture2CommitmentTestCase::TokenStrings SparseTexture2CommitmentTestCase:
        }
        else if (target == GL_TEXTURE_CUBE_MAP)
        {
-               s.outputType = "u" + outputBase + "2DArray";
                s.inputType  = prefix + inputBase + "Cube";
                s.pointType  = "ivec3";
                s.pointDef   = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z % 6";
        }
        else if (target == GL_TEXTURE_CUBE_MAP_ARRAY)
        {
-               s.outputType = "u" + outputBase + "2DArray";
                s.inputType  = prefix + inputBase + "CubeArray";
                s.pointType  = "ivec3";
                s.pointDef   = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
@@ -898,12 +913,19 @@ SparseTexture2CommitmentTestCase::TokenStrings SparseTexture2CommitmentTestCase:
        }
        else if (target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
        {
-               s.outputType = "u" + outputBase + "2DArray";
                s.inputType  = prefix + inputBase + "2DMSArray";
                s.pointType  = "ivec3";
                s.pointDef   = "gl_WorkGroupID.x, gl_WorkGroupID.y, gl_WorkGroupID.z";
                s.sampleDef  = ", " + de::toString(sample);
        }
+       if (verifyTarget == GL_TEXTURE_2D)
+       {
+               s.outputType = "u" + outputBase + "2D";
+       }
+       else
+       {
+               s.outputType = "u" + outputBase + "2DArray";
+       }
 
        return s;
 }
@@ -1063,7 +1085,12 @@ bool SparseTexture2CommitmentTestCase::writeDataToTexture(const Functions& gl, G
                                std::string shader = st2_compute_textureFill;
 
                                // Adjust shader source to texture format
-                               TokenStrings s = createShaderTokens(target, format, sample);
+                               GLint verifyTarget;
+                               if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
+                                       verifyTarget = GL_TEXTURE_2D;
+                               else
+                                       verifyTarget = GL_TEXTURE_2D_ARRAY;
+                               TokenStrings s = createShaderTokens(target, verifyTarget, format, sample);
 
                                replaceToken("<INPUT_TYPE>", s.inputType.c_str(), shader);
                                replaceToken("<POINT_TYPE>", s.pointType.c_str(), shader);
@@ -1233,7 +1260,7 @@ bool SparseTexture2CommitmentTestCase::verifyTextureData(const Functions& gl, GL
 
                // Create verifying texture
                GLint verifyTarget;
-               if (target == GL_TEXTURE_2D_MULTISAMPLE)
+               if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
                        verifyTarget = GL_TEXTURE_2D;
                else
                        verifyTarget = GL_TEXTURE_2D_ARRAY;
@@ -1256,7 +1283,7 @@ bool SparseTexture2CommitmentTestCase::verifyTextureData(const Functions& gl, GL
                        std::string shader = st2_compute_textureVerify;
 
                        // Adjust shader source to texture format
-                       TokenStrings s = createShaderTokens(target, format, sample);
+                       TokenStrings s = createShaderTokens(target, verifyTarget, format, sample);
 
                        replaceToken("<OUTPUT_TYPE>", s.outputType.c_str(), shader);
                        replaceToken("<FORMAT>", s.format.c_str(), shader);
@@ -1310,8 +1337,14 @@ bool SparseTexture2CommitmentTestCase::verifyTextureData(const Functions& gl, GL
                                                {
                                                        GLubyte* dataRegion     = exp_data + ((x + y * width) + z * width * height);
                                                        GLubyte* outDataRegion = out_data + ((x + y * width) + z * width * height);
-                                                       if (dataRegion[0] != outDataRegion[0])
+                                                       if (dataRegion[0] != outDataRegion[0]) {
+                                                               m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() <<
+                                                                       "Error detected at " << x << "," << y << "," << z << " for sample " << sample <<
+                                                                       ": expected [" << (unsigned)dataRegion[0] << "] got [" <<
+                                                                       (unsigned)outDataRegion[0] << "]" << tcu::TestLog::EndMessage;
                                                                result = false;
+                                                               goto out;
+                                                       }
                                                }
                        }
                        else
@@ -1323,7 +1356,7 @@ bool SparseTexture2CommitmentTestCase::verifyTextureData(const Functions& gl, GL
                                result = false;
                        }
                }
-
+out:
                Texture::Delete(gl, verifyTexture);
        }
 
@@ -1511,6 +1544,31 @@ bool UncommittedRegionsAccessTestCase::UncommittedReads(const Functions& gl, GLi
        if (result && level == 0 && target != GL_TEXTURE_RECTANGLE && target != GL_TEXTURE_2D_MULTISAMPLE &&
                target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
        {
+               /* Khronos bugzilla #9471 states that mipmap generation with integer formats
+                * is unsupported, so skip this test
+                */
+               switch (format) {
+               case GL_RGB10_A2UI:
+               case GL_R8I:
+               case GL_R8UI:
+               case GL_R16I:
+               case GL_R16UI:
+               case GL_R32I:
+               case GL_R32UI:
+               case GL_RG8I:
+               case GL_RG8UI:
+               case GL_RG16I:
+               case GL_RG16UI:
+               case GL_RG32I:
+               case GL_RG32UI:
+               case GL_RGBA8I:
+               case GL_RGBA8UI:
+               case GL_RGBA16I:
+               case GL_RGBA16UI:
+               case GL_RGBA32I:
+               case GL_RGBA32UI:
+                  return result;
+               }
                mLog << "Mipmap Generate - ";
                Texture::Bind(gl, texture, target);
                gl.generateMipmap(target);
@@ -1722,15 +1780,25 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
                GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData");
 
                //Verify only uncommitted region
-               for (GLint x = widthCommitted; x < width; ++x)
-                       for (GLint y = 0; y < height; ++y)
-                               for (GLint z = 0; z < depth; ++z)
+               for (GLint x = widthCommitted; result && x < width; ++x)
+                       for (GLint y = 0; result && y < height; ++y)
+                               for (GLint z = 0; result && z < depth; ++z)
                                {
                                        int              pixelSize       = mState.format.getPixelSize();
                                        GLubyte* dataRegion     = exp_data + ((x + y * width) * pixelSize);
                                        GLubyte* outDataRegion = out_data + ((x + y * width) * pixelSize);
-                                       if (deMemCmp(dataRegion, outDataRegion, pixelSize) != 0)
+                                       if (deMemCmp(dataRegion, outDataRegion, pixelSize) != 0) {
+                                               mLog <<
+                                                       "Error detected at " << x << "," << y << "," << z <<
+                                                       ": expected [ ";
+                                               for (int e = 0; e < pixelSize; e++)
+                                                       mLog << (unsigned)dataRegion[e] << " ";
+                                               mLog << "] got [ ";
+                                               for (int e = 0; e < pixelSize; e++)
+                                                       mLog <<(unsigned)outDataRegion[e] << " ";
+                                               mLog << "] ";
                                                result = false;
+                                       }
                                }
        }
        // Verify texture using API glGetTexImage* (Only cube map as it has to be verified for subtargets)
@@ -1768,15 +1836,25 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
                        GLU_EXPECT_NO_ERROR(gl.getError(), "Texture::GetData");
 
                        //Verify only uncommitted region
-                       for (GLint x = widthCommitted; x < width; ++x)
-                               for (GLint y = 0; y < height; ++y)
-                                       for (GLint z = 0; z < depth; ++z)
+                       for (GLint x = widthCommitted; result && x < width; ++x)
+                               for (GLint y = 0; result && y < height; ++y)
+                                       for (GLint z = 0; result && z < depth; ++z)
                                        {
                                                int              pixelSize       = mState.format.getPixelSize();
                                                GLubyte* dataRegion     = exp_data + ((x + y * width) * pixelSize);
                                                GLubyte* outDataRegion = out_data + ((x + y * width) * pixelSize);
-                                               if (deMemCmp(dataRegion, outDataRegion, pixelSize) != 0)
+                                               if (deMemCmp(dataRegion, outDataRegion, pixelSize) != 0) {
+                                                       mLog <<
+                                                               "Error detected at " << x << "," << y << "," << z <<
+                                                               ": expected [ ";
+                                                       for (int e = 0; e < pixelSize; e++)
+                                                               mLog << (unsigned)dataRegion[e] << " ";
+                                                       mLog << "] got [ ";
+                                                       for (int e = 0; e < pixelSize; e++)
+                                                               mLog <<(unsigned)outDataRegion[e] << " ";
+                                                       mLog << "] ";
                                                        result = false;
+                                               }
                                        }
 
                        if (!result)
@@ -1788,13 +1866,15 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
        {
                // Create verifying texture
                GLint verifyTarget;
-               if (target == GL_TEXTURE_2D_MULTISAMPLE)
+               if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
                        verifyTarget = GL_TEXTURE_2D;
                else
                        verifyTarget = GL_TEXTURE_2D_ARRAY;
 
                if (target == GL_TEXTURE_CUBE_MAP)
                        depth = depth * 6;
+               if (depth == 1 && mState.samples == 1)
+                       target = GL_TEXTURE_2D;
 
                GLint texSize = width * height * depth;
 
@@ -1826,7 +1906,7 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
                        std::string shader = st2_compute_textureVerify;
 
                        // Adjust shader source to texture format
-                       TokenStrings s = createShaderTokens(target, format, sample);
+                       TokenStrings s = createShaderTokens(target, verifyTarget, format, sample);
 
                        replaceToken("<OUTPUT_TYPE>", s.outputType.c_str(), shader);
                        replaceToken("<FORMAT>", s.format.c_str(), shader);
@@ -1850,14 +1930,14 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
                                gl.bindImageTexture(0, //unit
                                                                        verifyTexture,
                                                                        0,                //level
-                                                                       GL_FALSE, //layered
+                                                                       depth > 1, //layered
                                                                        0,                //layer
                                                                        GL_WRITE_ONLY, GL_R8UI);
                                GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
                                gl.bindImageTexture(1, //unit
                                                                        texture,
                                                                        level,  //level
-                                                                       GL_FALSE, //layered
+                                                                       depth > 1, //layered
                                                                        0,                //layer
                                                                        GL_READ_ONLY, format);
                                GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
@@ -1880,8 +1960,14 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
                                                {
                                                        GLubyte* dataRegion     = exp_data + ((x + y * width) + z * width * height);
                                                        GLubyte* outDataRegion = out_data + ((x + y * width) + z * width * height);
-                                                       if (dataRegion[0] != outDataRegion[0])
+                                                       if (dataRegion[0] != outDataRegion[0]) {
+                                                               m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() <<
+                                                                       "Error detected at " << x << "," << y << "," << z << " for sample " << sample <<
+                                                                       ": expected [" << (unsigned)dataRegion[0] << "] got [" <<
+                                                                       (unsigned)outDataRegion[0] << "]" << tcu::TestLog::EndMessage;
                                                                result = false;
+                                                               goto out;
+                                                       }
                                                }
                        }
                        else
@@ -1893,7 +1979,7 @@ bool UncommittedRegionsAccessTestCase::verifyTextureDataExtended(const Functions
                                result = false;
                        }
                }
-
+out:
                Texture::Delete(gl, verifyTexture);
        }
 
@@ -1933,10 +2019,14 @@ bool UncommittedRegionsAccessTestCase::verifyAtomicOperations(const Functions& g
 
        // Create verifying texture
        GLint verifyTarget;
-       if (target == GL_TEXTURE_2D_MULTISAMPLE)
+       if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
                verifyTarget = GL_TEXTURE_2D;
        else
                verifyTarget = GL_TEXTURE_2D_ARRAY;
+       if (target == GL_TEXTURE_CUBE_MAP)
+               depth = depth * 6;
+       if (depth == 1 && mState.samples == 1)
+               target = GL_TEXTURE_2D;
 
        GLint texSize = width * height * depth;
 
@@ -1968,7 +2058,7 @@ bool UncommittedRegionsAccessTestCase::verifyAtomicOperations(const Functions& g
                std::string shader = st2_compute_atomicVerify;
 
                // Adjust shader source to texture format
-               TokenStrings s            = createShaderTokens(target, format, sample);
+               TokenStrings s            = createShaderTokens(target, verifyTarget, format, sample);
                std::string  dataType = (s.returnType == "ivec4" ? "int" : "uint");
 
                replaceToken("<OUTPUT_TYPE>", s.outputType.c_str(), shader);
@@ -1992,14 +2082,14 @@ bool UncommittedRegionsAccessTestCase::verifyAtomicOperations(const Functions& g
                        gl.bindImageTexture(0, //unit
                                                                verifyTexture,
                                                                0,                //level
-                                                               GL_FALSE, //layered
+                                                               depth > 1, //layered
                                                                0,                //layer
                                                                GL_WRITE_ONLY, GL_R8UI);
                        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
                        gl.bindImageTexture(1, //unit
                                                                texture,
                                                                level,  //level
-                                                               GL_FALSE, //layered
+                                                               depth > 1, //layered
                                                                0,                //layer
                                                                GL_READ_ONLY, format);
                        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
@@ -2024,11 +2114,14 @@ bool UncommittedRegionsAccessTestCase::verifyAtomicOperations(const Functions& g
                                        {
                                                GLubyte* dataRegion     = exp_data + ((x + y * width) + z * width * height);
                                                GLubyte* outDataRegion = out_data + ((x + y * width) + z * width * height);
-                                               if (dataRegion[0] != outDataRegion[0])
-                                               {
-                                                       printf("%d:%d ", dataRegion[0], outDataRegion[0]);
-                                                       result = false;
-                                               }
+                                                       if (dataRegion[0] != outDataRegion[0]) {
+                                                               m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() <<
+                                                                       "Error detected at " << x << "," << y << "," << z << " for sample " << sample <<
+                                                                       ": expected [" << (unsigned)dataRegion[0] << "] got [" <<
+                                                                       (unsigned)outDataRegion[0] << "]" << tcu::TestLog::EndMessage;
+                                                               result = false;
+                                                               goto out;
+                                                       }
                                        }
                }
                else
@@ -2040,7 +2133,7 @@ bool UncommittedRegionsAccessTestCase::verifyAtomicOperations(const Functions& g
                        result = false;
                }
        }
-
+out:
        Texture::Delete(gl, verifyTexture);
 
        return result;
@@ -2392,7 +2485,7 @@ tcu::TestNode::IterateResult SparseTexture2LookupTestCase::iterate()
  * @return Returns extended token strings structure.
  */
 SparseTexture2LookupTestCase::TokenStringsExt SparseTexture2LookupTestCase::createLookupShaderTokens(
-       GLint target, GLint format, GLint level, GLint sample, FunctionToken& funcToken)
+       GLint target, GLint verifyTarget, GLint format, GLint level, GLint sample, FunctionToken& funcToken)
 {
        std::string funcName = funcToken.name;
 
@@ -2407,7 +2500,7 @@ SparseTexture2LookupTestCase::TokenStringsExt SparseTexture2LookupTestCase::crea
                inputType = "sampler";
 
        // Copy data from TokenStrings to TokenStringsExt
-       TokenStrings ss  = createShaderTokens(target, format, sample, "image", inputType);
+       TokenStrings ss  = createShaderTokens(target, verifyTarget, format, sample, "image", inputType);
        s.epsilon                = ss.epsilon;
        s.format                 = ss.format;
        s.inputType              = ss.inputType;
@@ -2695,7 +2788,12 @@ bool SparseTexture2LookupTestCase::writeDataToTexture(const Functions& gl, GLint
                        std::string shader = st2_compute_textureFill;
 
                        // Adjust shader source to texture format
-                       TokenStrings s = createShaderTokens(target, format, sample);
+                       GLint verifyTarget;
+                       if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
+                               verifyTarget = GL_TEXTURE_2D;
+                       else
+                               verifyTarget = GL_TEXTURE_2D_ARRAY;
+                       TokenStrings s = createShaderTokens(target, verifyTarget, format, sample);
 
                        replaceToken("<INPUT_TYPE>", s.inputType.c_str(), shader);
                        replaceToken("<POINT_TYPE>", s.pointType.c_str(), shader);
@@ -2717,7 +2815,7 @@ bool SparseTexture2LookupTestCase::writeDataToTexture(const Functions& gl, GLint
                        {
                                gl.useProgram(program.getProgram());
                                GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
-                               gl.bindImageTexture(0 /* unit */, texture, level /* level */, GL_FALSE /* layered */, 0 /* layer */,
+                               gl.bindImageTexture(0 /* unit */, texture, level /* level */, depth > 1 /* layered */, 0 /* layer */,
                                                                        GL_WRITE_ONLY, convFormat);
                                GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture");
                                gl.uniform1i(1, 0 /* image_unit */);
@@ -2806,7 +2904,7 @@ bool SparseTexture2LookupTestCase::verifyLookupTextureData(const Functions& gl,
 
        // Create verifying texture
        GLint verifyTarget;
-       if (target == GL_TEXTURE_2D_MULTISAMPLE)
+       if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
                verifyTarget = GL_TEXTURE_2D;
        else
                verifyTarget = GL_TEXTURE_2D_ARRAY;
@@ -2829,7 +2927,7 @@ bool SparseTexture2LookupTestCase::verifyLookupTextureData(const Functions& gl,
                std::string shader = st2_compute_lookupVerify;
 
                // Adjust shader source to texture format
-               TokenStringsExt s = createLookupShaderTokens(target, format, level, sample, f);
+               TokenStringsExt s = createLookupShaderTokens(target, verifyTarget, format, level, sample, f);
 
                replaceToken("<FUNCTION>", f.name.c_str(), shader);
                replaceToken("<ARGUMENTS>", f.arguments.c_str(), shader);
@@ -2926,8 +3024,14 @@ bool SparseTexture2LookupTestCase::verifyLookupTextureData(const Functions& gl,
                                        {
                                                GLubyte* dataRegion     = exp_data + x + y * width + z * width * height;
                                                GLubyte* outDataRegion = out_data + x + y * width + z * width * height;
-                                               if (dataRegion[0] != outDataRegion[0])
+                                               if (dataRegion[0] != outDataRegion[0]) {
+                                                       m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() <<
+                                                               "Error detected at " << x << "," << y << "," << z << " for sample " << sample <<
+                                                               ": expected [" << (unsigned)dataRegion[0] << "] got [" <<
+                                                               (unsigned)outDataRegion[0] << "]" << tcu::TestLog::EndMessage;
                                                        result = false;
+                                                       goto out;
+                                               }
                                        }
                }
                else
@@ -2940,7 +3044,7 @@ bool SparseTexture2LookupTestCase::verifyLookupTextureData(const Functions& gl,
                        result = false;
                }
        }
-
+out:
        Texture::Delete(gl, verifyTexture);
 
        return result;

diff --git a/external/openglcts/modules/gl/gl4cSparseTexture2Tests.hpp b/external/openglcts/modules/gl/gl4cSparseTexture2Tests.hpp
index 64cada9..56e3feb 100644 (file)
--- a/external/openglcts/modules/gl/gl4cSparseTexture2Tests.hpp
+++ b/external/openglcts/modules/gl/gl4cSparseTexture2Tests.hpp
@@ -147,7 +147,7 @@ protected:
        };
 
        /* Protected methods */
-       TokenStrings createShaderTokens(GLint target, GLint format, GLint sample, const std::string outputBase = "image",
+       TokenStrings createShaderTokens(GLint target, GLint verifyTarget, GLint format, GLint sample, const std::string outputBase = "image",
                                                                        const std::string inputBase = "image");
 
        virtual bool caseAllowed(GLint target, GLint format);
@@ -250,7 +250,7 @@ protected:
        std::vector<FunctionToken> mFunctions;
 
        /* Protected methods */
-       TokenStringsExt createLookupShaderTokens(GLint target, GLint format, GLint level, GLint sample,
+       TokenStringsExt createLookupShaderTokens(GLint target, GLint verifyTarget, GLint format, GLint level, GLint sample,
                                                                                         FunctionToken& funcToken);
 
        virtual bool caseAllowed(GLint target, GLint format);

diff --git a/external/openglcts/modules/gl/gl4cSparseTextureClampTests.cpp b/external/openglcts/modules/gl/gl4cSparseTextureClampTests.cpp
index 2afadb5..1246637 100644 (file)
--- a/external/openglcts/modules/gl/gl4cSparseTextureClampTests.cpp
+++ b/external/openglcts/modules/gl/gl4cSparseTextureClampTests.cpp
@@ -344,7 +344,7 @@ bool SparseTextureClampLookupResidencyTestCase::verifyLookupTextureData(const Fu
                FunctionToken f = funcToken;
 
                // Adjust shader source to texture format
-               TokenStringsExt s = createLookupShaderTokens(target, format, level, sample, f);
+               TokenStringsExt s = createLookupShaderTokens(target, verifyTarget, format, level, sample, f);
 
                replaceToken("<COORD_TYPE>", s.coordType.c_str(), vertex);
 
@@ -411,6 +411,8 @@ bool SparseTextureClampLookupResidencyTestCase::verifyLookupTextureData(const Fu
 
                                gl.bindTexture(target, texture);
                                GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture");
+                               gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+                               gl.texParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
                                gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                                draw(target, z, program);
@@ -425,8 +427,14 @@ bool SparseTextureClampLookupResidencyTestCase::verifyLookupTextureData(const Fu
                                        {
                                                GLubyte* dataRegion     = exp_data + x + y * width;
                                                GLubyte* outDataRegion = out_data + x + y * width;
-                                               if (dataRegion[0] != outDataRegion[0])
+                                               if (dataRegion[0] != outDataRegion[0]) {
+                                                       m_testCtx.getLog() << tcu::TestLog::Message << mLog.str() <<
+                                                               "Error detected at " << x << "," << y << "," << z <<
+                                                               ": expected [" << (unsigned)dataRegion[0] << "] got [" <<
+                                                               (unsigned)outDataRegion[0] << "]" << tcu::TestLog::EndMessage;
                                                        result = false;
+                                                       goto out;
+                                               }
                                        }
                        }
                }
@@ -441,7 +449,7 @@ bool SparseTextureClampLookupResidencyTestCase::verifyLookupTextureData(const Fu
                        result = false;
                }
        }
-
+out:
        gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer");
 
@@ -727,7 +735,12 @@ bool SparseTextureClampLookupColorTestCase::writeDataToTexture(const Functions&
                        std::string shader = stc_compute_textureFill;
 
                        // Adjust shader source to texture format
-                       TokenStrings s = createShaderTokens(target, format, sample);
+                       GLint verifyTarget;
+                       if (target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D || target == GL_TEXTURE_RECTANGLE)
+                               verifyTarget = GL_TEXTURE_2D;
+                       else
+                               verifyTarget = GL_TEXTURE_2D_ARRAY;
+                       TokenStrings s = createShaderTokens(target, verifyTarget, format, sample);
 
                        GLint convFormat = format;
                        if (format == GL_DEPTH_COMPONENT16)
@@ -848,7 +861,7 @@ bool SparseTextureClampLookupColorTestCase::verifyLookupTextureData(const Functi
                std::string functionDef = generateFunctionDef(f.name);
 
                // Adjust shader source to texture format
-               TokenStringsExt s = createLookupShaderTokens(target, format, level, sample, f);
+               TokenStringsExt s = createLookupShaderTokens(target, verifyTarget, format, level, sample, f);
 
                // Change expected result as it has to be adjusted to different levels
                s.resultExpected = generateExpectedResult(s.returnType, level, format);
@@ -916,6 +929,8 @@ bool SparseTextureClampLookupColorTestCase::verifyLookupTextureData(const Functi
 
                                gl.bindTexture(target, texture);
                                GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture");
+                               gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
+                               gl.texParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
                                gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                                draw(target, z, program);