Fix macOS tests

Attempt to fix tests on macOS

pygccxml/declarations/declaration.py

@@ -29,7 +29,7 @@ def __init__(
             is_artificial=False,
             mangled=None,
             attributes=None):
-        self._name = name
+        self._name = name.replace(" >", ">").replace("< ", "<")
         self._location = location
         self._is_artificial = is_artificial
         self._mangled = mangled
@@ -164,7 +164,7 @@ def name(self):
     @name.setter
     def name(self, new_name):
         previous_name = self._name
-        self._name = new_name
+        self._name = new_name.replace(" >", ">").replace("< ", "<")
         self._partial_name = None
         self.cache.reset_name_based()
         if previous_name:

pygccxml/declarations/pattern_parser.py

@@ -192,11 +192,11 @@ 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])
 

unittests/call_invocation_tester.py

@@ -65,7 +65,7 @@ def test_split_on_map(self):
 
     def test_join_on_vector(self):
         self.assertTrue(
-            "vector( int, std::allocator(int) )" ==
+            "vector(int, std::allocator(int))" ==
             declarations.call_invocation.join(
                 "vector", ("int", "std::allocator(int)")))
 

unittests/find_container_traits_tester.py

@@ -68,96 +68,96 @@ def __cmp_traits(self, typedef, expected, partial_name, key_type=None):
             self.assertTrue(traits.is_sequence(typedef))
 
     def test_find_traits(self):
-        self.__cmp_traits('v_int', declarations.vector_traits, "vector< int >")
-        self.__cmp_traits('l_int', declarations.list_traits, "list< int >")
+        self.__cmp_traits('v_int', declarations.vector_traits, "vector<int>")
+        self.__cmp_traits('l_int', declarations.list_traits, "list<int>")
         self.__cmp_traits(
             'd_v_int',
             declarations.deque_traits,
-            "deque< std::vector< int > >")
-        self.__cmp_traits('q_int', declarations.queue_traits, "queue< int >")
+            "deque<std::vector<int>>")
+        self.__cmp_traits('q_int', declarations.queue_traits, "queue<int>")
         self.__cmp_traits(
             'pq_int',
             declarations.priority_queue_traits,
-            "priority_queue< int >")
+            "priority_queue<int>")
         self.__cmp_traits(
             's_v_int',
             declarations.set_traits,
-            "set< std::vector< int > >")
+            "set<std::vector<int>>")
         self.__cmp_traits(
             'ms_v_int',
             declarations.multiset_traits,
-            "multiset< std::vector< int > >")
+            "multiset<std::vector<int>>")
         self.__cmp_traits(
             'm_i2d',
             declarations.map_traits,
-            "map< int, double >",
+            "map<int, double>",
             'int')
         self.__cmp_traits(
             'mm_i2d',
             declarations.multimap_traits,
-            "multimap< int, double >",
+            "multimap<int, double>",
             'int')
 
         if self.xml_generator_from_xml_file.is_castxml:
             self.__cmp_traits(
                 'hs_v_int',
                 declarations.unordered_set_traits,
-                "unordered_set< std::vector< int > >")
+                "unordered_set<std::vector<int>>")
         else:
             self.__cmp_traits(
                 'hs_v_int',
                 declarations.hash_set_traits,
-                "hash_set< std::vector< int > >")
+                "hash_set<std::vector<int>>")
 
         if self.xml_generator_from_xml_file.is_castxml:
             self.__cmp_traits(
                 'mhs_v_int',
                 declarations.unordered_multiset_traits,
-                "unordered_multiset< std::vector< int > >")
+                "unordered_multiset<std::vector<int>>")
         else:
             self.__cmp_traits(
                 'mhs_v_int',
                 declarations.hash_multiset_traits,
-                "hash_multiset< std::vector< int > >")
+                "hash_multiset<std::vector<int>>")
 
         if self.xml_generator_from_xml_file.is_castxml:
             self.__cmp_traits(
                 'hm_i2d',
                 declarations.unordered_map_traits,
-                "unordered_map< int, double >",
+                "unordered_map<int, double>",
                 'int')
         else:
             self.__cmp_traits(
                 'hm_i2d',
                 declarations.hash_map_traits,
-                "hash_map< int, double >",
+                "hash_map<int, double>",
                 'int')
 
         if self.xml_generator_from_xml_file.is_castxml:
             self.__cmp_traits(
                 'hmm_i2d',
                 declarations.unordered_multimap_traits,
-                "unordered_multimap< int, double >",
+                "unordered_multimap<int, double>",
                 'int')
         else:
             self.__cmp_traits(
                 'hmm_i2d',
                 declarations.hash_multimap_traits,
-                "hash_multimap< int, double >",
+                "hash_multimap<int, double>",
                 'int')
 
     def test_multimap(self):
         m = self.global_ns.class_(
             lambda decl: decl.name.startswith('multimap'))
         declarations.find_container_traits(m)
-        self.assertTrue(m.partial_name == 'multimap< int, int >')
+        self.assertTrue(m.partial_name == 'multimap<int, int>')
 
     def test_recursive_partial_name(self):
         f1 = self.global_ns.free_function('f1')
         t1 = declarations.class_traits.get_declaration(
             f1.arguments[0].decl_type)
         self.assertTrue(
-            'type< std::set< std::vector< int > > >' == t1.partial_name)
+            'type<std::set<std::vector<int>>>' == t1.partial_name)
 
     def test_remove_defaults_partial_name_namespace(self):
         f2 = self.global_ns.free_function('f2')
@@ -182,7 +182,7 @@ def test_from_ogre():
             'map<std::string, bool (*)(std::string&, ' +
             'Ogre::MaterialScriptContext&), std::less<std::string>, ' +
             'std::allocator<std::pair<std::string const, bool (*)' +
-            '(std::string&, Ogre::MaterialScriptContext&)> > >')
+            '(std::string&, Ogre::MaterialScriptContext&)>>>')
         ct = declarations.find_container_traits(x)
         ct.remove_defaults(x)
 

unittests/remove_template_defaults_tester.py

@@ -31,100 +31,100 @@ def setUp(self):
     def test_vector(self):
         v_int = self.global_ns.typedef('v_int')
         v_traits = declarations.vector_traits
-        self.assertTrue('vector< int >' == v_traits.remove_defaults(v_int))
+        self.assertEqual('vector<int>', v_traits.remove_defaults(v_int))
         v_string = self.global_ns.typedef('v_string')
-        self.assertTrue(
-            'vector< std::string >' == v_traits.remove_defaults(v_string))
+        self.assertEqual(
+            'vector<std::string>', v_traits.remove_defaults(v_string))
         v_v_int = self.global_ns.typedef('v_v_int')
-        self.assertTrue(
-            'vector< std::vector< int > >' ==
+        self.assertEqual(
+            'vector<std::vector<int>>',
             v_traits.remove_defaults(v_v_int))
 
     def test_list(self):
         l_int = self.global_ns.typedef('l_int')
         l_traits = declarations.list_traits
-        self.assertTrue('list< int >' == l_traits.remove_defaults(l_int))
+        self.assertEqual('list<int>', l_traits.remove_defaults(l_int))
         l_wstring = self.global_ns.typedef('l_wstring')
-        self.assertTrue(
-            'list< std::wstring >' == l_traits.remove_defaults(l_wstring))
+        self.assertEqual(
+            'list<std::wstring>', l_traits.remove_defaults(l_wstring))
 
     def test_deque(self):
         d_v_int = self.global_ns.typedef('d_v_int')
         d_v_traits = declarations.deque_traits
-        self.assertTrue(
-            'deque< std::vector< int > >' ==
+        self.assertEqual(
+            'deque<std::vector<int>>',
             d_v_traits.remove_defaults(d_v_int))
         d_l_string = self.global_ns.typedef('d_l_string')
-        self.assertTrue(
-            'deque< std::list< std::string > >' ==
+        self.assertEqual(
+            'deque<std::list<std::string>>',
             d_v_traits.remove_defaults(d_l_string))
 
     def test_queue(self):
         q_int = self.global_ns.typedef('q_int')
         q_traits = declarations.queue_traits
-        self.assertTrue('queue< int >' == q_traits.remove_defaults(q_int))
+        self.assertEqual('queue<int>', q_traits.remove_defaults(q_int))
         q_string = self.global_ns.typedef('q_string')
-        self.assertTrue(
-            'queue< std::string >' == q_traits.remove_defaults(q_string))
+        self.assertEqual(
+            'queue<std::string>', q_traits.remove_defaults(q_string))
 
     def test_priority_queue(self):
         pq_int = self.global_ns.typedef('pq_int')
         pq_traits = declarations.priority_queue_traits
-        self.assertTrue(
-            'priority_queue< int >' == pq_traits.remove_defaults(pq_int))
+        self.assertEqual(
+            'priority_queue<int>', pq_traits.remove_defaults(pq_int))
         pq_string = self.global_ns.typedef('pq_string')
-        self.assertTrue(
-            'priority_queue< std::string >' ==
+        self.assertEqual(
+            'priority_queue<std::string>',
             pq_traits.remove_defaults(pq_string))
 
     def test_set(self):
         s_v_int = self.global_ns.typedef('s_v_int')
-        self.assertTrue(
-            'set< std::vector< int > >' ==
+        self.assertEqual(
+            'set<std::vector<int>>',
             declarations.set_traits.remove_defaults(s_v_int))
         s_string = self.global_ns.typedef('s_string')
-        self.assertTrue(
-            'set< std::string >' ==
+        self.assertEqual(
+            'set<std::string>',
             declarations.set_traits.remove_defaults(s_string))
 
     def test_multiset(self):
         ms_v_int = self.global_ns.typedef('ms_v_int')
         ms_v_traits = declarations.multiset_traits
-        self.assertTrue(
-            'multiset< std::vector< int > >' ==
+        self.assertEqual(
+            'multiset<std::vector<int>>',
             ms_v_traits.remove_defaults(ms_v_int))
         ms_string = self.global_ns.typedef('ms_string')
-        self.assertTrue(
-            'multiset< std::string >' ==
+        self.assertEqual(
+            'multiset<std::string>',
             ms_v_traits.remove_defaults(ms_string))
 
     def test_map(self):
         m_i2d = self.global_ns.typedef('m_i2d')
-        self.assertTrue(
-            'map< int, double >' ==
+        self.assertEqual(
+            'map<int, double>',
             declarations.map_traits.remove_defaults(m_i2d))
         m_wstr2d = self.global_ns.typedef('m_wstr2d')
-        self.assertTrue(
-            'map< std::wstring, double >' ==
+        self.assertEqual(
+            'map<std::wstring, double>',
             declarations.map_traits.remove_defaults(m_wstr2d))
         m_v_i2m_wstr2d = self.global_ns.typedef('m_v_i2m_wstr2d')
-        m = 'map< const std::vector< int >, std::map< std::wstring, double > >'
-        self.assertTrue(
-            m == declarations.map_traits.remove_defaults(m_v_i2m_wstr2d))
+        m = 'map<const std::vector<int>, std::map<std::wstring, double>>'
+        self.assertEqual(
+            m, declarations.map_traits.remove_defaults(m_v_i2m_wstr2d))
 
     def test_multimap(self):
         mm_i2d = self.global_ns.typedef('mm_i2d')
         mm_traits = declarations.multimap_traits
-        self.assertTrue(
-            'multimap< int, double >' == mm_traits.remove_defaults(mm_i2d))
+        self.assertEqual(
+            'multimap<int, double>', mm_traits.remove_defaults(mm_i2d))
         mm_wstr2d = self.global_ns.typedef('mm_wstr2d')
-        self.assertTrue(
-            'multimap< const std::wstring, double >' ==
+        self.assertEqual(
+            'multimap<const std::wstring, double>',
             mm_traits.remove_defaults(mm_wstr2d))
         mm_v_i2mm_wstr2d = self.global_ns.typedef('mm_v_i2mm_wstr2d')
-        self.assertTrue(
-            ('multimap< const std::vector< int >, ' +
-                'const std::multimap< const std::wstring, double > >') ==
+        self.assertEqual(
+            ('multimap<const std::vector<int>, ' +
+                'const std::multimap<const std::wstring, double>>'),
             mm_traits.remove_defaults(mm_v_i2mm_wstr2d))
 
     def test_hash_set(self):
@@ -135,13 +135,13 @@ def test_hash_set(self):
         else:
             hs_traits = declarations.hash_set_traits
             name = 'hash_set'
-        self.assertTrue(
-            (name + '< std::vector< int > >') ==
+        self.assertEqual(
+            (name + '<std::vector<int>>'),
             hs_traits.remove_defaults(hs_v_int),
             hs_traits.remove_defaults(hs_v_int))
         hs_string = self.global_ns.typedef('hs_string')
-        self.assertTrue(
-            (name + '< std::string >') == hs_traits.remove_defaults(hs_string))
+        self.assertEqual(
+            (name + '<std::string>'), hs_traits.remove_defaults(hs_string))
 
     def test_hash_multiset(self):
         mhs_v_int = self.global_ns.typedef('mhs_v_int')
@@ -151,12 +151,12 @@ def test_hash_multiset(self):
         else:
             mhs_traits = declarations.hash_multiset_traits
             name = 'hash_multiset'
-        self.assertTrue(
-            (name + '< std::vector< int > >') ==
+        self.assertEqual(
+            (name + '<std::vector<int>>'),
             mhs_traits.remove_defaults(mhs_v_int))
         mhs_string = self.global_ns.typedef('mhs_string')
-        self.assertTrue(
-            (name + '< std::string >') ==
+        self.assertEqual(
+            (name + '<std::string>'),
             mhs_traits.remove_defaults(mhs_string))
 
     def test_hash_map(self):
@@ -167,11 +167,11 @@ def test_hash_map(self):
         else:
             hm_traits = declarations.hash_map_traits
             name = 'hash_map'
-        self.assertTrue(
-            (name + '< int, double >') == hm_traits.remove_defaults(hm_i2d))
+        self.assertEqual(
+            (name + '<int, double>'), hm_traits.remove_defaults(hm_i2d))
         hm_wstr2d = self.global_ns.typedef('hm_wstr2d')
-        self.assertTrue(
-            (name + '< std::wstring, double >') ==
+        self.assertEqual(
+            (name + '<std::wstring, double>'),
             hm_traits.remove_defaults(hm_wstr2d))
 
     def test_hash_multimap(self):
@@ -182,26 +182,26 @@ def test_hash_multimap(self):
         else:
             hmm_traits = declarations.hash_multimap_traits
             name = 'hash_multimap'
-        self.assertTrue(
-            (name + '< int, double >') ==
+        self.assertEqual(
+            (name + '<int, double>'),
             hmm_traits.remove_defaults(hmm_i2d))
         hmm_wstr2d = self.global_ns.typedef('hmm_wstr2d')
-        self.assertTrue(
-            (name + '< const std::wstring, double >') ==
+        self.assertEqual(
+            (name + '<const std::wstring, double>'),
             hmm_traits.remove_defaults(hmm_wstr2d))
 
         hmm_v_i2mm_wstr2d = self.global_ns.typedef('hmm_v_i2mm_wstr2d')
 
         hmm_traits_value = hmm_traits.remove_defaults(hmm_v_i2mm_wstr2d)
 
         possible_values = (
-            name + '< const std::vector< int >, ' +
-            'const __gnu_cxx::' + name + '< const std::wstring, double > >',
-            name + '< const std::vector< int >, ' +
+            name + '<const std::vector<int>, ' +
+            'const __gnu_cxx::' + name + '<const std::wstring, double>>',
+            name + '<const std::vector<int>, ' +
             'const std::' + utils.get_tr1(hmm_traits_value) + name +
-            '< const std::wstring, double > >',
-            name + '< const std::vector< int >, ' +
-            'const stdext::' + name + '< const std::wstring, double > >')
+            '<const std::wstring, double>>',
+            name + '<const std::vector<int>, ' +
+            'const stdext::' + name + '<const std::wstring, double>>')
 
         self.assertTrue(hmm_traits_value in possible_values, hmm_traits_value)