Use assertTrue instead of failUnless

failUnless is deprecated since a long time now: https://docs.python.org/2/library/unittest.html#deprecated-aliases
As Deprecation warnings are enabled in pygccxml; this clutters the test logs

Author: iMichka

unittests/algorithms_cache_tester.py

@@ -29,42 +29,42 @@ def test_name_based(self):
         if "CastXML" in utils.xml_generator:
             self.assertRaises(Exception, lambda: cls.cache.demangled_name)
         elif "GCCXML" in utils.xml_generator:
-            self.failUnless(cls.cache.demangled_name == cls.name)
+            self.assertTrue(cls.cache.demangled_name == cls.name)
 
         cls_full_name = declarations.full_name(cls)
-        self.failUnless(cls.cache.full_name == cls_full_name)
+        self.assertTrue(cls.cache.full_name == cls_full_name)
 
         cls_declaration_path = declarations.declaration_path(cls)
-        self.failUnless(cls.cache.declaration_path == cls_declaration_path)
+        self.assertTrue(cls.cache.declaration_path == cls_declaration_path)
 
         enum = cls.enum('ENestedPublic')
 
         enum_full_name = declarations.full_name(enum)
-        self.failUnless(enum.cache.full_name == enum_full_name)
+        self.assertTrue(enum.cache.full_name == enum_full_name)
 
         enum_declaration_path = declarations.declaration_path(enum)
-        self.failUnless(enum.cache.declaration_path == enum_declaration_path)
+        self.assertTrue(enum.cache.declaration_path == enum_declaration_path)
 
         # now we change class name, all internal decls cache should be cleared
         cls.name = "new_name"
-        self.failUnless(not cls.cache.full_name)
+        self.assertTrue(not cls.cache.full_name)
         if "GCCXML" in utils.xml_generator:
-            self.failUnless(not cls.cache.demangled_name)
-        self.failUnless(not cls.cache.declaration_path)
+            self.assertTrue(not cls.cache.demangled_name)
+        self.assertTrue(not cls.cache.declaration_path)
 
-        self.failUnless(not enum.cache.full_name)
+        self.assertTrue(not enum.cache.full_name)
         if "GCCXML" in utils.xml_generator:
-            self.failUnless(not enum.cache.demangled_name)
-        self.failUnless(not enum.cache.declaration_path)
+            self.assertTrue(not enum.cache.demangled_name)
+        self.assertTrue(not enum.cache.declaration_path)
 
     def test_access_type(self):
         cls = self.global_ns.class_(name='class_for_nested_enums_t')
         enum = cls.enum('ENestedPublic')
-        self.failUnless(enum.cache.access_type == 'public')
+        self.assertTrue(enum.cache.access_type == 'public')
         enum.cache.reset_access_type()
-        self.failUnless(not enum.cache.access_type)
-        self.failUnless('public' == cls.find_out_member_access_type(enum))
-        self.failUnless(enum.cache.access_type == 'public')
+        self.assertTrue(not enum.cache.access_type)
+        self.assertTrue('public' == cls.find_out_member_access_type(enum))
+        self.assertTrue(enum.cache.access_type == 'public')
 
 
 def create_suite():

unittests/array_bug_tester.py

@@ -21,7 +21,7 @@ def test1(self):
         global_ns = declarations.get_global_namespace(
             src_reader.read_string(code))
         aaaa_type = global_ns.variable('aaaa').type
-        self.failUnless(
+        self.assertTrue(
             'int[2][3][4][5]' == aaaa_type.decl_string,
             aaaa_type.decl_string)
 
@@ -31,7 +31,7 @@ def test2(self):
         global_ns = declarations.get_global_namespace(
             src_reader.read_string(code))
         aaaa_type = global_ns.variable('aaaa').type
-        self.failUnless(
+        self.assertTrue(
             'int *[2][3][4][5]' == aaaa_type.decl_string,
             aaaa_type.decl_string)
 
@@ -41,7 +41,7 @@ def test3(self):
         global_ns = declarations.get_global_namespace(
             src_reader.read_string(code))
         aaaa_type = global_ns.variable('aaaa').type
-        self.failUnless(
+        self.assertTrue(
             'int[2]' == aaaa_type.decl_string,
             aaaa_type.decl_string)
 
@@ -51,7 +51,7 @@ def test4(self):
         global_ns = declarations.get_global_namespace(
             src_reader.read_string(code))
         aaaa_type = global_ns.variable('aaaa').type
-        self.failUnless(
+        self.assertTrue(
             '::xyz[2][3]' == aaaa_type.decl_string,
             aaaa_type.decl_string)
 

unittests/attributes_tester.py

@@ -38,12 +38,12 @@ def test(self):
         # always on ubuntu (clang and gcc). Just skip this test for the
         # moment.
 
-        # self.failUnless(None is numeric.attributes)
+        # self.assertTrue(None is numeric.attributes)
 
         do_nothing = numeric.mem_fun('do_nothing')
-        self.failUnless((prefix + "(no throw)") == do_nothing.attributes)
+        self.assertTrue((prefix + "(no throw)") == do_nothing.attributes)
         arg = do_nothing.arguments[0]
-        self.failUnless((prefix + "(out)") == arg.attributes)
+        self.assertTrue((prefix + "(out)") == arg.attributes)
 
 
 def create_suite():

unittests/bit_fields_tester.py

@@ -26,13 +26,13 @@ def setUp(self):
 
     def test(self):
         bf_x = self.global_ns.variable('x')
-        self.failUnless(bf_x.bits == 1)
+        self.assertTrue(bf_x.bits == 1)
 
         bf_y = self.global_ns.variable('y')
-        self.failUnless(bf_y.bits == 7)
+        self.assertTrue(bf_y.bits == 7)
 
         mv_z = self.global_ns.variable('z')
-        self.failUnless(mv_z.bits is None)
+        self.assertTrue(mv_z.bits is None)
 
     def test2(self):
         pass

unittests/cache_enums_tester.py

@@ -40,7 +40,7 @@ def test_cache(self):
 
         color1 = declarations.matcher.get_single(enum_matcher, decls1)
         color2 = declarations.matcher.get_single(enum_matcher, decls2)
-        self.failUnless(color1.values == color2.values)
+        self.assertTrue(color1.values == color2.values)
 
 # there is no progress with this parser
 # class synopsis_tester_t( tester_impl_t ):

unittests/cached_source_file_tester.py

@@ -27,13 +27,13 @@ def test(self):
             prj_reader.read_files(
                 [fconfig],
                 compilation_mode=parser.COMPILATION_MODE.FILE_BY_FILE)
-            self.failUnless(os.path.exists(fconfig.cached_source_file))
+            self.assertTrue(os.path.exists(fconfig.cached_source_file))
             mtime1 = os.stat(fconfig.cached_source_file)[stat.ST_MTIME]
             prj_reader.read_files(
                 [fconfig],
                 compilation_mode=parser.COMPILATION_MODE.FILE_BY_FILE)
             mtime2 = os.stat(fconfig.cached_source_file)[stat.ST_MTIME]
-            self.failUnless(mtime1 == mtime2)
+            self.assertTrue(mtime1 == mtime2)
         finally:
             utils.remove_file_no_raise(fconfig.cached_source_file, self.config)
 

unittests/call_invocation_tester.py

@@ -13,16 +13,16 @@ def __init__(self, *args):
         unittest.TestCase.__init__(self, *args)
 
     def __test_split_impl(self, decl_string, name, args):
-        self.failUnless(
+        self.assertTrue(
             (name, args) == declarations.call_invocation.split(decl_string))
 
     def __test_split_recursive_impl(self, decl_string, control_seq):
-        self.failUnless(
+        self.assertTrue(
             control_seq ==
             declarations.call_invocation.split_recursive(decl_string))
 
     def __test_is_call_invocation_impl(self, decl_string):
-        self.failUnless(
+        self.assertTrue(
             declarations.call_invocation.is_call_invocation(decl_string))
 
     def test_split_on_vector(self):
@@ -64,22 +64,22 @@ def test_split_on_map(self):
                 " std::vector(int, std::allocator(int) ) ) )"])
 
     def test_join_on_vector(self):
-        self.failUnless(
+        self.assertTrue(
             "vector( int, std::allocator(int) )" ==
             declarations.call_invocation.join(
                 "vector", ("int", "std::allocator(int)")))
 
     def test_find_args(self):
         temp = 'x()()'
         found = declarations.call_invocation.find_args(temp)
-        self.failUnless((1, 2) == found)
+        self.assertTrue((1, 2) == found)
         found = declarations.call_invocation.find_args(temp, found[1] + 1)
-        self.failUnless((3, 4) == found)
+        self.assertTrue((3, 4) == found)
         temp = 'x(int,int)(1,2)'
         found = declarations.call_invocation.find_args(temp)
-        self.failUnless((1, 9) == found)
+        self.assertTrue((1, 9) == found)
         found = declarations.call_invocation.find_args(temp, found[1] + 1)
-        self.failUnless((10, 14) == found)
+        self.assertTrue((10, 14) == found)
 
     def test_bug_unmatched_brace(self):
         src = 'AlternativeName((&string("")), (&string("")), (&string("")))'

unittests/calldef_matcher_tester.py

@@ -27,7 +27,7 @@ def test(self):
             return_type='int',
             arg_types=[None, declarations.bool_t()])
         rda = declarations.matcher.get_single(criteria, self.declarations)
-        self.failUnless(rda, "return_default_args function was not found.")
+        self.assertTrue(rda, "return_default_args function was not found.")
 
 
 def create_suite():

unittests/calling_convention_tester.py

@@ -22,7 +22,7 @@ def test_extract(self):
 
         for expected, text in data:
             got = declarations.CALLING_CONVENTION_TYPES.extract(text)
-            self.failUnless(
+            self.assertTrue(
                 got == expected, "Expected calling convention: %s, got %s" %
                 (expected, got))
 

unittests/const_volatile_arg_tester.py

@@ -27,10 +27,10 @@ def setUp(self):
     def test(self):
         f = self.global_ns.free_fun('pygccxml_bug')
         t = f.arguments[0].type
-        self.failUnless(isinstance(t, declarations.pointer_t))
-        self.failUnless(isinstance(t.base, declarations.volatile_t))
-        self.failUnless(isinstance(t.base.base, declarations.const_t))
-        self.failUnless(declarations.is_integral(t.base.base.base))
+        self.assertTrue(isinstance(t, declarations.pointer_t))
+        self.assertTrue(isinstance(t.base, declarations.volatile_t))
+        self.assertTrue(isinstance(t.base.base, declarations.const_t))
+        self.assertTrue(declarations.is_integral(t.base.base.base))
 
 
 def create_suite():