1 //===- unittest/Tooling/CommentHandlerTest.cpp -----------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "TestVisitor.h"
11 #include "clang/Lex/Preprocessor.h"
12 
13 namespace clang {
14 
15 struct Comment {
16   Comment(const std::string &Message, unsigned Line, unsigned Col)
17     : Message(Message), Line(Line), Col(Col) { }
18 
19   std::string Message;
20   unsigned Line, Col;
21 };
22 
23 class CommentVerifier;
24 typedef std::vector<Comment> CommentList;
25 
26 class CommentHandlerVisitor : public TestVisitor<CommentHandlerVisitor>,
27                               public CommentHandler {
28   typedef TestVisitor<CommentHandlerVisitor> base;
29 
30 public:
31   CommentHandlerVisitor() : base(), PP(nullptr), Verified(false) {}
32 
33   ~CommentHandlerVisitor() override {
34     EXPECT_TRUE(Verified) << "CommentVerifier not accessed";
35   }
36 
37   bool HandleComment(Preprocessor &PP, SourceRange Loc) override {
38     assert(&PP == this->PP && "Preprocessor changed!");
39 
40     SourceLocation Start = Loc.getBegin();
41     SourceManager &SM = PP.getSourceManager();
42     std::string C(SM.getCharacterData(Start),
43                   SM.getCharacterData(Loc.getEnd()));
44 
45     bool Invalid;
46     unsigned CLine = SM.getSpellingLineNumber(Start, &Invalid);
47     EXPECT_TRUE(!Invalid) << "Invalid line number on comment " << C;
48 
49     unsigned CCol = SM.getSpellingColumnNumber(Start, &Invalid);
50     EXPECT_TRUE(!Invalid) << "Invalid column number on comment " << C;
51 
52     Comments.push_back(Comment(C, CLine, CCol));
53     return false;
54   }
55 
56   CommentVerifier GetVerifier();
57 
58 protected:
59   ASTFrontendAction *CreateTestAction() override {
60     return new CommentHandlerAction(this);
61   }
62 
63 private:
64   Preprocessor *PP;
65   CommentList Comments;
66   bool Verified;
67 
68   class CommentHandlerAction : public base::TestAction {
69   public:
70     CommentHandlerAction(CommentHandlerVisitor *Visitor)
71         : TestAction(Visitor) { }
72 
73     bool BeginSourceFileAction(CompilerInstance &CI) override {
74       CommentHandlerVisitor *V =
75           static_cast<CommentHandlerVisitor*>(this->Visitor);
76       V->PP = &CI.getPreprocessor();
77       V->PP->addCommentHandler(V);
78       return true;
79     }
80 
81     void EndSourceFileAction() override {
82       CommentHandlerVisitor *V =
83           static_cast<CommentHandlerVisitor*>(this->Visitor);
84       V->PP->removeCommentHandler(V);
85     }
86   };
87 };
88 
89 class CommentVerifier {
90   CommentList::const_iterator Current;
91   CommentList::const_iterator End;
92   Preprocessor *PP;
93 
94 public:
95   CommentVerifier(const CommentList &Comments, Preprocessor *PP)
96       : Current(Comments.begin()), End(Comments.end()), PP(PP)
97     { }
98 
99   CommentVerifier(CommentVerifier &&C) : Current(C.Current), End(C.End), PP(C.PP) {
100     C.Current = C.End;
101   }
102 
103   ~CommentVerifier() {
104     if (Current != End) {
105       EXPECT_TRUE(Current == End) << "Unexpected comment \""
106         << Current->Message << "\" at line " << Current->Line << ", column "
107         << Current->Col;
108     }
109   }
110 
111   void Match(const char *Message, unsigned Line, unsigned Col) {
112     EXPECT_TRUE(Current != End) << "Comment " << Message << " not found";
113     if (Current == End) return;
114 
115     const Comment &C = *Current;
116     EXPECT_TRUE(C.Message == Message && C.Line == Line && C.Col == Col)
117       <<   "Expected comment \"" << Message
118       << "\" at line " << Line   << ", column " << Col
119       << "\nActual comment   \"" << C.Message
120       << "\" at line " << C.Line << ", column " << C.Col;
121 
122     ++Current;
123   }
124 };
125 
126 CommentVerifier CommentHandlerVisitor::GetVerifier() {
127   Verified = true;
128   return CommentVerifier(Comments, PP);
129 }
130 
131 
132 TEST(CommentHandlerTest, BasicTest1) {
133   CommentHandlerVisitor Visitor;
134   EXPECT_TRUE(Visitor.runOver("class X {}; int main() { return 0; }"));
135   CommentVerifier Verifier = Visitor.GetVerifier();
136 }
137 
138 TEST(CommentHandlerTest, BasicTest2) {
139   CommentHandlerVisitor Visitor;
140   EXPECT_TRUE(Visitor.runOver(
141         "class X {}; int main() { /* comment */ return 0; }"));
142   CommentVerifier Verifier = Visitor.GetVerifier();
143   Verifier.Match("/* comment */", 1, 26);
144 }
145 
146 TEST(CommentHandlerTest, BasicTest3) {
147   CommentHandlerVisitor Visitor;
148   EXPECT_TRUE(Visitor.runOver(
149         "class X {}; // comment 1\n"
150         "int main() {\n"
151         "  // comment 2\n"
152         "  return 0;\n"
153         "}"));
154   CommentVerifier Verifier = Visitor.GetVerifier();
155   Verifier.Match("// comment 1", 1, 13);
156   Verifier.Match("// comment 2", 3, 3);
157 }
158 
159 TEST(CommentHandlerTest, IfBlock1) {
160   CommentHandlerVisitor Visitor;
161   EXPECT_TRUE(Visitor.runOver(
162         "#if 0\n"
163         "// ignored comment\n"
164         "#endif\n"
165         "// visible comment\n"));
166   CommentVerifier Verifier = Visitor.GetVerifier();
167   Verifier.Match("// visible comment", 4, 1);
168 }
169 
170 TEST(CommentHandlerTest, IfBlock2) {
171   CommentHandlerVisitor Visitor;
172   EXPECT_TRUE(Visitor.runOver(
173         "#define TEST        // visible_1\n"
174         "#ifndef TEST        // visible_2\n"
175         "                    // ignored_3\n"
176         "# ifdef UNDEFINED   // ignored_4\n"
177         "# endif             // ignored_5\n"
178         "#elif defined(TEST) // visible_6\n"
179         "# if 1              // visible_7\n"
180         "                    // visible_8\n"
181         "# else              // visible_9\n"
182         "                    // ignored_10\n"
183         "#  ifndef TEST      // ignored_11\n"
184         "#  endif            // ignored_12\n"
185         "# endif             // visible_13\n"
186         "#endif              // visible_14\n"));
187 
188   CommentVerifier Verifier = Visitor.GetVerifier();
189   Verifier.Match("// visible_1", 1, 21);
190   Verifier.Match("// visible_2", 2, 21);
191   Verifier.Match("// visible_6", 6, 21);
192   Verifier.Match("// visible_7", 7, 21);
193   Verifier.Match("// visible_8", 8, 21);
194   Verifier.Match("// visible_9", 9, 21);
195   Verifier.Match("// visible_13", 13, 21);
196   Verifier.Match("// visible_14", 14, 21);
197 }
198 
199 TEST(CommentHandlerTest, IfBlock3) {
200   const char *Source =
201         "/* commented out ...\n"
202         "#if 0\n"
203         "// enclosed\n"
204         "#endif */";
205 
206   CommentHandlerVisitor Visitor;
207   EXPECT_TRUE(Visitor.runOver(Source));
208   CommentVerifier Verifier = Visitor.GetVerifier();
209   Verifier.Match(Source, 1, 1);
210 }
211 
212 TEST(CommentHandlerTest, PPDirectives) {
213   CommentHandlerVisitor Visitor;
214   EXPECT_TRUE(Visitor.runOver(
215         "#warning Y   // ignored_1\n" // #warning takes whole line as message
216         "#undef MACRO // visible_2\n"
217         "#line 1      // visible_3\n"));
218 
219   CommentVerifier Verifier = Visitor.GetVerifier();
220   Verifier.Match("// visible_2", 2, 14);
221   Verifier.Match("// visible_3", 3, 14);
222 }
223 
224 } // end namespace clang
225