|
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 #include <stdlib.h> |
|
43 |
|
44 #ifdef SYMBIAN |
|
45 #include "mrt2_glib2_test.h" |
|
46 #endif /*SYMBIAN*/ |
|
47 |
|
48 typedef struct _BaseObject BaseObject; |
|
49 |
|
50 struct _EphyModule |
|
51 { |
|
52 GTypeModule parent_instance; |
|
53 |
|
54 GModule *library; |
|
55 |
|
56 char *path; |
|
57 GType type; |
|
58 guint resident : 1; |
|
59 }; |
|
60 |
|
61 typedef struct _EphyModule EphyModule; |
|
62 |
|
63 struct _BaseObject |
|
64 { |
|
65 GObject parent_instance; |
|
66 |
|
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; |
|
74 |
|
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); |
|
79 |
|
80 static void record (const gchar *str); |
|
81 |
|
82 #define TEST_TYPE_I (test_i_get_type ()) |
|
83 #define DERIVED_TYPE_OBJECT (derived_object_get_type ()) |
|
84 |
|
85 typedef struct _TestI TestI; |
|
86 typedef struct _TestIClass TestIClass; |
|
87 |
|
88 struct _TestIClass |
|
89 { |
|
90 GTypeInterface base_iface; |
|
91 }; |
|
92 |
|
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); |
|
110 |
|
111 gpointer my_boxed_copy_function(gpointer boxed) |
|
112 { |
|
113 return boxed; |
|
114 } |
|
115 |
|
116 void my_boxed_free_function(gpointer boxed) |
|
117 { |
|
118 } |
|
119 |
|
120 GType |
|
121 test_iface_get_type (void) |
|
122 { |
|
123 static GType test_iface_type = 0; |
|
124 |
|
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 }; |
|
133 |
|
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 } |
|
137 |
|
138 return test_iface_type; |
|
139 } |
|
140 |
|
141 |
|
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; |
|
174 |
|
175 g_assert (iface_data == GUINT_TO_POINTER (42)); |
|
176 |
|
177 g_assert (G_TYPE_FROM_INTERFACE (iface) == TEST_TYPE_IFACE); |
|
178 |
|
179 /* assert iface_base_init() was already called */ |
|
180 g_assert (iface_base_init_count > 0); |
|
181 |
|
182 /* initialize stuff */ |
|
183 iface->print_string = print_foo; |
|
184 } |
|
185 |
|
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 }; |
|
201 |
|
202 struct _TestObjectClass |
|
203 { |
|
204 GObjectClass parent_class; |
|
205 |
|
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); |
|
224 |
|
225 |
|
226 GType |
|
227 test_object_get_type (void) |
|
228 { |
|
229 static GType test_object_type = 0; |
|
230 |
|
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) }; |
|
246 |
|
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 } |
|
250 |
|
251 return test_object_type; |
|
252 } |
|
253 |
|
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]; |
|
268 |
|
269 class->test_signal = test_object_test_signal; |
|
270 |
|
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); |
|
278 |
|
279 hook_id = g_signal_add_emission_hook ( sig_id, |
|
280 detail, |
|
281 hook_func, |
|
282 "Data", |
|
283 data_destroy); |
|
284 |
|
285 |
|
286 g_type_class_add_private (class, sizeof (TestObjectPrivate)); |
|
287 } |
|
288 |
|
289 static void |
|
290 print_bar (TestIface *tiobj, |
|
291 const gchar *string) |
|
292 { |
|
293 TestIfaceClass *parent_iface; |
|
294 |
|
295 g_return_if_fail (TEST_IS_IFACE (tiobj)); |
|
296 |
|
297 if (!string) |
|
298 string = "<NULL>"; |
|
299 g_print ("Iface-BAR: \"%s\" from %p\n", string, tiobj); |
|
300 |
|
301 g_print ("chaining: "); |
|
302 parent_iface = g_type_interface_peek_parent (TEST_IFACE_GET_CLASS (tiobj)); |
|
303 parent_iface->print_string (tiobj, string); |
|
304 |
|
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; |
|
311 |
|
312 priv = TEST_OBJECT_GET_PRIVATE (tobject); |
|
313 |
|
314 g_assert (priv); |
|
315 g_assert ((gchar *)priv >= (gchar *)tobject + sizeof (TestObject)); |
|
316 |
|
317 priv->dummy1 = 54321; |
|
318 } |
|
319 |
|
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"); |
|
326 |
|
327 g_return_val_if_fail (TEST_IS_IFACE (iface_object), NULL); |
|
328 |
|
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; |
|
340 |
|
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; |
|
347 |
|
348 g_value_take_string (return_accu, result_string); |
|
349 |
|
350 return TRUE; |
|
351 } |
|
352 |
|
353 static void |
|
354 derived_object_test_iface_init (gpointer giface, |
|
355 gpointer iface_data) |
|
356 { |
|
357 TestIfaceClass *iface = giface; |
|
358 |
|
359 g_assert (iface_data == GUINT_TO_POINTER (87)); |
|
360 |
|
361 g_assert (G_TYPE_FROM_INTERFACE (iface) == TEST_TYPE_IFACE); |
|
362 |
|
363 /* assert test_object_test_iface_init() was already called */ |
|
364 g_assert (iface->print_string == print_foo); |
|
365 |
|
366 /* override stuff */ |
|
367 iface->print_string = print_bar; |
|
368 } |
|
369 |
|
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)) |
|
378 |
|
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); |
|
394 |
|
395 |
|
396 GType |
|
397 derived_object_get_type (void) |
|
398 { |
|
399 static GType derived_object_type = 0; |
|
400 |
|
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) }; |
|
416 |
|
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 } |
|
420 |
|
421 return derived_object_type; |
|
422 } |
|
423 |
|
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; |
|
434 |
|
435 derived_priv = DERIVED_OBJECT_GET_PRIVATE (dobject); |
|
436 |
|
437 g_assert (derived_priv); |
|
438 g_assert ((gchar *)derived_priv >= (gchar *)TEST_OBJECT_GET_PRIVATE (dobject) + sizeof (TestObjectPrivate)); |
|
439 |
|
440 test_priv = TEST_OBJECT_GET_PRIVATE (dobject); |
|
441 |
|
442 g_assert (test_priv); |
|
443 g_assert ((gchar *)test_priv >= (gchar *)dobject + sizeof (TestObject)); |
|
444 |
|
445 } |
|
446 |
|
447 //addition over |
|
448 |
|
449 static void |
|
450 test_i_foo (TestI *self) |
|
451 { |
|
452 record ("TestI::foo"); |
|
453 } |
|
454 |
|
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); |
|
471 |
|
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); |
|
477 |
|
478 g_signal_list_ids (TEST_TYPE_I, |
|
479 n_ids); |
|
480 g_assert(n_ids[0] == foo_signal_id); |
|
481 |
|
482 i = foo_signal_id ; |
|
483 } |
|
484 |
|
485 static DEFINE_IFACE (TestI, test_i, NULL, test_i_default_init) |
|
486 |
|
487 #define TEST_TYPE_A (test_a_get_type()) |
|
488 |
|
489 typedef struct _TestA TestA; |
|
490 typedef struct _TestAClass TestAClass; |
|
491 |
|
492 struct _TestA { |
|
493 GObject parent; |
|
494 }; |
|
495 struct _TestAClass { |
|
496 GObjectClass parent_class; |
|
497 |
|
498 void (* bar) (TestA *self); |
|
499 }; |
|
500 |
|
501 //Dummy function |
|
502 gint GMyCompareDataFunc (gconstpointer a, |
|
503 gconstpointer b, |
|
504 gpointer user_data) |
|
505 { |
|
506 |
|
507 return 0; |
|
508 } |
|
509 |
|
510 |
|
511 |
|
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 }}; |
|
540 |
|
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"; |
|
562 |
|
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); |
|
568 |
|
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'); |
|
573 |
|
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); |
|
579 |
|
580 |
|
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); |
|
586 |
|
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); |
|
591 |
|
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); |
|
596 |
|
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'); |
|
601 |
|
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); |
|
606 |
|
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); |
|
611 |
|
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); |
|
616 |
|
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")); |
|
621 |
|
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")); |
|
626 |
|
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); |
|
631 |
|
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")); |
|
637 |
|
638 ret_value_array = g_value_array_copy (&value_array); |
|
639 |
|
640 g_assert (ret_value_array != NULL ); |
|
641 |
|
642 g_value_array_free(ret_value_array); |
|
643 |
|
644 ret_value_array = g_value_array_prepend(&value_array, &orig); |
|
645 |
|
646 g_assert (ret_value_array != NULL ); |
|
647 |
|
648 ret_value = g_value_array_get_nth (&value_array, 0); |
|
649 |
|
650 g_assert (ret_value_array != NULL ); |
|
651 |
|
652 ret_value_array = g_value_array_sort(&value_array, compare_func); |
|
653 |
|
654 g_assert (ret_value_array != NULL ); |
|
655 |
|
656 ret_value_array = g_value_array_sort_with_data (&value_array, |
|
657 compare_func1, |
|
658 user_data); |
|
659 |
|
660 g_assert (ret_value_array != NULL ); |
|
661 |
|
662 |
|
663 memset (&xform, 0, sizeof (GValue)); |
|
664 g_value_init (&xform, G_TYPE_PARAM); |
|
665 |
|
666 g_value_set_param (&xform, NULL); |
|
667 |
|
668 g_assert (&xform != NULL ); |
|
669 |
|
670 g_value_set_param_take_ownership(&xform, NULL); |
|
671 |
|
672 g_assert (&xform != NULL ); |
|
673 |
|
674 paramSpec = g_value_dup_param (&xform); |
|
675 |
|
676 g_assert (paramSpec == NULL ); |
|
677 |
|
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 ); |
|
683 |
|
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); |
|
689 |
|
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); |
|
696 |
|
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); |
|
703 |
|
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); |
|
709 |
|
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); |
|
714 |
|
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); |
|
730 |
|
731 ret_gtype = g_type_children (G_TYPE_INT, &n_children); |
|
732 g_assert (ret_gtype != NULL); |
|
733 free(ret_gtype); |
|
734 |
|
735 ret_plugin = g_type_interface_get_plugin (G_TYPE_INT, G_TYPE_INTERFACE); |
|
736 g_assert (ret_plugin == NULL); |
|
737 |
|
738 ret_gtype = g_type_interface_prerequisites (G_TYPE_INTERFACE,&n_prerequisites); |
|
739 g_assert (ret_gtype != NULL); |
|
740 free(ret_gtype); |
|
741 |
|
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);*/ |
|
747 |
|
748 } |
|
749 |
|
750 //Function to test the apis |
|
751 |
|
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); |
|
772 |
|
773 memset (&xform, 0, sizeof (GValue)); |
|
774 g_value_init (&xform, G_TYPE_POINTER); |
|
775 |
|
776 paramSpec = g_param_spec_uchar("String1","Hello","World", 0,100,10, flags); |
|
777 |
|
778 g_assert (!strcmp(paramSpec->_nick , "Hello")); |
|
779 |
|
780 paramSpec = g_param_spec_uint("String2","Hello","World", 0,255,50, flags); |
|
781 |
|
782 g_assert (!strcmp(paramSpec->name , "String2")); |
|
783 |
|
784 paramSpec = g_param_spec_uint64("String3","Hello","World", 0,255555,1000, flags); |
|
785 |
|
786 g_assert (!strcmp(paramSpec->name , "String3")); |
|
787 |
|
788 paramSpec = g_param_spec_ulong("String4","Hello","World", 0,255,100, flags); |
|
789 |
|
790 g_assert (!strcmp(paramSpec->name , "String4")); |
|
791 |
|
792 paramSpec = g_param_spec_unichar("String5","Hello","World",'X', flags); |
|
793 |
|
794 g_assert (!strcmp(paramSpec->name , "String5")); |
|
795 |
|
796 paramSpec = g_param_spec_string("String6","Hello","World","String", flags); |
|
797 |
|
798 g_assert (!strcmp(paramSpec->name , "String6")); |
|
799 |
|
800 paramSpec = g_param_spec_int64("String7","Hello","World",-100,25555,500, flags); |
|
801 |
|
802 g_assert (!strcmp(paramSpec->name , "String7")); |
|
803 |
|
804 paramSpec = g_param_spec_long("String8","Hello","World",-100,2555,100, flags); |
|
805 |
|
806 g_assert (!strcmp(paramSpec->name , "String8")); |
|
807 |
|
808 g_param_spec_set_qdata(paramSpec,quark,qdata); |
|
809 retVal = g_param_spec_steal_qdata(paramSpec, quark); |
|
810 g_assert (retVal == qdata); |
|
811 |
|
812 g_param_spec_set_qdata(paramSpec,100, data); |
|
813 |
|
814 retVal = g_param_spec_get_qdata(paramSpec,100); |
|
815 |
|
816 testData = (gchar *)retVal; |
|
817 |
|
818 g_assert (!strcmp(testData , "MY data")); |
|
819 |
|
820 g_param_spec_set_qdata_full (paramSpec, 200, data, destroy); |
|
821 |
|
822 retVal = g_param_spec_get_qdata(paramSpec, 200); |
|
823 testData = (gchar *)retVal; |
|
824 g_assert (!strcmp(testData , "MY data")); |
|
825 |
|
826 paramSpec = g_param_spec_object("String9","Hello","World",G_TYPE_OBJECT,flags); |
|
827 g_assert (!strcmp(paramSpec->name , "String9")); |
|
828 |
|
829 paramSpec = g_param_spec_param("String10","Hello","World",G_TYPE_PARAM,flags); |
|
830 |
|
831 g_assert (!strcmp(paramSpec->name , "String10")); |
|
832 |
|
833 paramSpec = g_param_spec_pointer("String11", "Hello", "World", flags); |
|
834 |
|
835 g_assert (!strcmp(paramSpec->name , "String11")); |
|
836 |
|
837 ret = g_param_value_convert (paramSpec, &orig, &xform, TRUE); |
|
838 |
|
839 g_assert (ret == TRUE); |
|
840 |
|
841 ret = g_param_value_defaults(paramSpec , &xform); |
|
842 |
|
843 g_assert (ret == TRUE); |
|
844 |
|
845 paramSpec = g_param_spec_value_array ("String12", "Hello", "World", NULL, flags); |
|
846 |
|
847 g_assert (!strcmp(paramSpec->name , "String12")); |
|
848 |
|
849 paramSpec = g_param_spec_float("String13","Hello", "World",0.00,255.00,100.00,flags); |
|
850 |
|
851 g_assert (!strcmp(paramSpec->name , "String13")); |
|
852 |
|
853 paramSpec = g_param_spec_flags("String14","Hello", "World",G_TYPE_FLAGS,0,flags); |
|
854 |
|
855 g_assert (!strcmp(paramSpec->name , "String14")); |
|
856 |
|
857 paramSpec = g_param_spec_double("String15","Hello", "World", 0.00,25554.00,100.00,flags); |
|
858 |
|
859 g_assert (!strcmp(paramSpec->name , "String15")); |
|
860 |
|
861 paramSpec = g_param_spec_char("String16","Hello", "World", 'a','z','c',flags); |
|
862 |
|
863 g_assert (!strcmp(paramSpec->name , "String16")); |
|
864 |
|
865 paramSpec = g_param_spec_boolean("String17", "Hello", "World",TRUE,flags); |
|
866 |
|
867 g_assert (!strcmp(paramSpec->name , "String17")); |
|
868 |
|
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")); |
|
872 |
|
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")); |
|
876 |
|
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")); |
|
880 |
|
881 } |
|
882 |
|
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"; |
|
891 |
|
892 gint val1, val2, val3, val4; |
|
893 |
|
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); |
|
897 |
|
898 g_type_init (); |
|
899 |
|
900 object = g_object_new (DERIVED_TYPE_OBJECT , NULL); |
|
901 #if 0 |
|
902 module = g_object_new (EPHY_TYPE_MODULE, NULL); |
|
903 |
|
904 ephy_module_new_object(module); |
|
905 g_type_module_set_name (G_TYPE_MODULE (module), |
|
906 "name"); |
|
907 |
|
908 #endif |
|
909 |
|
910 } |
|
911 |
|
912 |
|
913 |
|
914 static void |
|
915 test_a_foo (TestI *self) |
|
916 { |
|
917 GValue args[1] = { { 0, } }; |
|
918 |
|
919 record ("TestA::foo"); |
|
920 |
|
921 g_value_init (&args[0], TEST_TYPE_A); |
|
922 g_value_set_object (&args[0], self); |
|
923 |
|
924 g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id); |
|
925 |
|
926 g_signal_chain_from_overridden (args, NULL); |
|
927 |
|
928 g_value_unset (&args[0]); |
|
929 } |
|
930 |
|
931 static void |
|
932 test_a_bar (TestA *self) |
|
933 { |
|
934 record ("TestA::bar"); |
|
935 } |
|
936 |
|
937 static void |
|
938 test_a_class_init (TestAClass *class) |
|
939 { |
|
940 class->bar = test_a_bar; |
|
941 |
|
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 } |
|
950 |
|
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 } |
|
959 |
|
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)) |
|
964 |
|
965 #define TEST_TYPE_B (test_b_get_type()) |
|
966 |
|
967 typedef struct _TestB TestB; |
|
968 typedef struct _TestBClass TestBClass; |
|
969 |
|
970 struct _TestB { |
|
971 TestA parent; |
|
972 }; |
|
973 struct _TestBClass { |
|
974 TestAClass parent_class; |
|
975 }; |
|
976 |
|
977 static void |
|
978 test_b_foo (TestA *self) |
|
979 { |
|
980 GValue args[1] = { { 0, } }; |
|
981 |
|
982 record ("TestB::foo"); |
|
983 |
|
984 g_value_init (&args[0], TEST_TYPE_A); |
|
985 g_value_set_object (&args[0], self); |
|
986 |
|
987 g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id); |
|
988 g_signal_chain_from_overridden (args, NULL); |
|
989 |
|
990 g_value_unset (&args[0]); |
|
991 } |
|
992 |
|
993 static void |
|
994 test_b_bar (TestI *self) |
|
995 { |
|
996 GValue args[1] = { { 0, } }; |
|
997 |
|
998 record ("TestB::bar"); |
|
999 |
|
1000 g_value_init (&args[0], TEST_TYPE_A); |
|
1001 g_value_set_object (&args[0], self); |
|
1002 |
|
1003 g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id); |
|
1004 g_signal_chain_from_overridden (args, NULL); |
|
1005 |
|
1006 g_value_unset (&args[0]); |
|
1007 } |
|
1008 |
|
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 } |
|
1021 |
|
1022 static DEFINE_TYPE (TestB, test_b, |
|
1023 test_b_class_init, NULL, NULL, |
|
1024 TEST_TYPE_A) |
|
1025 |
|
1026 #define TEST_TYPE_C (test_c_get_type()) |
|
1027 |
|
1028 typedef struct _TestC TestC; |
|
1029 typedef struct _TestCClass TestCClass; |
|
1030 |
|
1031 struct _TestC { |
|
1032 TestB parent; |
|
1033 }; |
|
1034 struct _TestCClass { |
|
1035 TestBClass parent_class; |
|
1036 }; |
|
1037 |
|
1038 static void |
|
1039 test_c_foo (TestA *self) |
|
1040 { |
|
1041 GValue args[1] = { { 0, } }; |
|
1042 |
|
1043 record ("TestC::foo"); |
|
1044 |
|
1045 g_value_init (&args[0], TEST_TYPE_A); |
|
1046 g_value_set_object (&args[0], self); |
|
1047 |
|
1048 g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id); |
|
1049 g_signal_chain_from_overridden (args, NULL); |
|
1050 |
|
1051 g_value_unset (&args[0]); |
|
1052 } |
|
1053 |
|
1054 static void |
|
1055 test_c_bar (TestI *self) |
|
1056 { |
|
1057 GValue args[1] = { { 0, } }; |
|
1058 |
|
1059 record ("TestC::bar"); |
|
1060 |
|
1061 g_value_init (&args[0], TEST_TYPE_A); |
|
1062 g_value_set_object (&args[0], self); |
|
1063 |
|
1064 g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id); |
|
1065 g_signal_chain_from_overridden (args, NULL); |
|
1066 |
|
1067 g_value_unset (&args[0]); |
|
1068 } |
|
1069 |
|
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 } |
|
1082 |
|
1083 |
|
1084 static DEFINE_TYPE (TestC, test_c, |
|
1085 test_c_class_init, NULL, NULL, |
|
1086 TEST_TYPE_B) |
|
1087 |
|
1088 static GString *test_string = NULL; |
|
1089 gboolean failed = FALSE; |
|
1090 |
|
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 } |
|
1098 |
|
1099 int |
|
1100 main (int argc, char **argv) |
|
1101 { |
|
1102 gpointer p; |
|
1103 |
|
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*/ |
|
1107 |
|
1108 g_type_init(); |
|
1109 |
|
1110 test_i_default_init(p); |
|
1111 |
|
1112 test_set_val_apis(); |
|
1113 |
|
1114 test_param_spec_apis(); |
|
1115 |
|
1116 test_object_apis(); |
|
1117 |
|
1118 #if SYMBIAN |
|
1119 testResultXml("g_test1"); |
|
1120 #endif /* EMULATOR */ |
|
1121 |
|
1122 return failed ? 1 : 0; |
|
1123 } |
|
1124 |