kc3-lang/angle/src/tests/preprocessor_tests/space_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/space_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
  {
  
  class SpaceTest : public PreprocessorTest
  {
    protected:
      SpaceTest() : PreprocessorTest(SH_GLES2_SPEC) {}
  
      void expectSpace(const std::string &str)
      {
          const char *cstr = str.c_str();
          ASSERT_TRUE(mPreprocessor.init(1, &cstr, 0));
  
          pp::Token token;
          // "foo" is returned after ignoring the whitespace characters.
          mPreprocessor.lex(&token);
          EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
          EXPECT_EQ("foo", token.text);
          // The whitespace character is however recorded with the next token.
          EXPECT_TRUE(token.hasLeadingSpace());
      }
  };
  
  // Whitespace characters allowed in GLSL.
  // Note that newline characters (\n) will be tested separately.
  static const char kSpaceChars[] = {' ', '\t', '\v', '\f'};
  
  // This test fixture tests the processing of a single whitespace character.
  // All tests in this fixture are ran with all possible whitespace character
  // allowed in GLSL.
  class SpaceCharTest : public SpaceTest, public testing::WithParamInterface<char>
  {};
  
  TEST_P(SpaceCharTest, SpaceIgnored)
  {
      // Construct test string with the whitespace char before "foo".
      std::string str(1, GetParam());
      str.append("foo");
  
      expectSpace(str);
  }
  
  INSTANTIATE_TEST_SUITE_P(SingleSpaceChar, SpaceCharTest, testing::ValuesIn(kSpaceChars));
  
  // This test fixture tests the processing of a string containing consecutive
  // whitespace characters. All tests in this fixture are ran with all possible
  // combinations of whitespace characters allowed in GLSL.
  typedef std::tuple<char, char, char> SpaceStringParams;
  class SpaceStringTest : public SpaceTest, public testing::WithParamInterface<SpaceStringParams>
  {};
  
  TEST_P(SpaceStringTest, SpaceIgnored)
  {
      // Construct test string with the whitespace char before "foo".
      std::string str;
      str.push_back(std::get<0>(GetParam()));
      str.push_back(std::get<1>(GetParam()));
      str.push_back(std::get<2>(GetParam()));
      str.append("foo");
  
      expectSpace(str);
  }
  
  INSTANTIATE_TEST_SUITE_P(SpaceCharCombination,
                           SpaceStringTest,
                           testing::Combine(testing::ValuesIn(kSpaceChars),
                                            testing::ValuesIn(kSpaceChars),
                                            testing::ValuesIn(kSpaceChars)));
  
  // The tests above make sure that the space char is recorded in the
  // next token. This test makes sure that a token is not incorrectly marked
  // to have leading space.
  TEST_F(SpaceTest, LeadingSpace)
  {
      const char *str = " foo+ -bar";
      ASSERT_TRUE(mPreprocessor.init(1, &str, 0));
  
      pp::Token token;
      mPreprocessor.lex(&token);
      EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
      EXPECT_EQ("foo", token.text);
      EXPECT_TRUE(token.hasLeadingSpace());
  
      mPreprocessor.lex(&token);
      EXPECT_EQ('+', token.type);
      EXPECT_FALSE(token.hasLeadingSpace());
  
      mPreprocessor.lex(&token);
      EXPECT_EQ('-', token.type);
      EXPECT_TRUE(token.hasLeadingSpace());
  
      mPreprocessor.lex(&token);
      EXPECT_EQ(pp::Token::IDENTIFIER, token.type);
      EXPECT_EQ("bar", token.text);
      EXPECT_FALSE(token.hasLeadingSpace());
  }
  
  }  // namespace angle
  

Download