Test: move another batch of tests to to pytest

Make also sure some type qualifiers attributes are booleans
Fix some container traits

Author: iMichka

src/pygccxml/declarations/container_traits.py

@@ -647,14 +647,14 @@ def remove_defaults(self, type_or_string):
 
 unordered_set_traits = container_traits_impl_t(
     'unordered_set',
-    1,
+    0,
     'value_type',
     'erase_hash_allocator',
     unordered_maps_and_sets=True)
 
 unordered_multiset_traits = container_traits_impl_t(
     'unordered_multiset',
-    1,
+    0,
     'value_type',
     'erase_hash_allocator',
     unordered_maps_and_sets=True)

src/pygccxml/parser/scanner.py

@@ -630,9 +630,9 @@ def __read_typedef(self, attrs):
 
     def __read_variable(self, attrs):
         type_qualifiers = declarations.type_qualifiers_t()
-        type_qualifiers.has_mutable = attrs.get(XML_AN_MUTABLE, False)
-        type_qualifiers.has_static = attrs.get(XML_AN_STATIC, False)
-        type_qualifiers.has_extern = attrs.get(XML_AN_EXTERN, False)
+        type_qualifiers.has_mutable = bool(attrs.get(XML_AN_MUTABLE, False))
+        type_qualifiers.has_static = bool(attrs.get(XML_AN_STATIC, False))
+        type_qualifiers.has_extern = bool(attrs.get(XML_AN_EXTERN, False))
         bits = attrs.get(XML_AN_BITS)
         if bits:
             bits = int(bits)

tests/conftest.py

@@ -12,6 +12,31 @@ def _test_type_composition(type_, expected_compound, expected_base):
         assert isinstance(type_, expected_compound)
         assert isinstance(type_.base, expected_base)
 
+    @staticmethod
+    def _test_calldef_args(calldef, expected_args):
+        assert len(calldef.arguments) == len(expected_args)
+
+        for i, expected_arg in enumerate(expected_args):
+            arg = calldef.arguments[i]
+            assert arg == expected_arg
+
+    @staticmethod
+    def _test_calldef_return_type(calldef, expected_type):
+        assert isinstance(calldef.return_type, expected_type)
+
+    @staticmethod
+    def _test_calldef_exceptions(global_ns, calldef, exceptions):
+        # exceptions is list of classes names
+        exception_decls = []
+        for name in exceptions:
+            exception_decl = global_ns.class_(name)
+            assert exception_decl is not None
+            exception_decls.append(exception_decl)
+        exception_decls.sort()
+        assert len(calldef.exceptions) == len(exception_decls)
+        exceptions_indeed = sorted(calldef.exceptions[:])
+        assert exception_decls == exceptions_indeed
+
 
 @pytest.fixture
 def helpers():

tests/test_declarations.py

@@ -0,0 +1,269 @@
+# Copyright 2014-2017 Insight Software Consortium.
+# Copyright 2004-2009 Roman Yakovenko.
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+
+import pytest
+
+from . import autoconfig
+
+from pygccxml import parser
+from pygccxml import declarations
+
+TEST_FILES = [
+    'declarations_enums.hpp',
+    'declarations_variables.hpp',
+    'declarations_calldef.hpp'
+]
+
+@pytest.fixture
+def global_ns_fixture_all_at_once():
+    COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
+    config = autoconfig.cxx_parsers_cfg.config.clone()
+    decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
+    global_ns = declarations.get_global_namespace(decls)
+    return global_ns
+
+@pytest.fixture
+def global_ns_fixture_file_by_file():
+    COMPILATION_MODE = parser.COMPILATION_MODE.FILE_BY_FILE
+    config = autoconfig.cxx_parsers_cfg.config.clone()
+    decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
+    global_ns = declarations.get_global_namespace(decls)
+    return global_ns
+
+@pytest.fixture
+def global_ns(request):
+    return request.getfixturevalue(request.param)
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_enumeration_t(global_ns):
+    enum = global_ns.enumeration('ENumbers')
+    expected_values = list(
+        zip(['e%d' % index for index in range(10)],
+            [index for index in range(10)]))
+    assert expected_values == enum.values
+
+def test_namespace():
+    pass  # tested in core_tester
+
+def test_types():
+    pass  # tested in core_tester
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_variables(global_ns, helpers):
+    global_ns.namespace('variables')
+    initialized = global_ns.variable(name='initialized')
+
+    expected_value = '10122004'
+    assert initialized.value == expected_value
+    helpers._test_type_composition(
+        initialized.decl_type,
+        declarations.const_t,
+        declarations.long_unsigned_int_t)
+
+    m_mutable = global_ns.variable(name="m_mutable")
+    assert m_mutable.type_qualifiers.has_static is False
+    assert m_mutable.type_qualifiers.has_mutable is True
+
+    # External static variable
+    extern_var = global_ns.variable(name="extern_var")
+    assert extern_var.type_qualifiers.has_extern is True
+    assert extern_var.type_qualifiers.has_static is False
+    assert extern_var.type_qualifiers.has_mutable is False
+
+    # Static variable
+    static_var = global_ns.variable(name="static_var")
+    assert static_var.type_qualifiers.has_static is True
+    assert static_var.type_qualifiers.has_extern is False
+    assert static_var.type_qualifiers.has_mutable is False
+
+    ssv_static_var = global_ns.variable(name="ssv_static_var")
+    assert ssv_static_var.type_qualifiers.has_static is True
+    assert ssv_static_var.type_qualifiers.has_extern is False
+    assert ssv_static_var.type_qualifiers.has_mutable is False
+
+    ssv_static_var_value = global_ns.variable(
+        name="ssv_static_var_value")
+    assert ssv_static_var_value.type_qualifiers.has_static is True
+    assert ssv_static_var_value.type_qualifiers.has_extern is False
+    assert ssv_static_var_value.type_qualifiers.has_mutable is False
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_calldef_free_functions(global_ns, helpers):
+    ns = global_ns.namespace('calldef')
+
+    no_return_no_args = ns.free_function('no_return_no_args')
+
+    helpers._test_calldef_return_type(no_return_no_args, declarations.void_t)
+    assert no_return_no_args.has_extern is False
+
+    # Static_call is explicetely defined as extern, this works with gccxml
+    # and castxml.
+    static_call = ns.free_function('static_call')
+    assert static_call is not None
+
+    return_no_args = ns.free_function('return_no_args')
+    helpers._test_calldef_return_type(return_no_args, declarations.int_t)
+    # from now there is no need to check return type.
+    no_return_1_arg = ns.free_function(name='no_return_1_arg')
+    assert no_return_1_arg is not None
+    assert no_return_1_arg.arguments[0].name in ['arg', 'arg0']
+    helpers._test_calldef_args(
+        no_return_1_arg,
+        [declarations.argument_t(
+            name=no_return_1_arg.arguments[0].name,
+            decl_type=declarations.int_t())])
+
+    return_default_args = ns.free_function('return_default_args')
+    assert return_default_args.arguments[0].name in ['arg', 'arg0']
+    assert return_default_args.arguments[1].name in ['arg1', 'flag']
+    helpers._test_calldef_args(
+        return_default_args,
+        [declarations.argument_t(
+            name=return_default_args.arguments[0].name,
+            decl_type=declarations.int_t(),
+            default_value='1'),
+            declarations.argument_t(
+                name=return_default_args.arguments[1].name,
+                decl_type=declarations.bool_t(),
+                default_value='false')])
+    helpers._test_calldef_exceptions(global_ns, return_default_args, [])
+
+    calldef_with_throw = ns.free_function('calldef_with_throw')
+    assert calldef_with_throw is not None
+    helpers._test_calldef_exceptions(
+        global_ns,
+        calldef_with_throw, [
+            'some_exception_t', 'other_exception_t'])
+    # from now there is no need to check exception specification
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_calldef_member_functions(global_ns, helpers):
+    struct_calldefs = global_ns.class_('calldefs_t')
+
+    member_inline_call = struct_calldefs.member_function(
+        'member_inline_call')
+    helpers._test_calldef_args(
+        member_inline_call, [
+            declarations.argument_t(
+                name='i', decl_type=declarations.int_t())])
+
+    member_const_call = struct_calldefs.member_function(
+        'member_const_call')
+    assert member_const_call.has_const
+    assert member_const_call.virtuality == declarations.VIRTUALITY_TYPES.NOT_VIRTUAL
+
+    member_virtual_call = struct_calldefs.member_function(
+        name='member_virtual_call')
+    assert member_virtual_call.virtuality == declarations.VIRTUALITY_TYPES.VIRTUAL
+
+    member_pure_virtual_call = struct_calldefs.member_function(
+        'member_pure_virtual_call')
+    assert member_pure_virtual_call.virtuality == declarations.VIRTUALITY_TYPES.PURE_VIRTUAL
+
+    static_call = struct_calldefs.member_function('static_call')
+    assert static_call.has_static is True
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_constructors_destructors(global_ns, helpers):
+    struct_calldefs = global_ns.class_('calldefs_t')
+
+    destructor = struct_calldefs.calldef('~calldefs_t')
+    helpers._test_calldef_args(destructor, [])
+    helpers._test_calldef_return_type(destructor, None.__class__)
+
+    # well, now we have a few functions ( constructors ) with the same
+    # name, there is no easy way to find the desired one. Well in my case
+    # I have only 4 constructors
+    # 1. from char
+    # 2. from (int,double)
+    # 3. default
+    # 4. copy constructor
+    constructor_found = struct_calldefs.constructors('calldefs_t')
+    assert len(constructor_found) == 5
+    assert len(
+        [constructor for constructor in constructor_found if
+            declarations.is_copy_constructor(constructor)]) == 1
+    # there is nothing to check about constructors - I know the
+    # implementation of parser.
+    # In this case it doesn't different from any other function
+
+    c = struct_calldefs.constructor('calldefs_t', arg_types=['char'])
+    assert c.explicit is True
+
+    arg_type = declarations.declarated_t(
+        global_ns.class_('some_exception_t'))
+    c = struct_calldefs.constructor('calldefs_t', arg_types=[arg_type])
+    assert c.explicit is False
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_operator_symbol(global_ns):
+    calldefs_operators = ['=', '==']
+    calldefs_cast_operators = ['char *', 'double']
+    struct_calldefs = global_ns.class_('calldefs_t')
+    assert struct_calldefs is not None
+    for decl in struct_calldefs.declarations:
+        if not isinstance(decl, declarations.operator_t):
+            continue
+        if not isinstance(decl, declarations.casting_operator_t):
+            assert decl.symbol in calldefs_operators
+        else:
+            assert decl.return_type.decl_string in calldefs_cast_operators
+
+@pytest.mark.parametrize(
+    "global_ns",
+    [
+        "global_ns_fixture_all_at_once",
+        "global_ns_fixture_file_by_file",
+    ],
+    indirect=True,
+)
+def test_ellipsis(global_ns):
+    ns = global_ns.namespace('ellipsis_tester')
+    do_smth = ns.member_function('do_smth')
+    assert do_smth.has_ellipsis is True
+    do_smth_else = ns.free_function('do_smth_else')
+    assert do_smth_else.has_ellipsis is True