From 33039b3716cd62744af5d11992a9b22bcb45ce32 Mon Sep 17 00:00:00 2001 From: Johan Dahlin Date: Wed, 16 Mar 2005 13:49:10 +0000 Subject: New test. * tests/test_radiobutton.py (RadioButtonTest): New test. * tests: Renamed *.py to test_*.py --- tests/Makefile.am | 9 ++- tests/conversion.py | 59 --------------- tests/enum.py | 187 ---------------------------------------------- tests/gtype.py | 60 --------------- tests/runtests.py | 17 ++++- tests/test_conversion.py | 59 +++++++++++++++ tests/test_enum.py | 187 ++++++++++++++++++++++++++++++++++++++++++++++ tests/test_gtype.py | 60 +++++++++++++++ tests/test_radiobutton.py | 31 ++++++++ 9 files changed, 357 insertions(+), 312 deletions(-) delete mode 100644 tests/conversion.py delete mode 100644 tests/enum.py delete mode 100644 tests/gtype.py create mode 100644 tests/test_conversion.py create mode 100644 tests/test_enum.py create mode 100644 tests/test_gtype.py create mode 100644 tests/test_radiobutton.py diff --git a/tests/Makefile.am b/tests/Makefile.am index 6572eff..e3b46fc 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -19,12 +19,13 @@ testhelper_la_SOURCES = \ test-unknown.c tests = \ - test_subprocess.py \ - conversion.py \ - enum.py \ - gtype.py \ + test_conversion.py \ test_dialog.py \ + test_enum.py \ + test_gtype.py \ + test_radiobutton.py \ test_signal.py \ + test_subprocess.py \ test_subtype.py \ test_unknown.py diff --git a/tests/conversion.py b/tests/conversion.py deleted file mode 100644 index e621e1f..0000000 --- a/tests/conversion.py +++ /dev/null @@ -1,59 +0,0 @@ -# -*- Mode: Python -*- - -import unittest - -from common import gtk - -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) - assert entry.get_invisible_char() == unicode(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) - assert entry.get_property('invisible_char') == valid_value - - for invalid_value in ['12', None, 1, '']: - try: - entry.set_property('invisible_char', invalid_value) - except: - pass - else: - raise AssertionError('exception not raised on invalid value w/ set_property: %s' - % invalid_value) - - def testColorCreation(self): - """ Test GdkColor creation """ - - c = gtk.gdk.Color(1, 2, 3) - assert c.red == 1 and c.green == 2 and c.blue == 3 - - c = gtk.gdk.Color(pixel = 0xffff) - assert c.pixel == 0xffff - - c = gtk.gdk.Color(pixel = 0xffffL) - assert c.pixel == 0xffff - - c = gtk.gdk.Color(pixel = 0xffffffffL) - assert c.pixel == 0xffffffffL - -if __name__ == '__main__': - unittest.main() diff --git a/tests/enum.py b/tests/enum.py deleted file mode 100644 index 052a5e9..0000000 --- a/tests/enum.py +++ /dev/null @@ -1,187 +0,0 @@ -import unittest -import warnings - -from common import gobject, atk, pango, gtk, gdk - -class EnumTest(unittest.TestCase): - def testEnums(self): - assert issubclass(gobject.GEnum, int) - assert isinstance(atk.LAYER_OVERLAY, atk.Layer) - assert isinstance(atk.LAYER_OVERLAY, int) - assert 'LAYER_OVERLAY' in repr(atk.LAYER_OVERLAY) - assert int(atk.LAYER_OVERLAY) - assert atk.LAYER_INVALID == 0 - assert atk.LAYER_INVALID != 1 - assert atk.LAYER_INVALID != -1 - assert atk.LAYER_INVALID != atk.LAYER_BACKGROUND - - def testComparisionWarning(self): - warnings.filterwarnings("error", "", Warning, "", 0) - try: - assert 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() - assert state == gdk.WINDOW_STATE_WITHDRAWN - assert isinstance(state, gdk.WindowState) - assert 'WINDOW_STATE_WITHDRAWN' in repr(state) - - def testProperty(self): - win = gtk.Window() - - wtype = win.get_property('type') - assert wtype == gtk.WINDOW_TOPLEVEL - assert isinstance(wtype, gtk.WindowType) - assert 'WINDOW_TOPLEVEL' in repr(wtype) - - def testAtkObj(self): - obj = atk.NoOpObject(gobject.GObject()) - assert obj.get_role() == atk.ROLE_INVALID - - def testGParam(self): - win = gtk.Window() - enums = filter(lambda x: gobject.type_is_a(x.value_type, gobject.GEnum), - gobject.list_properties(win)) - assert enums - enum = enums[0] - assert hasattr(enum, 'enum_class') - assert issubclass(enum.enum_class, gobject.GEnum) - - def testWeirdEnumValues(self): - assert int(gdk.NOTHING) == -1 - assert int(gdk.BUTTON_PRESS) == 4 - - def testParamSpec(self): - props = filter(lambda prop: gobject.type_is_a(prop.value_type, gobject.GEnum), - gobject.list_properties(gtk.Window)) - assert len(props)>= 6 - props = filter(lambda prop: prop.name == 'type', props) - assert props - prop = props[0] - klass = prop.enum_class - assert klass == gtk.WindowType - assert hasattr(klass, '__enum_values__') - assert isinstance(klass.__enum_values__, dict) - assert len(klass.__enum_values__) >= 2 - - def testOutofBounds(self): - val = gtk.icon_size_register('fake', 24, 24) - assert isinstance(val, gobject.GEnum) - assert int(val) == 7 - assert '7' in repr(val) - assert 'GtkIconSize' in repr(val) - -class FlagsTest(unittest.TestCase): - def testFlags(self): - assert issubclass(gobject.GFlags, int) - assert isinstance(gdk.BUTTON_PRESS_MASK, gdk.EventMask) - assert isinstance(gdk.BUTTON_PRESS_MASK, int) - assert gdk.BUTTON_PRESS_MASK == 256 - assert gdk.BUTTON_PRESS_MASK != 0 - assert gdk.BUTTON_PRESS_MASK != -256 - assert gdk.BUTTON_PRESS_MASK != gdk.BUTTON_RELEASE_MASK - - assert gdk.EventMask.__bases__[0] == gobject.GFlags - assert len(gdk.EventMask.__flags_values__) == 22 - - def testComparisionWarning(self): - warnings.filterwarnings("error", "", Warning, "", 0) - try: - assert gtk.ACCEL_VISIBLE != gtk.EXPAND - except Warning: - pass - else: - raise AssertionError - warnings.resetwarnings() - - def testFlagOperations(self): - a = gdk.BUTTON_PRESS_MASK - assert isinstance(a, gobject.GFlags) - assert a.first_value_name == 'GDK_BUTTON_PRESS_MASK' - assert a.first_value_nick == 'button-press-mask' - assert a.value_names == ['GDK_BUTTON_PRESS_MASK'], a.value_names - assert a.value_nicks == ['button-press-mask'], a.value_names - b = gdk.BUTTON_PRESS_MASK | gdk.BUTTON_RELEASE_MASK - assert isinstance(b, gobject.GFlags) - assert b.first_value_name == 'GDK_BUTTON_PRESS_MASK' - assert b.first_value_nick == 'button-press-mask' - assert b.value_names == ['GDK_BUTTON_PRESS_MASK', 'GDK_BUTTON_RELEASE_MASK'] - assert b.value_nicks == ['button-press-mask', 'button-release-mask'] - c = gdk.BUTTON_PRESS_MASK | gdk.BUTTON_RELEASE_MASK | gdk.ENTER_NOTIFY_MASK - assert isinstance(c, gobject.GFlags) - assert c.first_value_name == 'GDK_BUTTON_PRESS_MASK' - assert c.first_value_nick == 'button-press-mask' - assert c.value_names == ['GDK_BUTTON_PRESS_MASK', 'GDK_BUTTON_RELEASE_MASK', - 'GDK_ENTER_NOTIFY_MASK'] - assert c.value_nicks == ['button-press-mask', 'button-release-mask', - 'enter-notify-mask'] - assert int(a) - assert int(a) == int(gdk.BUTTON_PRESS_MASK) - assert int(b) - assert int(b) == (int(gdk.BUTTON_PRESS_MASK) | - int(gdk.BUTTON_RELEASE_MASK)) - assert int(c) - assert 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.type_is_a(x.value_type, gobject.GFlags), - gtk.container_class_list_child_properties(gtk.Table)) - assert len(props) >= 2 - klass = props[0].flags_class - assert klass == gtk.AttachOptions - assert hasattr(klass, '__flags_values__') - assert isinstance(klass.__flags_values__, dict) - assert len(klass.__flags_values__) >= 3 - - def testEnumComparision(self): - enum = gtk.TREE_VIEW_DROP_BEFORE - assert enum == 0 - assert not enum == 10 - assert not enum != 0 - assert enum != 10 - assert not enum < 0 - assert enum < 10 - assert not enum > 0 - assert not enum > 10 - assert enum >= 0 - assert not enum >= 10 - assert enum <= 0 - assert enum <= 10 - - def testFlagComparision(self): - flag = gdk.EXPOSURE_MASK - assert flag == 2 - assert not flag == 10 - assert not flag != 2 - assert flag != 10 - assert not flag < 2 - assert flag < 10 - assert not flag > 2 - assert not flag > 10 - assert flag >= 2 - assert not flag >= 10 - assert flag <= 2 - assert flag <= 10 - -if __name__ == '__main__': - unittest.main() diff --git a/tests/gtype.py b/tests/gtype.py deleted file mode 100644 index a891ba2..0000000 --- a/tests/gtype.py +++ /dev/null @@ -1,60 +0,0 @@ -import unittest - -from common import gobject - -class GTypeTest(unittest.TestCase): - def checkType(self, expected, *objects): - # First, double check so we get back what we sent - str = gobject.type_name(expected) # pyg_type_from_object - val = gobject.type_from_name(str) # pyg_type_wrapper_new - assert val == expected, \ - 'got %r while %r was expected' % (val, expected) - - # Then test the objects - for object in objects: - str = gobject.type_name(expected) - val = gobject.type_from_name(str) - assert val == expected, \ - 'got %r while %r was expected' % (val, expected) - - def testBool(self): - self.checkType(gobject.TYPE_BOOLEAN, 'gboolean', bool) - - def testInt(self): - self.checkType(gobject.TYPE_INT, 'gint', int) - import gtk - 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') - - # XXX: Flags, Enums - -if __name__ == '__main__': - unittest.main() diff --git a/tests/runtests.py b/tests/runtests.py index b22ce2b..f4c9e1f 100644 --- a/tests/runtests.py +++ b/tests/runtests.py @@ -6,8 +6,19 @@ import unittest import common -buildDir = sys.argv[1] -srcDir = sys.argv[2] +if len(sys.argv) == 3: + buildDir = sys.argv[1] + srcDir = sys.argv[2] +else: + if len(sys.argv) == 2: + program = sys.argv[1] + if program.endswith('.py'): + program = program[:-3] + else: + program = None + + buildDir = '..' + srcDir = '.' common.importModules(buildDir=buildDir, srcDir=srcDir) @@ -26,6 +37,8 @@ suite = unittest.TestSuite() loader = unittest.TestLoader() for name in gettestnames(): + if program and program not in name: + continue suite.addTest(loader.loadTestsFromName(name)) testRunner = unittest.TextTestRunner() diff --git a/tests/test_conversion.py b/tests/test_conversion.py new file mode 100644 index 0000000..e621e1f --- /dev/null +++ b/tests/test_conversion.py @@ -0,0 +1,59 @@ +# -*- Mode: Python -*- + +import unittest + +from common import gtk + +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) + assert entry.get_invisible_char() == unicode(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) + assert entry.get_property('invisible_char') == valid_value + + for invalid_value in ['12', None, 1, '']: + try: + entry.set_property('invisible_char', invalid_value) + except: + pass + else: + raise AssertionError('exception not raised on invalid value w/ set_property: %s' + % invalid_value) + + def testColorCreation(self): + """ Test GdkColor creation """ + + c = gtk.gdk.Color(1, 2, 3) + assert c.red == 1 and c.green == 2 and c.blue == 3 + + c = gtk.gdk.Color(pixel = 0xffff) + assert c.pixel == 0xffff + + c = gtk.gdk.Color(pixel = 0xffffL) + assert c.pixel == 0xffff + + c = gtk.gdk.Color(pixel = 0xffffffffL) + assert c.pixel == 0xffffffffL + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_enum.py b/tests/test_enum.py new file mode 100644 index 0000000..052a5e9 --- /dev/null +++ b/tests/test_enum.py @@ -0,0 +1,187 @@ +import unittest +import warnings + +from common import gobject, atk, pango, gtk, gdk + +class EnumTest(unittest.TestCase): + def testEnums(self): + assert issubclass(gobject.GEnum, int) + assert isinstance(atk.LAYER_OVERLAY, atk.Layer) + assert isinstance(atk.LAYER_OVERLAY, int) + assert 'LAYER_OVERLAY' in repr(atk.LAYER_OVERLAY) + assert int(atk.LAYER_OVERLAY) + assert atk.LAYER_INVALID == 0 + assert atk.LAYER_INVALID != 1 + assert atk.LAYER_INVALID != -1 + assert atk.LAYER_INVALID != atk.LAYER_BACKGROUND + + def testComparisionWarning(self): + warnings.filterwarnings("error", "", Warning, "", 0) + try: + assert 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() + assert state == gdk.WINDOW_STATE_WITHDRAWN + assert isinstance(state, gdk.WindowState) + assert 'WINDOW_STATE_WITHDRAWN' in repr(state) + + def testProperty(self): + win = gtk.Window() + + wtype = win.get_property('type') + assert wtype == gtk.WINDOW_TOPLEVEL + assert isinstance(wtype, gtk.WindowType) + assert 'WINDOW_TOPLEVEL' in repr(wtype) + + def testAtkObj(self): + obj = atk.NoOpObject(gobject.GObject()) + assert obj.get_role() == atk.ROLE_INVALID + + def testGParam(self): + win = gtk.Window() + enums = filter(lambda x: gobject.type_is_a(x.value_type, gobject.GEnum), + gobject.list_properties(win)) + assert enums + enum = enums[0] + assert hasattr(enum, 'enum_class') + assert issubclass(enum.enum_class, gobject.GEnum) + + def testWeirdEnumValues(self): + assert int(gdk.NOTHING) == -1 + assert int(gdk.BUTTON_PRESS) == 4 + + def testParamSpec(self): + props = filter(lambda prop: gobject.type_is_a(prop.value_type, gobject.GEnum), + gobject.list_properties(gtk.Window)) + assert len(props)>= 6 + props = filter(lambda prop: prop.name == 'type', props) + assert props + prop = props[0] + klass = prop.enum_class + assert klass == gtk.WindowType + assert hasattr(klass, '__enum_values__') + assert isinstance(klass.__enum_values__, dict) + assert len(klass.__enum_values__) >= 2 + + def testOutofBounds(self): + val = gtk.icon_size_register('fake', 24, 24) + assert isinstance(val, gobject.GEnum) + assert int(val) == 7 + assert '7' in repr(val) + assert 'GtkIconSize' in repr(val) + +class FlagsTest(unittest.TestCase): + def testFlags(self): + assert issubclass(gobject.GFlags, int) + assert isinstance(gdk.BUTTON_PRESS_MASK, gdk.EventMask) + assert isinstance(gdk.BUTTON_PRESS_MASK, int) + assert gdk.BUTTON_PRESS_MASK == 256 + assert gdk.BUTTON_PRESS_MASK != 0 + assert gdk.BUTTON_PRESS_MASK != -256 + assert gdk.BUTTON_PRESS_MASK != gdk.BUTTON_RELEASE_MASK + + assert gdk.EventMask.__bases__[0] == gobject.GFlags + assert len(gdk.EventMask.__flags_values__) == 22 + + def testComparisionWarning(self): + warnings.filterwarnings("error", "", Warning, "", 0) + try: + assert gtk.ACCEL_VISIBLE != gtk.EXPAND + except Warning: + pass + else: + raise AssertionError + warnings.resetwarnings() + + def testFlagOperations(self): + a = gdk.BUTTON_PRESS_MASK + assert isinstance(a, gobject.GFlags) + assert a.first_value_name == 'GDK_BUTTON_PRESS_MASK' + assert a.first_value_nick == 'button-press-mask' + assert a.value_names == ['GDK_BUTTON_PRESS_MASK'], a.value_names + assert a.value_nicks == ['button-press-mask'], a.value_names + b = gdk.BUTTON_PRESS_MASK | gdk.BUTTON_RELEASE_MASK + assert isinstance(b, gobject.GFlags) + assert b.first_value_name == 'GDK_BUTTON_PRESS_MASK' + assert b.first_value_nick == 'button-press-mask' + assert b.value_names == ['GDK_BUTTON_PRESS_MASK', 'GDK_BUTTON_RELEASE_MASK'] + assert b.value_nicks == ['button-press-mask', 'button-release-mask'] + c = gdk.BUTTON_PRESS_MASK | gdk.BUTTON_RELEASE_MASK | gdk.ENTER_NOTIFY_MASK + assert isinstance(c, gobject.GFlags) + assert c.first_value_name == 'GDK_BUTTON_PRESS_MASK' + assert c.first_value_nick == 'button-press-mask' + assert c.value_names == ['GDK_BUTTON_PRESS_MASK', 'GDK_BUTTON_RELEASE_MASK', + 'GDK_ENTER_NOTIFY_MASK'] + assert c.value_nicks == ['button-press-mask', 'button-release-mask', + 'enter-notify-mask'] + assert int(a) + assert int(a) == int(gdk.BUTTON_PRESS_MASK) + assert int(b) + assert int(b) == (int(gdk.BUTTON_PRESS_MASK) | + int(gdk.BUTTON_RELEASE_MASK)) + assert int(c) + assert 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.type_is_a(x.value_type, gobject.GFlags), + gtk.container_class_list_child_properties(gtk.Table)) + assert len(props) >= 2 + klass = props[0].flags_class + assert klass == gtk.AttachOptions + assert hasattr(klass, '__flags_values__') + assert isinstance(klass.__flags_values__, dict) + assert len(klass.__flags_values__) >= 3 + + def testEnumComparision(self): + enum = gtk.TREE_VIEW_DROP_BEFORE + assert enum == 0 + assert not enum == 10 + assert not enum != 0 + assert enum != 10 + assert not enum < 0 + assert enum < 10 + assert not enum > 0 + assert not enum > 10 + assert enum >= 0 + assert not enum >= 10 + assert enum <= 0 + assert enum <= 10 + + def testFlagComparision(self): + flag = gdk.EXPOSURE_MASK + assert flag == 2 + assert not flag == 10 + assert not flag != 2 + assert flag != 10 + assert not flag < 2 + assert flag < 10 + assert not flag > 2 + assert not flag > 10 + assert flag >= 2 + assert not flag >= 10 + assert flag <= 2 + assert flag <= 10 + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_gtype.py b/tests/test_gtype.py new file mode 100644 index 0000000..a891ba2 --- /dev/null +++ b/tests/test_gtype.py @@ -0,0 +1,60 @@ +import unittest + +from common import gobject + +class GTypeTest(unittest.TestCase): + def checkType(self, expected, *objects): + # First, double check so we get back what we sent + str = gobject.type_name(expected) # pyg_type_from_object + val = gobject.type_from_name(str) # pyg_type_wrapper_new + assert val == expected, \ + 'got %r while %r was expected' % (val, expected) + + # Then test the objects + for object in objects: + str = gobject.type_name(expected) + val = gobject.type_from_name(str) + assert val == expected, \ + 'got %r while %r was expected' % (val, expected) + + def testBool(self): + self.checkType(gobject.TYPE_BOOLEAN, 'gboolean', bool) + + def testInt(self): + self.checkType(gobject.TYPE_INT, 'gint', int) + import gtk + 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') + + # XXX: Flags, Enums + +if __name__ == '__main__': + unittest.main() diff --git a/tests/test_radiobutton.py b/tests/test_radiobutton.py new file mode 100644 index 0000000..791f8b2 --- /dev/null +++ b/tests/test_radiobutton.py @@ -0,0 +1,31 @@ +import unittest + +from common import gtk + +class RadioButtonTest(unittest.TestCase): + def testCreate(self): + radio = gtk.RadioButton() + self.assert_(isinstance(radio, gtk.RadioButton)) + + def testLabel(self): + radio = gtk.RadioButton(None, 'test-radio') + self.assertEqual(radio.get_label(), 'test-radio') + + def testGroup(self): + radio = gtk.RadioButton() + radio2 = gtk.RadioButton(radio) + self.assertEqual(radio.get_group(), radio2.get_group()) + + def testEmptyGroup(self): + radio = gtk.RadioButton() + radio2 = gtk.RadioButton() + self.assertEqual(radio.get_group(), [radio]) + self.assertEqual(radio2.get_group(), [radio2]) + radio2.set_group(radio) + self.assertEqual(radio.get_group(), radio2.get_group()) + radio2.set_group(None) + self.assertEqual(radio.get_group(), [radio]) + self.assertEqual(radio2.get_group(), [radio2]) + +if __name__ == '__main__': + unittest.main() -- cgit