1448 lines
42 KiB
C++
1448 lines
42 KiB
C++
//===- 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"
|
|
#include <vector>
|
|
|
|
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) {
|
|
MemoryBuffer *Buf = MemoryBuffer::getMemBuffer(Source);
|
|
FileID File = SourceMgr.createFileID(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
|
|
|