kc3-lang/angle/src/tests/preprocessor_tests/identifier_test.cpp

• Show log

  Commit

• Hash : f1cf5e63
  Author :
  Date : 2016-11-22T17:36:49
  

  Prevent stack overflow in macro expansion
  
  Add a configurable limit for how many nested MacroExpander objects can
  be created in the preprocessor, so that stack overflow can be
  prevented in case of malicious shaders. By default the limit is set to
  1000. In unit tests the limit is set lower to make the test run
  faster.
  
  Includes refactoring of most of the preprocessor tests so that they
  use utility functions provided by the test class instead of repeating
  the same code for initializing the preprocessor.
  
  BUG=angleproject:1600
  TEST=angle_unittests
  
  Change-Id: I23b5140d9f2dc52df96111650db63150f7238494
  Reviewed-on: https://chromium-review.googlesource.com/413986
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/tests/preprocessor_tests/identifier_test.cpp

• //
  // Copyright (c) 2012 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 "PreprocessorTest.h"
  #include "compiler/preprocessor/Token.h"
  
  #define CLOSED_RANGE(x, y) testing::Range(x, static_cast<char>((y) + 1))
  
  class IdentifierTest : public SimplePreprocessorTest
  {
  protected:
      void expectIdentifier(const std::string& str)
      {
          const char* cstr = str.c_str();
  
          pp::Token token;
          lexSingleToken(cstr, &token);
          EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
          EXPECT_EQ(str, token.text);
      }
  };
  
  class SingleLetterIdentifierTest : public IdentifierTest,
                                     public testing::WithParamInterface<char>
  {
  };
  
  // This test covers identifier names of form [_a-zA-Z].
  TEST_P(SingleLetterIdentifierTest, Identified)
  {
      std::string str(1, GetParam());
      expectIdentifier(str);
  }
  
  // Test string: '_'
  INSTANTIATE_TEST_CASE_P(Underscore,
                          SingleLetterIdentifierTest,
                          testing::Values('_'));
  
  // Test string: [a-z]
  INSTANTIATE_TEST_CASE_P(a_z,
                          SingleLetterIdentifierTest,
                          CLOSED_RANGE('a', 'z'));
  
  // Test string: [A-Z]
  INSTANTIATE_TEST_CASE_P(A_Z,
                          SingleLetterIdentifierTest,
                          CLOSED_RANGE('A', 'Z'));
  
  typedef std::tr1::tuple<char, char> IdentifierParams;
  class DoubleLetterIdentifierTest :
      public IdentifierTest,
      public testing::WithParamInterface<IdentifierParams>
  {
  };
  
  // This test covers identifier names of form [_a-zA-Z][_a-zA-Z0-9].
  TEST_P(DoubleLetterIdentifierTest, Identified)
  {
      std::string str;
      str.push_back(std::tr1::get<0>(GetParam()));
      str.push_back(std::tr1::get<1>(GetParam()));
  
      expectIdentifier(str);
  }
  
  // Test string: "__"
  INSTANTIATE_TEST_CASE_P(Underscore_Underscore,
                          DoubleLetterIdentifierTest,
                          testing::Combine(testing::Values('_'),
                                           testing::Values('_')));
  
  // Test string: "_"[a-z]
  INSTANTIATE_TEST_CASE_P(Underscore_a_z,
                          DoubleLetterIdentifierTest,
                          testing::Combine(testing::Values('_'),
                                           CLOSED_RANGE('a', 'z')));
  
  // Test string: "_"[A-Z]
  INSTANTIATE_TEST_CASE_P(Underscore_A_Z,
                          DoubleLetterIdentifierTest,
                          testing::Combine(testing::Values('_'),
                                           CLOSED_RANGE('A', 'Z')));
  
  // Test string: "_"[0-9]
  INSTANTIATE_TEST_CASE_P(Underscore_0_9,
                          DoubleLetterIdentifierTest,
                          testing::Combine(testing::Values('_'),
                                           CLOSED_RANGE('0', '9')));
  
  // Test string: [a-z]"_"
  INSTANTIATE_TEST_CASE_P(a_z_Underscore,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('a', 'z'),
                                           testing::Values('_')));
  
  // Test string: [a-z][a-z]
  INSTANTIATE_TEST_CASE_P(a_z_a_z,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('a', 'z'),
                                           CLOSED_RANGE('a', 'z')));
  
  // Test string: [a-z][A-Z]
  INSTANTIATE_TEST_CASE_P(a_z_A_Z,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('a', 'z'),
                                           CLOSED_RANGE('A', 'Z')));
  
  // Test string: [a-z][0-9]
  INSTANTIATE_TEST_CASE_P(a_z_0_9,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('a', 'z'),
                                           CLOSED_RANGE('0', '9')));
  
  // Test string: [A-Z]"_"
  INSTANTIATE_TEST_CASE_P(A_Z_Underscore,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('A', 'Z'),
                                           testing::Values('_')));
  
  // Test string: [A-Z][a-z]
  INSTANTIATE_TEST_CASE_P(A_Z_a_z,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('A', 'Z'),
                                           CLOSED_RANGE('a', 'z')));
  
  // Test string: [A-Z][A-Z]
  INSTANTIATE_TEST_CASE_P(A_Z_A_Z,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('A', 'Z'),
                                           CLOSED_RANGE('A', 'Z')));
  
  // Test string: [A-Z][0-9]
  INSTANTIATE_TEST_CASE_P(A_Z_0_9,
                          DoubleLetterIdentifierTest,
                          testing::Combine(CLOSED_RANGE('A', 'Z'),
                                           CLOSED_RANGE('0', '9')));
  
  // The tests above cover one-letter and various combinations of two-letter
  // identifier names. This test covers all characters in a single string.
  TEST_F(IdentifierTest, AllLetters)
  {
      std::string str;
      for (char c = 'a'; c <= 'z'; ++c)
          str.push_back(c);
  
      str.push_back('_');
  
      for (char c = 'A'; c <= 'Z'; ++c)
          str.push_back(c);
  
      str.push_back('_');
  
      for (char c = '0'; c <= '9'; ++c)
          str.push_back(c);
  
      expectIdentifier(str);
  }
  

Download