-commit e65d2fe75310a478e09eef1ab942ece09516d7d9
+commit 8ac474c15199ca00c729a73af9c926172657b842
Author: Sebastian Pölsterl <sebp@k-d-w.org>
-Date: Thu Feb 9 10:02:14 2012 +0100
+Date: Mon Feb 6 19:11:52 2012 +0100
- Prepare 3.0.4 release
+ Prepare 3.1.0 release
- NEWS | 5 +++++
- 1 files changed, 5 insertions(+), 0 deletions(-)
+ NEWS | 34 ++++++++++++++++++++++++++++++++++
+ 1 files changed, 34 insertions(+), 0 deletions(-)
-commit f24b5a4306fb83f6ff46920ecd7adc201d105b16
-Author: Martin Pitt <martin.pitt@ubuntu.com>
-Date: Sat Jan 7 09:47:24 2012 +0100
+commit 18996ae455fb01a1e53a3826f0a1e79d06097c5b
+Author: Sebastian Pölsterl <sebp@k-d-w.org>
+Date: Mon Feb 6 19:04:41 2012 +0100
+
+ Updated DOAP file to only include people currently actively working
+ on the project
+
+ Removed obsolete MAINTAINERS file
+
+ MAINTAINERS | 19 -------------------
+ pygobject.doap | 44 +++++++++++++++-----------------------------
+ 2 files changed, 15 insertions(+), 48 deletions(-)
+
+commit 0285e107be581c4d594127dc06cd05df1f02fb3f
+Author: Sebastian Pölsterl <sebp@k-d-w.org>
+Date: Mon Feb 6 18:57:01 2012 +0100
Revert "Convert all strings to utf-8 encoding when retrieving from
TreeModel"
- This changes existing behaviour (model values being str instead of
- unicode) and
- also makes tree model behaviour incompatible to the rest of Gtk
- behaviour
- (which always returns UTF-8 encoded str objects, not unicode). The
- original bug
- description was a bug in the test case code, you cannot mix str
- and unicode
- objects in interpolation.
-
- This reverts commit 33060639bc4857238f21c2329b8e8888fbd8fdc2.
+ This reverts commit 654711d0f940d7480d0f1cdb25a3dc9996f7a706.
- https://bugzilla.gnome.org/show_bug.cgi?id=663610
+ Due to this commit breaking backwards compatability, we decided to
+ revert this change
gi/overrides/Gtk.py | 15 ---------------
tests/compathelper.py | 2 --
tests/test_overrides.py | 31 +------------------------------
3 files changed, 1 insertions(+), 47 deletions(-)
-commit cba8124389de92f98c45cbaf2bd9c320036d6407
-Author: Tomeu Vizoso <tomeu.vizoso@collabora.com>
-Date: Fri Dec 23 12:20:15 2011 +0100
+commit 0e921cd26ed5a6e3bc6ef5f553e8b22b862d72a6
+Author: Sebastian Pölsterl <sebp@k-d-w.org>
+Date: Sun Feb 5 13:47:10 2012 +0100
- Post-release bump to 3.0.4
+ tests: Fixed issues with python3
- configure.ac | 2 +-
+ tests/test_gi.py | 9 ++++++---
+ 1 files changed, 6 insertions(+), 3 deletions(-)
+
+commit ee62df4d2fc0cc63c2f29d3ad9b47b875dbd5f89
+Author: Sebastian Pölsterl <sebp@k-d-w.org>
+Date: Sun Feb 5 11:59:51 2012 +0100
+
+ Properly distinguish between different integer types for properties
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=664150
+
+ gi/pygi-property.c | 48 ++++++++++++++++++++++++++++++++++++---
+ tests/test_gi.py | 62
+ ++++++++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 106 insertions(+), 4 deletions(-)
+
+commit c329bf2aee8d75ce452638db75e09197ff2b9b65
+Author: Sebastian Pölsterl <sebp@k-d-w.org>
+Date: Sun Feb 5 11:46:21 2012 +0100
+
+ Distinguish between GArray and GPtrArray when cleaning up
+
+ This fixes a crash in test_gi.TestGPtrArray and makes sure
+ memory is free'd correctly
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=669393
+
+ gi/pygi-marshal-cleanup.c | 32 +++++++++++++++++++++++---------
+ 1 files changed, 23 insertions(+), 9 deletions(-)
+
+commit 4ea37c606f67df843788261b2c8acd6bac4c1e0c
+Author: Paolo Borelli <pborelli@gnome.org>
+Date: Sun Feb 5 18:51:53 2012 +0100
+
+ Add null_gerror_callback unit test
+
+ This models the case where the callback is successful and does not set
+ an error.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=669415
+
+ tests/test_everything.py | 9 +++++++++
+ 1 files changed, 9 insertions(+), 0 deletions(-)
+
+commit a41984780ee49dcf02c718ca1be87bba747472e5
+Author: Martin Pitt <martin.pitt@ubuntu.com>
+Date: Mon Feb 6 09:34:28 2012 +0100
+
+ pyglib_error_check: Re-add missing NULL check
+
+ Commit adcfe96d49b09bc accidentally dropped the check if *error is
+ NULL, i. e.
+ any error is actually set. Due to that, pyglib_error_check()
+ always returned
+ TRUE. Reintroduce the check.
+
+ Thanks to Alberto Mardegan for spotting this!
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=669415
+
+ gi/_glib/pyglib.c | 2 ++
+ 1 files changed, 2 insertions(+), 0 deletions(-)
+
+commit 2c797c17913999379e277788d5e4cce8d68cebb0
+Author: Michael Culbertson <michael.culbertson@gmail.com>
+Date: Sat Feb 4 16:11:34 2012 +0100
+
+ Add tests/runtests-windows.py to source tarball
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=663288
+
+ tests/Makefile.am | 1 +
+ 1 files changed, 1 insertions(+), 0 deletions(-)
+
+commit d6a899cdf70e978534326155e3fad75a705f4b20
+Author: Sebastian Pölsterl <sebp@k-d-w.org>
+Date: Sat Feb 4 15:55:55 2012 +0100
+
+ Don't issue a depreciation warning for GtkDialog's NO_SEPARATOR flag,
+ even when unused
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=665553
+
+ gi/overrides/Gtk.py | 6 ++----
+ 1 files changed, 2 insertions(+), 4 deletions(-)
+
+commit 534ec71c575a279ff1c05da20a8858bb1145b4d0
+Author: Nirbheek Chauhan <nirbheek@gentoo.org>
+Date: Sat Feb 4 15:42:36 2012 +0100
+
+ Fix bool() operations on GLib.Variant objects
+
+ Defines __nonzero__ (python2) and __bool__ (python3) for GLib.Variant
+
+ Also adds some tests for boolean comparisons.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=647723
+
+ gi/overrides/GLib.py | 18 ++++++++++++++++++
+ tests/test_overrides.py | 45
+ +++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 63 insertions(+), 0 deletions(-)
+
+commit 8d6a127df5dd1e5f26faeba8f977074b4496b24f
+Author: Nirbheek Chauhan <nirbheek@gentoo.org>
+Date: Sat Feb 4 15:41:08 2012 +0100
+
+ Fix hash() and __eq__() for GLib.Variant objects
+
+ Define __hash__, __eq__, __ne__ for GLib.Variant so that objects can
+ be used in sets, dicts, and can be compared using == and != easily.
+
+ Also adds some tests for this.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=647725
+
+ gi/overrides/GLib.py | 23 +++++++++++++++++++
+ tests/test_overrides.py | 56
+ +++++++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 79 insertions(+), 0 deletions(-)
+
+commit f82404034be042bf2026bbb7f1e33b11d6e17a6f
+Author: Martin Pitt <martin.pitt@ubuntu.com>
+Date: Wed Jan 25 07:01:06 2012 +0100
+
+ Fix method names of callback tests
+
+ Change test_everything.TestCallbacks.* test names from camelCase
+ to the
+ standard PEP-8 underscore_style. This is now consistent with all
+ other test
+ case names.
+
+ tests/test_everything.py | 30 +++++++++++++++---------------
+ 1 files changed, 15 insertions(+), 15 deletions(-)
+
+commit e37ee78fbf0aa72159a40da4165a26bea065faf1
+Author: Will Thompson <will.thompson@collabora.co.uk>
+Date: Mon Jan 23 13:10:30 2012 +0000
+
+ Cairo: add missing braces around array-of-struct definition
+
+ This triggered a -Wmissing-braces warning.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=668497
+
+ gi/pygi-foreign-cairo.c | 2 +-
1 files changed, 1 insertions(+), 1 deletions(-)
-commit 9ba741343e79f0d108074c0110f1aada5f7da4a3
-Merge: 3306063 8d1a36c
+commit db24865d6b60351d72f5b8f47103d6d0a6c63b2e
+Author: Will Thompson <will.thompson@collabora.co.uk>
+Date: Mon Jan 23 13:06:41 2012 +0000
+
+ g_instance_init: cast to PyGObject * as needed
+
+ This squashes a compiler warning.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=668497
+
+ gi/_gobject/gobjectmodule.c | 2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+commit a8408cfd68cd5e7cdb0b8a83e107d9a0d828e4bd
+Author: Will Thompson <will.thompson@collabora.co.uk>
+Date: Mon Jan 23 13:01:27 2012 +0000
+
+ Fix a few set-but-not-used warnings.
+
+ In a couple of cases, the variable in question was set to a value
+ spelled out again later in the function.
+
+ The 'sequence_cache' variable is re-declared five lines below.
+
+ The return value of 'read' was previously completely ignored. The
+ 'gssize ret' variable was in fact added to squash an unused-result
+ warning.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=668497
+
+ gi/_glib/pygiochannel.c | 2 +-
+ gi/_glib/pygmainloop.c | 3 +--
+ gi/_gobject/pygobject.c | 2 +-
+ gi/pygi-marshal-cleanup.c | 2 --
+ 4 files changed, 3 insertions(+), 6 deletions(-)
+
+commit 29a30490ed51e347e8f57d2bf9af69400734eee8
+Author: Stefano Facchini <stefano.facchini@gmail.com>
+Date: Thu Jan 19 18:09:07 2012 +0100
+
+ pygmainloop: allow for extra arguments in 'quit' method
+
+ To allow for the common syntax:
+
+ object.connect('signal-name', main_loop.quit)
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=668288
+
+ gi/_glib/pygmainloop.c | 4 ++--
+ 1 files changed, 2 insertions(+), 2 deletions(-)
+
+commit 557a61c12c01137a0d7c679c4b053973df09d445
+Author: Alexandre Rostovtsev <tetromino@gentoo.org>
+Date: Mon Dec 26 00:44:56 2011 -0500
+
+ Fix bytearray test compatibility with python3
+
+ https://bugs.gentoo.org/show_bug.cgi?id=321879
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=666852
+
+ tests/test_gi.py | 4 ++--
+ 1 files changed, 2 insertions(+), 2 deletions(-)
+
+commit d69e5b3c7bdb9113382fd125c256b12bff4c24d2
+Author: Alberto Mardegan <mardy@users.sourceforge.net>
+Date: Mon Jan 23 12:37:26 2012 +0200
+
+ Respect transfer-type when demarshalling GErrors
+
+ The marshaller previously ignored "transfer full" on GError*
+ arguments, causing
+ crashes due to double-freeing them. This causes the
+ testCallbackUserdata() test
+ case to crash after the previous GError/GHashTable marshalling fix.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=666270
+
+ gi/pygi-argument.c | 12 +++++++++++-
+ 1 files changed, 11 insertions(+), 1 deletions(-)
+
+commit 77f32d9110bfeb6dad8457f565b4c70b5998fef6
+Author: Alberto Mardegan <mardy@users.sourceforge.net>
+Date: Thu Dec 15 16:12:01 2011 +0200
+
+ Support GHashTable and GError as callback/closure arguments
+
+ Marshalling of these types from C is already implemented, let's
+ take it
+ into use for calbacks and closures too.
+
+ Add corresponding test cases.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=666270
+
+ Signed-off-by: Martin Pitt <martin.pitt@ubuntu.com>
+
+ gi/pygi-closure.c | 2 ++
+ tests/test_everything.py | 35 +++++++++++++++++++++++++++++++++++
+ 2 files changed, 37 insertions(+), 0 deletions(-)
+
+commit 4b9dc03d0e49e9a1f4bf0f2df503bdff00d13a2b
+Author: Will Thompson <will.thompson@collabora.co.uk>
+Date: Mon Jan 23 13:56:02 2012 +0000
+
+ Don't leak when marshalling GErrors to C
+
+ Python-land GLib.GErrors are supposed to have three attributes:
+ "message", "domain" and "code". If those attributes are missing,
+ or they
+ have the wrong types, the C GError is filled in with a message
+ describing the error. The present-but-ill-typed code paths did not
+ DECREF the ill-typed values.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=666098
+
+ gi/_glib/pyglib.c | 3 +++
+ 1 files changed, 3 insertions(+), 0 deletions(-)
+
+commit adcfe96d49b09bcc550653d73de196610fd5144d
+Author: Will Thompson <will.thompson@collabora.co.uk>
+Date: Fri Jan 20 16:20:10 2012 +0000
+
+ Support functions which return GError
+
+ GStreamer has the following method:
+
+ void gst_message_parse_error (
+ GstMessage *message,
+ GError **error,
+ gchar **debug_message);
+
+ With this patch, we marshal the GError out parameter as a
+ GObject.GError
+ exception, but return it rather than throwing it. The test cases cover
+ two variations on the theme of the function above (one with (transfer
+ full), as in GStreamer, and another with (transfer none)) as well as a
+ function with return type GError *.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=666098
+
+ gi/_glib/pyglib.c | 46
+ +++++++++++++++++++++++++++++++++++-----------
+ gi/_glib/pyglib.h | 1 +
+ gi/pygi-marshal-to-py.c | 16 +++++++++++++---
+ tests/test_gi.py | 32 ++++++++++++++++++++++++++++++++
+ 4 files changed, 81 insertions(+), 14 deletions(-)
+
+commit 09f003729eac9d553a208c343c2a14d253b77d9a
+Author: Alberto Mardegan <mardy@users.sourceforge.net>
+Date: Mon Jan 23 12:42:21 2012 +0200
+
+ Fix indentation of _pygi_argument_to_object()
+
+ Side issue in https://bugzilla.gnome.org/show_bug.cgi?id=666270
+
+ Signed-off-by: Martin Pitt <martin.pitt@ubuntu.com>
+
+ gi/pygi-argument.c | 26 +++++++++++++-------------
+ 1 files changed, 13 insertions(+), 13 deletions(-)
+
+commit c71c010be01d706f90bc200194325fd82f4071b2
+Author: Paolo Borelli <pborelli@gnome.org>
+Date: Sat Jan 14 14:24:23 2012 +0100
+
+ Avoid C99 syntax.
+
+ gi/gimodule.c | 10 ++++++----
+ 1 files changed, 6 insertions(+), 4 deletions(-)
+
+commit c299d058c22385ececaec64c872d1dd1bc1ae17a
+Author: Paolo Borelli <pborelli@gnome.org>
+Date: Fri Jan 6 13:39:31 2012 +0100
+
+ Connect to first action of a radio group.
+
+ gi/overrides/Gtk.py | 4 ++--
+ 1 files changed, 2 insertions(+), 2 deletions(-)
+
+commit dee2f179037902a3883bd0e61ff1c350e1fd8a4f
+Author: Paolo Borelli <pborelli@gnome.org>
+Date: Wed Jan 4 16:40:51 2012 +0100
+
+ Use g_slist_free_full in pygi-closure.
+
+ gi/pygi-closure.c | 3 +--
+ 1 files changed, 1 insertions(+), 2 deletions(-)
+
+commit 2bee4207ab6f07dc9c0952affe72f0e304cfb624
+Author: Paolo Borelli <pborelli@gnome.org>
+Date: Wed Jan 4 15:24:13 2012 +0100
+
+ Avoid O(n^2) behavior when marshalling lists
+
+ Appending requires walking the list every time: just prepend and
+ reverse
+ the list at the end.
+
+ https://bugzilla.gnome.org/show_bug.cgi?id=667261
+
+ gi/pygi-marshal-from-py.c | 8 ++++----
+ 1 files changed, 4 insertions(+), 4 deletions(-)
+
+commit d68455e99b1a9ebba31209b17a11317b1958678b
+Author: Paolo Borelli <pborelli@gnome.org>
+Date: Tue Jan 3 16:57:40 2012 +0100
+
+ Handle NULL as a valid case of a char** array
+
+ Treat NULL as an empty array and add the corresponding testcase
+
+ gi/pygi-marshal-to-py.c | 9 +++++----
+ tests/test_gi.py | 3 +++
+ 2 files changed, 8 insertions(+), 4 deletions(-)
+
+commit e3451b8e6018bb76e9992fb6af24a71725de5cfd
Author: Tomeu Vizoso <tomeu.vizoso@collabora.com>
-Date: Fri Dec 23 12:18:00 2011 +0100
+Date: Fri Dec 23 12:01:43 2011 +0100
+
+ Branching, bump version to 3.1.0
- Merge branch 'master' into pygobject-3-0
+ configure.ac | 4 ++--
+ 1 files changed, 2 insertions(+), 2 deletions(-)
commit 8d1a36cc73f5f4df091ecb289c8a7b38ec2ab605
Author: Tomeu Vizoso <tomeu.vizoso@collabora.com>
pygi-convert.sh | 14 ++++++++++++++
1 files changed, 14 insertions(+), 0 deletions(-)
-commit 33060639bc4857238f21c2329b8e8888fbd8fdc2
-Author: Sebastian Pölsterl <sebp@k-d-w.org>
-Date: Tue Nov 8 12:38:12 2011 +0100
-
- Convert all strings to utf-8 encoding when retrieving from TreeModel
-
- https://bugzilla.gnome.org/show_bug.cgi?id=663610
-
- gi/overrides/Gtk.py | 15 +++++++++++++++
- tests/compathelper.py | 2 ++
- tests/test_overrides.py | 31 ++++++++++++++++++++++++++++++-
- 3 files changed, 47 insertions(+), 1 deletions(-)
-
-commit c9884283153c38f5b200a19b9abfaf6d9e698818
-Author: Sebastian Pölsterl <sebp@k-d-w.org>
-Date: Fri Nov 25 18:51:53 2011 +0100
-
- Post release version bump
-
- configure.ac | 2 +-
- 1 files changed, 1 insertions(+), 1 deletions(-)
-
commit 654711d0f940d7480d0f1cdb25a3dc9996f7a706
Author: Sebastian Pölsterl <sebp@k-d-w.org>
Date: Tue Nov 8 12:38:12 2011 +0100
-3.0.4 09-Feb-2012
- - Revert "Convert all strings to utf-8 encoding when retrieving from TreeModel" (Martin Pitt)
+3.1.0 06-Feb-2012
+ - Updated DOAP file to only include people currently actively working on the project (Sebastian Pölsterl)
+ - Revert "Convert all strings to utf-8 encoding when retrieving from TreeModel" (Sebastian Pölsterl)
+ - tests: Fixed issues with python3 (Sebastian Pölsterl)
+ - Properly distinguish between different integer types for properties (Sebastian Pölsterl)
+ - Distinguish between GArray and GPtrArray when cleaning up (Sebastian Pölsterl)
+ - Add null_gerror_callback unit test (Paolo Borelli)
+ - pyglib_error_check: Re-add missing NULL check (Martin Pitt)
+ - Add tests/runtests-windows.py to source tarball (Michael Culbertson)
+ - Don't issue a depreciation warning for GtkDialog's NO_SEPARATOR flag, even when unused (Sebastian Pölsterl)
+ - Fix bool() operations on GLib.Variant objects (Nirbheek Chauhan)
+ - Fix hash() and __eq__() for GLib.Variant objects (Nirbheek Chauhan)
+ - Fix method names of callback tests (Martin Pitt)
+ - Cairo: add missing braces around array-of-struct definition (Will Thompson)
+ - g_instance_init: cast to PyGObject * as needed (Will Thompson)
+ - Fix a few set-but-not-used warnings. (Will Thompson)
+ - pygmainloop: allow for extra arguments in 'quit' method (Stefano Facchini)
+ - Fix bytearray test compatibility with python3 (Alexandre Rostovtsev)
+ - Respect transfer-type when demarshalling GErrors (Alberto Mardegan)
+ - Support GHashTable and GError as callback/closure arguments (Alberto Mardegan)
+ - Don't leak when marshalling GErrors to C (Will Thompson)
+ - Support functions which return GError (Will Thompson)
+ - Fix indentation of _pygi_argument_to_object() (Alberto Mardegan)
+ - Avoid C99 syntax. (Paolo Borelli)
+ - Connect to first action of a radio group. (Paolo Borelli)
+ - Use g_slist_free_full in pygi-closure. (Paolo Borelli)
+ - Avoid O(n^2) behavior when marshalling lists (Paolo Borelli)
+ - Handle NULL as a valid case of a char** array (Paolo Borelli)
+ - Branching, bump version to 3.1.0 (Tomeu Vizoso)
+ - Add notes about branching to HACKING (Tomeu Vizoso)
- Fixed bug where GObject.property did not respect minimum and maximum values (Sebastian Pölsterl)
- Remove mention of removed option --enable-docs (Tomeu Vizoso)
+ - Fix sebp's name in NEWS (Tomeu Vizoso)
3.0.3 12-Dec-2011
- Convert all modifier constants to Gdk.ModifierType (Manuel Quiñones)
Metadata-Version: 1.0
Name: PyGObject
-Version: 3.0.4
+Version: 3.1.0
Summary: Python bindings for GObject
Home-page: http://www.pygtk.org/
Author: James Henstridge
Maintainer: Johan Dahlin
Maintainer-email: johan@gnome.org
License: GNU LGPL
-Download-url: ftp://ftp.gnome.org/pub/GNOME/sources/pygobject/3.0/pygobject-3.0.4.tar.gz
+Download-url: ftp://ftp.gnome.org/pub/GNOME/sources/pygobject/3.1/pygobject-3.1.0.tar.gz
Description: Python bindings for GLib and GObject
Platform: POSIX, Windows
Classifier: Development Status :: 5 - Production/Stable
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.68 for pygobject 3.0.4.
+# Generated by GNU Autoconf 2.68 for pygobject 3.1.0.
#
# Report bugs to <http://bugzilla.gnome.org/enter_bug.cgi?product=pygobject>.
#
# Identity of this package.
PACKAGE_NAME='pygobject'
PACKAGE_TARNAME='pygobject'
-PACKAGE_VERSION='3.0.4'
-PACKAGE_STRING='pygobject 3.0.4'
+PACKAGE_VERSION='3.1.0'
+PACKAGE_STRING='pygobject 3.1.0'
PACKAGE_BUGREPORT='http://bugzilla.gnome.org/enter_bug.cgi?product=pygobject'
PACKAGE_URL=''
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
-\`configure' configures pygobject 3.0.4 to adapt to many kinds of systems.
+\`configure' configures pygobject 3.1.0 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
if test -n "$ac_init_help"; then
case $ac_init_help in
- short | recursive ) echo "Configuration of pygobject 3.0.4:";;
+ short | recursive ) echo "Configuration of pygobject 3.1.0:";;
esac
cat <<\_ACEOF
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
-pygobject configure 3.0.4
+pygobject configure 3.1.0
generated by GNU Autoconf 2.68
Copyright (C) 2010 Free Software Foundation, Inc.
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
-It was created by pygobject $as_me 3.0.4, which was
+It was created by pygobject $as_me 3.1.0, which was
generated by GNU Autoconf 2.68. Invocation command line was
$ $0 $@
PYGOBJECT_MAJOR_VERSION=3
-$as_echo "#define PYGOBJECT_MINOR_VERSION 0" >>confdefs.h
+$as_echo "#define PYGOBJECT_MINOR_VERSION 1" >>confdefs.h
-PYGOBJECT_MINOR_VERSION=0
+PYGOBJECT_MINOR_VERSION=1
-$as_echo "#define PYGOBJECT_MICRO_VERSION 4" >>confdefs.h
+$as_echo "#define PYGOBJECT_MICRO_VERSION 0" >>confdefs.h
-PYGOBJECT_MICRO_VERSION=4
+PYGOBJECT_MICRO_VERSION=0
ac_config_headers="$ac_config_headers config.h"
# Define the identity of the package.
PACKAGE='pygobject'
- VERSION='3.0.4'
+ VERSION='3.1.0'
cat >>confdefs.h <<_ACEOF
Report bugs to <bug-libtool@gnu.org>."
lt_cl_version="\
-pygobject config.lt 3.0.4
+pygobject config.lt 3.1.0
configured by $0, generated by GNU Autoconf 2.68.
Copyright (C) 2010 Free Software Foundation, Inc.
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
-This file was extended by pygobject $as_me 3.0.4, which was
+This file was extended by pygobject $as_me 3.1.0, which was
generated by GNU Autoconf 2.68. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
-pygobject config.status 3.0.4
+pygobject config.status 3.1.0
configured by $0, generated by GNU Autoconf 2.68,
with options \\"\$ac_cs_config\\"
dnl the pygobject version number
m4_define(pygobject_major_version, 3)
-m4_define(pygobject_minor_version, 0)
-m4_define(pygobject_micro_version, 4)
+m4_define(pygobject_minor_version, 1)
+m4_define(pygobject_micro_version, 0)
m4_define(pygobject_version, pygobject_major_version.pygobject_minor_version.pygobject_micro_version)
dnl versions of packages we require ...
data->user_data = user_data; Py_XINCREF(user_data);
data->iochannel = self; Py_INCREF(self);
- handler_id = g_io_add_watch_full(((PyGIOChannel *) self)->channel,
+ handler_id = g_io_add_watch_full(iochannel,
priority, condition,
pyg_iowatch_marshal, data,
(GDestroyNotify) pyg_iowatch_data_free);
_PyGLib_API->unblock_threads = unblock_threads_func;
}
-
/**
- * pyglib_error_check:
+ * pyglib_error_marshal:
* @error: a pointer to the GError.
*
- * Checks to see if the GError has been set. If the error has been
- * set, then the glib.GError Python exception will be raised, and
- * the GError cleared.
+ * Checks to see if @error has been set. If @error has been set, then a
+ * GLib.GError Python exception object is returned (but not raised).
*
- * Returns: True if an error was set.
+ * Returns: a GLib.GError Python exception object, or NULL.
*/
-gboolean
-pyglib_error_check(GError **error)
+PyObject *
+pyglib_error_marshal (GError **error)
{
PyGILState_STATE state;
PyObject *exc_type;
PyObject *exc_instance;
PyObject *d;
- g_return_val_if_fail(error != NULL, FALSE);
+ g_return_val_if_fail(error != NULL, NULL);
if (*error == NULL)
- return FALSE;
-
+ return NULL;
+
state = pyglib_gil_state_ensure();
exc_type = _PyGLib_API->gerror_exception;
} else {
PyObject_SetAttrString(exc_instance, "message", Py_None);
}
+
+ pyglib_gil_state_release(state);
+ return exc_instance;
+}
+
+/**
+ * pyglib_error_check:
+ * @error: a pointer to the GError.
+ *
+ * Checks to see if the GError has been set. If the error has been
+ * set, then the glib.GError Python exception will be raised, and
+ * the GError cleared.
+ *
+ * Returns: True if an error was set.
+ */
+gboolean
+pyglib_error_check(GError **error)
+{
+ PyGILState_STATE state;
+ PyObject *exc_instance;
+
+ g_return_val_if_fail(error != NULL, FALSE);
+ if (*error == NULL)
+ return FALSE;
+
+ state = pyglib_gil_state_ensure();
+
+ exc_instance = pyglib_error_marshal (error);
PyErr_SetObject(_PyGLib_API->gerror_exception, exc_instance);
Py_DECREF(exc_instance);
g_clear_error(error);
py_message = PyObject_GetAttrString(value, "message");
if (!py_message || !PYGLIB_PyUnicode_Check(py_message)) {
bad_gerror_message = "gi._glib.GError instances must have a 'message' string attribute";
+ Py_XDECREF(py_message);
goto bad_gerror;
}
if (!py_domain || !PYGLIB_PyUnicode_Check(py_domain)) {
bad_gerror_message = "gi._glib.GError instances must have a 'domain' string attribute";
Py_DECREF(py_message);
+ Py_XDECREF(py_domain);
goto bad_gerror;
}
bad_gerror_message = "gi._glib.GError instances must have a 'code' int attribute";
Py_DECREF(py_message);
Py_DECREF(py_domain);
+ Py_XDECREF(py_code);
goto bad_gerror;
}
void pyglib_gil_state_release(PyGILState_STATE state);
int pyglib_enable_threads(void);
gboolean pyglib_error_check(GError **error);
+PyObject *pyglib_error_marshal (GError **error);
gboolean pyglib_gerror_exception_check(GError **error);
PyObject *pyglib_register_exception_for_domain(gchar *name,
gint error_domain);
PySignalWatchSource *real_source = (PySignalWatchSource *)source;
GPollFD *poll_fd = &real_source->fd;
unsigned char dummy;
- gssize ret;
if (poll_fd->revents & G_IO_IN)
- ret = read(poll_fd->fd, &dummy, 1);
+ (void) read(poll_fd->fd, &dummy, 1);
#endif
state = pyglib_gil_state_ensure();
}
static PyObject *
-_wrap_g_main_loop_quit (PyGMainLoop *self)
+_wrap_g_main_loop_quit (PyGMainLoop *self, PyObject *args, PyObject *kwargs)
{
g_main_loop_quit(self->loop);
static PyMethodDef _PyGMainLoop_methods[] = {
{ "get_context", (PyCFunction)_wrap_g_main_loop_get_context, METH_NOARGS },
{ "is_running", (PyCFunction)_wrap_g_main_loop_is_running, METH_NOARGS },
- { "quit", (PyCFunction)_wrap_g_main_loop_quit, METH_NOARGS },
+ { "quit", (PyCFunction)_wrap_g_main_loop_quit, METH_VARARGS|METH_KEYWORDS },
{ "run", (PyCFunction)_wrap_g_main_loop_run, METH_NOARGS },
{ NULL, NULL, 0 }
};
/* float the wrapper ref here because we are going to orphan it
* so we don't destroy the wrapper. The next call to pygobject_new_full
* will take the ref */
- pygobject_ref_float (wrapper);
+ pygobject_ref_float ((PyGObject *) wrapper);
args = PyTuple_New(0);
kwargs = PyDict_New();
if (Py_TYPE(wrapper)->tp_init(wrapper, args, kwargs))
property_name = PYGLIB_PyUnicode_AsString(py_property);
- pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(self->obj),
+ pspec = g_object_class_find_property(class,
property_name);
if (!pspec) {
PyErr_Format(PyExc_TypeError,
GIEnumInfo *info;
gint n_values;
GEnumValue *g_enum_values;
- GType g_type;
+ int i;
const gchar *type_name;
+ GType g_type;
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O:enum_add_make_new_gtype",
n_values = g_enum_info_get_n_values (info);
g_enum_values = g_new0 (GEnumValue, n_values + 1);
- for (int i=0; i < n_values; i++) {
+ for (i = 0; i < n_values; i++) {
GIValueInfo *value_info;
GEnumValue *enum_value;
const gchar *name;
GIEnumInfo *info;
gint n_values;
GFlagsValue *g_flags_values;
- GType g_type;
+ int i;
const gchar *type_name;
+ GType g_type;
if (!PyArg_ParseTupleAndKeywords (args, kwargs,
"O:flags_add_make_new_gtype",
n_values = g_enum_info_get_n_values (info);
g_flags_values = g_new0 (GFlagsValue, n_values + 1);
- for (int i=0; i < n_values; i++) {
+ for (i = 0; i < n_values; i++) {
GIValueInfo *value_info;
GFlagsValue *flags_value;
const gchar *name;
def __repr__(self):
return '<GLib.Variant(%s)>' % getattr(self, 'print')(True)
+ def __eq__(self, other):
+ try:
+ return self.equal(other)
+ except TypeError:
+ return False
+
+ def __ne__(self, other):
+ try:
+ return not self.equal(other)
+ except TypeError:
+ return True
+
+ def __hash__(self):
+ # We're not using just hash(self.unpack()) because otherwise we'll have
+ # hash collisions between the same content in different variant types,
+ # which will cause a performance issue in set/dict/etc.
+ return hash((self.get_type_string(), self.unpack()))
+
def unpack(self):
'''Decompose a GVariant into a native Python object.'''
def __len__(self):
if self.get_type_string() in ['s', 'o', 'g']:
return len(self.get_string())
+ # Array, dict, tuple
if self.get_type_string().startswith('a') or self.get_type_string().startswith('('):
return self.n_children()
raise TypeError('GVariant type %s does not have a length' % self.get_type_string())
raise TypeError('GVariant type %s is not a container' % self.get_type_string())
+ #
+ # Pythonic bool operations
+ #
+ def __nonzero__(self):
+ return self.__bool__()
+
+ def __bool__(self):
+ if self.get_type_string() in ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']:
+ return self.unpack() != 0
+ if self.get_type_string() in ['b']:
+ return self.get_boolean()
+ if self.get_type_string() in ['s', 'o', 'g']:
+ return len(self.get_string()) != 0
+ # Array, dict, tuple
+ if self.get_type_string().startswith('a') or self.get_type_string().startswith('('):
+ return self.n_children() != 0
+ if self.get_type_string() in ['v']:
+ # unpack works recursively, hence bool also works recursively
+ return bool(self.unpack())
+ # Everything else is True
+ return True
+
def keys(self):
if not self.get_type_string().startswith('a{'):
return TypeError, 'GVariant type %s is not a dictionary' % self.get_type_string()
if first_action is not None and on_change is not None:
if user_data is None:
- action.connect('changed', on_change)
+ first_action.connect('changed', on_change)
else:
- action.connect('changed', on_change, user_data)
+ first_action.connect('changed', on_change, user_data)
ActionGroup = override(ActionGroup)
__all__.append('ActionGroup')
self.set_destroy_with_parent(True)
# NO_SEPARATOR has been removed from Gtk 3
- try:
- if flags & Gtk.DialogFlags.NO_SEPARATOR:
- self.set_has_separator(False)
- except AttributeError:
+ if hasattr(Gtk.DialogFlags, "NO_SEPARATOR") and (flags & Gtk.DialogFlags.NO_SEPARATOR):
+ self.set_has_separator(False)
import warnings
warnings.warn("Gtk.DialogFlags.NO_SEPARATOR has been depricated since Gtk+-3.0", DeprecationWarning)
break;
}
case GI_TYPE_TAG_ERROR:
- if (pyglib_error_check ( (GError **) &arg->v_pointer)) {
- PyObject *err_type;
- PyObject *err_value;
- PyObject *err_trace;
- PyErr_Fetch (&err_type, &err_value, &err_trace);
- Py_XDECREF (err_type);
- Py_XDECREF (err_trace);
- object = err_value;
- } else {
- object = Py_None;
- Py_INCREF (object);
- break;
- }
+ {
+ GError *error = (GError *) arg->v_pointer;
+ if (error != NULL && transfer == GI_TRANSFER_NOTHING) {
+ /* If we have not been transferred the ownership we must copy
+ * the error, because pyglib_error_check() is going to free it.
+ */
+ error = g_error_copy (error);
+ }
+
+ if (pyglib_error_check (&error)) {
+ PyObject *err_type;
+ PyObject *err_value;
+ PyObject *err_trace;
+ PyErr_Fetch (&err_type, &err_value, &err_trace);
+ Py_XDECREF (err_type);
+ Py_XDECREF (err_trace);
+ object = err_value;
+ } else {
+ object = Py_None;
+ Py_INCREF (object);
+ break;
+ }
+ }
}
return object;
g_base_info_unref (interface);
}
+ case GI_TYPE_TAG_ERROR:
+ case GI_TYPE_TAG_GHASH:
case GI_TYPE_TAG_GLIST:
case GI_TYPE_TAG_GSLIST:
g_args[i].v_pointer = * (gpointer *) args[i];
ffi_closure *fficlosure;
/* Begin by cleaning up old async functions */
- g_slist_foreach (async_free_list, (GFunc) _pygi_invoke_closure_free, NULL);
- g_slist_free (async_free_list);
+ g_slist_free_full (async_free_list, (GDestroyNotify) _pygi_invoke_closure_free);
async_free_list = NULL;
/* Build the closure itself */
Py_RETURN_NONE;
}
-static PyMethodDef _gi_cairo_functions[] = {0,};
+static PyMethodDef _gi_cairo_functions[] = { {0,} };
PYGLIB_MODULE_START(_gi_cairo, "_gi_cairo")
{
#if PY_VERSION_HEX < 0x03000000
gboolean was_processed)
{
if (was_processed) {
- GArray *array_;
+ GArray *array_ = NULL;
+ GPtrArray *ptr_array_ = NULL;
PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
/* If this isn't a garray create one to help process variable sized
if (array_ == NULL)
return;
+ } else if (sequence_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
+ ptr_array_ = (GPtrArray *) data;
} else {
array_ = (GArray *) data;
}
/* clean up items first */
if (sequence_cache->item_cache->from_py_cleanup != NULL) {
gsize i;
+ guint len = (array_ != NULL) ? array_->len : ptr_array_->len;
PyGIMarshalCleanupFunc cleanup_func =
sequence_cache->item_cache->from_py_cleanup;
- for(i = 0; i < array_->len; i++) {
+ for(i = 0; i < len; i++) {
cleanup_func (state,
sequence_cache->item_cache,
- g_array_index (array_, gpointer, i),
+ (array_ != NULL) ? g_array_index (array_, gpointer, i) : g_ptr_array_index (ptr_array_, i),
TRUE);
}
}
g_array_free (array_, arg_cache->transfer == GI_TRANSFER_NOTHING);
} else if (state->failed ||
arg_cache->transfer == GI_TRANSFER_NOTHING) {
- g_array_free (array_, TRUE);
+ if (array_ != NULL)
+ g_array_free (array_, TRUE);
+ else
+ g_ptr_array_free (ptr_array_, TRUE);
}
}
}
gpointer data,
gboolean was_processed)
{
- PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
-
if (arg_cache->transfer == GI_TRANSFER_EVERYTHING ||
arg_cache->transfer == GI_TRANSFER_CONTAINER) {
- GArray *array_;
+ GArray *array_ = NULL;
+ GPtrArray *ptr_array_ = NULL;
PyGISequenceCache *sequence_cache = (PyGISequenceCache *)arg_cache;
/* If this isn't a garray create one to help process variable sized
if (array_ == NULL)
return;
-
+
+ } else if (sequence_cache->array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
+ ptr_array_ = (GPtrArray *) data;
} else {
array_ = (GArray *) data;
}
if (sequence_cache->item_cache->to_py_cleanup != NULL) {
gsize i;
+ guint len = (array_ != NULL) ? array_->len : ptr_array_->len;
PyGIMarshalCleanupFunc cleanup_func = sequence_cache->item_cache->to_py_cleanup;
- for (i = 0; i < array_->len; i++) {
+ for (i = 0; i < len; i++) {
cleanup_func (state,
sequence_cache->item_cache,
- g_array_index (array_, gpointer, i),
+ (array_ != NULL) ? g_array_index (array_, gpointer, i) : g_ptr_array_index (ptr_array_, i),
was_processed);
}
}
- g_array_free (array_, TRUE);
+ if (array_ != NULL)
+ g_array_free (array_, TRUE);
+ else
+ g_ptr_array_free (ptr_array_, TRUE);
}
}
&item))
goto err;
- list_ = g_list_append (list_, item.v_pointer);
+ list_ = g_list_prepend (list_, item.v_pointer);
continue;
err:
/* FIXME: clean up list
return FALSE;
}
- arg->v_pointer = list_;
+ arg->v_pointer = g_list_reverse (list_);
return TRUE;
}
&item))
goto err;
- list_ = g_slist_append (list_, item.v_pointer);
+ list_ = g_slist_prepend (list_, item.v_pointer);
continue;
err:
/* FIXME: Clean up list
return FALSE;
}
- arg->v_pointer = list_;
+ arg->v_pointer = g_slist_reverse (list_);
return TRUE;
}
#include <string.h>
#include <time.h>
+#include <pyglib.h>
#include <pygobject.h>
#include <pyglib-python-compat.h>
PyGISequenceCache *seq_cache = (PyGISequenceCache *)arg_cache;
gsize processed_items = 0;
- array_ = arg->v_pointer;
-
/* GArrays make it easier to iterate over arrays
* with different element sizes but requires that
* we allocate a GArray if the argument was a C array
g_assert(arg->v_pointer != NULL);
len = seq_cache->fixed_size;
} else if (seq_cache->is_zero_terminated) {
- g_assert(arg->v_pointer != NULL);
- if(seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
+ if (arg->v_pointer == NULL) {
+ len = 0;
+ } else if (seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
len = strlen (arg->v_pointer);
} else {
len = g_strv_length ((gchar **)arg->v_pointer);
g_free (array_->data);
array_->data = arg->v_pointer;
array_->len = len;
+ } else {
+ array_ = arg->v_pointer;
}
if (seq_cache->item_cache->type_tag == GI_TYPE_TAG_UINT8) {
PyGIArgCache *arg_cache,
GIArgument *arg)
{
+ GError *error = arg->v_pointer;
PyObject *py_obj = NULL;
- PyErr_Format (PyExc_NotImplementedError,
- "Marshalling for gerror to PyObject is not implemented");
- return py_obj;
+ py_obj = pyglib_error_marshal(&error);
+
+ if (arg_cache->transfer == GI_TRANSFER_EVERYTHING && error != NULL) {
+ g_error_free (error);
+ }
+
+ if (py_obj != NULL) {
+ return py_obj;
+ } else {
+ Py_RETURN_NONE;
+ }
}
PyObject *
arg.v_boolean = g_value_get_boolean (&value);
break;
case GI_TYPE_TAG_INT8:
+ arg.v_int8 = g_value_get_schar (&value);
+ break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
+ if (G_VALUE_HOLDS_LONG (&value))
+ arg.v_long = g_value_get_long (&value);
+ else
+ arg.v_int = g_value_get_int (&value);
+ break;
case GI_TYPE_TAG_INT64:
- arg.v_int = g_value_get_int (&value);
+ if (G_VALUE_HOLDS_LONG (&value))
+ arg.v_long = g_value_get_long (&value);
+ else
+ arg.v_int64 = g_value_get_int64 (&value);
break;
case GI_TYPE_TAG_UINT8:
+ arg.v_uint8 = g_value_get_uchar (&value);
+ break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
+ if (G_VALUE_HOLDS_ULONG (&value))
+ arg.v_ulong = g_value_get_ulong (&value);
+ else
+ arg.v_uint = g_value_get_uint (&value);
+ break;
case GI_TYPE_TAG_UINT64:
- arg.v_uint = g_value_get_uint (&value);
+ if (G_VALUE_HOLDS_ULONG (&value))
+ arg.v_ulong = g_value_get_ulong (&value);
+ else
+ arg.v_uint64 = g_value_get_uint64 (&value);
break;
case GI_TYPE_TAG_FLOAT:
arg.v_float = g_value_get_float (&value);
g_value_set_boolean (&value, arg.v_boolean);
break;
case GI_TYPE_TAG_INT8:
+ g_value_set_schar (&value, arg.v_int8);
+ break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
+ if (G_VALUE_HOLDS_LONG (&value))
+ g_value_set_long (&value, arg.v_long);
+ else
+ g_value_set_int (&value, arg.v_int);
+ break;
case GI_TYPE_TAG_INT64:
- g_value_set_int (&value, arg.v_int);
+ if (G_VALUE_HOLDS_LONG (&value))
+ g_value_set_long (&value, arg.v_long);
+ else
+ g_value_set_int64 (&value, arg.v_int64);
break;
case GI_TYPE_TAG_UINT8:
+ g_value_set_uchar (&value, arg.v_uint8);
+ break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
+ if (G_VALUE_HOLDS_ULONG (&value))
+ g_value_set_ulong (&value, arg.v_ulong);
+ else
+ g_value_set_uint (&value, arg.v_uint);
+ break;
case GI_TYPE_TAG_UINT64:
- g_value_set_uint (&value, arg.v_uint);
+ if (G_VALUE_HOLDS_ULONG (&value))
+ g_value_set_ulong (&value, arg.v_ulong);
+ else
+ g_value_set_uint64 (&value, arg.v_uint64);
break;
case GI_TYPE_TAG_FLOAT:
g_value_set_float (&value, arg.v_float);
EXTRA_DIST = \
compathelper.py \
runtests.py \
+ runtests-windows.py \
testmodule.py \
test-floating.h \
test-thread.h \
test_gdbus.py \
test_overrides.py
-EXTRA_DIST = compathelper.py runtests.py testmodule.py test-floating.h \
- test-thread.h test-unknown.h te_ST@nouppera \
- org.gnome.test.gschema.xml $(TEST_FILES_STATIC) \
+EXTRA_DIST = compathelper.py runtests.py runtests-windows.py \
+ testmodule.py test-floating.h test-thread.h test-unknown.h \
+ te_ST@nouppera org.gnome.test.gschema.xml $(TEST_FILES_STATIC) \
$(TEST_FILES_GI)
DBUS_LAUNCH = $(shell which dbus-launch)
RUN_TESTS_ENV_VARS = \
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+import os
+import sys
+import glob
+import unittest
+
+os.environ['PYGTK_USE_GIL_STATE_API'] = ''
+sys.path.insert(0, os.path.dirname(__file__))
+sys.argv.append('--g-fatal-warnings')
+
+from gi.repository import GObject
+GObject.threads_init()
+
+
+SKIP_FILES = ['runtests',
+ 'test_mainloop', # no os.fork on windows
+ 'test_subprocess'] # blocks on testChildWatch
+
+
+if __name__ == '__main__':
+ testdir = os.path.split(os.path.abspath(__file__))[0]
+ os.chdir(testdir)
+
+ def gettestnames():
+ files = glob.glob('*.py')
+ names = map(lambda x: x[:-3], files)
+ map(names.remove, SKIP_FILES)
+ return names
+
+ suite = unittest.TestSuite()
+ loader = unittest.TestLoader()
+
+ for name in gettestnames():
+ try:
+ suite.addTest(loader.loadTestsFromName(name))
+ except Exception, e:
+ print 'Could not load %s: %s' % (name, e)
+
+ testRunner = unittest.TextTestRunner()
+ testRunner.verbosity = 2
+ testRunner.run(suite)
from gi.repository import GObject
from gi.repository import GLib
+from gi.repository import Gio
from gi.repository import Regress as Everything
if sys.version_info < (3, 0):
called = False
main_loop = GObject.MainLoop()
- def testCallback(self):
+ def test_callback(self):
TestCallbacks.called = False
def callback():
TestCallbacks.called = True
Everything.test_simple_callback(callback)
self.assertTrue(TestCallbacks.called)
- def testCallbackException(self):
+ def test_callback_exception(self):
"""
This test ensures that we get errors from callbacks correctly
and in particular that we do not segv when callbacks fail
except ZeroDivisionError:
pass
- def testDoubleCallbackException(self):
+ def test_double_callback_exception(self):
"""
This test ensures that we get errors from callbacks correctly
and in particular that we do not segv when callbacks fail
except ZeroDivisionError:
pass
- def testReturnValueCallback(self):
+ def test_return_value_callback(self):
TestCallbacks.called = False
def callback():
TestCallbacks.called = True
self.assertEquals(Everything.test_callback(callback), 44)
self.assertTrue(TestCallbacks.called)
- def testCallbackAsync(self):
+ def test_callback_async(self):
TestCallbacks.called = False
def callback(foo):
TestCallbacks.called = True
self.assertEquals(44, i);
self.assertTrue(TestCallbacks.called)
- def testCallbackScopeCall(self):
+ def test_callback_scope_call(self):
TestCallbacks.called = 0
def callback():
TestCallbacks.called += 1
Everything.test_multi_callback(callback)
self.assertEquals(TestCallbacks.called, 2)
- def testCallbackUserdata(self):
+ def test_callback_userdata(self):
TestCallbacks.called = 0
def callback(userdata):
self.assertEquals(userdata, "Test%d" % TestCallbacks.called)
self.assertEquals(TestCallbacks.called, 100)
- def testCallbackUserdataRefCount(self):
+ def test_callback_userdata_refcount(self):
TestCallbacks.called = False
def callback(userdata):
TestCallbacks.called = True
self.assertEquals(start_ref_count, end_ref_count)
- def testAsyncReadyCallback(self):
+ def test_async_ready_callback(self):
TestCallbacks.called = False
TestCallbacks.main_loop = GObject.MainLoop()
self.assertTrue(TestCallbacks.called)
- def testCallbackDestroyNotify(self):
+ def test_callback_destroy_notify(self):
def callback(user_data):
TestCallbacks.called = True
return 42
self.assertTrue(TestCallbacks.called)
self.assertEquals(Everything.test_callback_thaw_notifications(), 42)
- def testCallbackInMethods(self):
+ def test_callback_in_methods(self):
object_ = Everything.TestObj()
def callback():
obj_ = Everything.TestObj.new_callback(callbackWithUserData, None)
self.assertTrue(TestCallbacks.called)
- def testCallbackNone(self):
+ def test_callback_none(self):
# make sure this doesn't assert or crash
Everything.test_simple_callback(None)
+ def test_callback_gerror(self):
+ def callback(error):
+ self.assertEqual(error.message, 'regression test error')
+ self.assertTrue('g-io' in error.domain)
+ self.assertEqual(error.code, Gio.IOErrorEnum.NOT_SUPPORTED)
+ TestCallbacks.called = True
+
+ TestCallbacks.called = False
+ Everything.test_gerror_callback(callback)
+ self.assertTrue(TestCallbacks.called)
+
+ def test_callback_null_gerror(self):
+ def callback(error):
+ self.assertEqual(error, None)
+ TestCallbacks.called = True
+
+ TestCallbacks.called = False
+ Everything.test_null_gerror_callback(callback)
+ self.assertTrue(TestCallbacks.called)
+
+ def test_callback_owned_gerror(self):
+ def callback(error):
+ self.assertEqual(error.message, 'regression test owned error')
+ self.assertTrue('g-io' in error.domain)
+ self.assertEqual(error.code, Gio.IOErrorEnum.PERMISSION_DENIED)
+ TestCallbacks.called = True
+
+ TestCallbacks.called = False
+ Everything.test_owned_gerror_callback(callback)
+ self.assertTrue(TestCallbacks.called)
+
+ def test_callback_hashtable(self):
+ def callback(data):
+ self.assertEqual(data, mydict)
+ mydict['new'] = 42
+ TestCallbacks.called = True
+
+ mydict = { 'foo': 1, 'bar': 2 }
+ TestCallbacks.called = False
+ Everything.test_hash_table_callback(mydict, callback)
+ self.assertTrue(TestCallbacks.called)
+ self.assertEqual(mydict, { 'foo': 1, 'bar': 2, 'new': 42 })
+
class TestClosures(unittest.TestCase):
def test_int_arg(self):
def callback(num):
def test_array_zero_terminated_return(self):
self.assertEquals(['0', '1', '2'], GIMarshallingTests.array_zero_terminated_return())
+ def test_array_zero_terminated_return_null(self):
+ self.assertEquals([], GIMarshallingTests.array_zero_terminated_return_null())
+
def test_array_zero_terminated_in(self):
GIMarshallingTests.array_zero_terminated_in(Sequence(['0', '1', '2']))
def test_array_gvariant_none_in(self):
v = [GLib.Variant("i", 27), GLib.Variant("s", "Hello")]
- self.assertEquals([27, "Hello"], map(GLib.Variant.unpack, GIMarshallingTests.array_gvariant_none_in(v)))
+ returned = [GLib.Variant.unpack(r) for r in GIMarshallingTests.array_gvariant_none_in(v)]
+ self.assertEquals([27, "Hello"], returned)
def test_array_gvariant_container_in(self):
v = [GLib.Variant("i", 27), GLib.Variant("s", "Hello")]
- self.assertEquals([27, "Hello"], map(GLib.Variant.unpack, GIMarshallingTests.array_gvariant_none_in(v)))
+ returned = [GLib.Variant.unpack(r) for r in GIMarshallingTests.array_gvariant_none_in(v)]
+ self.assertEquals([27, "Hello"], returned)
def test_array_gvariant_full_in(self):
v = [GLib.Variant("i", 27), GLib.Variant("s", "Hello")]
- self.assertEquals([27, "Hello"], map(GLib.Variant.unpack, GIMarshallingTests.array_gvariant_none_in(v)))
+ returned = [GLib.Variant.unpack(r) for r in GIMarshallingTests.array_gvariant_none_in(v)]
+ self.assertEquals([27, "Hello"], returned)
def test_bytearray_gvariant(self):
- v = GLib.Variant.new_bytestring("foo")
- self.assertEquals(v.get_bytestring(), "foo")
+ v = GLib.Variant.new_bytestring(b"foo")
+ self.assertEquals(v.get_bytestring(), b"foo")
class TestGArray(unittest.TestCase):
def test_gerror_array_in_crash(self):
self.assertRaises(GObject.GError, GIMarshallingTests.gerror_array_in, [1, 2, 3])
+class TestGErrorOut(unittest.TestCase):
+ # See https://bugzilla.gnome.org/show_bug.cgi?id=666098
+ def test_gerror_out(self):
+ error, debug = GIMarshallingTests.gerror_out()
+
+ self.assertIsInstance(error, GObject.GError)
+ self.assertEquals(error.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
+ self.assertEquals(error.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
+ self.assertEquals(error.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
+ self.assertEquals(debug, GIMarshallingTests.CONSTANT_GERROR_DEBUG_MESSAGE)
+
+class TestGErrorOutTransferNone(unittest.TestCase):
+ # See https://bugzilla.gnome.org/show_bug.cgi?id=666098
+ def test_gerror_out_transfer_none(self):
+ error, debug = GIMarshallingTests.gerror_out_transfer_none()
+
+ self.assertIsInstance(error, GObject.GError)
+ self.assertEquals(error.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
+ self.assertEquals(error.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
+ self.assertEquals(error.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
+ self.assertEquals(GIMarshallingTests.CONSTANT_GERROR_DEBUG_MESSAGE, debug)
+
+class TestGErrorReturn(unittest.TestCase):
+ # See https://bugzilla.gnome.org/show_bug.cgi?id=666098
+ def test_return_gerror(self):
+ error = GIMarshallingTests.gerror_return()
+
+ self.assertIsInstance(error, GObject.GError)
+ self.assertEquals(error.domain, GIMarshallingTests.CONSTANT_GERROR_DOMAIN)
+ self.assertEquals(error.code, GIMarshallingTests.CONSTANT_GERROR_CODE)
+ self.assertEquals(error.message, GIMarshallingTests.CONSTANT_GERROR_MESSAGE)
+
class TestKeywordArgs(unittest.TestCase):
def test_calling(self):
kw_func = GIMarshallingTests.int_three_in_three_out
d2 = d.copy()
GIMarshallingTests.int_three_in_three_out(1, c=4, **d)
self.assertEqual(d, d2)
+
+class TestPropertiesObject(unittest.TestCase):
+
+ def setUp(self):
+ self.obj = GIMarshallingTests.PropertiesObject()
+
+ def test_boolean(self):
+ self.assertEqual(self.obj.props.some_boolean, False)
+ self.obj.props.some_boolean = True
+ self.assertEqual(self.obj.props.some_boolean, True)
+
+ @unittest.expectedFailure
+ def test_char(self):
+ # gobject-introspection thinks it has a guint8 type tag, which is wrong
+ self.assertEqual(self.obj.props.some_char, 0)
+ self.obj.props.some_char = GObject.G_MAXINT8
+ self.assertEqual(self.obj.props.some_char, GObject.G_MAXINT8)
+
+ def test_uchar(self):
+ self.assertEqual(self.obj.props.some_uchar, 0)
+ self.obj.props.some_uchar = GObject.G_MAXUINT8
+ self.assertEqual(self.obj.props.some_uchar, GObject.G_MAXUINT8)
+
+ def test_int(self):
+ self.assertEqual(self.obj.props.some_int, 0)
+ self.obj.props.some_int = GObject.G_MAXINT
+ self.assertEqual(self.obj.props.some_int, GObject.G_MAXINT)
+
+ def test_uint(self):
+ self.assertEqual(self.obj.props.some_uint, 0)
+ self.obj.props.some_uint = GObject.G_MAXUINT
+ self.assertEqual(self.obj.props.some_uint, GObject.G_MAXUINT)
+
+ def test_long(self):
+ self.assertEqual(self.obj.props.some_long, 0)
+ self.obj.props.some_long = GObject.G_MAXLONG
+ self.assertEqual(self.obj.props.some_long, GObject.G_MAXLONG)
+
+ def test_ulong(self):
+ self.assertEqual(self.obj.props.some_ulong, 0)
+ self.obj.props.some_ulong = GObject.G_MAXULONG
+ self.assertEqual(self.obj.props.some_ulong, GObject.G_MAXULONG)
+
+ def test_int64(self):
+ self.assertEqual(self.obj.props.some_int64, 0)
+ self.obj.props.some_int64 = GObject.G_MAXINT64
+ self.assertEqual(self.obj.props.some_int64, GObject.G_MAXINT64)
+
+ def test_uint64(self):
+ self.assertEqual(self.obj.props.some_uint64, 0)
+ self.obj.props.some_uint64 = GObject.G_MAXUINT64
+ self.assertEqual(self.obj.props.some_uint64, GObject.G_MAXUINT64)
+
+ def test_float(self):
+ self.assertEqual(self.obj.props.some_float, 0)
+ self.obj.props.some_float = GObject.G_MAXFLOAT
+ self.assertEqual(self.obj.props.some_float, GObject.G_MAXFLOAT)
+
+ def test_double(self):
+ self.assertEqual(self.obj.props.some_double, 0)
+ self.obj.props.some_double = GObject.G_MAXDOUBLE
+ self.assertEqual(self.obj.props.some_double, GObject.G_MAXDOUBLE)
self.assertEqual(GLib.Variant.split_signature('(a{iv}(ii)((ss)a{s(ss)}))'),
['a{iv}', '(ii)', '((ss)a{s(ss)})'])
+ def test_variant_hash(self):
+ v1 = GLib.Variant('s', 'somestring')
+ v2 = GLib.Variant('s', 'somestring')
+ v3 = GLib.Variant('s', 'somestring2')
+
+ self.assertTrue(v2 in set([v1, v3]))
+ self.assertTrue(v2 in frozenset([v1, v3]))
+ self.assertTrue(v2 in {v1: '1', v3:'2' })
+
+ def test_variant_compare(self):
+ # Check if identical GVariant are equal
+
+ def assert_equal(vtype, value):
+ self.assertEqual(GLib.Variant(vtype, value), GLib.Variant(vtype, value))
+
+ def assert_not_equal(vtype1, value1, vtype2, value2):
+ self.assertNotEqual(GLib.Variant(vtype1, value1), GLib.Variant(vtype2, value2))
+
+ numbers = ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']
+ for num in numbers:
+ assert_equal(num, 42)
+ assert_not_equal(num, 42, num, 41)
+ assert_not_equal(num, 42, 's', '42')
+
+ assert_equal('s', 'something')
+ assert_not_equal('s', 'something', 's', 'somethingelse')
+ assert_not_equal('s', 'something', 'i', 1234)
+
+ assert_equal('g', 'dustybinqhogx')
+ assert_not_equal('g', 'dustybinqhogx', 'g', 'dustybin')
+ assert_not_equal('g', 'dustybinqhogx', 'i', 1234)
+
+ assert_equal('o', '/dev/null')
+ assert_not_equal('o', '/dev/null', 'o', '/dev/zero')
+ assert_not_equal('o', '/dev/null', 'i', 1234)
+
+ assert_equal('(s)', ('strtuple',))
+ assert_not_equal('(s)', ('strtuple',), '(s)', ('strtuple2',))
+
+ assert_equal('a{si}', {'str': 42})
+ assert_not_equal('a{si}', {'str': 42}, 'a{si}', {'str': 43})
+
+ assert_equal('v', GLib.Variant('i', 42))
+ assert_not_equal('v', GLib.Variant('i', 42), 'v', GLib.Variant('i', 43))
+
+ def test_variant_bool(self):
+ # Check if the GVariant bool matches the unpacked Pythonic bool
+
+ def assert_equals_bool(vtype, value):
+ self.assertEqual(bool(GLib.Variant(vtype, value)), bool(value))
+
+ # simple values
+ assert_equals_bool('b', True)
+ assert_equals_bool('b', False)
+
+ numbers = ['y', 'n', 'q', 'i', 'u', 'x', 't', 'h', 'd']
+ for number in numbers:
+ assert_equals_bool(number, 0)
+ assert_equals_bool(number, 1)
+
+ assert_equals_bool('s', '')
+ assert_equals_bool('g', '')
+ assert_equals_bool('s', 'something')
+ assert_equals_bool('o', '/dev/null')
+ assert_equals_bool('g', 'dustybinqhogx')
+
+ # arrays
+ assert_equals_bool('ab', [True])
+ assert_equals_bool('ab', [False])
+ for number in numbers:
+ assert_equals_bool('a'+number, [])
+ assert_equals_bool('a'+number, [0])
+ assert_equals_bool('as', [])
+ assert_equals_bool('as', [''])
+ assert_equals_bool('ao', [])
+ assert_equals_bool('ao', ['/'])
+ assert_equals_bool('ag', [])
+ assert_equals_bool('ag', [''])
+ assert_equals_bool('aai', [[]])
+
+ # tuples
+ assert_equals_bool('()', ())
+ for number in numbers:
+ assert_equals_bool('('+number+')', (0,))
+ assert_equals_bool('(s)', ('',))
+ assert_equals_bool('(o)', ('/',))
+ assert_equals_bool('(g)', ('',))
+ assert_equals_bool('(())', ((),))
+
+ # dictionaries
+ assert_equals_bool('a{si}', {})
+ assert_equals_bool('a{si}', {'': 0})
+
+ # complex types, always True
+ assert_equals_bool('(as)', ([],))
+ assert_equals_bool('a{s(i)}', {'': (0,)})
+
+ # variant types, recursive unpacking
+ assert_equals_bool('v', GLib.Variant('i', 0))
+ assert_equals_bool('v', GLib.Variant('i', 1))
+
class TestPango(unittest.TestCase):
def test_default_font_description(self):
projects / platform / upstream / pygobject2.git / commitdiff