mewin/cxxheaderparser
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix doxygen tests

Browse Source
This commit is contained in:
Dustin Spicuzza 2020-12-31 00:24:45 -05:00
parent 3f9c03a37b
commit a6977325b9
1 changed files with 243 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

409
tests/test_doxygen.py
View File

@ -37,185 +37,256 @@ from cxxheaderparser.simple import (
ParsedData, ParsedData,
) )
r"""
class SampleClass: public BaseSampleClass
{
public:
enum Elephant
{
EL_ONE = 1,
EL_TWO = 2,
EL_NINE = 9,
EL_TEN,
};
SampleClass(); def test_doxygen_class():
/*! content = """
* Method 1 // clang-format off
*/
string meth1();
/// /// cls comment
/// Method 2 description class
/// C {
/// @param v1 Variable 1 /// member comment
/// void fn();
int meth2(int v1);
/** /// var above
* Method 3 description int var_above;
*
* \param v1 Variable 1 with a really long
* wrapping description
* \param v2 Variable 2
*/
void meth3(const string & v1, vector<string> & v2);
/********************************** int var_after; /// var after
* Method 4 description };
* """
* @return Return value data = parse_string(content, cleandoc=True)
*********************************/
unsigned int meth4();
private:
void * meth5(){return NULL;}
/// prop1 description assert data == ParsedData(
string prop1; namespace=NamespaceScope(
//! prop5 description classes=[
int prop5; ClassScope(
class_decl=ClassDecl(
bool prop6; /*!< prop6 description */ typename=PQName(
segments=[NameSpecifier(name="C")], classkey="class"
double prop7; //!< prop7 description ),
//!< with two lines doxygen="/// cls comment",
),
/// prop8 description fields=[
int prop8; Field(
}; access="private",
namespace Alpha type=Type(
{ typename=PQName(
class AlphaClass segments=[FundamentalSpecifier(name="int")]
{ )
public: ),
AlphaClass(); name="var_above",
doxygen="/// var above",
void alphaMethod(); ),
Field(
string alphaString; access="private",
protected: type=Type(
typedef enum typename=PQName(
{ segments=[FundamentalSpecifier(name="int")]
Z_A, )
Z_B = 0x2B, ),
Z_C = 'j', name="var_after",
Z_D, doxygen="/// var after",
} Zebra; ),
}; ],
methods=[
namespace Omega Method(
{ return_type=Type(
class OmegaClass typename=PQName(
{ segments=[FundamentalSpecifier(name="void")]
public: )
OmegaClass(); ),
name=PQName(segments=[NameSpecifier(name="fn")]),
string omegaString; parameters=[],
protected: doxygen="/// member comment",
/// access="private",
/// @brief Rino Numbers, not that that means anything )
/// ],
typedef enum )
{ ]
RI_ZERO, /// item zero )
RI_ONE, /** item one */ )
RI_TWO, //!< item two
RI_THREE,
/// item four
RI_FOUR,
} Rino;
};
};
}
"""
# def test_doxygen_messy(): def test_doxygen_class_template():
# content = """ content = """
# // clang-format off // clang-format off
# /// fn comment /// template comment
# void template <typename T>
# fn(); class C2 {};
"""
data = parse_string(content, cleandoc=True)
# /// var comment assert data == ParsedData(
# int namespace=NamespaceScope(
# v1 = 0; classes=[
ClassScope(
class_decl=ClassDecl(
typename=PQName(
segments=[NameSpecifier(name="C2")], classkey="class"
),
template=TemplateDecl(
params=[TemplateTypeParam(typekey="typename", name="T")]
),
doxygen="/// template comment",
)
)
]
)
)
# int
# v2 = 0; /// var2 comment
# /// cls comment def test_doxygen_enum():
# class content = """
# C {}; // clang-format off
# /// template comment ///
# template <typename T> /// @brief Rino Numbers, not that that means anything
# class ///
# C2 {}; typedef enum
# """ {
# data = parse_string(content, cleandoc=True) RI_ZERO, /// item zero
RI_ONE, /** item one */
RI_TWO, //!< item two
RI_THREE,
/// item four
RI_FOUR,
} Rino;
"""
data = parse_string(content, cleandoc=True)
# assert data == ParsedData( assert data == ParsedData(
# namespace=NamespaceScope( namespace=NamespaceScope(
# classes=[ enums=[
# ClassScope( EnumDecl(
# class_decl=ClassDecl( typename=PQName(segments=[AnonymousName(id=1)], classkey="enum"),
# typename=PQName( values=[
# segments=[NameSpecifier(name="C")], classkey="class" Enumerator(name="RI_ZERO", doxygen="/// item zero"),
# ), Enumerator(name="RI_ONE", doxygen="/** item one */"),
# doxygen="/// cls comment", Enumerator(name="RI_TWO", doxygen="//!< item two"),
# ) Enumerator(name="RI_THREE"),
# ), Enumerator(name="RI_FOUR", doxygen="/// item four"),
# ClassScope( ],
# class_decl=ClassDecl( doxygen="///\n/// @brief Rino Numbers, not that that means anything\n///",
# typename=PQName( )
# segments=[NameSpecifier(name="C2")], classkey="class" ],
# ), typedefs=[
# template=TemplateDecl( Typedef(
# params=[TemplateTypeParam(typekey="typename", name="T")] type=Type(
# ), typename=PQName(segments=[AnonymousName(id=1)], classkey="enum")
# doxygen="/// template comment", ),
# ) name="Rino",
# ), )
# ], ],
# functions=[ )
# Function( )
# return_type=Type(
# typename=PQName(segments=[FundamentalSpecifier(name="void")])
# ), def test_doxygen_fn_3slash():
# name=PQName(segments=[NameSpecifier(name="fn")]), content = """
# parameters=[], // clang-format off
# doxygen="/// fn comment",
# ) /// fn comment
# ], void
# variables=[ fn();
# Variable(
# name=PQName(segments=[NameSpecifier(name="v1")]), """
# type=Type( data = parse_string(content, cleandoc=True)
# typename=PQName(segments=[FundamentalSpecifier(name="int")])
# ), assert data == ParsedData(
# value=Value(tokens=[Token(value="0")]), namespace=NamespaceScope(
# doxygen="/// var comment", functions=[
# ), Function(
# Variable( return_type=Type(
# name=PQName(segments=[NameSpecifier(name="v2")]), typename=PQName(segments=[FundamentalSpecifier(name="void")])
# type=Type( ),
# typename=PQName(segments=[FundamentalSpecifier(name="int")]) name=PQName(segments=[NameSpecifier(name="fn")]),
# ), parameters=[],
# value=Value(tokens=[Token(value="0")]), doxygen="/// fn comment",
# ), )
# ], ]
# ) )
# ) )
def test_doxygen_fn_cstyle():
content = """
// clang-format off
/**
* fn comment
*/
void
fn();
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
functions=[
Function(
return_type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="void")])
),
name=PQName(segments=[NameSpecifier(name="fn")]),
parameters=[],
doxygen="/**\n* fn comment\n*/",
)
]
)
)
def test_doxygen_var_above():
content = """
// clang-format off
/// var comment
int
v1 = 0;
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
variables=[
Variable(
name=PQName(segments=[NameSpecifier(name="v1")]),
type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="int")])
),
value=Value(tokens=[Token(value="0")]),
doxygen="/// var comment",
)
]
)
)
def test_doxygen_var_after():
content = """
// clang-format off
int
v2 = 0; /// var2 comment
"""
data = parse_string(content, cleandoc=True)
assert data == ParsedData(
namespace=NamespaceScope(
variables=[
Variable(
name=PQName(segments=[NameSpecifier(name="v2")]),
type=Type(
typename=PQName(segments=[FundamentalSpecifier(name="int")])
),
value=Value(tokens=[Token(value="0")]),
doxygen="/// var2 comment",
)
]
)
)