kc3-lang/angle/src/tests/compiler_tests/RecordConstantPrecision_test.cpp

• Show log

  Commit

• Hash : 10fcd9be
  Author :
  Date : 2016-06-30T12:24:09
  

  Add a helper class for compiler string matching tests
  
  The MatchOutputCodeTest class makes it easier to implement tests that
  do string matching on compiler output. Inheriting test classes set the
  compiler settings, tests then call compile() with the shader string
  and can call foundInCode() to check if the output code contains a
  given string.
  
  Various compiler unit tests that already did string matching are
  refactored to make use of this new helper class. Some tests now use
  SH_GLES3_SPEC instead of SH_GLES2_SPEC - this should not have a
  significant impact on test coverage.
  
  Some compileTestShader function variants that are now unused can be
  removed from the code.
  
  BUG=angleproject:1430
  TEST=angle_unittests
  
  Change-Id: I1fd3529d5a1c6ab192f95ace800cf162604e68e7
  Reviewed-on: https://chromium-review.googlesource.com/357800
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  

Download

• src/tests/compiler_tests/RecordConstantPrecision_test.cpp

• //
  // Copyright (c) 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.
  //
  // RecordConstantPrecision_test.cpp:
  //   Test for recording constant variable precision when it affects consuming expression.
  //
  
  #include "angle_gl.h"
  #include "gtest/gtest.h"
  #include "GLSLANG/ShaderLang.h"
  #include "tests/test_utils/compiler_test.h"
  
  class RecordConstantPrecisionTest : public MatchOutputCodeTest
  {
    public:
      RecordConstantPrecisionTest() : MatchOutputCodeTest(GL_FRAGMENT_SHADER, 0, SH_ESSL_OUTPUT) {}
  };
  
  // The constant cannot be folded if its precision is higher than the other operands, since it
  // increases the precision of the consuming expression.
  TEST_F(RecordConstantPrecisionTest, HigherPrecisionConstantAsParameter)
  {
      const std::string &shaderString =
          "uniform mediump float u;"
          "void main()\n"
          "{\n"
          "    const highp float a = 4096.5;\n"
          "    mediump float b = fract(a + u);\n"
          "    gl_FragColor = vec4(b);\n"
          "}\n";
      compile(shaderString);
      ASSERT_TRUE(foundInCode("const highp float s"));
      ASSERT_FALSE(foundInCode("fract(4096.5"));
      ASSERT_FALSE(foundInCode("fract((4096.5"));
  }
  
  // The constant can be folded if its precision is equal to the other operands, as it does not
  // increase the precision of the consuming expression.
  TEST_F(RecordConstantPrecisionTest, EqualPrecisionConstantAsParameter)
  {
      const std::string &shaderString =
          "uniform mediump float u;"
          "void main()\n"
          "{\n"
          "    const mediump float a = 4096.5;\n"
          "    mediump float b = fract(a + u);\n"
          "    gl_FragColor = vec4(b);\n"
          "}\n";
      compile(shaderString);
      ASSERT_FALSE(foundInCode("const mediump float s"));
      ASSERT_TRUE(foundInCode("fract((4096.5"));
  }
  
  // The constant cannot be folded if its precision is higher than the other operands, since it
  // increases the precision of the consuming expression. This applies also when the constant is
  // part of a constant expression that can be folded.
  TEST_F(RecordConstantPrecisionTest, FoldedBinaryConstantPrecisionIsHigher)
  {
      const std::string &shaderString =
          "uniform mediump float u;"
          "void main()\n"
          "{\n"
          "    const highp float a = 4095.5;\n"
          "    mediump float b = fract((a + 1.0) + u);\n"
          "    gl_FragColor = vec4(b);\n"
          "}\n";
      compile(shaderString);
      ASSERT_TRUE(foundInCode("const highp float s"));
      ASSERT_FALSE(foundInCode("fract(4096.5"));
      ASSERT_FALSE(foundInCode("fract((4096.5"));
  }
  
  
  // The constant cannot be folded if its precision is higher than the other operands, since it
  // increases the precision of the consuming expression. This applies also when the constant is
  // part of a constant expression that can be folded.
  TEST_F(RecordConstantPrecisionTest, FoldedUnaryConstantPrecisionIsHigher)
  {
      const std::string &shaderString =
          "uniform mediump float u;"
          "void main()\n"
          "{\n"
          "    const highp float a = 0.5;\n"
          "    mediump float b = sin(fract(a) + u);\n"
          "    gl_FragColor = vec4(b);\n"
          "}\n";
      compile(shaderString);
      ASSERT_TRUE(foundInCode("const highp float s"));
      ASSERT_FALSE(foundInCode("sin(0.5"));
      ASSERT_FALSE(foundInCode("sin((0.5"));
  }
  

Download