Merge vk-gl-cts/vulkan-cts-1.0.2 into vk-gl-cts/master

Change-Id: I862763ebe1531b6f701657c34083fa715a287678

diff --combined external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
index 9c924b1,cce98a2..a1eb7dc
--- 1/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
--- 2/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
@@@ -472,14 -472,14 +472,14 @@@ bool validateFeatureLimits(VkPhysicalDe
                }
        }
  
-       if (limits->viewportBoundsRange[0] > -2 * limits->maxViewportDimensions[0])
+       if (limits->viewportBoundsRange[0] > float(-2 * limits->maxViewportDimensions[0]))
        {
                log << TestLog::Message << "limit validation failed, viewPortBoundsRange[0] of " << limits->viewportBoundsRange[0]
                        << "is larger than -2*maxViewportDimension[0] of " << -2*limits->maxViewportDimensions[0] << TestLog::EndMessage;
                limitsOk = false;
        }
  
-       if (limits->viewportBoundsRange[1] < 2 * limits->maxViewportDimensions[1] - 1)
+       if (limits->viewportBoundsRange[1] < float(2 * limits->maxViewportDimensions[1] - 1))
        {
                log << TestLog::Message << "limit validation failed, viewportBoundsRange[1] of " << limits->viewportBoundsRange[1]
                        << "is less than 2*maxViewportDimension[1] of " << 2*limits->maxViewportDimensions[1] << TestLog::EndMessage;
@@@ -2114,28 -2114,12 +2114,28 @@@ tcu::TestStatus imageFormatProperties (
                                results.check(imageType != VK_IMAGE_TYPE_3D || (properties.maxExtent.width >= 1 && properties.maxExtent.height >= 1 && properties.maxExtent.depth >= 1), "Invalid dimensions for 3D image");
                                results.check(imageType != VK_IMAGE_TYPE_3D || properties.maxArrayLayers == 1, "Invalid maxArrayLayers for 3D image");
  
 -                              if (tiling == VK_IMAGE_TILING_OPTIMAL && imageType == VK_IMAGE_TYPE_2D && !(curCreateFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
 -                                       ((supportedFeatures & (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) ||
 -                                       ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) && deviceFeatures.shaderStorageImageMultisample)))
 +                              if (tiling == VK_IMAGE_TILING_OPTIMAL)
                                {
 -                                      const VkSampleCountFlags        requiredSampleCounts    = getRequiredOptimalTilingSampleCounts(deviceLimits, format, curUsageFlags);
 -                                      results.check((properties.sampleCounts & requiredSampleCounts) == requiredSampleCounts, "Required sample counts not supported");
 +                                      // Vulkan API specification has changed since initial Android Nougat release.
 +                                      // For NYC CTS we need to tolerate old behavior as well and issue compatibility
 +                                      // warning instead.
 +                                      //
 +                                      // See spec issues 272, 282, 302, 445 and CTS issues 369, 440.
 +                                      const bool      requiredByNewSpec       = (imageType == VK_IMAGE_TYPE_2D && !(curCreateFlags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
 +                                                                                                        ((supportedFeatures & (VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) ||
 +                                                                                                        ((supportedFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT) && deviceFeatures.shaderStorageImageMultisample)));
 +
 +                                      if (requiredByNewSpec)
 +                                      {
 +                                              const VkSampleCountFlags        requiredSampleCounts    = getRequiredOptimalTilingSampleCounts(deviceLimits, format, curUsageFlags);
 +
 +                                              results.check((properties.sampleCounts & requiredSampleCounts) == requiredSampleCounts, "Required sample counts not supported");
 +                                      }
 +                                      else if (properties.sampleCounts != VK_SAMPLE_COUNT_1_BIT)
 +                                      {
 +                                              results.addResult(QP_TEST_RESULT_COMPATIBILITY_WARNING,
 +                                                                            "Implementation supports more sample counts than allowed by the spec");
 +                                      }
                                }
                                else
                                        results.check(properties.sampleCounts == VK_SAMPLE_COUNT_1_BIT, "sampleCounts != VK_SAMPLE_COUNT_1_BIT");

diff --combined external/vulkancts/modules/vulkan/shaderexecutor/vktShaderBuiltinPrecisionTests.cpp
index 38ab5e7,22106d7..a1292b7
--- 1/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderBuiltinPrecisionTests.cpp
--- 2/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderBuiltinPrecisionTests.cpp
+++ b/external/vulkancts/modules/vulkan/shaderexecutor/vktShaderBuiltinPrecisionTests.cpp
@@@ -1064,10 -1064,10 +1064,10 @@@ const ExprP<Void>& voidP (void
  template <typename T0 = Void, typename T1 = Void, typename T2 = Void, typename T3 = Void>
  struct Tuple4
  {
-       explicit Tuple4 (const T0& e0 = T0(),
-                                        const T1& e1 = T1(),
-                                        const T2& e2 = T2(),
-                                        const T3& e3 = T3())
+       explicit Tuple4 (const T0 e0 = T0(),
+                                        const T1 e1 = T1(),
+                                        const T2 e2 = T2(),
+                                        const T3 e3 = T3())
                : a     (e0)
                , b     (e1)
                , c     (e2)
@@@ -2431,7 -2431,7 +2431,7 @@@ protected
                        if (xi.contains(0.0))
                                ret |= TCU_NAN;
                        if (xi.intersects(Interval(-TCU_INFINITY, 0.0)))
 -                              ret |= Interval(-DE_PI_DOUBLE, DE_PI_DOUBLE);
 +                              ret |= ctx.format.roundOut(Interval(-DE_PI_DOUBLE, DE_PI_DOUBLE), true);
                }
  
                if (ctx.format.hasInf() != YES && (!yi.isFinite() || !xi.isFinite()))

diff --combined modules/egl/teglRenderCase.cpp
index a0ff8ae,300687c..4662487
--- 1/modules/egl/teglRenderCase.cpp
--- 2/modules/egl/teglRenderCase.cpp
+++ b/modules/egl/teglRenderCase.cpp
@@@ -158,7 -158,7 +158,7 @@@ void RenderCase::executeForConfig (EGLD
  
                try
                {
-                       std::auto_ptr<eglu::NativePixmap>       pixmap          (pixmapFactory.createPixmap(&nativeDisplay, display, config, DE_NULL, width, height));
+                       de::UniquePtr<eglu::NativePixmap>       pixmap          (pixmapFactory.createPixmap(&nativeDisplay, display, config, DE_NULL, width, height));
                        EGLSurface                                                      eglSurface      = createPixmapSurface(nativeDisplay, *pixmap, display, config, DE_NULL);
                        eglu::UniqueSurface                                     surface         (egl, display, eglSurface);
  
@@@ -397,11 -397,6 +397,11 @@@ static bool isConformant (const eglu::C
        return c.get(EGL_CONFIG_CAVEAT) != EGL_NON_CONFORMANT_CONFIG;
  }
  
 +static bool notFloat (const eglu::CandidateConfig& c)
 +{
 +      return c.colorComponentType() != EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT;
 +}
 +
  void getDefaultRenderFilterLists (vector<RenderFilterList>& filterLists, const eglu::FilterList& baseFilters)
  {
        static const struct
@@@ -455,8 -450,7 +455,8 @@@
                                << notColorBits<4, 4, 4, 4>
                                << notColorBits<5, 5, 5, 1>
                                << notColorBits<8, 8, 8, 8>
 -                              << isConformant;
 +                              << isConformant
 +                              << notFloat;
  
                filterLists.push_back(filters);
        }

diff --combined modules/gles2/functional/es2fIntegerStateQueryTests.cpp
index 2b736d7,4d44fc9..ed5831c
--- 1/modules/gles2/functional/es2fIntegerStateQueryTests.cpp
--- 2/modules/gles2/functional/es2fIntegerStateQueryTests.cpp
+++ b/modules/gles2/functional/es2fIntegerStateQueryTests.cpp
@@@ -589,9 -589,9 +589,9 @@@ void GetFloatVerifier::verifyUnsignedIn
        if (!state.verifyValidity(testCtx))
                return;
  
-       if (GLuint(state) < GLfloat(reference))
+       if (state < GLfloat(reference))
        {
-               testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << GLuint(state) << TestLog::EndMessage;
+               testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
                if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
                        testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
        }
@@@ -869,15 -869,7 +869,15 @@@ public
                de::Random rnd(0xabcdef);
  
                GLint maxViewportDimensions[2] = {0};
 +              GLfloat viewportBoundsRange[2] = {0.0f};
 +              GLboolean hasViewportArray = false;
                glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions);
 +              hasViewportArray = m_context.getContextInfo().isExtensionSupported("GL_OES_viewport_array") ||
 +                                                 m_context.getContextInfo().isExtensionSupported("GL_NV_viewport_array");
 +              if (hasViewportArray)
 +              {
 +                      glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, viewportBoundsRange);
 +              }
  
                // verify initial value of first two values
                m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
@@@ -892,19 -884,7 +892,19 @@@
                        GLsizei height  = rnd.getInt(0, maxViewportDimensions[1]);
  
                        glViewport(x, y, width, height);
 -                      m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
 +
 +                      if (hasViewportArray)
 +                      {
 +                              m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT,
 +                                                                                 de::clamp(x, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])),
 +                                                                                 de::clamp(y, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])),
 +                                                                                 width, height);
 +                      }
 +                      else
 +                      {
 +                              m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
 +                      }
 +
                        expectError(GL_NO_ERROR);
                }
        }

diff --combined modules/gles3/functional/es3fIntegerStateQueryTests.cpp
index 4837128,be9d4a0..16c11b4
--- 1/modules/gles3/functional/es3fIntegerStateQueryTests.cpp
--- 2/modules/gles3/functional/es3fIntegerStateQueryTests.cpp
+++ b/modules/gles3/functional/es3fIntegerStateQueryTests.cpp
@@@ -827,9 -827,9 +827,9 @@@ void GetFloatVerifier::verifyUnsignedIn
        if (!state.verifyValidity(testCtx))
                return;
  
-       if (GLuint(state) < GLfloat(reference))
+       if (state < GLfloat(reference))
        {
-               testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << GLuint(state) << TestLog::EndMessage;
+               testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
                if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
                        testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
        }
@@@ -1148,15 -1148,7 +1148,15 @@@ public
                de::Random rnd(0xabcdef);
  
                GLint maxViewportDimensions[2] = {0};
 +              GLfloat viewportBoundsRange[2] = {0.0f};
 +              GLboolean hasViewportArray = false;
                glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions);
 +              hasViewportArray = m_context.getContextInfo().isExtensionSupported("GL_OES_viewport_array") ||
 +                                                 m_context.getContextInfo().isExtensionSupported("GL_NV_viewport_array");
 +              if (hasViewportArray)
 +              {
 +                      glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, viewportBoundsRange);
 +              }
  
                // verify initial value of first two values
                m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
@@@ -1171,19 -1163,7 +1171,19 @@@
                        GLsizei height  = rnd.getInt(0, maxViewportDimensions[1]);
  
                        glViewport(x, y, width, height);
 -                      m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
 +
 +                      if (hasViewportArray)
 +                      {
 +                              m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT,
 +                                                                                 de::clamp(x, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])),
 +                                                                                 de::clamp(y, deFloorFloatToInt32(viewportBoundsRange[0]), deFloorFloatToInt32(viewportBoundsRange[1])),
 +                                                                                 width, height);
 +                      }
 +                      else
 +                      {
 +                              m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
 +                      }
 +
                        expectError(GL_NO_ERROR);
                }
        }

diff --combined modules/gles31/functional/es31fFboTestUtil.cpp
index f3388a4,b484e9f..4d8ade1
--- 1/modules/gles31/functional/es31fFboTestUtil.cpp
--- 2/modules/gles31/functional/es31fFboTestUtil.cpp
+++ b/modules/gles31/functional/es31fFboTestUtil.cpp
@@@ -68,10 -68,10 +68,10 @@@ static rr::GenericVecType mapDataTypeTo
  template <typename T>
  static tcu::Vector<T, 4> castVectorSaturate (const tcu::Vec4& in)
  {
-       return tcu::Vector<T, 4>((in.x() + 0.5f >= std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : ((in.x() - 0.5f <= std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.x()))),
-                                (in.y() + 0.5f >= std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : ((in.y() - 0.5f <= std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.y()))),
-                                                        (in.z() + 0.5f >= std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : ((in.z() - 0.5f <= std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.z()))),
-                                                        (in.w() + 0.5f >= std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : ((in.w() - 0.5f <= std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.w()))));
+       return tcu::Vector<T, 4>(((double)in.x() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.x() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.x()))),
+                                ((double)in.y() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.y() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.y()))),
+                                                        ((double)in.z() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.z() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.z()))),
+                                                        ((double)in.w() + 0.5 >= (double)std::numeric_limits<T>::max()) ? (std::numeric_limits<T>::max()) : (((double)in.w() - 0.5 <= (double)std::numeric_limits<T>::min()) ? (std::numeric_limits<T>::min()) : (T(in.w()))));
  }
  
  static string genTexFragmentShader (const vector<glu::DataType>& samplerTypes, glu::DataType outputType)
@@@ -262,7 -262,7 +262,7 @@@ void Texture2DShader::shadeFragments (r
        }
  }
  
 -TextureCubeArrayShader::TextureCubeArrayShader (glu::DataType samplerType, glu::DataType outputType)
 +TextureCubeArrayShader::TextureCubeArrayShader (glu::DataType samplerType, glu::DataType outputType, glu::GLSLVersion glslVersion)
        : sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
                                                        << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
                                                        << sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT)
@@@ -274,11 -274,8 +274,11 @@@
                                                        << sglr::pdec::Uniform("u_bias", glu::TYPE_FLOAT_VEC4)
                                                        << sglr::pdec::Uniform("u_layer", glu::TYPE_INT)
                                                        << sglr::pdec::VertexSource(
 +                                                                      string("") +
 +                                                                      ((glslVersion == glu::GLSL_VERSION_310_ES) ?
                                                                        "#version 310 es\n"
                                                                        "#extension GL_EXT_texture_cube_map_array : require\n"
 +                                                                       : "#version 320 es\n") +
                                                                        "in highp vec4 a_position;\n"
                                                                        "in mediump vec2 a_coord;\n"
                                                                        "uniform mat3 u_coordMat;\n"
@@@ -290,10 -287,8 +290,10 @@@
                                                                        "}\n")
                                                        << sglr::pdec::FragmentSource(
                                                                        string("") +
 +                                                                      ((glslVersion == glu::GLSL_VERSION_310_ES) ?
                                                                        "#version 310 es\n"
                                                                        "#extension GL_EXT_texture_cube_map_array : require\n"
 +                                                                       : "#version 320 es\n") +
                                                                        "uniform highp " + glu::getDataTypeName(samplerType) + " u_sampler0;\n"
                                                                        "uniform highp vec4 u_scale;\n"
                                                                        "uniform highp vec4 u_bias;\n"
@@@ -309,7 -304,6 +309,7 @@@
        , m_layer               (0)
        , m_outputType  (outputType)
  {
 +      TCU_CHECK_INTERNAL(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion == glu::GLSL_VERSION_320_ES);
  }
  
  void TextureCubeArrayShader::setLayer (int layer)

diff --combined modules/gles31/functional/es31fMultisampleTests.cpp
index 5fe3edf,c55a4a8..a4efbe4
--- 1/modules/gles31/functional/es31fMultisampleTests.cpp
--- 2/modules/gles31/functional/es31fMultisampleTests.cpp
+++ b/modules/gles31/functional/es31fMultisampleTests.cpp
@@@ -174,7 -174,6 +174,6 @@@ public
  
  protected:
        void                                            renderTriangle                          (const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec4& c0, const Vec4& c1, const Vec4& c2) const;
-       void                                            renderTriangle                          (const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec4& color) const;
        void                                            renderTriangle                          (const Vec2& p0, const Vec2& p1, const Vec2& p2, const Vec4& c0, const Vec4& c1, const Vec4& c2) const;
        void                                            renderTriangle                          (const Vec2& p0, const Vec2& p1, const Vec2& p2, const Vec4& color) const;
        void                                            renderQuad                                      (const Vec2& p0, const Vec2& p1, const Vec2& p2, const Vec2& p3, const Vec4& c0, const Vec4& c1, const Vec4& c2, const Vec4& c3) const;
@@@ -226,9 -225,9 +225,9 @@@ DefaultFBOMultisampleCase::~DefaultFBOM
  
  void DefaultFBOMultisampleCase::init (void)
  {
 -      const bool                                      isES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
 +      const bool                                      supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
        map<string, string>                     args;
 -      args["GLSL_VERSION_DECL"] = isES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 +      args["GLSL_VERSION_DECL"] = supportsES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
  
        static const char* vertShaderSource =
                "${GLSL_VERSION_DECL}\n"
@@@ -344,11 -343,6 +343,6 @@@ void DefaultFBOMultisampleCase::renderT
        GLU_EXPECT_NO_ERROR(gl.getError(), "drawArrays");
  }
  
- void DefaultFBOMultisampleCase::renderTriangle (const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec4& color) const
- {
-       renderTriangle(p0, p1, p2, color, color, color);
- }
- 
  void DefaultFBOMultisampleCase::renderTriangle (const Vec2& p0, const Vec2& p1, const Vec2& p2, const Vec4& c0, const Vec4& c1, const Vec4& c2) const
  {
        renderTriangle(Vec3(p0.x(), p0.y(), 0.0f),

diff --combined modules/gles31/functional/es31fProgramInterfaceQueryTests.cpp
index b47e951,95d1950..cfa8574
--- 1/modules/gles31/functional/es31fProgramInterfaceQueryTests.cpp
--- 2/modules/gles31/functional/es31fProgramInterfaceQueryTests.cpp
+++ b/modules/gles31/functional/es31fProgramInterfaceQueryTests.cpp
@@@ -26,7 -26,6 +26,7 @@@
  #include "es31fProgramInterfaceDefinition.hpp"
  #include "es31fProgramInterfaceDefinitionUtil.hpp"
  #include "tcuTestLog.hpp"
 +#include "tcuStringTemplate.hpp"
  #include "gluShaderProgram.hpp"
  #include "gluVarTypeUtil.hpp"
  #include "gluStrUtil.hpp"
@@@ -209,16 -208,6 +209,16 @@@ static glu::ShaderType getShaderMaskLas
        return glu::SHADERTYPE_LAST;
  }
  
 +static std::string specializeShader(Context& context, const char* code)
 +{
 +      const glu::GLSLVersion                          glslVersion                     = glu::getContextTypeGLSLVersion(context.getRenderContext().getType());
 +      std::map<std::string, std::string>      specializationMap;
 +
 +      specializationMap["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glslVersion);
 +
 +      return tcu::StringTemplate(code).specialize(specializationMap);
 +}
 +
  namespace ResourceDefinition
  {
  
@@@ -436,7 -425,6 +436,6 @@@ public
        bool            isStagePresent          (glu::ShaderType stage) const;
        bool            isStageReferencing      (glu::ShaderType stage) const;
  
-       deUint32        getPresentMask          (void) const;
        deUint32        getReferencingMask      (void) const;
  
        const glu::GLSLVersion  m_version;
@@@ -494,17 -482,6 +493,6 @@@ bool ShaderSet::isStageReferencing (glu
        return m_stageReferencing[stage];
  }
  
- deUint32 ShaderSet::getPresentMask (void) const
- {
-       deUint32 mask = 0;
-       for (deUint32 stage = 0; stage < glu::SHADERTYPE_LAST; ++stage)
-       {
-               if (m_stagePresent[stage])
-                       mask |= (1u << stage);
-       }
-       return mask;
- }
- 
  deUint32 ShaderSet::getReferencingMask (void) const
  {
        deUint32 mask = 0;
@@@ -933,21 -910,20 +921,21 @@@ ResourceListTestCase::~ResourceListTest
  
  void ResourceListTestCase::init (void)
  {
 -      m_programDefinition = generateProgramDefinitionFromResource(m_targetResource.get()).release();
 +      m_programDefinition     = generateProgramDefinitionFromResource(m_targetResource.get()).release();
 +      const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
  
        if ((m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_CONTROL) || m_programDefinition->hasStage(glu::SHADERTYPE_TESSELLATION_EVALUATION)) &&
 -              !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
 +              !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
        {
                throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension");
        }
        if (m_programDefinition->hasStage(glu::SHADERTYPE_GEOMETRY) &&
 -              !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 +              !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
        {
                throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension");
        }
        if (programContainsIOBlocks(m_programDefinition) &&
 -              !m_context.getContextInfo().isExtensionSupported("GL_EXT_shader_io_blocks"))
 +              !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_shader_io_blocks"))
        {
                throw tcu::NotSupportedError("Test requires GL_EXT_shader_io_blocks extension");
        }
@@@ -1038,13 -1014,7 +1026,13 @@@ bool ResourceListTestCase::verifyResour
        m_testCtx.getLog() << tcu::TestLog::Message << "GL returned resources:" << tcu::TestLog::EndMessage;
  
        for (int ndx = 0; ndx < (int)resourceList.size(); ++ndx)
 -              m_testCtx.getLog() << tcu::TestLog::Message << "\t" << ndx << ": " << resourceList[ndx] << tcu::TestLog::EndMessage;
 +      {
 +              // dummyZero is a uniform that may be added by
 +              // generateProgramInterfaceProgramSources.  Omit it here to avoid
 +              // confusion about the output.
 +              if (resourceList[ndx] != getDummyZeroUniformName())
 +                      m_testCtx.getLog() << tcu::TestLog::Message << "\t" << ndx << ": " << resourceList[ndx] << tcu::TestLog::EndMessage;
 +      }
  
        m_testCtx.getLog() << tcu::TestLog::Message << "Expected list of resources:" << tcu::TestLog::EndMessage;
  
@@@ -1066,11 -1036,8 +1054,11 @@@
        {
                if (!de::contains(expectedResources.begin(), expectedResources.end(), resourceList[ndx]))
                {
 -                      // Ignore all builtin variables, mismatch causes errors otherwise
 -                      if (deStringBeginsWith(resourceList[ndx].c_str(), "gl_") == DE_FALSE)
 +                      // Ignore all builtin variables or the variable dummyZero,
 +                      // mismatch causes errors otherwise.  dummyZero is a uniform that
 +                      // may be added by generateProgramInterfaceProgramSources.
 +                      if (deStringBeginsWith(resourceList[ndx].c_str(), "gl_") == DE_FALSE &&
 +                              resourceList[ndx] != getDummyZeroUniformName())
                        {
                                m_testCtx.getLog() << tcu::TestLog::Message << "Error, resource list contains unexpected resource name " << resourceList[ndx] << tcu::TestLog::EndMessage;
                                error = true;
@@@ -1450,7 -1417,7 +1438,7 @@@ ResourceNameBufferLimitCase::~ResourceN
  
  ResourceNameBufferLimitCase::IterateResult ResourceNameBufferLimitCase::iterate (void)
  {
 -      static const char* const computeSource =        "#version 310 es\n"
 +      static const char* const computeSource =        "${GLSL_VERSION_DECL}\n"
                                                                                                "layout(local_size_x = 1) in;\n"
                                                                                                "uniform highp int u_uniformWithALongName;\n"
                                                                                                "writeonly buffer OutputBufferBlock { highp int b_output_int; };\n"
@@@ -1460,7 -1427,7 +1448,7 @@@
                                                                                                "}\n";
  
        const glw::Functions&           gl                              = m_context.getRenderContext().getFunctions();
 -      const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(computeSource));
 +      const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, computeSource)));
        glw::GLuint                                     uniformIndex;
  
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
@@@ -1576,7 -1543,7 +1564,7 @@@ ResourceQueryBufferLimitCase::~Resource
  
  ResourceQueryBufferLimitCase::IterateResult ResourceQueryBufferLimitCase::iterate (void)
  {
 -      static const char* const computeSource =        "#version 310 es\n"
 +      static const char* const computeSource =        "${GLSL_VERSION_DECL}\n"
                                                                                                "layout(local_size_x = 1) in;\n"
                                                                                                "uniform highp int u_uniform;\n"
                                                                                                "writeonly buffer OutputBufferBlock { highp int b_output_int; };\n"
@@@ -1586,7 -1553,7 +1574,7 @@@
                                                                                                "}\n";
  
        const glw::Functions&           gl                              = m_context.getRenderContext().getFunctions();
 -      const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(computeSource));
 +      const glu::ShaderProgram        program                 (m_context.getRenderContext(), glu::ProgramSources() << glu::ComputeSource(specializeShader(m_context, computeSource)));
        glw::GLuint                                     uniformIndex;
  
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
@@@ -1701,11 -1668,10 +1689,11 @@@ InterfaceBlockBaseCase::~InterfaceBlock
  
  void InterfaceBlockBaseCase::init (void)
  {
 -      ProgramInterfaceDefinition::Shader* shader;
 +      const glu::GLSLVersion                          glslVersion     = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +      ProgramInterfaceDefinition::Shader*     shader;
  
        m_program = new ProgramInterfaceDefinition::Program();
 -      shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES);
 +      shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glslVersion);
  
        // PrecedingInterface
        {
@@@ -2182,10 -2148,9 +2170,10 @@@ AtomicCounterCase::~AtomicCounterCase (
  void AtomicCounterCase::init (void)
  {
        ProgramInterfaceDefinition::Shader* shader;
 +      glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
  
        m_program = new ProgramInterfaceDefinition::Program();
 -      shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES);
 +      shader = m_program->addShader(glu::SHADERTYPE_COMPUTE, glslVersion);
  
        {
                glu::VariableDeclaration decl(glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "binding1_counter1", glu::STORAGE_UNIFORM);
@@@ -2726,12 -2691,10 +2714,12 @@@ void AtomicCounterReferencedByCase::ini
        const deUint32                          geometryMask            = (1 << glu::SHADERTYPE_GEOMETRY);
        const deUint32                          tessellationMask        = (1 << glu::SHADERTYPE_TESSELLATION_CONTROL) | (1 << glu::SHADERTYPE_TESSELLATION_EVALUATION);
        glu::VariableDeclaration        atomicVar                       (glu::VarType(glu::TYPE_UINT_ATOMIC_COUNTER, glu::PRECISION_LAST), "targetCounter", glu::STORAGE_UNIFORM);
 +      const glu::GLSLVersion          glslVersion                     = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +      const bool                                      supportsES32            = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
  
 -      if ((m_presentStagesMask & tessellationMask) != 0 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
 +      if ((m_presentStagesMask & tessellationMask) != 0 && !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
                throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension");
 -      if ((m_presentStagesMask & geometryMask) != 0 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 +      if ((m_presentStagesMask & geometryMask) != 0 && !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
                throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension");
  
        atomicVar.layout.binding = 1;
@@@ -2742,9 -2705,9 +2730,9 @@@
        for (int shaderType = 0; shaderType < glu::SHADERTYPE_LAST; ++shaderType)
        {
                if (m_activeStagesMask & (1 << shaderType))
 -                      m_program->addShader((glu::ShaderType)shaderType, glu::GLSL_VERSION_310_ES)->getDefaultBlock().variables.push_back(atomicVar);
 +                      m_program->addShader((glu::ShaderType)shaderType, glslVersion)->getDefaultBlock().variables.push_back(atomicVar);
                else if (m_presentStagesMask & (1 << shaderType))
 -                      m_program->addShader((glu::ShaderType)shaderType, glu::GLSL_VERSION_310_ES);
 +                      m_program->addShader((glu::ShaderType)shaderType, glslVersion);
        }
  
        if (m_program->hasStage(glu::SHADERTYPE_GEOMETRY))
@@@ -2763,21 -2726,19 +2751,21 @@@ void AtomicCounterReferencedByCase::dei
  
  AtomicCounterReferencedByCase::IterateResult AtomicCounterReferencedByCase::iterate (void)
  {
 -      static const struct
 +      const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
 +
 +      const struct
        {
                glw::GLenum             propName;
                glu::ShaderType shaderType;
                const char*             extension;
        } targetProps[] =
        {
 -              { GL_REFERENCED_BY_VERTEX_SHADER,                       glu::SHADERTYPE_VERTEX,                                         DE_NULL                                                 },
 -              { GL_REFERENCED_BY_FRAGMENT_SHADER,                     glu::SHADERTYPE_FRAGMENT,                                       DE_NULL                                                 },
 -              { GL_REFERENCED_BY_COMPUTE_SHADER,                      glu::SHADERTYPE_COMPUTE,                                        DE_NULL                                                 },
 -              { GL_REFERENCED_BY_TESS_CONTROL_SHADER,         glu::SHADERTYPE_TESSELLATION_CONTROL,           "GL_EXT_tessellation_shader"    },
 -              { GL_REFERENCED_BY_TESS_EVALUATION_SHADER,      glu::SHADERTYPE_TESSELLATION_EVALUATION,        "GL_EXT_tessellation_shader"    },
 -              { GL_REFERENCED_BY_GEOMETRY_SHADER,                     glu::SHADERTYPE_GEOMETRY,                                       "GL_EXT_geometry_shader"                },
 +              { GL_REFERENCED_BY_VERTEX_SHADER,                       glu::SHADERTYPE_VERTEX,                                         DE_NULL                                                                                         },
 +              { GL_REFERENCED_BY_FRAGMENT_SHADER,                     glu::SHADERTYPE_FRAGMENT,                                       DE_NULL                                                                                         },
 +              { GL_REFERENCED_BY_COMPUTE_SHADER,                      glu::SHADERTYPE_COMPUTE,                                        DE_NULL                                                                                         },
 +              { GL_REFERENCED_BY_TESS_CONTROL_SHADER,         glu::SHADERTYPE_TESSELLATION_CONTROL,           (supportsES32 ? DE_NULL : "GL_EXT_tessellation_shader") },
 +              { GL_REFERENCED_BY_TESS_EVALUATION_SHADER,      glu::SHADERTYPE_TESSELLATION_EVALUATION,        (supportsES32 ? DE_NULL : "GL_EXT_tessellation_shader") },
 +              { GL_REFERENCED_BY_GEOMETRY_SHADER,                     glu::SHADERTYPE_GEOMETRY,                                       (supportsES32 ? DE_NULL : "GL_EXT_geometry_shader")             },
        };
  
        const glw::Functions&           gl                      = m_context.getRenderContext().getFunctions();
@@@ -2876,14 -2837,12 +2864,14 @@@ void ProgramInputOutputReferencedByCase
        const bool hasGeometryShader =          (m_caseType == CASE_VERTEX_GEO_FRAGMENT)                ||
                                                                                (m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)   ||
                                                                                (m_caseType == CASE_SEPARABLE_GEOMETRY);
 +      const bool supportsES32 =                       glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
  
 -      if (hasTessellationShader && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
 +      if (hasTessellationShader && !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader"))
                throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension");
 -      if (hasGeometryShader && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 +      if (hasGeometryShader && !supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
                throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension");
  
 +      glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
        m_program = new ProgramInterfaceDefinition::Program();
  
        if (m_caseType == CASE_SEPARABLE_VERTEX         ||
@@@ -2912,11 -2871,11 +2900,11 @@@
                if (arrayedInterface && !perPatchStorage)
                {
                        const glu::VariableDeclaration targetDeclArr(glu::VarType(targetDecl.varType, glu::VarType::UNSIZED_ARRAY), varName, m_targetStorage);
 -                      m_program->addShader(shaderType, glu::GLSL_VERSION_310_ES)->getDefaultBlock().variables.push_back(targetDeclArr);
 +                      m_program->addShader(shaderType, glslVersion)->getDefaultBlock().variables.push_back(targetDeclArr);
                }
                else
                {
 -                      m_program->addShader(shaderType, glu::GLSL_VERSION_310_ES)->getDefaultBlock().variables.push_back(targetDecl);
 +                      m_program->addShader(shaderType, glslVersion)->getDefaultBlock().variables.push_back(targetDecl);
                }
        }
        else if (m_caseType == CASE_VERTEX_FRAGMENT                     ||
@@@ -2924,8 -2883,8 +2912,8 @@@
                         m_caseType == CASE_VERTEX_TESS_FRAGMENT        ||
                         m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)
        {
 -              ProgramInterfaceDefinition::Shader*     vertex          = m_program->addShader(glu::SHADERTYPE_VERTEX, glu::GLSL_VERSION_310_ES);
 -              ProgramInterfaceDefinition::Shader*     fragment        = m_program->addShader(glu::SHADERTYPE_FRAGMENT, glu::GLSL_VERSION_310_ES);
 +              ProgramInterfaceDefinition::Shader*     vertex          = m_program->addShader(glu::SHADERTYPE_VERTEX, glslVersion);
 +              ProgramInterfaceDefinition::Shader*     fragment        = m_program->addShader(glu::SHADERTYPE_FRAGMENT, glslVersion);
  
                m_program->setSeparable(false);
  
@@@ -2951,8 -2910,8 +2939,8 @@@
  
                if (m_caseType == CASE_VERTEX_TESS_FRAGMENT || m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)
                {
 -                      ProgramInterfaceDefinition::Shader* tessCtrl = m_program->addShader(glu::SHADERTYPE_TESSELLATION_CONTROL, glu::GLSL_VERSION_310_ES);
 -                      ProgramInterfaceDefinition::Shader* tessEval = m_program->addShader(glu::SHADERTYPE_TESSELLATION_EVALUATION, glu::GLSL_VERSION_310_ES);
 +                      ProgramInterfaceDefinition::Shader* tessCtrl = m_program->addShader(glu::SHADERTYPE_TESSELLATION_CONTROL, glslVersion);
 +                      ProgramInterfaceDefinition::Shader* tessEval = m_program->addShader(glu::SHADERTYPE_TESSELLATION_EVALUATION, glslVersion);
  
                        tessCtrl->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
                                                                                                                                                                         "shaderInput",
@@@ -2979,7 -2938,7 +2967,7 @@@
  
                if (m_caseType == CASE_VERTEX_GEO_FRAGMENT || m_caseType == CASE_VERTEX_TESS_GEO_FRAGMENT)
                {
 -                      ProgramInterfaceDefinition::Shader* geometry = m_program->addShader(glu::SHADERTYPE_GEOMETRY, glu::GLSL_VERSION_310_ES);
 +                      ProgramInterfaceDefinition::Shader* geometry = m_program->addShader(glu::SHADERTYPE_GEOMETRY, glslVersion);
  
                        geometry->getDefaultBlock().variables.push_back(glu::VariableDeclaration(glu::VarType(glu::VarType(glu::TYPE_FLOAT_VEC4, glu::PRECISION_HIGHP), glu::VarType::UNSIZED_ARRAY),
                                                                                                                                                                         "shaderInput",
@@@ -3622,10 -3581,10 +3610,10 @@@ static void generateUniformBlockLocatio
                generateVariableCases(context, parentStructure, targetGroup, queryTarget, 1, false);
  }
  
 -static void generateUniformBlockBlockIndexContents (Context& context, tcu::TestCaseGroup* const targetGroup)
 +static void generateUniformBlockBlockIndexContents (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
  {
        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       uniform                 (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_UNIFORM));
        const ResourceDefinition::Node::SharedPtr       binding                 (new ResourceDefinition::LayoutQualifier(uniform, glu::Layout(-1, 0)));
@@@ -4229,7 -4188,7 +4217,7 @@@ static void generateUniformReferencedBy
        }
  }
  
 -static void generateReferencedByShaderCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, void (*generateBlockContent)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, int expandLevel))
 +static void generateReferencedByShaderCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, void (*generateBlockContent)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, int expandLevel))
  {
        static const struct
        {
@@@ -4284,7 -4243,7 +4272,7 @@@
                TestCaseGroup* const                                            blockGroup                      = new TestCaseGroup(context, singleStageCases[ndx].name, "");
                const bool                                                                      programSeparable        = (singleStageCases[ndx].stage != glu::SHADERTYPE_COMPUTE);
                const ResourceDefinition::Node::SharedPtr       program                         (new ResourceDefinition::Program(programSeparable));
 -              const ResourceDefinition::Node::SharedPtr       stage                           (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glu::GLSL_VERSION_310_ES));
 +              const ResourceDefinition::Node::SharedPtr       stage                           (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glslVersion));
  
                targetGroup->addChild(blockGroup);
  
@@@ -4298,7 -4257,7 +4286,7 @@@
                        TestCaseGroup* const                                            blockGroup                      = new TestCaseGroup(context, pipelines[pipelineNdx].name, "");
                        const ResourceDefinition::Node::SharedPtr       program                         (new ResourceDefinition::Program());
                        ResourceDefinition::ShaderSet*                          shaderSet                       = new ResourceDefinition::ShaderSet(program,
 -                                                                                                                                                                                                                              glu::GLSL_VERSION_310_ES,
 +                                                                                                                                                                                                                              glslVersion,
                                                                                                                                                                                                                                pipelines[pipelineNdx].flags,
                                                                                                                                                                                                                                pipelines[pipelineNdx].flags);
                        targetGroup->addChild(blockGroup);
@@@ -4316,7 -4275,7 +4304,7 @@@
                        {
                                const ResourceDefinition::Node::SharedPtr       program         (new ResourceDefinition::Program());
                                ResourceDefinition::ShaderSet*                          shaderSet       = new ResourceDefinition::ShaderSet(program,
 -                                                                                                                                                                                                                      glu::GLSL_VERSION_310_ES,
 +                                                                                                                                                                                                                      glslVersion,
                                                                                                                                                                                                                        pipelines[pipelineNdx].flags,
                                                                                                                                                                                                                        (1u << selectedStageBit));
                                const char*                                                                     stageName       = (selectedStageBit == glu::SHADERTYPE_VERTEX)                                  ? ("vertex")
@@@ -4435,19 -4394,19 +4423,19 @@@ static ResourceDefinition::Node::Shared
        return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Variable(currentStructure, baseType));
  }
  
 -static ResourceDefinition::Node::SharedPtr generateRandomCoreShaderSet (de::Random& rnd)
 +static ResourceDefinition::Node::SharedPtr generateRandomCoreShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion)
  {
        if (rnd.getFloat() < 0.5f)
        {
                // compute only
                const ResourceDefinition::Node::SharedPtr program(new ResourceDefinition::Program());
 -              return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +              return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        }
        else if (rnd.getFloat() < 0.5f)
        {
                // vertex and fragment
                const ResourceDefinition::Node::SharedPtr       program         (new ResourceDefinition::Program());
 -              ResourceDefinition::ShaderSet*                          shaderSet       = new ResourceDefinition::ShaderSet(program, glu::GLSL_VERSION_310_ES);
 +              ResourceDefinition::ShaderSet*                          shaderSet       = new ResourceDefinition::ShaderSet(program, glslVersion);
  
                if (rnd.getBool())
                {
@@@ -4468,17 -4427,17 +4456,17 @@@
                const ResourceDefinition::Node::SharedPtr       program         (new ResourceDefinition::Program(true));
                const glu::ShaderType                                           shaderType      = (rnd.getBool()) ? (glu::SHADERTYPE_VERTEX) : (glu::SHADERTYPE_FRAGMENT);
  
 -              return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glu::GLSL_VERSION_310_ES));
 +              return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glslVersion));
        }
  }
  
 -static ResourceDefinition::Node::SharedPtr generateRandomExtShaderSet (de::Random& rnd)
 +static ResourceDefinition::Node::SharedPtr generateRandomExtShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion)
  {
        if (rnd.getFloat() < 0.5f)
        {
                // whole pipeline
                const ResourceDefinition::Node::SharedPtr       program         (new ResourceDefinition::Program());
 -              ResourceDefinition::ShaderSet*                          shaderSet       = new ResourceDefinition::ShaderSet(program, glu::GLSL_VERSION_310_ES);
 +              ResourceDefinition::ShaderSet*                          shaderSet       = new ResourceDefinition::ShaderSet(program, glslVersion);
  
                shaderSet->setStage(glu::SHADERTYPE_VERTEX, rnd.getBool());
                shaderSet->setStage(glu::SHADERTYPE_FRAGMENT, rnd.getBool());
@@@ -4523,16 -4482,16 +4511,16 @@@
                                                                                                                                : (selector == 2) ? (glu::SHADERTYPE_TESSELLATION_EVALUATION)
                                                                                                                                :                                       (glu::SHADERTYPE_LAST);
  
 -              return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glu::GLSL_VERSION_310_ES));
 +              return ResourceDefinition::Node::SharedPtr(new ResourceDefinition::Shader(program, shaderType, glslVersion));
        }
  }
  
 -static ResourceDefinition::Node::SharedPtr generateRandomShaderSet (de::Random& rnd, bool onlyExtensionStages)
 +static ResourceDefinition::Node::SharedPtr generateRandomShaderSet (de::Random& rnd, glu::GLSLVersion glslVersion, bool onlyExtensionStages)
  {
        if (!onlyExtensionStages)
 -              return generateRandomCoreShaderSet(rnd);
 +              return generateRandomCoreShaderSet(rnd, glslVersion);
        else
 -              return generateRandomExtShaderSet(rnd);
 +              return generateRandomExtShaderSet(rnd, glslVersion);
  }
  
  static glu::Layout generateRandomUniformBlockLayout (de::Random& rnd)
@@@ -4569,10 -4528,10 +4557,10 @@@ static glu::Layout generateRandomVariab
        return layout;
  }
  
 -static void generateUniformRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, int index, bool onlyExtensionStages)
 +static void generateUniformRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, int index, bool onlyExtensionStages)
  {
        de::Random                                                                      rnd                                     (index * 0x12345);
 -      const ResourceDefinition::Node::SharedPtr       shader                          = generateRandomShaderSet(rnd, onlyExtensionStages);
 +      const ResourceDefinition::Node::SharedPtr       shader                          = generateRandomShaderSet(rnd, glslVersion, onlyExtensionStages);
        const bool                                                                      interfaceBlock          = rnd.getBool();
        const glu::DataType                                                     type                            = generateRandomDataType(rnd, interfaceBlock);
        const glu::Layout                                                       layout                          = generateRandomVariableLayout(rnd, type, interfaceBlock);
@@@ -4598,15 -4557,15 +4586,15 @@@
        targetGroup->addChild(new ResourceTestCase(context, currentStructure, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_UNIFORM, PROGRAMRESOURCEPROP_UNIFORM_INTERFACE_MASK), de::toString(index).c_str()));
  }
  
 -static void generateUniformCaseRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup)
 +static void generateUniformCaseRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
  {
        const int numBasicCases         = 40;
        const int numTessGeoCases       = 40;
  
        for (int ndx = 0; ndx < numBasicCases; ++ndx)
 -              generateUniformRandomCase(context, targetGroup, ndx, false);
 +              generateUniformRandomCase(context, targetGroup, glslVersion, ndx, false);
        for (int ndx = 0; ndx < numTessGeoCases; ++ndx)
 -              generateUniformRandomCase(context, targetGroup, numBasicCases + ndx, true);
 +              generateUniformRandomCase(context, targetGroup, glslVersion, numBasicCases + ndx, true);
  }
  
  class UniformInterfaceTestGroup : public TestCaseGroup
@@@ -4623,9 -4582,8 +4611,9 @@@ UniformInterfaceTestGroup::UniformInter
  
  void UniformInterfaceTestGroup::init (void)
  {
 +      glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       computeShader   (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       computeShader   (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
  
        // .resource_list
        {
@@@ -4659,7 -4617,7 +4647,7 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "block_index", "Query block index");
                addChild(blockGroup);
 -              generateUniformBlockBlockIndexContents(m_context, blockGroup);
 +              generateUniformBlockBlockIndexContents(m_context, blockGroup, glslVersion);
        }
  
        // .location
@@@ -4701,7 -4659,7 +4689,7 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "referenced_by_shader", "Query referenced by shader");
                addChild(blockGroup);
 -              generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateUniformReferencedByShaderSingleBlockContentCases);
 +              generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateUniformReferencedByShaderSingleBlockContentCases);
        }
  
        // .type
@@@ -4715,7 -4673,7 +4703,7 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "random", "Random");
                addChild(blockGroup);
 -              generateUniformCaseRandomCases(m_context, blockGroup);
 +              generateUniformCaseRandomCases(m_context, blockGroup, glslVersion);
        }
  }
  
@@@ -4729,10 -4687,10 +4717,10 @@@ static void generateBufferBackedInterfa
        targetGroup->addChild(new ResourceTestCase(context, targetResource, ProgramResourceQueryTestTarget(interface, PROGRAMRESOURCEPROP_NAME_LENGTH), blockName));
  }
  
 -static void generateBufferBackedInterfaceResourceBasicBlockTypes (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, ProgramInterface interface, const char* blockName))
 +static void generateBufferBackedInterfaceResourceBasicBlockTypes (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, glu::Storage storage, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup* const, ProgramInterface interface, const char* blockName))
  {
        const ResourceDefinition::Node::SharedPtr       program                         (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock            (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       storageQualifier        (new ResourceDefinition::StorageQualifier(defaultBlock, storage));
        const ResourceDefinition::Node::SharedPtr       binding                         (new ResourceDefinition::LayoutQualifier(storageQualifier, glu::Layout(-1, 1)));
@@@ -4773,10 -4731,10 +4761,10 @@@
        }
  }
  
 -static void generateBufferBackedInterfaceResourceBufferBindingCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::Storage storage)
 +static void generateBufferBackedInterfaceResourceBufferBindingCases (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, glu::Storage storage)
  {
        const ResourceDefinition::Node::SharedPtr       program                         (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock            (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       storageQualifier        (new ResourceDefinition::StorageQualifier(defaultBlock, storage));
  
@@@ -4890,13 -4848,11 +4878,13 @@@ BufferBackedBlockInterfaceTestGroup::Bu
  
  void BufferBackedBlockInterfaceTestGroup::init (void)
  {
 +      const glu::GLSLVersion  glslVersion     = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +
        // .resource_list
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
                addChild(blockGroup);
 -              generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, m_storage, generateBufferBackedInterfaceResourceListCase);
 +              generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, glslVersion, m_storage, generateBufferBackedInterfaceResourceListCase);
        }
  
        // .active_variables
@@@ -4910,7 -4866,7 +4898,7 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "buffer_binding", "Buffer binding");
                addChild(blockGroup);
 -              generateBufferBackedInterfaceResourceBufferBindingCases(m_context, blockGroup, m_storage);
 +              generateBufferBackedInterfaceResourceBufferBindingCases(m_context, blockGroup, glslVersion, m_storage);
        }
  
        // .buffer_data_size
@@@ -4924,7 -4880,7 +4912,7 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length");
                addChild(blockGroup);
 -              generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, m_storage, generateBufferBackedInterfaceNameLengthCase);
 +              generateBufferBackedInterfaceResourceBasicBlockTypes(m_context, blockGroup, glslVersion, m_storage, generateBufferBackedInterfaceNameLengthCase);
        }
  
        // .referenced_by
@@@ -4933,9 -4889,9 +4921,9 @@@
                addChild(blockGroup);
  
                if (m_storage == glu::STORAGE_UNIFORM)
 -                      generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_UNIFORM>);
 +                      generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_UNIFORM>);
                else if (m_storage == glu::STORAGE_BUFFER)
 -                      generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_BUFFER>);
 +                      generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferBlockReferencedByShaderSingleBlockContentCases<glu::STORAGE_BUFFER>);
                else
                        DE_ASSERT(false);
        }
@@@ -5048,7 -5004,7 +5036,7 @@@ void AtomicCounterTestGroup::init (void
        }
  }
  
 -static void generateProgramInputOutputShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, bool withCompute, bool inputCase, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, deUint32))
 +static void generateProgramInputOutputShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, bool withCompute, bool inputCase, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, deUint32))
  {
        static const struct
        {
@@@ -5067,7 -5023,7 +5055,7 @@@
        {
                tcu::TestCaseGroup* const                                       blockGroup              = new TestCaseGroup(context, "vertex_fragment", "Vertex and fragment");
                const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program(false));
 -              ResourceDefinition::ShaderSet*                          shaderSetPtr    = new ResourceDefinition::ShaderSet(program, glu::GLSL_VERSION_310_ES);
 +              ResourceDefinition::ShaderSet*                          shaderSetPtr    = new ResourceDefinition::ShaderSet(program, glslVersion);
                const ResourceDefinition::Node::SharedPtr       shaderSet               (shaderSetPtr);
                const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shaderSet));
  
@@@ -5084,7 -5040,7 +5072,7 @@@
        {
                TestCaseGroup* const                                            blockGroup                      = new TestCaseGroup(context, singleStageCases[ndx].name, "");
                const ResourceDefinition::Node::SharedPtr       program                         (new ResourceDefinition::Program(true));
 -              const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glu::GLSL_VERSION_310_ES));
 +              const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glslVersion));
                const ResourceDefinition::Node::SharedPtr       defaultBlock            (new ResourceDefinition::DefaultBlock(shader));
  
                targetGroup->addChild(blockGroup);
@@@ -5096,7 -5052,7 +5084,7 @@@
        {
                tcu::TestCaseGroup* const                                       blockGroup              = new TestCaseGroup(context, "compute", "Compute");
                const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program(true));
 -              const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +              const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
                const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
  
                targetGroup->addChild(blockGroup);
@@@ -5147,7 -5103,7 +5135,7 @@@
                        const glu::Storage                                                      storageType             = (inputCase) ? (ioBlockTypes[ndx].inputStorage) : (ioBlockTypes[ndx].outputStorage);
                        tcu::TestCaseGroup* const                                       ioBlockGroup    = new TestCaseGroup(context, name, "");
                        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program(true));
 -                      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, shaderType, glu::GLSL_VERSION_310_ES));
 +                      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, shaderType, glslVersion));
                        const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
                        const ResourceDefinition::Node::SharedPtr       storage                 (new ResourceDefinition::StorageQualifier(defaultBlock, storageType));
  
@@@ -6015,34 -5971,32 +6003,34 @@@ ProgramInputTestGroup::ProgramInputTest
  
  void ProgramInputTestGroup::init (void)
  {
 +      const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +
        // .resource_list
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, true, true, generateProgramInputResourceListBlockContents);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, true, true, generateProgramInputResourceListBlockContents);
        }
  
        // .array_size
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Array size");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
        }
  
        // .location
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Location");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputLocationBlockContents);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, generateProgramInputLocationBlockContents);
        }
  
        // .name_length
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
        }
  
        // .referenced_by
@@@ -6056,14 -6010,14 +6044,14 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Type");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputTypeBlockContents);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, generateProgramInputTypeBlockContents);
        }
  
        // .is_per_patch
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "is_per_patch", "Is per patch");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, true, generateProgramInputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>);
        }
  }
  
@@@ -6081,34 -6035,32 +6069,34 @@@ ProgramOutputTestGroup::ProgramOutputTe
  
  void ProgramOutputTestGroup::init (void)
  {
 +      const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +
        // .resource_list
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "resource_list", "Resource list");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, true, false, generateProgramOutputResourceListBlockContents);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, true, false, generateProgramOutputResourceListBlockContents);
        }
  
        // .array_size
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "array_size", "Array size");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
        }
  
        // .location
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "location", "Location");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputLocationBlockContents);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, generateProgramOutputLocationBlockContents);
        }
  
        // .name_length
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "name_length", "Name length");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
        }
  
        // .referenced_by
@@@ -6122,18 -6074,18 +6110,18 @@@
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "type", "Type");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputTypeBlockContents);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, generateProgramOutputTypeBlockContents);
        }
  
        // .is_per_patch
        {
                tcu::TestCaseGroup* const blockGroup = new tcu::TestCaseGroup(m_testCtx, "is_per_patch", "Is per patch");
                addChild(blockGroup);
 -              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>);
 +              generateProgramInputOutputShaderCaseBlocks(m_context, blockGroup, glslVersion, false, false, generateProgramOutputBasicBlockContents<PROGRAMRESOURCEPROP_IS_PER_PATCH>);
        }
  }
  
 -static void generateTransformFeedbackShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
 +static void generateTransformFeedbackShaderCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
  {
        static const struct
        {
@@@ -6186,7 -6138,7 +6174,7 @@@
                TestCaseGroup* const                                            blockGroup              = new TestCaseGroup(context, pipelines[pipelineNdx].name, "");
                const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
                const ResourceDefinition::Node::SharedPtr       shaderSet               (new ResourceDefinition::ShaderSet(program,
 -                                                                                                                                                                                                         glu::GLSL_VERSION_310_ES,
 +                                                                                                                                                                                                         glslVersion,
                                                                                                                                                                                                           pipelines[pipelineNdx].stageBits,
                                                                                                                                                                                                           pipelines[pipelineNdx].lastStageBit));
  
@@@ -6199,7 -6151,7 +6187,7 @@@
        {
                TestCaseGroup* const                                            blockGroup                      = new TestCaseGroup(context, singleStageCases[ndx].name, "");
                const ResourceDefinition::Node::SharedPtr       program                         (new ResourceDefinition::Program(true));
 -              const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glu::GLSL_VERSION_310_ES));
 +              const ResourceDefinition::Node::SharedPtr       shader                          (new ResourceDefinition::Shader(program, singleStageCases[ndx].stage, glslVersion));
  
                targetGroup->addChild(blockGroup);
                blockContentGenerator(context, shader, blockGroup, singleStageCases[ndx].reducedSet);
@@@ -6395,41 -6347,39 +6383,41 @@@ TransformFeedbackVaryingTestGroup::Tran
  
  void TransformFeedbackVaryingTestGroup::init (void)
  {
 +      const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +
        // .resource_list
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "resource_list", "Resource list");
                addChild(blockGroup);
 -              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackResourceListBlockContents);
 +              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackResourceListBlockContents);
        }
  
        // .array_size
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_size", "Array size");
                addChild(blockGroup);
 -              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
 +              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
        }
  
        // .name_length
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "name_length", "Name length");
                addChild(blockGroup);
 -              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
 +              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackVariableBlockContents<PROGRAMRESOURCEPROP_NAME_LENGTH>);
        }
  
        // .type
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "type", "Type");
                addChild(blockGroup);
 -              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, generateTransformFeedbackVariableTypeBlockContents);
 +              generateTransformFeedbackShaderCaseBlocks(m_context, blockGroup, glslVersion, generateTransformFeedbackVariableTypeBlockContents);
        }
  }
  
 -static void generateBufferVariableBufferCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*))
 +static void generateBufferVariableBufferCaseBlocks (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*))
  {
        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       bufferStorage   (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
        const ResourceDefinition::Node::SharedPtr       binding                 (new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0)));
@@@ -6544,10 -6494,10 +6532,10 @@@ static void generateBufferVariableArray
        }
  }
  
 -static void generateBufferVariableBlockIndexCases (Context& context, tcu::TestCaseGroup* const targetGroup)
 +static void generateBufferVariableBlockIndexCases (Context& context, glu::GLSLVersion glslVersion, tcu::TestCaseGroup* const targetGroup)
  {
        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       bufferStorage   (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
        const ResourceDefinition::Node::SharedPtr       binding                 (new ResourceDefinition::LayoutQualifier(bufferStorage, glu::Layout(-1, 0)));
@@@ -6578,7 -6528,7 +6566,7 @@@
        }
  }
  
 -static void generateBufferVariableMatrixCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
 +static void generateBufferVariableMatrixCaseBlocks (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, void (*blockContentGenerator)(Context&, const ResourceDefinition::Node::SharedPtr&, tcu::TestCaseGroup*, bool))
  {
        static const struct
        {
@@@ -6598,7 -6548,7 +6586,7 @@@
        };
  
        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       buffer                  (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
  
@@@ -6880,10 -6830,10 +6868,10 @@@ static void generateBufferVariableTypeC
        }
  }
  
 -static void generateBufferVariableTypeBlock (Context& context, tcu::TestCaseGroup* targetGroup)
 +static void generateBufferVariableTypeBlock (Context& context, tcu::TestCaseGroup* targetGroup, glu::GLSLVersion glslVersion)
  {
        const ResourceDefinition::Node::SharedPtr       program                 (new ResourceDefinition::Program());
 -      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glu::GLSL_VERSION_310_ES));
 +      const ResourceDefinition::Node::SharedPtr       shader                  (new ResourceDefinition::Shader(program, glu::SHADERTYPE_COMPUTE, glslVersion));
        const ResourceDefinition::Node::SharedPtr       defaultBlock    (new ResourceDefinition::DefaultBlock(shader));
        const ResourceDefinition::Node::SharedPtr       buffer                  (new ResourceDefinition::StorageQualifier(defaultBlock, glu::STORAGE_BUFFER));
        const ResourceDefinition::Node::SharedPtr       block                   (new ResourceDefinition::InterfaceBlock(buffer, true));
@@@ -6891,10 -6841,10 +6879,10 @@@
        generateBufferVariableTypeCases(context, block, targetGroup);
  }
  
 -static void generateBufferVariableRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, int index, bool onlyExtensionStages)
 +static void generateBufferVariableRandomCase (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion, int index, bool onlyExtensionStages)
  {
        de::Random                                                                      rnd                                     (index * 0x12345);
 -      const ResourceDefinition::Node::SharedPtr       shader                          = generateRandomShaderSet(rnd, onlyExtensionStages);
 +      const ResourceDefinition::Node::SharedPtr       shader                          = generateRandomShaderSet(rnd, glslVersion, onlyExtensionStages);
        const glu::DataType                                                     type                            = generateRandomDataType(rnd, true);
        const glu::Layout                                                       layout                          = generateRandomVariableLayout(rnd, type, true);
        const bool                                                                      namedBlock                      = rnd.getBool();
@@@ -6912,15 -6862,15 +6900,15 @@@
        targetGroup->addChild(new ResourceTestCase(context, currentStructure, ProgramResourceQueryTestTarget(PROGRAMINTERFACE_BUFFER_VARIABLE, PROGRAMRESOURCEPROP_BUFFER_VARIABLE_MASK), de::toString(index).c_str()));
  }
  
 -static void generateBufferVariableRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup)
 +static void generateBufferVariableRandomCases (Context& context, tcu::TestCaseGroup* const targetGroup, glu::GLSLVersion glslVersion)
  {
        const int numBasicCases         = 40;
        const int numTessGeoCases       = 40;
  
        for (int ndx = 0; ndx < numBasicCases; ++ndx)
 -              generateBufferVariableRandomCase(context, targetGroup, ndx, false);
 +              generateBufferVariableRandomCase(context, targetGroup, glslVersion, ndx, false);
        for (int ndx = 0; ndx < numTessGeoCases; ++ndx)
 -              generateBufferVariableRandomCase(context, targetGroup, numBasicCases + ndx, true);
 +              generateBufferVariableRandomCase(context, targetGroup, glslVersion, numBasicCases + ndx, true);
  }
  
  class BufferVariableTestGroup : public TestCaseGroup
@@@ -6937,97 -6887,95 +6925,97 @@@ BufferVariableTestGroup::BufferVariable
  
  void BufferVariableTestGroup::init (void)
  {
 +      const glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType());
 +
        // .resource_list
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "resource_list", "Resource list");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableResourceListBlockContentsProxy);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableResourceListBlockContentsProxy);
        }
  
        // .array_size
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_size", "Array size");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_SIZE>);
        }
  
        // .array_stride
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "array_stride", "Array stride");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_STRIDE>);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableArrayCases<PROGRAMRESOURCEPROP_ARRAY_STRIDE>);
        }
  
        // .block_index
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "block_index", "Block index");
                addChild(blockGroup);
 -              generateBufferVariableBlockIndexCases(m_context, blockGroup);
 +              generateBufferVariableBlockIndexCases(m_context, glslVersion, blockGroup);
        }
  
        // .is_row_major
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "is_row_major", "Is row major");
                addChild(blockGroup);
 -              generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR>);
 +              generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_ROW_MAJOR>);
        }
  
        // .matrix_stride
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "matrix_stride", "Matrix stride");
                addChild(blockGroup);
 -              generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_STRIDE>);
 +              generateBufferVariableMatrixCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableMatrixCases<PROGRAMRESOURCEPROP_MATRIX_STRIDE>);
        }
  
        // .name_length
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "name_length", "Name length");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableNameLengthCases);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableNameLengthCases);
        }
  
        // .offset
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "offset", "Offset");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableOffsetCases);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableOffsetCases);
        }
  
        // .referenced_by
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "referenced_by", "Referenced by");
                addChild(blockGroup);
 -              generateReferencedByShaderCaseBlocks(m_context, blockGroup, generateBufferVariableReferencedByBlockContents);
 +              generateReferencedByShaderCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableReferencedByBlockContents);
        }
  
        // .top_level_array_size
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "top_level_array_size", "Top-level array size");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_SIZE>);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_SIZE>);
        }
  
        // .top_level_array_stride
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "top_level_array_stride", "Top-level array stride");
                addChild(blockGroup);
 -              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_STRIDE>);
 +              generateBufferVariableBufferCaseBlocks(m_context, blockGroup, glslVersion, generateBufferVariableTopLevelCases<PROGRAMRESOURCEPROP_TOP_LEVEL_ARRAY_STRIDE>);
        }
  
        // .type
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "type", "Type");
                addChild(blockGroup);
 -              generateBufferVariableTypeBlock(m_context, blockGroup);
 +              generateBufferVariableTypeBlock(m_context, blockGroup, glslVersion);
        }
  
        // .random
        {
                tcu::TestCaseGroup* const blockGroup = new TestCaseGroup(m_context, "random", "Random");
                addChild(blockGroup);
 -              generateBufferVariableRandomCases(m_context, blockGroup);
 +              generateBufferVariableRandomCases(m_context, blockGroup, glslVersion);
        }
  }