From 4cbd9941c5705970a9f7a429e236e1203d3155a1 Mon Sep 17 00:00:00 2001 From: Gian Mario Tagliaretti Date: Mon, 5 Apr 2010 18:10:42 +0200 Subject: Bug 613341 - pygobject tests seem to require pygtk causing a circular dependencies problem move tests that require pygtk to pygtk itself --- tests/test_conversion.py | 83 -------------- tests/test_enum.py | 234 -------------------------------------- tests/test_gtype.py | 112 ------------------ tests/test_subtype.py | 289 ----------------------------------------------- 4 files changed, 718 deletions(-) delete mode 100644 tests/test_conversion.py delete mode 100644 tests/test_enum.py delete mode 100644 tests/test_gtype.py delete mode 100644 tests/test_subtype.py 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('') - dialog = builder.get_object('main') - - self.assert_(isinstance(dialog, gtk.Buildable)) - self.assert_(hasattr(dialog, 'built')) -- cgit