|
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 */ |
|
22 |
|
23 |
|
24 #undef G_LOG_DOMAIN |
|
25 |
|
26 #undef G_DISABLE_ASSERT |
|
27 #undef G_DISABLE_CHECKS |
|
28 #undef G_DISABLE_CAST_CHECKS |
|
29 |
|
30 #undef VERBOSE |
|
31 #include <stdio.h> |
|
32 #include <string.h> |
|
33 #include <glib.h> |
|
34 #include <gmodule.h> |
|
35 |
|
36 #include <string.h> |
|
37 |
|
38 #include <glib.h> |
|
39 #include <glib-object.h> |
|
40 |
|
41 #include "testcommon.h" |
|
42 |
|
43 #ifdef SYMBIAN |
|
44 #include "mrt2_glib2_test.h" |
|
45 #endif /*SYMBIAN*/ |
|
46 |
|
47 typedef struct _BaseObject BaseObject; |
|
48 |
|
49 struct _EphyModule |
|
50 { |
|
51 GTypeModule parent_instance; |
|
52 |
|
53 GModule *library; |
|
54 |
|
55 char *path; |
|
56 GType type; |
|
57 guint resident : 1; |
|
58 }; |
|
59 |
|
60 typedef struct _EphyModule EphyModule; |
|
61 |
|
62 struct _BaseObject |
|
63 { |
|
64 GObject parent_instance; |
|
65 |
|
66 gint val1; |
|
67 gint val2; |
|
68 gint val3; |
|
69 gint val4; |
|
70 }; |
|
71 static guint foo_signal_id = 0; |
|
72 static guint bar_signal_id = 0; |
|
73 |
|
74 static GType test_i_get_type (void); |
|
75 static GType test_a_get_type (void); |
|
76 static GType test_b_get_type (void); |
|
77 static GType test_c_get_type (void); |
|
78 |
|
79 static void record (const gchar *str); |
|
80 |
|
81 #define TEST_TYPE_I (test_i_get_type ()) |
|
82 #define DERIVED_TYPE_OBJECT (derived_object_get_type ()) |
|
83 |
|
84 typedef struct _TestI TestI; |
|
85 typedef struct _TestIClass TestIClass; |
|
86 |
|
87 struct _TestIClass |
|
88 { |
|
89 GTypeInterface base_iface; |
|
90 }; |
|
91 |
|
92 //Added code |
|
93 #define TEST_TYPE_IFACE (test_iface_get_type ()) |
|
94 #define TEST_IFACE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_IFACE, TestIface)) |
|
95 #define TEST_IS_IFACE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_IFACE)) |
|
96 #define TEST_IFACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TEST_TYPE_IFACE, TestIfaceClass)) |
|
97 typedef struct _TestIface TestIface; |
|
98 typedef struct _TestIfaceClass TestIfaceClass; |
|
99 struct _TestIfaceClass |
|
100 { |
|
101 GTypeInterface base_iface; |
|
102 void (*print_string) (TestIface *tiobj, |
|
103 const gchar *string); |
|
104 }; |
|
105 static void iface_base_init (TestIfaceClass *iface); |
|
106 static void iface_base_finalize (TestIfaceClass *iface); |
|
107 static void print_foo (TestIface *tiobj, |
|
108 const gchar *string); |
|
109 |
|
110 gpointer my_boxed_copy_function(gpointer boxed) |
|
111 { |
|
112 return boxed; |
|
113 } |
|
114 |
|
115 void my_boxed_free_function(gpointer boxed) |
|
116 { |
|
117 } |
|
118 |
|
119 GType |
|
120 test_iface_get_type (void) |
|
121 { |
|
122 static GType test_iface_type = 0; |
|
123 |
|
124 if (!test_iface_type) |
|
125 { |
|
126 static const GTypeInfo test_iface_info = |
|
127 { |
|
128 sizeof (TestIfaceClass), |
|
129 (GBaseInitFunc) iface_base_init, /* base_init */ |
|
130 (GBaseFinalizeFunc) iface_base_finalize, /* base_finalize */ |
|
131 }; |
|
132 |
|
133 test_iface_type = g_type_register_static (G_TYPE_INTERFACE, "TestIface", &test_iface_info, 0); |
|
134 g_type_interface_add_prerequisite (test_iface_type, G_TYPE_OBJECT); |
|
135 } |
|
136 |
|
137 return test_iface_type; |
|
138 } |
|
139 |
|
140 |
|
141 static guint iface_base_init_count = 0; |
|
142 static void |
|
143 iface_base_init (TestIfaceClass *iface) |
|
144 { |
|
145 iface_base_init_count++; |
|
146 if (iface_base_init_count == 1) |
|
147 { |
|
148 /* add signals here */ |
|
149 } |
|
150 } |
|
151 static void |
|
152 iface_base_finalize (TestIfaceClass *iface) |
|
153 { |
|
154 iface_base_init_count--; |
|
155 if (iface_base_init_count == 0) |
|
156 { |
|
157 /* destroy signals here */ |
|
158 } |
|
159 } |
|
160 static void |
|
161 print_foo (TestIface *tiobj, |
|
162 const gchar *string) |
|
163 { |
|
164 if (!string) |
|
165 string = "<NULL>"; |
|
166 g_print ("Iface-FOO: \"%s\" from %p\n", string, tiobj); |
|
167 } |
|
168 static void |
|
169 test_object_test_iface_init (gpointer giface, |
|
170 gpointer iface_data) |
|
171 { |
|
172 TestIfaceClass *iface = giface; |
|
173 |
|
174 g_assert (iface_data == GUINT_TO_POINTER (42)); |
|
175 |
|
176 g_assert (G_TYPE_FROM_INTERFACE (iface) == TEST_TYPE_IFACE); |
|
177 |
|
178 /* assert iface_base_init() was already called */ |
|
179 g_assert (iface_base_init_count > 0); |
|
180 |
|
181 /* initialize stuff */ |
|
182 iface->print_string = print_foo; |
|
183 } |
|
184 |
|
185 /* --- TestObject --- */ |
|
186 #define TEST_TYPE_OBJECT (test_object_get_type ()) |
|
187 #define TEST_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), TEST_TYPE_OBJECT, TestObject)) |
|
188 #define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) |
|
189 #define TEST_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), TEST_TYPE_OBJECT)) |
|
190 #define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) |
|
191 #define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) |
|
192 #define TEST_OBJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_OBJECT, TestObjectPrivate)) |
|
193 typedef struct _TestObject TestObject; |
|
194 typedef struct _TestObjectClass TestObjectClass; |
|
195 typedef struct _TestObjectPrivate TestObjectPrivate; |
|
196 struct _TestObject |
|
197 { |
|
198 GObject parent_instance; |
|
199 }; |
|
200 |
|
201 struct _TestObjectClass |
|
202 { |
|
203 GObjectClass parent_class; |
|
204 |
|
205 gchar* (*test_signal) (TestObject *tobject, |
|
206 TestIface *iface_object, |
|
207 gpointer tdata); |
|
208 }; |
|
209 struct _TestObjectPrivate |
|
210 { |
|
211 int dummy1; |
|
212 gdouble dummy2; |
|
213 }; |
|
214 static void test_object_class_init (TestObjectClass *class); |
|
215 static void test_object_init (TestObject *tobject); |
|
216 static gboolean test_signal_accumulator (GSignalInvocationHint *ihint, |
|
217 GValue *return_accu, |
|
218 const GValue *handler_return, |
|
219 gpointer data); |
|
220 static gchar* test_object_test_signal (TestObject *tobject, |
|
221 TestIface *iface_object, |
|
222 gpointer tdata); |
|
223 |
|
224 |
|
225 GType |
|
226 test_object_get_type (void) |
|
227 { |
|
228 static GType test_object_type = 0; |
|
229 |
|
230 if (!test_object_type) |
|
231 { |
|
232 static const GTypeInfo test_object_info = |
|
233 { |
|
234 sizeof (TestObjectClass), |
|
235 NULL, /* base_init */ |
|
236 NULL, /* base_finalize */ |
|
237 (GClassInitFunc) test_object_class_init, |
|
238 NULL, /* class_finalize */ |
|
239 NULL, /* class_data */ |
|
240 sizeof (TestObject), |
|
241 5, /* n_preallocs */ |
|
242 (GInstanceInitFunc) test_object_init, |
|
243 }; |
|
244 GInterfaceInfo iface_info = { test_object_test_iface_init, NULL, GUINT_TO_POINTER (42) }; |
|
245 |
|
246 test_object_type = g_type_register_static (G_TYPE_OBJECT, "TestObject", &test_object_info, 0); |
|
247 g_type_add_interface_static (test_object_type, TEST_TYPE_IFACE, &iface_info); |
|
248 } |
|
249 |
|
250 return test_object_type; |
|
251 } |
|
252 |
|
253 static void |
|
254 test_object_class_init (TestObjectClass *class) |
|
255 { |
|
256 /* GObjectClass *gobject_class = G_OBJECT_CLASS (class); */ |
|
257 guint sig_id; |
|
258 GQuark detail; |
|
259 gulong hook_id; |
|
260 GSignalEmissionHook hook_func; |
|
261 gpointer hook_data; |
|
262 GDestroyNotify data_destroy; |
|
263 gulong handler_id; |
|
264 GClosure closure; |
|
265 gpointer instance; |
|
266 GValue args[2]; |
|
267 |
|
268 class->test_signal = test_object_test_signal; |
|
269 |
|
270 sig_id = g_signal_new ("test-signal", |
|
271 G_OBJECT_CLASS_TYPE (class), |
|
272 G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP | G_SIGNAL_DETAILED, |
|
273 G_STRUCT_OFFSET (TestObjectClass, test_signal), |
|
274 test_signal_accumulator, NULL, |
|
275 g_cclosure_marshal_STRING__OBJECT_POINTER, |
|
276 G_TYPE_STRING, 2, TEST_TYPE_IFACE, G_TYPE_POINTER); |
|
277 |
|
278 hook_id = g_signal_add_emission_hook ( sig_id, |
|
279 detail, |
|
280 hook_func, |
|
281 "Data", |
|
282 data_destroy); |
|
283 |
|
284 |
|
285 g_type_class_add_private (class, sizeof (TestObjectPrivate)); |
|
286 } |
|
287 |
|
288 static void |
|
289 print_bar (TestIface *tiobj, |
|
290 const gchar *string) |
|
291 { |
|
292 TestIfaceClass *parent_iface; |
|
293 |
|
294 g_return_if_fail (TEST_IS_IFACE (tiobj)); |
|
295 |
|
296 if (!string) |
|
297 string = "<NULL>"; |
|
298 g_print ("Iface-BAR: \"%s\" from %p\n", string, tiobj); |
|
299 |
|
300 g_print ("chaining: "); |
|
301 parent_iface = g_type_interface_peek_parent (TEST_IFACE_GET_CLASS (tiobj)); |
|
302 parent_iface->print_string (tiobj, string); |
|
303 |
|
304 g_assert (g_type_interface_peek_parent (parent_iface) == NULL); |
|
305 } |
|
306 static void |
|
307 test_object_init (TestObject *tobject) |
|
308 { |
|
309 TestObjectPrivate *priv; |
|
310 |
|
311 priv = TEST_OBJECT_GET_PRIVATE (tobject); |
|
312 |
|
313 g_assert (priv); |
|
314 g_assert ((gchar *)priv >= (gchar *)tobject + sizeof (TestObject)); |
|
315 |
|
316 priv->dummy1 = 54321; |
|
317 } |
|
318 |
|
319 static gchar* |
|
320 test_object_test_signal (TestObject *tobject, |
|
321 TestIface *iface_object, |
|
322 gpointer tdata) |
|
323 { |
|
324 g_message ("::test_signal default_handler called"); |
|
325 |
|
326 g_return_val_if_fail (TEST_IS_IFACE (iface_object), NULL); |
|
327 |
|
328 return g_strdup ("<default_handler>"); |
|
329 } |
|
330 static gboolean |
|
331 test_signal_accumulator (GSignalInvocationHint *ihint, |
|
332 GValue *return_accu, |
|
333 const GValue *handler_return, |
|
334 gpointer data) |
|
335 { |
|
336 const gchar *accu_string = g_value_get_string (return_accu); |
|
337 const gchar *new_string = g_value_get_string (handler_return); |
|
338 gchar *result_string; |
|
339 |
|
340 if (accu_string) |
|
341 result_string = g_strconcat (accu_string, new_string, NULL); |
|
342 else if (new_string) |
|
343 result_string = g_strdup (new_string); |
|
344 else |
|
345 result_string = NULL; |
|
346 |
|
347 g_value_take_string (return_accu, result_string); |
|
348 |
|
349 return TRUE; |
|
350 } |
|
351 |
|
352 static void |
|
353 derived_object_test_iface_init (gpointer giface, |
|
354 gpointer iface_data) |
|
355 { |
|
356 TestIfaceClass *iface = giface; |
|
357 |
|
358 g_assert (iface_data == GUINT_TO_POINTER (87)); |
|
359 |
|
360 g_assert (G_TYPE_FROM_INTERFACE (iface) == TEST_TYPE_IFACE); |
|
361 |
|
362 /* assert test_object_test_iface_init() was already called */ |
|
363 g_assert (iface->print_string == print_foo); |
|
364 |
|
365 /* override stuff */ |
|
366 iface->print_string = print_bar; |
|
367 } |
|
368 |
|
369 /* --- DerivedObject --- */ |
|
370 #define DERIVED_TYPE_OBJECT (derived_object_get_type ()) |
|
371 #define DERIVED_OBJECT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), DERIVED_TYPE_OBJECT, DerivedObject)) |
|
372 #define DERIVED_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), DERIVED_TYPE_OBJECT, DerivedObjectClass)) |
|
373 #define DERIVED_IS_OBJECT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), DERIVED_TYPE_OBJECT)) |
|
374 #define DERIVED_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DERIVED_TYPE_OBJECT)) |
|
375 #define DERIVED_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), DERIVED_TYPE_OBJECT, DerivedObjectClass)) |
|
376 #define DERIVED_OBJECT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), DERIVED_TYPE_OBJECT, DerivedObjectPrivate)) |
|
377 |
|
378 typedef struct _DerivedObject DerivedObject; |
|
379 typedef struct _TestObjectClass DerivedObjectClass; |
|
380 typedef struct _DerivedObjectPrivate DerivedObjectPrivate; |
|
381 struct _DerivedObject |
|
382 { |
|
383 TestObject parent_instance; |
|
384 int dummy1; |
|
385 int dummy2; |
|
386 }; |
|
387 struct _DerivedObjectPrivate |
|
388 { |
|
389 char dummy; |
|
390 }; |
|
391 static void derived_object_class_init (DerivedObjectClass *class); |
|
392 static void derived_object_init (DerivedObject *dobject); |
|
393 |
|
394 |
|
395 GType |
|
396 derived_object_get_type (void) |
|
397 { |
|
398 static GType derived_object_type = 0; |
|
399 |
|
400 if (!derived_object_type) |
|
401 { |
|
402 static const GTypeInfo derived_object_info = |
|
403 { |
|
404 sizeof (DerivedObjectClass), |
|
405 NULL, /* base_init */ |
|
406 NULL, /* base_finalize */ |
|
407 (GClassInitFunc) derived_object_class_init, |
|
408 NULL, /* class_finalize */ |
|
409 NULL, /* class_data */ |
|
410 sizeof (DerivedObject), |
|
411 5, /* n_preallocs */ |
|
412 (GInstanceInitFunc) derived_object_init, |
|
413 }; |
|
414 GInterfaceInfo iface_info = { derived_object_test_iface_init, NULL, GUINT_TO_POINTER (87) }; |
|
415 |
|
416 derived_object_type = g_type_register_static (TEST_TYPE_OBJECT, "DerivedObject", &derived_object_info, 0); |
|
417 g_type_add_interface_static (derived_object_type, TEST_TYPE_IFACE, &iface_info); |
|
418 } |
|
419 |
|
420 return derived_object_type; |
|
421 } |
|
422 |
|
423 static void |
|
424 derived_object_class_init (DerivedObjectClass *class) |
|
425 { |
|
426 g_type_class_add_private (class, sizeof (DerivedObjectPrivate)); |
|
427 } |
|
428 static void |
|
429 derived_object_init (DerivedObject *dobject) |
|
430 { |
|
431 TestObjectPrivate *test_priv; |
|
432 DerivedObjectPrivate *derived_priv; |
|
433 |
|
434 derived_priv = DERIVED_OBJECT_GET_PRIVATE (dobject); |
|
435 |
|
436 g_assert (derived_priv); |
|
437 g_assert ((gchar *)derived_priv >= (gchar *)TEST_OBJECT_GET_PRIVATE (dobject) + sizeof (TestObjectPrivate)); |
|
438 |
|
439 test_priv = TEST_OBJECT_GET_PRIVATE (dobject); |
|
440 |
|
441 g_assert (test_priv); |
|
442 g_assert ((gchar *)test_priv >= (gchar *)dobject + sizeof (TestObject)); |
|
443 |
|
444 } |
|
445 |
|
446 //addition over |
|
447 |
|
448 static void |
|
449 test_i_foo (TestI *self) |
|
450 { |
|
451 record ("TestI::foo"); |
|
452 } |
|
453 |
|
454 static void |
|
455 test_i_default_init (gpointer g_class) |
|
456 { |
|
457 gint i; |
|
458 const char *name; |
|
459 GSignalQuery query; |
|
460 guint retval; |
|
461 guint n_ids[4]; |
|
462 foo_signal_id = g_signal_newv ("foo", |
|
463 TEST_TYPE_I, |
|
464 G_SIGNAL_RUN_LAST, |
|
465 g_cclosure_new(G_CALLBACK(test_i_foo), |
|
466 NULL, NULL), |
|
467 NULL, NULL, |
|
468 g_cclosure_marshal_VOID__VOID, |
|
469 G_TYPE_NONE, 0, NULL); |
|
470 |
|
471 g_assert(!strcmp(g_signal_name(foo_signal_id), "foo")); |
|
472 g_signal_query (foo_signal_id, &query); |
|
473 g_assert(query.signal_id == foo_signal_id); |
|
474 retval = g_signal_lookup("foo",TEST_TYPE_I); |
|
475 g_assert(retval == foo_signal_id); |
|
476 |
|
477 g_signal_list_ids (TEST_TYPE_I, |
|
478 n_ids); |
|
479 g_assert(n_ids[0] == foo_signal_id); |
|
480 |
|
481 i = foo_signal_id ; |
|
482 } |
|
483 |
|
484 static DEFINE_IFACE (TestI, test_i, NULL, test_i_default_init) |
|
485 |
|
486 #define TEST_TYPE_A (test_a_get_type()) |
|
487 |
|
488 typedef struct _TestA TestA; |
|
489 typedef struct _TestAClass TestAClass; |
|
490 |
|
491 struct _TestA { |
|
492 GObject parent; |
|
493 }; |
|
494 struct _TestAClass { |
|
495 GObjectClass parent_class; |
|
496 |
|
497 void (* bar) (TestA *self); |
|
498 }; |
|
499 |
|
500 //Dummy function |
|
501 gint GMyCompareDataFunc (gconstpointer a, |
|
502 gconstpointer b, |
|
503 gpointer user_data) |
|
504 { |
|
505 |
|
506 return 0; |
|
507 } |
|
508 |
|
509 |
|
510 |
|
511 //Function to test the apis : |
|
512 static void |
|
513 test_set_val_apis (void) |
|
514 { |
|
515 GType type; |
|
516 gchar c; |
|
517 gchar *p="foo"; |
|
518 gconstpointer ptr; |
|
519 gpointer ret_val = NULL; |
|
520 gpointer v_object ; |
|
521 gchar *retVal; |
|
522 GObject *object; |
|
523 GParamFlags flags; |
|
524 GParamSpec* paramSpec; |
|
525 GParamSpec *gpSpec = (GParamSpec * )g_malloc(sizeof (GParamSpec)); |
|
526 GValue orig = { 0, }; |
|
527 GValue orig1 = { 1, }; |
|
528 GValue xform = { 0, }; |
|
529 GValue param1 = { 0, }; |
|
530 GTypeModule module ; |
|
531 GEnumValue values[] = { {0,"0","0"}, {1,"1","1"}}; |
|
532 GValueArray value_array = { |
|
533 { |
|
534 0 |
|
535 }, |
|
536 { |
|
537 0 |
|
538 }}; |
|
539 |
|
540 GValueArray *ret_value_array; |
|
541 GCompareFunc compare_func; |
|
542 GCompareDataFunc compare_func1 = GMyCompareDataFunc; |
|
543 GValue *ret_value; |
|
544 gpointer user_data; |
|
545 GParamSpec *param; |
|
546 GQuark detail; |
|
547 GValue *return_value; |
|
548 GObject *ret_object; |
|
549 guint t; |
|
550 guint n_children = 10; |
|
551 GType *ret_gtype; |
|
552 GTypePlugin * ret_plugin; |
|
553 guint n_prerequisites = 1; |
|
554 const GInterfaceInfo interface_info; |
|
555 GType flag_type,boxed_type; |
|
556 GFlagsValue flag_value = {0,"0","0"}; |
|
557 int dummy; |
|
558 gpointer boxed_value = &dummy; |
|
559 GParamSpec *spec; |
|
560 gchar *boxed_variable = "abc"; |
|
561 |
|
562 type = g_enum_register_static ("TestEnum", values); |
|
563 g_value_init (&orig, type); |
|
564 g_value_set_enum (&orig, 5); |
|
565 t = g_value_get_enum(&orig); |
|
566 g_assert(t == 5); |
|
567 |
|
568 memset (&xform, 0, sizeof (GValue)); |
|
569 g_value_init (&xform, G_TYPE_CHAR); |
|
570 g_value_set_char (&xform, 10); |
|
571 g_assert (xform.data[0].v_int == '\n'); |
|
572 |
|
573 memset (&xform, 0, sizeof (GValue)); |
|
574 g_value_init (&xform, G_TYPE_DOUBLE); |
|
575 g_value_set_double (&xform, 100.00); |
|
576 g_assert (xform.data[0].v_double == 100.00); |
|
577 g_assert (g_value_get_double (&xform) == 100.00); |
|
578 |
|
579 |
|
580 memset (&xform, 0, sizeof (GValue)); |
|
581 g_value_init (&xform, G_TYPE_FLOAT); |
|
582 g_value_set_float (&xform, 1.0); |
|
583 g_assert (xform.data[0].v_float == 1.0); |
|
584 g_assert (g_value_get_float(&xform) == 1.0); |
|
585 |
|
586 memset (&xform, 0, sizeof (GValue)); |
|
587 g_value_init (&xform, G_TYPE_INT64); |
|
588 g_value_set_int64 (&xform, 2555); |
|
589 g_assert (xform.data[0].v_int64 == 2555); |
|
590 |
|
591 memset (&xform, 0, sizeof (GValue)); |
|
592 g_value_init (&xform, G_TYPE_LONG); |
|
593 g_value_set_long (&xform, 2555); |
|
594 g_assert (xform.data[0].v_long == 2555); |
|
595 |
|
596 memset (&xform, 0, sizeof (GValue)); |
|
597 g_value_init (&xform, G_TYPE_UCHAR); |
|
598 g_value_set_uchar (&xform, 10); |
|
599 g_assert (xform.data[0].v_uint == '\n'); |
|
600 |
|
601 memset (&xform, 0, sizeof (GValue)); |
|
602 g_value_init (&xform, G_TYPE_UINT); |
|
603 g_value_set_uint (&xform, 100); |
|
604 g_assert (xform.data[0].v_uint == 100); |
|
605 |
|
606 memset (&xform, 0, sizeof (GValue)); |
|
607 g_value_init (&xform, G_TYPE_UINT64); |
|
608 g_value_set_uint64 (&xform, 1000000); |
|
609 g_assert (xform.data[0].v_uint64 == 1000000); |
|
610 |
|
611 memset (&xform, 0, sizeof (GValue)); |
|
612 g_value_init (&xform, G_TYPE_ULONG); |
|
613 g_value_set_ulong (&xform, 1000000); |
|
614 g_assert (xform.data[0].v_ulong == 1000000); |
|
615 |
|
616 memset (&xform, 0, sizeof (GValue)); |
|
617 g_value_init (&xform, G_TYPE_STRING); |
|
618 g_value_set_string (&xform, "Hello"); |
|
619 g_assert (!strcmp(xform.data[0].v_pointer , "Hello")); |
|
620 |
|
621 memset (&xform, 0, sizeof (GValue)); |
|
622 g_value_init (&xform, G_TYPE_STRING); |
|
623 g_value_set_static_string (&xform, "Hello"); |
|
624 g_assert (!strcmp(xform.data[0].v_pointer , "Hello")); |
|
625 |
|
626 memset (&xform, 0, sizeof (GValue)); |
|
627 g_value_init (&xform, G_TYPE_POINTER); |
|
628 g_value_set_pointer (&xform, p); |
|
629 g_assert (xform.data[0].v_pointer == p); |
|
630 |
|
631 memset (&xform, 0, sizeof (GValue)); |
|
632 g_value_init (&xform, G_TYPE_STRING); |
|
633 g_value_set_string (&xform, "World"); |
|
634 retVal = g_value_dup_string (&xform); |
|
635 g_assert (!strcmp(retVal , "World")); |
|
636 |
|
637 ret_value_array = g_value_array_copy (&value_array); |
|
638 |
|
639 g_assert (ret_value_array != NULL ); |
|
640 |
|
641 g_value_array_free(ret_value_array); |
|
642 |
|
643 ret_value_array = g_value_array_prepend(&value_array, &orig); |
|
644 |
|
645 g_assert (ret_value_array != NULL ); |
|
646 |
|
647 ret_value = g_value_array_get_nth (&value_array, 0); |
|
648 |
|
649 g_assert (ret_value_array != NULL ); |
|
650 |
|
651 ret_value_array = g_value_array_sort(&value_array, compare_func); |
|
652 |
|
653 g_assert (ret_value_array != NULL ); |
|
654 |
|
655 ret_value_array = g_value_array_sort_with_data (&value_array, |
|
656 compare_func1, |
|
657 user_data); |
|
658 |
|
659 g_assert (ret_value_array != NULL ); |
|
660 |
|
661 |
|
662 memset (&xform, 0, sizeof (GValue)); |
|
663 g_value_init (&xform, G_TYPE_PARAM); |
|
664 |
|
665 g_value_set_param (&xform, NULL); |
|
666 |
|
667 g_assert (&xform != NULL ); |
|
668 |
|
669 g_value_set_param_take_ownership(&xform, NULL); |
|
670 |
|
671 g_assert (&xform != NULL ); |
|
672 |
|
673 paramSpec = g_value_dup_param (&xform); |
|
674 |
|
675 g_assert (paramSpec == NULL ); |
|
676 |
|
677 //g_signal_emitv (&orig, 1, detail, return_value); |
|
678 memset (&xform, 0, sizeof (GValue)); |
|
679 g_value_init (&xform, G_TYPE_POINTER); |
|
680 ret_val = g_value_get_pointer(&xform); |
|
681 g_assert (ret_val == NULL ); |
|
682 |
|
683 memset (&xform, 0, sizeof (GValue)); |
|
684 g_value_init (&xform, G_TYPE_OBJECT); |
|
685 ret_object = g_value_dup_object(&xform); |
|
686 g_assert (ret_object == NULL ); |
|
687 g_value_set_object_take_ownership (&xform, NULL); |
|
688 |
|
689 memset (&xform, 0, sizeof (GValue)); |
|
690 flag_type = g_flags_register_static("TestFlag",&flag_value); |
|
691 g_value_init(&xform , flag_type); |
|
692 g_value_set_flags (&xform , 1); |
|
693 t = g_value_get_flags (&xform); |
|
694 g_assert (t == 1); |
|
695 |
|
696 memset (&xform, 0, sizeof (GValue)); |
|
697 boxed_type = g_boxed_type_register_static("TestBoxed",my_boxed_copy_function,my_boxed_free_function); |
|
698 g_value_init (&xform, boxed_type); |
|
699 g_value_set_boxed (&xform,boxed_variable); |
|
700 ret_val = g_value_get_boxed (&xform); |
|
701 g_assert (ret_val == boxed_variable); |
|
702 |
|
703 g_value_set_static_boxed (&xform, "abc"); |
|
704 g_value_set_boxed_take_ownership (&xform, "abc"); |
|
705 g_assert (&xform != NULL); |
|
706 ret_val = g_value_dup_boxed (&xform); |
|
707 g_assert (ret_val == boxed_variable); |
|
708 |
|
709 memset (&xform, 0, sizeof (GValue)); |
|
710 g_value_init(&xform,G_TYPE_OBJECT); |
|
711 ret_val = g_value_get_object(&xform); |
|
712 g_assert (ret_val == NULL); |
|
713 |
|
714 memset (&xform, 0, sizeof (GValue)); |
|
715 g_value_init (&xform, G_TYPE_PARAM); |
|
716 spec = g_param_spec_int |
|
717 ( |
|
718 "property-a", /* property name */ |
|
719 "a", /* nickname */ |
|
720 "Mysterty value 1", /* description */ |
|
721 5, /* minimum */ |
|
722 10, /* maximum */ |
|
723 5, /* default */ |
|
724 G_PARAM_READABLE |G_PARAM_WRITABLE /* GParamSpecFlags */ |
|
725 ); |
|
726 g_value_set_param(&xform,spec); |
|
727 param = g_value_get_param(&xform); |
|
728 g_assert (param == spec); |
|
729 |
|
730 ret_gtype = g_type_children (G_TYPE_INT, &n_children); |
|
731 g_assert (ret_gtype != NULL); |
|
732 free(ret_gtype); |
|
733 |
|
734 ret_plugin = g_type_interface_get_plugin (G_TYPE_INT, G_TYPE_INTERFACE); |
|
735 g_assert (ret_plugin == NULL); |
|
736 |
|
737 ret_gtype = g_type_interface_prerequisites (G_TYPE_INTERFACE,&n_prerequisites); |
|
738 g_assert (ret_gtype != NULL); |
|
739 free(ret_gtype); |
|
740 |
|
741 //g_type_module_set_name (&module, "Name"); |
|
742 //g_object_set_property (object, |
|
743 // NULL, |
|
744 // &xform); |
|
745 // g_type_class_unref_uncached (NULL);*/ |
|
746 |
|
747 } |
|
748 |
|
749 //Function to test the apis |
|
750 |
|
751 static void |
|
752 test_param_spec_apis (void) |
|
753 { |
|
754 GParamFlags flags; |
|
755 GParamSpec* paramSpec; |
|
756 gchar *qdata = "abc"; |
|
757 GQuark quark = g_quark_from_string(qdata); |
|
758 gpointer retVal; |
|
759 gpointer data= "MY data"; |
|
760 gchar *testData; |
|
761 GDestroyNotify destroy; |
|
762 GType type; |
|
763 gboolean ret; |
|
764 GValue orig = { 0, }; |
|
765 GValue xform = { 0, }; |
|
766 GEnumValue values[] = { {0,"0","0"}, {1,"1","1"}}; |
|
767 GFlagsValue flag_value = {1,"1","1"}; |
|
768 GType enum_type,flags_type,boxed_type; |
|
769 memset (&orig, 0, sizeof (GValue)); |
|
770 g_value_init (&orig, G_TYPE_POINTER); |
|
771 |
|
772 memset (&xform, 0, sizeof (GValue)); |
|
773 g_value_init (&xform, G_TYPE_POINTER); |
|
774 |
|
775 paramSpec = g_param_spec_uchar("String1","Hello","World", 0,100,10, flags); |
|
776 |
|
777 g_assert (!strcmp(paramSpec->_nick , "Hello")); |
|
778 |
|
779 paramSpec = g_param_spec_uint("String2","Hello","World", 0,255,50, flags); |
|
780 |
|
781 g_assert (!strcmp(paramSpec->name , "String2")); |
|
782 |
|
783 paramSpec = g_param_spec_uint64("String3","Hello","World", 0,255555,1000, flags); |
|
784 |
|
785 g_assert (!strcmp(paramSpec->name , "String3")); |
|
786 |
|
787 paramSpec = g_param_spec_ulong("String4","Hello","World", 0,255,100, flags); |
|
788 |
|
789 g_assert (!strcmp(paramSpec->name , "String4")); |
|
790 |
|
791 paramSpec = g_param_spec_unichar("String5","Hello","World",'X', flags); |
|
792 |
|
793 g_assert (!strcmp(paramSpec->name , "String5")); |
|
794 |
|
795 paramSpec = g_param_spec_string("String6","Hello","World","String", flags); |
|
796 |
|
797 g_assert (!strcmp(paramSpec->name , "String6")); |
|
798 |
|
799 paramSpec = g_param_spec_int64("String7","Hello","World",-100,25555,500, flags); |
|
800 |
|
801 g_assert (!strcmp(paramSpec->name , "String7")); |
|
802 |
|
803 paramSpec = g_param_spec_long("String8","Hello","World",-100,2555,100, flags); |
|
804 |
|
805 g_assert (!strcmp(paramSpec->name , "String8")); |
|
806 |
|
807 g_param_spec_set_qdata(paramSpec,quark,qdata); |
|
808 retVal = g_param_spec_steal_qdata(paramSpec, quark); |
|
809 g_assert (retVal == qdata); |
|
810 |
|
811 g_param_spec_set_qdata(paramSpec,100, data); |
|
812 |
|
813 retVal = g_param_spec_get_qdata(paramSpec,100); |
|
814 |
|
815 testData = (gchar *)retVal; |
|
816 |
|
817 g_assert (!strcmp(testData , "MY data")); |
|
818 |
|
819 g_param_spec_set_qdata_full (paramSpec, 200, data, destroy); |
|
820 |
|
821 retVal = g_param_spec_get_qdata(paramSpec, 200); |
|
822 testData = (gchar *)retVal; |
|
823 g_assert (!strcmp(testData , "MY data")); |
|
824 |
|
825 paramSpec = g_param_spec_object("String9","Hello","World",G_TYPE_OBJECT,flags); |
|
826 g_assert (!strcmp(paramSpec->name , "String9")); |
|
827 |
|
828 paramSpec = g_param_spec_param("String10","Hello","World",G_TYPE_PARAM,flags); |
|
829 |
|
830 g_assert (!strcmp(paramSpec->name , "String10")); |
|
831 |
|
832 paramSpec = g_param_spec_pointer("String11", "Hello", "World", flags); |
|
833 |
|
834 g_assert (!strcmp(paramSpec->name , "String11")); |
|
835 |
|
836 ret = g_param_value_convert (paramSpec, &orig, &xform, TRUE); |
|
837 |
|
838 g_assert (ret == TRUE); |
|
839 |
|
840 ret = g_param_value_defaults(paramSpec , &xform); |
|
841 |
|
842 g_assert (ret == TRUE); |
|
843 |
|
844 paramSpec = g_param_spec_value_array ("String12", "Hello", "World", NULL, flags); |
|
845 |
|
846 g_assert (!strcmp(paramSpec->name , "String12")); |
|
847 |
|
848 paramSpec = g_param_spec_float("String13","Hello", "World",0.00,255.00,100.00,flags); |
|
849 |
|
850 g_assert (!strcmp(paramSpec->name , "String13")); |
|
851 |
|
852 paramSpec = g_param_spec_flags("String14","Hello", "World",G_TYPE_FLAGS,0,flags); |
|
853 |
|
854 g_assert (!strcmp(paramSpec->name , "String14")); |
|
855 |
|
856 paramSpec = g_param_spec_double("String15","Hello", "World", 0.00,25554.00,100.00,flags); |
|
857 |
|
858 g_assert (!strcmp(paramSpec->name , "String15")); |
|
859 |
|
860 paramSpec = g_param_spec_char("String16","Hello", "World", 'a','z','c',flags); |
|
861 |
|
862 g_assert (!strcmp(paramSpec->name , "String16")); |
|
863 |
|
864 paramSpec = g_param_spec_boolean("String17", "Hello", "World",TRUE,flags); |
|
865 |
|
866 g_assert (!strcmp(paramSpec->name , "String17")); |
|
867 |
|
868 flags_type = g_flags_register_static("TestFlag1",&flag_value); |
|
869 paramSpec = g_param_spec_flags ("String18", "Hello", "World", flags_type, 1, flags); |
|
870 g_assert (!strcmp(paramSpec->name , "String18")); |
|
871 |
|
872 enum_type = g_enum_register_static("TestEnum1",values); |
|
873 paramSpec = g_param_spec_enum ("String19", "Hello", "World", enum_type, 0, flags); |
|
874 g_assert (!strcmp(paramSpec->name , "String19")); |
|
875 |
|
876 boxed_type = g_boxed_type_register_static("TestBoxed1",my_boxed_copy_function,my_boxed_free_function); |
|
877 paramSpec = g_param_spec_boxed ("String20", "Hello", "World", boxed_type, flags); |
|
878 g_assert (!strcmp(paramSpec->name , "String20")); |
|
879 |
|
880 } |
|
881 |
|
882 static void test_object_apis() |
|
883 { |
|
884 BaseObject *object; |
|
885 EphyModule *module; |
|
886 GObjectClass *object_class; |
|
887 GParamSpec **properties; |
|
888 gint n_properties; |
|
889 gpointer p = "Hello"; |
|
890 |
|
891 gint val1, val2, val3, val4; |
|
892 |
|
893 g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) | |
|
894 G_LOG_LEVEL_WARNING | |
|
895 G_LOG_LEVEL_CRITICAL); |
|
896 |
|
897 g_type_init (); |
|
898 |
|
899 object = g_object_new (DERIVED_TYPE_OBJECT , NULL); |
|
900 #if 0 |
|
901 module = g_object_new (EPHY_TYPE_MODULE, NULL); |
|
902 |
|
903 ephy_module_new_object(module); |
|
904 g_type_module_set_name (G_TYPE_MODULE (module), |
|
905 "name"); |
|
906 |
|
907 #endif |
|
908 |
|
909 } |
|
910 |
|
911 |
|
912 |
|
913 static void |
|
914 test_a_foo (TestI *self) |
|
915 { |
|
916 GValue args[1] = { { 0, } }; |
|
917 |
|
918 record ("TestA::foo"); |
|
919 |
|
920 g_value_init (&args[0], TEST_TYPE_A); |
|
921 g_value_set_object (&args[0], self); |
|
922 |
|
923 g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id); |
|
924 |
|
925 g_signal_chain_from_overridden (args, NULL); |
|
926 |
|
927 g_value_unset (&args[0]); |
|
928 } |
|
929 |
|
930 static void |
|
931 test_a_bar (TestA *self) |
|
932 { |
|
933 record ("TestA::bar"); |
|
934 } |
|
935 |
|
936 static void |
|
937 test_a_class_init (TestAClass *class) |
|
938 { |
|
939 class->bar = test_a_bar; |
|
940 |
|
941 bar_signal_id = g_signal_new ("bar", |
|
942 TEST_TYPE_A, |
|
943 G_SIGNAL_RUN_LAST, |
|
944 G_STRUCT_OFFSET (TestAClass, bar), |
|
945 NULL, NULL, |
|
946 g_cclosure_marshal_VOID__VOID, |
|
947 G_TYPE_NONE, 0, NULL); |
|
948 } |
|
949 |
|
950 static void |
|
951 test_a_interface_init (TestIClass *iface) |
|
952 { |
|
953 g_signal_override_class_closure (foo_signal_id, |
|
954 TEST_TYPE_A, |
|
955 g_cclosure_new (G_CALLBACK (test_a_foo), |
|
956 NULL, NULL)); |
|
957 } |
|
958 |
|
959 static DEFINE_TYPE_FULL (TestA, test_a, |
|
960 test_a_class_init, NULL, NULL, |
|
961 G_TYPE_OBJECT, |
|
962 INTERFACE (test_a_interface_init, TEST_TYPE_I)) |
|
963 |
|
964 #define TEST_TYPE_B (test_b_get_type()) |
|
965 |
|
966 typedef struct _TestB TestB; |
|
967 typedef struct _TestBClass TestBClass; |
|
968 |
|
969 struct _TestB { |
|
970 TestA parent; |
|
971 }; |
|
972 struct _TestBClass { |
|
973 TestAClass parent_class; |
|
974 }; |
|
975 |
|
976 static void |
|
977 test_b_foo (TestA *self) |
|
978 { |
|
979 GValue args[1] = { { 0, } }; |
|
980 |
|
981 record ("TestB::foo"); |
|
982 |
|
983 g_value_init (&args[0], TEST_TYPE_A); |
|
984 g_value_set_object (&args[0], self); |
|
985 |
|
986 g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id); |
|
987 g_signal_chain_from_overridden (args, NULL); |
|
988 |
|
989 g_value_unset (&args[0]); |
|
990 } |
|
991 |
|
992 static void |
|
993 test_b_bar (TestI *self) |
|
994 { |
|
995 GValue args[1] = { { 0, } }; |
|
996 |
|
997 record ("TestB::bar"); |
|
998 |
|
999 g_value_init (&args[0], TEST_TYPE_A); |
|
1000 g_value_set_object (&args[0], self); |
|
1001 |
|
1002 g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id); |
|
1003 g_signal_chain_from_overridden (args, NULL); |
|
1004 |
|
1005 g_value_unset (&args[0]); |
|
1006 } |
|
1007 |
|
1008 static void |
|
1009 test_b_class_init (TestBClass *class) |
|
1010 { |
|
1011 g_signal_override_class_closure (foo_signal_id, |
|
1012 TEST_TYPE_B, |
|
1013 g_cclosure_new (G_CALLBACK (test_b_foo), |
|
1014 NULL, NULL)); |
|
1015 g_signal_override_class_closure (bar_signal_id, |
|
1016 TEST_TYPE_B, |
|
1017 g_cclosure_new (G_CALLBACK (test_b_bar), |
|
1018 NULL, NULL)); |
|
1019 } |
|
1020 |
|
1021 static DEFINE_TYPE (TestB, test_b, |
|
1022 test_b_class_init, NULL, NULL, |
|
1023 TEST_TYPE_A) |
|
1024 |
|
1025 #define TEST_TYPE_C (test_c_get_type()) |
|
1026 |
|
1027 typedef struct _TestC TestC; |
|
1028 typedef struct _TestCClass TestCClass; |
|
1029 |
|
1030 struct _TestC { |
|
1031 TestB parent; |
|
1032 }; |
|
1033 struct _TestCClass { |
|
1034 TestBClass parent_class; |
|
1035 }; |
|
1036 |
|
1037 static void |
|
1038 test_c_foo (TestA *self) |
|
1039 { |
|
1040 GValue args[1] = { { 0, } }; |
|
1041 |
|
1042 record ("TestC::foo"); |
|
1043 |
|
1044 g_value_init (&args[0], TEST_TYPE_A); |
|
1045 g_value_set_object (&args[0], self); |
|
1046 |
|
1047 g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id); |
|
1048 g_signal_chain_from_overridden (args, NULL); |
|
1049 |
|
1050 g_value_unset (&args[0]); |
|
1051 } |
|
1052 |
|
1053 static void |
|
1054 test_c_bar (TestI *self) |
|
1055 { |
|
1056 GValue args[1] = { { 0, } }; |
|
1057 |
|
1058 record ("TestC::bar"); |
|
1059 |
|
1060 g_value_init (&args[0], TEST_TYPE_A); |
|
1061 g_value_set_object (&args[0], self); |
|
1062 |
|
1063 g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id); |
|
1064 g_signal_chain_from_overridden (args, NULL); |
|
1065 |
|
1066 g_value_unset (&args[0]); |
|
1067 } |
|
1068 |
|
1069 static void |
|
1070 test_c_class_init (TestBClass *class) |
|
1071 { |
|
1072 g_signal_override_class_closure (foo_signal_id, |
|
1073 TEST_TYPE_C, |
|
1074 g_cclosure_new (G_CALLBACK (test_c_foo), |
|
1075 NULL, NULL)); |
|
1076 g_signal_override_class_closure (bar_signal_id, |
|
1077 TEST_TYPE_C, |
|
1078 g_cclosure_new (G_CALLBACK (test_c_bar), |
|
1079 NULL, NULL)); |
|
1080 } |
|
1081 |
|
1082 |
|
1083 static DEFINE_TYPE (TestC, test_c, |
|
1084 test_c_class_init, NULL, NULL, |
|
1085 TEST_TYPE_B) |
|
1086 |
|
1087 static GString *test_string = NULL; |
|
1088 gboolean failed = FALSE; |
|
1089 |
|
1090 static void |
|
1091 record (const gchar *str) |
|
1092 { |
|
1093 if (test_string->len) |
|
1094 g_string_append_c (test_string, ','); |
|
1095 g_string_append (test_string, str); |
|
1096 } |
|
1097 |
|
1098 int |
|
1099 main (int argc, char **argv) |
|
1100 { |
|
1101 gpointer p; |
|
1102 |
|
1103 #ifdef SYMBIAN |
|
1104 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); |
|
1105 #endif /*SYMBIAN*/ |
|
1106 |
|
1107 g_type_init(); |
|
1108 |
|
1109 test_i_default_init(p); |
|
1110 |
|
1111 test_set_val_apis(); |
|
1112 |
|
1113 test_param_spec_apis(); |
|
1114 |
|
1115 test_object_apis(); |
|
1116 |
|
1117 #if SYMBIAN |
|
1118 testResultXml("g_test1"); |
|
1119 #endif /* EMULATOR */ |
|
1120 |
|
1121 return failed ? 1 : 0; |
|
1122 } |
|
1123 |