kc3-lang/angle/src/tests/gl_tests/GLSLTest.cpp

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Geoff Lang
  Date : 2015-06-09 15:16:31
  Hash : dd323e95
  Message : Only run tests that the current hardware can support. For each config, determine if a context can be created at test instantiation time. This allows skipping of ES3 tests when the hardware does not support ES3. Updated the perf_tests to use the EGLPlatformParameters struct so that they can be filtered in the same way. Change-Id: If664604b057cec4005eb4b63bebd83cd4964b7b2 Reviewed-on: https://chromium-review.googlesource.com/276460 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Tested-by: Geoff Lang <geofflang@chromium.org>

• src/tests/gl_tests/GLSLTest.cpp

• //
  // Copyright 2015 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "test_utils/ANGLETest.h"
  
  #include "libANGLE/Context.h"
  #include "libANGLE/Program.h"
  
  using namespace angle;
  
  class GLSLTest : public ANGLETest
  {
    protected:
      GLSLTest()
      {
          setWindowWidth(128);
          setWindowHeight(128);
          setConfigRedBits(8);
          setConfigGreenBits(8);
          setConfigBlueBits(8);
          setConfigAlphaBits(8);
      }
  
      virtual void SetUp()
      {
          ANGLETest::SetUp();
  
          mSimpleVSSource = SHADER_SOURCE
          (
              attribute vec4 inputAttribute;
              void main()
              {
                  gl_Position = inputAttribute;
              }
          );
      }
  
      std::string GenerateVaryingType(GLint vectorSize)
      {
          char varyingType[10];
  
          if (vectorSize == 1)
          {
              sprintf(varyingType, "float");
          }
          else
          {
              sprintf(varyingType, "vec%d", vectorSize);
          }
  
          return std::string(varyingType);
      }
  
      std::string GenerateVectorVaryingDeclaration(GLint vectorSize, GLint arraySize, GLint id)
      {
          char buff[100];
  
          if (arraySize == 1)
          {
              sprintf(buff, "varying %s v%d;\n", GenerateVaryingType(vectorSize).c_str(), id);
          }
          else
          {
              sprintf(buff, "varying %s v%d[%d];\n", GenerateVaryingType(vectorSize).c_str(), id, arraySize);
          }
  
          return std::string(buff);
      }
  
      std::string GenerateVectorVaryingSettingCode(GLint vectorSize, GLint arraySize, GLint id)
      {
          std::string returnString;
          char buff[100];
  
          if (arraySize == 1)
          {
              sprintf(buff, "\t v%d = %s(1.0);\n", id, GenerateVaryingType(vectorSize).c_str());
              returnString += buff;
          }
          else
          {
              for (int i = 0; i < arraySize; i++)
              {
                  sprintf(buff, "\t v%d[%d] = %s(1.0);\n", id, i, GenerateVaryingType(vectorSize).c_str());
                  returnString += buff;
              }
          }
  
          return returnString;
      }
  
      std::string GenerateVectorVaryingUseCode(GLint arraySize, GLint id)
      {
          if (arraySize == 1)
          {
              char buff[100];
              sprintf(buff, "v%d + ", id);
              return std::string(buff);
          }
          else
          {
              std::string returnString;
              for (int i = 0; i < arraySize; i++)
              {
                  char buff[100];
                  sprintf(buff, "v%d[%d] + ", id, i);
                  returnString += buff;
              }
              return returnString;
          }
      }
  
      void GenerateGLSLWithVaryings(GLint floatCount, GLint floatArrayCount, GLint vec2Count, GLint vec2ArrayCount, GLint vec3Count, GLint vec3ArrayCount,
                                    GLint vec4Count, GLint vec4ArrayCount, bool useFragCoord, bool usePointCoord, bool usePointSize,
                                    std::string* fragmentShader, std::string* vertexShader)
      {
          // Generate a string declaring the varyings, to share between the fragment shader and the vertex shader.
          std::string varyingDeclaration;
  
          unsigned int varyingCount = 0;
  
          for (GLint i = 0; i < floatCount; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(1, 1, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < floatArrayCount; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(1, 2, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < vec2Count; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(2, 1, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < vec2ArrayCount; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(2, 2, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < vec3Count; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(3, 1, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < vec3ArrayCount; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(3, 2, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < vec4Count; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(4, 1, varyingCount);
              varyingCount += 1;
          }
  
          for (GLint i = 0; i < vec4ArrayCount; i++)
          {
              varyingDeclaration += GenerateVectorVaryingDeclaration(4, 2, varyingCount);
              varyingCount += 1;
          }
  
          // Generate the vertex shader
          vertexShader->clear();
          vertexShader->append(varyingDeclaration);
          vertexShader->append("\nvoid main()\n{\n");
  
          unsigned int currentVSVarying = 0;
  
          for (GLint i = 0; i < floatCount; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(1, 1, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < floatArrayCount; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(1, 2, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < vec2Count; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(2, 1, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < vec2ArrayCount; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(2, 2, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < vec3Count; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(3, 1, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < vec3ArrayCount; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(3, 2, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < vec4Count; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(4, 1, currentVSVarying));
              currentVSVarying += 1;
          }
  
          for (GLint i = 0; i < vec4ArrayCount; i++)
          {
              vertexShader->append(GenerateVectorVaryingSettingCode(4, 2, currentVSVarying));
              currentVSVarying += 1;
          }
  
          if (usePointSize)
          {
              vertexShader->append("gl_PointSize = 1.0;\n");
          }
  
          vertexShader->append("}\n");
  
          // Generate the fragment shader
          fragmentShader->clear();
          fragmentShader->append("precision highp float;\n");
          fragmentShader->append(varyingDeclaration);
          fragmentShader->append("\nvoid main() \n{ \n\tvec4 retColor = vec4(0,0,0,0);\n");
  
          unsigned int currentFSVarying = 0;
  
          // Make use of the float varyings
          fragmentShader->append("\tretColor += vec4(");
  
          for (GLint i = 0; i < floatCount; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
              currentFSVarying += 1;
          }
  
          for (GLint i = 0; i < floatArrayCount; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
              currentFSVarying += 1;
          }
  
          fragmentShader->append("0.0, 0.0, 0.0, 0.0);\n");
  
          // Make use of the vec2 varyings
          fragmentShader->append("\tretColor += vec4(");
  
          for (GLint i = 0; i < vec2Count; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
              currentFSVarying += 1;
          }
  
          for (GLint i = 0; i < vec2ArrayCount; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
              currentFSVarying += 1;
          }
  
          fragmentShader->append("vec2(0.0, 0.0), 0.0, 0.0);\n");
  
          // Make use of the vec3 varyings
          fragmentShader->append("\tretColor += vec4(");
  
          for (GLint i = 0; i < vec3Count; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
              currentFSVarying += 1;
          }
  
          for (GLint i = 0; i < vec3ArrayCount; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
              currentFSVarying += 1;
          }
  
          fragmentShader->append("vec3(0.0, 0.0, 0.0), 0.0);\n");
  
          // Make use of the vec4 varyings
          fragmentShader->append("\tretColor += ");
  
          for (GLint i = 0; i < vec4Count; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(1, currentFSVarying));
              currentFSVarying += 1;
          }
  
          for (GLint i = 0; i < vec4ArrayCount; i++)
          {
              fragmentShader->append(GenerateVectorVaryingUseCode(2, currentFSVarying));
              currentFSVarying += 1;
          }
  
          fragmentShader->append("vec4(0.0, 0.0, 0.0, 0.0);\n");
  
          // Set gl_FragColor, and use special variables if requested
          fragmentShader->append("\tgl_FragColor = retColor");
          
          if (useFragCoord)
          {
              fragmentShader->append(" + gl_FragCoord");
          }
  
          if (usePointCoord)
          {
              fragmentShader->append(" + vec4(gl_PointCoord, 0.0, 0.0)");
          }
  
          fragmentShader->append(";\n}");
      }
  
      void VaryingTestBase(GLint floatCount, GLint floatArrayCount, GLint vec2Count, GLint vec2ArrayCount, GLint vec3Count, GLint vec3ArrayCount,
                           GLint vec4Count, GLint vec4ArrayCount, bool useFragCoord, bool usePointCoord, bool usePointSize, bool expectSuccess)
      {
          std::string fragmentShaderSource;
          std::string vertexShaderSource;
  
          GenerateGLSLWithVaryings(floatCount, floatArrayCount, vec2Count, vec2ArrayCount, vec3Count, vec3ArrayCount,
                                   vec4Count, vec4ArrayCount, useFragCoord, usePointCoord, usePointSize,
                                   &fragmentShaderSource, &vertexShaderSource);
  
          GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
  
          if (expectSuccess)
          {
              EXPECT_NE(0u, program);
          }
          else
          {
              EXPECT_EQ(0u, program);
          }
      }
  
      std::string mSimpleVSSource;
  };
  
  class GLSLTest_ES3 : public GLSLTest
  {
  };
  
  TEST_P(GLSLTest, NamelessScopedStructs)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          void main()
          {
              struct
              {
                  float q;
              } b;
  
              gl_FragColor = vec4(1, 0, 0, 1);
              gl_FragColor.a += b.q;
          }
      );
  
      GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, ScopedStructsOrderBug)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          struct T
          {
              float f;
          };
  
          void main()
          {
              T a;
  
              struct T
              {
                  float q;
              };
  
              T b;
  
              gl_FragColor = vec4(1, 0, 0, 1);
              gl_FragColor.a += a.f;
              gl_FragColor.a += b.q;
          }
      );
  
      GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, ScopedStructsBug)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          struct T_0
          {
              float f;
          };
  
          void main()
          {
              gl_FragColor = vec4(1, 0, 0, 1);
  
              struct T
              {
                  vec2 v;
              };
  
              T_0 a;
              T b;
  
              gl_FragColor.a += a.f;
              gl_FragColor.a += b.v.x;
          }
      );
  
      GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, DxPositionBug)
  {
      const std::string &vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 inputAttribute;
          varying float dx_Position;
          void main()
          {
              gl_Position = vec4(inputAttribute);
              dx_Position = 0.0;
          }
      );
  
      const std::string &fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          varying float dx_Position;
  
          void main()
          {
              gl_FragColor = vec4(dx_Position, 0, 0, 1);
          }
      );
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, ElseIfRewriting)
  {
      const std::string &vertexShaderSource =
          "attribute vec4 a_position;\n"
          "varying float v;\n"
          "void main() {\n"
          "  gl_Position = a_position;\n"
          "  v = 1.0;\n"
          "  if (a_position.x <= 0.5) {\n"
          "    v = 0.0;\n"
          "  } else if (a_position.x >= 0.5) {\n"
          "    v = 2.0;\n"
          "  }\n"
          "}\n";
  
      const std::string &fragmentShaderSource =
          "precision highp float;\n"
          "varying float v;\n"
          "void main() {\n"
          "  vec4 color = vec4(1.0, 0.0, 0.0, 1.0);\n"
          "  if (v >= 1.0) color = vec4(0.0, 1.0, 0.0, 1.0);\n"
          "  if (v >= 2.0) color = vec4(0.0, 0.0, 1.0, 1.0);\n"
          "  gl_FragColor = color;\n"
          "}\n";
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      ASSERT_NE(0u, program);
  
      drawQuad(program, "a_position", 0.5f);
  
      EXPECT_PIXEL_EQ(0, 0, 255, 0, 0, 255);
      EXPECT_PIXEL_EQ(getWindowWidth()-1, 0, 0, 255, 0, 255);
  }
  
  TEST_P(GLSLTest, TwoElseIfRewriting)
  {
      const std::string &vertexShaderSource =
          "attribute vec4 a_position;\n"
          "varying float v;\n"
          "void main() {\n"
          "  gl_Position = a_position;\n"
          "  if (a_position.x == 0.0) {\n"
          "    v = 1.0;\n"
          "  } else if (a_position.x > 0.5) {\n"
          "    v = 0.0;\n"
          "  } else if (a_position.x > 0.75) {\n"
          "    v = 0.5;\n"
          "  }\n"
          "}\n";
  
      const std::string &fragmentShaderSource =
          "precision highp float;\n"
          "varying float v;\n"
          "void main() {\n"
          "  gl_FragColor = vec4(v, 0.0, 0.0, 1.0);\n"
          "}\n";
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, InvariantVaryingOut)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
          varying float v_varying;
          void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
      );
  
      const std::string vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 a_position;
          invariant varying float v_varying;
          void main() { v_varying = a_position.x; gl_Position = a_position; }
      );
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, FrontFacingAndVarying)
  {
      EGLPlatformParameters platform = GetParam().eglParameters;
  
      // Disable this test on D3D11 feature level 9_3, since gl_FrontFacing isn't supported.
      if (platform.renderer == EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE)
      {
          if (platform.majorVersion == 9 && platform.minorVersion == 3)
          {
              return;
          }
      }
  
      const std::string vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 a_position;
          varying float v_varying;
          void main()
          {
              v_varying = a_position.x;
              gl_Position = a_position;
          }
      );
  
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
          varying float v_varying;
          void main()
          {
              vec4 c;
  
              if (gl_FrontFacing)
              {
                  c = vec4(v_varying, 0, 0, 1.0);
              }
              else
              {
                  c = vec4(0, v_varying, 0, 1.0);
              }
              gl_FragColor = c;
          }
      );
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, InvariantVaryingIn)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
          invariant varying float v_varying;
          void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
      );
  
      const std::string vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 a_position;
          varying float v_varying;
          void main() { v_varying = a_position.x; gl_Position = a_position; }
      );
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, InvariantVaryingBoth)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
          invariant varying float v_varying;
          void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
      );
  
      const std::string vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 a_position;
          invariant varying float v_varying;
          void main() { v_varying = a_position.x; gl_Position = a_position; }
      );
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, InvariantGLPosition)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
          varying float v_varying;
          void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
      );
  
      const std::string vertexShaderSource = SHADER_SOURCE
      (
          attribute vec4 a_position;
          invariant gl_Position;
          varying float v_varying;
          void main() { v_varying = a_position.x; gl_Position = a_position; }
      );
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, InvariantAll)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
          varying float v_varying;
          void main() { gl_FragColor = vec4(v_varying, 0, 0, 1.0); }
      );
  
      const std::string vertexShaderSource =
          "#pragma STDGL invariant(all)\n"
          "attribute vec4 a_position;\n"
          "varying float v_varying;\n"
          "void main() { v_varying = a_position.x; gl_Position = a_position; }\n";
  
      GLuint program = CompileProgram(vertexShaderSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec4)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings, 0, false, false, false, true);
  }
  
  TEST_P(GLSLTest, MaxMinusTwoVaryingVec4PlusTwoSpecialVariables)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      // Generate shader code that uses gl_FragCoord and gl_PointCoord, two special fragment shader variables.
      VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings - 2, 0, true, true, false, true);
  }
  
  TEST_P(GLSLTest, MaxMinusTwoVaryingVec4PlusThreeSpecialVariables)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      // Generate shader code that uses gl_FragCoord, gl_PointCoord and gl_PointSize.
      VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings - 2, 0, true, true, true, true);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec4PlusFragCoord)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      // Generate shader code that uses gl_FragCoord, a special fragment shader variables.
      // This test should fail, since we are really using (maxVaryings + 1) varyings.
      VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings, 0, true, false, false, false);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec4PlusPointCoord)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      // Generate shader code that uses gl_FragCoord, a special fragment shader variables.
      // This test should fail, since we are really using (maxVaryings + 1) varyings.
      VaryingTestBase(0, 0, 0, 0, 0, 0, maxVaryings, 0, false, true, false, false);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec3)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 0, 0, maxVaryings, 0, 0, 0, false, false, false, true);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec3Array)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 0, 0, 0, maxVaryings / 2, 0, 0, false, false, false, true);
  }
  
  // Disabled because of a failure in D3D9
  TEST_P(GLSLTest, DISABLED_MaxVaryingVec3AndOneFloat)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(1, 0, 0, 0, maxVaryings, 0, 0, 0, false, false, false, true);
  }
  
  // Disabled because of a failure in D3D9
  TEST_P(GLSLTest, DISABLED_MaxVaryingVec3ArrayAndOneFloatArray)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 1, 0, 0, 0, maxVaryings / 2, 0, 0, false, false, false, true);
  }
  
  // Disabled because of a failure in D3D9
  TEST_P(GLSLTest, DISABLED_TwiceMaxVaryingVec2)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 2 * maxVaryings, 0, 0, 0, 0, 0, false, false, false, true);
  }
  
  // Disabled because of a failure in D3D9
  TEST_P(GLSLTest, DISABLED_MaxVaryingVec2Arrays)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 0, maxVaryings, 0, 0, 0, 0, false, false, false, true);
  }
  
  TEST_P(GLSLTest, MaxPlusOneVaryingVec3)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 0, 0, maxVaryings + 1, 0, 0, 0, false, false, false, false);
  }
  
  TEST_P(GLSLTest, MaxPlusOneVaryingVec3Array)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 0, 0, 0, maxVaryings / 2 + 1, 0, 0, false, false, false, false);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec3AndOneVec2)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 1, 0, maxVaryings, 0, 0, 0, false, false, false, false);
  }
  
  TEST_P(GLSLTest, MaxPlusOneVaryingVec2)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, 0, 2 * maxVaryings + 1, 0, 0, 0, 0, 0, false, false, false, false);
  }
  
  TEST_P(GLSLTest, MaxVaryingVec3ArrayAndMaxPlusOneFloatArray)
  {
      GLint maxVaryings = 0;
      glGetIntegerv(GL_MAX_VARYING_VECTORS, &maxVaryings);
  
      VaryingTestBase(0, maxVaryings / 2 + 1, 0, 0, 0, 0, 0, maxVaryings / 2, false, false, false, false);
  }
  
  // Verify shader source with a fixed length that is less than the null-terminated length will compile.
  TEST_P(GLSLTest, FixedShaderLength)
  {
      GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
  
      const std::string appendGarbage = "abcasdfasdfasdfasdfasdf";
      const std::string source = "void main() { gl_FragColor = vec4(0, 0, 0, 0); }" + appendGarbage;
      const char *sourceArray[1] = { source.c_str() };
      GLint lengths[1] = { static_cast<GLint>(source.length() - appendGarbage.length()) };
      glShaderSource(shader, ArraySize(sourceArray), sourceArray, lengths);
      glCompileShader(shader);
  
      GLint compileResult;
      glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);
      EXPECT_NE(compileResult, 0);
  }
  
  // Verify that a negative shader source length is treated as a null-terminated length.
  TEST_P(GLSLTest, NegativeShaderLength)
  {
      GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
  
      const char *sourceArray[1] = { "void main() { gl_FragColor = vec4(0, 0, 0, 0); }" };
      GLint lengths[1] = { -10 };
      glShaderSource(shader, ArraySize(sourceArray), sourceArray, lengths);
      glCompileShader(shader);
  
      GLint compileResult;
      glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);
      EXPECT_NE(compileResult, 0);
  }
  
  // Verify that a length array with mixed positive and negative values compiles.
  TEST_P(GLSLTest, MixedShaderLengths)
  {
      GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
  
      const char *sourceArray[] =
      {
          "void main()",
          "{",
          "    gl_FragColor = vec4(0, 0, 0, 0);",
          "}",
      };
      GLint lengths[] =
      {
          -10,
          1,
          static_cast<GLint>(strlen(sourceArray[2])),
          -1,
      };
      ASSERT_EQ(ArraySize(sourceArray), ArraySize(lengths));
  
      glShaderSource(shader, ArraySize(sourceArray), sourceArray, lengths);
      glCompileShader(shader);
  
      GLint compileResult;
      glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);
      EXPECT_NE(compileResult, 0);
  }
  
  // Verify that zero-length shader source does not affect shader compilation.
  TEST_P(GLSLTest, ZeroShaderLength)
  {
      GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
  
      const char *sourceArray[] =
      {
          "adfasdf",
          "34534",
          "void main() { gl_FragColor = vec4(0, 0, 0, 0); }",
          "",
          "asdfasdfsdsdf",
      };
      GLint lengths[] =
      {
          0,
          0,
          -1,
          0,
          0,
      };
      ASSERT_EQ(ArraySize(sourceArray), ArraySize(lengths));
  
      glShaderSource(shader, ArraySize(sourceArray), sourceArray, lengths);
      glCompileShader(shader);
  
      GLint compileResult;
      glGetShaderiv(shader, GL_COMPILE_STATUS, &compileResult);
      EXPECT_NE(compileResult, 0);
  }
  
  // Tests that bad index expressions don't crash ANGLE's translator.
  // https://code.google.com/p/angleproject/issues/detail?id=857
  TEST_P(GLSLTest, BadIndexBug)
  {
      const std::string &fragmentShaderSourceVec =
          "precision mediump float;\n"
          "uniform vec4 uniformVec;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(uniformVec[int()]);\n"
          "}";
  
      GLuint shader = CompileShader(GL_FRAGMENT_SHADER, fragmentShaderSourceVec);
      EXPECT_EQ(0u, shader);
  
      if (shader != 0)
      {
          glDeleteShader(shader);
      }
  
      const std::string &fragmentShaderSourceMat =
          "precision mediump float;\n"
          "uniform mat4 uniformMat;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(uniformMat[int()]);\n"
          "}";
  
      shader = CompileShader(GL_FRAGMENT_SHADER, fragmentShaderSourceMat);
      EXPECT_EQ(0u, shader);
  
      if (shader != 0)
      {
          glDeleteShader(shader);
      }
  
      const std::string &fragmentShaderSourceArray =
          "precision mediump float;\n"
          "uniform vec4 uniformArray;\n"
          "void main()\n"
          "{\n"
          "    gl_FragColor = vec4(uniformArray[int()]);\n"
          "}";
  
      shader = CompileShader(GL_FRAGMENT_SHADER, fragmentShaderSourceArray);
      EXPECT_EQ(0u, shader);
  
      if (shader != 0)
      {
          glDeleteShader(shader);
      }
  }
  
  // Test that structs defined in uniforms are translated correctly.
  TEST_P(GLSLTest, StructSpecifiersUniforms)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          uniform struct S { float field;} s;
  
          void main()
          {
              gl_FragColor = vec4(1, 0, 0, 1);
              gl_FragColor.a += s.field;
          }
      );
  
      GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  }
  
  // Test that gl_DepthRange is not stored as a uniform location. Since uniforms
  // beginning with "gl_" are filtered out by our validation logic, we must
  // bypass the validation to test the behaviour of the implementation.
  // (note this test is still Impl-independent)
  TEST_P(GLSLTest, DepthRangeUniforms)
  {
      const std::string fragmentShaderSource = SHADER_SOURCE
      (
          precision mediump float;
  
          void main()
          {
              gl_FragColor = vec4(gl_DepthRange.near, gl_DepthRange.far, gl_DepthRange.diff, 1);
          }
      );
  
      GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  
      // dive into the ANGLE internals, so we can bypass validation.
      gl::Context *context = reinterpret_cast<gl::Context *>(getEGLWindow()->getContext());
      gl::Program *glProgram = context->getProgram(program);
      GLint nearIndex = glProgram->getUniformLocation("gl_DepthRange.near");
      EXPECT_EQ(-1, nearIndex);
  
      // Test drawing does not throw an exception.
      drawQuad(program, "inputAttribute", 0.5f);
  
      EXPECT_GL_NO_ERROR();
  
      glDeleteProgram(program);
  }
  
  // Covers the WebGL test 'glsl/bugs/pow-of-small-constant-in-user-defined-function'
  // See https://code.google.com/p/angleproject/issues/detail?id=851
  // TODO(jmadill): ANGLE constant folding can fix this
  TEST_P(GLSLTest, DISABLED_PowOfSmallConstant)
  {
      const std::string &fragmentShaderSource = SHADER_SOURCE
      (
          precision highp float;
  
          float fun(float arg)
          {
              // These values are still easily within the highp range.
              // The minimum range in terms of 10's exponent is around -19 to 19, and IEEE-754 single precision range is higher than that.
              return pow(arg, 2.0);
          }
  
          void main()
          {
              // Note that the bug did not reproduce if an uniform was passed to the function instead of a constant,
              // or if the expression was moved outside the user-defined function.
              const float a = 1.0e-6;
              float b = 1.0e12 * fun(a);
              if (abs(b - 1.0) < 0.01)
              {
                  gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); // green
              }
              else
              {
                  gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); // red
              }
          }
      );
  
      GLuint program = CompileProgram(mSimpleVSSource, fragmentShaderSource);
      EXPECT_NE(0u, program);
  
      drawQuad(program, "inputAttribute", 0.5f);
      EXPECT_PIXEL_EQ(0, 0, 0, 255, 0, 255);
      EXPECT_GL_NO_ERROR();
  }
  
  // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
  ANGLE_INSTANTIATE_TEST(GLSLTest, ES2_D3D9(), ES2_D3D11());
  
  // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
  ANGLE_INSTANTIATE_TEST(GLSLTest_ES3, ES3_D3D11());