1 //===- unittests/AST/CommentParser.cpp ------ Comment parser tests --------===//
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 "clang/AST/CommentParser.h"
11 #include "clang/AST/Comment.h"
12 #include "clang/AST/CommentCommandTraits.h"
13 #include "clang/AST/CommentLexer.h"
14 #include "clang/AST/CommentSema.h"
15 #include "clang/Basic/CommentOptions.h"
16 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/DiagnosticOptions.h"
18 #include "clang/Basic/FileManager.h"
19 #include "clang/Basic/SourceManager.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/Support/Allocator.h"
22 #include "gtest/gtest.h"
23 
24 using namespace llvm;
25 using namespace clang;
26 
27 namespace clang {
28 namespace comments {
29 
30 namespace {
31 
32 const bool DEBUG = true;
33 
34 class CommentParserTest : public ::testing::Test {
35 protected:
36   CommentParserTest()
37     : FileMgr(FileMgrOpts),
38       DiagID(new DiagnosticIDs()),
39       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
40       SourceMgr(Diags, FileMgr),
41       Traits(Allocator, CommentOptions()) {
42   }
43 
44   FileSystemOptions FileMgrOpts;
45   FileManager FileMgr;
46   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
47   DiagnosticsEngine Diags;
48   SourceManager SourceMgr;
49   llvm::BumpPtrAllocator Allocator;
50   CommandTraits Traits;
51 
52   FullComment *parseString(const char *Source);
53 };
54 
55 FullComment *CommentParserTest::parseString(const char *Source) {
56   std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Source);
57   FileID File = SourceMgr.createFileID(std::move(Buf));
58   SourceLocation Begin = SourceMgr.getLocForStartOfFile(File);
59 
60   Lexer L(Allocator, Diags, Traits, Begin, Source, Source + strlen(Source));
61 
62   Sema S(Allocator, SourceMgr, Diags, Traits, /*PP=*/ nullptr);
63   Parser P(L, S, Allocator, SourceMgr, Diags, Traits);
64   FullComment *FC = P.parseFullComment();
65 
66   if (DEBUG) {
67     llvm::errs() << "=== Source:\n" << Source << "\n=== AST:\n";
68     FC->dump(llvm::errs(), &Traits, &SourceMgr);
69   }
70 
71   Token Tok;
72   L.lex(Tok);
73   if (Tok.is(tok::eof))
74     return FC;
75   else
76     return nullptr;
77 }
78 
79 ::testing::AssertionResult HasChildCount(const Comment *C, size_t Count) {
80   if (!C)
81     return ::testing::AssertionFailure() << "Comment is NULL";
82 
83   if (Count != C->child_count())
84     return ::testing::AssertionFailure()
85         << "Count = " << Count
86         << ", child_count = " << C->child_count();
87 
88   return ::testing::AssertionSuccess();
89 }
90 
91 template <typename T>
92 ::testing::AssertionResult GetChildAt(const Comment *C,
93                                       size_t Idx,
94                                       T *&Child) {
95   if (!C)
96     return ::testing::AssertionFailure() << "Comment is NULL";
97 
98   if (Idx >= C->child_count())
99     return ::testing::AssertionFailure()
100         << "Idx out of range.  Idx = " << Idx
101         << ", child_count = " << C->child_count();
102 
103   Comment::child_iterator I = C->child_begin() + Idx;
104   Comment *CommentChild = *I;
105   if (!CommentChild)
106     return ::testing::AssertionFailure() << "Child is NULL";
107 
108   Child = dyn_cast<T>(CommentChild);
109   if (!Child)
110     return ::testing::AssertionFailure()
111         << "Child is not of requested type, but a "
112         << CommentChild->getCommentKindName();
113 
114   return ::testing::AssertionSuccess();
115 }
116 
117 ::testing::AssertionResult HasTextAt(const Comment *C,
118                                      size_t Idx,
119                                      StringRef Text) {
120   TextComment *TC;
121   ::testing::AssertionResult AR = GetChildAt(C, Idx, TC);
122   if (!AR)
123     return AR;
124 
125   StringRef ActualText = TC->getText();
126   if (ActualText != Text)
127     return ::testing::AssertionFailure()
128         << "TextComment has text \"" << ActualText.str() << "\", "
129            "expected \"" << Text.str() << "\"";
130 
131   if (TC->hasTrailingNewline())
132     return ::testing::AssertionFailure()
133         << "TextComment has a trailing newline";
134 
135   return ::testing::AssertionSuccess();
136 }
137 
138 ::testing::AssertionResult HasTextWithNewlineAt(const Comment *C,
139                                                 size_t Idx,
140                                                 StringRef Text) {
141   TextComment *TC;
142   ::testing::AssertionResult AR = GetChildAt(C, Idx, TC);
143   if (!AR)
144     return AR;
145 
146   StringRef ActualText = TC->getText();
147   if (ActualText != Text)
148     return ::testing::AssertionFailure()
149         << "TextComment has text \"" << ActualText.str() << "\", "
150            "expected \"" << Text.str() << "\"";
151 
152   if (!TC->hasTrailingNewline())
153     return ::testing::AssertionFailure()
154         << "TextComment has no trailing newline";
155 
156   return ::testing::AssertionSuccess();
157 }
158 
159 ::testing::AssertionResult HasBlockCommandAt(const Comment *C,
160                                              const CommandTraits &Traits,
161                                              size_t Idx,
162                                              BlockCommandComment *&BCC,
163                                              StringRef Name,
164                                              ParagraphComment *&Paragraph) {
165   ::testing::AssertionResult AR = GetChildAt(C, Idx, BCC);
166   if (!AR)
167     return AR;
168 
169   StringRef ActualName = BCC->getCommandName(Traits);
170   if (ActualName != Name)
171     return ::testing::AssertionFailure()
172         << "BlockCommandComment has name \"" << ActualName.str() << "\", "
173            "expected \"" << Name.str() << "\"";
174 
175   Paragraph = BCC->getParagraph();
176 
177   return ::testing::AssertionSuccess();
178 }
179 
180 ::testing::AssertionResult HasParamCommandAt(
181                               const Comment *C,
182                               const CommandTraits &Traits,
183                               size_t Idx,
184                               ParamCommandComment *&PCC,
185                               StringRef CommandName,
186                               ParamCommandComment::PassDirection Direction,
187                               bool IsDirectionExplicit,
188                               StringRef ParamName,
189                               ParagraphComment *&Paragraph) {
190   ::testing::AssertionResult AR = GetChildAt(C, Idx, PCC);
191   if (!AR)
192     return AR;
193 
194   StringRef ActualCommandName = PCC->getCommandName(Traits);
195   if (ActualCommandName != CommandName)
196     return ::testing::AssertionFailure()
197         << "ParamCommandComment has name \"" << ActualCommandName.str() << "\", "
198            "expected \"" << CommandName.str() << "\"";
199 
200   if (PCC->getDirection() != Direction)
201     return ::testing::AssertionFailure()
202         << "ParamCommandComment has direction " << PCC->getDirection() << ", "
203            "expected " << Direction;
204 
205   if (PCC->isDirectionExplicit() != IsDirectionExplicit)
206     return ::testing::AssertionFailure()
207         << "ParamCommandComment has "
208         << (PCC->isDirectionExplicit() ? "explicit" : "implicit")
209         << " direction, "
210            "expected " << (IsDirectionExplicit ? "explicit" : "implicit");
211 
212   if (!ParamName.empty() && !PCC->hasParamName())
213     return ::testing::AssertionFailure()
214         << "ParamCommandComment has no parameter name";
215 
216   StringRef ActualParamName = PCC->hasParamName() ? PCC->getParamNameAsWritten() : "";
217   if (ActualParamName != ParamName)
218     return ::testing::AssertionFailure()
219         << "ParamCommandComment has parameter name \"" << ActualParamName.str()
220         << "\", "
221            "expected \"" << ParamName.str() << "\"";
222 
223   Paragraph = PCC->getParagraph();
224 
225   return ::testing::AssertionSuccess();
226 }
227 
228 ::testing::AssertionResult HasTParamCommandAt(
229                               const Comment *C,
230                               const CommandTraits &Traits,
231                               size_t Idx,
232                               TParamCommandComment *&TPCC,
233                               StringRef CommandName,
234                               StringRef ParamName,
235                               ParagraphComment *&Paragraph) {
236   ::testing::AssertionResult AR = GetChildAt(C, Idx, TPCC);
237   if (!AR)
238     return AR;
239 
240   StringRef ActualCommandName = TPCC->getCommandName(Traits);
241   if (ActualCommandName != CommandName)
242     return ::testing::AssertionFailure()
243         << "TParamCommandComment has name \"" << ActualCommandName.str() << "\", "
244            "expected \"" << CommandName.str() << "\"";
245 
246   if (!ParamName.empty() && !TPCC->hasParamName())
247     return ::testing::AssertionFailure()
248         << "TParamCommandComment has no parameter name";
249 
250   StringRef ActualParamName = TPCC->hasParamName() ? TPCC->getParamNameAsWritten() : "";
251   if (ActualParamName != ParamName)
252     return ::testing::AssertionFailure()
253         << "TParamCommandComment has parameter name \"" << ActualParamName.str()
254         << "\", "
255            "expected \"" << ParamName.str() << "\"";
256 
257   Paragraph = TPCC->getParagraph();
258 
259   return ::testing::AssertionSuccess();
260 }
261 
262 ::testing::AssertionResult HasInlineCommandAt(const Comment *C,
263                                               const CommandTraits &Traits,
264                                               size_t Idx,
265                                               InlineCommandComment *&ICC,
266                                               StringRef Name) {
267   ::testing::AssertionResult AR = GetChildAt(C, Idx, ICC);
268   if (!AR)
269     return AR;
270 
271   StringRef ActualName = ICC->getCommandName(Traits);
272   if (ActualName != Name)
273     return ::testing::AssertionFailure()
274         << "InlineCommandComment has name \"" << ActualName.str() << "\", "
275            "expected \"" << Name.str() << "\"";
276 
277   return ::testing::AssertionSuccess();
278 }
279 
280 struct NoArgs {};
281 
282 ::testing::AssertionResult HasInlineCommandAt(const Comment *C,
283                                               const CommandTraits &Traits,
284                                               size_t Idx,
285                                               InlineCommandComment *&ICC,
286                                               StringRef Name,
287                                               NoArgs) {
288   ::testing::AssertionResult AR = HasInlineCommandAt(C, Traits, Idx, ICC, Name);
289   if (!AR)
290     return AR;
291 
292   if (ICC->getNumArgs() != 0)
293     return ::testing::AssertionFailure()
294         << "InlineCommandComment has " << ICC->getNumArgs() << " arg(s), "
295            "expected 0";
296 
297   return ::testing::AssertionSuccess();
298 }
299 
300 ::testing::AssertionResult HasInlineCommandAt(const Comment *C,
301                                               const CommandTraits &Traits,
302                                               size_t Idx,
303                                               InlineCommandComment *&ICC,
304                                               StringRef Name,
305                                               StringRef Arg) {
306   ::testing::AssertionResult AR = HasInlineCommandAt(C, Traits, Idx, ICC, Name);
307   if (!AR)
308     return AR;
309 
310   if (ICC->getNumArgs() != 1)
311     return ::testing::AssertionFailure()
312         << "InlineCommandComment has " << ICC->getNumArgs() << " arg(s), "
313            "expected 1";
314 
315   StringRef ActualArg = ICC->getArgText(0);
316   if (ActualArg != Arg)
317     return ::testing::AssertionFailure()
318         << "InlineCommandComment has argument \"" << ActualArg.str() << "\", "
319            "expected \"" << Arg.str() << "\"";
320 
321   return ::testing::AssertionSuccess();
322 }
323 
324 ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C,
325                                              size_t Idx,
326                                              HTMLStartTagComment *&HST,
327                                              StringRef TagName) {
328   ::testing::AssertionResult AR = GetChildAt(C, Idx, HST);
329   if (!AR)
330     return AR;
331 
332   StringRef ActualTagName = HST->getTagName();
333   if (ActualTagName != TagName)
334     return ::testing::AssertionFailure()
335         << "HTMLStartTagComment has name \"" << ActualTagName.str() << "\", "
336            "expected \"" << TagName.str() << "\"";
337 
338   return ::testing::AssertionSuccess();
339 }
340 
341 struct SelfClosing {};
342 
343 ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C,
344                                              size_t Idx,
345                                              HTMLStartTagComment *&HST,
346                                              StringRef TagName,
347                                              SelfClosing) {
348   ::testing::AssertionResult AR = HasHTMLStartTagAt(C, Idx, HST, TagName);
349   if (!AR)
350     return AR;
351 
352   if (!HST->isSelfClosing())
353     return ::testing::AssertionFailure()
354         << "HTMLStartTagComment is not self-closing";
355 
356   return ::testing::AssertionSuccess();
357 }
358 
359 
360 struct NoAttrs {};
361 
362 ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C,
363                                              size_t Idx,
364                                              HTMLStartTagComment *&HST,
365                                              StringRef TagName,
366                                              NoAttrs) {
367   ::testing::AssertionResult AR = HasHTMLStartTagAt(C, Idx, HST, TagName);
368   if (!AR)
369     return AR;
370 
371   if (HST->isSelfClosing())
372     return ::testing::AssertionFailure()
373         << "HTMLStartTagComment is self-closing";
374 
375   if (HST->getNumAttrs() != 0)
376     return ::testing::AssertionFailure()
377         << "HTMLStartTagComment has " << HST->getNumAttrs() << " attr(s), "
378            "expected 0";
379 
380   return ::testing::AssertionSuccess();
381 }
382 
383 ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C,
384                                              size_t Idx,
385                                              HTMLStartTagComment *&HST,
386                                              StringRef TagName,
387                                              StringRef AttrName,
388                                              StringRef AttrValue) {
389   ::testing::AssertionResult AR = HasHTMLStartTagAt(C, Idx, HST, TagName);
390   if (!AR)
391     return AR;
392 
393   if (HST->isSelfClosing())
394     return ::testing::AssertionFailure()
395         << "HTMLStartTagComment is self-closing";
396 
397   if (HST->getNumAttrs() != 1)
398     return ::testing::AssertionFailure()
399         << "HTMLStartTagComment has " << HST->getNumAttrs() << " attr(s), "
400            "expected 1";
401 
402   StringRef ActualName = HST->getAttr(0).Name;
403   if (ActualName != AttrName)
404     return ::testing::AssertionFailure()
405         << "HTMLStartTagComment has attr \"" << ActualName.str() << "\", "
406            "expected \"" << AttrName.str() << "\"";
407 
408   StringRef ActualValue = HST->getAttr(0).Value;
409   if (ActualValue != AttrValue)
410     return ::testing::AssertionFailure()
411         << "HTMLStartTagComment has attr value \"" << ActualValue.str() << "\", "
412            "expected \"" << AttrValue.str() << "\"";
413 
414   return ::testing::AssertionSuccess();
415 }
416 
417 ::testing::AssertionResult HasHTMLEndTagAt(const Comment *C,
418                                            size_t Idx,
419                                            HTMLEndTagComment *&HET,
420                                            StringRef TagName) {
421   ::testing::AssertionResult AR = GetChildAt(C, Idx, HET);
422   if (!AR)
423     return AR;
424 
425   StringRef ActualTagName = HET->getTagName();
426   if (ActualTagName != TagName)
427     return ::testing::AssertionFailure()
428         << "HTMLEndTagComment has name \"" << ActualTagName.str() << "\", "
429            "expected \"" << TagName.str() << "\"";
430 
431   return ::testing::AssertionSuccess();
432 }
433 
434 ::testing::AssertionResult HasParagraphCommentAt(const Comment *C,
435                                                  size_t Idx,
436                                                  StringRef Text) {
437   ParagraphComment *PC;
438 
439   {
440     ::testing::AssertionResult AR = GetChildAt(C, Idx, PC);
441     if (!AR)
442       return AR;
443   }
444 
445   {
446     ::testing::AssertionResult AR = HasChildCount(PC, 1);
447     if (!AR)
448       return AR;
449   }
450 
451   {
452     ::testing::AssertionResult AR = HasTextAt(PC, 0, Text);
453     if (!AR)
454       return AR;
455   }
456 
457   return ::testing::AssertionSuccess();
458 }
459 
460 ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C,
461                                               const CommandTraits &Traits,
462                                               size_t Idx,
463                                               VerbatimBlockComment *&VBC,
464                                               StringRef Name,
465                                               StringRef CloseName) {
466   ::testing::AssertionResult AR = GetChildAt(C, Idx, VBC);
467   if (!AR)
468     return AR;
469 
470   StringRef ActualName = VBC->getCommandName(Traits);
471   if (ActualName != Name)
472     return ::testing::AssertionFailure()
473         << "VerbatimBlockComment has name \"" << ActualName.str() << "\", "
474            "expected \"" << Name.str() << "\"";
475 
476   StringRef ActualCloseName = VBC->getCloseName();
477   if (ActualCloseName != CloseName)
478     return ::testing::AssertionFailure()
479         << "VerbatimBlockComment has closing command name \""
480         << ActualCloseName.str() << "\", "
481            "expected \"" << CloseName.str() << "\"";
482 
483   return ::testing::AssertionSuccess();
484 }
485 
486 struct NoLines {};
487 struct Lines {};
488 
489 ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C,
490                                               const CommandTraits &Traits,
491                                               size_t Idx,
492                                               VerbatimBlockComment *&VBC,
493                                               StringRef Name,
494                                               StringRef CloseName,
495                                               NoLines) {
496   ::testing::AssertionResult AR = HasVerbatimBlockAt(C, Traits, Idx, VBC, Name,
497                                                      CloseName);
498   if (!AR)
499     return AR;
500 
501   if (VBC->getNumLines() != 0)
502     return ::testing::AssertionFailure()
503         << "VerbatimBlockComment has " << VBC->getNumLines() << " lines(s), "
504            "expected 0";
505 
506   return ::testing::AssertionSuccess();
507 }
508 
509 ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C,
510                                               const CommandTraits &Traits,
511                                               size_t Idx,
512                                               VerbatimBlockComment *&VBC,
513                                               StringRef Name,
514                                               StringRef CloseName,
515                                               Lines,
516                                               StringRef Line0) {
517   ::testing::AssertionResult AR = HasVerbatimBlockAt(C, Traits, Idx, VBC, Name,
518                                                      CloseName);
519   if (!AR)
520     return AR;
521 
522   if (VBC->getNumLines() != 1)
523     return ::testing::AssertionFailure()
524         << "VerbatimBlockComment has " << VBC->getNumLines() << " lines(s), "
525            "expected 1";
526 
527   StringRef ActualLine0 = VBC->getText(0);
528   if (ActualLine0 != Line0)
529     return ::testing::AssertionFailure()
530         << "VerbatimBlockComment has lines[0] \"" << ActualLine0.str() << "\", "
531            "expected \"" << Line0.str() << "\"";
532 
533   return ::testing::AssertionSuccess();
534 }
535 
536 ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C,
537                                               const CommandTraits &Traits,
538                                               size_t Idx,
539                                               VerbatimBlockComment *&VBC,
540                                               StringRef Name,
541                                               StringRef CloseName,
542                                               Lines,
543                                               StringRef Line0,
544                                               StringRef Line1) {
545   ::testing::AssertionResult AR = HasVerbatimBlockAt(C, Traits, Idx, VBC, Name,
546                                                      CloseName);
547   if (!AR)
548     return AR;
549 
550   if (VBC->getNumLines() != 2)
551     return ::testing::AssertionFailure()
552         << "VerbatimBlockComment has " << VBC->getNumLines() << " lines(s), "
553            "expected 2";
554 
555   StringRef ActualLine0 = VBC->getText(0);
556   if (ActualLine0 != Line0)
557     return ::testing::AssertionFailure()
558         << "VerbatimBlockComment has lines[0] \"" << ActualLine0.str() << "\", "
559            "expected \"" << Line0.str() << "\"";
560 
561   StringRef ActualLine1 = VBC->getText(1);
562   if (ActualLine1 != Line1)
563     return ::testing::AssertionFailure()
564         << "VerbatimBlockComment has lines[1] \"" << ActualLine1.str() << "\", "
565            "expected \"" << Line1.str() << "\"";
566 
567   return ::testing::AssertionSuccess();
568 }
569 
570 ::testing::AssertionResult HasVerbatimLineAt(const Comment *C,
571                                              const CommandTraits &Traits,
572                                              size_t Idx,
573                                              VerbatimLineComment *&VLC,
574                                              StringRef Name,
575                                              StringRef Text) {
576   ::testing::AssertionResult AR = GetChildAt(C, Idx, VLC);
577   if (!AR)
578     return AR;
579 
580   StringRef ActualName = VLC->getCommandName(Traits);
581   if (ActualName != Name)
582     return ::testing::AssertionFailure()
583         << "VerbatimLineComment has name \"" << ActualName.str() << "\", "
584            "expected \"" << Name.str() << "\"";
585 
586   StringRef ActualText = VLC->getText();
587   if (ActualText != Text)
588     return ::testing::AssertionFailure()
589         << "VerbatimLineComment has text \"" << ActualText.str() << "\", "
590            "expected \"" << Text.str() << "\"";
591 
592   return ::testing::AssertionSuccess();
593 }
594 
595 
596 TEST_F(CommentParserTest, Basic1) {
597   const char *Source = "//";
598 
599   FullComment *FC = parseString(Source);
600   ASSERT_TRUE(HasChildCount(FC, 0));
601 }
602 
603 TEST_F(CommentParserTest, Basic2) {
604   const char *Source = "// Meow";
605 
606   FullComment *FC = parseString(Source);
607   ASSERT_TRUE(HasChildCount(FC, 1));
608 
609   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Meow"));
610 }
611 
612 TEST_F(CommentParserTest, Basic3) {
613   const char *Source =
614     "// Aaa\n"
615     "// Bbb";
616 
617   FullComment *FC = parseString(Source);
618   ASSERT_TRUE(HasChildCount(FC, 1));
619 
620   {
621     ParagraphComment *PC;
622     ASSERT_TRUE(GetChildAt(FC, 0, PC));
623 
624     ASSERT_TRUE(HasChildCount(PC, 2));
625       ASSERT_TRUE(HasTextWithNewlineAt(PC, 0, " Aaa"));
626       ASSERT_TRUE(HasTextAt(PC, 1, " Bbb"));
627   }
628 }
629 
630 TEST_F(CommentParserTest, ParagraphSplitting1) {
631   const char *Sources[] = {
632     "// Aaa\n"
633     "//\n"
634     "// Bbb",
635 
636     "// Aaa\n"
637     "// \n"
638     "// Bbb",
639 
640     "// Aaa\n"
641     "//\t\n"
642     "// Bbb",
643 
644     "// Aaa\n"
645     "//\n"
646     "//\n"
647     "// Bbb",
648 
649     "/**\n"
650     " Aaa\n"
651     "\n"
652     " Bbb\n"
653     "*/",
654 
655     "/**\n"
656     " Aaa\n"
657     " \n"
658     " Bbb\n"
659     "*/",
660 
661     "/**\n"
662     " Aaa\n"
663     "\t \n"
664     " Bbb\n"
665     "*/",
666   };
667 
668   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
669     FullComment *FC = parseString(Sources[i]);
670     ASSERT_TRUE(HasChildCount(FC, 2));
671 
672     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Aaa"));
673     ASSERT_TRUE(HasParagraphCommentAt(FC, 1, " Bbb"));
674   }
675 }
676 
677 TEST_F(CommentParserTest, Paragraph1) {
678   const char *Source =
679     "// \\brief Aaa\n"
680     "//\n"
681     "// Bbb";
682 
683   FullComment *FC = parseString(Source);
684   ASSERT_TRUE(HasChildCount(FC, 3));
685 
686   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
687   {
688     BlockCommandComment *BCC;
689     ParagraphComment *PC;
690     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC));
691 
692     ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " Aaa"));
693   }
694   ASSERT_TRUE(HasParagraphCommentAt(FC, 2, " Bbb"));
695 }
696 
697 TEST_F(CommentParserTest, Paragraph2) {
698   const char *Source = "// \\brief \\author";
699 
700   FullComment *FC = parseString(Source);
701   ASSERT_TRUE(HasChildCount(FC, 3));
702 
703   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
704   {
705     BlockCommandComment *BCC;
706     ParagraphComment *PC;
707     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC));
708 
709     ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " "));
710   }
711   {
712     BlockCommandComment *BCC;
713     ParagraphComment *PC;
714     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "author", PC));
715 
716     ASSERT_TRUE(GetChildAt(BCC, 0, PC));
717       ASSERT_TRUE(HasChildCount(PC, 0));
718   }
719 }
720 
721 TEST_F(CommentParserTest, Paragraph3) {
722   const char *Source =
723     "// \\brief Aaa\n"
724     "// Bbb \\author\n"
725     "// Ccc";
726 
727   FullComment *FC = parseString(Source);
728   ASSERT_TRUE(HasChildCount(FC, 3));
729 
730   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
731   {
732     BlockCommandComment *BCC;
733     ParagraphComment *PC;
734     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC));
735 
736     ASSERT_TRUE(GetChildAt(BCC, 0, PC));
737       ASSERT_TRUE(HasChildCount(PC, 2));
738       ASSERT_TRUE(HasTextWithNewlineAt(PC, 0, " Aaa"));
739       ASSERT_TRUE(HasTextAt(PC, 1, " Bbb "));
740   }
741   {
742     BlockCommandComment *BCC;
743     ParagraphComment *PC;
744     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "author", PC));
745 
746     ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " Ccc"));
747   }
748 }
749 
750 TEST_F(CommentParserTest, ParamCommand1) {
751   const char *Source = "// \\param aaa";
752 
753   FullComment *FC = parseString(Source);
754   ASSERT_TRUE(HasChildCount(FC, 2));
755 
756   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
757   {
758     ParamCommandComment *PCC;
759     ParagraphComment *PC;
760     ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
761                                   ParamCommandComment::In,
762                                   /* IsDirectionExplicit = */ false,
763                                   "aaa", PC));
764     ASSERT_TRUE(HasChildCount(PCC, 1));
765     ASSERT_TRUE(HasChildCount(PC, 0));
766   }
767 }
768 
769 TEST_F(CommentParserTest, ParamCommand2) {
770   const char *Source = "// \\param\\brief";
771 
772   FullComment *FC = parseString(Source);
773   ASSERT_TRUE(HasChildCount(FC, 3));
774 
775   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
776   {
777     ParamCommandComment *PCC;
778     ParagraphComment *PC;
779     ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
780                                   ParamCommandComment::In,
781                                   /* IsDirectionExplicit = */ false,
782                                   "", PC));
783     ASSERT_TRUE(HasChildCount(PCC, 1));
784     ASSERT_TRUE(HasChildCount(PC, 0));
785   }
786   {
787     BlockCommandComment *BCC;
788     ParagraphComment *PC;
789     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "brief", PC));
790     ASSERT_TRUE(HasChildCount(PC, 0));
791   }
792 }
793 
794 TEST_F(CommentParserTest, ParamCommand3) {
795   const char *Sources[] = {
796     "// \\param aaa Bbb\n",
797     "// \\param\n"
798     "//     aaa Bbb\n",
799     "// \\param \n"
800     "//     aaa Bbb\n",
801     "// \\param aaa\n"
802     "// Bbb\n"
803   };
804 
805   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
806     FullComment *FC = parseString(Sources[i]);
807     ASSERT_TRUE(HasChildCount(FC, 2));
808 
809     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
810     {
811       ParamCommandComment *PCC;
812       ParagraphComment *PC;
813       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
814                                     ParamCommandComment::In,
815                                     /* IsDirectionExplicit = */ false,
816                                     "aaa", PC));
817       ASSERT_TRUE(HasChildCount(PCC, 1));
818       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
819     }
820   }
821 }
822 
823 TEST_F(CommentParserTest, ParamCommand4) {
824   const char *Sources[] = {
825     "// \\param [in] aaa Bbb\n",
826     "// \\param[in] aaa Bbb\n",
827     "// \\param\n"
828     "//     [in] aaa Bbb\n",
829     "// \\param [in]\n"
830     "//     aaa Bbb\n",
831     "// \\param [in] aaa\n"
832     "// Bbb\n",
833   };
834 
835   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
836     FullComment *FC = parseString(Sources[i]);
837     ASSERT_TRUE(HasChildCount(FC, 2));
838 
839     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
840     {
841       ParamCommandComment *PCC;
842       ParagraphComment *PC;
843       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
844                                     ParamCommandComment::In,
845                                     /* IsDirectionExplicit = */ true,
846                                     "aaa", PC));
847       ASSERT_TRUE(HasChildCount(PCC, 1));
848       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
849     }
850   }
851 }
852 
853 TEST_F(CommentParserTest, ParamCommand5) {
854   const char *Sources[] = {
855     "// \\param [out] aaa Bbb\n",
856     "// \\param[out] aaa Bbb\n",
857     "// \\param\n"
858     "//     [out] aaa Bbb\n",
859     "// \\param [out]\n"
860     "//     aaa Bbb\n",
861     "// \\param [out] aaa\n"
862     "// Bbb\n",
863   };
864 
865   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
866     FullComment *FC = parseString(Sources[i]);
867     ASSERT_TRUE(HasChildCount(FC, 2));
868 
869     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
870     {
871       ParamCommandComment *PCC;
872       ParagraphComment *PC;
873       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
874                                     ParamCommandComment::Out,
875                                     /* IsDirectionExplicit = */ true,
876                                     "aaa", PC));
877       ASSERT_TRUE(HasChildCount(PCC, 1));
878       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
879     }
880   }
881 }
882 
883 TEST_F(CommentParserTest, ParamCommand6) {
884   const char *Sources[] = {
885     "// \\param [in,out] aaa Bbb\n",
886     "// \\param[in,out] aaa Bbb\n",
887     "// \\param [in, out] aaa Bbb\n",
888     "// \\param [in,\n"
889     "//     out] aaa Bbb\n",
890     "// \\param [in,out]\n"
891     "//     aaa Bbb\n",
892     "// \\param [in,out] aaa\n"
893     "// Bbb\n"
894   };
895 
896   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
897     FullComment *FC = parseString(Sources[i]);
898     ASSERT_TRUE(HasChildCount(FC, 2));
899 
900     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
901     {
902       ParamCommandComment *PCC;
903       ParagraphComment *PC;
904       ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
905                                     ParamCommandComment::InOut,
906                                     /* IsDirectionExplicit = */ true,
907                                     "aaa", PC));
908       ASSERT_TRUE(HasChildCount(PCC, 1));
909       ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb"));
910     }
911   }
912 }
913 
914 TEST_F(CommentParserTest, ParamCommand7) {
915   const char *Source =
916     "// \\param aaa \\% Bbb \\$ ccc\n";
917 
918   FullComment *FC = parseString(Source);
919   ASSERT_TRUE(HasChildCount(FC, 2));
920 
921   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
922   {
923     ParamCommandComment *PCC;
924     ParagraphComment *PC;
925     ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param",
926                                   ParamCommandComment::In,
927                                   /* IsDirectionExplicit = */ false,
928                                   "aaa", PC));
929     ASSERT_TRUE(HasChildCount(PCC, 1));
930 
931     ASSERT_TRUE(HasChildCount(PC, 5));
932       ASSERT_TRUE(HasTextAt(PC, 0, " "));
933       ASSERT_TRUE(HasTextAt(PC, 1, "%"));
934       ASSERT_TRUE(HasTextAt(PC, 2, " Bbb "));
935       ASSERT_TRUE(HasTextAt(PC, 3, "$"));
936       ASSERT_TRUE(HasTextAt(PC, 4, " ccc"));
937   }
938 }
939 
940 TEST_F(CommentParserTest, TParamCommand1) {
941   const char *Sources[] = {
942     "// \\tparam aaa Bbb\n",
943     "// \\tparam\n"
944     "//     aaa Bbb\n",
945     "// \\tparam \n"
946     "//     aaa Bbb\n",
947     "// \\tparam aaa\n"
948     "// Bbb\n"
949   };
950 
951   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
952     FullComment *FC = parseString(Sources[i]);
953     ASSERT_TRUE(HasChildCount(FC, 2));
954 
955     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
956     {
957       TParamCommandComment *TPCC;
958       ParagraphComment *PC;
959       ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam",
960                                      "aaa", PC));
961       ASSERT_TRUE(HasChildCount(TPCC, 1));
962       ASSERT_TRUE(HasParagraphCommentAt(TPCC, 0, " Bbb"));
963     }
964   }
965 }
966 
967 TEST_F(CommentParserTest, TParamCommand2) {
968   const char *Source = "// \\tparam\\brief";
969 
970   FullComment *FC = parseString(Source);
971   ASSERT_TRUE(HasChildCount(FC, 3));
972 
973   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
974   {
975     TParamCommandComment *TPCC;
976     ParagraphComment *PC;
977     ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam", "", PC));
978     ASSERT_TRUE(HasChildCount(TPCC, 1));
979     ASSERT_TRUE(HasChildCount(PC, 0));
980   }
981   {
982     BlockCommandComment *BCC;
983     ParagraphComment *PC;
984     ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "brief", PC));
985     ASSERT_TRUE(HasChildCount(PC, 0));
986   }
987 }
988 
989 
990 TEST_F(CommentParserTest, InlineCommand1) {
991   const char *Source = "// \\c";
992 
993   FullComment *FC = parseString(Source);
994   ASSERT_TRUE(HasChildCount(FC, 1));
995 
996   {
997     ParagraphComment *PC;
998     InlineCommandComment *ICC;
999     ASSERT_TRUE(GetChildAt(FC, 0, PC));
1000 
1001     ASSERT_TRUE(HasChildCount(PC, 2));
1002       ASSERT_TRUE(HasTextAt(PC, 0, " "));
1003       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", NoArgs()));
1004   }
1005 }
1006 
1007 TEST_F(CommentParserTest, InlineCommand2) {
1008   const char *Source = "// \\c ";
1009 
1010   FullComment *FC = parseString(Source);
1011   ASSERT_TRUE(HasChildCount(FC, 1));
1012 
1013   {
1014     ParagraphComment *PC;
1015     InlineCommandComment *ICC;
1016     ASSERT_TRUE(GetChildAt(FC, 0, PC));
1017 
1018     ASSERT_TRUE(HasChildCount(PC, 3));
1019       ASSERT_TRUE(HasTextAt(PC, 0, " "));
1020       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", NoArgs()));
1021       ASSERT_TRUE(HasTextAt(PC, 2, " "));
1022   }
1023 }
1024 
1025 TEST_F(CommentParserTest, InlineCommand3) {
1026   const char *Source = "// \\c aaa\n";
1027 
1028   FullComment *FC = parseString(Source);
1029   ASSERT_TRUE(HasChildCount(FC, 1));
1030 
1031   {
1032     ParagraphComment *PC;
1033     InlineCommandComment *ICC;
1034     ASSERT_TRUE(GetChildAt(FC, 0, PC));
1035 
1036     ASSERT_TRUE(HasChildCount(PC, 2));
1037       ASSERT_TRUE(HasTextAt(PC, 0, " "));
1038       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", "aaa"));
1039   }
1040 }
1041 
1042 TEST_F(CommentParserTest, InlineCommand4) {
1043   const char *Source = "// \\c aaa bbb";
1044 
1045   FullComment *FC = parseString(Source);
1046   ASSERT_TRUE(HasChildCount(FC, 1));
1047 
1048   {
1049     ParagraphComment *PC;
1050     InlineCommandComment *ICC;
1051     ASSERT_TRUE(GetChildAt(FC, 0, PC));
1052 
1053     ASSERT_TRUE(HasChildCount(PC, 3));
1054       ASSERT_TRUE(HasTextAt(PC, 0, " "));
1055       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", "aaa"));
1056       ASSERT_TRUE(HasTextAt(PC, 2, " bbb"));
1057   }
1058 }
1059 
1060 TEST_F(CommentParserTest, InlineCommand5) {
1061   const char *Source = "// \\unknown aaa\n";
1062 
1063   FullComment *FC = parseString(Source);
1064   ASSERT_TRUE(HasChildCount(FC, 1));
1065 
1066   {
1067     ParagraphComment *PC;
1068     InlineCommandComment *ICC;
1069     ASSERT_TRUE(GetChildAt(FC, 0, PC));
1070 
1071     ASSERT_TRUE(HasChildCount(PC, 3));
1072       ASSERT_TRUE(HasTextAt(PC, 0, " "));
1073       ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "unknown", NoArgs()));
1074       ASSERT_TRUE(HasTextAt(PC, 2, " aaa"));
1075   }
1076 }
1077 
1078 TEST_F(CommentParserTest, HTML1) {
1079   const char *Sources[] = {
1080     "// <a",
1081     "// <a>",
1082     "// <a >"
1083   };
1084 
1085   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1086     FullComment *FC = parseString(Sources[i]);
1087     ASSERT_TRUE(HasChildCount(FC, 1));
1088 
1089     {
1090       ParagraphComment *PC;
1091       HTMLStartTagComment *HST;
1092       ASSERT_TRUE(GetChildAt(FC, 0, PC));
1093 
1094       ASSERT_TRUE(HasChildCount(PC, 2));
1095         ASSERT_TRUE(HasTextAt(PC, 0, " "));
1096         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", NoAttrs()));
1097     }
1098   }
1099 }
1100 
1101 TEST_F(CommentParserTest, HTML2) {
1102   const char *Sources[] = {
1103     "// <br/>",
1104     "// <br />"
1105   };
1106 
1107   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1108     FullComment *FC = parseString(Sources[i]);
1109     ASSERT_TRUE(HasChildCount(FC, 1));
1110 
1111     {
1112       ParagraphComment *PC;
1113       HTMLStartTagComment *HST;
1114       ASSERT_TRUE(GetChildAt(FC, 0, PC));
1115 
1116       ASSERT_TRUE(HasChildCount(PC, 2));
1117         ASSERT_TRUE(HasTextAt(PC, 0, " "));
1118         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "br", SelfClosing()));
1119     }
1120   }
1121 }
1122 
1123 TEST_F(CommentParserTest, HTML3) {
1124   const char *Sources[] = {
1125     "// <a href",
1126     "// <a href ",
1127     "// <a href>",
1128     "// <a href >",
1129   };
1130 
1131   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1132     FullComment *FC = parseString(Sources[i]);
1133     ASSERT_TRUE(HasChildCount(FC, 1));
1134 
1135     {
1136       ParagraphComment *PC;
1137       HTMLStartTagComment *HST;
1138       ASSERT_TRUE(GetChildAt(FC, 0, PC));
1139 
1140       ASSERT_TRUE(HasChildCount(PC, 2));
1141         ASSERT_TRUE(HasTextAt(PC, 0, " "));
1142         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", ""));
1143     }
1144   }
1145 }
1146 
1147 TEST_F(CommentParserTest, HTML4) {
1148   const char *Sources[] = {
1149     "// <a href=\"bbb\"",
1150     "// <a href=\"bbb\">",
1151   };
1152 
1153   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1154     FullComment *FC = parseString(Sources[i]);
1155     ASSERT_TRUE(HasChildCount(FC, 1));
1156 
1157     {
1158       ParagraphComment *PC;
1159       HTMLStartTagComment *HST;
1160       ASSERT_TRUE(GetChildAt(FC, 0, PC));
1161 
1162       ASSERT_TRUE(HasChildCount(PC, 2));
1163         ASSERT_TRUE(HasTextAt(PC, 0, " "));
1164         ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", "bbb"));
1165     }
1166   }
1167 }
1168 
1169 TEST_F(CommentParserTest, HTML5) {
1170   const char *Sources[] = {
1171     "// </a",
1172     "// </a>",
1173     "// </a >"
1174   };
1175 
1176   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1177     FullComment *FC = parseString(Sources[i]);
1178     ASSERT_TRUE(HasChildCount(FC, 1));
1179 
1180     {
1181       ParagraphComment *PC;
1182       HTMLEndTagComment *HET;
1183       ASSERT_TRUE(GetChildAt(FC, 0, PC));
1184 
1185       ASSERT_TRUE(HasChildCount(PC, 2));
1186         ASSERT_TRUE(HasTextAt(PC, 0, " "));
1187         ASSERT_TRUE(HasHTMLEndTagAt(PC, 1, HET, "a"));
1188     }
1189   }
1190 }
1191 
1192 TEST_F(CommentParserTest, HTML6) {
1193   const char *Source =
1194     "// <pre>\n"
1195     "// Aaa\n"
1196     "// Bbb\n"
1197     "// </pre>\n";
1198 
1199   FullComment *FC = parseString(Source);
1200   ASSERT_TRUE(HasChildCount(FC, 1));
1201 
1202   {
1203     ParagraphComment *PC;
1204     HTMLStartTagComment *HST;
1205     HTMLEndTagComment *HET;
1206     ASSERT_TRUE(GetChildAt(FC, 0, PC));
1207 
1208     ASSERT_TRUE(HasChildCount(PC, 6));
1209       ASSERT_TRUE(HasTextAt(PC, 0, " "));
1210       ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "pre", NoAttrs()));
1211       ASSERT_TRUE(HasTextWithNewlineAt(PC, 2, " Aaa"));
1212       ASSERT_TRUE(HasTextWithNewlineAt(PC, 3, " Bbb"));
1213       ASSERT_TRUE(HasTextAt(PC, 4, " "));
1214       ASSERT_TRUE(HasHTMLEndTagAt(PC, 5, HET, "pre"));
1215   }
1216 }
1217 
1218 TEST_F(CommentParserTest, VerbatimBlock1) {
1219   const char *Source = "// \\verbatim\\endverbatim\n";
1220 
1221   FullComment *FC = parseString(Source);
1222   ASSERT_TRUE(HasChildCount(FC, 2));
1223 
1224   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1225   {
1226     VerbatimBlockComment *VCC;
1227     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VCC,
1228                                    "verbatim", "endverbatim",
1229                                    NoLines()));
1230   }
1231 }
1232 
1233 TEST_F(CommentParserTest, VerbatimBlock2) {
1234   const char *Source = "// \\verbatim Aaa \\endverbatim\n";
1235 
1236   FullComment *FC = parseString(Source);
1237   ASSERT_TRUE(HasChildCount(FC, 2));
1238 
1239   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1240   {
1241     VerbatimBlockComment *VBC;
1242     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
1243                                    "verbatim", "endverbatim",
1244                                    Lines(), " Aaa "));
1245   }
1246 }
1247 
1248 TEST_F(CommentParserTest, VerbatimBlock3) {
1249   const char *Source = "// \\verbatim Aaa\n";
1250 
1251   FullComment *FC = parseString(Source);
1252   ASSERT_TRUE(HasChildCount(FC, 2));
1253 
1254   ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1255   {
1256     VerbatimBlockComment *VBC;
1257     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, "verbatim", "",
1258                                    Lines(), " Aaa"));
1259   }
1260 }
1261 
1262 TEST_F(CommentParserTest, VerbatimBlock4) {
1263   const char *Source =
1264     "//\\verbatim\n"
1265     "//\\endverbatim\n";
1266 
1267   FullComment *FC = parseString(Source);
1268   ASSERT_TRUE(HasChildCount(FC, 1));
1269 
1270   {
1271     VerbatimBlockComment *VBC;
1272     ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC,
1273                                    "verbatim", "endverbatim",
1274                                    NoLines()));
1275   }
1276 }
1277 
1278 TEST_F(CommentParserTest, VerbatimBlock5) {
1279   const char *Sources[] = {
1280     "//\\verbatim\n"
1281     "// Aaa\n"
1282     "//\\endverbatim\n",
1283 
1284     "/*\\verbatim\n"
1285     " * Aaa\n"
1286     " *\\endverbatim*/"
1287   };
1288 
1289   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1290     FullComment *FC = parseString(Sources[i]);
1291     ASSERT_TRUE(HasChildCount(FC, 1));
1292 
1293     {
1294       VerbatimBlockComment *VBC;
1295       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC,
1296                                      "verbatim", "endverbatim",
1297                                      Lines(), " Aaa"));
1298     }
1299   }
1300 }
1301 
1302 TEST_F(CommentParserTest, VerbatimBlock6) {
1303   const char *Sources[] = {
1304     "// \\verbatim\n"
1305     "// Aaa\n"
1306     "// \\endverbatim\n",
1307 
1308     "/* \\verbatim\n"
1309     " * Aaa\n"
1310     " * \\endverbatim*/"
1311   };
1312 
1313   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1314     FullComment *FC = parseString(Sources[i]);
1315     ASSERT_TRUE(HasChildCount(FC, 2));
1316 
1317     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1318     {
1319       VerbatimBlockComment *VBC;
1320       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
1321                                      "verbatim", "endverbatim",
1322                                      Lines(), " Aaa"));
1323     }
1324   }
1325 }
1326 
1327 TEST_F(CommentParserTest, VerbatimBlock7) {
1328   const char *Sources[] = {
1329     "// \\verbatim\n"
1330     "// Aaa\n"
1331     "// Bbb\n"
1332     "// \\endverbatim\n",
1333 
1334     "/* \\verbatim\n"
1335     " * Aaa\n"
1336     " * Bbb\n"
1337     " * \\endverbatim*/"
1338   };
1339 
1340   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1341     FullComment *FC = parseString(Sources[i]);
1342     ASSERT_TRUE(HasChildCount(FC, 2));
1343 
1344     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1345     {
1346       VerbatimBlockComment *VBC;
1347       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
1348                                      "verbatim", "endverbatim",
1349                                      Lines(), " Aaa", " Bbb"));
1350     }
1351   }
1352 }
1353 
1354 TEST_F(CommentParserTest, VerbatimBlock8) {
1355   const char *Sources[] = {
1356     "// \\verbatim\n"
1357     "// Aaa\n"
1358     "//\n"
1359     "// Bbb\n"
1360     "// \\endverbatim\n",
1361 
1362     "/* \\verbatim\n"
1363     " * Aaa\n"
1364     " *\n"
1365     " * Bbb\n"
1366     " * \\endverbatim*/"
1367   };
1368   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1369     FullComment *FC = parseString(Sources[i]);
1370     ASSERT_TRUE(HasChildCount(FC, 2));
1371 
1372     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1373     {
1374       VerbatimBlockComment *VBC;
1375       ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC,
1376                                      "verbatim", "endverbatim"));
1377       ASSERT_EQ(3U, VBC->getNumLines());
1378       ASSERT_EQ(" Aaa", VBC->getText(0));
1379       ASSERT_EQ("",     VBC->getText(1));
1380       ASSERT_EQ(" Bbb", VBC->getText(2));
1381     }
1382   }
1383 }
1384 
1385 TEST_F(CommentParserTest, VerbatimLine1) {
1386   const char *Sources[] = {
1387     "// \\fn",
1388     "// \\fn\n"
1389   };
1390 
1391   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1392     FullComment *FC = parseString(Sources[i]);
1393     ASSERT_TRUE(HasChildCount(FC, 2));
1394 
1395     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1396     {
1397       VerbatimLineComment *VLC;
1398       ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn", ""));
1399     }
1400   }
1401 }
1402 
1403 TEST_F(CommentParserTest, VerbatimLine2) {
1404   const char *Sources[] = {
1405     "/// \\fn void *foo(const char *zzz = \"\\$\");\n//",
1406     "/** \\fn void *foo(const char *zzz = \"\\$\");*/"
1407   };
1408 
1409   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1410     FullComment *FC = parseString(Sources[i]);
1411     ASSERT_TRUE(HasChildCount(FC, 2));
1412 
1413     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1414     {
1415       VerbatimLineComment *VLC;
1416       ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn",
1417                   " void *foo(const char *zzz = \"\\$\");"));
1418     }
1419   }
1420 }
1421 
1422 TEST_F(CommentParserTest, Deprecated) {
1423   const char *Sources[] = {
1424     "/** @deprecated*/",
1425     "/// @deprecated\n"
1426   };
1427 
1428   for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) {
1429     FullComment *FC = parseString(Sources[i]);
1430     ASSERT_TRUE(HasChildCount(FC, 2));
1431 
1432     ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " "));
1433     {
1434       BlockCommandComment *BCC;
1435       ParagraphComment *PC;
1436       ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "deprecated", PC));
1437       ASSERT_TRUE(HasChildCount(PC, 0));
1438     }
1439   }
1440 }
1441 
1442 } // unnamed namespace
1443 
1444 } // end namespace comments
1445 } // end namespace clang
1446 
1447