Add missing methods on PyGIBaseInfo and sub-classes

Expose all methods of GIBaseBase info and its sub-classes.

https://bugzilla.gnome.org/show_bug.cgi?id=709008

1 files changed, 134 insertions, 0 deletions

diff --git a/tests/test_repository.py b/tests/test_repository.py
index 3ce3f0de..6fd79062 100644
--- a/tests/test_repository.py
+++ b/tests/test_repository.py
@@ -66,6 +66,10 @@ class Test(unittest.TestCase):
         self.assertFalse(arg.is_optional())
         self.assertFalse(arg.is_return_value())
         self.assertFalse(arg.may_be_null())
+        self.assertEqual(arg.get_destroy(), -1)
+        self.assertEqual(arg.get_ownership_transfer(), GIRepository.Transfer.NOTHING)
+        self.assertEqual(arg.get_scope(), GIRepository.ScopeType.INVALID)
+        self.assertEqual(arg.get_type().get_tag(), GIRepository.TypeTag.ARRAY)
 
     def test_base_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Object')
@@ -88,38 +92,70 @@ class Test(unittest.TestCase):
         self.assertTrue(isinstance(info.get_interfaces(), collections.Iterable))
         self.assertTrue(isinstance(info.get_constants(), collections.Iterable))
         self.assertTrue(isinstance(info.get_vfuncs(), collections.Iterable))
+        self.assertTrue(isinstance(info.get_properties(), collections.Iterable))
         self.assertFalse(info.get_abstract())
         self.assertEqual(info.get_class_struct(), repo.find_by_name('GIMarshallingTests', 'ObjectClass'))
+        self.assertEqual(info.get_type_name(), 'GIMarshallingTestsObject')
+        self.assertEqual(info.get_type_init(), 'gi_marshalling_tests_object_get_type')
+        self.assertFalse(info.get_fundamental())
+        self.assertEqual(info.get_parent(), repo.find_by_name('GObject', 'Object'))
 
     def test_registered_type_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Object')
         # Call these from the class because GIObjectInfo overrides them
         self.assertEqual(GIRepository.RegisteredTypeInfo.get_g_type(info),
                          GObject.type_from_name('GIMarshallingTestsObject'))
+        self.assertEqual(GIRepository.RegisteredTypeInfo.get_type_name(info),
+                         'GIMarshallingTestsObject')
+        self.assertEqual(GIRepository.RegisteredTypeInfo.get_type_init(info),
+                         'gi_marshalling_tests_object_get_type')
 
     @unittest.skipUnless(has_cairo, 'Regress needs cairo')
     def test_fundamental_object_info(self):
         repo.require('Regress')
         info = repo.find_by_name('Regress', 'TestFundamentalObject')
         self.assertTrue(info.get_abstract())
+        self.assertTrue(info.get_fundamental())
+        self.assertEqual(info.get_ref_function(), 'regress_test_fundamental_object_ref')
+        self.assertEqual(info.get_unref_function(), 'regress_test_fundamental_object_unref')
+        self.assertEqual(info.get_get_value_function(), 'regress_test_value_get_fundamental_object')
+        self.assertEqual(info.get_set_value_function(), 'regress_test_value_set_fundamental_object')
 
     def test_interface_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Interface')
         self.assertTrue(isinstance(info.get_methods(), collections.Iterable))
         self.assertTrue(isinstance(info.get_vfuncs(), collections.Iterable))
         self.assertTrue(isinstance(info.get_constants(), collections.Iterable))
+        self.assertTrue(isinstance(info.get_prerequisites(), collections.Iterable))
+        self.assertTrue(isinstance(info.get_properties(), collections.Iterable))
+        self.assertTrue(isinstance(info.get_signals(), collections.Iterable))
+
+        method = info.find_method('test_int8_in')
+        vfunc = info.find_vfunc('test_int8_in')
+        self.assertEqual(method.get_name(), 'test_int8_in')
+        self.assertEqual(vfunc.get_invoker(), method)
+        self.assertEqual(method.get_vfunc(), vfunc)
+
+        iface = info.get_iface_struct()
+        self.assertEqual(iface, repo.find_by_name('GIMarshallingTests', 'InterfaceIface'))
 
     def test_struct_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'InterfaceIface')
         self.assertTrue(isinstance(info, GIRepository.StructInfo))
         self.assertTrue(isinstance(info.get_fields(), collections.Iterable))
         self.assertTrue(isinstance(info.get_methods(), collections.Iterable))
+        self.assertTrue(isinstance(info.get_size(), int))
+        self.assertTrue(isinstance(info.get_alignment(), int))
+        self.assertTrue(info.is_gtype_struct())
+        self.assertFalse(info.is_foreign())
 
     def test_enum_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Enum')
         self.assertTrue(isinstance(info, GIRepository.EnumInfo))
         self.assertTrue(isinstance(info.get_values(), collections.Iterable))
+        self.assertTrue(isinstance(info.get_methods(), collections.Iterable))
         self.assertFalse(info.is_flags())
+        self.assertTrue(info.get_storage_type() > 0)  # might be platform dependent
 
     def test_union_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Union')
@@ -127,15 +163,90 @@ class Test(unittest.TestCase):
         self.assertTrue(isinstance(info.get_fields(), collections.Iterable))
         self.assertTrue(isinstance(info.get_methods(), collections.Iterable))
 
+    def test_type_info(self):
+        func_info = repo.find_by_name('GIMarshallingTests', 'array_fixed_out_struct')
+        arg_info, = func_info.get_arguments()
+        type_info = arg_info.get_type()
+
+        self.assertTrue(type_info.is_pointer())
+        self.assertEqual(type_info.get_tag(), GIRepository.TypeTag.ARRAY)
+        self.assertEqual(type_info.get_tag_as_string(), 'array')
+        self.assertEqual(type_info.get_param_type(0).get_tag(),
+                         GIRepository.TypeTag.INTERFACE)
+        self.assertEqual(type_info.get_param_type(0).get_interface(),
+                         repo.find_by_name('GIMarshallingTests', 'SimpleStruct'))
+        self.assertEqual(type_info.get_interface(), None)
+        self.assertEqual(type_info.get_array_length(), -1)
+        self.assertEqual(type_info.get_array_fixed_size(), 2)
+        self.assertFalse(type_info.is_zero_terminated())
+        self.assertEqual(type_info.get_array_type(), GIRepository.ArrayType.C)
+
     def test_field_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'InterfaceIface')
         field = find_child_info(info, 'get_fields', 'test_int8_in')
         self.assertEqual(field.get_name(), 'test_int8_in')
+        self.assertTrue(field.get_flags() & GIRepository.FieldInfoFlags.IS_READABLE)
+        self.assertFalse(field.get_flags() & GIRepository.FieldInfoFlags.IS_WRITABLE)
+        self.assertEqual(field.get_type().get_tag(), GIRepository.TypeTag.INTERFACE)
+
+        # don't test actual values because that might fail with architecture differences
+        self.assertTrue(isinstance(field.get_size(), int))
+        self.assertTrue(isinstance(field.get_offset(), int))
+
+    def test_property_info(self):
+        info = repo.find_by_name('GIMarshallingTests', 'PropertiesObject')
+        prop = find_child_info(info, 'get_properties', 'some-object')
+
+        flags = GObject.ParamFlags.READABLE | GObject.ParamFlags.WRITABLE | GObject.ParamFlags.CONSTRUCT
+        self.assertEqual(prop.get_flags(), flags)
+        self.assertEqual(prop.get_type().get_tag(), GIRepository.TypeTag.INTERFACE)
+        self.assertEqual(prop.get_type().get_interface(),
+                         repo.find_by_name('GObject', 'Object'))
+        self.assertEqual(prop.get_ownership_transfer(), GIRepository.Transfer.NOTHING)
 
     def test_callable_info(self):
         func_info = repo.find_by_name('GIMarshallingTests', 'array_fixed_out_struct')
         self.assertTrue(hasattr(func_info, 'invoke'))
         self.assertTrue(isinstance(func_info.get_arguments(), collections.Iterable))
+        self.assertEqual(func_info.get_caller_owns(), GIRepository.Transfer.NOTHING)
+        self.assertFalse(func_info.may_return_null())
+        self.assertEqual(func_info.get_return_type().get_tag(), GIRepository.TypeTag.VOID)
+        self.assertRaises(AttributeError, func_info.get_return_attribute, '_not_an_attr')
+
+    @unittest.expectedFailure  # https://bugzilla.gnome.org/show_bug.cgi?id=709462
+    @unittest.skipUnless(has_cairo, 'Regress needs cairo')
+    def test_signal_info(self):
+        repo.require('Regress')
+        info = repo.find_by_name('Regress', 'TestObj')
+        sig_info = find_child_info(info, 'get_signals', 'test')
+
+        sig_flags = GObject.SignalFlags.RUN_LAST | \
+            GObject.SignalFlags.NO_RECURSE | GObject.SignalFlags.NO_HOOKS
+
+        self.assertTrue(sig_info is not None)
+        self.assertTrue(isinstance(sig_info, GIRepository.CallableInfo))
+        self.assertTrue(isinstance(sig_info, GIRepository.SignalInfo))
+        self.assertEqual(sig_info.get_name(), 'test')
+        self.assertEqual(sig_info.get_class_closure(), None)
+        self.assertFalse(sig_info.true_stops_emit())
+        self.assertEqual(sig_info.get_flags(), sig_flags)
+
+    @unittest.expectedFailure  # https://bugzilla.gnome.org/show_bug.cgi?id=709462
+    @unittest.skipUnless(has_cairo, 'Regress needs cairo')
+    def test_notify_signal_info_with_obj(self):
+        repo.require('Regress')
+        info = repo.find_by_name('Regress', 'TestObj')
+        sig_info = find_child_info(info, 'get_signals', 'sig-with-array-prop')
+
+        sig_flags = GObject.SignalFlags.RUN_LAST
+
+        self.assertTrue(sig_info is not None)
+        self.assertTrue(isinstance(sig_info, GIRepository.CallableInfo))
+        self.assertTrue(isinstance(sig_info, GIRepository.SignalInfo))
+        self.assertEqual(sig_info.get_name(), 'sig-with-array-prop')
+        self.assertEqual(sig_info.get_class_closure(), None)
+        self.assertFalse(sig_info.true_stops_emit())
+        self.assertEqual(sig_info.get_flags(), sig_flags)
 
     def test_object_constructor(self):
         info = repo.find_by_name('GIMarshallingTests', 'Object')
@@ -147,6 +258,15 @@ class Test(unittest.TestCase):
         self.assertEqual(method.get_name(), 'new')
         self.assertFalse(method.is_method())
         self.assertTrue(method.is_constructor())
+        self.assertEqual(method.get_symbol(), 'gi_marshalling_tests_object_new')
+
+        flags = method.get_flags()
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.IS_METHOD)
+        self.assertTrue(flags & GIRepository.FunctionInfoFlags.IS_CONSTRUCTOR)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.IS_GETTER)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.IS_SETTER)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.WRAPS_VFUNC)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.THROWS)
 
     def test_method_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Object')
@@ -157,6 +277,16 @@ class Test(unittest.TestCase):
         self.assertTrue(method in info.get_methods())
         self.assertEqual(method.get_name(), 'vfunc_return_value_only')
         self.assertFalse(method.is_constructor())
+        self.assertEqual(method.get_symbol(), 'gi_marshalling_tests_object_vfunc_return_value_only')
+        self.assertTrue(method.is_method())
+
+        flags = method.get_flags()
+        self.assertTrue(flags & GIRepository.FunctionInfoFlags.IS_METHOD)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.IS_CONSTRUCTOR)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.IS_GETTER)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.IS_SETTER)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.WRAPS_VFUNC)
+        self.assertFalse(flags & GIRepository.FunctionInfoFlags.THROWS)
 
     def test_vfunc_info(self):
         info = repo.find_by_name('GIMarshallingTests', 'Object')
@@ -167,6 +297,10 @@ class Test(unittest.TestCase):
         self.assertTrue(isinstance(vfunc, GIRepository.VFuncInfo))
         self.assertEqual(vfunc.get_name(), 'vfunc_return_value_only')
         self.assertEqual(vfunc.get_invoker(), invoker)
+        self.assertEqual(invoker, info.find_method('vfunc_return_value_only'))
+        self.assertEqual(vfunc.get_flags(), 0)
+        self.assertEqual(vfunc.get_offset(), 0xFFFF)  # unknown offset
+        self.assertEqual(vfunc.get_signal(), None)
 
     def test_flags_double_registration_error(self):
         # a warning is printed for double registration and pygobject will