| //===- unittests/AST/CommentParser.cpp ------ Comment parser tests --------===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/AST/CommentParser.h" |
| #include "clang/AST/Comment.h" |
| #include "clang/AST/CommentCommandTraits.h" |
| #include "clang/AST/CommentLexer.h" |
| #include "clang/AST/CommentSema.h" |
| #include "clang/Basic/CommentOptions.h" |
| #include "clang/Basic/Diagnostic.h" |
| #include "clang/Basic/DiagnosticOptions.h" |
| #include "clang/Basic/FileManager.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/Support/Allocator.h" |
| #include "gtest/gtest.h" |
| |
| using namespace llvm; |
| using namespace clang; |
| |
| namespace clang { |
| namespace comments { |
| |
| namespace { |
| |
| const bool DEBUG = true; |
| |
| class CommentParserTest : public ::testing::Test { |
| protected: |
| CommentParserTest() |
| : FileMgr(FileMgrOpts), |
| DiagID(new DiagnosticIDs()), |
| Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()), |
| SourceMgr(Diags, FileMgr), |
| Traits(Allocator, CommentOptions()) { |
| } |
| |
| FileSystemOptions FileMgrOpts; |
| FileManager FileMgr; |
| IntrusiveRefCntPtr<DiagnosticIDs> DiagID; |
| DiagnosticsEngine Diags; |
| SourceManager SourceMgr; |
| llvm::BumpPtrAllocator Allocator; |
| CommandTraits Traits; |
| |
| FullComment *parseString(const char *Source); |
| }; |
| |
| FullComment *CommentParserTest::parseString(const char *Source) { |
| std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Source); |
| FileID File = SourceMgr.createFileID(std::move(Buf)); |
| SourceLocation Begin = SourceMgr.getLocForStartOfFile(File); |
| |
| Lexer L(Allocator, Diags, Traits, Begin, Source, Source + strlen(Source)); |
| |
| Sema S(Allocator, SourceMgr, Diags, Traits, /*PP=*/ nullptr); |
| Parser P(L, S, Allocator, SourceMgr, Diags, Traits); |
| FullComment *FC = P.parseFullComment(); |
| |
| if (DEBUG) { |
| llvm::errs() << "=== Source:\n" << Source << "\n=== AST:\n"; |
| FC->dump(llvm::errs(), &Traits, &SourceMgr); |
| } |
| |
| Token Tok; |
| L.lex(Tok); |
| if (Tok.is(tok::eof)) |
| return FC; |
| else |
| return nullptr; |
| } |
| |
| ::testing::AssertionResult HasChildCount(const Comment *C, size_t Count) { |
| if (!C) |
| return ::testing::AssertionFailure() << "Comment is NULL"; |
| |
| if (Count != C->child_count()) |
| return ::testing::AssertionFailure() |
| << "Count = " << Count |
| << ", child_count = " << C->child_count(); |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| template <typename T> |
| ::testing::AssertionResult GetChildAt(const Comment *C, |
| size_t Idx, |
| T *&Child) { |
| if (!C) |
| return ::testing::AssertionFailure() << "Comment is NULL"; |
| |
| if (Idx >= C->child_count()) |
| return ::testing::AssertionFailure() |
| << "Idx out of range. Idx = " << Idx |
| << ", child_count = " << C->child_count(); |
| |
| Comment::child_iterator I = C->child_begin() + Idx; |
| Comment *CommentChild = *I; |
| if (!CommentChild) |
| return ::testing::AssertionFailure() << "Child is NULL"; |
| |
| Child = dyn_cast<T>(CommentChild); |
| if (!Child) |
| return ::testing::AssertionFailure() |
| << "Child is not of requested type, but a " |
| << CommentChild->getCommentKindName(); |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasTextAt(const Comment *C, |
| size_t Idx, |
| StringRef Text) { |
| TextComment *TC; |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, TC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualText = TC->getText(); |
| if (ActualText != Text) |
| return ::testing::AssertionFailure() |
| << "TextComment has text \"" << ActualText.str() << "\", " |
| "expected \"" << Text.str() << "\""; |
| |
| if (TC->hasTrailingNewline()) |
| return ::testing::AssertionFailure() |
| << "TextComment has a trailing newline"; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasTextWithNewlineAt(const Comment *C, |
| size_t Idx, |
| StringRef Text) { |
| TextComment *TC; |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, TC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualText = TC->getText(); |
| if (ActualText != Text) |
| return ::testing::AssertionFailure() |
| << "TextComment has text \"" << ActualText.str() << "\", " |
| "expected \"" << Text.str() << "\""; |
| |
| if (!TC->hasTrailingNewline()) |
| return ::testing::AssertionFailure() |
| << "TextComment has no trailing newline"; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasBlockCommandAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| BlockCommandComment *&BCC, |
| StringRef Name, |
| ParagraphComment *&Paragraph) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, BCC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualName = BCC->getCommandName(Traits); |
| if (ActualName != Name) |
| return ::testing::AssertionFailure() |
| << "BlockCommandComment has name \"" << ActualName.str() << "\", " |
| "expected \"" << Name.str() << "\""; |
| |
| Paragraph = BCC->getParagraph(); |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasParamCommandAt( |
| const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| ParamCommandComment *&PCC, |
| StringRef CommandName, |
| ParamCommandComment::PassDirection Direction, |
| bool IsDirectionExplicit, |
| StringRef ParamName, |
| ParagraphComment *&Paragraph) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, PCC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualCommandName = PCC->getCommandName(Traits); |
| if (ActualCommandName != CommandName) |
| return ::testing::AssertionFailure() |
| << "ParamCommandComment has name \"" << ActualCommandName.str() << "\", " |
| "expected \"" << CommandName.str() << "\""; |
| |
| if (PCC->getDirection() != Direction) |
| return ::testing::AssertionFailure() |
| << "ParamCommandComment has direction " << PCC->getDirection() << ", " |
| "expected " << Direction; |
| |
| if (PCC->isDirectionExplicit() != IsDirectionExplicit) |
| return ::testing::AssertionFailure() |
| << "ParamCommandComment has " |
| << (PCC->isDirectionExplicit() ? "explicit" : "implicit") |
| << " direction, " |
| "expected " << (IsDirectionExplicit ? "explicit" : "implicit"); |
| |
| if (!ParamName.empty() && !PCC->hasParamName()) |
| return ::testing::AssertionFailure() |
| << "ParamCommandComment has no parameter name"; |
| |
| StringRef ActualParamName = PCC->hasParamName() ? PCC->getParamNameAsWritten() : ""; |
| if (ActualParamName != ParamName) |
| return ::testing::AssertionFailure() |
| << "ParamCommandComment has parameter name \"" << ActualParamName.str() |
| << "\", " |
| "expected \"" << ParamName.str() << "\""; |
| |
| Paragraph = PCC->getParagraph(); |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasTParamCommandAt( |
| const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| TParamCommandComment *&TPCC, |
| StringRef CommandName, |
| StringRef ParamName, |
| ParagraphComment *&Paragraph) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, TPCC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualCommandName = TPCC->getCommandName(Traits); |
| if (ActualCommandName != CommandName) |
| return ::testing::AssertionFailure() |
| << "TParamCommandComment has name \"" << ActualCommandName.str() << "\", " |
| "expected \"" << CommandName.str() << "\""; |
| |
| if (!ParamName.empty() && !TPCC->hasParamName()) |
| return ::testing::AssertionFailure() |
| << "TParamCommandComment has no parameter name"; |
| |
| StringRef ActualParamName = TPCC->hasParamName() ? TPCC->getParamNameAsWritten() : ""; |
| if (ActualParamName != ParamName) |
| return ::testing::AssertionFailure() |
| << "TParamCommandComment has parameter name \"" << ActualParamName.str() |
| << "\", " |
| "expected \"" << ParamName.str() << "\""; |
| |
| Paragraph = TPCC->getParagraph(); |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasInlineCommandAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| InlineCommandComment *&ICC, |
| StringRef Name) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, ICC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualName = ICC->getCommandName(Traits); |
| if (ActualName != Name) |
| return ::testing::AssertionFailure() |
| << "InlineCommandComment has name \"" << ActualName.str() << "\", " |
| "expected \"" << Name.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| struct NoArgs {}; |
| |
| ::testing::AssertionResult HasInlineCommandAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| InlineCommandComment *&ICC, |
| StringRef Name, |
| NoArgs) { |
| ::testing::AssertionResult AR = HasInlineCommandAt(C, Traits, Idx, ICC, Name); |
| if (!AR) |
| return AR; |
| |
| if (ICC->getNumArgs() != 0) |
| return ::testing::AssertionFailure() |
| << "InlineCommandComment has " << ICC->getNumArgs() << " arg(s), " |
| "expected 0"; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasInlineCommandAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| InlineCommandComment *&ICC, |
| StringRef Name, |
| StringRef Arg) { |
| ::testing::AssertionResult AR = HasInlineCommandAt(C, Traits, Idx, ICC, Name); |
| if (!AR) |
| return AR; |
| |
| if (ICC->getNumArgs() != 1) |
| return ::testing::AssertionFailure() |
| << "InlineCommandComment has " << ICC->getNumArgs() << " arg(s), " |
| "expected 1"; |
| |
| StringRef ActualArg = ICC->getArgText(0); |
| if (ActualArg != Arg) |
| return ::testing::AssertionFailure() |
| << "InlineCommandComment has argument \"" << ActualArg.str() << "\", " |
| "expected \"" << Arg.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C, |
| size_t Idx, |
| HTMLStartTagComment *&HST, |
| StringRef TagName) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, HST); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualTagName = HST->getTagName(); |
| if (ActualTagName != TagName) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment has name \"" << ActualTagName.str() << "\", " |
| "expected \"" << TagName.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| struct SelfClosing {}; |
| |
| ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C, |
| size_t Idx, |
| HTMLStartTagComment *&HST, |
| StringRef TagName, |
| SelfClosing) { |
| ::testing::AssertionResult AR = HasHTMLStartTagAt(C, Idx, HST, TagName); |
| if (!AR) |
| return AR; |
| |
| if (!HST->isSelfClosing()) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment is not self-closing"; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| |
| struct NoAttrs {}; |
| |
| ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C, |
| size_t Idx, |
| HTMLStartTagComment *&HST, |
| StringRef TagName, |
| NoAttrs) { |
| ::testing::AssertionResult AR = HasHTMLStartTagAt(C, Idx, HST, TagName); |
| if (!AR) |
| return AR; |
| |
| if (HST->isSelfClosing()) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment is self-closing"; |
| |
| if (HST->getNumAttrs() != 0) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment has " << HST->getNumAttrs() << " attr(s), " |
| "expected 0"; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasHTMLStartTagAt(const Comment *C, |
| size_t Idx, |
| HTMLStartTagComment *&HST, |
| StringRef TagName, |
| StringRef AttrName, |
| StringRef AttrValue) { |
| ::testing::AssertionResult AR = HasHTMLStartTagAt(C, Idx, HST, TagName); |
| if (!AR) |
| return AR; |
| |
| if (HST->isSelfClosing()) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment is self-closing"; |
| |
| if (HST->getNumAttrs() != 1) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment has " << HST->getNumAttrs() << " attr(s), " |
| "expected 1"; |
| |
| StringRef ActualName = HST->getAttr(0).Name; |
| if (ActualName != AttrName) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment has attr \"" << ActualName.str() << "\", " |
| "expected \"" << AttrName.str() << "\""; |
| |
| StringRef ActualValue = HST->getAttr(0).Value; |
| if (ActualValue != AttrValue) |
| return ::testing::AssertionFailure() |
| << "HTMLStartTagComment has attr value \"" << ActualValue.str() << "\", " |
| "expected \"" << AttrValue.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasHTMLEndTagAt(const Comment *C, |
| size_t Idx, |
| HTMLEndTagComment *&HET, |
| StringRef TagName) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, HET); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualTagName = HET->getTagName(); |
| if (ActualTagName != TagName) |
| return ::testing::AssertionFailure() |
| << "HTMLEndTagComment has name \"" << ActualTagName.str() << "\", " |
| "expected \"" << TagName.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasParagraphCommentAt(const Comment *C, |
| size_t Idx, |
| StringRef Text) { |
| ParagraphComment *PC; |
| |
| { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, PC); |
| if (!AR) |
| return AR; |
| } |
| |
| { |
| ::testing::AssertionResult AR = HasChildCount(PC, 1); |
| if (!AR) |
| return AR; |
| } |
| |
| { |
| ::testing::AssertionResult AR = HasTextAt(PC, 0, Text); |
| if (!AR) |
| return AR; |
| } |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| VerbatimBlockComment *&VBC, |
| StringRef Name, |
| StringRef CloseName) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, VBC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualName = VBC->getCommandName(Traits); |
| if (ActualName != Name) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has name \"" << ActualName.str() << "\", " |
| "expected \"" << Name.str() << "\""; |
| |
| StringRef ActualCloseName = VBC->getCloseName(); |
| if (ActualCloseName != CloseName) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has closing command name \"" |
| << ActualCloseName.str() << "\", " |
| "expected \"" << CloseName.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| struct NoLines {}; |
| struct Lines {}; |
| |
| ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| VerbatimBlockComment *&VBC, |
| StringRef Name, |
| StringRef CloseName, |
| NoLines) { |
| ::testing::AssertionResult AR = HasVerbatimBlockAt(C, Traits, Idx, VBC, Name, |
| CloseName); |
| if (!AR) |
| return AR; |
| |
| if (VBC->getNumLines() != 0) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has " << VBC->getNumLines() << " lines(s), " |
| "expected 0"; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| VerbatimBlockComment *&VBC, |
| StringRef Name, |
| StringRef CloseName, |
| Lines, |
| StringRef Line0) { |
| ::testing::AssertionResult AR = HasVerbatimBlockAt(C, Traits, Idx, VBC, Name, |
| CloseName); |
| if (!AR) |
| return AR; |
| |
| if (VBC->getNumLines() != 1) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has " << VBC->getNumLines() << " lines(s), " |
| "expected 1"; |
| |
| StringRef ActualLine0 = VBC->getText(0); |
| if (ActualLine0 != Line0) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has lines[0] \"" << ActualLine0.str() << "\", " |
| "expected \"" << Line0.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasVerbatimBlockAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| VerbatimBlockComment *&VBC, |
| StringRef Name, |
| StringRef CloseName, |
| Lines, |
| StringRef Line0, |
| StringRef Line1) { |
| ::testing::AssertionResult AR = HasVerbatimBlockAt(C, Traits, Idx, VBC, Name, |
| CloseName); |
| if (!AR) |
| return AR; |
| |
| if (VBC->getNumLines() != 2) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has " << VBC->getNumLines() << " lines(s), " |
| "expected 2"; |
| |
| StringRef ActualLine0 = VBC->getText(0); |
| if (ActualLine0 != Line0) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has lines[0] \"" << ActualLine0.str() << "\", " |
| "expected \"" << Line0.str() << "\""; |
| |
| StringRef ActualLine1 = VBC->getText(1); |
| if (ActualLine1 != Line1) |
| return ::testing::AssertionFailure() |
| << "VerbatimBlockComment has lines[1] \"" << ActualLine1.str() << "\", " |
| "expected \"" << Line1.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| ::testing::AssertionResult HasVerbatimLineAt(const Comment *C, |
| const CommandTraits &Traits, |
| size_t Idx, |
| VerbatimLineComment *&VLC, |
| StringRef Name, |
| StringRef Text) { |
| ::testing::AssertionResult AR = GetChildAt(C, Idx, VLC); |
| if (!AR) |
| return AR; |
| |
| StringRef ActualName = VLC->getCommandName(Traits); |
| if (ActualName != Name) |
| return ::testing::AssertionFailure() |
| << "VerbatimLineComment has name \"" << ActualName.str() << "\", " |
| "expected \"" << Name.str() << "\""; |
| |
| StringRef ActualText = VLC->getText(); |
| if (ActualText != Text) |
| return ::testing::AssertionFailure() |
| << "VerbatimLineComment has text \"" << ActualText.str() << "\", " |
| "expected \"" << Text.str() << "\""; |
| |
| return ::testing::AssertionSuccess(); |
| } |
| |
| |
| TEST_F(CommentParserTest, Basic1) { |
| const char *Source = "//"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 0)); |
| } |
| |
| TEST_F(CommentParserTest, Basic2) { |
| const char *Source = "// Meow"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Meow")); |
| } |
| |
| TEST_F(CommentParserTest, Basic3) { |
| const char *Source = |
| "// Aaa\n" |
| "// Bbb"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextWithNewlineAt(PC, 0, " Aaa")); |
| ASSERT_TRUE(HasTextAt(PC, 1, " Bbb")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParagraphSplitting1) { |
| const char *Sources[] = { |
| "// Aaa\n" |
| "//\n" |
| "// Bbb", |
| |
| "// Aaa\n" |
| "// \n" |
| "// Bbb", |
| |
| "// Aaa\n" |
| "//\t\n" |
| "// Bbb", |
| |
| "// Aaa\n" |
| "//\n" |
| "//\n" |
| "// Bbb", |
| |
| "/**\n" |
| " Aaa\n" |
| "\n" |
| " Bbb\n" |
| "*/", |
| |
| "/**\n" |
| " Aaa\n" |
| " \n" |
| " Bbb\n" |
| "*/", |
| |
| "/**\n" |
| " Aaa\n" |
| "\t \n" |
| " Bbb\n" |
| "*/", |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " Aaa")); |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 1, " Bbb")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, Paragraph1) { |
| const char *Source = |
| "// \\brief Aaa\n" |
| "//\n" |
| "// Bbb"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 3)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " Aaa")); |
| } |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 2, " Bbb")); |
| } |
| |
| TEST_F(CommentParserTest, Paragraph2) { |
| const char *Source = "// \\brief \\author"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 3)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " ")); |
| } |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "author", PC)); |
| |
| ASSERT_TRUE(GetChildAt(BCC, 0, PC)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| } |
| |
| TEST_F(CommentParserTest, Paragraph3) { |
| const char *Source = |
| "// \\brief Aaa\n" |
| "// Bbb \\author\n" |
| "// Ccc"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 3)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "brief", PC)); |
| |
| ASSERT_TRUE(GetChildAt(BCC, 0, PC)); |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextWithNewlineAt(PC, 0, " Aaa")); |
| ASSERT_TRUE(HasTextAt(PC, 1, " Bbb ")); |
| } |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "author", PC)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(BCC, 0, " Ccc")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand1) { |
| const char *Source = "// \\param aaa"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::In, |
| /* IsDirectionExplicit = */ false, |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand2) { |
| const char *Source = "// \\param\\brief"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 3)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::In, |
| /* IsDirectionExplicit = */ false, |
| "", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "brief", PC)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand3) { |
| const char *Sources[] = { |
| "// \\param aaa Bbb\n", |
| "// \\param\n" |
| "// aaa Bbb\n", |
| "// \\param \n" |
| "// aaa Bbb\n", |
| "// \\param aaa\n" |
| "// Bbb\n" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::In, |
| /* IsDirectionExplicit = */ false, |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand4) { |
| const char *Sources[] = { |
| "// \\param [in] aaa Bbb\n", |
| "// \\param[in] aaa Bbb\n", |
| "// \\param\n" |
| "// [in] aaa Bbb\n", |
| "// \\param [in]\n" |
| "// aaa Bbb\n", |
| "// \\param [in] aaa\n" |
| "// Bbb\n", |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::In, |
| /* IsDirectionExplicit = */ true, |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand5) { |
| const char *Sources[] = { |
| "// \\param [out] aaa Bbb\n", |
| "// \\param[out] aaa Bbb\n", |
| "// \\param\n" |
| "// [out] aaa Bbb\n", |
| "// \\param [out]\n" |
| "// aaa Bbb\n", |
| "// \\param [out] aaa\n" |
| "// Bbb\n", |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::Out, |
| /* IsDirectionExplicit = */ true, |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand6) { |
| const char *Sources[] = { |
| "// \\param [in,out] aaa Bbb\n", |
| "// \\param[in,out] aaa Bbb\n", |
| "// \\param [in, out] aaa Bbb\n", |
| "// \\param [in,\n" |
| "// out] aaa Bbb\n", |
| "// \\param [in,out]\n" |
| "// aaa Bbb\n", |
| "// \\param [in,out] aaa\n" |
| "// Bbb\n" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::InOut, |
| /* IsDirectionExplicit = */ true, |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| ASSERT_TRUE(HasParagraphCommentAt(PCC, 0, " Bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, ParamCommand7) { |
| const char *Source = |
| "// \\param aaa \\% Bbb \\$ ccc\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| ParamCommandComment *PCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasParamCommandAt(FC, Traits, 1, PCC, "param", |
| ParamCommandComment::In, |
| /* IsDirectionExplicit = */ false, |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(PCC, 1)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 5)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasTextAt(PC, 1, "%")); |
| ASSERT_TRUE(HasTextAt(PC, 2, " Bbb ")); |
| ASSERT_TRUE(HasTextAt(PC, 3, "$")); |
| ASSERT_TRUE(HasTextAt(PC, 4, " ccc")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, TParamCommand1) { |
| const char *Sources[] = { |
| "// \\tparam aaa Bbb\n", |
| "// \\tparam\n" |
| "// aaa Bbb\n", |
| "// \\tparam \n" |
| "// aaa Bbb\n", |
| "// \\tparam aaa\n" |
| "// Bbb\n" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| TParamCommandComment *TPCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam", |
| "aaa", PC)); |
| ASSERT_TRUE(HasChildCount(TPCC, 1)); |
| ASSERT_TRUE(HasParagraphCommentAt(TPCC, 0, " Bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, TParamCommand2) { |
| const char *Source = "// \\tparam\\brief"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 3)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| TParamCommandComment *TPCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasTParamCommandAt(FC, Traits, 1, TPCC, "tparam", "", PC)); |
| ASSERT_TRUE(HasChildCount(TPCC, 1)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 2, BCC, "brief", PC)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| } |
| |
| |
| TEST_F(CommentParserTest, InlineCommand1) { |
| const char *Source = "// \\c"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| InlineCommandComment *ICC; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", NoArgs())); |
| } |
| } |
| |
| TEST_F(CommentParserTest, InlineCommand2) { |
| const char *Source = "// \\c "; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| InlineCommandComment *ICC; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 3)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", NoArgs())); |
| ASSERT_TRUE(HasTextAt(PC, 2, " ")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, InlineCommand3) { |
| const char *Source = "// \\c aaa\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| InlineCommandComment *ICC; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", "aaa")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, InlineCommand4) { |
| const char *Source = "// \\c aaa bbb"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| InlineCommandComment *ICC; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 3)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "c", "aaa")); |
| ASSERT_TRUE(HasTextAt(PC, 2, " bbb")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, InlineCommand5) { |
| const char *Source = "// \\unknown aaa\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| InlineCommandComment *ICC; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 3)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasInlineCommandAt(PC, Traits, 1, ICC, "unknown", NoArgs())); |
| ASSERT_TRUE(HasTextAt(PC, 2, " aaa")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, HTML1) { |
| const char *Sources[] = { |
| "// <a", |
| "// <a>", |
| "// <a >" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| HTMLStartTagComment *HST; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", NoAttrs())); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, HTML2) { |
| const char *Sources[] = { |
| "// <br/>", |
| "// <br />" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| HTMLStartTagComment *HST; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "br", SelfClosing())); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, HTML3) { |
| const char *Sources[] = { |
| "// <a href", |
| "// <a href ", |
| "// <a href>", |
| "// <a href >", |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| HTMLStartTagComment *HST; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", "")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, HTML4) { |
| const char *Sources[] = { |
| "// <a href=\"bbb\"", |
| "// <a href=\"bbb\">", |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| HTMLStartTagComment *HST; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "a", "href", "bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, HTML5) { |
| const char *Sources[] = { |
| "// </a", |
| "// </a>", |
| "// </a >" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| HTMLEndTagComment *HET; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 2)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasHTMLEndTagAt(PC, 1, HET, "a")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, HTML6) { |
| const char *Source = |
| "// <pre>\n" |
| "// Aaa\n" |
| "// Bbb\n" |
| "// </pre>\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| ParagraphComment *PC; |
| HTMLStartTagComment *HST; |
| HTMLEndTagComment *HET; |
| ASSERT_TRUE(GetChildAt(FC, 0, PC)); |
| |
| ASSERT_TRUE(HasChildCount(PC, 6)); |
| ASSERT_TRUE(HasTextAt(PC, 0, " ")); |
| ASSERT_TRUE(HasHTMLStartTagAt(PC, 1, HST, "pre", NoAttrs())); |
| ASSERT_TRUE(HasTextWithNewlineAt(PC, 2, " Aaa")); |
| ASSERT_TRUE(HasTextWithNewlineAt(PC, 3, " Bbb")); |
| ASSERT_TRUE(HasTextAt(PC, 4, " ")); |
| ASSERT_TRUE(HasHTMLEndTagAt(PC, 5, HET, "pre")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock1) { |
| const char *Source = "// \\verbatim\\endverbatim\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimBlockComment *VCC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VCC, |
| "verbatim", "endverbatim", |
| NoLines())); |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock2) { |
| const char *Source = "// \\verbatim Aaa \\endverbatim\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, |
| "verbatim", "endverbatim", |
| Lines(), " Aaa ")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock3) { |
| const char *Source = "// \\verbatim Aaa\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, "verbatim", "", |
| Lines(), " Aaa")); |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock4) { |
| const char *Source = |
| "//\\verbatim\n" |
| "//\\endverbatim\n"; |
| |
| FullComment *FC = parseString(Source); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC, |
| "verbatim", "endverbatim", |
| NoLines())); |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock5) { |
| const char *Sources[] = { |
| "//\\verbatim\n" |
| "// Aaa\n" |
| "//\\endverbatim\n", |
| |
| "/*\\verbatim\n" |
| " * Aaa\n" |
| " *\\endverbatim*/" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 1)); |
| |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 0, VBC, |
| "verbatim", "endverbatim", |
| Lines(), " Aaa")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock6) { |
| const char *Sources[] = { |
| "// \\verbatim\n" |
| "// Aaa\n" |
| "// \\endverbatim\n", |
| |
| "/* \\verbatim\n" |
| " * Aaa\n" |
| " * \\endverbatim*/" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, |
| "verbatim", "endverbatim", |
| Lines(), " Aaa")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock7) { |
| const char *Sources[] = { |
| "// \\verbatim\n" |
| "// Aaa\n" |
| "// Bbb\n" |
| "// \\endverbatim\n", |
| |
| "/* \\verbatim\n" |
| " * Aaa\n" |
| " * Bbb\n" |
| " * \\endverbatim*/" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, |
| "verbatim", "endverbatim", |
| Lines(), " Aaa", " Bbb")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimBlock8) { |
| const char *Sources[] = { |
| "// \\verbatim\n" |
| "// Aaa\n" |
| "//\n" |
| "// Bbb\n" |
| "// \\endverbatim\n", |
| |
| "/* \\verbatim\n" |
| " * Aaa\n" |
| " *\n" |
| " * Bbb\n" |
| " * \\endverbatim*/" |
| }; |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimBlockComment *VBC; |
| ASSERT_TRUE(HasVerbatimBlockAt(FC, Traits, 1, VBC, |
| "verbatim", "endverbatim")); |
| ASSERT_EQ(3U, VBC->getNumLines()); |
| ASSERT_EQ(" Aaa", VBC->getText(0)); |
| ASSERT_EQ("", VBC->getText(1)); |
| ASSERT_EQ(" Bbb", VBC->getText(2)); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimLine1) { |
| const char *Sources[] = { |
| "// \\fn", |
| "// \\fn\n" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimLineComment *VLC; |
| ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn", "")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, VerbatimLine2) { |
| const char *Sources[] = { |
| "/// \\fn void *foo(const char *zzz = \"\\$\");\n//", |
| "/** \\fn void *foo(const char *zzz = \"\\$\");*/" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| VerbatimLineComment *VLC; |
| ASSERT_TRUE(HasVerbatimLineAt(FC, Traits, 1, VLC, "fn", |
| " void *foo(const char *zzz = \"\\$\");")); |
| } |
| } |
| } |
| |
| TEST_F(CommentParserTest, Deprecated) { |
| const char *Sources[] = { |
| "/** @deprecated*/", |
| "/// @deprecated\n" |
| }; |
| |
| for (size_t i = 0, e = array_lengthof(Sources); i != e; i++) { |
| FullComment *FC = parseString(Sources[i]); |
| ASSERT_TRUE(HasChildCount(FC, 2)); |
| |
| ASSERT_TRUE(HasParagraphCommentAt(FC, 0, " ")); |
| { |
| BlockCommandComment *BCC; |
| ParagraphComment *PC; |
| ASSERT_TRUE(HasBlockCommandAt(FC, Traits, 1, BCC, "deprecated", PC)); |
| ASSERT_TRUE(HasChildCount(PC, 0)); |
| } |
| } |
| } |
| |
| } // unnamed namespace |
| |
| } // end namespace comments |
| } // end namespace clang |
| |
