Symaptic: os/ossrv/glib/tsrc/BC/src/tg

     1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

3 *

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

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

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

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

8 *

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

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

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

    12 * Lesser General Public License for more details.

    13 *

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

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

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

    17 * Boston, MA 02111-1307, USA.

    18 *

    19 * Description:

    20 *

    21 */

    24 #undef	G_LOG_DOMAIN

    26 #undef G_DISABLE_ASSERT

    27 #undef G_DISABLE_CHECKS

    28 #undef G_DISABLE_CAST_CHECKS

    30 #undef VERBOSE

    31 #include <stdio.h>

    32 #include <string.h>

    33 #include <glib.h>

    34 #include <gmodule.h>

    36 #include <string.h>

    38 #include <glib.h>

    39 #include <glib-object.h>

    41 #include "testcommon.h"

    42 #include <stdlib.h>

    44 #ifdef SYMBIAN

    45 #include "mrt2_glib2_test.h"

    46 #endif /*SYMBIAN*/

    48 typedef struct _BaseObject        BaseObject;

    50 struct _EphyModule

    51 {

    52 	GTypeModule parent_instance;

    54 	GModule *library;

    56 	char *path;

    57 	GType type;

    58 	guint resident : 1;

    59 };

    61 typedef struct _EphyModule EphyModule;

    63 struct _BaseObject

    64 {

    65   GObject parent_instance;

    67   gint val1;

    68   gint val2;

    69   gint val3;

    70   gint val4;

    71 };

    72 static guint foo_signal_id = 0;

    73 static guint bar_signal_id = 0;

    75 static GType test_i_get_type (void);

    76 static GType test_a_get_type (void);

    77 static GType test_b_get_type (void);

    78 static GType test_c_get_type (void);

    80 static void  record (const gchar *str);

    82 #define TEST_TYPE_I (test_i_get_type ())

    83 #define DERIVED_TYPE_OBJECT          (derived_object_get_type ())

    85 typedef struct _TestI TestI;

    86 typedef struct _TestIClass TestIClass;

    88 struct _TestIClass

    89 {

    90   GTypeInterface base_iface;

    91 };

    93 //Added code

    94 #define TEST_TYPE_IFACE           (test_iface_get_type ())

    95 #define TEST_IFACE(obj)		  (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_IFACE, TestIface))

    96 #define TEST_IS_IFACE(obj)	  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_IFACE))

    97 #define TEST_IFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TEST_TYPE_IFACE, TestIfaceClass))

    98 typedef struct _TestIface      TestIface;

    99 typedef struct _TestIfaceClass TestIfaceClass;

   100 struct _TestIfaceClass

   101 {

   102   GTypeInterface base_iface;

   103   void	(*print_string)	(TestIface	*tiobj,

   104 			 const gchar	*string);

   105 };

   106 static void	iface_base_init		(TestIfaceClass	*iface);

   107 static void	iface_base_finalize	(TestIfaceClass	*iface);

   108 static void	print_foo		(TestIface	*tiobj,

   109 					 const gchar	*string);

   111 gpointer my_boxed_copy_function(gpointer boxed)

   112 {

   113 	return boxed;

   114 }

   116 void my_boxed_free_function(gpointer boxed)

   117 {

   118 }

   120 GType

   121 test_iface_get_type (void)

   122 {

   123   static GType test_iface_type = 0;

   125   if (!test_iface_type)

   126     {

   127       static const GTypeInfo test_iface_info =

   128       {

   129 	sizeof (TestIfaceClass),

   130 	(GBaseInitFunc)	iface_base_init,		/* base_init */

   131 	(GBaseFinalizeFunc) iface_base_finalize,	/* base_finalize */

   132       };

   134       test_iface_type = g_type_register_static (G_TYPE_INTERFACE, "TestIface", &test_iface_info, 0);

   135       g_type_interface_add_prerequisite (test_iface_type, G_TYPE_OBJECT);

   136     }

   138   return test_iface_type;

   139 }

   142 static guint iface_base_init_count = 0;

   143 static void

   144 iface_base_init (TestIfaceClass *iface)

   145 {

   146   iface_base_init_count++;

   147   if (iface_base_init_count == 1)

   148     {

   149       /* add signals here */

   150     }

   151 }

   152 static void

   153 iface_base_finalize (TestIfaceClass *iface)

   154 {

   155   iface_base_init_count--;

   156   if (iface_base_init_count == 0)

   157     {

   158       /* destroy signals here */

   159     }

   160 }

   161 static void

   162 print_foo (TestIface   *tiobj,

   163 	   const gchar *string)

   164 {

   165   if (!string)

   166     string = "<NULL>";

   167   g_print ("Iface-FOO: \"%s\" from %p\n", string, tiobj);

   168 }

   169 static void

   170 test_object_test_iface_init (gpointer giface,

   171 			     gpointer iface_data)

   172 {

   173   TestIfaceClass *iface = giface;

   175   g_assert (iface_data == GUINT_TO_POINTER (42));

   177   g_assert (G_TYPE_FROM_INTERFACE (iface) == TEST_TYPE_IFACE);

   179   /* assert iface_base_init() was already called */

   180   g_assert (iface_base_init_count > 0);

   182   /* initialize stuff */

   183   iface->print_string = print_foo;

   184 }

   186 /* --- TestObject --- */

   187 #define TEST_TYPE_OBJECT            (test_object_get_type ())

   188 #define TEST_OBJECT(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), TEST_TYPE_OBJECT, TestObject))

   189 #define TEST_OBJECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass))

   190 #define TEST_IS_OBJECT(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), TEST_TYPE_OBJECT))

   191 #define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT))

   192 #define TEST_OBJECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass))

   193 #define TEST_OBJECT_GET_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_OBJECT, TestObjectPrivate))

   194 typedef struct _TestObject        TestObject;

   195 typedef struct _TestObjectClass   TestObjectClass;

   196 typedef struct _TestObjectPrivate TestObjectPrivate;

   197 struct _TestObject

   198 {

   199   GObject parent_instance;

   200 };

   202 struct _TestObjectClass

   203 {

   204   GObjectClass parent_class;

   206   gchar* (*test_signal) (TestObject *tobject,

   207 			 TestIface  *iface_object,

   208 			 gpointer    tdata);

   209 };

   210 struct _TestObjectPrivate

   211 {

   212   int     dummy1;

   213   gdouble dummy2;

   214 };

   215 static void	test_object_class_init	(TestObjectClass	*class);

   216 static void	test_object_init	(TestObject		*tobject);

   217 static gboolean	test_signal_accumulator	(GSignalInvocationHint	*ihint,

   218 					 GValue            	*return_accu,

   219 					 const GValue       	*handler_return,

   220 					 gpointer                data);

   221 static gchar*	test_object_test_signal	(TestObject		*tobject,

   222 					 TestIface		*iface_object,

   223 					 gpointer		 tdata);

   226 GType

   227 test_object_get_type (void)

   228 {

   229   static GType test_object_type = 0;

   231   if (!test_object_type)

   232     {

   233       static const GTypeInfo test_object_info =

   234       {

   235 	sizeof (TestObjectClass),

   236 	NULL,           /* base_init */

   237 	NULL,           /* base_finalize */

   238 	(GClassInitFunc) test_object_class_init,

   239 	NULL,           /* class_finalize */

   240 	NULL,           /* class_data */

   241 	sizeof (TestObject),

   242 	5,              /* n_preallocs */

   243 	(GInstanceInitFunc) test_object_init,

   244       };

   245       GInterfaceInfo iface_info = { test_object_test_iface_init, NULL, GUINT_TO_POINTER (42) };

   247       test_object_type = g_type_register_static (G_TYPE_OBJECT, "TestObject", &test_object_info, 0);

   248       g_type_add_interface_static (test_object_type, TEST_TYPE_IFACE, &iface_info);

   249     }

   251   return test_object_type;

   252 }

   254 static void

   255 test_object_class_init (TestObjectClass *class)

   256 {

   257   /*  GObjectClass *gobject_class = G_OBJECT_CLASS (class); */

   258   guint sig_id;

   259   GQuark detail;

   260   gulong hook_id;

   261   GSignalEmissionHook hook_func;

   262   gpointer hook_data;

   263   GDestroyNotify data_destroy;

   264   gulong handler_id;

   265   GClosure closure;

   266   gpointer instance;

   267   GValue args[2];

   269   class->test_signal = test_object_test_signal;

   271   sig_id = g_signal_new ("test-signal",

   272 		G_OBJECT_CLASS_TYPE (class),

   273 		G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP | G_SIGNAL_DETAILED,

   274 		G_STRUCT_OFFSET (TestObjectClass, test_signal),

   275 		test_signal_accumulator, NULL,

   276 		g_cclosure_marshal_STRING__OBJECT_POINTER,

   277 		G_TYPE_STRING, 2, TEST_TYPE_IFACE, G_TYPE_POINTER);

   279   hook_id = g_signal_add_emission_hook      ( sig_id,

   280                                              detail,

   281                                              hook_func,

   282                                              "Data",

   283                                              data_destroy);

   286   g_type_class_add_private (class, sizeof (TestObjectPrivate));

   287 }

   289 static void

   290 print_bar (TestIface   *tiobj,

   291 	   const gchar *string)

   292 {

   293   TestIfaceClass *parent_iface;

   295   g_return_if_fail (TEST_IS_IFACE (tiobj));

   297   if (!string)

   298     string = "<NULL>";

   299   g_print ("Iface-BAR: \"%s\" from %p\n", string, tiobj);

   301   g_print ("chaining: ");

   302   parent_iface = g_type_interface_peek_parent (TEST_IFACE_GET_CLASS (tiobj));

   303   parent_iface->print_string (tiobj, string);

   305   g_assert (g_type_interface_peek_parent (parent_iface) == NULL);

   306 }

   307 static void

   308 test_object_init (TestObject *tobject)

   309 {

   310   TestObjectPrivate *priv;

   312   priv = TEST_OBJECT_GET_PRIVATE (tobject);

   314   g_assert (priv);

   315   g_assert ((gchar *)priv >= (gchar *)tobject + sizeof (TestObject));

   317   priv->dummy1 = 54321;

   318 }

   320 static gchar*

   321 test_object_test_signal (TestObject *tobject,

   322 			 TestIface  *iface_object,

   323 			 gpointer    tdata)

   324 {

   325   g_message ("::test_signal default_handler called");

   327   g_return_val_if_fail (TEST_IS_IFACE (iface_object), NULL);

   329   return g_strdup ("<default_handler>");

   330 }

   331 static gboolean

   332 test_signal_accumulator (GSignalInvocationHint *ihint,

   333 			 GValue                *return_accu,

   334 			 const GValue          *handler_return,

   335 			 gpointer               data)

   336 {

   337  const gchar *accu_string = g_value_get_string (return_accu);

   338 const  gchar *new_string = g_value_get_string (handler_return);

   339   gchar *result_string;

   341   if (accu_string)

   342     result_string = g_strconcat (accu_string, new_string, NULL);

   343   else if (new_string)

   344     result_string = g_strdup (new_string);

   345   else

   346     result_string = NULL;

   348   g_value_take_string (return_accu, result_string);

   350   return TRUE;

   351 }

   353 static void

   354 derived_object_test_iface_init (gpointer giface,

   355 				gpointer iface_data)

   356 {

   357   TestIfaceClass *iface = giface;

   359   g_assert (iface_data == GUINT_TO_POINTER (87));

   361   g_assert (G_TYPE_FROM_INTERFACE (iface) == TEST_TYPE_IFACE);

   363   /* assert test_object_test_iface_init() was already called */

   364   g_assert (iface->print_string == print_foo);

   366   /* override stuff */

   367   iface->print_string = print_bar;

   368 }

   370 /* --- DerivedObject --- */

   371 #define DERIVED_TYPE_OBJECT            (derived_object_get_type ())

   372 #define DERIVED_OBJECT(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), DERIVED_TYPE_OBJECT, DerivedObject))

   373 #define DERIVED_OBJECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DERIVED_TYPE_OBJECT, DerivedObjectClass))

   374 #define DERIVED_IS_OBJECT(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), DERIVED_TYPE_OBJECT))

   375 #define DERIVED_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DERIVED_TYPE_OBJECT))

   376 #define DERIVED_OBJECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DERIVED_TYPE_OBJECT, DerivedObjectClass))

   377 #define DERIVED_OBJECT_GET_PRIVATE(o)  (G_TYPE_INSTANCE_GET_PRIVATE ((o), DERIVED_TYPE_OBJECT, DerivedObjectPrivate))

   379 typedef struct _DerivedObject        DerivedObject;

   380 typedef struct _TestObjectClass      DerivedObjectClass;

   381 typedef struct _DerivedObjectPrivate DerivedObjectPrivate;

   382 struct _DerivedObject

   383 {

   384   TestObject parent_instance;

   385   int  dummy1;

   386   int  dummy2;

   387 };

   388 struct _DerivedObjectPrivate

   389 {

   390   char dummy;

   391 };

   392 static void derived_object_class_init (DerivedObjectClass *class);

   393 static void derived_object_init       (DerivedObject      *dobject);

   396 GType

   397 derived_object_get_type (void)

   398 {

   399   static GType derived_object_type = 0;

   401   if (!derived_object_type)

   402     {

   403       static const GTypeInfo derived_object_info =

   404       {

   405 	sizeof (DerivedObjectClass),

   406 	NULL,           /* base_init */

   407 	NULL,           /* base_finalize */

   408 	(GClassInitFunc) derived_object_class_init,

   409 	NULL,           /* class_finalize */

   410 	NULL,           /* class_data */

   411 	sizeof (DerivedObject),

   412 	5,              /* n_preallocs */

   413 	(GInstanceInitFunc) derived_object_init,

   414       };

   415       GInterfaceInfo iface_info = { derived_object_test_iface_init, NULL, GUINT_TO_POINTER (87) };

   417       derived_object_type = g_type_register_static (TEST_TYPE_OBJECT, "DerivedObject", &derived_object_info, 0);

   418       g_type_add_interface_static (derived_object_type, TEST_TYPE_IFACE, &iface_info);

   419     }

   421   return derived_object_type;

   422 }

   424 static void

   425 derived_object_class_init (DerivedObjectClass *class)

   426 {

   427   g_type_class_add_private (class, sizeof (DerivedObjectPrivate));

   428 }

   429 static void

   430 derived_object_init (DerivedObject *dobject)

   431 {

   432   TestObjectPrivate *test_priv;

   433   DerivedObjectPrivate *derived_priv;

   435   derived_priv = DERIVED_OBJECT_GET_PRIVATE (dobject);

   437   g_assert (derived_priv);

   438   g_assert ((gchar *)derived_priv >= (gchar *)TEST_OBJECT_GET_PRIVATE (dobject) + sizeof (TestObjectPrivate));

   440   test_priv = TEST_OBJECT_GET_PRIVATE (dobject);

   442   g_assert (test_priv);

   443   g_assert ((gchar *)test_priv >= (gchar *)dobject + sizeof (TestObject));

   445 }

   447 //addition over

   449 static void

   450 test_i_foo (TestI *self)

   451 {

   452   record ("TestI::foo");

   453 }

   455 static void

   456 test_i_default_init (gpointer g_class)

   457 {

   458   gint i;

   459   const char *name;

   460   GSignalQuery query;

   461   guint retval;

   462   guint n_ids[4];

   463   foo_signal_id = g_signal_newv ("foo",

   464 				 TEST_TYPE_I,

   465 				 G_SIGNAL_RUN_LAST,

   466 				 g_cclosure_new(G_CALLBACK(test_i_foo),

   467 						NULL, NULL),

   468 				 NULL, NULL,

   469 				 g_cclosure_marshal_VOID__VOID,

   470 				 G_TYPE_NONE, 0, NULL);

   472  g_assert(!strcmp(g_signal_name(foo_signal_id), "foo"));

   473  g_signal_query (foo_signal_id, &query);

   474  g_assert(query.signal_id == foo_signal_id);

   475  retval = g_signal_lookup("foo",TEST_TYPE_I);

   476  g_assert(retval == foo_signal_id);

   478  g_signal_list_ids               (TEST_TYPE_I,

   479                                              n_ids);

   480  g_assert(n_ids[0] == foo_signal_id);

   482  i = foo_signal_id ;

   483 }

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

   487 #define TEST_TYPE_A (test_a_get_type())

   489      typedef struct _TestA TestA;

   490      typedef struct _TestAClass TestAClass;

   492 struct _TestA {

   493   GObject parent;

   494 };

   495 struct _TestAClass {

   496   GObjectClass parent_class;

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

   499 };

   501 //Dummy function

   502 gint        GMyCompareDataFunc            (gconstpointer a,

   503                                              gconstpointer b,

   504                                              gpointer user_data)

   505 {

   507 return 0;

   508 }

   512 //Function to test the apis :

   513 static void

   514 test_set_val_apis (void)

   515 {

   516   GType type;

   517   gchar c;

   518   gchar *p="foo";

   519   gconstpointer ptr;

   520   gpointer ret_val = NULL;

   521   gpointer v_object ;

   522   gchar *retVal;

   523   GObject *object;

   524   GParamFlags flags;

   525   GParamSpec* paramSpec;

   526   GParamSpec *gpSpec = (GParamSpec * )g_malloc(sizeof (GParamSpec));

   527   GValue orig = { 0, };

   528   GValue orig1 = { 1, };

   529   GValue xform = { 0, };

   530   GValue param1 = { 0, };

   531   GTypeModule module ;

   532   GEnumValue values[] = { {0,"0","0"}, {1,"1","1"}};

   533   GValueArray value_array = {

   534   {

   535    0

   536   },

   537   {

   538    0

   539   }};

   541   GValueArray *ret_value_array;

   542   GCompareFunc compare_func;

   543   GCompareDataFunc compare_func1 = GMyCompareDataFunc;

   544   GValue *ret_value;

   545   gpointer user_data;

   546   GParamSpec *param;

   547   GQuark detail;

   548   GValue *return_value;

   549   GObject *ret_object;

   550   guint t;

   551   guint n_children = 10;

   552   GType *ret_gtype;

   553   GTypePlugin * ret_plugin;

   554   guint n_prerequisites = 1;

   555   const GInterfaceInfo interface_info;

   556   GType flag_type,boxed_type;

   557   GFlagsValue flag_value = {0,"0","0"};

   558   int dummy;

   559   gpointer boxed_value = &dummy;

   560   GParamSpec *spec;

   561   gchar *boxed_variable = "abc";

   563   type = g_enum_register_static ("TestEnum", values);

   564  g_value_init (&orig, type);

   565  g_value_set_enum (&orig, 5);

   566  t = g_value_get_enum(&orig);

   567  g_assert(t == 5);

   569  memset (&xform, 0, sizeof (GValue));

   570  g_value_init (&xform, G_TYPE_CHAR);

   571  g_value_set_char (&xform, 10);

   572  g_assert (xform.data[0].v_int == '\n');

   574  memset (&xform, 0, sizeof (GValue));

   575  g_value_init (&xform, G_TYPE_DOUBLE);

   576  g_value_set_double (&xform, 100.00);

   577  g_assert (xform.data[0].v_double == 100.00);

   578  g_assert (g_value_get_double (&xform) == 100.00);

   581  memset (&xform, 0, sizeof (GValue));

   582  g_value_init (&xform, G_TYPE_FLOAT);

   583  g_value_set_float (&xform, 1.0);

   584  g_assert (xform.data[0].v_float == 1.0);

   585  g_assert (g_value_get_float(&xform) ==  1.0);

   587  memset (&xform, 0, sizeof (GValue));

   588  g_value_init (&xform, G_TYPE_INT64);

   589  g_value_set_int64 (&xform, 2555);

   590  g_assert (xform.data[0].v_int64 == 2555);

   592  memset (&xform, 0, sizeof (GValue));

   593  g_value_init (&xform, G_TYPE_LONG);

   594  g_value_set_long (&xform, 2555);

   595  g_assert (xform.data[0].v_long == 2555);

   597  memset (&xform, 0, sizeof (GValue));

   598  g_value_init (&xform, G_TYPE_UCHAR);

   599  g_value_set_uchar (&xform, 10);

   600  g_assert (xform.data[0].v_uint == '\n');

   602  memset (&xform, 0, sizeof (GValue));

   603  g_value_init (&xform, G_TYPE_UINT);

   604  g_value_set_uint (&xform, 100);

   605  g_assert (xform.data[0].v_uint == 100);

   607  memset (&xform, 0, sizeof (GValue));

   608  g_value_init (&xform, G_TYPE_UINT64);

   609  g_value_set_uint64 (&xform, 1000000);

   610  g_assert (xform.data[0].v_uint64 == 1000000);

   612  memset (&xform, 0, sizeof (GValue));

   613  g_value_init (&xform, G_TYPE_ULONG);

   614  g_value_set_ulong (&xform, 1000000);

   615  g_assert (xform.data[0].v_ulong == 1000000);

   617  memset (&xform, 0, sizeof (GValue));

   618  g_value_init (&xform, G_TYPE_STRING);

   619  g_value_set_string (&xform, "Hello");

   620  g_assert (!strcmp(xform.data[0].v_pointer , "Hello"));

   622  memset (&xform, 0, sizeof (GValue));

   623  g_value_init (&xform, G_TYPE_STRING);

   624  g_value_set_static_string (&xform, "Hello");

   625  g_assert (!strcmp(xform.data[0].v_pointer , "Hello"));

   627  memset (&xform, 0, sizeof (GValue));

   628  g_value_init (&xform, G_TYPE_POINTER);

   629  g_value_set_pointer (&xform, p);

   630  g_assert (xform.data[0].v_pointer == p);

   632  memset (&xform, 0, sizeof (GValue));

   633  g_value_init (&xform, G_TYPE_STRING);

   634  g_value_set_string (&xform, "World");

   635  retVal = g_value_dup_string (&xform);

   636  g_assert (!strcmp(retVal , "World"));

   638  ret_value_array = g_value_array_copy (&value_array);

   640  g_assert (ret_value_array != NULL );

   642  g_value_array_free(ret_value_array);

   644  ret_value_array = g_value_array_prepend(&value_array, &orig);

   646  g_assert (ret_value_array != NULL );

   648  ret_value = g_value_array_get_nth (&value_array, 0);

   650  g_assert (ret_value_array != NULL );

   652  ret_value_array = g_value_array_sort(&value_array, compare_func);

   654  g_assert (ret_value_array != NULL );

   656  ret_value_array = g_value_array_sort_with_data  (&value_array,

   657                                               compare_func1,

   658                                               user_data);

   660  g_assert (ret_value_array != NULL );

   663  memset (&xform, 0, sizeof (GValue));

   664  g_value_init (&xform, G_TYPE_PARAM);

   666  g_value_set_param (&xform, NULL);

   668  g_assert (&xform != NULL );

   670  g_value_set_param_take_ownership(&xform, NULL);

   672  g_assert (&xform != NULL );

   674  paramSpec = g_value_dup_param (&xform);

   676  g_assert (paramSpec == NULL );

   678  //g_signal_emitv (&orig, 1, detail, return_value);

   679  memset (&xform, 0, sizeof (GValue));

   680  g_value_init (&xform, G_TYPE_POINTER);

   681  ret_val = g_value_get_pointer(&xform);

   682  g_assert (ret_val == NULL );

   684  memset (&xform, 0, sizeof (GValue));

   685  g_value_init (&xform, G_TYPE_OBJECT);

   686  ret_object = g_value_dup_object(&xform);

   687  g_assert (ret_object == NULL );

   688  g_value_set_object_take_ownership (&xform, NULL);

   690  memset (&xform, 0, sizeof (GValue));

   691  flag_type = g_flags_register_static("TestFlag",&flag_value);

   692  g_value_init(&xform , flag_type);

   693  g_value_set_flags (&xform , 1);

   694  t = g_value_get_flags (&xform);

   695  g_assert (t == 1);

   697  memset (&xform, 0, sizeof (GValue));

   698  boxed_type = g_boxed_type_register_static("TestBoxed",my_boxed_copy_function,my_boxed_free_function);

   699  g_value_init (&xform, boxed_type);

   700  g_value_set_boxed (&xform,boxed_variable);

   701  ret_val = g_value_get_boxed (&xform);

   702  g_assert (ret_val == boxed_variable);

   704  g_value_set_static_boxed (&xform, "abc");

   705  g_value_set_boxed_take_ownership (&xform, "abc");

   706  g_assert (&xform != NULL);

   707  ret_val = g_value_dup_boxed (&xform);

   708  g_assert (ret_val == boxed_variable);

   710  memset (&xform, 0, sizeof (GValue));

   711  g_value_init(&xform,G_TYPE_OBJECT);

   712  ret_val = g_value_get_object(&xform);

   713  g_assert (ret_val == NULL);

   715  memset (&xform, 0, sizeof (GValue));

   716  g_value_init (&xform, G_TYPE_PARAM);

   717  spec = g_param_spec_int

   718 	(

   719 		"property-a",				/* property name */

   720  		"a",					/* nickname */

   721 		"Mysterty value 1",			/* description */

   722 		5,					/* minimum */

   723 		10,					/* maximum */

   724 		5,					/* default */

   725 		G_PARAM_READABLE |G_PARAM_WRITABLE	/* GParamSpecFlags */

   726 	);

   727  g_value_set_param(&xform,spec);

   728  param = g_value_get_param(&xform);

   729  g_assert (param == spec);

   731  ret_gtype = g_type_children (G_TYPE_INT, &n_children);

   732  g_assert (ret_gtype != NULL);

   733  free(ret_gtype);

   735  ret_plugin = g_type_interface_get_plugin (G_TYPE_INT, G_TYPE_INTERFACE);

   736  g_assert (ret_plugin == NULL);

   738  ret_gtype = g_type_interface_prerequisites  (G_TYPE_INTERFACE,&n_prerequisites);

   739  g_assert (ret_gtype != NULL);

   740  free(ret_gtype);

   742  //g_type_module_set_name (&module, "Name");

   743  //g_object_set_property (object,

   744  //                                            NULL,

   745  //                                            &xform);

   746 // g_type_class_unref_uncached     (NULL);*/

   748 }

   750 //Function to test the apis

   752 static void

   753 test_param_spec_apis (void)

   754 {

   755   GParamFlags flags;

   756   GParamSpec* paramSpec;

   757   gchar *qdata = "abc";

   758   GQuark quark = g_quark_from_string(qdata);

   759   gpointer retVal;

   760   gpointer data= "MY data";

   761   gchar *testData;

   762   GDestroyNotify destroy;

   763   GType type;

   764   gboolean ret;

   765   GValue orig = { 0, };

   766   GValue xform = { 0, };

   767   GEnumValue values[] = { {0,"0","0"}, {1,"1","1"}};

   768   GFlagsValue flag_value = {1,"1","1"};

   769   GType enum_type,flags_type,boxed_type;

   770   memset (&orig, 0, sizeof (GValue));

   771   g_value_init (&orig, G_TYPE_POINTER);

   773   memset (&xform, 0, sizeof (GValue));

   774   g_value_init (&xform, G_TYPE_POINTER);

   776   paramSpec = g_param_spec_uchar("String1","Hello","World", 0,100,10, flags);

   778   g_assert (!strcmp(paramSpec->_nick , "Hello"));

   780   paramSpec = g_param_spec_uint("String2","Hello","World", 0,255,50, flags);

   782   g_assert (!strcmp(paramSpec->name , "String2"));

   784   paramSpec = g_param_spec_uint64("String3","Hello","World", 0,255555,1000, flags);

   786   g_assert (!strcmp(paramSpec->name , "String3"));

   788   paramSpec = g_param_spec_ulong("String4","Hello","World", 0,255,100, flags);

   790   g_assert (!strcmp(paramSpec->name , "String4"));

   792   paramSpec = g_param_spec_unichar("String5","Hello","World",'X', flags);

   794   g_assert (!strcmp(paramSpec->name , "String5"));

   796   paramSpec = g_param_spec_string("String6","Hello","World","String", flags);

   798   g_assert (!strcmp(paramSpec->name , "String6"));

   800   paramSpec = g_param_spec_int64("String7","Hello","World",-100,25555,500, flags);

   802   g_assert (!strcmp(paramSpec->name , "String7"));

   804   paramSpec = g_param_spec_long("String8","Hello","World",-100,2555,100, flags);

   806   g_assert (!strcmp(paramSpec->name , "String8"));

   808   g_param_spec_set_qdata(paramSpec,quark,qdata);

   809   retVal = g_param_spec_steal_qdata(paramSpec, quark);

   810   g_assert (retVal == qdata);

   812   g_param_spec_set_qdata(paramSpec,100, data);

   814   retVal = g_param_spec_get_qdata(paramSpec,100);

   816   testData = (gchar *)retVal;

   818   g_assert (!strcmp(testData , "MY data"));

   820   g_param_spec_set_qdata_full (paramSpec, 200, data, destroy);

   822   retVal = g_param_spec_get_qdata(paramSpec, 200);

   823   testData = (gchar *)retVal;

   824   g_assert (!strcmp(testData , "MY data"));

   826   paramSpec = g_param_spec_object("String9","Hello","World",G_TYPE_OBJECT,flags);

   827   g_assert (!strcmp(paramSpec->name , "String9"));

   829   paramSpec = g_param_spec_param("String10","Hello","World",G_TYPE_PARAM,flags);

   831   g_assert (!strcmp(paramSpec->name , "String10"));

   833   paramSpec = g_param_spec_pointer("String11", "Hello", "World", flags);

   835   g_assert (!strcmp(paramSpec->name , "String11"));

   837   ret = g_param_value_convert (paramSpec, &orig, &xform, TRUE);

   839   g_assert (ret == TRUE);

   841   ret = g_param_value_defaults(paramSpec , &xform);

   843   g_assert (ret == TRUE);

   845   paramSpec = g_param_spec_value_array ("String12", "Hello", "World", NULL, flags);

   847   g_assert (!strcmp(paramSpec->name , "String12"));

   849   paramSpec = g_param_spec_float("String13","Hello", "World",0.00,255.00,100.00,flags);

   851   g_assert (!strcmp(paramSpec->name , "String13"));

   853   paramSpec = g_param_spec_flags("String14","Hello", "World",G_TYPE_FLAGS,0,flags);

   855   g_assert (!strcmp(paramSpec->name , "String14"));

   857   paramSpec = g_param_spec_double("String15","Hello", "World", 0.00,25554.00,100.00,flags);

   859   g_assert (!strcmp(paramSpec->name , "String15"));

   861   paramSpec = g_param_spec_char("String16","Hello", "World", 'a','z','c',flags);

   863   g_assert (!strcmp(paramSpec->name , "String16"));

   865   paramSpec = g_param_spec_boolean("String17", "Hello", "World",TRUE,flags);

   867   g_assert (!strcmp(paramSpec->name , "String17"));

   869   flags_type = g_flags_register_static("TestFlag1",&flag_value);

   870   paramSpec = g_param_spec_flags   ("String18", "Hello", "World", flags_type, 1, flags);

   871   g_assert (!strcmp(paramSpec->name , "String18"));

   873   enum_type = g_enum_register_static("TestEnum1",values);

   874   paramSpec = g_param_spec_enum ("String19", "Hello", "World", enum_type, 0, flags);

   875   g_assert (!strcmp(paramSpec->name , "String19"));

   877   boxed_type = g_boxed_type_register_static("TestBoxed1",my_boxed_copy_function,my_boxed_free_function);

   878   paramSpec =  g_param_spec_boxed ("String20", "Hello", "World", boxed_type, flags);

   879   g_assert (!strcmp(paramSpec->name , "String20"));

   881 }

   883 static void test_object_apis()

   884 {

   885   BaseObject *object;

   886   EphyModule *module;

   887   GObjectClass *object_class;

   888   GParamSpec **properties;

   889   gint n_properties;

   890   gpointer p = "Hello";

   892   gint val1, val2, val3, val4;

   894   g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |

   895 			  G_LOG_LEVEL_WARNING |

   896 			  G_LOG_LEVEL_CRITICAL);

   898   g_type_init ();

   900   object = g_object_new (DERIVED_TYPE_OBJECT , NULL);

   901 #if 0

   902   module = g_object_new (EPHY_TYPE_MODULE, NULL);

   904   ephy_module_new_object(module);

   905   g_type_module_set_name          (G_TYPE_MODULE (module),

   906                                              "name");

   908 #endif

   910 }

   914 static void

   915 test_a_foo (TestI *self)

   916 {

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

   919   record ("TestA::foo");

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

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

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

   926   g_signal_chain_from_overridden (args, NULL);

   928   g_value_unset (&args[0]);

   929 }

   931 static void

   932 test_a_bar (TestA *self)

   933 {

   934   record ("TestA::bar");

   935 }

   937 static void

   938 test_a_class_init (TestAClass *class)

   939 {

   940   class->bar = test_a_bar;

   942   bar_signal_id = g_signal_new ("bar",

   943 				TEST_TYPE_A,

   944 				G_SIGNAL_RUN_LAST,

   945 				G_STRUCT_OFFSET (TestAClass, bar),

   946 				NULL, NULL,

   947 				g_cclosure_marshal_VOID__VOID,

   948 				G_TYPE_NONE, 0, NULL);

   949 }

   951 static void

   952 test_a_interface_init (TestIClass *iface)

   953 {

   954   g_signal_override_class_closure (foo_signal_id,

   955 				   TEST_TYPE_A,

   956 				   g_cclosure_new (G_CALLBACK (test_a_foo),

   957 				   		   NULL, NULL));

   958 }

   960 static DEFINE_TYPE_FULL (TestA, test_a,

   961 			 test_a_class_init, NULL, NULL,

   962 			 G_TYPE_OBJECT,

   963 			 INTERFACE (test_a_interface_init, TEST_TYPE_I))

   965 #define TEST_TYPE_B (test_b_get_type())

   967 typedef struct _TestB TestB;

   968 typedef struct _TestBClass TestBClass;

   970 struct _TestB {

   971   TestA parent;

   972 };

   973 struct _TestBClass {

   974   TestAClass parent_class;

   975 };

   977 static void

   978 test_b_foo (TestA *self)

   979 {

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

   982   record ("TestB::foo");

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

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

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

   988   g_signal_chain_from_overridden (args, NULL);

   990   g_value_unset (&args[0]);

   991 }

   993 static void

   994 test_b_bar (TestI *self)

   995 {

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

   998   record ("TestB::bar");

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

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

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

  1004   g_signal_chain_from_overridden (args, NULL);

  1006   g_value_unset (&args[0]);

  1007 }

  1009 static void

  1010 test_b_class_init (TestBClass *class)

  1011 {

  1012   g_signal_override_class_closure (foo_signal_id,

  1013 				   TEST_TYPE_B,

  1014 				   g_cclosure_new (G_CALLBACK (test_b_foo),

  1015 						   NULL, NULL));

  1016   g_signal_override_class_closure (bar_signal_id,

  1017 				   TEST_TYPE_B,

  1018 				   g_cclosure_new (G_CALLBACK (test_b_bar),

  1019 						   NULL, NULL));

  1020 }

  1022 static DEFINE_TYPE (TestB, test_b,

  1023 		    test_b_class_init, NULL, NULL,

  1024 		    TEST_TYPE_A)

  1026 #define TEST_TYPE_C (test_c_get_type())

  1028 typedef struct _TestC TestC;

  1029 typedef struct _TestCClass TestCClass;

  1031 struct _TestC {

  1032   TestB parent;

  1033 };

  1034 struct _TestCClass {

  1035   TestBClass parent_class;

  1036 };

  1038 static void

  1039 test_c_foo (TestA *self)

  1040 {

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

  1043   record ("TestC::foo");

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

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

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

  1049   g_signal_chain_from_overridden (args, NULL);

  1051   g_value_unset (&args[0]);

  1052 }

  1054 static void

  1055 test_c_bar (TestI *self)

  1056 {

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

  1059   record ("TestC::bar");

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

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

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

  1065   g_signal_chain_from_overridden (args, NULL);

  1067   g_value_unset (&args[0]);

  1068 }

  1070 static void

  1071 test_c_class_init (TestBClass *class)

  1072 {

  1073   g_signal_override_class_closure (foo_signal_id,

  1074 				   TEST_TYPE_C,

  1075 				   g_cclosure_new (G_CALLBACK (test_c_foo),

  1076 						   NULL, NULL));

  1077   g_signal_override_class_closure (bar_signal_id,

  1078 				   TEST_TYPE_C,

  1079 				   g_cclosure_new (G_CALLBACK (test_c_bar),

  1080 						   NULL, NULL));

  1081 }

  1084 static DEFINE_TYPE (TestC, test_c,

  1085 		    test_c_class_init, NULL, NULL,

  1086 		    TEST_TYPE_B)

  1088 static GString *test_string = NULL;

  1089 gboolean failed = FALSE;

  1091 static void

  1092 record (const gchar *str)

  1093 {

  1094   if (test_string->len)

  1095     g_string_append_c (test_string, ',');

  1096   g_string_append (test_string, str);

  1097 }

  1099 int

  1100 main (int argc, char **argv)

  1101 {

  1102   gpointer p;

  1104 #ifdef SYMBIAN

  1105   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);

  1106 #endif /*SYMBIAN*/

  1108   g_type_init();

  1110   test_i_default_init(p);

  1112   test_set_val_apis();

  1114   test_param_spec_apis();

  1116   test_object_apis();

  1118   #if SYMBIAN

  1119   testResultXml("g_test1");

  1120   #endif /* EMULATOR */

  1122   return failed ? 1 : 0;

  1123 }

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--