1 /* GObject - GLib Type, Object, Parameter and Signal Library

     2  * override.c: Closure override test program

     3  * Copyright (C) 2001, James Henstridge

     4  * Copyright (C) 2003, Red Hat, Inc.

     5  * Portions copyright (c) 2006-2009 Nokia Corporation.  All rights reserved.

     6  * This library is free software; you can redistribute it and/or

     7  * modify it under the terms of the GNU Lesser General Public

     8  * License as published by the Free Software Foundation; either

     9  * version 2 of the License, or (at your option) any later version.

    10  *

    11  * This library is distributed in the hope that it will be useful,

    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    14  * Lesser General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU Lesser General

    17  * Public License along with this library; if not, write to the

    18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,

    19  * Boston, MA 02111-1307, USA.

    20  */

    21 

    22 #undef	G_LOG_DOMAIN

    23 #define	G_LOG_DOMAIN "TestOverride"

    24 

    25 #undef G_DISABLE_ASSERT

    26 #undef G_DISABLE_CHECKS

    27 #undef G_DISABLE_CAST_CHECKS

    28 

    29 #undef VERBOSE

    30 

    31 #include <string.h>

    32 

    33 #include <glib.h>

    34 #include <glib-object.h>

    35 

    36 #include "testcommon.h"

    37 #ifdef __SYMBIAN32__

    38   #include "mrt2_glib2_test.h"

    39   #endif /*__SYMBIAN32__*/

    40 

    41 static guint foo_signal_id = 0;

    42 static guint bar_signal_id = 0;

    43 static guint baz_signal_id = 0;

    44 

    45 static GType test_i_get_type (void);

    46 static GType test_a_get_type (void);

    47 static GType test_b_get_type (void);

    48 static GType test_c_get_type (void);

    49 

    50 static void  record (const gchar *str);

    51 

    52 #define TEST_TYPE_I (test_i_get_type ())

    53 

    54 typedef struct _TestI TestI;

    55 typedef struct _TestIClass TestIClass;

    56 

    57 struct _TestIClass

    58 {

    59   GTypeInterface base_iface;

    60 };

    61 

    62 static void

    63 test_i_foo (TestI *self)

    64 {

    65   record ("TestI::foo");

    66 }

    67 

    68 static void

    69 test_i_default_init (gpointer g_class)

    70 {

    71   foo_signal_id = g_signal_newv ("foo",

    72 				 TEST_TYPE_I,

    73 				 G_SIGNAL_RUN_LAST,

    74 				 g_cclosure_new(G_CALLBACK(test_i_foo),

    75 						NULL, NULL),

    76 				 NULL, NULL,

    77 				 g_cclosure_marshal_VOID__VOID,

    78 				 G_TYPE_NONE, 0, NULL);

    79 }

    80 

    81 static DEFINE_IFACE (TestI, test_i, NULL, test_i_default_init)

    82 

    83 #define TEST_TYPE_A (test_a_get_type())

    84 

    85      typedef struct _TestA TestA;

    86      typedef struct _TestAClass TestAClass;

    87 

    88 struct _TestA {

    89   GObject parent;

    90 };

    91 struct _TestAClass {

    92   GObjectClass parent_class;

    93 

    94   void (* bar) (TestA *self);

    95 };

    96 

    97 static void

    98 test_a_foo (TestI *self)

    99 {

   100   GValue args[1] = { { 0, } };

   101 

   102   record ("TestA::foo");

   103 

   104   g_value_init (&args[0], TEST_TYPE_A);

   105   g_value_set_object (&args[0], self);

   106 

   107   g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);

   108   g_signal_chain_from_overridden (args, NULL);

   109 

   110   g_value_unset (&args[0]);

   111 }

   112 

   113 static void

   114 test_a_bar (TestA *self)

   115 {

   116   record ("TestA::bar");

   117 }

   118 

   119 static gchar *

   120 test_a_baz (TestA    *self,

   121             GObject  *object,

   122             gpointer  pointer)

   123 {

   124   record ("TestA::baz");

   125 

   126   g_assert (object == G_OBJECT (self));

   127   g_assert (GPOINTER_TO_INT (pointer) == 23);

   128 

   129   return g_strdup ("TestA::baz");

   130 }

   131 

   132 static void

   133 test_a_class_init (TestAClass *class)

   134 {

   135   class->bar = test_a_bar;

   136 

   137   bar_signal_id = g_signal_new ("bar",

   138 				TEST_TYPE_A,

   139 				G_SIGNAL_RUN_LAST,

   140 				G_STRUCT_OFFSET (TestAClass, bar),

   141 				NULL, NULL,

   142 				g_cclosure_marshal_VOID__VOID,

   143 				G_TYPE_NONE, 0, NULL);

   144 

   145   baz_signal_id = g_signal_new_class_handler ("baz",

   146                                               TEST_TYPE_A,

   147                                               G_SIGNAL_RUN_LAST,

   148                                               G_CALLBACK (test_a_baz),

   149                                               NULL, NULL,

   150                                               g_cclosure_marshal_STRING__OBJECT_POINTER,

   151                                               G_TYPE_STRING, 2,

   152                                               G_TYPE_OBJECT,

   153                                               G_TYPE_POINTER);

   154 }

   155 

   156 static void

   157 test_a_interface_init (TestIClass *iface)

   158 {

   159   g_signal_override_class_closure (foo_signal_id,

   160 				   TEST_TYPE_A,

   161 				   g_cclosure_new (G_CALLBACK (test_a_foo),

   162 						   NULL, NULL));

   163 }

   164 

   165 static DEFINE_TYPE_FULL (TestA, test_a,

   166 			 test_a_class_init, NULL, NULL,

   167 			 G_TYPE_OBJECT,

   168 			 INTERFACE (test_a_interface_init, TEST_TYPE_I))

   169      

   170 #define TEST_TYPE_B (test_b_get_type())

   171 

   172 typedef struct _TestB TestB;

   173 typedef struct _TestBClass TestBClass;

   174 

   175 struct _TestB {

   176   TestA parent;

   177 };

   178 struct _TestBClass {

   179   TestAClass parent_class;

   180 };

   181 

   182 static void

   183 test_b_foo (TestI *self)

   184 {

   185   GValue args[1] = { { 0, } };

   186 

   187   record ("TestB::foo");

   188 

   189   g_value_init (&args[0], TEST_TYPE_A);

   190   g_value_set_object (&args[0], self);

   191 

   192   g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);

   193   g_signal_chain_from_overridden (args, NULL);

   194 

   195   g_value_unset (&args[0]);

   196 }

   197 

   198 static void

   199 test_b_bar (TestA *self)

   200 {

   201   GValue args[1] = { { 0, } };

   202 

   203   record ("TestB::bar");

   204 

   205   g_value_init (&args[0], TEST_TYPE_A);

   206   g_value_set_object (&args[0], self);

   207 

   208   g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);

   209   g_signal_chain_from_overridden (args, NULL);

   210 

   211   g_value_unset (&args[0]);

   212 }

   213 

   214 static gchar *

   215 test_b_baz (TestA    *self,

   216             GObject  *object,

   217             gpointer  pointer)

   218 {

   219   gchar *retval = NULL;

   220 

   221   record ("TestB::baz");

   222 

   223   g_assert (object == G_OBJECT (self));

   224   g_assert (GPOINTER_TO_INT (pointer) == 23);

   225 

   226   g_signal_chain_from_overridden_handler (self, object, pointer, &retval);

   227 

   228   if (retval)

   229     {

   230       gchar *tmp = g_strconcat (retval , ",TestB::baz", NULL);

   231       g_free (retval);

   232       retval = tmp;

   233     }

   234 

   235   return retval;

   236 }

   237 

   238 static void

   239 test_b_class_init (TestBClass *class)

   240 {

   241   g_signal_override_class_closure (foo_signal_id,

   242 				   TEST_TYPE_B,

   243 				   g_cclosure_new (G_CALLBACK (test_b_foo),

   244 						   NULL, NULL));

   245   g_signal_override_class_closure (bar_signal_id,

   246 				   TEST_TYPE_B,

   247 				   g_cclosure_new (G_CALLBACK (test_b_bar),

   248 						   NULL, NULL));

   249   g_signal_override_class_handler ("baz",

   250 				   TEST_TYPE_B,

   251 				   G_CALLBACK (test_b_baz));

   252 }

   253 

   254 static DEFINE_TYPE (TestB, test_b,

   255 		    test_b_class_init, NULL, NULL,

   256 		    TEST_TYPE_A)

   257 

   258 #define TEST_TYPE_C (test_c_get_type())

   259 

   260 typedef struct _TestC TestC;

   261 typedef struct _TestCClass TestCClass;

   262 

   263 struct _TestC {

   264   TestB parent;

   265 };

   266 struct _TestCClass {

   267   TestBClass parent_class;

   268 };

   269 

   270 static void

   271 test_c_foo (TestI *self)

   272 {

   273   GValue args[1] = { { 0, } };

   274 

   275   record ("TestC::foo");

   276 

   277   g_value_init (&args[0], TEST_TYPE_A);

   278   g_value_set_object (&args[0], self);

   279 

   280   g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);

   281   g_signal_chain_from_overridden (args, NULL);

   282 

   283   g_value_unset (&args[0]);

   284 }

   285 

   286 static void

   287 test_c_bar (TestA *self)

   288 {

   289   GValue args[1] = { { 0, } };

   290 

   291   record ("TestC::bar");

   292 

   293   g_value_init (&args[0], TEST_TYPE_A);

   294   g_value_set_object (&args[0], self);

   295 

   296   g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);

   297   g_signal_chain_from_overridden (args, NULL);

   298 

   299   g_value_unset (&args[0]);

   300 }

   301 

   302 static gchar *

   303 test_c_baz (TestA    *self,

   304             GObject  *object,

   305             gpointer  pointer)

   306 {

   307   gchar *retval = NULL;

   308 

   309   record ("TestC::baz");

   310 

   311   g_assert (object == G_OBJECT (self));

   312   g_assert (GPOINTER_TO_INT (pointer) == 23);

   313 

   314   g_signal_chain_from_overridden_handler (self, object, pointer, &retval);

   315 

   316   if (retval)

   317     {

   318       gchar *tmp = g_strconcat (retval , ",TestC::baz", NULL);

   319       g_free (retval);

   320       retval = tmp;

   321     }

   322 

   323   return retval;

   324 }

   325 

   326 static void

   327 test_c_class_init (TestBClass *class)

   328 {

   329   g_signal_override_class_closure (foo_signal_id,

   330 				   TEST_TYPE_C,

   331 				   g_cclosure_new (G_CALLBACK (test_c_foo),

   332 						   NULL, NULL));

   333   g_signal_override_class_closure (bar_signal_id,

   334 				   TEST_TYPE_C,

   335 				   g_cclosure_new (G_CALLBACK (test_c_bar),

   336 						   NULL, NULL));

   337   g_signal_override_class_handler ("baz",

   338 				   TEST_TYPE_C,

   339 				   G_CALLBACK (test_c_baz));

   340 }

   341 

   342 

   343 static DEFINE_TYPE (TestC, test_c,

   344 		    test_c_class_init, NULL, NULL,

   345 		    TEST_TYPE_B)

   346 

   347 static GString *test_string = NULL;

   348 gboolean failed = FALSE;

   349      

   350 static void

   351 record (const gchar *str)

   352 {

   353   if (test_string->len)

   354     g_string_append_c (test_string, ',');

   355   g_string_append (test_string, str);

   356 }

   357      

   358 static void

   359 test (GType        type,

   360       const gchar *signal,

   361       const gchar *expected,

   362       const gchar *expected_retval)

   363 {

   364   GObject *self = g_object_new (type, NULL);

   365 

   366   test_string = g_string_new (NULL);

   367 

   368   if (strcmp (signal, "baz"))

   369     {

   370       g_signal_emit_by_name (self, signal);

   371     }

   372   else

   373     {

   374       gchar *ret;

   375 

   376       g_signal_emit_by_name (self, signal, self, GINT_TO_POINTER (23), &ret);

   377 

   378       if (strcmp (ret, expected_retval) != 0)

   379         failed = TRUE;

   380     }

   381 

   382 #ifndef VERBOSE

   383   if (strcmp (test_string->str, expected) != 0)

   384 #endif

   385     {

   386       g_printerr ("*** emitting %s on a %s instance\n"

   387 		  "    Expecting: %s\n"

   388 		  "    Got: %s\n",

   389 		  signal, g_type_name (type),

   390 		  expected,

   391 		  test_string->str);

   392       

   393       if (strcmp (test_string->str, expected) != 0)

   394 	failed = TRUE;

   395     }

   396 

   397   g_string_free (test_string, TRUE);

   398 }

   399      

   400 int

   401 main (int argc, char **argv)

   402 {

   403 #ifdef __SYMBIAN32__

   404   g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

   405   g_set_print_handler(mrtPrintHandler);

   406   #endif /*__SYMBIAN32__*/

   407   g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |

   408 			  G_LOG_LEVEL_WARNING |

   409 			  G_LOG_LEVEL_CRITICAL);

   410   g_type_init();

   411 

   412   test (TEST_TYPE_A, "foo", "TestA::foo,TestI::foo", NULL);

   413   test (TEST_TYPE_A, "bar", "TestA::bar", NULL);

   414   test (TEST_TYPE_A, "baz", "TestA::baz", "TestA::baz");

   415 

   416   test (TEST_TYPE_B, "foo", "TestB::foo,TestA::foo,TestI::foo", NULL);

   417   test (TEST_TYPE_B, "bar", "TestB::bar,TestA::bar", NULL);

   418   test (TEST_TYPE_B, "baz", "TestB::baz,TestA::baz", "TestA::baz,TestB::baz");

   419 

   420   test (TEST_TYPE_C, "foo", "TestC::foo,TestB::foo,TestA::foo,TestI::foo", NULL);

   421   test (TEST_TYPE_C, "bar", "TestC::bar,TestB::bar,TestA::bar", NULL);

   422   test (TEST_TYPE_C, "baz", "TestC::baz,TestB::baz,TestA::baz", "TestA::baz,TestB::baz,TestC::baz");

   423 

   424   #ifdef __SYMBIAN32__

   425   testResultXml("override");

   426   #endif /*__SYMBIAN32__*/

   427   return failed ? 1 : 0;

   428 }