Remove support for pointers to basic types as input-only argument and return value

There is no reason for an API to use such things, and g_function_info_invoke
broke such features.

https://bugzilla.gnome.org/show_bug.cgi?id=607759

3 files changed, 0 insertions, 890 deletions

diff --git a/tests/libtestgi.c b/tests/libtestgi.c
index c3899a6..a9edf21 100644
--- a/tests/libtestgi.c
+++ b/tests/libtestgi.c
@@ -21,28 +21,6 @@ test_gi_boolean_return_false (void)
     return FALSE;
 }
 
-/**
- * test_gi_boolean_return_ptr_true:
- * Returns: (transfer none):
- */
-gboolean *
-test_gi_boolean_return_ptr_true (void)
-{
-    static gboolean bool_ = TRUE;
-    return &bool_;
-}
-
-/**
- * test_gi_boolean_return_ptr_false:
- * Returns: (transfer none):
- */
-gboolean *
-test_gi_boolean_return_ptr_false (void)
-{
-    static gboolean bool_ = FALSE;
-    return &bool_;
-}
-
 void
 test_gi_boolean_in_true (gboolean bool_)
 {
@@ -56,26 +34,6 @@ test_gi_boolean_in_false (gboolean bool_)
 }
 
 /**
- * test_gi_boolean_in_ptr_true:
- * bool_: (in):
- */
-void
-test_gi_boolean_in_ptr_true (gboolean *bool_)
-{
-    g_assert (*bool_ == TRUE);
-}
-
-/**
- * test_gi_boolean_in_ptr_false:
- * bool_: (in):
- */
-void
-test_gi_boolean_in_ptr_false (gboolean *bool_)
-{
-    g_assert (*bool_ == FALSE);
-}
-
-/**
  * test_gi_boolean_out_true:
  * bool_: (out):
  */
@@ -132,28 +90,6 @@ test_gi_int8_return_min (void)
     return G_MININT8;
 }
 
-/**
- * test_gi_int8_return_ptr_max:
- * Returns: (transfer none):
- */
-gint8 *
-test_gi_int8_return_ptr_max (void)
-{
-    static gint8 int8 = G_MAXINT8;
-    return &int8;
-}
-
-/**
- * test_gi_int8_return_ptr_min:
- * Returns: (transfer none):
- */
-gint8 *
-test_gi_int8_return_ptr_min (void)
-{
-    static gint8 int8 = G_MININT8;
-    return &int8;
-}
-
 void
 test_gi_int8_in_max (gint8 int8)
 {
@@ -167,26 +103,6 @@ test_gi_int8_in_min (gint8 int8)
 }
 
 /**
- * test_gi_int8_in_ptr_max:
- * int8: (in):
- */
-void
-test_gi_int8_in_ptr_max (gint8 *int8)
-{
-    g_assert(*int8 == G_MAXINT8);
-}
-
-/**
- * test_gi_int8_in_ptr_min:
- * int8: (in):
- */
-void
-test_gi_int8_in_ptr_min (gint8 *int8)
-{
-    g_assert(*int8 == G_MININT8);
-}
-
-/**
  * test_gi_int8_out_max:
  * int8: (out):
  */
@@ -235,17 +151,6 @@ test_gi_uint8_return (void)
     return G_MAXUINT8;
 }
 
-/**
- * test_gi_uint8_return_ptr:
- * Returns: (transfer none):
- */
-guint8 *
-test_gi_uint8_return_ptr (void)
-{
-    static guint8 uint8 = G_MAXUINT8;
-    return &uint8;
-}
-
 void
 test_gi_uint8_in (guint8 uint8)
 {
@@ -253,16 +158,6 @@ test_gi_uint8_in (guint8 uint8)
 }
 
 /**
- * test_gi_uint8_in_ptr:
- * uint8: (in):
- */
-void
-test_gi_uint8_in_ptr (guint8 *uint8)
-{
-    g_assert(*uint8 == G_MAXUINT8);
-}
-
-/**
  * test_gi_uint8_out:
  * uint8: (out):
  */
@@ -296,28 +191,6 @@ test_gi_int16_return_min (void)
     return G_MININT16;
 }
 
-/**
- * test_gi_int16_return_ptr_max:
- * Returns: (transfer none):
- */
-gint16 *
-test_gi_int16_return_ptr_max (void)
-{
-    static gint16 int16 = G_MAXINT16;
-    return &int16;
-}
-
-/**
- * test_gi_int16_return_ptr_min:
- * Returns: (transfer none):
- */
-gint16 *
-test_gi_int16_return_ptr_min (void)
-{
-    static gint16 int16 = G_MININT16;
-    return &int16;
-}
-
 void
 test_gi_int16_in_max (gint16 int16)
 {
@@ -331,26 +204,6 @@ test_gi_int16_in_min (gint16 int16)
 }
 
 /**
- * test_gi_int16_in_ptr_max:
- * int16: (in):
- */
-void
-test_gi_int16_in_ptr_max (gint16 *int16)
-{
-    g_assert(*int16 == G_MAXINT16);
-}
-
-/**
- * test_gi_int16_in_ptr_min:
- * int16: (in):
- */
-void
-test_gi_int16_in_ptr_min (gint16 *int16)
-{
-    g_assert(*int16 == G_MININT16);
-}
-
-/**
  * test_gi_int16_out_max:
  * int16: (out):
  */
@@ -399,17 +252,6 @@ test_gi_uint16_return (void)
     return G_MAXUINT16;
 }
 
-/**
- * test_gi_uint16_return_ptr:
- * Returns: (transfer none):
- */
-guint16 *
-test_gi_uint16_return_ptr (void)
-{
-    static guint16 uint16 = G_MAXUINT16;
-    return &uint16;
-}
-
 void
 test_gi_uint16_in (guint16 uint16)
 {
@@ -417,16 +259,6 @@ test_gi_uint16_in (guint16 uint16)
 }
 
 /**
- * test_gi_uint16_in_ptr:
- * uint16: (in):
- */
-void
-test_gi_uint16_in_ptr (guint16 *uint16)
-{
-    g_assert(*uint16 == G_MAXUINT16);
-}
-
-/**
  * test_gi_uint16_out:
  * uint16: (out):
  */
@@ -460,28 +292,6 @@ test_gi_int32_return_min (void)
     return G_MININT32;
 }
 
-/**
- * test_gi_int32_return_ptr_max:
- * Returns: (transfer none):
- */
-gint32 *
-test_gi_int32_return_ptr_max (void)
-{
-    static gint32 int32 = G_MAXINT32;
-    return &int32;
-}
-
-/**
- * test_gi_int32_return_ptr_min:
- * Returns: (transfer none):
- */
-gint32 *
-test_gi_int32_return_ptr_min (void)
-{
-    static gint32 int32 = G_MININT32;
-    return &int32;
-}
-
 void
 test_gi_int32_in_max (gint32 int32)
 {
@@ -495,26 +305,6 @@ test_gi_int32_in_min (gint32 int32)
 }
 
 /**
- * test_gi_int32_in_ptr_max:
- * int32: (in):
- */
-void
-test_gi_int32_in_ptr_max (gint32 *int32)
-{
-    g_assert(*int32 == G_MAXINT32);
-}
-
-/**
- * test_gi_int32_in_ptr_min:
- * int32: (in):
- */
-void
-test_gi_int32_in_ptr_min (gint32 *int32)
-{
-    g_assert(*int32 == G_MININT32);
-}
-
-/**
  * test_gi_int32_out_max:
  * int32: (out):
  */
@@ -563,17 +353,6 @@ test_gi_uint32_return (void)
     return G_MAXUINT32;
 }
 
-/**
- * test_gi_uint32_return_ptr:
- * Returns: (transfer none):
- */
-guint32 *
-test_gi_uint32_return_ptr (void)
-{
-    static guint32 uint32 = G_MAXUINT32;
-    return &uint32;
-}
-
 void
 test_gi_uint32_in (guint32 uint32)
 {
@@ -581,16 +360,6 @@ test_gi_uint32_in (guint32 uint32)
 }
 
 /**
- * test_gi_uint32_in_ptr:
- * uint32: (in):
- */
-void
-test_gi_uint32_in_ptr (guint32 *uint32)
-{
-    g_assert(*uint32 == G_MAXUINT32);
-}
-
-/**
  * test_gi_uint32_out:
  * uint32: (out):
  */
@@ -624,28 +393,6 @@ test_gi_int64_return_min (void)
     return G_MININT64;
 }
 
-/**
- * test_gi_int64_return_ptr_max:
- * Returns: (transfer none):
- */
-gint64 *
-test_gi_int64_return_ptr_max (void)
-{
-    static gint64 int64 = G_MAXINT64;
-    return &int64;
-}
-
-/**
- * test_gi_int64_return_ptr_min:
- * Returns: (transfer none):
- */
-gint64 *
-test_gi_int64_return_ptr_min (void)
-{
-    static gint64 int64 = G_MININT64;
-    return &int64;
-}
-
 void
 test_gi_int64_in_max (gint64 int64)
 {
@@ -659,26 +406,6 @@ test_gi_int64_in_min (gint64 int64)
 }
 
 /**
- * test_gi_int64_in_ptr_max:
- * int64: (in):
- */
-void
-test_gi_int64_in_ptr_max (gint64 *int64)
-{
-    g_assert(*int64 == G_MAXINT64);
-}
-
-/**
- * test_gi_int64_in_ptr_min:
- * int64: (in):
- */
-void
-test_gi_int64_in_ptr_min (gint64 *int64)
-{
-    g_assert(*int64 == G_MININT64);
-}
-
-/**
  * test_gi_int64_out_max:
  * int64: (out):
  */
@@ -727,17 +454,6 @@ test_gi_uint64_return (void)
     return G_MAXUINT64;
 }
 
-/**
- * test_gi_uint64_return_ptr:
- * Returns: (transfer none):
- */
-guint64 *
-test_gi_uint64_return_ptr (void)
-{
-    static guint64 uint64 = G_MAXUINT64;
-    return &uint64;
-}
-
 void
 test_gi_uint64_in (guint64 uint64)
 {
@@ -745,16 +461,6 @@ test_gi_uint64_in (guint64 uint64)
 }
 
 /**
- * test_gi_uint64_in_ptr:
- * uint64: (in):
- */
-void
-test_gi_uint64_in_ptr (guint64 *uint64)
-{
-    g_assert(*uint64 == G_MAXUINT64);
-}
-
-/**
  * test_gi_uint64_out:
  * uint64: (out):
  */
@@ -788,28 +494,6 @@ test_gi_short_return_min (void)
     return G_MINSHORT;
 }
 
-/**
- * test_gi_short_return_ptr_max:
- * Returns: (transfer none):
- */
-gshort *
-test_gi_short_return_ptr_max (void)
-{
-    static gshort short_ = G_MAXSHORT;
-    return &short_;
-}
-
-/**
- * test_gi_short_return_ptr_min:
- * Returns: (transfer none):
- */
-gshort *
-test_gi_short_return_ptr_min (void)
-{
-    static gshort short_ = G_MINSHORT;
-    return &short_;
-}
-
 void
 test_gi_short_in_max (gshort short_)
 {
@@ -823,26 +507,6 @@ test_gi_short_in_min (gshort short_)
 }
 
 /**
- * test_gi_short_in_ptr_max:
- * short_: (in):
- */
-void
-test_gi_short_in_ptr_max (gshort *short_)
-{
-    g_assert(*short_ == G_MAXSHORT);
-}
-
-/**
- * test_gi_short_in_ptr_min:
- * short_: (in):
- */
-void
-test_gi_short_in_ptr_min (gshort *short_)
-{
-    g_assert(*short_ == G_MINSHORT);
-}
-
-/**
  * test_gi_short_out_max:
  * short_: (out):
  */
@@ -891,17 +555,6 @@ test_gi_ushort_return (void)
     return G_MAXUSHORT;
 }
 
-/**
- * test_gi_ushort_return_ptr:
- * Returns: (transfer none):
- */
-gushort *
-test_gi_ushort_return_ptr (void)
-{
-    static gushort ushort = G_MAXUSHORT;
-    return &ushort;
-}
-
 void
 test_gi_ushort_in (gushort ushort)
 {
@@ -909,16 +562,6 @@ test_gi_ushort_in (gushort ushort)
 }
 
 /**
- * test_gi_ushort_in_ptr:
- * ushort: (in):
- */
-void
-test_gi_ushort_in_ptr (gushort *ushort)
-{
-    g_assert(*ushort == G_MAXUSHORT);
-}
-
-/**
  * test_gi_ushort_out:
  * ushort: (out):
  */
@@ -952,28 +595,6 @@ test_gi_int_return_min (void)
     return G_MININT;
 }
 
-/**
- * test_gi_int_return_ptr_max:
- * Returns: (transfer none):
- */
-gint *
-test_gi_int_return_ptr_max (void)
-{
-    static gint int_ = G_MAXINT;
-    return &int_;
-}
-
-/**
- * test_gi_int_return_ptr_min:
- * Returns: (transfer none):
- */
-gint *
-test_gi_int_return_ptr_min (void)
-{
-    static gint int_ = G_MININT;
-    return &int_;
-}
-
 void
 test_gi_int_in_max (gint int_)
 {
@@ -987,26 +608,6 @@ test_gi_int_in_min (gint int_)
 }
 
 /**
- * test_gi_int_in_ptr_max:
- * int_: (in):
- */
-void
-test_gi_int_in_ptr_max (gint *int_)
-{
-    g_assert(*int_ == G_MAXINT);
-}
-
-/**
- * test_gi_int_in_ptr_min:
- * int_: (in):
- */
-void
-test_gi_int_in_ptr_min (gint *int_)
-{
-    g_assert(*int_ == G_MININT);
-}
-
-/**
  * test_gi_int_out_max:
  * int_: (out):
  */
@@ -1055,17 +656,6 @@ test_gi_uint_return (void)
     return G_MAXUINT;
 }
 
-/**
- * test_gi_uint_return_ptr:
- * Returns: (transfer none):
- */
-guint *
-test_gi_uint_return_ptr (void)
-{
-    static guint uint = G_MAXUINT;
-    return &uint;
-}
-
 void
 test_gi_uint_in (guint uint)
 {
@@ -1073,16 +663,6 @@ test_gi_uint_in (guint uint)
 }
 
 /**
- * test_gi_uint_in_ptr:
- * uint: (in):
- */
-void
-test_gi_uint_in_ptr (guint *uint)
-{
-    g_assert(*uint == G_MAXUINT);
-}
-
-/**
  * test_gi_uint_out:
  * uint: (out):
  */
@@ -1116,28 +696,6 @@ test_gi_long_return_min (void)
     return G_MINLONG;
 }
 
-/**
- * test_gi_long_return_ptr_max:
- * Returns: (transfer none):
- */
-glong *
-test_gi_long_return_ptr_max (void)
-{
-    static glong long_ = G_MAXLONG;
-    return &long_;
-}
-
-/**
- * test_gi_long_return_ptr_min:
- * Returns: (transfer none):
- */
-glong *
-test_gi_long_return_ptr_min (void)
-{
-    static glong long_ = G_MINLONG;
-    return &long_;
-}
-
 void
 test_gi_long_in_max (glong long_)
 {
@@ -1151,26 +709,6 @@ test_gi_long_in_min (glong long_)
 }
 
 /**
- * test_gi_long_in_ptr_max:
- * long_: (in):
- */
-void
-test_gi_long_in_ptr_max (glong *long_)
-{
-    g_assert(*long_ == G_MAXLONG);
-}
-
-/**
- * test_gi_long_in_ptr_min:
- * long_: (in):
- */
-void
-test_gi_long_in_ptr_min (glong *long_)
-{
-    g_assert(*long_ == G_MINLONG);
-}
-
-/**
  * test_gi_long_out_max:
  * long_: (out):
  */
@@ -1219,17 +757,6 @@ test_gi_ulong_return (void)
     return G_MAXULONG;
 }
 
-/**
- * test_gi_ulong_return_ptr:
- * Returns: (transfer none):
- */
-gulong *
-test_gi_ulong_return_ptr (void)
-{
-    static gulong ulong = G_MAXULONG;
-    return &ulong;
-}
-
 void
 test_gi_ulong_in (gulong ulong)
 {
@@ -1237,16 +764,6 @@ test_gi_ulong_in (gulong ulong)
 }
 
 /**
- * test_gi_ulong_in_ptr:
- * ulong: (in):
- */
-void
-test_gi_ulong_in_ptr (gulong *ulong)
-{
-    g_assert(*ulong == G_MAXULONG);
-}
-
-/**
  * test_gi_ulong_out:
  * ulong: (out):
  */
@@ -1280,28 +797,6 @@ test_gi_ssize_return_min (void)
     return G_MINSSIZE;
 }
 
-/**
- * test_gi_ssize_return_ptr_max:
- * Returns: (transfer none):
- */
-gssize *
-test_gi_ssize_return_ptr_max (void)
-{
-    static gssize ssize = G_MAXSSIZE;
-    return &ssize;
-}
-
-/**
- * test_gi_ssize_return_ptr_min:
- * Returns: (transfer none):
- */
-gssize *
-test_gi_ssize_return_ptr_min (void)
-{
-    static gssize ssize = G_MINSSIZE;
-    return &ssize;
-}
-
 void
 test_gi_ssize_in_max (gssize ssize)
 {
@@ -1315,26 +810,6 @@ test_gi_ssize_in_min (gssize ssize)
 }
 
 /**
- * test_gi_ssize_in_ptr_max:
- * ssize: (in):
- */
-void
-test_gi_ssize_in_ptr_max (gssize *ssize)
-{
-    g_assert(*ssize == G_MAXSSIZE);
-}
-
-/**
- * test_gi_ssize_in_ptr_min:
- * ssize: (in):
- */
-void
-test_gi_ssize_in_ptr_min (gssize *ssize)
-{
-    g_assert(*ssize == G_MINSSIZE);
-}
-
-/**
  * test_gi_ssize_out_max:
  * ssize: (out):
  */
@@ -1383,17 +858,6 @@ test_gi_size_return (void)
     return G_MAXSIZE;
 }
 
-/**
- * test_gi_size_return_ptr:
- * Returns: (transfer none):
- */
-gsize *
-test_gi_size_return_ptr (void)
-{
-    static gsize size = G_MAXSIZE;
-    return &size;
-}
-
 void
 test_gi_size_in (gsize size)
 {
@@ -1401,16 +865,6 @@ test_gi_size_in (gsize size)
 }
 
 /**
- * test_gi_size_in_ptr:
- * size: (in):
- */
-void
-test_gi_size_in_ptr (gsize *size)
-{
-    g_assert(*size == G_MAXSIZE);
-}
-
-/**
  * test_gi_size_out:
  * size: (out):
  */
@@ -1438,17 +892,6 @@ test_gi_float_return (void)
     return G_MAXFLOAT;
 }
 
-/**
- * test_gi_float_return_ptr:
- * Returns: (transfer none):
- */
-gfloat *
-test_gi_float_return_ptr (void)
-{
-    static gfloat float_ = G_MAXFLOAT;
-    return &float_;
-}
-
 void
 test_gi_float_in (gfloat float_)
 {
@@ -1456,16 +899,6 @@ test_gi_float_in (gfloat float_)
 }
 
 /**
- * test_gi_float_in_ptr:
- * float_: (in):
- */
-void
-test_gi_float_in_ptr (gfloat *float_)
-{
-    g_assert(*float_ == G_MAXFLOAT);
-}
-
-/**
  * test_gi_float_out:
  * float_: (out):
  */
@@ -1493,17 +926,6 @@ test_gi_double_return (void)
     return G_MAXDOUBLE;
 }
 
-/**
- * test_gi_double_return_ptr:
- * Returns: (transfer none):
- */
-gdouble *
-test_gi_double_return_ptr (void)
-{
-    static gdouble double_ = G_MAXDOUBLE;
-    return &double_;
-}
-
 void
 test_gi_double_in (gdouble double_)
 {
@@ -1511,16 +933,6 @@ test_gi_double_in (gdouble double_)
 }
 
 /**
- * test_gi_double_in_ptr:
- * double_: (in):
- */
-void
-test_gi_double_in_ptr (gdouble *double_)
-{
-    g_assert(*double_ == G_MAXDOUBLE);
-}
-
-/**
  * test_gi_double_out:
  * double_: (out):
  */
@@ -1548,17 +960,6 @@ test_gi_time_t_return (void)
     return 1234567890;
 }
 
-/**
- * test_gi_time_t_return_ptr:
- * Returns: (transfer none):
- */
-time_t *
-test_gi_time_t_return_ptr (void)
-{
-    static time_t time_t_ = 1234567890;
-    return &time_t_;
-}
-
 void
 test_gi_time_t_in (time_t time_t_)
 {
@@ -1566,16 +967,6 @@ test_gi_time_t_in (time_t time_t_)
 }
 
 /**
- * test_gi_time_t_in_ptr:
- * time_t_: (in):
- */
-void
-test_gi_time_t_in_ptr (time_t *time_t_)
-{
-    g_assert(*time_t_ == 1234567890);
-}
-
-/**
  * test_gi_time_t_out:
  * time_t_: (out):
  */
@@ -1603,17 +994,6 @@ test_gi_gtype_return (void)
     return G_TYPE_NONE;
 }
 
-/**
- * test_gi_gtype_return_ptr:
- * Returns: (transfer none):
- */
-GType *
-test_gi_gtype_return_ptr (void)
-{
-    static GType gtype = G_TYPE_NONE;
-    return &gtype;
-}
-
 void
 test_gi_gtype_in (GType gtype)
 {
@@ -1621,16 +1001,6 @@ test_gi_gtype_in (GType gtype)
 }
 
 /**
- * test_gi_gtype_in_ptr:
- * gtype: (in):
- */
-void
-test_gi_gtype_in_ptr (GType *gtype)
-{
-    g_assert(*gtype == G_TYPE_NONE);
-}
-
-/**
  * test_gi_gtype_out:
  * gtype: (out):
  */
@@ -2783,16 +2153,6 @@ test_gi_enum_in (TestGIEnum enum_)
 }
 
 /**
- * test_gi_enum_in_ptr:
- * @enum_: (in) (transfer none):
- */
-void
-test_gi_enum_in_ptr (TestGIEnum *enum_)
-{
-    g_assert(*enum_ == TESTGI_ENUM_VALUE3);
-}
-
-/**
  * test_gi_enum_out:
  * @enum_: (out):
  */
@@ -2850,16 +2210,6 @@ test_gi_flags_in_zero (TestGIFlags flags)
 }
 
 /**
- * test_gi_flags_in_ptr:
- * @flags_: (in) (transfer none):
- */
-void
-test_gi_flags_in_ptr (TestGIFlags *flags_)
-{
-    g_assert(*flags_ == TESTGI_FLAGS_VALUE2);
-}
-
-/**
  * test_gi_flags_out:
  * @flags_: (out):
  */
@@ -3467,16 +2817,6 @@ test_gi_int_return_out (gint *int_)
     return 6;
 }
 
-/**
- * test_gi_ptr_return_null:
- * Returns: (allow-none):
- */
-gint *
-test_gi_int_return_ptr_null (void)
-{
-    return NULL;
-}
-
 
 TestGIOverridesStruct *
 test_gi_overrides_struct_copy (TestGIOverridesStruct *struct_)
diff --git a/tests/libtestgi.h b/tests/libtestgi.h
index 970d01b..a08a7fc 100644
--- a/tests/libtestgi.h
+++ b/tests/libtestgi.h
@@ -20,9 +20,6 @@ typedef struct _TestGISimpleStruct TestGISimpleStruct;
 gboolean test_gi_boolean_return_true (void);
 gboolean test_gi_boolean_return_false (void);
 
-gboolean *test_gi_boolean_return_ptr_true (void);
-gboolean *test_gi_boolean_return_ptr_false (void);
-
 void test_gi_boolean_in_true (gboolean bool_);
 void test_gi_boolean_in_false (gboolean bool_);
 
@@ -32,24 +29,15 @@ void test_gi_boolean_out_false (gboolean *bool_);
 void test_gi_boolean_inout_true_false (gboolean *bool_);
 void test_gi_boolean_inout_false_true (gboolean *bool_);
 
-void test_gi_boolean_in_ptr_true (gboolean *bool_);
-void test_gi_boolean_in_ptr_false (gboolean *bool_);
-
 
 /* Integers */
 
 gint8 test_gi_int8_return_max (void);
 gint8 test_gi_int8_return_min (void);
 
-gint8 *test_gi_int8_return_ptr_max (void);
-gint8 *test_gi_int8_return_ptr_min (void);
-
 void test_gi_int8_in_max (gint8 int8);
 void test_gi_int8_in_min (gint8 int8);
 
-void test_gi_int8_in_ptr_max (gint8 *int8);
-void test_gi_int8_in_ptr_min (gint8 *int8);
-
 void test_gi_int8_out_max (gint8 *int8);
 void test_gi_int8_out_min (gint8 *int8);
 
@@ -58,10 +46,8 @@ void test_gi_int8_inout_min_max (gint8 *int8);
 
 
 guint8 test_gi_uint8_return (void);
-guint8 *test_gi_uint8_return_ptr (void);
 
 void test_gi_uint8_in (guint8 uint8);
-void test_gi_uint8_in_ptr (guint8 *uint8);
 
 void test_gi_uint8_out (guint8 *uint8);
 void test_gi_uint8_inout (guint8 *uint8);
@@ -70,15 +56,9 @@ void test_gi_uint8_inout (guint8 *uint8);
 gint16 test_gi_int16_return_max (void);
 gint16 test_gi_int16_return_min (void);
 
-gint16 *test_gi_int16_return_ptr_max (void);
-gint16 *test_gi_int16_return_ptr_min (void);
-
 void test_gi_int16_in_max (gint16 int16);
 void test_gi_int16_in_min (gint16 int16);
 
-void test_gi_int16_in_ptr_max (gint16 *int16);
-void test_gi_int16_in_ptr_min (gint16 *int16);
-
 void test_gi_int16_out_max (gint16 *int16);
 void test_gi_int16_out_min (gint16 *int16);
 
@@ -87,10 +67,8 @@ void test_gi_int16_inout_min_max (gint16 *int16);
 
 
 guint16 test_gi_uint16_return (void);
-guint16 *test_gi_uint16_return_ptr (void);
 
 void test_gi_uint16_in (guint16 uint16);
-void test_gi_uint16_in_ptr (guint16 *uint16);
 
 void test_gi_uint16_out (guint16 *uint16);
 void test_gi_uint16_inout (guint16 *uint16);
@@ -99,15 +77,9 @@ void test_gi_uint16_inout (guint16 *uint16);
 gint32 test_gi_int32_return_max (void);
 gint32 test_gi_int32_return_min (void);
 
-gint32 *test_gi_int32_return_ptr_max (void);
-gint32 *test_gi_int32_return_ptr_min (void);
-
 void test_gi_int32_in_max (gint32 int32);
 void test_gi_int32_in_min (gint32 int32);
 
-void test_gi_int32_in_ptr_max (gint32 *int32);
-void test_gi_int32_in_ptr_min (gint32 *int32);
-
 void test_gi_int32_out_max (gint32 *int32);
 void test_gi_int32_out_min (gint32 *int32);
 
@@ -116,10 +88,8 @@ void test_gi_int32_inout_min_max (gint32 *int32);
 
 
 guint32 test_gi_uint32_return (void);
-guint32 *test_gi_uint32_return_ptr (void);
 
 void test_gi_uint32_in (guint32 uint32);
-void test_gi_uint32_in_ptr (guint32 *uint32);
 
 void test_gi_uint32_out (guint32 *uint32);
 void test_gi_uint32_inout (guint32 *uint32);
@@ -128,15 +98,9 @@ void test_gi_uint32_inout (guint32 *uint32);
 gint64 test_gi_int64_return_max (void);
 gint64 test_gi_int64_return_min (void);
 
-gint64 *test_gi_int64_return_ptr_max (void);
-gint64 *test_gi_int64_return_ptr_min (void);
-
 void test_gi_int64_in_max (gint64 int64);
 void test_gi_int64_in_min (gint64 int64);
 
-void test_gi_int64_in_ptr_max (gint64 *int64);
-void test_gi_int64_in_ptr_min (gint64 *int64);
-
 void test_gi_int64_out_max (gint64 *int64);
 void test_gi_int64_out_min (gint64 *int64);
 
@@ -145,10 +109,8 @@ void test_gi_int64_inout_min_max (gint64 *int64);
 
 
 guint64 test_gi_uint64_return (void);
-guint64 *test_gi_uint64_return_ptr (void);
 
 void test_gi_uint64_in (guint64 uint64);
-void test_gi_uint64_in_ptr (guint64 *uint64);
 
 void test_gi_uint64_out (guint64 *uint64);
 void test_gi_uint64_inout (guint64 *uint64);
@@ -157,15 +119,9 @@ void test_gi_uint64_inout (guint64 *uint64);
 gshort test_gi_short_return_max (void);
 gshort test_gi_short_return_min (void);
 
-gshort *test_gi_short_return_ptr_max (void);
-gshort *test_gi_short_return_ptr_min (void);
-
 void test_gi_short_in_max (gshort short_);
 void test_gi_short_in_min (gshort short_);
 
-void test_gi_short_in_ptr_max (gshort *short_);
-void test_gi_short_in_ptr_min (gshort *short_);
-
 void test_gi_short_out_max (gshort *short_);
 void test_gi_short_out_min (gshort *short_);
 
@@ -174,10 +130,8 @@ void test_gi_short_inout_min_max (gshort *short_);
 
 
 gushort test_gi_ushort_return (void);
-gushort *test_gi_ushort_return_ptr (void);
 
 void test_gi_ushort_in (gushort ushort);
-void test_gi_ushort_in_ptr (gushort *ushort);
 
 void test_gi_ushort_out (gushort *ushort);
 void test_gi_ushort_inout (gushort *ushort);
@@ -186,15 +140,9 @@ void test_gi_ushort_inout (gushort *ushort);
 gint test_gi_int_return_max (void);
 gint test_gi_int_return_min (void);
 
-gint *test_gi_int_return_ptr_max (void);
-gint *test_gi_int_return_ptr_min (void);
-
 void test_gi_int_in_max (gint int_);
 void test_gi_int_in_min (gint int_);
 
-void test_gi_int_in_ptr_max (gint *int_);
-void test_gi_int_in_ptr_min (gint *int_);
-
 void test_gi_int_out_max (gint *int_);
 void test_gi_int_out_min (gint *int_);
 
@@ -203,10 +151,8 @@ void test_gi_int_inout_min_max (gint *int_);
 
 
 guint test_gi_uint_return (void);
-guint *test_gi_uint_return_ptr (void);
 
 void test_gi_uint_in (guint uint);
-void test_gi_uint_in_ptr (guint *uint);
 
 void test_gi_uint_out (guint *uint);
 void test_gi_uint_inout (guint *uint);
@@ -215,15 +161,9 @@ void test_gi_uint_inout (guint *uint);
 glong test_gi_long_return_max (void);
 glong test_gi_long_return_min (void);
 
-glong *test_gi_long_return_ptr_max (void);
-glong *test_gi_long_return_ptr_min (void);
-
 void test_gi_long_in_max (glong long_);
 void test_gi_long_in_min (glong long_);
 
-void test_gi_long_in_ptr_max (glong *long_);
-void test_gi_long_in_ptr_min (glong *long_);
-
 void test_gi_long_out_max (glong *long_);
 void test_gi_long_out_min (glong *long_);
 
@@ -232,10 +172,8 @@ void test_gi_long_inout_min_max (glong *long_);
 
 
 gulong test_gi_ulong_return (void);
-gulong *test_gi_ulong_return_ptr (void);
 
 void test_gi_ulong_in (gulong ulong);
-void test_gi_ulong_in_ptr (gulong *ulong);
 
 void test_gi_ulong_out (gulong *ulong);
 void test_gi_ulong_inout (gulong *ulong);
@@ -244,15 +182,9 @@ void test_gi_ulong_inout (gulong *ulong);
 gssize test_gi_ssize_return_max (void);
 gssize test_gi_ssize_return_min (void);
 
-gssize *test_gi_ssize_return_ptr_max (void);
-gssize *test_gi_ssize_return_ptr_min (void);
-
 void test_gi_ssize_in_max (gssize ssize);
 void test_gi_ssize_in_min (gssize ssize);
 
-void test_gi_ssize_in_ptr_max (gssize *ssize);
-void test_gi_ssize_in_ptr_min (gssize *ssize);
-
 void test_gi_ssize_out_max (gssize *ssize);
 void test_gi_ssize_out_min (gssize *ssize);
 
@@ -261,10 +193,8 @@ void test_gi_ssize_inout_min_max (gssize *ssize);
 
 
 gsize test_gi_size_return (void);
-gsize *test_gi_size_return_ptr (void);
 
 void test_gi_size_in (gsize size);
-void test_gi_size_in_ptr (gsize *size);
 
 void test_gi_size_out (gsize *size);
 void test_gi_size_inout (gsize *size);
@@ -273,10 +203,8 @@ void test_gi_size_inout (gsize *size);
 /* Floating-point */
 
 gfloat test_gi_float_return (void);
-gfloat *test_gi_float_return_ptr (void);
 
 void test_gi_float_in (gfloat float_);
-void test_gi_float_in_ptr (gfloat *float_);
 
 void test_gi_float_out (gfloat *float_);
 
@@ -284,10 +212,8 @@ void test_gi_float_inout (gfloat *float_);
 
 
 gdouble test_gi_double_return (void);
-gdouble *test_gi_double_return_ptr (void);
 
 void test_gi_double_in (gdouble double_);
-void test_gi_double_in_ptr (gdouble *double_);
 
 void test_gi_double_out (gdouble *double_);
 
@@ -297,10 +223,8 @@ void test_gi_double_inout (gdouble *double_);
 /* Timestamps */
 
 time_t test_gi_time_t_return (void);
-time_t *test_gi_time_t_return_ptr (void);
 
 void test_gi_time_t_in (time_t time_t_);
-void test_gi_time_t_in_ptr (time_t *time_t_);
 
 void test_gi_time_t_out (time_t *time_t_);
 
@@ -310,10 +234,8 @@ void test_gi_time_t_inout (time_t *time_t_);
 /* GType */
 
 GType test_gi_gtype_return (void);
-GType *test_gi_gtype_return_ptr (void);
 
 void test_gi_gtype_in (GType gtype);
-void test_gi_gtype_in_ptr (GType *gtype);
 
 void test_gi_gtype_out (GType *gtype);
 
@@ -470,7 +392,6 @@ GType test_gi_enum_get_type (void) G_GNUC_CONST;
 TestGIEnum test_gi_enum_return (void);
 
 void test_gi_enum_in (TestGIEnum enum_);
-void test_gi_enum_in_ptr (TestGIEnum *enum_);
 
 void test_gi_enum_out (TestGIEnum *enum_);
 
@@ -493,7 +414,6 @@ TestGIFlags test_gi_flags_return (void);
 
 void test_gi_flags_in (TestGIFlags flags_);
 void test_gi_flags_in_zero (TestGIFlags flags);
-void test_gi_flags_in_ptr (TestGIFlags *flags_);
 
 void test_gi_flags_out (TestGIFlags *flags_);
 
@@ -656,12 +576,6 @@ void test_gi_int_out_out (gint *int0, gint *int1);
 gint test_gi_int_return_out (gint *int_);
 
 
-/* Nullable arguments */
-
-gint *test_gi_int_return_ptr_null (void);
-void test_gi_int_in_ptr_null (gint *int_);
-
-
 /* Overrides */
 
 #define TESTGI_OVERRIDES_CONSTANT 42
diff --git a/tests/test_gi.py b/tests/test_gi.py
index 0d97915..36337ed 100644
--- a/tests/test_gi.py
+++ b/tests/test_gi.py
@@ -59,10 +59,6 @@ class TestBoolean(unittest.TestCase):
         self.assertEquals(True, TestGI.boolean_return_true())
         self.assertEquals(False, TestGI.boolean_return_false())
 
-    def test_boolean_return_ptr(self):
-        self.assertEquals(True, TestGI.boolean_return_ptr_true())
-        self.assertEquals(False, TestGI.boolean_return_ptr_false())
-
     def test_boolean_in(self):
         TestGI.boolean_in_true(True)
         TestGI.boolean_in_false(False)
@@ -70,11 +66,6 @@ class TestBoolean(unittest.TestCase):
         TestGI.boolean_in_true(1)
         TestGI.boolean_in_false(0)
 
-    def test_boolean_in_ptr(self):
-        TestGI.boolean_in_ptr_true(True)
-        TestGI.boolean_in_ptr_false(False)
-        TestGI.boolean_in_ptr_false(None)
-
     def test_boolean_out(self):
         self.assertEquals(True, TestGI.boolean_out_true())
         self.assertEquals(False, TestGI.boolean_out_false())
@@ -93,10 +84,6 @@ class TestInt8(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.int8_return_max())
         self.assertEquals(self.MIN, TestGI.int8_return_min())
 
-    def test_int8_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.int8_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.int8_return_ptr_min())
-
     def test_int8_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -112,11 +99,6 @@ class TestInt8(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.int8_in_max, "self.MAX")
 
-    def test_int8_in_ptr(self):
-        TestGI.int8_in_ptr_max(Number(self.MAX))
-        TestGI.int8_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.int8_in_ptr_max, None)
-
     def test_int8_out(self):
         self.assertEquals(self.MAX, TestGI.int8_out_max())
         self.assertEquals(self.MIN, TestGI.int8_out_min())
@@ -133,10 +115,6 @@ class TestUInt8(unittest.TestCase):
     def test_uint8_return(self):
         self.assertEquals(self.MAX, TestGI.uint8_return())
 
-# Blocked by https://bugzilla.gnome.org/show_bug.cgi?id=596420
-#    def test_uint8_return_ptr(self):
-#        self.assertEquals(self.MAX, TestGI.uint8_return_ptr())
-
     def test_uint8_in(self):
         number = Number(self.MAX)
 
@@ -165,10 +143,6 @@ class TestInt16(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.int16_return_max())
         self.assertEquals(self.MIN, TestGI.int16_return_min())
 
-    def test_int16_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.int16_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.int16_return_ptr_min())
-
     def test_int16_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -184,11 +158,6 @@ class TestInt16(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.int16_in_max, "self.MAX")
 
-    def test_int16_in_ptr(self):
-        TestGI.int16_in_ptr_max(Number(self.MAX))
-        TestGI.int16_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.int16_in_ptr_max, None)
-
     def test_int16_out(self):
         self.assertEquals(self.MAX, TestGI.int16_out_max())
         self.assertEquals(self.MIN, TestGI.int16_out_min())
@@ -205,9 +174,6 @@ class TestUInt16(unittest.TestCase):
     def test_uint16_return(self):
         self.assertEquals(self.MAX, TestGI.uint16_return())
 
-    def test_uint16_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.uint16_return_ptr())
-
     def test_uint16_in(self):
         number = Number(self.MAX)
 
@@ -236,10 +202,6 @@ class TestInt32(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.int32_return_max())
         self.assertEquals(self.MIN, TestGI.int32_return_min())
 
-    def test_int32_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.int32_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.int32_return_ptr_min())
-
     def test_int32_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -255,11 +217,6 @@ class TestInt32(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.int32_in_max, "self.MAX")
 
-    def test_int32_in_ptr(self):
-        TestGI.int32_in_ptr_max(Number(self.MAX))
-        TestGI.int32_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.int32_in_ptr_max, None)
-
     def test_int32_out(self):
         self.assertEquals(self.MAX, TestGI.int32_out_max())
         self.assertEquals(self.MIN, TestGI.int32_out_min())
@@ -276,9 +233,6 @@ class TestUInt32(unittest.TestCase):
     def test_uint32_return(self):
         self.assertEquals(self.MAX, TestGI.uint32_return())
 
-    def test_uint32_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.uint32_return_ptr())
-
     def test_uint32_in(self):
         number = Number(self.MAX)
 
@@ -307,10 +261,6 @@ class TestInt64(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.int64_return_max())
         self.assertEquals(self.MIN, TestGI.int64_return_min())
 
-    def test_int64_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.int64_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.int64_return_ptr_min())
-
     def test_int64_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -326,11 +276,6 @@ class TestInt64(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.int64_in_max, "self.MAX")
 
-    def test_int64_in_ptr(self):
-        TestGI.int64_in_ptr_max(Number(self.MAX))
-        TestGI.int64_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.int64_in_ptr_max, None)
-
     def test_int64_out(self):
         self.assertEquals(self.MAX, TestGI.int64_out_max())
         self.assertEquals(self.MIN, TestGI.int64_out_min())
@@ -347,9 +292,6 @@ class TestUInt64(unittest.TestCase):
     def test_uint64_return(self):
         self.assertEquals(self.MAX, TestGI.uint64_return())
 
-    def test_uint64_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.uint64_return_ptr())
-
     def test_uint64_in(self):
         number = Number(self.MAX)
 
@@ -378,10 +320,6 @@ class TestShort(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.short_return_max())
         self.assertEquals(self.MIN, TestGI.short_return_min())
 
-    def test_short_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.short_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.short_return_ptr_min())
-
     def test_short_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -397,11 +335,6 @@ class TestShort(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.short_in_max, "self.MAX")
 
-    def test_short_in_ptr(self):
-        TestGI.short_in_ptr_max(Number(self.MAX))
-        TestGI.short_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.short_in_ptr_max, None)
-
     def test_short_out(self):
         self.assertEquals(self.MAX, TestGI.short_out_max())
         self.assertEquals(self.MIN, TestGI.short_out_min())
@@ -418,9 +351,6 @@ class TestUShort(unittest.TestCase):
     def test_ushort_return(self):
         self.assertEquals(self.MAX, TestGI.ushort_return())
 
-    def test_ushort_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.ushort_return_ptr())
-
     def test_ushort_in(self):
         number = Number(self.MAX)
 
@@ -449,10 +379,6 @@ class TestInt(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.int_return_max())
         self.assertEquals(self.MIN, TestGI.int_return_min())
 
-    def test_int_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.int_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.int_return_ptr_min())
-
     def test_int_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -468,11 +394,6 @@ class TestInt(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.int_in_max, "self.MAX")
 
-    def test_int_in_ptr(self):
-        TestGI.int_in_ptr_max(Number(self.MAX))
-        TestGI.int_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.int_in_ptr_max, None)
-
     def test_int_out(self):
         self.assertEquals(self.MAX, TestGI.int_out_max())
         self.assertEquals(self.MIN, TestGI.int_out_min())
@@ -489,9 +410,6 @@ class TestUInt(unittest.TestCase):
     def test_uint_return(self):
         self.assertEquals(self.MAX, TestGI.uint_return())
 
-    def test_uint_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.uint_return_ptr())
-
     def test_uint_in(self):
         number = Number(self.MAX)
 
@@ -520,10 +438,6 @@ class TestLong(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.long_return_max())
         self.assertEquals(self.MIN, TestGI.long_return_min())
 
-    def test_long_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.long_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.long_return_ptr_min())
-
     def test_long_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -539,11 +453,6 @@ class TestLong(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.long_in_max, "self.MAX")
 
-    def test_long_in_ptr(self):
-        TestGI.long_in_ptr_max(Number(self.MAX))
-        TestGI.long_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.long_in_ptr_max, None)
-
     def test_long_out(self):
         self.assertEquals(self.MAX, TestGI.long_out_max())
         self.assertEquals(self.MIN, TestGI.long_out_min())
@@ -560,9 +469,6 @@ class TestULong(unittest.TestCase):
     def test_ulong_return(self):
         self.assertEquals(self.MAX, TestGI.ulong_return())
 
-    def test_ulong_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.ulong_return_ptr())
-
     def test_ulong_in(self):
         number = Number(self.MAX)
 
@@ -591,10 +497,6 @@ class TestSSize(unittest.TestCase):
         self.assertEquals(self.MAX, TestGI.ssize_return_max())
         self.assertEquals(self.MIN, TestGI.ssize_return_min())
 
-    def test_ssize_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.ssize_return_ptr_max())
-        self.assertEquals(self.MIN, TestGI.ssize_return_ptr_min())
-
     def test_ssize_in(self):
         max = Number(self.MAX)
         min = Number(self.MIN)
@@ -610,11 +512,6 @@ class TestSSize(unittest.TestCase):
 
         self.assertRaises(TypeError, TestGI.ssize_in_max, "self.MAX")
 
-    def test_ssize_in_ptr(self):
-        TestGI.ssize_in_ptr_max(Number(self.MAX))
-        TestGI.ssize_in_ptr_min(Number(self.MIN))
-        self.assertRaises(TypeError, TestGI.ssize_in_ptr_max, None)
-
     def test_ssize_out(self):
         self.assertEquals(self.MAX, TestGI.ssize_out_max())
         self.assertEquals(self.MIN, TestGI.ssize_out_min())
@@ -631,9 +528,6 @@ class TestSize(unittest.TestCase):
     def test_size_return(self):
         self.assertEquals(self.MAX, TestGI.size_return())
 
-    def test_size_return_ptr(self):
-        self.assertEquals(self.MAX, TestGI.size_return_ptr())
-
     def test_size_in(self):
         number = Number(self.MAX)
 
@@ -661,18 +555,11 @@ class TestFloat(unittest.TestCase):
     def test_float_return(self):
         self.assertAlmostEquals(self.MAX, TestGI.float_return())
 
-    def test_float_return_ptr(self):
-        self.assertAlmostEquals(self.MAX, TestGI.float_return_ptr())
-
     def test_float_in(self):
         TestGI.float_in(Number(self.MAX))
 
         self.assertRaises(TypeError, TestGI.float_in, "self.MAX")
 
-    def test_float_in_ptr(self):
-        TestGI.float_in_ptr(Number(self.MAX))
-        self.assertRaises(TypeError, TestGI.float_in_ptr, None)
-
     def test_float_out(self):
         self.assertAlmostEquals(self.MAX, TestGI.float_out())
 
@@ -688,18 +575,11 @@ class TestDouble(unittest.TestCase):
     def test_double_return(self):
         self.assertAlmostEquals(self.MAX, TestGI.double_return())
 
-    def test_double_return_ptr(self):
-        self.assertAlmostEquals(self.MAX, TestGI.double_return_ptr())
-
     def test_double_in(self):
         TestGI.double_in(Number(self.MAX))
 
         self.assertRaises(TypeError, TestGI.double_in, "self.MAX")
 
-    def test_double_in_ptr(self):
-        TestGI.double_in_ptr(Number(self.MAX))
-        self.assertRaises(TypeError, TestGI.double_in_ptr, None)
-
     def test_double_out(self):
         self.assertAlmostEquals(self.MAX, TestGI.double_out())
 
@@ -714,18 +594,11 @@ class TestTimeT(unittest.TestCase):
     def test_time_t_return(self):
         self.assertEquals(self.DATETIME, TestGI.time_t_return())
 
-    def test_time_t_return_ptr(self):
-        self.assertEquals(self.DATETIME, TestGI.time_t_return_ptr())
-
     def test_time_t_in(self):
         TestGI.time_t_in(self.DATETIME)
 
         self.assertRaises(TypeError, TestGI.time_t_in, "self.DATETIME")
 
-    def test_time_t_in_ptr(self):
-        TestGI.time_t_in_ptr(self.DATETIME)
-        self.assertRaises(TypeError, TestGI.time_t_in_ptr, None)
-
     def test_time_t_out(self):
         self.assertEquals(self.DATETIME, TestGI.time_t_out())
 
@@ -738,18 +611,11 @@ class TestGType(unittest.TestCase):
     def test_gtype_return(self):
         self.assertEquals(gobject.TYPE_NONE, TestGI.gtype_return())
 
-    def test_gtype_return_ptr(self):
-        self.assertEquals(gobject.TYPE_NONE, TestGI.gtype_return_ptr())
-
     def test_gtype_in(self):
         TestGI.gtype_in(gobject.TYPE_NONE)
 
         self.assertRaises(TypeError, TestGI.gtype_in, "gobject.TYPE_NONE")
 
-    def test_gtype_in_ptr(self):
-        TestGI.gtype_in_ptr(gobject.TYPE_NONE)
-        self.assertRaises(TypeError, TestGI.gtype_in_ptr, None)
-
     def test_gtype_out(self):
         self.assertEquals(gobject.TYPE_NONE, TestGI.gtype_out())
 
@@ -1064,11 +930,6 @@ class TestGEnum(unittest.TestCase):
         self.assertRaises(TypeError, TestGI.enum_in, 42)
         self.assertRaises(TypeError, TestGI.enum_in, 'TestGI.Enum.VALUE3')
 
-    def test_enum_in_ptr(self):
-        TestGI.enum_in_ptr(TestGI.Enum.VALUE3)
-
-        self.assertRaises(TypeError, TestGI.enum_in_ptr, None)
-
     def test_enum_out(self):
         enum = TestGI.enum_out()
         self.assertTrue(isinstance(enum, TestGI.Enum))
@@ -1096,11 +957,6 @@ class TestGFlags(unittest.TestCase):
         self.assertRaises(TypeError, TestGI.flags_in, 1 << 1)
         self.assertRaises(TypeError, TestGI.flags_in, 'TestGI.Flags.VALUE2')
 
-    def test_flags_in_ptr(self):
-        TestGI.flags_in_ptr(TestGI.Flags.VALUE2)
-
-        self.assertRaises(TypeError, TestGI.flags_in_ptr, None)
-
     def test_flags_out(self):
         flags = TestGI.flags_out()
         self.assertTrue(isinstance(flags, TestGI.Flags))