Fix syntax errors in non copyable class check

This part of the code had no code coverage, so I added a test for it.
See also bug #13

Author: iMichka

pygccxml/declarations/class_declaration.py

@@ -572,40 +572,51 @@ def _get_partial_name_impl(self):
 
     def find_noncopyable_vars(self):
         """returns list of all `noncopyable` variables"""
+
         from . import type_traits as tt  # prevent cyclic dependencies
+
         logger = utils.loggers.cxx_parser
         mvars = self.vars(
             lambda v: not v.type_qualifiers.has_static,
             recursive=False,
             allow_empty=True)
         noncopyable_vars = []
+
+        message = (
+            "__contains_noncopyable_mem_var - %s - TRUE - " +
+            "containes const member variable")
+
         for mvar in mvars:
+
             type_ = tt.remove_reference(mvar.type)
+
             if tt.is_const(type_):
                 no_const = tt.remove_const(type_)
-                message = (
-                    "__contains_noncopyable_mem_var - %s - TRUE - " +
-                    "containes const member variable")
                 if tt.is_fundamental(no_const) or tt.is_enum(no_const):
-                    logger.debug(
-                        message + "- fundamental or enum" % self.decl_string)
+                    logger.debug((
+                        message + "- fundamental or enum")
+                        % self.decl_string)
                     noncopyable_vars.append(mvar)
                 if tt.is_class(no_const):
                     logger.debug(message + " - class" % self.decl_string)
                     noncopyable_vars.append(mvar)
                 if tt.is_array(no_const):
                     logger.debug(message + " - array" % self.decl_string)
                     noncopyable_vars.append(mvar)
+
             if tt.class_traits.is_my_case(type_):
+
                 cls = tt.class_traits.get_declaration(type_)
                 if tt.is_noncopyable(cls):
-                    logger.debug(
-                        message +
-                        " - class that is not copyable" % self.decl_string)
+                    logger.debug((
+                        message + " - class that is not copyable")
+                        % self.decl_string)
                     noncopyable_vars.append(mvar)
+
         logger.debug((
-            "__contains_noncopyable_mem_var - %s - false - doesn't " +
-            "contains noncopyable members") % self.decl_string)
+            "__contains_noncopyable_mem_var - %s - FALSE - doesn't " +
+            "contain noncopyable members") % self.decl_string)
+
         return noncopyable_vars
 
     @property

unittests/data/non_copyable_classes.hpp

@@ -0,0 +1,49 @@
+// Copyright 2014 Insight Software Consortium.
+// Distributed under the Boost Software License, Version 1.0.
+// See http://www.boost.org/LICENSE_1_0.txt
+
+// A non copyable class, see:
+// http://stackoverflow.com/questions/2173746/how-do-i-make-this-c-object-non-copyable
+
+
+#ifndef __non_copyable_classes_hpp__
+#define __non_copyable_classes_hpp__
+
+namespace non_copyable{
+
+// A first base class, which can not be copied
+class Foo1 {
+  private:
+  	Foo1();
+    Foo1( const Foo1& other ); // non construction-copyable
+    Foo1& operator=( const Foo1& ); // non copyable
+  protected:
+    int var;
+  public:
+    void set_values (int a)
+      { var=a; }
+};
+
+// A second base class, with a non copiable const
+class Foo2 {
+  private:
+  	Foo2();
+  protected:
+    const int var;
+};
+
+class MainFoo1: public Foo1 {
+  public:
+    int get_var()
+      { return var; }
+};
+
+class MainFoo2: public Foo2 {
+  public:
+    int get_var()
+      { return var; }
+};
+
+}
+
+#endif//__non_copyable_classes_hpp__

unittests/non_copyable_classes_tester.py

@@ -0,0 +1,55 @@
+# Copyright 2014 Insight Software Consortium.
+# Distributed under the Boost Software License, Version 1.0.
+# See http://www.boost.org/LICENSE_1_0.txt
+
+import unittest
+import parser_test_case
+
+from pygccxml import parser
+from pygccxml import declarations
+
+
+class tester_t(parser_test_case.parser_test_case_t):
+
+    def __init__(self, *args):
+        parser_test_case.parser_test_case_t.__init__(self, *args)
+        self.header = 'non_copyable_classes.hpp'
+        self.global_ns = None
+
+    def setUp(self):
+        if not self.global_ns:
+            decls = parser.parse([self.header], self.config)
+            self.global_ns = declarations.get_global_namespace(decls)
+            self.global_ns.init_optimizer()
+
+    def test(self):
+
+        """
+        Search for two classes which can not be copied.
+
+        See bug #13
+
+        Covers two cases for the moment
+        1) non copyable class
+        2) non copyable class due to a non copyable const
+
+        """
+
+        MainFoo1 = self.global_ns.class_('MainFoo1')
+        self.assertTrue(declarations.is_noncopyable(MainFoo1))
+
+        MainFoo2 = self.global_ns.class_('MainFoo2')
+        self.assertTrue(declarations.is_noncopyable(MainFoo2))
+
+
+def create_suite():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(tester_t))
+    return suite
+
+
+def run_suite():
+    unittest.TextTestRunner(verbosity=2).run(create_suite())
+
+if __name__ == "__main__":
+    run_suite()

unittests/test_all.py

@@ -34,6 +34,7 @@
 import cache_enums_tester
 import decl_printer_tester
 import typedefs_tester
+import non_copyable_classes_tester
 # import demangled_tester
 import unnamed_enums_bug_tester
 import vector_traits_tester
@@ -93,6 +94,7 @@
     cache_enums_tester,
     decl_printer_tester,
     typedefs_tester,
+    non_copyable_classes_tester,
     unnamed_enums_bug_tester,
     vector_traits_tester,
     string_traits_tester,