tests: refactor / simplify

Author: iMichka

tests/test_attributes.py

@@ -49,6 +49,7 @@ def test_attributes_thiscall():
     config = autoconfig.cxx_parsers_cfg.config.clone()
 
     config.flags = ["f2"]
+    config.castxml_epic_version = 1
 
     decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
     global_ns = declarations.get_global_namespace(decls)

tests/test_castxml_wrong_epic.py

@@ -3,43 +3,21 @@
 # Distributed under the Boost Software License, Version 1.0.
 # See http://www.boost.org/LICENSE_1_0.txt
 
-import unittest
+import pytest
 
-from . import parser_test_case
+from . import autoconfig
 
 from pygccxml import parser
 
 
-class Test(parser_test_case.parser_test_case_t):
 
-    def test_castxml_epic_version_check(self):
-        """
-        Test using a forbidden value for the castxml epic version.
+def test_castxml_epic_version_check():
+    """
+    Test using a forbidden value for the castxml epic version.
 
-        """
+    """
 
-        if self.config.castxml_epic_version != 1:
-            # Run this test only with castxml epic version == 1
-            return
-
-        self.config.castxml_epic_version = 2
-        self.assertRaises(
-            RuntimeError, lambda: parser.parse_string("", self.config))
-
-        # Reset castxml epic version
-        self.config.castxml_epic_version = 1
-
-
-def create_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(
-        unittest.TestLoader().loadTestsFromTestCase(testCaseClass=Test))
-    return suite
-
-
-def run_suite():
-    unittest.TextTestRunner(verbosity=2).run(create_suite())
-
-
-if __name__ == "__main__":
-    run_suite()
+    config = autoconfig.cxx_parsers_cfg.config.clone()
+    config.castxml_epic_version = 2
+    with pytest.raises(RuntimeError):
+        parser.parse_string("", config)

tests/test_ccflags.py

@@ -3,65 +3,47 @@
 # Distributed under the Boost Software License, Version 1.0.
 # See http://www.boost.org/LICENSE_1_0.txt
 
-import unittest
+import pytest
 
-from . import parser_test_case
+from . import autoconfig
 
 from pygccxml import parser
 from pygccxml import declarations
 
 
-class Test(parser_test_case.parser_test_case_t):
-    global_ns = None
+TEST_FILES = [
+    "test_ccflags.hpp",
+]
 
-    def __init__(self, *args):
-        parser_test_case.parser_test_case_t.__init__(self, *args)
-        self.header = "test_ccflags.hpp"
-        self.global_ns = None
-        self.config.castxml_epic_version = 1
-        self.config.append_cflags("-fopenmp")
+COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
 
-    def _parse_src(self):
-        decls = parser.parse([self.header], self.config)
-        Test.global_ns = declarations.get_global_namespace(decls)
-        Test.xml_generator_from_xml_file = (
-            self.config.xml_generator_from_xml_file
-        )
-        self.xml_generator_from_xml_file = Test.xml_generator_from_xml_file
 
-        self.global_ns = Test.global_ns
+@pytest.fixture
+def config():
+    config = autoconfig.cxx_parsers_cfg.config.clone()
+    config.castxml_epic_version = 1
+    config.append_cflags("-fopenmp")
+    return config
 
-    def _add_ccflags(self):
-        if "clang++" in self.config.compiler_path:
-            self.config.append_ccflags("-Xpreprocessor")
 
-        self.config.append_ccflags("-fopenmp")
+def test_ccflags(config):
+    # First check that macro is not defined.
+    decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
+    global_ns = declarations.get_global_namespace(decls)
 
-    def test(self):
-        # First check that macro is not defined.
-        self._parse_src()
-        namespace_names = [
-            n.name for n in self.global_ns.namespaces(allow_empty=True)
-        ]
-        self.assertNotIn("ccflags_test_namespace", namespace_names)
+    namespace_names = [
+        n.name for n in global_ns.namespaces(allow_empty=True)
+    ]
+    assert "ccflags_test_namespace" not in namespace_names
 
-        # Next check that macro is defined when passed directly as ccflag
-        self._add_ccflags()
-        self._parse_src()
-        namespace_names = [n.name for n in self.global_ns.namespaces()]
-        self.assertIn("ccflags_test_namespace", namespace_names)
+    # Next check that macro is defined when passed directly as ccflag
 
+    if "clang++" in config.compiler_path:
+        config.append_ccflags("-Xpreprocessor")
+    config.append_ccflags("-fopenmp")
 
-def create_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(
-        unittest.TestLoader().loadTestsFromTestCase(testCaseClass=Test))
-    return suite
+    decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
+    global_ns = declarations.get_global_namespace(decls)
 
-
-def run_suite():
-    unittest.TextTestRunner(verbosity=2).run(create_suite())
-
-
-if __name__ == "__main__":
-    run_suite()
+    namespace_names = [n.name for n in global_ns.namespaces()]
+    assert "ccflags_test_namespace" in namespace_names

tests/test_comments.py

@@ -3,98 +3,79 @@
 # Distributed under the Boost Software License, Version 1.0.
 # See http://www.boost.org/LICENSE_1_0.txt
 
-import unittest
+import pytest
 
-from . import parser_test_case
+from . import autoconfig
 
 from pygccxml import parser
 from pygccxml import declarations
 
 
-class Test(parser_test_case.parser_test_case_t):
-    global_ns = None
+TEST_FILES = [
+    "test_comments.hpp",
+]
 
-    def __init__(self, *args):
-        parser_test_case.parser_test_case_t.__init__(self, *args)
-        self.header = "test_comments.hpp"
-        self.global_ns = None
-        self.config.castxml_epic_version = 1
 
-    def _check_comment_content(self, list, comment_decl):
-        if comment_decl.text:
-            self.assertEqual(list, comment_decl.text)
-        else:
-            print("No text in comment to check")
+@pytest.fixture
+def global_ns():
+    COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
+    INIT_OPTIMIZER = True
+    config = autoconfig.cxx_parsers_cfg.config.clone()
+    config.castxml_epic_version = 1
+    decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
+    global_ns = declarations.get_global_namespace(decls)
+    if INIT_OPTIMIZER:
+        global_ns.init_optimizer()
+    return global_ns
 
-    def setUp(self):
 
-        if not self.global_ns:
-            decls = parser.parse([self.header], self.config)
-            Test.global_ns = declarations.get_global_namespace(decls)
-            Test.xml_generator_from_xml_file = \
-                self.config.xml_generator_from_xml_file
-        self.xml_generator_from_xml_file = Test.xml_generator_from_xml_file
+def _check_comment_content(list, comment_decl):
+    if comment_decl.text:
+        assert list == comment_decl.text
+    else:
+        print("No text in comment to check")
 
-        self.global_ns = Test.global_ns
 
-    def test(self):
-        """
-        Check the comment parsing
-        """
-        if self.config.castxml_epic_version != 1:
-            # Run this test only with castxml epic version == 1
-            return
-        tnamespace = self.global_ns.namespace("comment")
+def test_comments(global_ns):
+    """
+    Check the comment parsing
+    """
+    tnamespace = global_ns.namespace("comment")
 
-        self.assertIn("comment", dir(tnamespace))
-        self._check_comment_content(["//! Namespace Comment",
-                                    "//! Across multiple lines"],
-                                    tnamespace.comment)
+    assert "comment" in dir(tnamespace)
+    _check_comment_content(["//! Namespace Comment",
+                                "//! Across multiple lines"],
+                                tnamespace.comment)
 
-        tenumeration = tnamespace.enumeration("com_enum")
-        self.assertIn("comment", dir(tenumeration))
-        self._check_comment_content(['/// Outside Class enum comment'],
-                                    tenumeration.comment)
+    tenumeration = tnamespace.enumeration("com_enum")
+    assert "comment" in dir(tenumeration)
+    _check_comment_content(['/// Outside Class enum comment'],
+                                tenumeration.comment)
 
-        tclass = tnamespace.class_("test")
-        self.assertIn("comment", dir(tclass))
-        self._check_comment_content(["/** class comment */"], tclass.comment)
+    tclass = tnamespace.class_("test")
+    assert "comment" in dir(tclass)
+    _check_comment_content(["/** class comment */"], tclass.comment)
 
-        tcls_enumeration = tclass.enumeration("test_enum")
-        self.assertIn("comment", dir(tcls_enumeration))
-        self._check_comment_content(['/// inside class enum comment'],
-                                    tcls_enumeration.comment)
+    tcls_enumeration = tclass.enumeration("test_enum")
+    assert "comment" in dir(tcls_enumeration)
+    _check_comment_content(['/// inside class enum comment'],
+                                tcls_enumeration.comment)
 
-        tmethod = tclass.member_functions()[0]
+    tmethod = tclass.member_functions()[0]
 
-        self.assertIn("comment", dir(tmethod))
-        self._check_comment_content(["/// cxx comment",
-                                     "/// with multiple lines"],
-                                    tmethod.comment)
+    assert "comment" in dir(tmethod)
+    _check_comment_content(["/// cxx comment",
+                                    "/// with multiple lines"],
+                                tmethod.comment)
 
-        tconstructor = tclass.constructors()[0]
+    tconstructor = tclass.constructors()[0]
 
-        self.assertIn("comment", dir(tconstructor))
-        self._check_comment_content(["/** doc comment */"],
-                                    tconstructor.comment)
+    assert "comment" in dir(tconstructor)
+    _check_comment_content(["/** doc comment */"],
+                                tconstructor.comment)
 
-        for indx, cmt in enumerate(['//! mutable field comment',
-                                    "/// bit field comment"]):
-            tvariable = tclass.variables()[indx]
-            self.assertIn("comment", dir(tvariable))
-            self._check_comment_content([cmt], tvariable.comment)
-
-
-def create_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(
-        unittest.TestLoader().loadTestsFromTestCase(testCaseClass=Test))
-    return suite
-
-
-def run_suite():
-    unittest.TextTestRunner(verbosity=2).run(create_suite())
-
-
-if __name__ == "__main__":
-    run_suite()
+    for indx, cmt in enumerate(['//! mutable field comment',
+                                "/// bit field comment"]):
+        tvariable = tclass.variables()[indx]
+        assert "comment" in dir(tvariable)
+        _check_comment_content([cmt], tvariable.comment)

tests/test_complex_types.py

@@ -3,45 +3,36 @@
 # Distributed under the Boost Software License, Version 1.0.
 # See http://www.boost.org/LICENSE_1_0.txt
 
-import os
-import unittest
+import pytest
 
-from . import parser_test_case
+from . import autoconfig
 
+from pygccxml import declarations
 from pygccxml import parser
 
 
-class Test(parser_test_case.parser_test_case_t):
-    COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
-
-    def __init__(self, *args):
-        parser_test_case.parser_test_case_t.__init__(self, *args)
-        self.header = 'complex_types.hpp'
-        self.declarations = None
-
-    def setUp(self):
-        if not self.declarations:
-            self.declarations = parser.parse([self.header], self.config)
-
-    def test(self):
-        """
-        This test tests presence of complex long double, float within
-        FUNDAMENTAL_TYPES map
-        """
-        pass
-
+TEST_FILES = [
+    "complex_types.hpp",
+]
 
-def create_suite():
-    suite = unittest.TestSuite()
-    if os.name != 'nt':
-        suite.addTest(
-            unittest.TestLoader().loadTestsFromTestCase(testCaseClass=Test))
-    return suite
 
-
-def run_suite():
-    unittest.TextTestRunner(verbosity=2).run(create_suite())
-
-
-if __name__ == "__main__":
-    run_suite()
+@pytest.fixture
+def global_ns():
+    COMPILATION_MODE = parser.COMPILATION_MODE.ALL_AT_ONCE
+    INIT_OPTIMIZER = True
+    config = autoconfig.cxx_parsers_cfg.config.clone()
+    config.castxml_epic_version = 1
+    decls = parser.parse(TEST_FILES, config, COMPILATION_MODE)
+    global_ns = declarations.get_global_namespace(decls)
+    if INIT_OPTIMIZER:
+        global_ns.init_optimizer()
+    return global_ns
+
+
+def test_complex_types():
+    """
+    This test tests presence of complex long double, float within
+    FUNDAMENTAL_TYPES map
+    """
+    pass
+    # TODO: write test