1 #include "ClangTidyTest.h"
2 #include "readability/BracesAroundStatementsCheck.h"
3 #include "readability/NamespaceCommentCheck.h"
4 #include "gtest/gtest.h"
5 
6 namespace clang {
7 namespace tidy {
8 namespace test {
9 
10 using readability::BracesAroundStatementsCheck;
11 using readability::NamespaceCommentCheck;
12 
13 TEST(NamespaceCommentCheckTest, Basic) {
14   EXPECT_EQ("namespace i {\n} // namespace i",
15             runCheckOnCode<NamespaceCommentCheck>("namespace i {\n}"));
16   EXPECT_EQ("namespace {\n} // namespace",
17             runCheckOnCode<NamespaceCommentCheck>("namespace {\n}"));
18   EXPECT_EQ(
19       "namespace i { namespace j {\n} // namespace j\n } // namespace i",
20       runCheckOnCode<NamespaceCommentCheck>("namespace i { namespace j {\n} }"));
21 }
22 
23 TEST(NamespaceCommentCheckTest, SingleLineNamespaces) {
24   EXPECT_EQ(
25       "namespace i { namespace j { } }",
26       runCheckOnCode<NamespaceCommentCheck>("namespace i { namespace j { } }"));
27 }
28 
29 TEST(NamespaceCommentCheckTest, CheckExistingComments) {
30   EXPECT_EQ("namespace i { namespace j {\n"
31             "} /* namespace j */ } // namespace i\n"
32             " /* random comment */",
33             runCheckOnCode<NamespaceCommentCheck>(
34                 "namespace i { namespace j {\n"
35                 "} /* namespace j */ } /* random comment */"));
36   EXPECT_EQ("namespace {\n"
37             "} // namespace",
38             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
39                                                   "} // namespace"));
40   EXPECT_EQ("namespace {\n"
41             "} //namespace",
42             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
43                                                   "} //namespace"));
44   EXPECT_EQ("namespace {\n"
45             "} // anonymous namespace",
46             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
47                                                   "} // anonymous namespace"));
48   EXPECT_EQ("namespace {\n"
49             "} // Anonymous namespace.",
50             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
51                                                   "} // Anonymous namespace."));
52   EXPECT_EQ("namespace q {\n"
53             "} // namespace q",
54             runCheckOnCode<NamespaceCommentCheck>("namespace q {\n"
55                                                   "} // anonymous namespace q"));
56   EXPECT_EQ(
57       "namespace My_NameSpace123 {\n"
58       "} // namespace My_NameSpace123",
59       runCheckOnCode<NamespaceCommentCheck>("namespace My_NameSpace123 {\n"
60                                             "} // namespace My_NameSpace123"));
61   EXPECT_EQ(
62       "namespace My_NameSpace123 {\n"
63       "} //namespace My_NameSpace123",
64       runCheckOnCode<NamespaceCommentCheck>("namespace My_NameSpace123 {\n"
65                                             "} //namespace My_NameSpace123"));
66   EXPECT_EQ("namespace My_NameSpace123 {\n"
67             "} //  end namespace   My_NameSpace123",
68             runCheckOnCode<NamespaceCommentCheck>(
69                 "namespace My_NameSpace123 {\n"
70                 "} //  end namespace   My_NameSpace123"));
71   // Understand comments only on the same line.
72   EXPECT_EQ("namespace {\n"
73             "} // namespace\n"
74             "// namespace",
75             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
76                                                   "}\n"
77                                                   "// namespace"));
78 }
79 
80 TEST(NamespaceCommentCheckTest, FixWrongComments) {
81   EXPECT_EQ("namespace i { namespace jJ0_ {\n"
82             "} // namespace jJ0_\n"
83             " } // namespace i\n"
84             " /* random comment */",
85             runCheckOnCode<NamespaceCommentCheck>(
86                 "namespace i { namespace jJ0_ {\n"
87                 "} /* namespace qqq */ } /* random comment */"));
88   EXPECT_EQ("namespace {\n"
89             "} // namespace",
90             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
91                                                   "} // namespace asdf"));
92   // Remove unknown line comments. These are likely to be an unrecognized form
93   // of a namespace ending comment.
94   EXPECT_EQ("namespace {\n"
95             "} // namespace",
96             runCheckOnCode<NamespaceCommentCheck>("namespace {\n"
97                                                   "} // random text"));
98 }
99 
100 TEST(BracesAroundStatementsCheck, IfWithComments) {
101   EXPECT_EQ("int main() {\n"
102             "  if (false /*dummy token*/) {\n"
103             "    // comment\n"
104             "    return -1; /**/\n"
105             "}\n"
106             "  if (false) {\n"
107             "    return -1; // comment\n"
108             "}\n"
109             "  if (false) {\n"
110             "    return -1; \n"
111             "}/* multi-line \n comment */\n"
112             "}",
113             runCheckOnCode<BracesAroundStatementsCheck>(
114                 "int main() {\n"
115                 "  if (false /*dummy token*/)\n"
116                 "    // comment\n"
117                 "    return -1; /**/\n"
118                 "  if (false)\n"
119                 "    return -1; // comment\n"
120                 "  if (false)\n"
121                 "    return -1; /* multi-line \n comment */\n"
122                 "}"));
123   EXPECT_EQ("int main() {\n"
124             "  if (false /*dummy token*/) {\n"
125             "    // comment\n"
126             "    return -1 /**/ ;\n"
127             "}\n"
128             "}",
129             runCheckOnCode<BracesAroundStatementsCheck>(
130                 "int main() {\n"
131                 "  if (false /*dummy token*/)\n"
132                 "    // comment\n"
133                 "    return -1 /**/ ;\n"
134                 "}"));
135 }
136 
137 TEST(BracesAroundStatementsCheck, If) {
138   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
139                                                  "  if (false) {\n"
140                                                  "    return -1;\n"
141                                                  "  }\n"
142                                                  "}");
143   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
144                                                  "  if (auto Cond = false) {\n"
145                                                  "    return -1;\n"
146                                                  "  }\n"
147                                                  "}");
148   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
149                                                  "  if (false) {\n"
150                                                  "    return -1;\n"
151                                                  "  } else {\n"
152                                                  "    return -2;\n"
153                                                  "  }\n"
154                                                  "}");
155   EXPECT_EQ("int main() {\n"
156             "  if (false) {\n"
157             "    return -1;\n"
158             "}\n"
159             "}",
160             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
161                                                         "  if (false)\n"
162                                                         "    return -1;\n"
163                                                         "}"));
164   EXPECT_EQ("int main() {\n"
165             "  if (auto Cond = false /**/ ) {\n"
166             "    return -1;\n"
167             "}\n"
168             "}",
169             runCheckOnCode<BracesAroundStatementsCheck>(
170                 "int main() {\n"
171                 "  if (auto Cond = false /**/ )\n"
172                 "    return -1;\n"
173                 "}"));
174   // FIXME: Consider adding braces before EMPTY_MACRO and after the statement.
175   EXPECT_NO_CHANGES(BracesAroundStatementsCheck,
176                     "#define EMPTY_MACRO\n"
177                     "int main() {\n"
178                     "  if (auto Cond = false EMPTY_MACRO /**/ ) EMPTY_MACRO\n"
179                     "    return -1;\n"
180                     "}");
181   EXPECT_EQ("int main() {\n"
182             "  if (true) { return -1/**/ ;\n"
183             "}\n"
184             "}",
185             runCheckOnCode<BracesAroundStatementsCheck>(
186                 "int main() {\n"
187                 "  if (true) return -1/**/ ;\n"
188                 "}"));
189   EXPECT_EQ("int main() {\n"
190             "  if (false) {\n"
191             "    return -1;\n"
192             "  } else {\n"
193             "    return -2;\n"
194             "}\n"
195             "}",
196             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
197                                                         "  if (false)\n"
198                                                         "    return -1;\n"
199                                                         "  else\n"
200                                                         "    return -2;\n"
201                                                         "}"));
202   EXPECT_EQ("int main() {\n"
203             "  if (false) {\n"
204             "    return -1;\n"
205             "  } else if (1 == 2) {\n"
206             "    return -2;\n"
207             "  } else {\n"
208             "    return -3;\n"
209             "}\n"
210             "}",
211             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
212                                                         "  if (false)\n"
213                                                         "    return -1;\n"
214                                                         "  else if (1 == 2)\n"
215                                                         "    return -2;\n"
216                                                         "  else\n"
217                                                         "    return -3;\n"
218                                                         "}"));
219   EXPECT_EQ("int main() {\n"
220             "  if (false) {\n"
221             "    return -1;\n"
222             "  } else if (1 == 2) {\n"
223             "    return -2;\n"
224             "  } else {\n"
225             "    return -3;\n"
226             "}\n"
227             "}",
228             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
229                                                         "  if (false)\n"
230                                                         "    return -1;\n"
231                                                         "  else if (1 == 2) {\n"
232                                                         "    return -2;\n"
233                                                         "  } else\n"
234                                                         "    return -3;\n"
235                                                         "}"));
236 }
237 
238 TEST(BracesAroundStatementsCheck, IfElseWithShortStatements) {
239   ClangTidyOptions Options;
240   Options.CheckOptions["test-check.ShortStatementLines"] = "1";
241 
242   EXPECT_EQ("int main() {\n"
243             "  if (true) return 1;\n"
244             "  if (false) { return -1;\n"
245             "  } else if (1 == 2) { return -2;\n"
246             "  } else { return -3;\n"
247             "}\n"
248             "}",
249             runCheckOnCode<BracesAroundStatementsCheck>(
250                 "int main() {\n"
251                 "  if (true) return 1;\n"
252                 "  if (false) return -1;\n"
253                 "  else if (1 == 2) return -2;\n"
254                 "  else return -3;\n"
255                 "}",
256                 nullptr, "input.cc", None, Options));
257 }
258 
259 TEST(BracesAroundStatementsCheck, For) {
260   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
261                                                  "  for (;;) {\n"
262                                                  "    ;\n"
263                                                  "  }\n"
264                                                  "}");
265   EXPECT_EQ("int main() {\n"
266             "  for (;;) {\n"
267             "    ;\n"
268             "}\n"
269             "}",
270             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
271                                                         "  for (;;)\n"
272                                                         "    ;\n"
273                                                         "}"));
274   EXPECT_EQ("int main() {\n"
275             "  for (;;) {\n"
276             "    /**/ ;\n"
277             "}\n"
278             "}",
279             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
280                                                         "  for (;;)\n"
281                                                         "    /**/ ;\n"
282                                                         "}"));
283   EXPECT_EQ("int main() {\n"
284             "  for (;;) {\n"
285             "    return -1 /**/ ;\n"
286             "}\n"
287             "}",
288             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
289                                                         "  for (;;)\n"
290                                                         "    return -1 /**/ ;\n"
291                                                         "}"));
292 }
293 
294 TEST(BracesAroundStatementsCheck, ForRange) {
295   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
296                                                  "  int arr[4];\n"
297                                                  "  for (int i : arr) {\n"
298                                                  "    ;\n"
299                                                  "  }\n"
300                                                  "}");
301   EXPECT_EQ("int main() {\n"
302             "  int arr[4];\n"
303             "  for (int i : arr) {\n"
304             "    ;\n"
305             "}\n"
306             "  for (int i : arr) {\n"
307             "    return -1 ;\n"
308             "}\n"
309             "}",
310             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
311                                                         "  int arr[4];\n"
312                                                         "  for (int i : arr)\n"
313                                                         "    ;\n"
314                                                         "  for (int i : arr)\n"
315                                                         "    return -1 ;\n"
316                                                         "}"));
317 }
318 
319 TEST(BracesAroundStatementsCheck, DoWhile) {
320   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
321                                                  "  do {\n"
322                                                  "    ;\n"
323                                                  "  } while (false);\n"
324                                                  "}");
325   EXPECT_EQ("int main() {\n"
326             "  do {\n"
327             "    ;\n"
328             "  } while (false);\n"
329             "}",
330             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
331                                                         "  do\n"
332                                                         "    ;\n"
333                                                         "  while (false);\n"
334                                                         "}"));
335 }
336 
337 TEST(BracesAroundStatementsCheck, While) {
338   EXPECT_NO_CHANGES(BracesAroundStatementsCheck, "int main() {\n"
339                                                  "  while (false) {\n"
340                                                  "    ;\n"
341                                                  "  }\n"
342                                                  "}");
343   EXPECT_EQ("int main() {\n"
344             "  while (false) {\n"
345             "    ;\n"
346             "}\n"
347             "}",
348             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
349                                                         "  while (false)\n"
350                                                         "    ;\n"
351                                                         "}"));
352   EXPECT_EQ("int main() {\n"
353             "  while (auto Cond = false) {\n"
354             "    ;\n"
355             "}\n"
356             "}",
357             runCheckOnCode<BracesAroundStatementsCheck>(
358                 "int main() {\n"
359                 "  while (auto Cond = false)\n"
360                 "    ;\n"
361                 "}"));
362   EXPECT_EQ("int main() {\n"
363             "  while (false /*dummy token*/) {\n"
364             "    ;\n"
365             "}\n"
366             "}",
367             runCheckOnCode<BracesAroundStatementsCheck>(
368                 "int main() {\n"
369                 "  while (false /*dummy token*/)\n"
370                 "    ;\n"
371                 "}"));
372   EXPECT_EQ("int main() {\n"
373             "  while (false) {\n"
374             "    break;\n"
375             "}\n"
376             "}",
377             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
378                                                         "  while (false)\n"
379                                                         "    break;\n"
380                                                         "}"));
381   EXPECT_EQ("int main() {\n"
382             "  while (false) {\n"
383             "    break /**/;\n"
384             "}\n"
385             "}",
386             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
387                                                         "  while (false)\n"
388                                                         "    break /**/;\n"
389                                                         "}"));
390   EXPECT_EQ("int main() {\n"
391             "  while (false) {\n"
392             "    /**/;\n"
393             "}\n"
394             "}",
395             runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
396                                                         "  while (false)\n"
397                                                         "    /**/;\n"
398                                                         "}"));
399 }
400 
401 TEST(BracesAroundStatementsCheck, Nested) {
402   EXPECT_EQ("int main() {\n"
403             "  do { if (true) {}} while (false);\n"
404             "}",
405             runCheckOnCode<BracesAroundStatementsCheck>(
406                 "int main() {\n"
407                 "  do if (true) {}while (false);\n"
408                 "}"));
409   EXPECT_EQ("int main() {\n"
410             "  do { if (true) {}} while (false);\n"
411             "}",
412             runCheckOnCode<BracesAroundStatementsCheck>(
413                 "int main() {\n"
414                 "  do if (true) {}while (false);\n"
415                 "}"));
416   EXPECT_EQ(
417       "int main() {\n"
418       "  if (true) {\n"
419       "    // comment\n"
420       "    if (false) {\n"
421       "      // comment\n"
422       "      /**/ ; // comment\n"
423       "    }\n"
424       "}\n"
425       "}",
426       runCheckOnCode<BracesAroundStatementsCheck>("int main() {\n"
427                                                   "  if (true)\n"
428                                                   "    // comment\n"
429                                                   "    if (false) {\n"
430                                                   "      // comment\n"
431                                                   "      /**/ ; // comment\n"
432                                                   "    }\n"
433                                                   "}"));
434 }
435 
436 TEST(BracesAroundStatementsCheck, Macros) {
437   EXPECT_NO_CHANGES(BracesAroundStatementsCheck,
438                     "#define IF(COND) if (COND) return -1;\n"
439                     "int main() {\n"
440                     "  IF(false)\n"
441                     "}");
442   EXPECT_NO_CHANGES(BracesAroundStatementsCheck,
443                     "#define FOR(COND) for (COND) return -1;\n"
444                     "int main() {\n"
445                     "  FOR(;;)\n"
446                     "}");
447 }
448 
449 } // namespace test
450 } // namespace tidy
451 } // namespace clang
452