clang/unittests/AST/DataCollectionTest.cpp

   1 //===- unittests/AST/DataCollectionTest.cpp -------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains tests for the DataCollection module.
  10 //
  11 // They work by hashing the collected data of two nodes and asserting that the
  12 // hash values are equal iff the nodes are considered equal.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "clang/AST/DataCollection.h"
  17 #include "clang/AST/DeclTemplate.h"
  18 #include "clang/AST/StmtVisitor.h"
  19 #include "clang/ASTMatchers/ASTMatchFinder.h"
  20 #include "clang/Tooling/Tooling.h"
  21 #include "gtest/gtest.h"
  22
  23 using namespace clang;
  24 using namespace tooling;
  25 using namespace ast_matchers;
  26
  27 namespace {
  28 class StmtDataCollector : public ConstStmtVisitor<StmtDataCollector> {
  29   ASTContext &Context;
  30   llvm::MD5 &DataConsumer;
  31
  32   template <class T> void addData(const T &Data) {
  33     data_collection::addDataToConsumer(DataConsumer, Data);
  34   }
  35
  36 public:
  37   StmtDataCollector(const Stmt *S, ASTContext &Context, llvm::MD5 &DataConsumer)
  38       : Context(Context), DataConsumer(DataConsumer) {
  39     this->Visit(S);
  40   }
  41
  42 #define DEF_ADD_DATA(CLASS, CODE)                                              \
  43   template <class Dummy = void> Dummy Visit##CLASS(const CLASS *S) {           \
  44     CODE;                                                                      \
  45     ConstStmtVisitor<StmtDataCollector>::Visit##CLASS(S);                      \
  46   }
  47
  48 #include "clang/AST/StmtDataCollectors.inc"
  49 };
  50 } // end anonymous namespace
  51
  52 namespace {
  53 struct StmtHashMatch : public MatchFinder::MatchCallback {
  54   unsigned NumFound;
  55   llvm::MD5::MD5Result &Hash;
  56   StmtHashMatch(llvm::MD5::MD5Result &Hash) : NumFound(0), Hash(Hash) {}
  57
  58   void run(const MatchFinder::MatchResult &Result) override {
  59     const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
  60     if (!S)
  61       return;
  62     ++NumFound;
  63     if (NumFound > 1)
  64       return;
  65     llvm::MD5 MD5;
  66     StmtDataCollector(S, *Result.Context, MD5);
  67     MD5.final(Hash);
  68   }
  69 };
  70 } // end anonymous namespace
  71
  72 static testing::AssertionResult hashStmt(llvm::MD5::MD5Result &Hash,
  73                                          const StatementMatcher &StmtMatch,
  74                                          StringRef Code) {
  75   StmtHashMatch Hasher(Hash);
  76   MatchFinder Finder;
  77   Finder.addMatcher(StmtMatch, &Hasher);
  78   std::unique_ptr<FrontendActionFactory> Factory(
  79       newFrontendActionFactory(&Finder));
  80   if (!runToolOnCode(Factory->create(), Code))
  81     return testing::AssertionFailure()
  82            << "Parsing error in \"" << Code.str() << "\"";
  83   if (Hasher.NumFound == 0)
  84     return testing::AssertionFailure() << "Matcher didn't find any statements";
  85   if (Hasher.NumFound > 1)
  86     return testing::AssertionFailure()
  87            << "Matcher should match only one statement "
  88               "(found "
  89            << Hasher.NumFound << ")";
  90   return testing::AssertionSuccess();
  91 }
  92
  93 static testing::AssertionResult
  94 isStmtHashEqual(const StatementMatcher &StmtMatch, StringRef Code1,
  95                 StringRef Code2) {
  96   llvm::MD5::MD5Result Hash1, Hash2;
  97   testing::AssertionResult Result = hashStmt(Hash1, StmtMatch, Code1);
  98   if (!Result)
  99     return Result;
 100   if (!(Result = hashStmt(Hash2, StmtMatch, Code2)))
 101     return Result;
 102
 103   return testing::AssertionResult(Hash1 == Hash2);
 104 }
 105
 106 TEST(StmtDataCollector, TestDeclRefExpr) {
 107   ASSERT_TRUE(isStmtHashEqual(declRefExpr().bind("id"), "int x, r = x;",
 108                               "int x, r = x;"));
 109   ASSERT_FALSE(isStmtHashEqual(declRefExpr().bind("id"), "int x, r = x;",
 110                                "int y, r = y;"));
 111   ASSERT_FALSE(isStmtHashEqual(declRefExpr().bind("id"), "int x, r = x;",
 112                                "namespace n { int x, r = x; };"));
 113 }
 114
 115 TEST(StmtDataCollector, TestMemberExpr) {
 116   ASSERT_TRUE(isStmtHashEqual(memberExpr().bind("id"),
 117                               "struct { int x; } X; int r = X.x;",
 118                               "struct { int x; } X; int r = (&X)->x;"));
 119   ASSERT_TRUE(isStmtHashEqual(memberExpr().bind("id"),
 120                               "struct { int x; } X; int r = X.x;",
 121                               "struct { int x; } Y; int r = Y.x;"));
 122   ASSERT_TRUE(isStmtHashEqual(memberExpr().bind("id"),
 123                               "struct { int x; } X; int r = X.x;",
 124                               "struct C { int x; } X; int r = X.C::x;"));
 125   ASSERT_FALSE(isStmtHashEqual(memberExpr().bind("id"),
 126                                "struct { int x; } X; int r = X.x;",
 127                                "struct { int y; } X; int r = X.y;"));
 128 }
 129
 130 TEST(StmtDataCollector, TestIntegerLiteral) {
 131   ASSERT_TRUE(
 132       isStmtHashEqual(integerLiteral().bind("id"), "int x = 0;", "int x = 0;"));
 133   ASSERT_TRUE(
 134       isStmtHashEqual(integerLiteral().bind("id"), "int x = 0;", "int x =00;"));
 135   ASSERT_FALSE(
 136       isStmtHashEqual(integerLiteral().bind("id"), "int x = 0;", "int x = 1;"));
 137 }
 138
 139 TEST(StmtDataCollector, TestFloatingLiteral) {
 140   ASSERT_TRUE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .0;",
 141                               "double x = .0;"));
 142   ASSERT_TRUE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .10;",
 143                               "double x = .1;"));
 144   ASSERT_TRUE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .1;",
 145                               "double x = 1e-1;"));
 146   ASSERT_FALSE(isStmtHashEqual(floatLiteral().bind("id"), "double x = .0;",
 147                                "double x = .1;"));
 148 }
 149
 150 TEST(StmtDataCollector, TestStringLiteral) {
 151   ASSERT_TRUE(isStmtHashEqual(stringLiteral().bind("id"), R"(char x[] = "0";)",
 152                               R"(char x[] = "0";)"));
 153   ASSERT_FALSE(isStmtHashEqual(stringLiteral().bind("id"), R"(char x[] = "0";)",
 154                                R"(char x[] = "1";)"));
 155 }
 156
 157 TEST(StmtDataCollector, TestCXXBoolLiteral) {
 158   ASSERT_TRUE(isStmtHashEqual(cxxBoolLiteral().bind("id"), "bool x = false;",
 159                               "bool x = false;"));
 160   ASSERT_FALSE(isStmtHashEqual(cxxBoolLiteral().bind("id"), "bool x = false;",
 161                                "bool x = true;"));
 162 }
 163
 164 TEST(StmtDataCollector, TestCharacterLiteral) {
 165   ASSERT_TRUE(isStmtHashEqual(characterLiteral().bind("id"), "char x = '0';",
 166                               "char x = '0';"));
 167   ASSERT_TRUE(isStmtHashEqual(characterLiteral().bind("id"),
 168                               R"(char x = '\0';)",
 169                               R"(char x = '\x00';)"));
 170   ASSERT_FALSE(isStmtHashEqual(characterLiteral().bind("id"), "char x = '0';",
 171                                "char x = '1';"));
 172 }