Bug 613341 - pygobject tests seem to require pygtk causing a circular

dependencies problem

move tests that require pygtk to pygtk itself

4 files changed, 0 insertions, 718 deletions

diff --git a/tests/test_conversion.py b/tests/test_conversion.py
deleted file mode 100644
index 30d29df..0000000
--- a/tests/test_conversion.py
+++ /dev/null
@@ -1,83 +0,0 @@
-# -*- Mode: Python -*-
-
-import unittest
-
-from common import gtk, gobject
-
-class Tests(unittest.TestCase):
-
-    def testUnicharArg(self):
-        """ Test unichar values when used as arguments. """
-
-        entry = gtk.Entry()
-        for valid_value in ['a', u'b', u'\ufff0', u'\ufff0'.encode()]:
-            entry.set_invisible_char(valid_value)
-            self.assertEqual(entry.get_invisible_char(),
-                             unicode(valid_value),
-                             valid_value)
-
-        for invalid_value in ('12', None, 1, ''):
-            try:
-                entry.set_invisible_char(invalid_value)
-            except:
-                pass
-            else:
-                raise AssertionError(
-                    'exception not raised on invalid value w/ '
-                    'set_invisible_char: %s'  % invalid_value)
-
-
-    def testUnicharProperty(self):
-        """ Test unichar values when used as properties. """
-
-        entry = gtk.Entry()
-        for valid_value in ['a', u'b', u'\ufff0', u'\ufff0'.encode()]:
-            entry.set_property('invisible_char', valid_value)
-            self.assertEqual(entry.get_property('invisible_char'),
-                             valid_value, valid_value)
-
-        for invalid_value in ('12', None, 1, ''):
-            try:
-                entry.set_property('invisible_char', invalid_value)
-            except TypeError:
-                pass
-            else:
-                raise AssertionError(
-                    'exception not raised on invalid value w/ '
-                    'set_invisible_char: %s'  % invalid_value)
-
-    def testUnicharConstructor(self):
-        for valid_value in ['a', u'b', u'\ufff0', u'\ufff0'.encode()]:
-            entry = gobject.new(gtk.Entry, invisible_char=valid_value)
-            self.assertEqual(entry.get_property('invisible_char'),
-                             valid_value, valid_value)
-
-    def testColorCreation(self):
-        """ Test GdkColor creation """
-
-        c = gtk.gdk.Color(1, 2, 3)
-        self.assertEqual(c.red, 1)
-        self.assertEqual(c.green, 2)
-        self.assertEqual(c.blue, 3)
-
-        c = gtk.gdk.Color(pixel=0xffff)
-        self.assertEqual(c.pixel, 0xffff)
-
-        c = gtk.gdk.Color(pixel=0xffffL)
-        self.assertEqual(c.pixel, 0xffff)
-
-        c = gtk.gdk.Color(pixel=0xffffffffL)
-        self.assertEqual(c.pixel, 0xffffffffL)
-
-    def testUIntArg(self):
-        child = gtk.DrawingArea()
-        table = gtk.Table(2, 2, False)
-        table.attach(child, 1, 2, 0, 1, ypadding=2)
-        self.assertEqual(table.child_get_property(child, 'y-padding'), 2)
-
-        child = gtk.DrawingArea()
-        table.attach(child, 1, 2, 0, 1, ypadding=2L)
-        self.assertEqual(table.child_get_property(child, 'y-padding'), 2)
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/tests/test_enum.py b/tests/test_enum.py
deleted file mode 100644
index f4d6bef..0000000
--- a/tests/test_enum.py
+++ /dev/null
@@ -1,234 +0,0 @@
-import pickle
-import unittest
-import warnings
-
-# FIXME: Do not import this
-from common import gobject, atk, gtk, gdk
-
-
-class PObject(gobject.GObject):
-    enum = gobject.property(type=gtk.WindowType, default=gtk.WINDOW_TOPLEVEL)
-    enum2 = gobject.property(type=gtk.WindowType, default=int(gtk.WINDOW_TOPLEVEL))
-    flags = gobject.property(type=gtk.AttachOptions, default=gtk.EXPAND)
-    flags2 = gobject.property(type=gtk.AttachOptions, default=int(gtk.EXPAND))
-
-
-class EnumTest(unittest.TestCase):
-    def testEnums(self):
-        self.failUnless(issubclass(gobject.GEnum, int))
-        self.failUnless(isinstance(atk.LAYER_OVERLAY, atk.Layer))
-        self.failUnless(isinstance(atk.LAYER_OVERLAY, int))
-        self.failUnless('LAYER_OVERLAY' in repr(atk.LAYER_OVERLAY))
-        self.failUnless(int(atk.LAYER_OVERLAY))
-        self.assertEquals(atk.LAYER_INVALID, 0)
-        self.assertNotEquals(atk.LAYER_INVALID, 1)
-        self.assertNotEquals(atk.LAYER_INVALID, -1)
-        self.assertNotEquals(atk.LAYER_INVALID, atk.LAYER_BACKGROUND)
-
-    def testComparisionWarning(self):
-        warnings.filterwarnings("error", "", Warning, "", 0)
-        try:
-            self.assertNotEquals(atk.LAYER_INVALID, atk.RELATION_NULL)
-        except Warning:
-            pass
-        else:
-            raise AssertionError
-        warnings.resetwarnings()
-
-    def testWindowGetState(self):
-        win = gtk.Window()
-        win.realize()
-
-        state = win.window.get_state()
-        self.assertEquals(state, gdk.WINDOW_STATE_WITHDRAWN)
-        self.failUnless(isinstance(state, gdk.WindowState))
-        self.failUnless('WINDOW_STATE_WITHDRAWN' in repr(state))
-
-    def testProperty(self):
-        win = gtk.Window()
-
-        wtype = win.get_property('type')
-        self.assertEquals(wtype, gtk.WINDOW_TOPLEVEL)
-        self.failUnless(isinstance(wtype, gtk.WindowType))
-        self.failUnless('WINDOW_TOPLEVEL' in repr(wtype))
-
-    def testAtkObj(self):
-        obj = atk.NoOpObject(gobject.GObject())
-        self.assertEquals(obj.get_role(), atk.ROLE_INVALID)
-
-    def testGParam(self):
-        win = gtk.Window()
-        enums = filter(lambda x: gobject.GType.is_a(x.value_type, gobject.GEnum),
-                       gobject.list_properties(win))
-        self.failUnless(enums)
-        enum = enums[0]
-        self.failUnless(hasattr(enum, 'enum_class'))
-        self.failUnless(issubclass(enum.enum_class, gobject.GEnum))
-
-    def testWeirdEnumValues(self):
-        self.assertEquals(int(gdk.NOTHING), -1)
-        self.assertEquals(int(gdk.BUTTON_PRESS), 4)
-
-    def testParamSpec(self):
-        props = filter(lambda prop: gobject.GType.is_a(prop.value_type, gobject.GEnum),
-                       gobject.list_properties(gtk.Window))
-        self.failUnless(len(props)>= 6)
-        props = filter(lambda prop: prop.name == 'type', props)
-        self.failUnless(props)
-        pspec = props[0]
-        klass = pspec.enum_class
-        self.assertEquals(klass, gtk.WindowType)
-        self.failUnless(hasattr(klass, '__enum_values__'))
-        self.failUnless(isinstance(klass.__enum_values__, dict))
-        self.failUnless(len(klass.__enum_values__) >= 2)
-        self.failUnless(isinstance(pspec.default_value, gtk.WindowType))
-
-    def testOutofBounds(self):
-        val = gtk.icon_size_register('fake', 24, 24)
-        self.failUnless(isinstance(val, gobject.gobject.GEnum))
-        self.assertEquals(int(val), 7)
-        self.failUnless('7' in repr(val))
-        self.failUnless('GtkIconSize' in repr(val))
-
-    def testEnumProperty(self):
-        default = PObject.props.enum.default_value
-        self.failUnless(isinstance(default, gtk.WindowType))
-        self.assertEqual(default, gtk.WINDOW_TOPLEVEL)
-        default = PObject.props.enum2.default_value
-        self.failUnless(isinstance(default, gtk.WindowType))
-        self.assertEqual(default, gtk.WINDOW_TOPLEVEL)
-
-    def testPickling(self):
-        values = [getattr(gtk, name) for name in dir(gtk)
-                  if isinstance(getattr(gtk, name), gobject.gobject.GEnum)]
-        for protocol in range(0, pickle.HIGHEST_PROTOCOL + 1):
-            for value in values:
-                self.assertEqual(value, pickle.loads(pickle.dumps(value, protocol)))
-
-
-class FlagsTest(unittest.TestCase):
-    def testFlags(self):
-        self.failUnless(issubclass(gobject.GFlags, int))
-        self.failUnless(isinstance(gdk.BUTTON_PRESS_MASK, gdk.EventMask))
-        self.failUnless(isinstance(gdk.BUTTON_PRESS_MASK, int))
-        self.assertEquals(gdk.BUTTON_PRESS_MASK, 256)
-        self.assertNotEquals(gdk.BUTTON_PRESS_MASK, 0)
-        self.assertNotEquals(gdk.BUTTON_PRESS_MASK, -256)
-        self.assertNotEquals(gdk.BUTTON_PRESS_MASK, gdk.BUTTON_RELEASE_MASK)
-
-        self.assertEquals(gdk.EventMask.__bases__[0], gobject.GFlags)
-        self.assertEquals(len(gdk.EventMask.__flags_values__), 22)
-
-    def testComparisionWarning(self):
-        warnings.filterwarnings("error", "", Warning, "", 0)
-        try:
-            self.assertNotEquals(gtk.ACCEL_VISIBLE, gtk.EXPAND)
-        except Warning:
-            pass
-        else:
-            raise AssertionError
-        warnings.resetwarnings()
-
-    def testFlagOperations(self):
-        a = gdk.BUTTON_PRESS_MASK
-        self.failUnless(isinstance(a, gobject.GFlags))
-        self.assertEquals(a.first_value_name, 'GDK_BUTTON_PRESS_MASK')
-        self.assertEquals(a.first_value_nick, 'button-press-mask')
-        self.assertEquals(a.value_names, ['GDK_BUTTON_PRESS_MASK'],
-                          a.value_names)
-        self.assertEquals(a.value_nicks, ['button-press-mask'],
-                          a.value_names)
-        b = gdk.BUTTON_PRESS_MASK | gdk.BUTTON_RELEASE_MASK
-        self.failUnless(isinstance(b, gobject.GFlags))
-        self.assertEquals(b.first_value_name, 'GDK_BUTTON_PRESS_MASK')
-        self.assertEquals(b.first_value_nick, 'button-press-mask')
-        self.assertEquals(b.value_names, ['GDK_BUTTON_PRESS_MASK',
-                                          'GDK_BUTTON_RELEASE_MASK'])
-        self.assertEquals(b.value_nicks, ['button-press-mask',
-                                          'button-release-mask'])
-        c = (gdk.BUTTON_PRESS_MASK |
-             gdk.BUTTON_RELEASE_MASK |
-             gdk.ENTER_NOTIFY_MASK)
-        self.failUnless(isinstance(c, gobject.GFlags))
-        self.assertEquals(c.first_value_name, 'GDK_BUTTON_PRESS_MASK')
-        self.assertEquals(c.first_value_nick, 'button-press-mask')
-        self.assertEquals(c.value_names,
-                          ['GDK_BUTTON_PRESS_MASK',
-                           'GDK_BUTTON_RELEASE_MASK',
-                           'GDK_ENTER_NOTIFY_MASK'])
-        self.assertEquals(c.value_nicks,
-                          ['button-press-mask',
-                           'button-release-mask',
-                           'enter-notify-mask'])
-        self.failUnless(int(a))
-        self.assertEquals(int(a), int(gdk.BUTTON_PRESS_MASK))
-        self.failUnless(int(b))
-        self.assertEquals(int(b), (int(gdk.BUTTON_PRESS_MASK) |
-                                   int(gdk.BUTTON_RELEASE_MASK)))
-        self.failUnless(int(c))
-        self.assertEquals(int(c), (int(gdk.BUTTON_PRESS_MASK) |
-                                   int(gdk.BUTTON_RELEASE_MASK) |
-                                   int(gdk.ENTER_NOTIFY_MASK)))
-
-    def testUnsupportedOpertionWarning(self):
-        warnings.filterwarnings("error", "", Warning, "", 0)
-        try:
-            value = gdk.BUTTON_PRESS_MASK + gdk.BUTTON_RELEASE_MASK
-        except Warning:
-            pass
-        else:
-            raise AssertionError
-        warnings.resetwarnings()
-
-    def testParamSpec(self):
-        props = filter(lambda x: gobject.GType.is_a(x.value_type, gobject.GFlags),
-                       gtk.container_class_list_child_properties(gtk.Table))
-        self.failUnless(len(props) >= 2)
-        pspec = props[0]
-        klass = pspec.flags_class
-        self.assertEquals(klass, gtk.AttachOptions)
-        self.failUnless(hasattr(klass, '__flags_values__'))
-        self.failUnless(isinstance(klass.__flags_values__, dict))
-        self.failUnless(len(klass.__flags_values__) >= 3)
-        self.failUnless(isinstance(pspec.default_value, gtk.AttachOptions))
-
-    def testEnumComparision(self):
-        enum = gtk.TREE_VIEW_DROP_BEFORE
-        self.assertEquals(enum, 0)
-        self.failUnless(not enum == 10)
-        self.failUnless(not enum != 0)
-        self.assertNotEquals(enum, 10)
-        self.failUnless(not enum < 0)
-        self.failUnless(enum < 10)
-        self.failUnless(not enum > 0)
-        self.failUnless(not enum > 10)
-        self.failUnless(enum >= 0)
-        self.failUnless(not enum >= 10)
-        self.failUnless(enum <= 0)
-        self.failUnless(enum <= 10)
-
-    def testFlagComparision(self):
-        flag = gdk.EXPOSURE_MASK
-        self.assertEquals(flag, 2)
-        self.failUnless(not flag == 10)
-        self.failUnless(not flag != 2)
-        self.assertNotEquals(flag, 10)
-        self.failUnless(not flag < 2)
-        self.failUnless(flag < 10)
-        self.failUnless(not flag > 2)
-        self.failUnless(not flag > 10)
-        self.failUnless(flag >= 2)
-        self.failUnless(not flag >= 10)
-        self.failUnless(flag <= 2)
-        self.failUnless(flag <= 10)
-
-    def testFlagsProperty(self):
-        default = PObject.props.flags.default_value
-        self.failUnless(isinstance(default, gtk.AttachOptions))
-        self.assertEqual(default, gtk.EXPAND)
-        default = PObject.props.flags2.default_value
-        self.failUnless(isinstance(default, gtk.AttachOptions))
-        self.assertEqual(default, gtk.EXPAND)
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/tests/test_gtype.py b/tests/test_gtype.py
deleted file mode 100644
index cd1b140..0000000
--- a/tests/test_gtype.py
+++ /dev/null
@@ -1,112 +0,0 @@
-import unittest
-
-from gobject import GType
-from common import gobject, testhelper
-
-def raiseGError():
-    err = gobject.GError
-    err.message = "Test conversion between exception and GError"
-    err.code = 1
-    err.domain = ""
-    raise err
-
-def test_raiseGError():
-    testhelper.test_gerror_exception(raiseGError)
-
-class GTypeTest(unittest.TestCase):
-    def checkType(self, expected, *objects):
-        # First, double check so we get back what we sent
-        str = GType(expected).name # pyg_type_from_object
-        val = GType.from_name(str) # pyg_type_wrapper_new
-        self.assertEqual(val, expected,
-                         'got %r while %r was expected' % (val, expected))
-
-        # Then test the objects
-        for object in objects:
-            val = GType.from_name(GType(expected).name)
-            self.assertEqual(val, expected,
-                             'got %r while %r was expected' %
-                             (val, expected))
-
-    def assertPyType(self, val, pytype):
-        val.pytype = pytype
-        self.assertEqual(val.pytype, pytype,
-                         'got %r while %r was expected' % (val.pytype, pytype))
-
-    def setInvalidPyType(self):
-        val = GType(gobject.TYPE_INT)
-        val.pytype = 1
-
-    def testBool(self):
-        self.checkType(gobject.TYPE_BOOLEAN, 'gboolean', bool)
-
-    def testInt(self):
-        self.checkType(gobject.TYPE_INT, 'gint', int)
-    #    model = gtk.ListStore(str, int)
-    #    iter = model.append()
-    #    model.set(iter, 1, 100000000)
-
-    def testInt64(self):
-        self.checkType(gobject.TYPE_INT64, 'gint64')
-
-    def testUint(self):
-        self.checkType(gobject.TYPE_UINT, 'guint')
-
-    def testUint64(self):
-        self.checkType(gobject.TYPE_UINT64, 'guint64')
-
-    def testLong(self):
-        self.checkType(gobject.TYPE_LONG, 'glong', long)
-
-    def testUlong(self):
-        self.checkType(gobject.TYPE_ULONG, 'gulong')
-
-    def testDouble(self):
-        self.checkType(gobject.TYPE_DOUBLE, 'gdouble', float)
-
-    def testFloat(self):
-        self.checkType(gobject.TYPE_FLOAT, 'gfloat')
-
-    def testPyObject(self):
-        self.checkType(gobject.TYPE_PYOBJECT, 'GObject', object)
-
-    def testObject(self):
-        self.checkType(gobject.TYPE_OBJECT, 'PyObject')
-
-    def testPyType(self):
-        val = GType(gobject.TYPE_INT)
-        self.assertEqual(val.pytype, None,
-                         'got %r while %r was expected' % (val.pytype, None))
-        for t in [int, None, float]:
-            self.assertPyType(val, t)
-
-    def testInvalidPyType(self):
-        self.assertRaises(TypeError, self.setInvalidPyType)
-
-    def testValue(self):
-        array = [1, "foo", True]
-        for i in array:
-            self.assertEqual(i, testhelper.test_value(i))
-            
-    def testValueArray(self):
-        array = [1, 2, 3, "foo", True]
-        self.assertEqual(array, testhelper.test_value_array(array))
-
-    def testValueArrayNone(self):
-        array = [1, 2, 3, "foo", True, None]
-        self.assertEqual(array, testhelper.test_value_array(array))
-
-    def testGError(self):
-        self.assertRaises(gobject.GError, test_raiseGError)
-
-    # XXX: Flags, Enums
-
-class MyObject(gobject.GObject):
-    __gtype_name__ = 'MyObject'
-
-class TypeNameTest(unittest.TestCase):
-    def testTypeName(self):
-        self.assertEqual(GType(MyObject).name, 'MyObject')
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/tests/test_subtype.py b/tests/test_subtype.py
deleted file mode 100644
index 6fce3a0..0000000
--- a/tests/test_subtype.py
+++ /dev/null
@@ -1,289 +0,0 @@
-import unittest
-import weakref
-import gc
-
-import testmodule
-from common import gobject, testhelper
-
-# FIXME: do not import gtk
-import gtk
-
-
-class _ClassInittableMetaType(gobject.GObjectMeta):
-    def __init__(cls, name, bases, namespace):
-        super(_ClassInittableMetaType, cls).__init__(name, bases, namespace)
-        cls.__class_init__(namespace)
-
-
-class ClassInittableObject(object):
-    __metaclass__ = _ClassInittableMetaType
-    def __class_init__(cls, namespace):
-        pass
-    __class_init__ = classmethod(__class_init__)
-
-
-class TestSubType(unittest.TestCase):
-    def testSubType(self):
-        t = type('testtype', (gobject.GObject, gobject.GInterface), {})
-        self.failUnless(issubclass(t, gobject.GObject))
-        self.failUnless(issubclass(t, gobject.GInterface))
-
-    def testGObject(self):
-        label = gobject.GObject()
-        self.assertEqual(label.__grefcount__, 1)
-        label = gobject.new(gobject.GObject)
-        self.assertEqual(label.__grefcount__, 1)
-
-    def testPythonSubclass(self):
-        label = testmodule.PyGObject()
-        self.assertEqual(label.__grefcount__, 1)
-        self.assertEqual(label.props.label, "hello")
-        label = gobject.new(testmodule.PyGObject)
-        self.assertEqual(label.__grefcount__, 1)
-        self.assertEqual(label.props.label, "hello")
-
-    def testCPyCSubclassing(self):
-        obj = testhelper.create_test_type()
-        self.assertEqual(obj.__grefcount__, 1)
-        refcount = testhelper.test_g_object_new()
-        self.assertEqual(refcount, 2)
-
-    def testRegisterArgNotType(self):
-        self.assertRaises(TypeError, gobject.type_register, 1)
-
-    def testGObjectNewError(self):
-        self.assertRaises(TypeError, gobject.new, gobject.GObject, text='foo')
-
-    def testSubSubType(self):
-        Object1 = type('Object1', (gobject.GObject,),
-                       {'__gtype_name__': 'Object1'})
-        Object2 = type('Object2', (Object1,),
-                       {'__gtype_name__': 'Object2'})
-
-        obj = Object2()
-        self.failUnless(isinstance(obj, Object2))
-        self.assertEqual(obj.__gtype__.name, 'Object2')
-
-        obj = gobject.new(Object2)
-        self.failUnless(isinstance(obj, Object2))
-        self.assertEqual(obj.__gtype__.name, 'Object2')
-
-    def testUnregisteredSubclass(self):
-        class MyButton(gtk.Button):
-            def custom_method(self):
-                pass
-        b = MyButton()
-        self.assertEqual(type(b), MyButton)
-        box = gtk.EventBox()
-        box.add(b)
-        del b
-        b = box.child
-        self.assertEqual(type(b), MyButton)
-        try:
-            b.custom_method()
-        except AttributeError:
-            self.fail()
-
-    def testInstDict(self):
-        b = gtk.Button()
-        box = gtk.EventBox()
-        box.add(b)
-        b.xyz = "zbr"
-        del b
-        b = box.child
-        self.assert_(hasattr(b, "xyz"))
-        try:
-            xyz = b.xyz
-        except AttributeError:
-            self.fail()
-        self.assertEqual(xyz, "zbr")
-
-    def testImmediateCollection(self):
-        b = gtk.Button()
-        bref = weakref.ref(b)
-        while gc.collect():
-            pass
-        del b
-        self.assertEqual(gc.collect(), 0)
-        self.assertEqual(bref(), None)
-
-    def testGCCollection(self):
-        a = gtk.Button()
-        b = gtk.Button()
-        a.b = b
-        b.a = a
-        aref = weakref.ref(a)
-        bref = weakref.ref(b)
-        del a, b
-        while gc.collect():
-            pass
-        self.assertEqual(aref(), None)
-        self.assertEqual(bref(), None)
-
-    def testWrapperUnref(self):
-        b = gtk.Button()
-        bref = weakref.ref(b)
-        del b
-        self.assertEqual(bref(), None)
-
-    def testGObjectUnref(self):
-        b = gtk.Button()
-        bref = b.weak_ref()
-        self.assert_(bref() is b)
-        del b
-        self.assertEqual(bref(), None)
-
-    def testGCCollection(self):
-        a = gtk.Button()
-        b = gtk.Button()
-        a.b = b
-        b.a = a
-        aref = a.weak_ref()
-        bref = b.weak_ref()
-        del a, b
-        while gc.collect():
-            pass
-        self.assertEqual(aref(), None)
-        self.assertEqual(bref(), None)
-
-    def testGhostTwice(self):
-        b = gtk.Button()
-        bref = b.weak_ref()
-        box = gtk.EventBox()
-        box.add(b)
-        del b
-        b = box.child
-        del b
-        self.assertNotEqual(bref(), None)
-        box.destroy()
-        del box
-        self.assertEqual(bref(), None)
-
-    def testGhostWeakref(self):
-        b = gtk.Button()
-        bref = b.weak_ref()
-        box = gtk.EventBox()
-        box.add(b)
-        del b
-        b = bref()
-        b.hide()
-        del box
-        b.hide()
-        del b
-
-    def testWeakRefCallback(self):
-        def callback(a, b, c):
-            self._wr_args = a, b, c
-        self._wr_args = None
-        b = gtk.Button()
-        bref = b.weak_ref(callback, 1, 2, 3)
-        del b
-        self.assertEqual(self._wr_args, (1, 2, 3))
-
-
-    def testCycle(self):
-
-        class _TestCycle(gtk.EventBox):
-            def __init__(self):
-                gtk.EventBox.__init__(self)
-                self.connect('notify', self.cb)
-
-                class DetectDel:
-                    def __del__(self):
-                        pass
-                        #print 'del'
-
-                self.d = DetectDel()
-
-            def cb(self, *args):
-                pass
-
-        a = _TestCycle()
-        a_d_id = id(a.d)
-        a.foo = "hello"
-        b = gtk.EventBox()
-        b.add(a)
-        #print "__dict__1: refcount=%i id=%i" % (sys.getrefcount(a.__dict__), id(a.__dict__))
-
-        del a
-        while gc.collect():
-            pass
-        a = b.child
-        #print "__dict__2: refcount=%i id=%i" % (sys.getrefcount(a.__dict__), id(a.__dict__))
-
-        del a
-        while gc.collect():
-            pass
-        a = b.child
-        #print "__dict__3: refcount=%i id=%i" % (sys.getrefcount(a.__dict__), id(a.__dict__))
-
-        self.assert_(hasattr(a, 'd'))
-        self.assert_(hasattr(a, 'foo'))
-        self.assertEqual(a.foo, "hello")
-        self.assertEqual(id(a.d), a_d_id)
-
-    def testSimpleDecref(self):
-        class CallInDel:
-            def __init__(self, callback):
-                self.callback = callback
-
-            def __del__(self):
-                if callable(self.callback):
-                    self.callback()
-        disposed_calls = []
-        def on_dispose():
-            disposed_calls.append(None)
-        gobj = gobject.GObject()
-        gobj.set_data('tmp', CallInDel(on_dispose))
-        del gobj
-        assert len(disposed_calls) == 1
-
-    def testDescriptor(self):
-        # Test for bug #434659
-        class GProperty(object):
-            def __set__(self, instance, value):
-                pass
-
-        class C(gobject.GObject):
-            str = GProperty()
-
-        o = C()
-        o.str = 'str'
-        o.str = 'str'
-
-    def testDescriptorV2(self):
-        """http://bugzilla.gnome.org/show_bug.cgi?id=447271"""
-        class Foo(gobject.GObject):
-            def set_foo(self, foo):
-                self._foo = foo
-            def get_foo(self, foo):
-                self._foo = foo
-            fooprop = property(get_foo, set_foo)
-
-        foo = Foo()
-        foo.fooprop = 123
-
-    def testGetDict(self):
-        """reported in bug #466082"""
-        class Foo(gobject.GObject):
-            __gtype_name__ = 'Foo'
-        foo = Foo()
-        d = foo.__dict__
-
-    def test_gtk_buildable_virtual_method(self):
-        """Bug 566571."""
-
-        # Currently the bug is not solved, so skip the test.
-        return
-
-        class CustomDialog(gtk.Dialog):
-            __gtype_name__ = 'CustomDialog'
-            def do_parser_finished(self, build):
-                self.built = True
-
-        builder = gtk.Builder()
-        builder.add_from_string('<interface><object class="CustomDialog" id="main"/></interface>')
-        dialog = builder.get_object('main')
-
-        self.assert_(isinstance(dialog, gtk.Buildable))
-        self.assert_(hasattr(dialog, 'built'))