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
23using namespace clang;
24using namespace tooling;
25using namespace ast_matchers;
26
27namespace {
28class 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
36public:
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
52namespace {
53struct 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: "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(Result&: Hash);
68 }
69};
70} // end anonymous namespace
71
72static testing::AssertionResult hashStmt(llvm::MD5::MD5Result &Hash,
73 const StatementMatcher &StmtMatch,
74 StringRef Code) {
75 StmtHashMatch Hasher(Hash);
76 MatchFinder Finder;
77 Finder.addMatcher(NodeMatch: StmtMatch, Action: &Hasher);
78 std::unique_ptr<FrontendActionFactory> Factory(
79 newFrontendActionFactory(ConsumerFactory: &Finder));
80 if (!runToolOnCode(ToolAction: 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
93static testing::AssertionResult
94isStmtHashEqual(const StatementMatcher &StmtMatch, StringRef Code1,
95 StringRef Code2) {
96 llvm::MD5::MD5Result Hash1, Hash2;
97 testing::AssertionResult Result = hashStmt(Hash&: Hash1, StmtMatch, Code: Code1);
98 if (!Result)
99 return Result;
100 if (!(Result = hashStmt(Hash&: Hash2, StmtMatch, Code: Code2)))
101 return Result;
102
103 return testing::AssertionResult(Hash1 == Hash2);
104}
105
106TEST(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
115TEST(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
130TEST(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
139TEST(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
150TEST(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
157TEST(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
164TEST(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}
173

source code of clang/unittests/AST/DataCollectionTest.cpp