mirror of
https://github.com/sphinx-doc/sphinx.git
synced 2025-02-25 18:55:22 -06:00
C++, internal changes to id generation
This commit is contained in:
Jakob Lykke Andersen
parent
71a1ffb303
commit
85a94b79ca
File diff suppressed because it is too large
Load Diff
@ -16,11 +16,9 @@ import pytest
|
||||
|
||||
from sphinx import addnodes
|
||||
from sphinx.domains.cpp import DefinitionParser, DefinitionError, NoOldIdError
|
||||
from sphinx.domains.cpp import Symbol
|
||||
from sphinx.domains.cpp import Symbol, _max_id, _id_prefix
|
||||
import sphinx.domains.cpp as cppDomain
|
||||
|
||||
ids = []
|
||||
|
||||
|
||||
def parse(name, string):
|
||||
class Config(object):
|
||||
@ -39,7 +37,7 @@ def parse(name, string):
|
||||
return ast
|
||||
|
||||
|
||||
def check(name, input, idv1output=None, idv2output=None, output=None):
|
||||
def check(name, input, idDict, output=None):
|
||||
# first a simple check of the AST
|
||||
if output is None:
|
||||
output = input
|
||||
@ -58,28 +56,35 @@ def check(name, input, idv1output=None, idv2output=None, output=None):
|
||||
parentNode += signode
|
||||
ast.describe_signature(signode, 'lastIsName', symbol, options={})
|
||||
|
||||
if idv2output:
|
||||
idv2output = "_CPPv2" + idv2output
|
||||
try:
|
||||
idv1 = ast.get_id_v1()
|
||||
assert idv1 is not None
|
||||
except NoOldIdError:
|
||||
idv1 = None
|
||||
try:
|
||||
idv2 = ast.get_id_v2()
|
||||
assert idv2 is not None
|
||||
except NoOldIdError:
|
||||
idv2 = None
|
||||
if idv1 != idv1output or idv2 != idv2output:
|
||||
idExpected = [None]
|
||||
for i in range(1, _max_id + 1):
|
||||
if i in idDict:
|
||||
idExpected.append(idDict[i])
|
||||
else:
|
||||
idExpected.append(idExpected[i - 1])
|
||||
idActual = [None]
|
||||
for i in range(1, _max_id + 1):
|
||||
try:
|
||||
id = ast.get_id(version=i)
|
||||
assert id is not None
|
||||
idActual.append(id[len(_id_prefix[i]):])
|
||||
except NoOldIdError:
|
||||
idActual.append(None)
|
||||
|
||||
res = [True]
|
||||
for i in range(1, _max_id + 1):
|
||||
res.append(idExpected[i] == idActual[i])
|
||||
|
||||
if not all(res):
|
||||
print("input: %s" % text_type(input).rjust(20))
|
||||
print(" %s %s" % ("Id v1".rjust(20), "Id v2".rjust(20)))
|
||||
print("result: %s %s" % (str(idv1).rjust(20), str(idv2).rjust(20)))
|
||||
print("expected: %s %s" % (str(idv1output).rjust(20),
|
||||
str(idv2output).rjust(20)))
|
||||
for i in range(1, _max_id + 1):
|
||||
if res[i]:
|
||||
continue
|
||||
print("Error in id version %d." % i)
|
||||
print("result: %s" % str(idActual[i]))
|
||||
print("expected: %s" % str(idExpected[i]))
|
||||
print(rootSymbol.dump(0))
|
||||
raise DefinitionError("")
|
||||
ids.append(ast.get_id_v2())
|
||||
# print ".. %s:: %s" % (name, input)
|
||||
|
||||
|
||||
def test_fundamental_types():
|
||||
@ -99,55 +104,55 @@ def test_fundamental_types():
|
||||
if t == "std::nullptr_t":
|
||||
id = "NSt9nullptr_tE"
|
||||
return "1f%s" % id
|
||||
check("function", "void f(%s arg)" % t, makeIdV1(), makeIdV2())
|
||||
check("function", "void f(%s arg)" % t, {1: makeIdV1(), 2:makeIdV2()})
|
||||
|
||||
|
||||
def test_type_definitions():
|
||||
check("type", "public bool b", "b", "1b", "bool b")
|
||||
check("type", "bool A::b", "A::b", "N1A1bE")
|
||||
check("type", "bool *b", "b", "1b")
|
||||
check("type", "bool *const b", "b", "1b")
|
||||
check("type", "bool *volatile const b", "b", "1b")
|
||||
check("type", "bool *volatile const b", "b", "1b")
|
||||
check("type", "bool *volatile const *b", "b", "1b")
|
||||
check("type", "bool &b", "b", "1b")
|
||||
check("type", "bool b[]", "b", "1b")
|
||||
check("type", "std::pair<int, int> coord", "coord", "5coord")
|
||||
check("type", "long long int foo", "foo", "3foo")
|
||||
check("type", "public bool b", {1:"b", 2:"1b"}, "bool b")
|
||||
check("type", "bool A::b", {1:"A::b", 2:"N1A1bE"})
|
||||
check("type", "bool *b", {1:"b", 2:"1b"})
|
||||
check("type", "bool *const b", {1:"b", 2:"1b"})
|
||||
check("type", "bool *volatile const b", {1:"b", 2:"1b"})
|
||||
check("type", "bool *volatile const b", {1:"b", 2:"1b"})
|
||||
check("type", "bool *volatile const *b", {1:"b", 2:"1b"})
|
||||
check("type", "bool &b", {1:"b", 2:"1b"})
|
||||
check("type", "bool b[]", {1:"b", 2:"1b"})
|
||||
check("type", "std::pair<int, int> coord", {1:"coord", 2:"5coord"})
|
||||
check("type", "long long int foo", {1:"foo", 2:"3foo"})
|
||||
check("type", 'std::vector<std::pair<std::string, long long>> module::blah',
|
||||
"module::blah", "N6module4blahE")
|
||||
check("type", "std::function<void()> F", "F", "1F")
|
||||
check("type", "std::function<R(A1, A2)> F", "F", "1F")
|
||||
check("type", "std::function<R(A1, A2, A3)> F", "F", "1F")
|
||||
check("type", "std::function<R(A1, A2, A3, As...)> F", "F", "1F")
|
||||
{1:"module::blah", 2:"N6module4blahE"})
|
||||
check("type", "std::function<void()> F", {1:"F", 2:"1F"})
|
||||
check("type", "std::function<R(A1, A2)> F", {1:"F", 2:"1F"})
|
||||
check("type", "std::function<R(A1, A2, A3)> F", {1:"F", 2:"1F"})
|
||||
check("type", "std::function<R(A1, A2, A3, As...)> F", {1:"F", 2:"1F"})
|
||||
check("type", "MyContainer::const_iterator",
|
||||
"MyContainer::const_iterator", "N11MyContainer14const_iteratorE")
|
||||
{1:"MyContainer::const_iterator", 2:"N11MyContainer14const_iteratorE"})
|
||||
check("type",
|
||||
"public MyContainer::const_iterator",
|
||||
"MyContainer::const_iterator", "N11MyContainer14const_iteratorE",
|
||||
{1:"MyContainer::const_iterator", 2:"N11MyContainer14const_iteratorE"},
|
||||
output="MyContainer::const_iterator")
|
||||
# test decl specs on right
|
||||
check("type", "bool const b", "b", "1b")
|
||||
check("type", "bool const b", {1:"b", 2:"1b"})
|
||||
# test name in global scope
|
||||
check("type", "bool ::B::b", "B::b", "N1B1bE")
|
||||
check("type", "bool ::B::b", {1:"B::b", 2:"N1B1bE"})
|
||||
|
||||
check('type', 'A = B', None, '1A')
|
||||
check('type', 'A = B', {2:'1A'})
|
||||
|
||||
# from breathe#267 (named function parameters for function pointers
|
||||
check('type', 'void (*gpio_callback_t)(struct device *port, uint32_t pin)',
|
||||
'gpio_callback_t', '15gpio_callback_t')
|
||||
check('type', 'void (*f)(std::function<void(int i)> g)', 'f', '1f')
|
||||
{1:'gpio_callback_t', 2:'15gpio_callback_t'})
|
||||
check('type', 'void (*f)(std::function<void(int i)> g)', {1:'f', 2:'1f'})
|
||||
|
||||
|
||||
def test_concept_definitions():
|
||||
check('concept', 'template<typename Param> A::B::Concept',
|
||||
None, 'I0EN1A1B7ConceptE')
|
||||
{2:'I0EN1A1B7ConceptE'})
|
||||
check('concept', 'template<typename A, typename B, typename ...C> Foo',
|
||||
None, 'I00DpE3Foo')
|
||||
{2:'I00DpE3Foo'})
|
||||
check('concept', 'template<typename Param> A::B::Concept()',
|
||||
None, 'I0EN1A1B7ConceptE')
|
||||
{2:'I0EN1A1B7ConceptE'})
|
||||
check('concept', 'template<typename A, typename B, typename ...C> Foo()',
|
||||
None, 'I00DpE3Foo')
|
||||
{2:'I00DpE3Foo'})
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('concept', 'Foo')
|
||||
with pytest.raises(DefinitionError):
|
||||
@ -156,256 +161,254 @@ def test_concept_definitions():
|
||||
|
||||
def test_member_definitions():
|
||||
check('member', ' const std::string & name = 42',
|
||||
"name__ssCR", "4name", output='const std::string &name = 42')
|
||||
check('member', ' const std::string & name', "name__ssCR", "4name",
|
||||
{1:"name__ssCR", 2:"4name"}, output='const std::string &name = 42')
|
||||
check('member', ' const std::string & name', {1:"name__ssCR", 2:"4name"},
|
||||
output='const std::string &name')
|
||||
check('member', ' const std::string & name [ n ]',
|
||||
"name__ssCRA", "4name", output='const std::string &name[n]')
|
||||
{1:"name__ssCRA", 2:"4name"}, output='const std::string &name[n]')
|
||||
check('member', 'const std::vector< unsigned int, long> &name',
|
||||
"name__std::vector:unsigned-i.l:CR",
|
||||
"4name", output='const std::vector<unsigned int, long> &name')
|
||||
check('member', 'module::myclass foo[n]', "foo__module::myclassA", "3foo")
|
||||
check('member', 'int *const p', 'p__iPC', '1p')
|
||||
check('member', 'extern int myInt', 'myInt__i', '5myInt')
|
||||
check('member', 'thread_local int myInt', 'myInt__i', '5myInt')
|
||||
check('member', 'extern thread_local int myInt', 'myInt__i', '5myInt')
|
||||
check('member', 'thread_local extern int myInt', 'myInt__i', '5myInt',
|
||||
{1:"name__std::vector:unsigned-i.l:CR", 2:"4name"},
|
||||
output='const std::vector<unsigned int, long> &name')
|
||||
check('member', 'module::myclass foo[n]', {1:"foo__module::myclassA", 2:"3foo"})
|
||||
check('member', 'int *const p', {1:'p__iPC', 2:'1p'})
|
||||
check('member', 'extern int myInt', {1:'myInt__i', 2:'5myInt'})
|
||||
check('member', 'thread_local int myInt', {1:'myInt__i', 2:'5myInt'})
|
||||
check('member', 'extern thread_local int myInt', {1:'myInt__i', 2:'5myInt'})
|
||||
check('member', 'thread_local extern int myInt', {1:'myInt__i', 2:'5myInt'},
|
||||
'extern thread_local int myInt')
|
||||
|
||||
|
||||
def test_function_definitions():
|
||||
check('function', 'operator bool() const', "castto-b-operatorC", "NKcvbEv")
|
||||
check('function', 'operator bool() const', {1:"castto-b-operatorC", 2:"NKcvbEv"})
|
||||
check('function', 'A::operator bool() const',
|
||||
"A::castto-b-operatorC", "NK1AcvbEv")
|
||||
{1:"A::castto-b-operatorC", 2:"NK1AcvbEv"})
|
||||
check('function', 'A::operator bool() volatile const &',
|
||||
"A::castto-b-operatorVCR", "NVKR1AcvbEv")
|
||||
{1:"A::castto-b-operatorVCR", 2:"NVKR1AcvbEv"})
|
||||
check('function', 'A::operator bool() volatile const &&',
|
||||
"A::castto-b-operatorVCO", "NVKO1AcvbEv")
|
||||
{1:"A::castto-b-operatorVCO", 2:"NVKO1AcvbEv"})
|
||||
check('function', 'bool namespaced::theclass::method(arg1, arg2)',
|
||||
"namespaced::theclass::method__arg1.arg2",
|
||||
"N10namespaced8theclass6methodE4arg14arg2")
|
||||
{1:"namespaced::theclass::method__arg1.arg2",
|
||||
2:"N10namespaced8theclass6methodE4arg14arg2"})
|
||||
x = 'std::vector<std::pair<std::string, int>> &module::test(register int ' \
|
||||
'foo, bar, std::string baz = "foobar, blah, bleh") const = 0'
|
||||
check('function', x, "module::test__i.bar.ssC",
|
||||
"NK6module4testEi3barNSt6stringE")
|
||||
check('function', x, {1:"module::test__i.bar.ssC",
|
||||
2:"NK6module4testEi3barNSt6stringE"})
|
||||
check('function', 'void f(std::pair<A, B>)',
|
||||
"f__std::pair:A.B:", "1fNSt4pairI1A1BEE")
|
||||
{1:"f__std::pair:A.B:", 2:"1fNSt4pairI1A1BEE"})
|
||||
check('function', 'explicit module::myclass::foo::foo()',
|
||||
"module::myclass::foo::foo", "N6module7myclass3foo3fooEv")
|
||||
{1:"module::myclass::foo::foo", 2:"N6module7myclass3foo3fooEv"})
|
||||
check('function', 'module::myclass::foo::~foo()',
|
||||
"module::myclass::foo::~foo", "N6module7myclass3fooD0Ev")
|
||||
{1:"module::myclass::foo::~foo", 2:"N6module7myclass3fooD0Ev"})
|
||||
check('function', 'int printf(const char *fmt, ...)',
|
||||
"printf__cCP.z", "6printfPKcz")
|
||||
{1:"printf__cCP.z", 2:"6printfPKcz"})
|
||||
check('function', 'int foo(const unsigned int j)',
|
||||
"foo__unsigned-iC", "3fooKj")
|
||||
{1:"foo__unsigned-iC", 2:"3fooKj"})
|
||||
check('function', 'int foo(const int *const ptr)',
|
||||
"foo__iCPC", "3fooPCKi")
|
||||
{1:"foo__iCPC", 2:"3fooPCKi"})
|
||||
check('function', 'module::myclass::operator std::vector<std::string>()',
|
||||
"module::myclass::castto-std::vector:ss:-operator",
|
||||
"N6module7myclasscvNSt6vectorINSt6stringEEEEv")
|
||||
{1:"module::myclass::castto-std::vector:ss:-operator",
|
||||
2:"N6module7myclasscvNSt6vectorINSt6stringEEEEv"})
|
||||
check('function',
|
||||
'void operator()(const boost::array<VertexID, 2> &v) const',
|
||||
"call-operator__boost::array:VertexID.2:CRC",
|
||||
"NKclERKN5boost5arrayI8VertexIDX2EEE")
|
||||
{1:"call-operator__boost::array:VertexID.2:CRC",
|
||||
2:"NKclERKN5boost5arrayI8VertexIDX2EEE"})
|
||||
check('function',
|
||||
'void operator()(const boost::array<VertexID, 2, "foo, bar"> &v) const',
|
||||
'call-operator__boost::array:VertexID.2."foo,--bar":CRC',
|
||||
'NKclERKN5boost5arrayI8VertexIDX2EX"foo, bar"EEE')
|
||||
{1:'call-operator__boost::array:VertexID.2."foo,--bar":CRC',
|
||||
2:'NKclERKN5boost5arrayI8VertexIDX2EX"foo, bar"EEE'})
|
||||
check('function', 'MyClass::MyClass(MyClass::MyClass&&)',
|
||||
"MyClass::MyClass__MyClass::MyClassRR",
|
||||
"N7MyClass7MyClassERRN7MyClass7MyClassE")
|
||||
check('function', 'constexpr int get_value()', "get_valueCE", "9get_valuev")
|
||||
{1:"MyClass::MyClass__MyClass::MyClassRR",
|
||||
2:"N7MyClass7MyClassERRN7MyClass7MyClassE"})
|
||||
check('function', 'constexpr int get_value()', {1:"get_valueCE", 2:"9get_valuev"})
|
||||
check('function', 'static constexpr int get_value()',
|
||||
"get_valueCE", "9get_valuev")
|
||||
{1:"get_valueCE", 2:"9get_valuev"})
|
||||
check('function', 'int get_value() const noexcept',
|
||||
"get_valueC", "NK9get_valueEv")
|
||||
{1:"get_valueC", 2:"NK9get_valueEv"})
|
||||
check('function', 'int get_value() const noexcept = delete',
|
||||
"get_valueC", "NK9get_valueEv")
|
||||
{1:"get_valueC", 2:"NK9get_valueEv"})
|
||||
check('function', 'int get_value() volatile const',
|
||||
"get_valueVC", "NVK9get_valueEv")
|
||||
{1:"get_valueVC", 2:"NVK9get_valueEv"})
|
||||
check('function', 'MyClass::MyClass(MyClass::MyClass&&) = default',
|
||||
"MyClass::MyClass__MyClass::MyClassRR",
|
||||
"N7MyClass7MyClassERRN7MyClass7MyClassE")
|
||||
{1:"MyClass::MyClass__MyClass::MyClassRR",
|
||||
2:"N7MyClass7MyClassERRN7MyClass7MyClassE"})
|
||||
check('function', 'virtual MyClass::a_virtual_function() const override',
|
||||
"MyClass::a_virtual_functionC", "NK7MyClass18a_virtual_functionEv")
|
||||
check('function', 'A B() override', "B", "1Bv")
|
||||
check('function', 'A B() final', "B", "1Bv")
|
||||
check('function', 'A B() final override', "B", "1Bv")
|
||||
check('function', 'A B() override final', "B", "1Bv",
|
||||
{1:"MyClass::a_virtual_functionC", 2:"NK7MyClass18a_virtual_functionEv"})
|
||||
check('function', 'A B() override', {1:"B", 2:"1Bv"})
|
||||
check('function', 'A B() final', {1:"B", 2:"1Bv"})
|
||||
check('function', 'A B() final override', {1:"B", 2:"1Bv"})
|
||||
check('function', 'A B() override final', {1:"B", 2:"1Bv"},
|
||||
output='A B() final override')
|
||||
check('function', 'MyClass::a_member_function() volatile',
|
||||
"MyClass::a_member_functionV", "NV7MyClass17a_member_functionEv")
|
||||
{1:"MyClass::a_member_functionV", 2:"NV7MyClass17a_member_functionEv"})
|
||||
check('function', 'MyClass::a_member_function() volatile const',
|
||||
"MyClass::a_member_functionVC", "NVK7MyClass17a_member_functionEv")
|
||||
{1:"MyClass::a_member_functionVC", 2:"NVK7MyClass17a_member_functionEv"})
|
||||
check('function', 'MyClass::a_member_function() &&',
|
||||
"MyClass::a_member_functionO", "NO7MyClass17a_member_functionEv")
|
||||
{1:"MyClass::a_member_functionO", 2:"NO7MyClass17a_member_functionEv"})
|
||||
check('function', 'MyClass::a_member_function() &',
|
||||
"MyClass::a_member_functionR", "NR7MyClass17a_member_functionEv")
|
||||
{1:"MyClass::a_member_functionR", 2:"NR7MyClass17a_member_functionEv"})
|
||||
check('function', 'MyClass::a_member_function() const &',
|
||||
"MyClass::a_member_functionCR", "NKR7MyClass17a_member_functionEv")
|
||||
{1:"MyClass::a_member_functionCR", 2:"NKR7MyClass17a_member_functionEv"})
|
||||
check('function', 'int main(int argc, char *argv[])',
|
||||
"main__i.cPA", "4mainiA_Pc")
|
||||
{1:"main__i.cPA", 2:"4mainiA_Pc"})
|
||||
check('function', 'MyClass &MyClass::operator++()',
|
||||
"MyClass::inc-operator", "N7MyClassppEv")
|
||||
{1:"MyClass::inc-operator", 2:"N7MyClassppEv"})
|
||||
check('function', 'MyClass::pointer MyClass::operator->()',
|
||||
"MyClass::pointer-operator", "N7MyClassptEv")
|
||||
{1:"MyClass::pointer-operator", 2:"N7MyClassptEv"})
|
||||
|
||||
x = 'std::vector<std::pair<std::string, int>> &module::test(register int ' \
|
||||
'foo, bar[n], std::string baz = "foobar, blah, bleh") const = 0'
|
||||
check('function', x, "module::test__i.barA.ssC",
|
||||
"NK6module4testEiAn_3barNSt6stringE")
|
||||
check('function', x, {1:"module::test__i.barA.ssC",
|
||||
2:"NK6module4testEiAn_3barNSt6stringE"})
|
||||
check('function',
|
||||
'int foo(Foo f = Foo(double(), std::make_pair(int(2), double(3.4))))',
|
||||
"foo__Foo", "3foo3Foo")
|
||||
check('function', 'int foo(A a = x(a))', "foo__A", "3foo1A")
|
||||
{1:"foo__Foo", 2:"3foo3Foo"})
|
||||
check('function', 'int foo(A a = x(a))', {1:"foo__A", 2:"3foo1A"})
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('function', 'int foo(B b=x(a)')
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('function', 'int foo)C c=x(a))')
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('function', 'int foo(D d=x(a')
|
||||
check('function', 'int foo(const A&... a)', "foo__ACRDp", "3fooDpRK1A")
|
||||
check('function', 'virtual void f()', "f", "1fv")
|
||||
check('function', 'int foo(const A&... a)', {1:"foo__ACRDp", 2:"3fooDpRK1A"})
|
||||
check('function', 'virtual void f()', {1:"f", 2:"1fv"})
|
||||
# test for ::nestedName, from issue 1738
|
||||
check("function", "result(int val, ::std::error_category const &cat)",
|
||||
"result__i.std::error_categoryCR", "6resultiRNSt14error_categoryE")
|
||||
check("function", "int *f()", "f", "1fv")
|
||||
{1:"result__i.std::error_categoryCR", 2:"6resultiRNSt14error_categoryE"})
|
||||
check("function", "int *f()", {1:"f", 2:"1fv"})
|
||||
# tests derived from issue #1753 (skip to keep sanity)
|
||||
check("function", "f(int (&array)[10])", None, "1fRA10_i")
|
||||
check("function", "void f(int (&array)[10])", None, "1fRA10_i")
|
||||
check("function", "void f(float *q(double))", None, "1fFPfdE")
|
||||
check("function", "void f(float *(*q)(double))", None, "1fPFPfdE")
|
||||
check("function", "void f(float (*q)(double))", None, "1fPFfdE")
|
||||
check("function", "int (*f(double d))(float)", "f__double", "1fd")
|
||||
check("function", "int (*f(bool b))[5]", "f__b", "1fb")
|
||||
check("function", "f(int (&array)[10])", {2:"1fRA10_i"})
|
||||
check("function", "void f(int (&array)[10])", {2:"1fRA10_i"})
|
||||
check("function", "void f(float *q(double))", {2:"1fFPfdE"})
|
||||
check("function", "void f(float *(*q)(double))", {2:"1fPFPfdE"})
|
||||
check("function", "void f(float (*q)(double))", {2:"1fPFfdE"})
|
||||
check("function", "int (*f(double d))(float)", {1:"f__double", 2:"1fd"})
|
||||
check("function", "int (*f(bool b))[5]", {1:"f__b", 2:"1fb"})
|
||||
check("function", "int (*A::f(double d) const)(float)",
|
||||
"A::f__doubleC", "NK1A1fEd")
|
||||
{1:"A::f__doubleC", 2:"NK1A1fEd"})
|
||||
check("function", "void f(std::shared_ptr<int(double)> ptr)",
|
||||
None, "1fNSt10shared_ptrIFidEEE")
|
||||
check("function", "void f(int *const p)", "f__iPC", "1fPCi")
|
||||
check("function", "void f(int *volatile const p)", "f__iPVC", "1fPVCi")
|
||||
{2:"1fNSt10shared_ptrIFidEEE"})
|
||||
check("function", "void f(int *const p)", {1:"f__iPC", 2:"1fPCi"})
|
||||
check("function", "void f(int *volatile const p)", {1:"f__iPVC", 2:"1fPVCi"})
|
||||
|
||||
check('function', 'extern int f()', 'f', '1fv')
|
||||
check('function', 'extern int f()', {1:'f', 2:'1fv'})
|
||||
|
||||
# TODO: make tests for functions in a template, e.g., Test<int&&()>
|
||||
# such that the id generation for function type types is correct.
|
||||
|
||||
check('function', 'friend std::ostream &f(std::ostream&, int)',
|
||||
'f__osR.i', '1fRNSt7ostreamEi')
|
||||
{1:'f__osR.i', 2:'1fRNSt7ostreamEi'})
|
||||
|
||||
# from breathe#223
|
||||
check('function', 'void f(struct E e)', 'f__E', '1f1E')
|
||||
check('function', 'void f(class E e)', 'f__E', '1f1E')
|
||||
check('function', 'void f(typename E e)', 'f__E', '1f1E')
|
||||
check('function', 'void f(enum E e)', 'f__E', '1f1E')
|
||||
check('function', 'void f(union E e)', 'f__E', '1f1E')
|
||||
check('function', 'void f(struct E e)', {1:'f__E', 2:'1f1E'})
|
||||
check('function', 'void f(class E e)', {1:'f__E', 2:'1f1E'})
|
||||
check('function', 'void f(typename E e)', {1:'f__E', 2:'1f1E'})
|
||||
check('function', 'void f(enum E e)', {1:'f__E', 2:'1f1E'})
|
||||
check('function', 'void f(union E e)', {1:'f__E', 2:'1f1E'})
|
||||
|
||||
# pointer to member (function)
|
||||
check('function', 'void f(int C::*)', None, '1fM1Ci')
|
||||
check('function', 'void f(int C::* p)', None, '1fM1Ci')
|
||||
check('function', 'void f(int ::C::* p)', None, '1fM1Ci')
|
||||
check('function', 'void f(int C::* const)', None, '1fKM1Ci')
|
||||
check('function', 'void f(int C::* const&)', None, '1fRKM1Ci')
|
||||
check('function', 'void f(int C::* volatile)', None, '1fVM1Ci')
|
||||
check('function', 'void f(int C::* const volatile)', None, '1fVKM1Ci',
|
||||
check('function', 'void f(int C::*)', {2:'1fM1Ci'})
|
||||
check('function', 'void f(int C::* p)', {2:'1fM1Ci'})
|
||||
check('function', 'void f(int ::C::* p)', {2:'1fM1Ci'})
|
||||
check('function', 'void f(int C::* const)', {2:'1fKM1Ci'})
|
||||
check('function', 'void f(int C::* const&)', {2:'1fRKM1Ci'})
|
||||
check('function', 'void f(int C::* volatile)', {2:'1fVM1Ci'})
|
||||
check('function', 'void f(int C::* const volatile)', {2:'1fVKM1Ci'},
|
||||
output='void f(int C::* volatile const)')
|
||||
check('function', 'void f(int C::* volatile const)', None, '1fVKM1Ci')
|
||||
check('function', 'void f(int (C::*)(float, double))', None, '1fM1CFifdE')
|
||||
check('function', 'void f(int (C::* p)(float, double))', None, '1fM1CFifdE')
|
||||
check('function', 'void f(int (::C::* p)(float, double))', None, '1fM1CFifdE')
|
||||
check('function', 'void f(void (C::*)() const &)', None, '1fM1CKRFvvE')
|
||||
check('function', 'int C::* f(int, double)', None, '1fid')
|
||||
check('function', 'void f(int C::* *)', None, '1fPM1Ci')
|
||||
check('function', 'void f(int C::* volatile const)', {2:'1fVKM1Ci'})
|
||||
check('function', 'void f(int (C::*)(float, double))', {2:'1fM1CFifdE'})
|
||||
check('function', 'void f(int (C::* p)(float, double))', {2:'1fM1CFifdE'})
|
||||
check('function', 'void f(int (::C::* p)(float, double))', {2:'1fM1CFifdE'})
|
||||
check('function', 'void f(void (C::*)() const &)', {2:'1fM1CKRFvvE'})
|
||||
check('function', 'int C::* f(int, double)', {2:'1fid'})
|
||||
check('function', 'void f(int C::* *)', {2:'1fPM1Ci'})
|
||||
|
||||
|
||||
def test_operators():
|
||||
check('function', 'void operator new [ ] ()',
|
||||
"new-array-operator", "nav", output='void operator new[]()')
|
||||
{1:"new-array-operator", 2:"nav"}, output='void operator new[]()')
|
||||
check('function', 'void operator delete ()',
|
||||
"delete-operator", "dlv", output='void operator delete()')
|
||||
{1:"delete-operator", 2:"dlv"}, output='void operator delete()')
|
||||
check('function', 'operator bool() const',
|
||||
"castto-b-operatorC", "NKcvbEv", output='operator bool() const')
|
||||
{1:"castto-b-operatorC", 2:"NKcvbEv"}, output='operator bool() const')
|
||||
|
||||
check('function', 'void operator * ()',
|
||||
"mul-operator", "mlv", output='void operator*()')
|
||||
{1:"mul-operator", 2:"mlv"}, output='void operator*()')
|
||||
check('function', 'void operator - ()',
|
||||
"sub-operator", "miv", output='void operator-()')
|
||||
{1:"sub-operator", 2:"miv"}, output='void operator-()')
|
||||
check('function', 'void operator + ()',
|
||||
"add-operator", "plv", output='void operator+()')
|
||||
{1:"add-operator", 2:"plv"}, output='void operator+()')
|
||||
check('function', 'void operator = ()',
|
||||
"assign-operator", "aSv", output='void operator=()')
|
||||
{1:"assign-operator", 2:"aSv"}, output='void operator=()')
|
||||
check('function', 'void operator / ()',
|
||||
"div-operator", "dvv", output='void operator/()')
|
||||
{1:"div-operator", 2:"dvv"}, output='void operator/()')
|
||||
check('function', 'void operator % ()',
|
||||
"mod-operator", "rmv", output='void operator%()')
|
||||
{1:"mod-operator", 2:"rmv"}, output='void operator%()')
|
||||
check('function', 'void operator ! ()',
|
||||
"not-operator", "ntv", output='void operator!()')
|
||||
{1:"not-operator", 2:"ntv"}, output='void operator!()')
|
||||
|
||||
check('function', 'void operator "" _udl()',
|
||||
None, 'li4_udlv', output='void operator""_udl()')
|
||||
{2:'li4_udlv'}, output='void operator""_udl()')
|
||||
|
||||
|
||||
def test_class_definitions():
|
||||
check('class', 'public A', "A", "1A", output='A')
|
||||
check('class', 'private A', "A", "1A")
|
||||
check('class', 'A final', 'A', '1A')
|
||||
check('class', 'public A', {1:"A", 2:"1A"}, output='A')
|
||||
check('class', 'private A', {1:"A", 2:"1A"})
|
||||
check('class', 'A final', {1:'A', 2:'1A'})
|
||||
|
||||
# test bases
|
||||
check('class', 'A', "A", "1A")
|
||||
check('class', 'A::B::C', "A::B::C", "N1A1B1CE")
|
||||
check('class', 'A : B', "A", "1A")
|
||||
check('class', 'A : private B', "A", "1A", output='A : B')
|
||||
check('class', 'A : public B', "A", "1A")
|
||||
check('class', 'A : B, C', "A", "1A")
|
||||
check('class', 'A : B, protected C, D', "A", "1A")
|
||||
check('class', 'A : virtual private B', 'A', '1A', output='A : virtual B')
|
||||
check('class', 'A : B, virtual C', 'A', '1A')
|
||||
check('class', 'A : public virtual B', 'A', '1A')
|
||||
check('class', 'A : B, C...', 'A', '1A')
|
||||
check('class', 'A : B..., C', 'A', '1A')
|
||||
check('class', 'A', {1:"A", 2:"1A"})
|
||||
check('class', 'A::B::C', {1:"A::B::C", 2:"N1A1B1CE"})
|
||||
check('class', 'A : B', {1:"A", 2:"1A"})
|
||||
check('class', 'A : private B', {1:"A", 2:"1A"}, output='A : B')
|
||||
check('class', 'A : public B', {1:"A", 2:"1A"})
|
||||
check('class', 'A : B, C', {1:"A", 2:"1A"})
|
||||
check('class', 'A : B, protected C, D', {1:"A", 2:"1A"})
|
||||
check('class', 'A : virtual private B', {1:'A', 2:'1A'}, output='A : virtual B')
|
||||
check('class', 'A : B, virtual C', {1:'A', 2:'1A'})
|
||||
check('class', 'A : public virtual B', {1:'A', 2:'1A'})
|
||||
check('class', 'A : B, C...', {1:'A', 2:'1A'})
|
||||
check('class', 'A : B..., C', {1:'A', 2:'1A'})
|
||||
|
||||
|
||||
def test_enum_definitions():
|
||||
check('enum', 'A', None, "1A")
|
||||
check('enum', 'A : std::underlying_type<B>::type', None, "1A")
|
||||
check('enum', 'A : unsigned int', None, "1A")
|
||||
check('enum', 'public A', None, "1A", output='A')
|
||||
check('enum', 'private A', None, "1A")
|
||||
check('enum', 'A', {2:"1A"})
|
||||
check('enum', 'A : std::underlying_type<B>::type', {2:"1A"})
|
||||
check('enum', 'A : unsigned int', {2:"1A"})
|
||||
check('enum', 'public A', {2:"1A"}, output='A')
|
||||
check('enum', 'private A', {2:"1A"})
|
||||
|
||||
check('enumerator', 'A', None, "1A")
|
||||
check('enumerator', 'A = std::numeric_limits<unsigned long>::max()',
|
||||
None, "1A")
|
||||
check('enumerator', 'A', {2:"1A"})
|
||||
check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2:"1A"})
|
||||
|
||||
|
||||
def test_templates():
|
||||
check('class', "A<T>", None, "IE1AI1TE", output="template<> A<T>")
|
||||
check('class', "A<T>", {2:"IE1AI1TE"}, output="template<> A<T>")
|
||||
# first just check which objects support templating
|
||||
check('class', "template<> A", None, "IE1A")
|
||||
check('function', "template<> void A()", None, "IE1Av")
|
||||
check('member', "template<> A a", None, "IE1a")
|
||||
check('type', "template<> a = A", None, "IE1a")
|
||||
check('class', "template<> A", {2:"IE1A"})
|
||||
check('function', "template<> void A()", {2:"IE1Av"})
|
||||
check('member', "template<> A a", {2:"IE1a"})
|
||||
check('type', "template<> a = A", {2:"IE1a"})
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('enum', "template<> A")
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('enumerator', "template<> A")
|
||||
# then all the real tests
|
||||
check('class', "template<typename T1, typename T2> A", None, "I00E1A")
|
||||
check('type', "template<> a", None, "IE1a")
|
||||
check('class', "template<typename T1, typename T2> A", {2:"I00E1A"})
|
||||
check('type', "template<> a", {2:"IE1a"})
|
||||
|
||||
check('class', "template<typename T> A", None, "I0E1A")
|
||||
check('class', "template<class T> A", None, "I0E1A")
|
||||
check('class', "template<typename ...T> A", None, "IDpE1A")
|
||||
check('class', "template<typename...> A", None, "IDpE1A")
|
||||
check('class', "template<typename = Test> A", None, "I0E1A")
|
||||
check('class', "template<typename T = Test> A", None, "I0E1A")
|
||||
check('class', "template<typename T> A", {2:"I0E1A"})
|
||||
check('class', "template<class T> A", {2:"I0E1A"})
|
||||
check('class', "template<typename ...T> A", {2:"IDpE1A"})
|
||||
check('class', "template<typename...> A", {2:"IDpE1A"})
|
||||
check('class', "template<typename = Test> A", {2:"I0E1A"})
|
||||
check('class', "template<typename T = Test> A", {2:"I0E1A"})
|
||||
|
||||
check('class', "template<template<typename> typename T> A",
|
||||
None, "II0E0E1A")
|
||||
check('class', "template<int> A", None, "I_iE1A")
|
||||
check('class', "template<int T> A", None, "I_iE1A")
|
||||
check('class', "template<int... T> A", None, "I_DpiE1A")
|
||||
check('class', "template<int T = 42> A", None, "I_iE1A")
|
||||
check('class', "template<int = 42> A", None, "I_iE1A")
|
||||
check('class', "template<template<typename> typename T> A", {2:"II0E0E1A"})
|
||||
check('class', "template<int> A", {2:"I_iE1A"})
|
||||
check('class', "template<int T> A", {2:"I_iE1A"})
|
||||
check('class', "template<int... T> A", {2:"I_DpiE1A"})
|
||||
check('class', "template<int T = 42> A", {2:"I_iE1A"})
|
||||
check('class', "template<int = 42> A", {2:"I_iE1A"})
|
||||
|
||||
# from #2058
|
||||
check('function',
|
||||
@ -413,8 +416,8 @@ def test_templates():
|
||||
"inline std::basic_ostream<Char, Traits> &operator<<("
|
||||
"std::basic_ostream<Char, Traits> &os, "
|
||||
"const c_string_view_base<const Char, Traits> &str)",
|
||||
None, "I00ElsRNSt13basic_ostreamI4Char6TraitsEE"
|
||||
"RK18c_string_view_baseIK4Char6TraitsE")
|
||||
{2:"I00ElsRNSt13basic_ostreamI4Char6TraitsEE"
|
||||
"RK18c_string_view_baseIK4Char6TraitsE"})
|
||||
|
||||
# template introductions
|
||||
with pytest.raises(DefinitionError):
|
||||
@ -422,63 +425,61 @@ def test_templates():
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('enumerator', 'abc::ns::foo{id_0, id_1, id_2} A')
|
||||
check('class', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar',
|
||||
None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE')
|
||||
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
|
||||
check('class', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar',
|
||||
None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE')
|
||||
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
|
||||
check('class', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar<id_0, id_1, id_2>',
|
||||
None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barI4id_04id_14id_2EE')
|
||||
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barI4id_04id_14id_2EE'})
|
||||
check('class', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar<id_0, id_1, id_2...>',
|
||||
None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barI4id_04id_1Dp4id_2EE')
|
||||
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barI4id_04id_1Dp4id_2EE'})
|
||||
|
||||
check('class', 'template<> Concept{U} A<int>::B',
|
||||
None, 'IEI0EX7ConceptI1UEEN1AIiE1BE')
|
||||
check('class', 'template<> Concept{U} A<int>::B', {2:'IEI0EX7ConceptI1UEEN1AIiE1BE'})
|
||||
|
||||
check('type', 'abc::ns::foo{id_0, id_1, id_2} xyz::bar = ghi::qux',
|
||||
None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE')
|
||||
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
|
||||
check('type', 'abc::ns::foo{id_0, id_1, ...id_2} xyz::bar = ghi::qux',
|
||||
None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE')
|
||||
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
|
||||
check('function', 'abc::ns::foo{id_0, id_1, id_2} void xyz::bar()',
|
||||
None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barEv')
|
||||
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barEv'})
|
||||
check('function', 'abc::ns::foo{id_0, id_1, ...id_2} void xyz::bar()',
|
||||
None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barEv')
|
||||
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barEv'})
|
||||
check('member', 'abc::ns::foo{id_0, id_1, id_2} ghi::qux xyz::bar',
|
||||
None, 'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE')
|
||||
{2:'I000EXN3abc2ns3fooEI4id_04id_14id_2EEN3xyz3barE'})
|
||||
check('member', 'abc::ns::foo{id_0, id_1, ...id_2} ghi::qux xyz::bar',
|
||||
None, 'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE')
|
||||
check('concept', 'Iterator{T, U} Another',
|
||||
None, 'I00EX8IteratorI1T1UEE7Another')
|
||||
{2:'I00DpEXN3abc2ns3fooEI4id_04id_1sp4id_2EEN3xyz3barE'})
|
||||
check('concept', 'Iterator{T, U} Another', {2:'I00EX8IteratorI1T1UEE7Another'})
|
||||
check('concept', 'template<typename ...Pack> Numerics = (... && Numeric<Pack>)',
|
||||
None, 'IDpE8Numerics')
|
||||
{2:'IDpE8Numerics'})
|
||||
|
||||
def test_template_args():
|
||||
# from breathe#218
|
||||
check('function',
|
||||
"template<typename F> "
|
||||
"void allow(F *f, typename func<F, B, G!=1>::type tt)",
|
||||
None, "I0E5allowP1FN4funcI1F1BXG!=1EE4typeE")
|
||||
{2:"I0E5allowP1FN4funcI1F1BXG!=1EE4typeE"})
|
||||
# from #3542
|
||||
check('type', "template<typename T> "
|
||||
"enable_if_not_array_t = std::enable_if_t<!is_array<T>::value, int>",
|
||||
None, "I0E21enable_if_not_array_t")
|
||||
{2:"I0E21enable_if_not_array_t"})
|
||||
|
||||
def test_attributes():
|
||||
# style: C++
|
||||
check('member', '[[]] int f', 'f__i', '1f')
|
||||
check('member', '[ [ ] ] int f', 'f__i', '1f',
|
||||
check('member', '[[]] int f', {1:'f__i', 2:'1f'})
|
||||
check('member', '[ [ ] ] int f', {1:'f__i', 2:'1f'},
|
||||
# this will fail when the proper grammar is implemented
|
||||
output='[[ ]] int f')
|
||||
check('member', '[[a]] int f', 'f__i', '1f')
|
||||
check('member', '[[a]] int f', {1:'f__i', 2:'1f'})
|
||||
# style: GNU
|
||||
check('member', '__attribute__(()) int f', 'f__i', '1f')
|
||||
check('member', '__attribute__((a)) int f', 'f__i', '1f')
|
||||
check('member', '__attribute__((a, b)) int f', 'f__i', '1f')
|
||||
check('member', '__attribute__(()) int f', {1:'f__i', 2:'1f'})
|
||||
check('member', '__attribute__((a)) int f', {1:'f__i', 2:'1f'})
|
||||
check('member', '__attribute__((a, b)) int f', {1:'f__i', 2:'1f'})
|
||||
# style: user-defined id
|
||||
check('member', 'id_attr int f', 'f__i', '1f')
|
||||
check('member', 'id_attr int f', {1:'f__i', 2:'1f'})
|
||||
# style: user-defined paren
|
||||
check('member', 'paren_attr() int f', 'f__i', '1f')
|
||||
check('member', 'paren_attr(a) int f', 'f__i', '1f')
|
||||
check('member', 'paren_attr("") int f', 'f__i', '1f')
|
||||
check('member', 'paren_attr(()[{}][]{}) int f', 'f__i', '1f')
|
||||
check('member', 'paren_attr() int f', {1:'f__i', 2:'1f'})
|
||||
check('member', 'paren_attr(a) int f', {1:'f__i', 2:'1f'})
|
||||
check('member', 'paren_attr("") int f', {1:'f__i', 2:'1f'})
|
||||
check('member', 'paren_attr(()[{}][]{}) int f', {1:'f__i', 2:'1f'})
|
||||
with pytest.raises(DefinitionError):
|
||||
parse('member', 'paren_attr(() int f')
|
||||
with pytest.raises(DefinitionError):
|
||||
@ -494,7 +495,7 @@ def test_attributes():
|
||||
|
||||
# position: decl specs
|
||||
check('function', 'static inline __attribute__(()) void f()',
|
||||
'f', '1fv',
|
||||
{1:'f', 2:'1fv'},
|
||||
output='__attribute__(()) static inline void f()')
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user