clang 19.0.0git
GtestMatchers.cpp
Go to the documentation of this file.
1//===- GtestMatchers.cpp - AST Matchers for Gtest ---------------*- C++ -*-===//
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 implements several matchers for popular gtest macros. In general,
10// AST matchers cannot match calls to macros. However, we can simulate such
11// matches if the macro definition has identifiable elements that themselves can
12// be matched. In that case, we can match on those elements and then check that
13// the match occurs within an expansion of the desired macro. The more uncommon
14// the identified elements, the more efficient this process will be.
15//
16//===----------------------------------------------------------------------===//
17
23#include "llvm/ADT/DenseMap.h"
24#include "llvm/ADT/StringRef.h"
25
26namespace clang {
27namespace ast_matchers {
28namespace {
29
30enum class MacroType {
31 Expect,
32 Assert,
33 On,
34};
35
36} // namespace
37
39 switch (Cmp) {
40 case GtestCmp::Eq:
41 return cxxMethodDecl(hasName("Compare"),
42 ofClass(cxxRecordDecl(isSameOrDerivedFrom(
43 hasName("::testing::internal::EqHelper")))));
44 case GtestCmp::Ne:
45 return functionDecl(hasName("::testing::internal::CmpHelperNE"));
46 case GtestCmp::Ge:
47 return functionDecl(hasName("::testing::internal::CmpHelperGE"));
48 case GtestCmp::Gt:
49 return functionDecl(hasName("::testing::internal::CmpHelperGT"));
50 case GtestCmp::Le:
51 return functionDecl(hasName("::testing::internal::CmpHelperLE"));
52 case GtestCmp::Lt:
53 return functionDecl(hasName("::testing::internal::CmpHelperLT"));
54 }
55 llvm_unreachable("Unhandled GtestCmp enum");
56}
57
58static llvm::StringRef getMacroTypeName(MacroType Macro) {
59 switch (Macro) {
60 case MacroType::Expect:
61 return "EXPECT";
62 case MacroType::Assert:
63 return "ASSERT";
64 case MacroType::On:
65 return "ON";
66 }
67 llvm_unreachable("Unhandled MacroType enum");
68}
69
70static llvm::StringRef getComparisonTypeName(GtestCmp Cmp) {
71 switch (Cmp) {
72 case GtestCmp::Eq:
73 return "EQ";
74 case GtestCmp::Ne:
75 return "NE";
76 case GtestCmp::Ge:
77 return "GE";
78 case GtestCmp::Gt:
79 return "GT";
80 case GtestCmp::Le:
81 return "LE";
82 case GtestCmp::Lt:
83 return "LT";
84 }
85 llvm_unreachable("Unhandled GtestCmp enum");
86}
87
88static std::string getMacroName(MacroType Macro, GtestCmp Cmp) {
89 return (getMacroTypeName(Macro) + "_" + getComparisonTypeName(Cmp)).str();
90}
91
92static std::string getMacroName(MacroType Macro, llvm::StringRef Operation) {
93 return (getMacroTypeName(Macro) + "_" + Operation).str();
94}
95
96// Under the hood, ON_CALL is expanded to a call to `InternalDefaultActionSetAt`
97// to set a default action spec to the underlying function mocker, while
98// EXPECT_CALL is expanded to a call to `InternalExpectedAt` to set a new
99// expectation spec.
100static llvm::StringRef getSpecSetterName(MacroType Macro) {
101 switch (Macro) {
102 case MacroType::On:
103 return "InternalDefaultActionSetAt";
104 case MacroType::Expect:
105 return "InternalExpectedAt";
106 default:
107 llvm_unreachable("Unhandled MacroType enum");
108 }
109 llvm_unreachable("Unhandled MacroType enum");
110}
111
112// In general, AST matchers cannot match calls to macros. However, we can
113// simulate such matches if the macro definition has identifiable elements that
114// themselves can be matched. In that case, we can match on those elements and
115// then check that the match occurs within an expansion of the desired
116// macro. The more uncommon the identified elements, the more efficient this
117// process will be.
118//
119// We use this approach to implement the derived matchers gtestAssert and
120// gtestExpect.
121static internal::BindableMatcher<Stmt>
123 StatementMatcher Right) {
124 return callExpr(isExpandedFromMacro(getMacroName(Macro, Cmp)),
125 callee(getComparisonDecl(Cmp)), hasArgument(2, Left),
126 hasArgument(3, Right));
127}
128
129static internal::BindableMatcher<Stmt>
130gtestThatInternal(MacroType Macro, StatementMatcher Actual,
131 StatementMatcher Matcher) {
132 return cxxOperatorCallExpr(
133 isExpandedFromMacro(getMacroName(Macro, "THAT")),
134 hasOverloadedOperatorName("()"), hasArgument(2, Actual),
135 hasArgument(
137 "::testing::internal::PredicateFormatterFromMatcher"))),
138 ignoringImplicit(
140 "::testing::internal::"
141 "MakePredicateFormatterFromMatcher"))),
142 hasArgument(0, ignoringImplicit(Matcher)))))));
143}
144
145static internal::BindableMatcher<Stmt>
146gtestCallInternal(MacroType Macro, StatementMatcher MockCall, MockArgs Args) {
147 // A ON_CALL or EXPECT_CALL macro expands to different AST structures
148 // depending on whether the mock method has arguments or not.
149 switch (Args) {
150 // For example,
151 // `ON_CALL(mock, TwoParamMethod)` is expanded to
152 // `mock.gmock_TwoArgsMethod(WithoutMatchers(),
153 // nullptr).InternalDefaultActionSetAt(...)`.
154 // EXPECT_CALL is the same except
155 // that it calls `InternalExpectedAt` instead of `InternalDefaultActionSetAt`
156 // in the end.
157 case MockArgs::None:
158 return cxxMemberCallExpr(
159 isExpandedFromMacro(getMacroName(Macro, "CALL")),
160 callee(functionDecl(hasName(getSpecSetterName(Macro)))),
161 onImplicitObjectArgument(ignoringImplicit(MockCall)));
162 // For example,
163 // `ON_CALL(mock, TwoParamMethod(m1, m2))` is expanded to
164 // `mock.gmock_TwoParamMethod(m1,m2)(WithoutMatchers(),
165 // nullptr).InternalDefaultActionSetAt(...)`.
166 // EXPECT_CALL is the same except that it calls `InternalExpectedAt` instead
167 // of `InternalDefaultActionSetAt` in the end.
168 case MockArgs::Some:
169 return cxxMemberCallExpr(
170 isExpandedFromMacro(getMacroName(Macro, "CALL")),
171 callee(functionDecl(hasName(getSpecSetterName(Macro)))),
172 onImplicitObjectArgument(ignoringImplicit(cxxOperatorCallExpr(
173 hasOverloadedOperatorName("()"), argumentCountIs(3),
174 hasArgument(0, ignoringImplicit(MockCall))))));
175 }
176 llvm_unreachable("Unhandled MockArgs enum");
177}
178
179static internal::BindableMatcher<Stmt>
180gtestCallInternal(MacroType Macro, StatementMatcher MockObject,
181 llvm::StringRef MockMethodName, MockArgs Args) {
182 return gtestCallInternal(
183 Macro,
185 onImplicitObjectArgument(MockObject),
186 callee(functionDecl(hasName(("gmock_" + MockMethodName).str())))),
187 Args);
188}
189
190internal::BindableMatcher<Stmt> gtestAssert(GtestCmp Cmp, StatementMatcher Left,
191 StatementMatcher Right) {
192 return gtestComparisonInternal(MacroType::Assert, Cmp, Left, Right);
193}
194
195internal::BindableMatcher<Stmt> gtestExpect(GtestCmp Cmp, StatementMatcher Left,
196 StatementMatcher Right) {
197 return gtestComparisonInternal(MacroType::Expect, Cmp, Left, Right);
198}
199
200internal::BindableMatcher<Stmt> gtestAssertThat(StatementMatcher Actual,
201 StatementMatcher Matcher) {
202 return gtestThatInternal(MacroType::Assert, Actual, Matcher);
203}
204
205internal::BindableMatcher<Stmt> gtestExpectThat(StatementMatcher Actual,
206 StatementMatcher Matcher) {
207 return gtestThatInternal(MacroType::Expect, Actual, Matcher);
208}
209
210internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockObject,
211 llvm::StringRef MockMethodName,
212 MockArgs Args) {
213 return gtestCallInternal(MacroType::On, MockObject, MockMethodName, Args);
214}
215
216internal::BindableMatcher<Stmt> gtestOnCall(StatementMatcher MockCall,
217 MockArgs Args) {
218 return gtestCallInternal(MacroType::On, MockCall, Args);
219}
220
221internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockObject,
222 llvm::StringRef MockMethodName,
223 MockArgs Args) {
224 return gtestCallInternal(MacroType::Expect, MockObject, MockMethodName, Args);
225}
226
227internal::BindableMatcher<Stmt> gtestExpectCall(StatementMatcher MockCall,
228 MockArgs Args) {
229 return gtestCallInternal(MacroType::Expect, MockCall, Args);
230}
231
232} // end namespace ast_matchers
233} // end namespace clang
Defines the clang::ASTContext interface.
internal::BindableMatcher< Stmt > gtestAssert(GtestCmp Cmp, StatementMatcher Left, StatementMatcher Right)
Matcher for gtest's ASSERT comparison macros including ASSERT_EQ, ASSERT_NE, ASSERT_GE,...
static internal::BindableMatcher< Stmt > gtestComparisonInternal(MacroType Macro, GtestCmp Cmp, StatementMatcher Left, StatementMatcher Right)
MockArgs
This enum indicates whether the mock method in the matched ON_CALL or EXPECT_CALL macro has arguments...
Definition: GtestMatchers.h:38
static llvm::StringRef getComparisonTypeName(GtestCmp Cmp)
GtestCmp
Gtest's comparison operations.
Definition: GtestMatchers.h:25
internal::Matcher< Decl > DeclarationMatcher
Types of matchers for the top-level classes in the AST class hierarchy.
Definition: ASTMatchers.h:143
static DeclarationMatcher getComparisonDecl(GtestCmp Cmp)
internal::BindableMatcher< Stmt > gtestExpect(GtestCmp Cmp, StatementMatcher Left, StatementMatcher Right)
Matcher for gtest's EXPECT comparison macros including EXPECT_EQ, EXPECT_NE, EXPECT_GE,...
internal::Matcher< NamedDecl > hasName(StringRef Name)
Matches NamedDecl nodes that have the specified name.
Definition: ASTMatchers.h:3079
const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr
Matches call expressions.
static llvm::StringRef getMacroTypeName(MacroType Macro)
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXMemberCallExpr > cxxMemberCallExpr
Matches member call expressions.
internal::BindableMatcher< Stmt > gtestExpectThat(StatementMatcher Actual, StatementMatcher Matcher)
Matcher for gtest's EXPECT_THAT macro.
static internal::BindableMatcher< Stmt > gtestThatInternal(MacroType Macro, StatementMatcher Actual, StatementMatcher Matcher)
internal::Matcher< Stmt > StatementMatcher
Definition: ASTMatchers.h:144
internal::BindableMatcher< Stmt > gtestAssertThat(StatementMatcher Actual, StatementMatcher Matcher)
Matcher for gtest's ASSERT_THAT macro.
const internal::VariadicDynCastAllOfMatcher< Stmt, CXXOperatorCallExpr > cxxOperatorCallExpr
Matches overloaded operator calls.
internal::PolymorphicMatcher< internal::HasOverloadedOperatorNameMatcher, AST_POLYMORPHIC_SUPPORTED_TYPES(CXXOperatorCallExpr, FunctionDecl), std::vector< std::string > > hasOverloadedOperatorName(StringRef Name)
Matches overloaded operator names.
Definition: ASTMatchers.h:3142
const internal::VariadicDynCastAllOfMatcher< Decl, ClassTemplateSpecializationDecl > classTemplateSpecializationDecl
Matches C++ class template specializations.
const internal::VariadicDynCastAllOfMatcher< Decl, FunctionDecl > functionDecl
Matches function declarations.
const internal::VariadicDynCastAllOfMatcher< Decl, CXXRecordDecl > cxxRecordDecl
Matches C++ class declarations.
internal::BindableMatcher< Stmt > gtestOnCall(StatementMatcher MockObject, llvm::StringRef MockMethodName, MockArgs Args)
Like the first gtestExpectCall overload but for ON_CALL.
static std::string getMacroName(MacroType Macro, GtestCmp Cmp)
internal::BindableMatcher< Stmt > gtestExpectCall(StatementMatcher MockObject, llvm::StringRef MockMethodName, MockArgs Args)
Matcher for gtest's EXPECT_CALL macro.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
static llvm::StringRef getSpecSetterName(MacroType Macro)
const internal::VariadicDynCastAllOfMatcher< Decl, CXXMethodDecl > cxxMethodDecl
Matches method declarations.
static internal::BindableMatcher< Stmt > gtestCallInternal(MacroType Macro, StatementMatcher MockCall, MockArgs Args)
The JSON file list parser is used to communicate input to InstallAPI.