| 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 |
} |