Allow enums to be specified in the constructor Return flags or enum object

    * gobject/gobjectmodule.c: (create_property):
    Allow enums to be specified in the constructor
    * gobject/pygparamspec.c: (pyg_param_spec_getattr):
    Return flags or enum object for pspec.default_value
    * tests/test_enum.py: Remove usage of assert statement,
    add default_value test, both for flags and enum

3 files changed, 184 insertions, 119 deletions

diff --git a/gobject/gobjectmodule.c b/gobject/gobjectmodule.c
index b6dba0d..e038bfa 100644
--- a/gobject/gobjectmodule.c
+++ b/gobject/gobjectmodule.c
@@ -701,9 +701,15 @@ create_property (const gchar  *prop_name,
     case G_TYPE_ENUM:
 	{
 	    gint default_value;
-
-	    if (!PyArg_ParseTuple(args, "i", &default_value))
+	    PyObject *pydefault;
+	    
+	    if (!PyArg_ParseTuple(args, "O", &pydefault))
+		return NULL;
+	    
+	    if (pyg_enum_get_value(prop_type, pydefault,
+				   (gint *)&default_value))
 		return NULL;
+	    
 	    pspec = g_param_spec_enum (prop_name, nick, blurb,
 				       prop_type, default_value, flags);
 	}
@@ -711,9 +717,15 @@ create_property (const gchar  *prop_name,
     case G_TYPE_FLAGS:
 	{
 	    guint default_value;
+	    PyObject *pydefault;
 
-	    if (!PyArg_ParseTuple(args, "i", &default_value))
+	    if (!PyArg_ParseTuple(args, "O", &pydefault))
+		return NULL;
+	    
+	    if (pyg_flags_get_value(prop_type, pydefault,
+				    (gint *)&default_value))
 		return NULL;
+	    
 	    pspec = g_param_spec_flags (prop_name, nick, blurb,
 					prop_type, default_value, flags);
 	}
diff --git a/gobject/pygparamspec.c b/gobject/pygparamspec.c
index 13a526c..4bcc3f1 100644
--- a/gobject/pygparamspec.c
+++ b/gobject/pygparamspec.c
@@ -131,7 +131,8 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "value_type", "minimum", "maximum",
 				 "default_value");
 	} else if (!strcmp(attr, "default_value")) {
-	    return PyString_FromFormat("%c", G_PARAM_SPEC_CHAR(pspec)->default_value);
+	    return PyString_FromFormat(
+		"%c", G_PARAM_SPEC_CHAR(pspec)->default_value);
 	} else if (!strcmp(attr, "minimum")) {
 	    return PyInt_FromLong(G_PARAM_SPEC_CHAR(pspec)->minimum);
 	} else if (!strcmp(attr, "maximum")) {
@@ -145,7 +146,8 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "value_type", "minimum", "maximum",
 				 "default_value");
 	} else if (!strcmp(attr, "default_value")) {
-	    return PyString_FromFormat("%c", G_PARAM_SPEC_UCHAR(pspec)->default_value);
+	    return PyString_FromFormat(
+		"%c", G_PARAM_SPEC_UCHAR(pspec)->default_value);
 	} else if (!strcmp(attr, "minimum")) {
 	    return PyInt_FromLong(G_PARAM_SPEC_UCHAR(pspec)->minimum);
 	} else if (!strcmp(attr, "maximum")) {
@@ -251,7 +253,8 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "flags", "name", "nick", "owner_type",
 				 "value_type", "default_value");
 	} else if (!strcmp(attr, "default_value")) {
-	    return PyString_FromFormat("%c", G_PARAM_SPEC_UNICHAR(pspec)->default_value);
+	    return PyString_FromFormat(
+		"%c", G_PARAM_SPEC_UNICHAR(pspec)->default_value);
 	}
     } else if (G_IS_PARAM_SPEC_ENUM(pspec)) {
 	if (!strcmp(attr, "__members__")) {
@@ -260,7 +263,8 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "flags", "name", "nick", "owner_type",
 				 "value_type", "enum_class");
 	} else if (!strcmp(attr, "default_value")) {
-	    return PyInt_FromLong(G_PARAM_SPEC_ENUM(pspec)->default_value);
+	    return pyg_enum_from_gtype(
+		pspec->value_type, G_PARAM_SPEC_ENUM(pspec)->default_value);
 	} else if (!strcmp(attr, "enum_class")) {
 	    return pygenum_from_pspec(pspec);
 	}
@@ -271,7 +275,8 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "flags", "name", "nick", "owner_type",
 				 "value_type", "flags_class");
 	} else if (!strcmp(attr, "default_value")) {
-	    return PyInt_FromLong(G_PARAM_SPEC_FLAGS(pspec)->default_value);
+	    return pyg_flags_from_gtype(
+		pspec->value_type, G_PARAM_SPEC_FLAGS(pspec)->default_value);
 	} else if (!strcmp(attr, "flags_class")) {
 	    return pygflags_from_pspec(pspec);
 	}
@@ -299,7 +304,8 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "minimum", "maximum",
 				 "default_value", "epsilon");
 	} else if (!strcmp(attr, "default_value")) {
-	    return PyFloat_FromDouble(G_PARAM_SPEC_DOUBLE(pspec)->default_value);
+	    return PyFloat_FromDouble(
+		G_PARAM_SPEC_DOUBLE(pspec)->default_value);
 	} else if (!strcmp(attr, "minimum")) {
 	    return PyFloat_FromDouble(G_PARAM_SPEC_DOUBLE(pspec)->minimum);
 	} else if (!strcmp(attr, "maximum")) {
@@ -315,17 +321,23 @@ pyg_param_spec_getattr(PyGParamSpec *self, const gchar *attr)
 				 "cset_nth", "substitutor",
 				 "null_fold_if_empty", "ensure_non_null");
 	} else if (!strcmp(attr, "default_value")) {
-	    return Py_BuildValue("s", G_PARAM_SPEC_STRING(pspec)->default_value);
+	    return Py_BuildValue(
+		"s", G_PARAM_SPEC_STRING(pspec)->default_value);
 	} else if (!strcmp(attr, "cset_first")) {
-	    return Py_BuildValue("s", G_PARAM_SPEC_STRING(pspec)->cset_first);
+	    return Py_BuildValue(
+		"s", G_PARAM_SPEC_STRING(pspec)->cset_first);
 	} else if (!strcmp(attr, "cset_nth")) {
-	    return Py_BuildValue("s", G_PARAM_SPEC_STRING(pspec)->cset_nth);
+	    return Py_BuildValue(
+		"s", G_PARAM_SPEC_STRING(pspec)->cset_nth);
 	} else if (!strcmp(attr, "substitutor")) {
-	    return Py_BuildValue("c", G_PARAM_SPEC_STRING(pspec)->substitutor);
+	    return Py_BuildValue(
+		"c", G_PARAM_SPEC_STRING(pspec)->substitutor);
 	} else if (!strcmp(attr, "null_fold_if_empty")) {
-	    return PyBool_FromLong(G_PARAM_SPEC_STRING(pspec)->null_fold_if_empty);
+	    return PyBool_FromLong(
+		G_PARAM_SPEC_STRING(pspec)->null_fold_if_empty);
 	} else if (!strcmp(attr, "ensure_non_null")) {
-	    return PyBool_FromLong(G_PARAM_SPEC_STRING(pspec)->ensure_non_null);
+	    return PyBool_FromLong(
+		G_PARAM_SPEC_STRING(pspec)->ensure_non_null);
 	}
     } else {
 	if (!strcmp(attr, "__members__")) {
diff --git a/tests/test_enum.py b/tests/test_enum.py
index 45bc0dc..508ad16 100644
--- a/tests/test_enum.py
+++ b/tests/test_enum.py
@@ -1,25 +1,37 @@
 import unittest
 import warnings
 
-from gobject import GEnum, GFlags, GObject, GType
+from gobject import GEnum, GFlags, GObject, GType, PARAM_READWRITE
 from common import gobject, atk, pango, gtk, gdk
 
+class PObject(GObject):
+    __gproperties__ = {
+        'enum': (gtk.WindowType, 'blurb', 'description',
+                 gtk.WINDOW_TOPLEVEL, PARAM_READWRITE),
+        'enum2': (gtk.WindowType, 'blurb', 'description',
+                  int(gtk.WINDOW_TOPLEVEL), PARAM_READWRITE),
+        'flags': (gtk.AttachOptions, 'blurb', 'description',
+                  gtk.EXPAND, PARAM_READWRITE),
+        'flags2': (gtk.AttachOptions, 'blurb', 'description',
+                   int(gtk.EXPAND), PARAM_READWRITE),
+    }
+
 class EnumTest(unittest.TestCase):
     def testEnums(self):
-        assert issubclass(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
+        self.failUnless(issubclass(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:
-            assert atk.LAYER_INVALID != atk.RELATION_NULL
+            self.assertNotEquals(atk.LAYER_INVALID, atk.RELATION_NULL)
         except Warning:
             pass
         else:
@@ -31,72 +43,81 @@ class EnumTest(unittest.TestCase):
         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)
+        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')
-        assert wtype == gtk.WINDOW_TOPLEVEL
-        assert isinstance(wtype, gtk.WindowType)
-        assert 'WINDOW_TOPLEVEL' in repr(wtype)
+        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())
-        assert obj.get_role() == atk.ROLE_INVALID
+        self.assertEquals(obj.get_role(), atk.ROLE_INVALID)
 
     def testGParam(self):
         win = gtk.Window()
         enums = filter(lambda x: GType.is_a(x.value_type, GEnum),
                        gobject.list_properties(win))
-        assert enums
+        self.failUnless(enums)
         enum = enums[0]
-        assert hasattr(enum, 'enum_class')
-        assert issubclass(enum.enum_class, GEnum)
+        self.failUnless(hasattr(enum, 'enum_class'))
+        self.failUnless(issubclass(enum.enum_class, GEnum))
 
     def testWeirdEnumValues(self):
-        assert int(gdk.NOTHING) == -1
-        assert int(gdk.BUTTON_PRESS) == 4
+        self.assertEquals(int(gdk.NOTHING), -1)
+        self.assertEquals(int(gdk.BUTTON_PRESS), 4)
 
     def testParamSpec(self):
         props = filter(lambda prop: GType.is_a(prop.value_type, GEnum),
                        gobject.list_properties(gtk.Window))
-        assert len(props)>= 6
+        self.failUnless(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
+        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)
-        assert isinstance(val, gobject.GEnum)
-        assert int(val) == 7
-        assert '7' in repr(val)
-        assert 'GtkIconSize' in repr(val)
+        self.failUnless(isinstance(val, 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)
 
 class FlagsTest(unittest.TestCase):
     def testFlags(self):
-        assert issubclass(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
+        self.failUnless(issubclass(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)
 
-        assert gdk.EventMask.__bases__[0] == GFlags
-        assert len(gdk.EventMask.__flags_values__) == 22
+        self.assertEquals(gdk.EventMask.__bases__[0], GFlags)
+        self.assertEquals(len(gdk.EventMask.__flags_values__), 22)
 
     def testComparisionWarning(self):
         warnings.filterwarnings("error", "", Warning, "", 0)
         try:
-            assert gtk.ACCEL_VISIBLE != gtk.EXPAND
+            self.assertNotEquals(gtk.ACCEL_VISIBLE, gtk.EXPAND)
         except Warning:
             pass
         else:
@@ -105,35 +126,45 @@ class FlagsTest(unittest.TestCase):
         
     def testFlagOperations(self):
         a = gdk.BUTTON_PRESS_MASK
-        assert isinstance(a, 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
+        self.failUnless(isinstance(a, 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
-        assert isinstance(b, 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, 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))
-
+        self.failUnless(isinstance(b, 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, 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:
@@ -147,42 +178,52 @@ class FlagsTest(unittest.TestCase):
     def testParamSpec(self):
         props = filter(lambda x: GType.is_a(x.value_type, 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
-
+        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
-        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
+        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
-        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
+        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()