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

• Show log

  Commit

• Hash : ffd39978
  Author :
  Date : 2019-02-20T10:45:24
  

  test: Replace _TEST_CASE_ with _TEST_SUITE_.
  
  Googletest is (at last) converging with industry-standard terminology
  [1]. We previously called test suites "test cases", which was rather
  confusing for folks coming from any other testing framework.
  
  Chrome now has a googletest version that supports _TEST_SUITE_ macros
  instead of _TEST_CASE_, so this CL cleans up some of the outdated usage.
  
  [1] https://github.com/google/googletest/blob/master/googletest/docs/primer.md#beware-of-the-nomenclature
  
  Bug: chromium:925652
  Change-Id: Ia0deec0bc4216ef1adabc33985a7cbda89682608
  Reviewed-on: https://chromium-review.googlesource.com/c/1477418
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Victor Costan <pwnall@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 <tuple>
  
  #include "PreprocessorTest.h"
  #include "compiler/preprocessor/Token.h"
  
  namespace angle
  {
  
  #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_SUITE_P(Underscore, SingleLetterIdentifierTest, testing::Values('_'));
  
  // Test string: [a-z]
  INSTANTIATE_TEST_SUITE_P(a_z, SingleLetterIdentifierTest, CLOSED_RANGE('a', 'z'));
  
  // Test string: [A-Z]
  INSTANTIATE_TEST_SUITE_P(A_Z, SingleLetterIdentifierTest, CLOSED_RANGE('A', 'Z'));
  
  typedef std::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::get<0>(GetParam()));
      str.push_back(std::get<1>(GetParam()));
  
      expectIdentifier(str);
  }
  
  // Test string: "__"
  INSTANTIATE_TEST_SUITE_P(Underscore_Underscore,
                           DoubleLetterIdentifierTest,
                           testing::Combine(testing::Values('_'), testing::Values('_')));
  
  // Test string: "_"[a-z]
  INSTANTIATE_TEST_SUITE_P(Underscore_a_z,
                           DoubleLetterIdentifierTest,
                           testing::Combine(testing::Values('_'), CLOSED_RANGE('a', 'z')));
  
  // Test string: "_"[A-Z]
  INSTANTIATE_TEST_SUITE_P(Underscore_A_Z,
                           DoubleLetterIdentifierTest,
                           testing::Combine(testing::Values('_'), CLOSED_RANGE('A', 'Z')));
  
  // Test string: "_"[0-9]
  INSTANTIATE_TEST_SUITE_P(Underscore_0_9,
                           DoubleLetterIdentifierTest,
                           testing::Combine(testing::Values('_'), CLOSED_RANGE('0', '9')));
  
  // Test string: [a-z]"_"
  INSTANTIATE_TEST_SUITE_P(a_z_Underscore,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('a', 'z'), testing::Values('_')));
  
  // Test string: [a-z][a-z]
  INSTANTIATE_TEST_SUITE_P(a_z_a_z,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('a', 'z'), CLOSED_RANGE('a', 'z')));
  
  // Test string: [a-z][A-Z]
  INSTANTIATE_TEST_SUITE_P(a_z_A_Z,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('a', 'z'), CLOSED_RANGE('A', 'Z')));
  
  // Test string: [a-z][0-9]
  INSTANTIATE_TEST_SUITE_P(a_z_0_9,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('a', 'z'), CLOSED_RANGE('0', '9')));
  
  // Test string: [A-Z]"_"
  INSTANTIATE_TEST_SUITE_P(A_Z_Underscore,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('A', 'Z'), testing::Values('_')));
  
  // Test string: [A-Z][a-z]
  INSTANTIATE_TEST_SUITE_P(A_Z_a_z,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('A', 'Z'), CLOSED_RANGE('a', 'z')));
  
  // Test string: [A-Z][A-Z]
  INSTANTIATE_TEST_SUITE_P(A_Z_A_Z,
                           DoubleLetterIdentifierTest,
                           testing::Combine(CLOSED_RANGE('A', 'Z'), CLOSED_RANGE('A', 'Z')));
  
  // Test string: [A-Z][0-9]
  INSTANTIATE_TEST_SUITE_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);
  }
  
  }  // namespace angle
  

Download