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

• Show log

  Commit

• Hash : fbb1c792
  Author :
  Date : 2018-01-19T16:26:59
  

  Store symbol names as a ImmutableString
  
  This will enable compile-time initialization of built-in symbols as
  well as reducing copying strings.
  
  Most of the code that deals with names is changed to use
  ImmutableString where it makes sense to avoid conversions.
  
  The lexer/parser now allocate const char pointers into pool memory
  instead of allocating TStrings. These are then converted to
  ImmutableString upon entering TParseContext.
  
  BUG=angleproject:2267
  TEST=angle_unittests, angle_end2end_tests
  
  Change-Id: I244d6271ea1ecf7150d4f89dfa388a7745a1150c
  Reviewed-on: https://chromium-review.googlesource.com/881561
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/tests/compiler_tests/QualificationOrderESSL31_test.cpp

• //
  // Copyright (c) 2016 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.
  //
  // QualificationOrderESSL31_test.cpp:
  //   OpenGL ES 3.1 removes the strict order of qualifiers imposed by the grammar.
  //   This file contains tests for invalid order and usage of qualifiers in GLSL ES 3.10.
  
  #include "gtest/gtest.h"
  
  #include "angle_gl.h"
  #include "compiler/translator/TranslatorESSL.h"
  #include "GLSLANG/ShaderLang.h"
  #include "tests/test_utils/compiler_test.h"
  #include "tests/test_utils/ShaderCompileTreeTest.h"
  
  using namespace sh;
  
  class QualificationVertexShaderTestESSL31 : public ShaderCompileTreeTest
  {
    public:
      QualificationVertexShaderTestESSL31() {}
    protected:
      ::GLenum getShaderType() const override { return GL_VERTEX_SHADER; }
      ShShaderSpec getShaderSpec() const override { return SH_GLES3_1_SPEC; }
  
      const TIntermSymbol *findSymbolInAST(const ImmutableString &symbolName)
      {
          return FindSymbolNode(mASTRoot, symbolName);
      }
  };
  
  // GLSL ES 3.10 has relaxed checks on qualifier order. Any order is correct.
  TEST_F(QualificationVertexShaderTestESSL31, CentroidOut)
  {
      const std::string &shaderString =
          "#version 310 es\n"
          "precision lowp float;\n"
          "out centroid float something;\n"
          "void main(){\n"
          "   something = 1.0;\n"
          "}\n";
      if (!compile(shaderString))
      {
          FAIL() << "Shader compilation failed, expecting success" << mInfoLog;
      }
      else
      {
          const TIntermSymbol *node = findSymbolInAST(ImmutableString("something"));
          ASSERT_NE(nullptr, node);
  
          const TType &type = node->getType();
          EXPECT_EQ(EvqCentroidOut, type.getQualifier());
      }
  }
  
  // GLSL ES 3.10 has relaxed checks on qualifier order. Any order is correct.
  TEST_F(QualificationVertexShaderTestESSL31, AllQualifiersMixed)
  {
      const std::string &shaderString =
          "#version 310 es\n"
          "precision lowp float;\n"
          "highp out invariant centroid flat vec4 something;\n"
          "void main(){\n"
          "}\n";
      if (!compile(shaderString))
      {
          FAIL() << "Shader compilation failed, expecting success" << mInfoLog;
      }
      else
      {
          const TIntermSymbol *node = findSymbolInAST(ImmutableString("something"));
          ASSERT_NE(nullptr, node);
  
          const TType &type = node->getType();
          EXPECT_TRUE(type.isInvariant());
          EXPECT_EQ(EvqFlatOut, type.getQualifier());
          EXPECT_EQ(EbpHigh, type.getPrecision());
      }
  }
  
  // GLSL ES 3.10 allows multiple layout qualifiers to be specified.
  TEST_F(QualificationVertexShaderTestESSL31, MultipleLayouts)
  {
      const std::string &shaderString =
          "#version 310 es\n"
          "precision lowp float;\n"
          "in layout(location=1) layout(location=2) vec4 something;\n"
          "void main(){\n"
          "}\n";
      if (!compile(shaderString))
      {
          FAIL() << "Shader compilation failed, expecting success" << mInfoLog;
      }
      else
      {
          const TIntermSymbol *node = findSymbolInAST(ImmutableString("something"));
          ASSERT_NE(nullptr, node);
  
          const TType &type = node->getType();
          EXPECT_EQ(EvqVertexIn, type.getQualifier());
          EXPECT_EQ(2, type.getLayoutQualifier().location);
      }
  }
  
  // The test checks layout qualifier overriding when multiple layouts are specified.
  TEST_F(QualificationVertexShaderTestESSL31, MultipleLayoutsInterfaceBlock)
  {
      const std::string &shaderString =
          "#version 310 es\n"
          "precision lowp float;\n"
          "out float someValue;\n"
          "layout(shared) layout(std140) layout(column_major) uniform MyInterface\n"
          "{ vec4 something; } MyInterfaceName;\n"
          "void main(){\n"
          "   someValue = MyInterfaceName.something.r;\n"
          "}\n";
      if (!compile(shaderString))
      {
          FAIL() << "Shader compilation failed, expecting success" << mInfoLog;
      }
      else
      {
          const TIntermSymbol *node = findSymbolInAST(ImmutableString("MyInterfaceName"));
          ASSERT_NE(nullptr, node);
  
          const TType &type                = node->getType();
          TLayoutQualifier layoutQualifier = type.getLayoutQualifier();
          EXPECT_EQ(EbsStd140, layoutQualifier.blockStorage);
          EXPECT_EQ(EmpColumnMajor, layoutQualifier.matrixPacking);
      }
  }
  
  // The test checks layout qualifier overriding when multiple layouts are specified.
  TEST_F(QualificationVertexShaderTestESSL31, MultipleLayoutsInterfaceBlock2)
  {
      const std::string &shaderString =
          "#version 310 es\n"
          "precision lowp float;\n"
          "out float someValue;\n"
          "layout(row_major) layout(std140) layout(shared) uniform MyInterface\n"
          "{ vec4 something; } MyInterfaceName;\n"
          "void main(){\n"
          "   someValue = MyInterfaceName.something.r;\n"
          "}\n";
      if (!compile(shaderString))
      {
          FAIL() << "Shader compilation failed, expecting success" << mInfoLog;
      }
      else
      {
          const TIntermSymbol *node = findSymbolInAST(ImmutableString("MyInterfaceName"));
          ASSERT_NE(nullptr, node);
  
          const TType &type                = node->getType();
          TLayoutQualifier layoutQualifier = type.getLayoutQualifier();
          EXPECT_EQ(EbsShared, layoutQualifier.blockStorage);
          EXPECT_EQ(EmpRowMajor, layoutQualifier.matrixPacking);
      }
  }
  

Download