diff options
Diffstat (limited to 'tests/test_domain_cpp.py')
| -rw-r--r-- | tests/test_domain_cpp.py | 617 |
1 files changed, 375 insertions, 242 deletions
diff --git a/tests/test_domain_cpp.py b/tests/test_domain_cpp.py index 7437b4c05..3561e76ce 100644 --- a/tests/test_domain_cpp.py +++ b/tests/test_domain_cpp.py @@ -16,30 +16,25 @@ 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): cpp_id_attributes = ["id_attr"] cpp_paren_attributes = ["paren_attr"] parser = DefinitionParser(string, None, Config()) + parser.allowFallbackExpressionParsing = False ast = parser.parse_declaration(name) - if not parser.eof: - print("Parsing stopped at", parser.pos) - print(string) - print('-' * parser.pos + '^') - raise DefinitionError("") + parser.assert_end() # The scopedness would usually have been set by CPPEnumObject if name == "enum": ast.scoped = None # simulate unscoped enum 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,37 +53,43 @@ 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(): # see http://en.cppreference.com/w/cpp/language/types for t, id_v2 in cppDomain._id_fundamental_v2.items(): - if t == "decltype(auto)": - continue - def makeIdV1(): + if t == 'decltype(auto)': + return None id = t.replace(" ", "-").replace("long", "l").replace("int", "i") id = id.replace("bool", "b").replace("char", "c") id = id.replace("wc_t", "wchar_t").replace("c16_t", "char16_t") @@ -100,55 +101,163 @@ 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_expressions(): + def exprCheck(expr, id): + ids = 'IE1CIA%s_1aE' + check('class', 'template<> C<a[%s]>' % expr, {2: ids % expr, 3: ids % id}) + # primary + exprCheck('nullptr', 'LDnE') + exprCheck('true', 'L1E') + exprCheck('false', 'L0E') + ints = ['5', '0', '075', '0xF', '0XF', '0b1', '0B1'] + unsignedSuffix = ['', 'u', 'U'] + longSuffix = ['', 'l', 'L', 'll', 'LL'] + for i in ints: + for u in unsignedSuffix: + for l in longSuffix: + expr = i + u + l + exprCheck(expr, 'L' + expr + 'E') + expr = i + l + u + exprCheck(expr, 'L' + expr + 'E') + for suffix in ['', 'f', 'F', 'l', 'L']: + expr = '5.0' + suffix + exprCheck(expr, 'L' + expr + 'E') + exprCheck('"abc\\"cba"', 'LA8_KcE') # string + # TODO: test the rest + exprCheck('(... + Ns)', '(... + Ns)') + exprCheck('(5)', 'L5E') + exprCheck('C', '1C') + # postfix + exprCheck('A(2)', 'cl1AL2EE') + exprCheck('A[2]', 'ix1AL2E') + exprCheck('a.b.c', 'dtdt1a1b1c') + exprCheck('a->b->c', 'ptpt1a1b1c') + exprCheck('i++', 'pp1i') + exprCheck('i--', 'mm1i') + # TODO, those with prefixes + # unary + exprCheck('++5', 'pp_L5E') + exprCheck('--5', 'mm_L5E') + exprCheck('*5', 'deL5E') + exprCheck('&5', 'adL5E') + exprCheck('+5', 'psL5E') + exprCheck('-5', 'ngL5E') + exprCheck('!5', 'ntL5E') + exprCheck('~5', 'coL5E') + exprCheck('sizeof...(a)', 'sZ1a') + exprCheck('sizeof(T)', 'st1T') + exprCheck('sizeof -42', 'szngL42E') + exprCheck('alignof(T)', 'at1T') + exprCheck('noexcept(-42)', 'nxngL42E') + # cast + exprCheck('(int)2', 'cviL2E') + # binary op + exprCheck('5 || 42', 'ooL5EL42E') + exprCheck('5 && 42', 'aaL5EL42E') + exprCheck('5 | 42', 'orL5EL42E') + exprCheck('5 ^ 42', 'eoL5EL42E') + exprCheck('5 & 42', 'anL5EL42E') + # ['==', '!='] + exprCheck('5 == 42', 'eqL5EL42E') + exprCheck('5 != 42', 'neL5EL42E') + # ['<=', '>=', '<', '>'] + exprCheck('5 <= 42', 'leL5EL42E') + exprCheck('5 >= 42', 'geL5EL42E') + exprCheck('5 < 42', 'ltL5EL42E') + exprCheck('5 > 42', 'gtL5EL42E') + # ['<<', '>>'] + exprCheck('5 << 42', 'lsL5EL42E') + exprCheck('5 >> 42', 'rsL5EL42E') + # ['+', '-'] + exprCheck('5 + 42', 'plL5EL42E') + exprCheck('5 - 42', 'miL5EL42E') + # ['*', '/', '%'] + exprCheck('5 * 42', 'mlL5EL42E') + exprCheck('5 / 42', 'dvL5EL42E') + exprCheck('5 % 42', 'rmL5EL42E') + # ['.*', '->*'] + exprCheck('5 .* 42', 'dsL5EL42E') + exprCheck('5 ->* 42', 'pmL5EL42E') + # conditional + # TODO + # assignment + exprCheck('a = 5', 'aS1aL5E') + exprCheck('a *= 5', 'mL1aL5E') + exprCheck('a /= 5', 'dV1aL5E') + exprCheck('a %= 5', 'rM1aL5E') + exprCheck('a += 5', 'pL1aL5E') + exprCheck('a -= 5', 'mI1aL5E') + exprCheck('a >>= 5', 'rS1aL5E') + exprCheck('a <<= 5', 'lS1aL5E') + exprCheck('a &= 5', 'aN1aL5E') + exprCheck('a ^= 5', 'eO1aL5E') + exprCheck('a |= 5', 'oR1aL5E') + + # Additional tests + # a < expression that starts with something that could be a template + exprCheck('A < 42', 'lt1AL42E') + check('function', 'template<> void f(A<B, 2> &v)', + {2: "IE1fR1AI1BX2EE", 3: "IE1fR1AI1BXL2EEE"}) + exprCheck('A<1>::value', 'N1AIXL1EEE5valueE') + check('class', "template<int T = 42> A", {2: "I_iE1A"}) + check('enumerator', 'A = std::numeric_limits<unsigned long>::max()', {2: "1A"}) + + exprCheck('operator()()', 'clclE') + exprCheck('operator()<int>()', 'clclIiEE') 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'}) + check('type', 'A = decltype(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'}) + + check('type', 'T = A::template B<int>::template C<double>', {2: '1T'}) + + check('type', 'T = Q<A::operator()>', {2: '1T'}) + check('type', 'T = Q<A::operator()<int>>', {2: '1T'}) + check('type', 'T = Q<A::operator bool>', {2: '1T'}) 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') - check('concept', 'template<typename Param> A::B::Concept()', - None, '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): @@ -157,256 +266,270 @@ 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", + 3: "NKclERKN5boost5arrayI8VertexIDXL2EEEE"}) 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', + 3: 'NKclERKN5boost5arrayI8VertexIDXL2EEXLA9_KcEEEE'}) 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", + 3: "NK6module4testEiA1n_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", 3: "1fRAL10E_i"}) + check("function", "void f(int (&array)[10])", {2: "1fRA10_i", 3: "1fRAL10E_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()', {1: 'f', 2: '1fv'}) - check('function', 'extern int f()', 'f', '1fv') + check('function', 'decltype(auto) 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'}) + + # from #4094 + check('class', 'template<class, class = std::void_t<>> has_var', {2: 'I00E7has_var'}) + check('class', 'template<class T> has_var<T, std::void_t<decltype(&T::var)>>', + {2: 'I0E7has_varI1TNSt6void_tIDTadN1T3varEEEEE'}) 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 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<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<typename T1, typename T2> A", {2: "I00E1A"}) + check('type', "template<> a", {2: "IE1a"}) + + 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", {2: "II0E0E1A"}) + check('class', "template<template<typename> typename> A", {2: "II0E0E1A"}) + check('class', "template<template<typename> typename ...T> A", {2: "II0EDpE1A"}) + check('class', "template<template<typename> typename...> A", {2: "II0EDpE1A"}) + + 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"}) + + check('class', "template<> A<NS::B<>>", {2: "IE1AIN2NS1BIEEE"}) # from #2058 check('function', @@ -414,8 +537,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): @@ -423,65 +546,75 @@ 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'}) + + # explicit specializations of members + check('member', 'template<> int A<int>::a', {2: 'IEN1AIiE1aE'}) + check('member', 'template int A<int>::a', {2: 'IEN1AIiE1aE'}, + output='template<> int A<int>::a') # same as above + check('member', 'template<> template<> int A<int>::B<int>::b', {2: 'IEIEN1AIiE1BIiE1bE'}) + check('member', 'template int A<int>::B<int>::b', {2: 'IEIEN1AIiE1BIiE1bE'}, + output='template<> template<> int A<int>::B<int>::b') # same as above + + # defaulted constrained type parameters + check('type', 'template<C T = int&> A', {2: 'I_1CE1A'}) 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") + "void allow(F *f, typename func<F, B, G != 1>::type tt)", + {2: "I0E5allowP1FN4funcI1F1BXG != 1EE4typeE", + 3: "I0E5allowP1FN4funcI1F1BXne1GL1EEE4typeE"}) # 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): @@ -497,7 +630,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()') |