test

Author: iMichka

.github/workflows/tests.yml

@@ -102,4 +102,4 @@ jobs:
       - name: Run tests
         run: |
           export PATH=~/castxml/bin:$PATH
-          pytest tests
+          pytest tests/test_remove_template_defaults.py

src/pygccxml/declarations/container_traits.py

@@ -30,6 +30,8 @@ def normalize(self, type_str):
 
     def replace_basic_string(self, cls_name):
 
+        print("replace_basic_string START", cls_name)
+
         # Take the lists of all possible string variations
         # and clean them up by replacing ::std by std.
         str_eq = [
@@ -49,6 +51,8 @@ def replace_basic_string(self, cls_name):
             for lname in long_names:
                 new_name = new_name.replace(lname, short_name)
 
+        print("replace_basic_string DONE", new_name)
+
         return new_name
 
     def decorated_call_prefix(self, cls_name, text, doit):
@@ -99,10 +103,12 @@ def erase_recursive(self, cls_name):
         return self.no_end_const(cls_name)
 
     def erase_allocator(self, cls_name, default_allocator='std::allocator'):
+        print("erase_allocator START", cls_name)
         cls_name = self.replace_basic_string(cls_name)
         c_name, c_args = templates.split(cls_name)
         if len(c_args) != 2:
-            return
+            print("erase_allocator EARLY RETURN")
+            return cls_name
         value_type = c_args[0]
         tmpl = string.Template(
             "$container<$value_type, $allocator<$value_type>>")
@@ -112,8 +118,10 @@ def erase_allocator(self, cls_name, default_allocator='std::allocator'):
             allocator=default_allocator)
         if self.normalize(cls_name) == \
                 self.normalize(tmpl):
+            print("erase_allocator NORMALIZED RETURN")
             return templates.join(
                 c_name, [self.erase_recursive(value_type)])
+        print("erase_allocator FINAL RETURN NONE")
 
     def erase_container(self, cls_name, default_container_name='std::deque'):
         cls_name = self.replace_basic_string(cls_name)
@@ -525,6 +533,7 @@ def remove_defaults(self, type_or_string):
             name = self.class_declaration(type_or_string).name
         if not self.remove_defaults_impl:
             return name
+        print("remove_defaults", name)
         no_defaults = self.remove_defaults_impl(name)
         if not no_defaults:
             return name

src/pygccxml/declarations/pattern_parser.py

@@ -192,16 +192,17 @@ def join(self, name, args, arg_separator=None):
         args = [_f for _f in args if _f]
 
         if not args:
-            args_str = ' '
+            args_str = ''
         elif len(args) == 1:
-            args_str = ' ' + args[0] + ' '
+            args_str = '' + args[0] + ''
         else:
-            args_str = ' ' + arg_separator.join(args) + ' '
+            args_str = '' + arg_separator.join(args) + ''
 
         return ''.join([name, self.__begin, args_str, self.__end])
 
     def normalize(self, decl_string, arg_separator=None):
         """implementation details"""
+
         if not self.has_pattern(decl_string):
             return decl_string
         name, args = self.split(decl_string)

src/pygccxml/declarations/type_traits.py

@@ -482,8 +482,11 @@ def is_fundamental(type_):
 
 string_equivalences = [
     (
-        '::std::basic_string<char,std::char_traits<char>,'
-        'std::allocator<char>>'),
+        'std::basic_string<char, std::char_traits<char>, '
+        'std::allocator<char>>, '
+        'std::allocator<std::basic_string<'
+        'char, std::char_traits<char>, std::allocator<char>>>'),
+    '::std::basic_string<char,std::char_traits<char>,std::allocator<char>>',
     '::std::basic_string<char>', '::std::string']
 
 wstring_equivalences = [

src/pygccxml/parser/patcher.py

@@ -314,6 +314,32 @@ def remove_spaces_from_template_names(decls):
     after hash<std::vector<int>>
     """
     for decl in decls:
+        # if "v_int" in decl.name:
+        #     print("------")
+        #     print(
+        #         decl.decl_type,
+        #         type(decl.decl_type),
+        #         decl.decl_type.declaration.name)
+        # if "vector" in decl.name:
+        #     print("------")
+        #     print("vvvvvvv", decl, decl.name)
         decl.name = decl.name.replace(" >", ">").replace("< ", "<")
         decl.partial_name = \
             decl.partial_name.replace(" >", ">").replace("< ", "<")
+        if isinstance(decl, declarations.typedef_t) and \
+           isinstance(decl.decl_type, declarations.declarated_t):
+            decl.decl_type.declaration.name = fix_spaces(
+                decl.decl_type.declaration.name)
+            decl.decl_type.declaration.partial_name = fix_spaces(
+                decl.decl_type.declaration.partial_name)
+        # if "v_int" in decl.name:
+        #     print(
+        #         decl.decl_type,
+        #         type(decl.decl_type),
+        #         decl.decl_type.declaration.name)
+        # if "vector" in decl.name:
+        #     print("vvvvvvv", decl, decl.name)
+
+
+def fix_spaces(val):
+    return val.replace(" >", ">").replace("< ", "<")

tests/test_pattern_parser.py

@@ -66,8 +66,8 @@ def test_split():
 
     """
 
-    p1 = "std::vector<char, std::allocator<char> >"
-    p2 = "std::vector<int, std::allocator<int> >"
+    p1 = "std::vector<char, std::allocator<char>>"
+    p2 = "std::vector<int, std::allocator<int>>"
     args_list = [
         "const std::basic_string<char> &", "const int &", "const double &"]