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