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