gccxml / pygccxml / 396

pending completion

Build # 396

Build Type

Pull #35

travis-ci

Committed by

praetorian20

Commit Message

<a href="https://github.com/gccxml/pygccxml/commit/1b7a4683d">Fix for differences in nesting of cv-qual types between GCCXML/CastXML

There is a difference in behavior between GCCXML and CastXML for cv-qual
arrays. GCCXML produces the following nesting of types:
   -&gt;  volatile_t(const_t(array_t))
while CastXML produces the following nesting:
   -&gt;  array_t(volatile_t(const_t))
For both cases, we must unwrap the types, remove const_t, and add back
the outer layers.

Change-Id: I</a><a class="double-link" href="https://github.com/gccxml/pygccxml/commit/17c1e1b03">17c1e1b03</a>

Pull Request Pull Request #35: Fixes for cv-qualified arrays

Run Details

78 of 78 new or added lines in 3 files covered. (100.0%)

8347 of 10131 relevant lines covered (82.39%)

10.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.27

/unittests/type_traits_tester.py

# Copyright 2014-2016 Insight Software Consortium.
# Copyright 2004-2008 Roman Yakovenko.
# Distributed under the Boost Software License, Version 1.0.
# See http://www.boost.org/LICENSE_1_0.txt

import unittest
import autoconfig
import parser_test_case

from pygccxml import parser
from pygccxml import declarations
from pygccxml import utils


class tester_t(parser_test_case.parser_test_case_t):
    COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
    declarations = None

    def __init__(self, *args):
        parser_test_case.parser_test_case_t.__init__(self, *args)
        self.header = 'type_traits.hpp'
        self.declarations = None

    def setUp(self):
        if not tester_t.declarations:
            tester_t.declarations = parser.parse([self.header], self.config)
        self.declarations = tester_t.declarations

    def __test_type_category(self, ns_name, controller):
        ns_control = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name=ns_name)
        self.assertTrue(ns_control, "unable to find '%s' namespace" % ns_name)
        ns_yes = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='yes')
        self.assertTrue(ns_yes, "unable to find 'yes' namespace")
        ns_no = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='no')
        self.assertTrue(ns_no, "unable to find 'no' namespace")
        er = 'for type "%s" the answer to the question "%s" should be True'
        for decl in ns_yes.declarations:
            if isinstance(decl, declarations.variable_t):
                self.assertTrue(
                    controller(decl.type),
                    er % (decl.type.decl_string, ns_name))
            elif isinstance(decl, declarations.calldef_t) and \
                    decl.name.startswith('test_'):
                continue
            else:
                self.assertTrue(
                    controller(decl), er % (decl.decl_string, ns_name))
        er = 'for type "%s" the answer to the question "%s" should be False'
        for decl in ns_no.declarations:
            if isinstance(decl, declarations.calldef_t) and \
                    decl.name.startswith('test_'):
                continue

            self.assertFalse(
                controller(decl),
                er % (decl.decl_string, ns_name))

    def __test_type_transformation(self, ns_name, transformer):
        ns_control = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name=ns_name)
        self.assertTrue(ns_control, "unable to find '%s' namespace" % ns_name)
        ns_before = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='before')
        self.assertTrue(ns_before, "unable to find 'before' namespace")
        ns_after = declarations.find_declaration(
            ns_control,
            type=declarations.namespace_t,
            name='after')
        self.assertTrue(ns_after, "unable to find 'after' namespace")

        for tbefore in ns_before.declarations:
            tafter = declarations.find_declaration(
                ns_after,
                name=tbefore.name)
            self.assertTrue(
                tafter,
                "unable to find transformed type definition for type '%s'" %
                tbefore.decl_string)
            transformed = transformer(tbefore)
            self.assertTrue(
                declarations.is_same(
                    transformed,
                    tafter),
                ("there is a difference between expected type({0}) " +
                 "and result({1}). typedef name: {2}").format(
                    declarations.remove_declarated(tafter).decl_string,
                    declarations.remove_declarated(transformed).decl_string,
                    tbefore.decl_string))

    def test_is_enum(self):
        self.__test_type_category('is_enum', declarations.is_enum)

    def test_is_void(self):
        self.__test_type_category('is_void', declarations.is_void)

    def test_is_integral(self):
        self.__test_type_category('is_integral', declarations.is_integral)

    def test_is_pointer(self):
        self.__test_type_category('is_pointer', declarations.is_pointer)

    def test_is_const(self):
        self.__test_type_category('is_const', declarations.is_const)

    def test_is_volatile(self):
        self.__test_type_category('is_volatile', declarations.is_volatile)

    def test_is_reference(self):
        self.__test_type_category('is_reference', declarations.is_reference)

    def test_is_floating_point(self):
        self.__test_type_category(
            'is_floating_point',
            declarations.is_floating_point)

    def test_is_array(self):
        self.__test_type_category('is_array', declarations.is_array)

    def test_is_fundamental(self):
        self.__test_type_category(
            'is_fundamental',
            declarations.is_fundamental)

    def test_is_noncopyable(self):
        self.__test_type_category(
            'is_noncopyable',
            declarations.is_noncopyable)

    def test_is_std_ostream(self):
        self.__test_type_category(
            'is_std_ostream',
            declarations.is_std_ostream)

    def test_is_std_wostream(self):
        self.__test_type_category(
            'is_std_wostream',
            declarations.is_std_wostream)

    def test_is_calldef_pointer(self):
        self.__test_type_category(
            'is_calldef_pointer',
            declarations.is_calldef_pointer)

    def test_has_trivial_constructor(self):
        self.__test_type_category(
            'has_trivial_constructor',
            declarations.has_trivial_constructor)

    def test_has_public_constructor(self):
        self.__test_type_category(
            'has_public_constructor',
            declarations.has_public_constructor)

    def test_has_public_destructor(self):
        self.__test_type_category(
            'has_public_destructor',
            declarations.has_public_destructor)

    def test_has_any_non_copyconstructor(self):
        self.__test_type_category(
            'has_any_non_copyconstructor',
            declarations.has_any_non_copyconstructor)

    def test_has_copy_constructor(self):
        self.__test_type_category(
            'has_copy_constructor',
            declarations.has_copy_constructor)

    def test_is_base_and_derived(self):
        ns = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name='is_base_and_derived')
        self.assertTrue(ns, "unable to find 'is_base_and_derived' namespace")
        base = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='base')
        derived = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='derived')
        self.assertTrue(
            base and derived and declarations.is_base_and_derived(
                base,
                derived))
        self.assertTrue(
            base and derived and
            declarations.is_base_and_derived(base, (derived, derived)))

        unrelated1 = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='unrelated1')

        unrelated2 = declarations.find_declaration(
            ns.declarations,
            type=declarations.class_t,
            name='unrelated2')
        self.assertTrue(
            base and derived and not declarations.is_base_and_derived(
                unrelated1,
                unrelated2))

    def test_is_same(self):
        self.assertTrue(
            declarations.is_same(
                declarations.int_t,
                declarations.int_t))
        self.assertFalse(
            declarations.is_same(
                declarations.int_t,
                declarations.float_t))

    def test_remove_const(self):
        self.__test_type_transformation(
            'remove_const',
            declarations.remove_const)

    def test_remove_reference(self):
        self.__test_type_transformation(
            'remove_reference',
            declarations.remove_reference)

    def test_remove_volatile(self):
        self.__test_type_transformation(
            'remove_volatile',
            declarations.remove_volatile)

    def test_remove_cv(self):
        self.__test_type_transformation('remove_cv', declarations.remove_cv)

    def test_remove_pointer(self):
        self.__test_type_transformation(
            'remove_pointer',
            declarations.remove_pointer)

    def test_is_unary_binary_operator(self):
        operator_not = declarations.find_declaration(
            self.declarations,
            type=declarations.operator_t,
            fullname='::is_unary_operator::dummy::operator!')
        self.assertTrue(operator_not, 'operator! was not found')
        self.assertTrue(
            declarations.is_unary_operator(operator_not),
            'operator! should be idenitified as unary operator')
        self.assertTrue(
            not declarations.is_binary_operator(operator_not),
            'operator! should be idenitified as unary operator')

        operator_class_p = declarations.find_declaration(
            self.declarations,
            type=declarations.operator_t,
            fullname='::is_unary_operator::dummy::operator+')
        self.assertTrue(operator_class_p, 'operator+ was not found')
        self.assertTrue(
            not declarations.is_unary_operator(operator_class_p),
            'operator+ should be idenitified as binary operator')
        self.assertTrue(
            declarations.is_binary_operator(operator_class_p),
            'operator! should be idenitified as binary operator')

        operator_class_pp = declarations.find_declaration(
            self.declarations,
            type=declarations.operator_t,
            fullname='::is_unary_operator::dummy::operator++')
        self.assertTrue(operator_class_pp, 'operator++ was not found')
        self.assertTrue(
            declarations.is_unary_operator(operator_class_pp),
            'operator++ should be idenitified as unary operator')
        self.assertTrue(
            not declarations.is_binary_operator(operator_class_pp),
            'operator++ should be idenitified as unary operator')

        operator_pp = declarations.find_declaration(
            self.declarations,
            type=declarations.operator_t,
            fullname='::is_unary_operator::operator++')
        self.assertTrue(operator_pp, 'operator++ was not found')
        self.assertTrue(
            declarations.is_unary_operator(operator_pp),
            'operator++ should be idenitified as unary operator')
        self.assertTrue(
            not declarations.is_binary_operator(operator_pp),
            'operator++ should be idenitified as unary operator')

        operator_mm = declarations.find_declaration(
            self.declarations,
            type=declarations.operator_t,
            fullname='::is_unary_operator::operator*')
        self.assertTrue(operator_mm, 'operator-- was not found')
        self.assertTrue(
            not declarations.is_unary_operator(operator_mm),
            'operator-- should be idenitified as binary operator')
        self.assertTrue(
            declarations.is_binary_operator(operator_mm),
            'operator-- should be idenitified as binray operator')

        operator_pe = declarations.find_declaration(
            self.declarations,
            type=declarations.operator_t,
            fullname='::is_unary_operator::operator+=')
        self.assertTrue(operator_pe, 'operator+= was not found')
        self.assertTrue(
            not declarations.is_unary_operator(operator_pe),
            'operator+= should be idenitified as binary operator')
        self.assertTrue(
            declarations.is_binary_operator(operator_pe),
            'operator+= should be idenitified as binray operator')

    def __is_convertible_impl(self, decl):
        defs = decl.bases[0].related_class.declarations
        source_type = declarations.find_declaration(defs, name='source_type')
        target_type = declarations.find_declaration(defs, name='target_type')
        expected_type = declarations.find_declaration(
            defs,
            name='expected',
            type=declarations.enumeration_t)
        expected_value = bool(expected_type.get_name2value_dict()['value'])
        self.assertTrue(
            expected_value == declarations.is_convertible(
                source_type,
                target_type),
            'Check conversion failed for ' +
            decl.name)

    def test_is_convertible(self):
        ns_is_convertible = declarations.find_declaration(
            self.declarations,
            type=declarations.namespace_t,
            name="is_convertible")

        self.assertTrue(
            ns_is_convertible,
            "namespace is_convertible was not found")
        for tester in [
            decl for decl in ns_is_convertible.declarations if
                decl.name.startswith('x')]:

            self.__is_convertible_impl(tester)


class missing_decls_tester_t(unittest.TestCase):

    def test(self):
        config = autoconfig.cxx_parsers_cfg.gccxml
        code = "struct const_item{ const int values[10]; };"
        global_ns = parser.parse_string(code, config)[0]
        ci = global_ns.class_('const_item')
        if 'CastXML' in utils.xml_generator:
            # Constructor, copy constructor, destructor, variable
            self.assertTrue(len(ci.declarations) == 4)
        else:
            # Copy constructor, destructor, variable
            self.assertTrue(len(ci.declarations) == 3)

# class tester_diff_t( parser_test_case.parser_test_case_t ):
    # COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
    # declarations = None
    # def __init__(self, *args ):
        # parser_test_case.parser_test_case_t.__init__( self, *args )
        # self.header = 'type_traits.hpp'
        # self.declarations = None

    # def setUp(self):
        # if not tester_t.declarations:
        # tester_t.declarations = parser.parse([self.header], self.config)
        # self.declarations = tester_t.declarations

    # def test( self ):
        # x = declarations.find_declaration( self.declarations
        # , type=declarations.typedef_t
        # , name="s2s_multimap_type" )
        # print declarations.is_noncopyable( x)
        # declarations.print_declarations(
        #    [declarations.class_traits.get_declaration( x )] )


class class_traits_tester_t(unittest.TestCase):

    def test_get_declaration(self):
        code = """
            namespace A{
            struct B{
                int c;
            };

            template <class T>
            struct C: public T{
                int d;
            };

            template <class T>
            struct D{
                int dD;
            };

            typedef C<B> easy;
            typedef D<easy> Deasy;

            inline void instantiate(){
                int val = sizeof(easy);
            }

            }
        """

        global_ns = parser.parse_string(
            code,
            autoconfig.cxx_parsers_cfg.gccxml)
        global_ns = declarations.get_global_namespace(global_ns)
        easy = global_ns.typedef('easy')
        declarations.class_traits.get_declaration(easy)
        deasy = global_ns.typedef('Deasy')
        d_a = declarations.class_traits.get_declaration(deasy)
        self.assertTrue(isinstance(d_a, declarations.class_types))


def create_suite():
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(class_traits_tester_t))
    suite.addTest(unittest.makeSuite(tester_t))
    suite.addTest(unittest.makeSuite(missing_decls_tester_t))
    return suite


def run_suite():
    unittest.TextTestRunner(verbosity=2).run(create_suite())

if __name__ == "__main__":
    run_suite()

1	# Copyright 2014-2016 Insight Software Consortium.
2	# Copyright 2004-2008 Roman Yakovenko.
3	# Distributed under the Boost Software License, Version 1.0.
4	# See http://www.boost.org/LICENSE_1_0.txt
5
6	import unittest	13✔
7	import autoconfig	13✔
8	import parser_test_case	13✔
9
10	from pygccxml import parser	13✔
11	from pygccxml import declarations	13✔
12	from pygccxml import utils	13✔
13
14
15	class tester_t(parser_test_case.parser_test_case_t):	13✔
16	COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE	13✔
17	declarations = None	13✔
18
19	def __init__(self, *args):	13✔
20	parser_test_case.parser_test_case_t.__init__(self, *args)	13✔
21	self.header = 'type_traits.hpp'	13✔
22	self.declarations = None	13✔
23
24	def setUp(self):	13✔
25	if not tester_t.declarations:	13✔
26	tester_t.declarations = parser.parse([self.header], self.config)	13✔
27	self.declarations = tester_t.declarations	13✔
28
29	def __test_type_category(self, ns_name, controller):	13✔
30	ns_control = declarations.find_declaration(	13✔
31	self.declarations,
32	type=declarations.namespace_t,
33	name=ns_name)
34	self.assertTrue(ns_control, "unable to find '%s' namespace" % ns_name)	13✔
35	ns_yes = declarations.find_declaration(	13✔
36	ns_control,
37	type=declarations.namespace_t,
38	name='yes')
39	self.assertTrue(ns_yes, "unable to find 'yes' namespace")	13✔
40	ns_no = declarations.find_declaration(	13✔
41	ns_control,
42	type=declarations.namespace_t,
43	name='no')
44	self.assertTrue(ns_no, "unable to find 'no' namespace")	13✔
45	er = 'for type "%s" the answer to the question "%s" should be True'	13✔
46	for decl in ns_yes.declarations:	13✔
47	if isinstance(decl, declarations.variable_t):	13✔
48	self.assertTrue(	13✔
49	controller(decl.type),
50	er % (decl.type.decl_string, ns_name))
51	elif isinstance(decl, declarations.calldef_t) and \	13✔
52	decl.name.startswith('test_'):
53	continue	×
54	else:
55	self.assertTrue(	13✔
56	controller(decl), er % (decl.decl_string, ns_name))
57	er = 'for type "%s" the answer to the question "%s" should be False'	13✔
58	for decl in ns_no.declarations:	13✔
59	if isinstance(decl, declarations.calldef_t) and \	13✔
60	decl.name.startswith('test_'):
61	continue	×
62
63	self.assertFalse(	13✔
64	controller(decl),
65	er % (decl.decl_string, ns_name))
66
67	def __test_type_transformation(self, ns_name, transformer):	13✔
68	ns_control = declarations.find_declaration(	13✔
69	self.declarations,
70	type=declarations.namespace_t,
71	name=ns_name)
72	self.assertTrue(ns_control, "unable to find '%s' namespace" % ns_name)	13✔
73	ns_before = declarations.find_declaration(	13✔
74	ns_control,
75	type=declarations.namespace_t,
76	name='before')
77	self.assertTrue(ns_before, "unable to find 'before' namespace")	13✔
78	ns_after = declarations.find_declaration(	13✔
79	ns_control,
80	type=declarations.namespace_t,
81	name='after')
82	self.assertTrue(ns_after, "unable to find 'after' namespace")	13✔
83
84	for tbefore in ns_before.declarations:	13✔
85	tafter = declarations.find_declaration(	13✔
86	ns_after,
87	name=tbefore.name)
88	self.assertTrue(	13✔
89	tafter,
90	"unable to find transformed type definition for type '%s'" %
91	tbefore.decl_string)
92	transformed = transformer(tbefore)	13✔
93	self.assertTrue(	13✔
94	declarations.is_same(
95	transformed,
96	tafter),
97	("there is a difference between expected type({0}) " +
98	"and result({1}). typedef name: {2}").format(
99	declarations.remove_declarated(tafter).decl_string,
100	declarations.remove_declarated(transformed).decl_string,
101	tbefore.decl_string))
102
103	def test_is_enum(self):	13✔
104	self.__test_type_category('is_enum', declarations.is_enum)	13✔
105
106	def test_is_void(self):	13✔
107	self.__test_type_category('is_void', declarations.is_void)	13✔
108
109	def test_is_integral(self):	13✔
110	self.__test_type_category('is_integral', declarations.is_integral)	13✔
111
112	def test_is_pointer(self):	13✔
113	self.__test_type_category('is_pointer', declarations.is_pointer)	13✔
114
115	def test_is_const(self):	13✔
116	self.__test_type_category('is_const', declarations.is_const)	13✔
117
118	def test_is_volatile(self):	13✔
119	self.__test_type_category('is_volatile', declarations.is_volatile)	13✔
120
121	def test_is_reference(self):	13✔
122	self.__test_type_category('is_reference', declarations.is_reference)	13✔
123
124	def test_is_floating_point(self):	13✔
125	self.__test_type_category(	13✔
126	'is_floating_point',
127	declarations.is_floating_point)
128
129	def test_is_array(self):	13✔
130	self.__test_type_category('is_array', declarations.is_array)	13✔
131
132	def test_is_fundamental(self):	13✔
133	self.__test_type_category(	13✔
134	'is_fundamental',
135	declarations.is_fundamental)
136
137	def test_is_noncopyable(self):	13✔
138	self.__test_type_category(	13✔
139	'is_noncopyable',
140	declarations.is_noncopyable)
141
142	def test_is_std_ostream(self):	13✔
143	self.__test_type_category(	13✔
144	'is_std_ostream',
145	declarations.is_std_ostream)
146
147	def test_is_std_wostream(self):	13✔
148	self.__test_type_category(	13✔
149	'is_std_wostream',
150	declarations.is_std_wostream)
151
152	def test_is_calldef_pointer(self):	13✔
153	self.__test_type_category(	13✔
154	'is_calldef_pointer',
155	declarations.is_calldef_pointer)
156
157	def test_has_trivial_constructor(self):	13✔
158	self.__test_type_category(	13✔
159	'has_trivial_constructor',
160	declarations.has_trivial_constructor)
161
162	def test_has_public_constructor(self):	13✔
163	self.__test_type_category(	13✔
164	'has_public_constructor',
165	declarations.has_public_constructor)
166
167	def test_has_public_destructor(self):	13✔
168	self.__test_type_category(	13✔
169	'has_public_destructor',
170	declarations.has_public_destructor)
171
172	def test_has_any_non_copyconstructor(self):	13✔
173	self.__test_type_category(	13✔
174	'has_any_non_copyconstructor',
175	declarations.has_any_non_copyconstructor)
176
177	def test_has_copy_constructor(self):	13✔
178	self.__test_type_category(	13✔
179	'has_copy_constructor',
180	declarations.has_copy_constructor)
181
182	def test_is_base_and_derived(self):	13✔
183	ns = declarations.find_declaration(	13✔
184	self.declarations,
185	type=declarations.namespace_t,
186	name='is_base_and_derived')
187	self.assertTrue(ns, "unable to find 'is_base_and_derived' namespace")	13✔
188	base = declarations.find_declaration(	13✔
189	ns.declarations,
190	type=declarations.class_t,
191	name='base')
192	derived = declarations.find_declaration(	13✔
193	ns.declarations,
194	type=declarations.class_t,
195	name='derived')
196	self.assertTrue(	13✔
197	base and derived and declarations.is_base_and_derived(
198	base,
199	derived))
200	self.assertTrue(	13✔
201	base and derived and
202	declarations.is_base_and_derived(base, (derived, derived)))
203
204	unrelated1 = declarations.find_declaration(	13✔
205	ns.declarations,
206	type=declarations.class_t,
207	name='unrelated1')
208
209	unrelated2 = declarations.find_declaration(	13✔
210	ns.declarations,
211	type=declarations.class_t,
212	name='unrelated2')
213	self.assertTrue(	13✔
214	base and derived and not declarations.is_base_and_derived(
215	unrelated1,
216	unrelated2))
217
218	def test_is_same(self):	13✔
219	self.assertTrue(	13✔
220	declarations.is_same(
221	declarations.int_t,
222	declarations.int_t))
223	self.assertFalse(	13✔
224	declarations.is_same(
225	declarations.int_t,
226	declarations.float_t))
227
228	def test_remove_const(self):	13✔
229	self.__test_type_transformation(	13✔
230	'remove_const',
231	declarations.remove_const)
232
233	def test_remove_reference(self):	13✔
234	self.__test_type_transformation(	13✔
235	'remove_reference',
236	declarations.remove_reference)
237
238	def test_remove_volatile(self):	13✔
239	self.__test_type_transformation(	13✔
240	'remove_volatile',
241	declarations.remove_volatile)
242
243	def test_remove_cv(self):	13✔
244	self.__test_type_transformation('remove_cv', declarations.remove_cv)	13✔
245
246	def test_remove_pointer(self):	13✔
247	self.__test_type_transformation(	13✔
248	'remove_pointer',
249	declarations.remove_pointer)
250
251	def test_is_unary_binary_operator(self):	13✔
252	operator_not = declarations.find_declaration(	13✔
253	self.declarations,
254	type=declarations.operator_t,
255	fullname='::is_unary_operator::dummy::operator!')
256	self.assertTrue(operator_not, 'operator! was not found')	13✔
257	self.assertTrue(	13✔
258	declarations.is_unary_operator(operator_not),
259	'operator! should be idenitified as unary operator')
260	self.assertTrue(	13✔
261	not declarations.is_binary_operator(operator_not),
262	'operator! should be idenitified as unary operator')
263
264	operator_class_p = declarations.find_declaration(	13✔
265	self.declarations,
266	type=declarations.operator_t,
267	fullname='::is_unary_operator::dummy::operator+')
268	self.assertTrue(operator_class_p, 'operator+ was not found')	13✔
269	self.assertTrue(	13✔
270	not declarations.is_unary_operator(operator_class_p),
271	'operator+ should be idenitified as binary operator')
272	self.assertTrue(	13✔
273	declarations.is_binary_operator(operator_class_p),
274	'operator! should be idenitified as binary operator')
275
276	operator_class_pp = declarations.find_declaration(	13✔
277	self.declarations,
278	type=declarations.operator_t,
279	fullname='::is_unary_operator::dummy::operator++')
280	self.assertTrue(operator_class_pp, 'operator++ was not found')	13✔
281	self.assertTrue(	13✔
282	declarations.is_unary_operator(operator_class_pp),
283	'operator++ should be idenitified as unary operator')
284	self.assertTrue(	13✔
285	not declarations.is_binary_operator(operator_class_pp),
286	'operator++ should be idenitified as unary operator')
287
288	operator_pp = declarations.find_declaration(	13✔
289	self.declarations,
290	type=declarations.operator_t,
291	fullname='::is_unary_operator::operator++')
292	self.assertTrue(operator_pp, 'operator++ was not found')	13✔
293	self.assertTrue(	13✔
294	declarations.is_unary_operator(operator_pp),
295	'operator++ should be idenitified as unary operator')
296	self.assertTrue(	13✔
297	not declarations.is_binary_operator(operator_pp),
298	'operator++ should be idenitified as unary operator')
299
300	operator_mm = declarations.find_declaration(	13✔
301	self.declarations,
302	type=declarations.operator_t,
303	fullname='::is_unary_operator::operator*')
304	self.assertTrue(operator_mm, 'operator-- was not found')	13✔
305	self.assertTrue(	13✔
306	not declarations.is_unary_operator(operator_mm),
307	'operator-- should be idenitified as binary operator')
308	self.assertTrue(	13✔
309	declarations.is_binary_operator(operator_mm),
310	'operator-- should be idenitified as binray operator')
311
312	operator_pe = declarations.find_declaration(	13✔
313	self.declarations,
314	type=declarations.operator_t,
315	fullname='::is_unary_operator::operator+=')
316	self.assertTrue(operator_pe, 'operator+= was not found')	13✔
317	self.assertTrue(	13✔
318	not declarations.is_unary_operator(operator_pe),
319	'operator+= should be idenitified as binary operator')
320	self.assertTrue(	13✔
321	declarations.is_binary_operator(operator_pe),
322	'operator+= should be idenitified as binray operator')
323
324	def __is_convertible_impl(self, decl):	13✔
325	defs = decl.bases[0].related_class.declarations	13✔
326	source_type = declarations.find_declaration(defs, name='source_type')	13✔
327	target_type = declarations.find_declaration(defs, name='target_type')	13✔
328	expected_type = declarations.find_declaration(	13✔
329	defs,
330	name='expected',
331	type=declarations.enumeration_t)
332	expected_value = bool(expected_type.get_name2value_dict()['value'])	13✔
333	self.assertTrue(	13✔
334	expected_value == declarations.is_convertible(
335	source_type,
336	target_type),
337	'Check conversion failed for ' +
338	decl.name)
339
340	def test_is_convertible(self):	13✔
341	ns_is_convertible = declarations.find_declaration(	13✔
342	self.declarations,
343	type=declarations.namespace_t,
344	name="is_convertible")
345
346	self.assertTrue(	13✔
347	ns_is_convertible,
348	"namespace is_convertible was not found")
349	for tester in [	13✔
350	decl for decl in ns_is_convertible.declarations if
351	decl.name.startswith('x')]:
352
353	self.__is_convertible_impl(tester)	13✔
354
355
356	class missing_decls_tester_t(unittest.TestCase):	13✔
357
358	def test(self):	13✔
359	config = autoconfig.cxx_parsers_cfg.gccxml	13✔
360	code = "struct const_item{ const int values[10]; };"	13✔
361	global_ns = parser.parse_string(code, config)[0]	13✔
362	ci = global_ns.class_('const_item')	13✔
363	if 'CastXML' in utils.xml_generator:	13✔
364	# Constructor, copy constructor, destructor, variable
365	self.assertTrue(len(ci.declarations) == 4)	7 all except XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", and XML_GENERATOR="gccxml" ✔
366	else:
367	# Copy constructor, destructor, variable
368	self.assertTrue(len(ci.declarations) == 3)	6 only XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", XML_GENERATOR="gccxml", and XML_GENERATOR="gccxml" ✔
369
370	# class tester_diff_t( parser_test_case.parser_test_case_t ):
371	# COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
372	# declarations = None
373	# def __init__(self, *args ):
374	# parser_test_case.parser_test_case_t.__init__( self, *args )
375	# self.header = 'type_traits.hpp'
376	# self.declarations = None
377
378	# def setUp(self):
379	# if not tester_t.declarations:
380	# tester_t.declarations = parser.parse([self.header], self.config)
381	# self.declarations = tester_t.declarations
382
383	# def test( self ):
384	# x = declarations.find_declaration( self.declarations
385	# , type=declarations.typedef_t
386	# , name="s2s_multimap_type" )
387	# print declarations.is_noncopyable( x)
388	# declarations.print_declarations(
389	# [declarations.class_traits.get_declaration( x )] )
390
391
392	class class_traits_tester_t(unittest.TestCase):	13✔
393
394	def test_get_declaration(self):	13✔
395	code = """	13✔
396	namespace A{
397	struct B{
398	int c;
399	};
400
401	template <class T>
402	struct C: public T{
403	int d;
404	};
405
406	template <class T>
407	struct D{
408	int dD;
409	};
410
411	typedef C<B> easy;
412	typedef D<easy> Deasy;
413
414	inline void instantiate(){
415	int val = sizeof(easy);
416	}
417
418	}
419	"""
420
421	global_ns = parser.parse_string(	13✔
422	code,
423	autoconfig.cxx_parsers_cfg.gccxml)
424	global_ns = declarations.get_global_namespace(global_ns)	13✔
425	easy = global_ns.typedef('easy')	13✔
426	declarations.class_traits.get_declaration(easy)	13✔
427	deasy = global_ns.typedef('Deasy')	13✔
428	d_a = declarations.class_traits.get_declaration(deasy)	13✔
429	self.assertTrue(isinstance(d_a, declarations.class_types))	13✔
430
431
432	def create_suite():	13✔
433	suite = unittest.TestSuite()	13✔
434	suite.addTest(unittest.makeSuite(class_traits_tester_t))	13✔
435	suite.addTest(unittest.makeSuite(tester_t))	13✔
436	suite.addTest(unittest.makeSuite(missing_decls_tester_t))	13✔
437	return suite	13✔
438
439
440	def run_suite():	13✔
441	unittest.TextTestRunner(verbosity=2).run(create_suite())	×
442
443	if __name__ == "__main__":
444	run_suite()

gccxml / pygccxml / 396

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous