[pygobject] tests: Don't use deprecated override attributes
- From: Christoph Reiter <creiter src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [pygobject] tests: Don't use deprecated override attributes
- Date: Tue, 3 Mar 2015 12:22:42 +0000 (UTC)
commit 9948a67e677c8a351f2de17080d7a671882570f3
Author: Christoph Reiter <reiter christoph gmail com>
Date: Tue Jan 27 17:47:49 2015 +0100
tests: Don't use deprecated override attributes
In case the test explicitly tests the deprecated attribute
silence the resulting warnings.
Instead of replacing GObject.PARAM_READWRITE with
GObject.ParamFlags.READWRITE use (READABLE | WRITABLE)
to not depend on a newer glib version.
https://bugzilla.gnome.org/show_bug.cgi?id=743514
tests/test_everything.py | 168 +++++++++++++++++++++---------------------
tests/test_gi.py | 66 +++++++++--------
tests/test_glib.py | 33 ++++++---
tests/test_gobject.py | 21 +++---
tests/test_internal_api.py | 4 +-
tests/test_iochannel.py | 11 ++-
tests/test_overrides_gtk.py | 20 +++---
tests/test_properties.py | 100 ++++++++++++++------------
tests/test_signal.py | 111 ++++++++++++++--------------
tests/test_source.py | 8 +-
tests/test_subprocess.py | 7 ++-
tests/testmodule.py | 3 +-
12 files changed, 292 insertions(+), 260 deletions(-)
---
diff --git a/tests/test_everything.py b/tests/test_everything.py
index b8a37f1..5be9ce4 100644
--- a/tests/test_everything.py
+++ b/tests/test_everything.py
@@ -63,112 +63,112 @@ class TestEverything(unittest.TestCase):
self.assertEqual(Everything.test_boolean_false(False), False)
def test_int8(self):
- self.assertEqual(Everything.test_int8(GObject.G_MAXINT8),
- GObject.G_MAXINT8)
- self.assertEqual(Everything.test_int8(GObject.G_MININT8),
- GObject.G_MININT8)
- self.assertRaises(OverflowError, Everything.test_int8, GObject.G_MAXINT8 + 1)
-
- self.assertEqual(Everything.test_uint8(GObject.G_MAXUINT8),
- GObject.G_MAXUINT8)
+ self.assertEqual(Everything.test_int8(GLib.MAXINT8),
+ GLib.MAXINT8)
+ self.assertEqual(Everything.test_int8(GLib.MININT8),
+ GLib.MININT8)
+ self.assertRaises(OverflowError, Everything.test_int8, GLib.MAXINT8 + 1)
+
+ self.assertEqual(Everything.test_uint8(GLib.MAXUINT8),
+ GLib.MAXUINT8)
self.assertEqual(Everything.test_uint8(0), 0)
self.assertRaises(OverflowError, Everything.test_uint8, -1)
- self.assertRaises(OverflowError, Everything.test_uint8, GObject.G_MAXUINT8 + 1)
+ self.assertRaises(OverflowError, Everything.test_uint8, GLib.MAXUINT8 + 1)
def test_int16(self):
- self.assertEqual(Everything.test_int16(GObject.G_MAXINT16),
- GObject.G_MAXINT16)
- self.assertEqual(Everything.test_int16(GObject.G_MININT16),
- GObject.G_MININT16)
- self.assertRaises(OverflowError, Everything.test_int16, GObject.G_MAXINT16 + 1)
-
- self.assertEqual(Everything.test_uint16(GObject.G_MAXUINT16),
- GObject.G_MAXUINT16)
+ self.assertEqual(Everything.test_int16(GLib.MAXINT16),
+ GLib.MAXINT16)
+ self.assertEqual(Everything.test_int16(GLib.MININT16),
+ GLib.MININT16)
+ self.assertRaises(OverflowError, Everything.test_int16, GLib.MAXINT16 + 1)
+
+ self.assertEqual(Everything.test_uint16(GLib.MAXUINT16),
+ GLib.MAXUINT16)
self.assertEqual(Everything.test_uint16(0), 0)
self.assertRaises(OverflowError, Everything.test_uint16, -1)
- self.assertRaises(OverflowError, Everything.test_uint16, GObject.G_MAXUINT16 + 1)
+ self.assertRaises(OverflowError, Everything.test_uint16, GLib.MAXUINT16 + 1)
def test_int32(self):
- self.assertEqual(Everything.test_int32(GObject.G_MAXINT32),
- GObject.G_MAXINT32)
- self.assertEqual(Everything.test_int32(GObject.G_MININT32),
- GObject.G_MININT32)
- self.assertRaises(OverflowError, Everything.test_int32, GObject.G_MAXINT32 + 1)
-
- self.assertEqual(Everything.test_uint32(GObject.G_MAXUINT32),
- GObject.G_MAXUINT32)
+ self.assertEqual(Everything.test_int32(GLib.MAXINT32),
+ GLib.MAXINT32)
+ self.assertEqual(Everything.test_int32(GLib.MININT32),
+ GLib.MININT32)
+ self.assertRaises(OverflowError, Everything.test_int32, GLib.MAXINT32 + 1)
+
+ self.assertEqual(Everything.test_uint32(GLib.MAXUINT32),
+ GLib.MAXUINT32)
self.assertEqual(Everything.test_uint32(0), 0)
self.assertRaises(OverflowError, Everything.test_uint32, -1)
- self.assertRaises(OverflowError, Everything.test_uint32, GObject.G_MAXUINT32 + 1)
+ self.assertRaises(OverflowError, Everything.test_uint32, GLib.MAXUINT32 + 1)
def test_int64(self):
- self.assertEqual(Everything.test_int64(GObject.G_MAXINT64),
- GObject.G_MAXINT64)
- self.assertEqual(Everything.test_int64(GObject.G_MININT64),
- GObject.G_MININT64)
- self.assertRaises(OverflowError, Everything.test_int64, GObject.G_MAXINT64 + 1)
-
- self.assertEqual(Everything.test_uint64(GObject.G_MAXUINT64),
- GObject.G_MAXUINT64)
+ self.assertEqual(Everything.test_int64(GLib.MAXINT64),
+ GLib.MAXINT64)
+ self.assertEqual(Everything.test_int64(GLib.MININT64),
+ GLib.MININT64)
+ self.assertRaises(OverflowError, Everything.test_int64, GLib.MAXINT64 + 1)
+
+ self.assertEqual(Everything.test_uint64(GLib.MAXUINT64),
+ GLib.MAXUINT64)
self.assertEqual(Everything.test_uint64(0), 0)
self.assertRaises(OverflowError, Everything.test_uint64, -1)
- self.assertRaises(OverflowError, Everything.test_uint64, GObject.G_MAXUINT64 + 1)
+ self.assertRaises(OverflowError, Everything.test_uint64, GLib.MAXUINT64 + 1)
def test_int(self):
- self.assertEqual(Everything.test_int(GObject.G_MAXINT),
- GObject.G_MAXINT)
- self.assertEqual(Everything.test_int(GObject.G_MININT),
- GObject.G_MININT)
- self.assertRaises(OverflowError, Everything.test_int, GObject.G_MAXINT + 1)
-
- self.assertEqual(Everything.test_uint(GObject.G_MAXUINT),
- GObject.G_MAXUINT)
+ self.assertEqual(Everything.test_int(GLib.MAXINT),
+ GLib.MAXINT)
+ self.assertEqual(Everything.test_int(GLib.MININT),
+ GLib.MININT)
+ self.assertRaises(OverflowError, Everything.test_int, GLib.MAXINT + 1)
+
+ self.assertEqual(Everything.test_uint(GLib.MAXUINT),
+ GLib.MAXUINT)
self.assertEqual(Everything.test_uint(0), 0)
self.assertRaises(OverflowError, Everything.test_uint, -1)
- self.assertRaises(OverflowError, Everything.test_uint, GObject.G_MAXUINT + 1)
+ self.assertRaises(OverflowError, Everything.test_uint, GLib.MAXUINT + 1)
def test_short(self):
- self.assertEqual(Everything.test_short(GObject.G_MAXSHORT),
- GObject.G_MAXSHORT)
- self.assertEqual(Everything.test_short(GObject.G_MINSHORT),
- GObject.G_MINSHORT)
- self.assertRaises(OverflowError, Everything.test_short, GObject.G_MAXSHORT + 1)
-
- self.assertEqual(Everything.test_ushort(GObject.G_MAXUSHORT),
- GObject.G_MAXUSHORT)
+ self.assertEqual(Everything.test_short(GLib.MAXSHORT),
+ GLib.MAXSHORT)
+ self.assertEqual(Everything.test_short(GLib.MINSHORT),
+ GLib.MINSHORT)
+ self.assertRaises(OverflowError, Everything.test_short, GLib.MAXSHORT + 1)
+
+ self.assertEqual(Everything.test_ushort(GLib.MAXUSHORT),
+ GLib.MAXUSHORT)
self.assertEqual(Everything.test_ushort(0), 0)
self.assertRaises(OverflowError, Everything.test_ushort, -1)
- self.assertRaises(OverflowError, Everything.test_ushort, GObject.G_MAXUSHORT + 1)
+ self.assertRaises(OverflowError, Everything.test_ushort, GLib.MAXUSHORT + 1)
def test_long(self):
- self.assertEqual(Everything.test_long(GObject.G_MAXLONG),
- GObject.G_MAXLONG)
- self.assertEqual(Everything.test_long(GObject.G_MINLONG),
- GObject.G_MINLONG)
- self.assertRaises(OverflowError, Everything.test_long, GObject.G_MAXLONG + 1)
-
- self.assertEqual(Everything.test_ulong(GObject.G_MAXULONG),
- GObject.G_MAXULONG)
+ self.assertEqual(Everything.test_long(GLib.MAXLONG),
+ GLib.MAXLONG)
+ self.assertEqual(Everything.test_long(GLib.MINLONG),
+ GLib.MINLONG)
+ self.assertRaises(OverflowError, Everything.test_long, GLib.MAXLONG + 1)
+
+ self.assertEqual(Everything.test_ulong(GLib.MAXULONG),
+ GLib.MAXULONG)
self.assertEqual(Everything.test_ulong(0), 0)
self.assertRaises(OverflowError, Everything.test_ulong, -1)
- self.assertRaises(OverflowError, Everything.test_ulong, GObject.G_MAXULONG + 1)
+ self.assertRaises(OverflowError, Everything.test_ulong, GLib.MAXULONG + 1)
def test_size(self):
- self.assertEqual(Everything.test_ssize(GObject.G_MAXSSIZE),
- GObject.G_MAXSSIZE)
- self.assertEqual(Everything.test_ssize(GObject.G_MINSSIZE),
- GObject.G_MINSSIZE)
- self.assertRaises(OverflowError, Everything.test_ssize, GObject.G_MAXSSIZE + 1)
-
- self.assertEqual(Everything.test_size(GObject.G_MAXSIZE),
- GObject.G_MAXSIZE)
+ self.assertEqual(Everything.test_ssize(GLib.MAXSSIZE),
+ GLib.MAXSSIZE)
+ self.assertEqual(Everything.test_ssize(GLib.MINSSIZE),
+ GLib.MINSSIZE)
+ self.assertRaises(OverflowError, Everything.test_ssize, GLib.MAXSSIZE + 1)
+
+ self.assertEqual(Everything.test_size(GLib.MAXSIZE),
+ GLib.MAXSIZE)
self.assertEqual(Everything.test_size(0), 0)
self.assertRaises(OverflowError, Everything.test_size, -1)
- self.assertRaises(OverflowError, Everything.test_size, GObject.G_MAXSIZE + 1)
+ self.assertRaises(OverflowError, Everything.test_size, GLib.MAXSIZE + 1)
def test_timet(self):
self.assertEqual(Everything.test_timet(42), 42)
- self.assertRaises(OverflowError, Everything.test_timet, GObject.G_MAXUINT64 + 1)
+ self.assertRaises(OverflowError, Everything.test_timet, GLib.MAXUINT64 + 1)
def test_unichar(self):
self.assertEqual("c", Everything.test_unichar("c"))
@@ -180,25 +180,25 @@ class TestEverything(unittest.TestCase):
self.assertRaises(TypeError, Everything.test_unichar, "morethanonechar")
def test_float(self):
- self.assertEqual(Everything.test_float(GObject.G_MAXFLOAT),
- GObject.G_MAXFLOAT)
- self.assertEqual(Everything.test_float(GObject.G_MINFLOAT),
- GObject.G_MINFLOAT)
- self.assertRaises(OverflowError, Everything.test_float, GObject.G_MAXFLOAT * 2)
+ self.assertEqual(Everything.test_float(GLib.MAXFLOAT),
+ GLib.MAXFLOAT)
+ self.assertEqual(Everything.test_float(GLib.MINFLOAT),
+ GLib.MINFLOAT)
+ self.assertRaises(OverflowError, Everything.test_float, GLib.MAXFLOAT * 2)
def test_double(self):
- self.assertEqual(Everything.test_double(GObject.G_MAXDOUBLE),
- GObject.G_MAXDOUBLE)
- self.assertEqual(Everything.test_double(GObject.G_MINDOUBLE),
- GObject.G_MINDOUBLE)
+ self.assertEqual(Everything.test_double(GLib.MAXDOUBLE),
+ GLib.MAXDOUBLE)
+ self.assertEqual(Everything.test_double(GLib.MINDOUBLE),
+ GLib.MINDOUBLE)
(two, three) = Everything.test_multi_double_args(2.5)
self.assertAlmostEqual(two, 5.0)
self.assertAlmostEqual(three, 7.5)
def test_value(self):
- self.assertEqual(Everything.test_int_value_arg(GObject.G_MAXINT), GObject.G_MAXINT)
- self.assertEqual(Everything.test_value_return(GObject.G_MAXINT), GObject.G_MAXINT)
+ self.assertEqual(Everything.test_int_value_arg(GLib.MAXINT), GLib.MAXINT)
+ self.assertEqual(Everything.test_value_return(GLib.MAXINT), GLib.MAXINT)
def test_variant(self):
v = Everything.test_gvariant_i()
diff --git a/tests/test_gi.py b/tests/test_gi.py
index a803529..22a5738 100644
--- a/tests/test_gi.py
+++ b/tests/test_gi.py
@@ -101,8 +101,8 @@ class TestBoolean(unittest.TestCase):
class TestInt8(unittest.TestCase):
- MAX = GObject.G_MAXINT8
- MIN = GObject.G_MININT8
+ MAX = GLib.MAXINT8
+ MIN = GLib.MININT8
def test_int8_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.int8_return_max())
@@ -134,7 +134,7 @@ class TestInt8(unittest.TestCase):
class TestUInt8(unittest.TestCase):
- MAX = GObject.G_MAXUINT8
+ MAX = GLib.MAXUINT8
def test_uint8_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.uint8_return())
@@ -160,8 +160,8 @@ class TestUInt8(unittest.TestCase):
class TestInt16(unittest.TestCase):
- MAX = GObject.G_MAXINT16
- MIN = GObject.G_MININT16
+ MAX = GLib.MAXINT16
+ MIN = GLib.MININT16
def test_int16_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.int16_return_max())
@@ -193,7 +193,7 @@ class TestInt16(unittest.TestCase):
class TestUInt16(unittest.TestCase):
- MAX = GObject.G_MAXUINT16
+ MAX = GLib.MAXUINT16
def test_uint16_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.uint16_return())
@@ -219,8 +219,8 @@ class TestUInt16(unittest.TestCase):
class TestInt32(unittest.TestCase):
- MAX = GObject.G_MAXINT32
- MIN = GObject.G_MININT32
+ MAX = GLib.MAXINT32
+ MIN = GLib.MININT32
def test_int32_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.int32_return_max())
@@ -252,7 +252,7 @@ class TestInt32(unittest.TestCase):
class TestUInt32(unittest.TestCase):
- MAX = GObject.G_MAXUINT32
+ MAX = GLib.MAXUINT32
def test_uint32_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.uint32_return())
@@ -337,8 +337,8 @@ class TestUInt64(unittest.TestCase):
class TestShort(unittest.TestCase):
- MAX = GObject.G_MAXSHORT
- MIN = GObject.G_MINSHORT
+ MAX = GLib.MAXSHORT
+ MIN = GLib.MINSHORT
def test_short_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.short_return_max())
@@ -370,7 +370,7 @@ class TestShort(unittest.TestCase):
class TestUShort(unittest.TestCase):
- MAX = GObject.G_MAXUSHORT
+ MAX = GLib.MAXUSHORT
def test_ushort_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.ushort_return())
@@ -396,8 +396,8 @@ class TestUShort(unittest.TestCase):
class TestInt(unittest.TestCase):
- MAX = GObject.G_MAXINT
- MIN = GObject.G_MININT
+ MAX = GLib.MAXINT
+ MIN = GLib.MININT
def test_int_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.int_return_max())
@@ -430,7 +430,7 @@ class TestInt(unittest.TestCase):
class TestUInt(unittest.TestCase):
- MAX = GObject.G_MAXUINT
+ MAX = GLib.MAXUINT
def test_uint_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.uint_return())
@@ -456,8 +456,8 @@ class TestUInt(unittest.TestCase):
class TestLong(unittest.TestCase):
- MAX = GObject.G_MAXLONG
- MIN = GObject.G_MINLONG
+ MAX = GLib.MAXLONG
+ MIN = GLib.MINLONG
def test_long_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.long_return_max())
@@ -489,7 +489,7 @@ class TestLong(unittest.TestCase):
class TestULong(unittest.TestCase):
- MAX = GObject.G_MAXULONG
+ MAX = GLib.MAXULONG
def test_ulong_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.ulong_return())
@@ -515,8 +515,8 @@ class TestULong(unittest.TestCase):
class TestSSize(unittest.TestCase):
- MAX = GObject.G_MAXLONG
- MIN = GObject.G_MINLONG
+ MAX = GLib.MAXLONG
+ MIN = GLib.MINLONG
def test_ssize_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.ssize_return_max())
@@ -548,7 +548,7 @@ class TestSSize(unittest.TestCase):
class TestSize(unittest.TestCase):
- MAX = GObject.G_MAXULONG
+ MAX = GLib.MAXULONG
def test_size_return(self):
self.assertEqual(self.MAX, GIMarshallingTests.size_return())
@@ -590,8 +590,8 @@ class TestTimet(unittest.TestCase):
class TestFloat(unittest.TestCase):
- MAX = GObject.G_MAXFLOAT
- MIN = GObject.G_MINFLOAT
+ MAX = GLib.MAXFLOAT
+ MIN = GLib.MINFLOAT
def test_float_return(self):
self.assertAlmostEqual(self.MAX, GIMarshallingTests.float_return())
@@ -610,8 +610,8 @@ class TestFloat(unittest.TestCase):
class TestDouble(unittest.TestCase):
- MAX = GObject.G_MAXDOUBLE
- MIN = GObject.G_MINDOUBLE
+ MAX = GLib.MAXDOUBLE
+ MIN = GLib.MINDOUBLE
def test_double_return(self):
self.assertAlmostEqual(self.MAX, GIMarshallingTests.double_return())
@@ -962,7 +962,7 @@ class TestGArray(unittest.TestCase):
self.assertEqual([-1, 0, 1, 2], GIMarshallingTests.garray_int_none_return())
def test_garray_uint64_none_return(self):
- self.assertEqual([0, GObject.G_MAXUINT64], GIMarshallingTests.garray_uint64_none_return())
+ self.assertEqual([0, GLib.MAXUINT64], GIMarshallingTests.garray_uint64_none_return())
def test_garray_utf8_none_return(self):
self.assertEqual(['0', '1', '2'], GIMarshallingTests.garray_utf8_none_return())
@@ -982,7 +982,7 @@ class TestGArray(unittest.TestCase):
self.assertRaises(TypeError, GIMarshallingTests.garray_int_none_in, None)
def test_garray_uint64_none_in(self):
- GIMarshallingTests.garray_uint64_none_in(Sequence([0, GObject.G_MAXUINT64]))
+ GIMarshallingTests.garray_uint64_none_in(Sequence([0, GLib.MAXUINT64]))
def test_garray_utf8_none_in(self):
GIMarshallingTests.garray_utf8_none_in(Sequence(['0', '1', '2']))
@@ -1109,7 +1109,7 @@ class TestGList(unittest.TestCase):
self.assertEqual([-1, 0, 1, 2], GIMarshallingTests.glist_int_none_return())
def test_glist_uint32_none_return(self):
- self.assertEqual([0, GObject.G_MAXUINT32], GIMarshallingTests.glist_uint32_none_return())
+ self.assertEqual([0, GLib.MAXUINT32], GIMarshallingTests.glist_uint32_none_return())
def test_glist_utf8_none_return(self):
self.assertEqual(['0', '1', '2'], GIMarshallingTests.glist_utf8_none_return())
@@ -1137,7 +1137,7 @@ class TestGList(unittest.TestCase):
self.assertRaises(Exception, GIMarshallingTests.glist_int_none_in, FailingSequence((-1, 0, 1, 2)))
def test_glist_uint32_none_in(self):
- GIMarshallingTests.glist_uint32_none_in(Sequence((0, GObject.G_MAXUINT32)))
+ GIMarshallingTests.glist_uint32_none_in(Sequence((0, GLib.MAXUINT32)))
def test_glist_utf8_none_in(self):
GIMarshallingTests.glist_utf8_none_in(Sequence(('0', '1', '2')))
@@ -1280,7 +1280,7 @@ class TestGValue(unittest.TestCase):
self.assertEqual(value.get_int(), 24)
def test_gvalue_int64_in(self):
- value = GObject.Value(GObject.TYPE_INT64, GObject.G_MAXINT64)
+ value = GObject.Value(GObject.TYPE_INT64, GLib.MAXINT64)
GIMarshallingTests.gvalue_int64_in(value)
def test_gvalue_in_with_type(self):
@@ -1300,7 +1300,7 @@ class TestGValue(unittest.TestCase):
self.assertEqual(42, GIMarshallingTests.gvalue_out())
def test_gvalue_int64_out(self):
- self.assertEqual(GObject.G_MAXINT64, GIMarshallingTests.gvalue_int64_out())
+ self.assertEqual(GLib.MAXINT64, GIMarshallingTests.gvalue_int64_out())
def test_gvalue_out_caller_allocates(self):
self.assertEqual(42, GIMarshallingTests.gvalue_out_caller_allocates())
@@ -2798,7 +2798,9 @@ class TestDeprecation(unittest.TestCase):
# the descriptor raises AttributeError for itself
self.assertFalse(hasattr(type(GLib), "IO_STATUS_ERROR"))
- self.assertTrue(hasattr(GLib, "IO_STATUS_ERROR"))
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
+ self.assertTrue(hasattr(GLib, "IO_STATUS_ERROR"))
try:
# check if replacing works
diff --git a/tests/test_glib.py b/tests/test_glib.py
index 17ac2de..5ede849 100644
--- a/tests/test_glib.py
+++ b/tests/test_glib.py
@@ -38,11 +38,14 @@ class TestGLib(unittest.TestCase):
def test_xdg_dirs(self):
d = GLib.get_user_data_dir()
self.assertTrue('/' in d, d)
- d = GLib.get_user_special_dir(GLib.USER_DIRECTORY_DESKTOP)
+ d = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_MUSIC)
self.assertTrue('/' in d, d)
- # also works with backwards compatible enum names
- self.assertEqual(GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_MUSIC),
- GLib.get_user_special_dir(GLib.USER_DIRECTORY_MUSIC))
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
+
+ # also works with backwards compatible enum names
+ self.assertEqual(GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_MUSIC),
+ GLib.get_user_special_dir(GLib.USER_DIRECTORY_MUSIC))
for d in GLib.get_system_config_dirs():
self.assertTrue('/' in d, d)
@@ -215,16 +218,22 @@ https://my.org/q?x=1&y=2
(cmd.stdout, GLib.IOCondition.IN, b'world\n')])
def test_glib_version(self):
- (major, minor, micro) = GLib.glib_version
- self.assertGreaterEqual(major, 2)
- self.assertGreaterEqual(minor, 0)
- self.assertGreaterEqual(micro, 0)
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
+
+ (major, minor, micro) = GLib.glib_version
+ self.assertGreaterEqual(major, 2)
+ self.assertGreaterEqual(minor, 0)
+ self.assertGreaterEqual(micro, 0)
def test_pyglib_version(self):
- (major, minor, micro) = GLib.pyglib_version
- self.assertGreaterEqual(major, 3)
- self.assertGreaterEqual(minor, 0)
- self.assertGreaterEqual(micro, 0)
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
+
+ (major, minor, micro) = GLib.pyglib_version
+ self.assertGreaterEqual(major, 3)
+ self.assertGreaterEqual(minor, 0)
+ self.assertGreaterEqual(micro, 0)
def test_timezone_constructor(self):
timezone = GLib.TimeZone("+05:21")
diff --git a/tests/test_gobject.py b/tests/test_gobject.py
index a88a4bc..6c15e20 100644
--- a/tests/test_gobject.py
+++ b/tests/test_gobject.py
@@ -60,17 +60,20 @@ class TestGObjectAPI(unittest.TestCase):
self.assertLess(GObject.PRIORITY_HIGH, GObject.PRIORITY_DEFAULT)
def test_min_max_int(self):
- self.assertEqual(GObject.G_MAXINT16, 2 ** 15 - 1)
- self.assertEqual(GObject.G_MININT16, -2 ** 15)
- self.assertEqual(GObject.G_MAXUINT16, 2 ** 16 - 1)
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
- self.assertEqual(GObject.G_MAXINT32, 2 ** 31 - 1)
- self.assertEqual(GObject.G_MININT32, -2 ** 31)
- self.assertEqual(GObject.G_MAXUINT32, 2 ** 32 - 1)
+ self.assertEqual(GObject.G_MAXINT16, 2 ** 15 - 1)
+ self.assertEqual(GObject.G_MININT16, -2 ** 15)
+ self.assertEqual(GObject.G_MAXUINT16, 2 ** 16 - 1)
- self.assertEqual(GObject.G_MAXINT64, 2 ** 63 - 1)
- self.assertEqual(GObject.G_MININT64, -2 ** 63)
- self.assertEqual(GObject.G_MAXUINT64, 2 ** 64 - 1)
+ self.assertEqual(GObject.G_MAXINT32, 2 ** 31 - 1)
+ self.assertEqual(GObject.G_MININT32, -2 ** 31)
+ self.assertEqual(GObject.G_MAXUINT32, 2 ** 32 - 1)
+
+ self.assertEqual(GObject.G_MAXINT64, 2 ** 63 - 1)
+ self.assertEqual(GObject.G_MININT64, -2 ** 63)
+ self.assertEqual(GObject.G_MAXUINT64, 2 ** 64 - 1)
class TestReferenceCounting(unittest.TestCase):
diff --git a/tests/test_internal_api.py b/tests/test_internal_api.py
index ca50f6b..eb66fdd 100644
--- a/tests/test_internal_api.py
+++ b/tests/test_internal_api.py
@@ -40,8 +40,8 @@ class TestGValueConversion(unittest.TestCase):
self.assertEqual(testhelper.test_value(0), 0)
self.assertEqual(testhelper.test_value(5), 5)
self.assertEqual(testhelper.test_value(-5), -5)
- self.assertEqual(testhelper.test_value(GObject.G_MAXINT32), GObject.G_MAXINT32)
- self.assertEqual(testhelper.test_value(GObject.G_MININT32), GObject.G_MININT32)
+ self.assertEqual(testhelper.test_value(GLib.MAXINT32), GLib.MAXINT32)
+ self.assertEqual(testhelper.test_value(GLib.MININT32), GLib.MININT32)
def test_str(self):
self.assertEqual(testhelper.test_value('hello'), 'hello')
diff --git a/tests/test_iochannel.py b/tests/test_iochannel.py
index 259171b..02277e1 100644
--- a/tests/test_iochannel.py
+++ b/tests/test_iochannel.py
@@ -415,10 +415,13 @@ second line
self.assertEqual(cb_reads, [b'a', b'b'])
def test_backwards_compat_flags(self):
- self.assertEqual(GLib.IOCondition.IN, GLib.IO_IN)
- self.assertEqual(GLib.IOFlags.NONBLOCK, GLib.IO_FLAG_NONBLOCK)
- self.assertEqual(GLib.IOFlags.IS_SEEKABLE, GLib.IO_FLAG_IS_SEEKABLE)
- self.assertEqual(GLib.IOStatus.NORMAL, GLib.IO_STATUS_NORMAL)
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
+
+ self.assertEqual(GLib.IOCondition.IN, GLib.IO_IN)
+ self.assertEqual(GLib.IOFlags.NONBLOCK, GLib.IO_FLAG_NONBLOCK)
+ self.assertEqual(GLib.IOFlags.IS_SEEKABLE, GLib.IO_FLAG_IS_SEEKABLE)
+ self.assertEqual(GLib.IOStatus.NORMAL, GLib.IO_STATUS_NORMAL)
if __name__ == '__main__':
unittest.main()
diff --git a/tests/test_overrides_gtk.py b/tests/test_overrides_gtk.py
index a57b7da..bd477bf 100644
--- a/tests/test_overrides_gtk.py
+++ b/tests/test_overrides_gtk.py
@@ -908,8 +908,8 @@ class TestTreeModel(unittest.TestCase):
i % 2,
bool(i % 2),
i,
- GObject.G_MAXULONG,
- GObject.G_MININT64,
+ GLib.MAXULONG,
+ GLib.MININT64,
0xffffffffffffffff,
254,
_bytes('a')
@@ -930,8 +930,8 @@ class TestTreeModel(unittest.TestCase):
7, i % 2,
8, bool(i % 2),
9, i,
- 10, GObject.G_MAXULONG,
- 11, GObject.G_MININT64,
+ 10, GLib.MAXULONG,
+ 11, GLib.MININT64,
12, 0xffffffffffffffff,
13, 254,
14, _bytes('a'))
@@ -950,8 +950,8 @@ class TestTreeModel(unittest.TestCase):
7: i % 2,
8: bool(i % 2),
9: i,
- 10: GObject.G_MAXULONG,
- 11: GObject.G_MININT64,
+ 10: GLib.MAXULONG,
+ 11: GLib.MININT64,
12: 0xffffffffffffffff,
13: 254,
14: _bytes('a')})
@@ -971,8 +971,8 @@ class TestTreeModel(unittest.TestCase):
i % 2,
bool(i % 2),
i,
- GObject.G_MAXULONG,
- GObject.G_MININT64,
+ GLib.MAXULONG,
+ GLib.MININT64,
0xffffffffffffffff,
254,
_bytes('a')))
@@ -1011,9 +1011,9 @@ class TestTreeModel(unittest.TestCase):
uint_ = tree_store.get_value(treeiter, 9)
self.assertEqual(uint_, i)
ulong_ = tree_store.get_value(treeiter, 10)
- self.assertEqual(ulong_, GObject.G_MAXULONG)
+ self.assertEqual(ulong_, GLib.MAXULONG)
int64_ = tree_store.get_value(treeiter, 11)
- self.assertEqual(int64_, GObject.G_MININT64)
+ self.assertEqual(int64_, GLib.MININT64)
uint64_ = tree_store.get_value(treeiter, 12)
self.assertEqual(uint64_, 0xffffffffffffffff)
uchar_ = tree_store.get_value(treeiter, 13)
diff --git a/tests/test_properties.py b/tests/test_properties.py
index a147aae..6010bc2 100644
--- a/tests/test_properties.py
+++ b/tests/test_properties.py
@@ -8,8 +8,7 @@ import unittest
import gi
from gi.repository import GObject
-from gi.repository.GObject import GType, new, PARAM_READWRITE, \
- PARAM_CONSTRUCT, PARAM_READABLE, PARAM_WRITABLE, PARAM_CONSTRUCT_ONLY
+from gi.repository.GObject import ParamFlags, GType, new
from gi.repository.GObject import \
TYPE_INT, TYPE_UINT, TYPE_LONG, TYPE_ULONG, TYPE_INT64, \
TYPE_UINT64, TYPE_GTYPE, TYPE_INVALID, TYPE_NONE, TYPE_STRV, \
@@ -17,9 +16,9 @@ from gi.repository.GObject import \
TYPE_DOUBLE, TYPE_POINTER, TYPE_BOXED, TYPE_PARAM, TYPE_OBJECT, \
TYPE_STRING, TYPE_PYOBJECT, TYPE_VARIANT
-from gi.repository.GObject import \
- G_MININT, G_MAXINT, G_MAXUINT, G_MINLONG, G_MAXLONG, G_MAXULONG, \
- G_MAXUINT64, G_MAXINT64, G_MININT64
+from gi.repository.GLib import \
+ MININT, MAXINT, MAXUINT, MINLONG, MAXLONG, MAXULONG, \
+ MAXUINT64, MAXINT64, MININT64
from gi.repository import Gio
from gi.repository import GLib
@@ -48,38 +47,49 @@ class PropertyObject(GObject.GObject):
normal = GObject.Property(type=str)
construct = GObject.Property(
type=str,
- flags=PARAM_READWRITE | PARAM_CONSTRUCT, default='default')
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT,
+ default='default')
+
construct_only = GObject.Property(
type=str,
- flags=PARAM_READWRITE | PARAM_CONSTRUCT_ONLY)
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT_ONLY)
+
uint64 = GObject.Property(
- type=TYPE_UINT64, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
+ type=TYPE_UINT64,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT)
enum = GObject.Property(
type=Gio.SocketType, default=Gio.SocketType.STREAM)
boxed = GObject.Property(
- type=GLib.Regex, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
+ type=GLib.Regex,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT)
flags = GObject.Property(
- type=GIMarshallingTests.Flags, flags=PARAM_READWRITE | PARAM_CONSTRUCT,
+ type=GIMarshallingTests.Flags,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT,
default=GIMarshallingTests.Flags.VALUE1)
gtype = GObject.Property(
- type=TYPE_GTYPE, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
+ type=TYPE_GTYPE,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT)
strings = GObject.Property(
- type=TYPE_STRV, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
+ type=TYPE_STRV,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT)
variant = GObject.Property(
- type=TYPE_VARIANT, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
+ type=TYPE_VARIANT,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT)
variant_def = GObject.Property(
- type=TYPE_VARIANT, flags=PARAM_READWRITE | PARAM_CONSTRUCT,
+ type=TYPE_VARIANT,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT,
default=GLib.Variant('i', 42))
interface = GObject.Property(
- type=Gio.File, flags=PARAM_READWRITE | PARAM_CONSTRUCT)
+ type=Gio.File,
+ flags=ParamFlags.READABLE | ParamFlags.WRITABLE | ParamFlags.CONSTRUCT)
if has_regress:
@@ -210,7 +220,7 @@ class TestPropertyObject(unittest.TestCase):
__gproperties__ = {
'time': (TYPE_UINT64, 'Time', 'Time',
_long(0), (1 << 64) - 1, _long(0),
- PARAM_READABLE)
+ ParamFlags.READABLE)
}
except OverflowError:
(etype, ex) = sys.exc_info()[2:]
@@ -443,7 +453,7 @@ class TestPropertyObject(unittest.TestCase):
d = {}
for key, (gtype, min, max) in types_.items():
d[key] = (gtype, 'blurb', 'desc', min, max, 0,
- PARAM_READABLE | PARAM_WRITABLE)
+ ParamFlags.READABLE | ParamFlags.WRITABLE)
return d
class RangeCheck(GObject.GObject):
@@ -645,12 +655,12 @@ class TestProperty(unittest.TestCase):
def test_range(self):
types_ = [
- (TYPE_INT, G_MININT, G_MAXINT),
- (TYPE_UINT, 0, G_MAXUINT),
- (TYPE_LONG, G_MINLONG, G_MAXLONG),
- (TYPE_ULONG, 0, G_MAXULONG),
- (TYPE_INT64, G_MININT64, G_MAXINT64),
- (TYPE_UINT64, 0, G_MAXUINT64),
+ (TYPE_INT, MININT, MAXINT),
+ (TYPE_UINT, 0, MAXUINT),
+ (TYPE_LONG, MINLONG, MAXLONG),
+ (TYPE_ULONG, 0, MAXULONG),
+ (TYPE_INT64, MININT64, MAXINT64),
+ (TYPE_UINT64, 0, MAXUINT64),
]
for gtype, min, max in types_:
@@ -969,24 +979,24 @@ class CPropertiesTestBase(object):
def test_char(self):
self.assertEqual(self.get_prop(self.obj, 'some-char'), 0)
- self.set_prop(self.obj, 'some-char', GObject.G_MAXINT8)
- self.assertEqual(self.get_prop(self.obj, 'some-char'), GObject.G_MAXINT8)
+ self.set_prop(self.obj, 'some-char', GLib.MAXINT8)
+ self.assertEqual(self.get_prop(self.obj, 'some-char'), GLib.MAXINT8)
obj = GIMarshallingTests.PropertiesObject(some_char=-42)
self.assertEqual(self.get_prop(obj, 'some-char'), -42)
def test_uchar(self):
self.assertEqual(self.get_prop(self.obj, 'some-uchar'), 0)
- self.set_prop(self.obj, 'some-uchar', GObject.G_MAXUINT8)
- self.assertEqual(self.get_prop(self.obj, 'some-uchar'), GObject.G_MAXUINT8)
+ self.set_prop(self.obj, 'some-uchar', GLib.MAXUINT8)
+ self.assertEqual(self.get_prop(self.obj, 'some-uchar'), GLib.MAXUINT8)
obj = GIMarshallingTests.PropertiesObject(some_uchar=42)
self.assertEqual(self.get_prop(obj, 'some-uchar'), 42)
def test_int(self):
self.assertEqual(self.get_prop(self.obj, 'some_int'), 0)
- self.set_prop(self.obj, 'some-int', GObject.G_MAXINT)
- self.assertEqual(self.get_prop(self.obj, 'some_int'), GObject.G_MAXINT)
+ self.set_prop(self.obj, 'some-int', GLib.MAXINT)
+ self.assertEqual(self.get_prop(self.obj, 'some_int'), GLib.MAXINT)
obj = GIMarshallingTests.PropertiesObject(some_int=-42)
self.assertEqual(self.get_prop(obj, 'some-int'), -42)
@@ -998,8 +1008,8 @@ class CPropertiesTestBase(object):
def test_uint(self):
self.assertEqual(self.get_prop(self.obj, 'some_uint'), 0)
- self.set_prop(self.obj, 'some-uint', GObject.G_MAXUINT)
- self.assertEqual(self.get_prop(self.obj, 'some_uint'), GObject.G_MAXUINT)
+ self.set_prop(self.obj, 'some-uint', GLib.MAXUINT)
+ self.assertEqual(self.get_prop(self.obj, 'some_uint'), GLib.MAXUINT)
obj = GIMarshallingTests.PropertiesObject(some_uint=42)
self.assertEqual(self.get_prop(obj, 'some-uint'), 42)
@@ -1011,8 +1021,8 @@ class CPropertiesTestBase(object):
def test_long(self):
self.assertEqual(self.get_prop(self.obj, 'some_long'), 0)
- self.set_prop(self.obj, 'some-long', GObject.G_MAXLONG)
- self.assertEqual(self.get_prop(self.obj, 'some_long'), GObject.G_MAXLONG)
+ self.set_prop(self.obj, 'some-long', GLib.MAXLONG)
+ self.assertEqual(self.get_prop(self.obj, 'some_long'), GLib.MAXLONG)
obj = GIMarshallingTests.PropertiesObject(some_long=-42)
self.assertEqual(self.get_prop(obj, 'some-long'), -42)
@@ -1024,8 +1034,8 @@ class CPropertiesTestBase(object):
def test_ulong(self):
self.assertEqual(self.get_prop(self.obj, 'some_ulong'), 0)
- self.set_prop(self.obj, 'some-ulong', GObject.G_MAXULONG)
- self.assertEqual(self.get_prop(self.obj, 'some_ulong'), GObject.G_MAXULONG)
+ self.set_prop(self.obj, 'some-ulong', GLib.MAXULONG)
+ self.assertEqual(self.get_prop(self.obj, 'some_ulong'), GLib.MAXULONG)
obj = GIMarshallingTests.PropertiesObject(some_ulong=42)
self.assertEqual(self.get_prop(obj, 'some-ulong'), 42)
@@ -1037,24 +1047,24 @@ class CPropertiesTestBase(object):
def test_int64(self):
self.assertEqual(self.get_prop(self.obj, 'some-int64'), 0)
- self.set_prop(self.obj, 'some-int64', GObject.G_MAXINT64)
- self.assertEqual(self.get_prop(self.obj, 'some-int64'), GObject.G_MAXINT64)
+ self.set_prop(self.obj, 'some-int64', GLib.MAXINT64)
+ self.assertEqual(self.get_prop(self.obj, 'some-int64'), GLib.MAXINT64)
obj = GIMarshallingTests.PropertiesObject(some_int64=-4200000000000000)
self.assertEqual(self.get_prop(obj, 'some-int64'), -4200000000000000)
def test_uint64(self):
self.assertEqual(self.get_prop(self.obj, 'some-uint64'), 0)
- self.set_prop(self.obj, 'some-uint64', GObject.G_MAXUINT64)
- self.assertEqual(self.get_prop(self.obj, 'some-uint64'), GObject.G_MAXUINT64)
+ self.set_prop(self.obj, 'some-uint64', GLib.MAXUINT64)
+ self.assertEqual(self.get_prop(self.obj, 'some-uint64'), GLib.MAXUINT64)
obj = GIMarshallingTests.PropertiesObject(some_uint64=4200000000000000)
self.assertEqual(self.get_prop(obj, 'some-uint64'), 4200000000000000)
def test_float(self):
self.assertEqual(self.get_prop(self.obj, 'some-float'), 0)
- self.set_prop(self.obj, 'some-float', GObject.G_MAXFLOAT)
- self.assertEqual(self.get_prop(self.obj, 'some-float'), GObject.G_MAXFLOAT)
+ self.set_prop(self.obj, 'some-float', GLib.MAXFLOAT)
+ self.assertEqual(self.get_prop(self.obj, 'some-float'), GLib.MAXFLOAT)
obj = GIMarshallingTests.PropertiesObject(some_float=42.42)
self.assertAlmostEqual(self.get_prop(obj, 'some-float'), 42.42, 4)
@@ -1069,8 +1079,8 @@ class CPropertiesTestBase(object):
def test_double(self):
self.assertEqual(self.get_prop(self.obj, 'some-double'), 0)
- self.set_prop(self.obj, 'some-double', GObject.G_MAXDOUBLE)
- self.assertEqual(self.get_prop(self.obj, 'some-double'), GObject.G_MAXDOUBLE)
+ self.set_prop(self.obj, 'some-double', GLib.MAXDOUBLE)
+ self.assertEqual(self.get_prop(self.obj, 'some-double'), GLib.MAXDOUBLE)
obj = GIMarshallingTests.PropertiesObject(some_double=42.42)
self.assertAlmostEqual(self.get_prop(obj, 'some-double'), 42.42)
@@ -1120,7 +1130,7 @@ class CPropertiesTestBase(object):
def test_boxed_glist(self):
self.assertEqual(self.get_prop(self.obj, 'some-boxed-glist'), [])
- l = [GObject.G_MININT, 42, GObject.G_MAXINT]
+ l = [GLib.MININT, 42, GLib.MAXINT]
self.set_prop(self.obj, 'some-boxed-glist', l)
self.assertEqual(self.get_prop(self.obj, 'some-boxed-glist'), l)
self.set_prop(self.obj, 'some-boxed-glist', [])
@@ -1141,7 +1151,7 @@ class CPropertiesTestBase(object):
@unittest.expectedFailure
def test_boxed_glist_ctor(self):
- l = [GObject.G_MININT, 42, GObject.G_MAXINT]
+ l = [GLib.MININT, 42, GLib.MAXINT]
obj = GIMarshallingTests.PropertiesObject(some_boxed_glist=l)
self.assertEqual(self.get_prop(obj, 'some-boxed-glist'), l)
diff --git a/tests/test_signal.py b/tests/test_signal.py
index 40cfb4f..74ec745 100644
--- a/tests/test_signal.py
+++ b/tests/test_signal.py
@@ -500,7 +500,8 @@ class SigPropClass(GObject.GObject):
(GObject.TYPE_INT,))}
__gproperties__ = {
- 'foo': (str, None, None, '', GObject.PARAM_WRITABLE | GObject.PARAM_CONSTRUCT),
+ 'foo': (str, None, None, '',
+ GObject.ParamFlags.WRITABLE | GObject.ParamFlags.CONSTRUCT),
}
signal_emission_failed = False
@@ -577,11 +578,11 @@ class _TestCMarshaller:
rv = self.obj.emit("test-int64", 102030405)
self.assertEqual(rv, 102030405)
- rv = self.obj.emit("test-int64", GObject.G_MAXINT64)
- self.assertEqual(rv, GObject.G_MAXINT64 - 1)
+ rv = self.obj.emit("test-int64", GLib.MAXINT64)
+ self.assertEqual(rv, GLib.MAXINT64 - 1)
- rv = self.obj.emit("test-int64", GObject.G_MININT64)
- self.assertEqual(rv, GObject.G_MININT64)
+ rv = self.obj.emit("test-int64", GLib.MININT64)
+ self.assertEqual(rv, GLib.MININT64)
def test_string(self):
rv = self.obj.emit("test-string", "str")
@@ -634,34 +635,34 @@ class _TestCMarshaller:
self.assertAlmostEqual(rv, 1.234, 4)
# explicit int64
- v = GObject.Value(GObject.TYPE_INT64, GObject.G_MAXINT64)
+ v = GObject.Value(GObject.TYPE_INT64, GLib.MAXINT64)
rv = self.obj.emit("test-gvalue", v)
- self.assertEqual(rv, GObject.G_MAXINT64)
+ self.assertEqual(rv, GLib.MAXINT64)
# explicit uint64
- v = GObject.Value(GObject.TYPE_UINT64, GObject.G_MAXUINT64)
+ v = GObject.Value(GObject.TYPE_UINT64, GLib.MAXUINT64)
rv = self.obj.emit("test-gvalue", v)
- self.assertEqual(rv, GObject.G_MAXUINT64)
+ self.assertEqual(rv, GLib.MAXUINT64)
@unittest.expectedFailure # https://bugzilla.gnome.org/show_bug.cgi?id=705291
def test_gvalue_implicit_int64(self):
# implicit int64
- rv = self.obj.emit("test-gvalue", GObject.G_MAXINT64)
- self.assertEqual(rv, GObject.G_MAXINT64)
+ rv = self.obj.emit("test-gvalue", GLib.MAXINT64)
+ self.assertEqual(rv, GLib.MAXINT64)
# implicit uint64
- rv = self.obj.emit("test-gvalue", GObject.G_MAXUINT64)
- self.assertEqual(rv, GObject.G_MAXUINT64)
+ rv = self.obj.emit("test-gvalue", GLib.MAXUINT64)
+ self.assertEqual(rv, GLib.MAXUINT64)
def test_gvalue_ret(self):
self.assertEqual(self.obj.emit("test-gvalue-ret", GObject.TYPE_INT),
- GObject.G_MAXINT)
+ GLib.MAXINT)
self.assertEqual(self.obj.emit("test-gvalue-ret", GObject.TYPE_UINT),
- GObject.G_MAXUINT)
+ GLib.MAXUINT)
self.assertEqual(self.obj.emit("test-gvalue-ret", GObject.TYPE_INT64),
- GObject.G_MAXINT64)
+ GLib.MAXINT64)
self.assertEqual(self.obj.emit("test-gvalue-ret", GObject.TYPE_UINT64),
- GObject.G_MAXUINT64)
+ GLib.MAXUINT64)
self.assertEqual(self.obj.emit("test-gvalue-ret", GObject.TYPE_STRING),
"hello")
@@ -871,75 +872,75 @@ class _ConnectDataTestBase(object):
return callback_args[0]
def test_0(self):
- obj, value = self.run_connect_test([GObject.G_MAXINT64], user_data=[])
+ obj, value = self.run_connect_test([GLib.MAXINT64], user_data=[])
self.assertIsInstance(obj, self.Object)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
def test_1(self):
- obj, value, data = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value, data = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata'])
self.assertIsInstance(obj, self.Object)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data, 'mydata')
def test_after_0(self):
- obj, value = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value = self.run_connect_test([GLib.MAXINT64],
user_data=[],
flags=GObject.ConnectFlags.AFTER)
self.assertIsInstance(obj, self.Object)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
def test_after_1(self):
- obj, value, data = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value, data = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata'],
flags=GObject.ConnectFlags.AFTER)
self.assertIsInstance(obj, self.Object)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data, 'mydata')
def test_swaped_0(self):
# Swapped only works with a single user data argument.
with self.assertRaises(ValueError):
- self.run_connect_test([GObject.G_MAXINT64],
+ self.run_connect_test([GLib.MAXINT64],
user_data=[],
flags=GObject.ConnectFlags.SWAPPED)
def test_swaped_1(self):
# Notice obj and data are reversed in the return.
- data, value, obj = self.run_connect_test([GObject.G_MAXINT64],
+ data, value, obj = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata'],
flags=GObject.ConnectFlags.SWAPPED)
self.assertIsInstance(obj, self.Object)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data, 'mydata')
def test_swaped_2(self):
# Swapped only works with a single user data argument.
with self.assertRaises(ValueError):
- self.run_connect_test([GObject.G_MAXINT64],
+ self.run_connect_test([GLib.MAXINT64],
user_data=[1, 2],
flags=GObject.ConnectFlags.SWAPPED)
def test_after_and_swapped_0(self):
# Swapped only works with a single user data argument.
with self.assertRaises(ValueError):
- self.run_connect_test([GObject.G_MAXINT64],
+ self.run_connect_test([GLib.MAXINT64],
user_data=[],
flags=GObject.ConnectFlags.AFTER | GObject.ConnectFlags.SWAPPED)
def test_after_and_swapped_1(self):
# Notice obj and data are reversed in the return.
- data, value, obj = self.run_connect_test([GObject.G_MAXINT64],
+ data, value, obj = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata'],
flags=GObject.ConnectFlags.AFTER |
GObject.ConnectFlags.SWAPPED)
self.assertIsInstance(obj, self.Object)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data, 'mydata')
def test_after_and_swapped_2(self):
# Swapped only works with a single user data argument.
with self.assertRaises(ValueError):
- self.run_connect_test([GObject.G_MAXINT64],
+ self.run_connect_test([GLib.MAXINT64],
user_data=[],
flags=GObject.ConnectFlags.AFTER | GObject.ConnectFlags.SWAPPED)
@@ -1129,9 +1130,9 @@ class TestIntrospectedSignals(unittest.TestCase):
obj.callback_i = None
obj.connect('sig-with-int64-prop', callback)
- rv = obj.emit('sig-with-int64-prop', GObject.G_MAXINT64)
- self.assertEqual(rv, GObject.G_MAXINT64)
- self.assertEqual(obj.callback_i, GObject.G_MAXINT64)
+ rv = obj.emit('sig-with-int64-prop', GLib.MAXINT64)
+ self.assertEqual(rv, GLib.MAXINT64)
+ self.assertEqual(obj.callback_i, GLib.MAXINT64)
def test_uint64_param_from_py(self):
obj = Regress.TestObj()
@@ -1142,9 +1143,9 @@ class TestIntrospectedSignals(unittest.TestCase):
obj.callback_i = None
obj.connect('sig-with-uint64-prop', callback)
- rv = obj.emit('sig-with-uint64-prop', GObject.G_MAXUINT64)
- self.assertEqual(rv, GObject.G_MAXUINT64)
- self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)
+ rv = obj.emit('sig-with-uint64-prop', GLib.MAXUINT64)
+ self.assertEqual(rv, GLib.MAXUINT64)
+ self.assertEqual(obj.callback_i, GLib.MAXUINT64)
def test_int64_param_from_c(self):
obj = Regress.TestObj()
@@ -1157,7 +1158,7 @@ class TestIntrospectedSignals(unittest.TestCase):
obj.connect('sig-with-int64-prop', callback)
obj.emit_sig_with_int64()
- self.assertEqual(obj.callback_i, GObject.G_MAXINT64)
+ self.assertEqual(obj.callback_i, GLib.MAXINT64)
def test_uint64_param_from_c(self):
obj = Regress.TestObj()
@@ -1170,7 +1171,7 @@ class TestIntrospectedSignals(unittest.TestCase):
obj.connect('sig-with-uint64-prop', callback)
obj.emit_sig_with_uint64()
- self.assertEqual(obj.callback_i, GObject.G_MAXUINT64)
+ self.assertEqual(obj.callback_i, GLib.MAXUINT64)
def test_intarray_ret(self):
obj = Regress.TestObj()
@@ -1203,8 +1204,8 @@ class TestIntrospectedSignals(unittest.TestCase):
obj.connect('sig-with-array-prop', callback)
obj.callback_arr = None
- self.assertEqual(obj.emit('sig-with-array-prop', [1, 2, GObject.G_MAXUINT]), None)
- self.assertEqual(obj.callback_arr, [1, 2, GObject.G_MAXUINT])
+ self.assertEqual(obj.emit('sig-with-array-prop', [1, 2, GLib.MAXUINT]), None)
+ self.assertEqual(obj.callback_arr, [1, 2, GLib.MAXUINT])
def test_held_struct_ref(self):
held_structs = []
@@ -1261,46 +1262,46 @@ class _ConnectObjectTestBase(object):
return callback_args[0]
def test_0(self):
- obj, value = self.run_connect_test([GObject.G_MAXINT64], user_data=[])
+ obj, value = self.run_connect_test([GLib.MAXINT64], user_data=[])
self.assertIsInstance(obj, self.SwapObject)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
def test_1(self):
- obj, value, data = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value, data = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata'])
self.assertIsInstance(obj, self.SwapObject)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data, 'mydata')
def test_2(self):
- obj, value, data1, data2 = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value, data1, data2 = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata1', 'mydata2'])
self.assertIsInstance(obj, self.SwapObject)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data1, 'mydata1')
self.assertEqual(data2, 'mydata2')
def test_after_0(self):
- obj, value = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value = self.run_connect_test([GLib.MAXINT64],
user_data=[],
flags=GObject.ConnectFlags.AFTER)
self.assertIsInstance(obj, self.SwapObject)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
def test_after_1(self):
- obj, value, data = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value, data = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata'],
flags=GObject.ConnectFlags.AFTER)
self.assertIsInstance(obj, self.SwapObject)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data, 'mydata')
def test_after_2(self):
- obj, value, data1, data2 = self.run_connect_test([GObject.G_MAXINT64],
+ obj, value, data1, data2 = self.run_connect_test([GLib.MAXINT64],
user_data=['mydata1', 'mydata2'],
flags=GObject.ConnectFlags.AFTER)
self.assertIsInstance(obj, self.SwapObject)
- self.assertEqual(value, GObject.G_MAXINT64)
+ self.assertEqual(value, GLib.MAXINT64)
self.assertEqual(data1, 'mydata1')
self.assertEqual(data2, 'mydata2')
diff --git a/tests/test_source.py b/tests/test_source.py
index 4c8bcc5..362e5cd 100644
--- a/tests/test_source.py
+++ b/tests/test_source.py
@@ -4,7 +4,7 @@ import gc
import unittest
import warnings
-from gi.repository import GLib, GObject
+from gi.repository import GLib
from gi import PyGIDeprecationWarning
@@ -138,9 +138,9 @@ class TestSource(unittest.TestCase):
self.assertEqual(GLib.source_remove(s), False)
# accepts large source IDs (they are unsigned)
- self.assertEqual(GLib.source_remove(GObject.G_MAXINT32), False)
- self.assertEqual(GLib.source_remove(GObject.G_MAXINT32 + 1), False)
- self.assertEqual(GLib.source_remove(GObject.G_MAXUINT32), False)
+ self.assertEqual(GLib.source_remove(GLib.MAXINT32), False)
+ self.assertEqual(GLib.source_remove(GLib.MAXINT32 + 1), False)
+ self.assertEqual(GLib.source_remove(GLib.MAXUINT32), False)
finally:
GLib.log_set_always_fatal(old_mask)
diff --git a/tests/test_subprocess.py b/tests/test_subprocess.py
index 720c950..fac54c9 100644
--- a/tests/test_subprocess.py
+++ b/tests/test_subprocess.py
@@ -149,5 +149,8 @@ class TestProcess(unittest.TestCase):
self.assertEqual(out, b'moo!\n')
def test_backwards_compat_flags(self):
- self.assertEqual(GLib.SpawnFlags.DO_NOT_REAP_CHILD,
- GLib.SPAWN_DO_NOT_REAP_CHILD)
+ with warnings.catch_warnings():
+ warnings.simplefilter('ignore', PyGIDeprecationWarning)
+
+ self.assertEqual(GLib.SpawnFlags.DO_NOT_REAP_CHILD,
+ GLib.SPAWN_DO_NOT_REAP_CHILD)
diff --git a/tests/testmodule.py b/tests/testmodule.py
index 3da8ed5..c083f62 100644
--- a/tests/testmodule.py
+++ b/tests/testmodule.py
@@ -7,7 +7,8 @@ class PyGObject(GObject.GObject):
'label': (GObject.TYPE_STRING,
'label property',
'the label of the object',
- 'default', GObject.PARAM_READWRITE),
+ 'default',
+ GObject.ParamFlags.READABLE | GObject.ParamFlags.WRITABLE),
}
def __init__(self):
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
