|
1 /* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.*/ |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 #include <unistd.h> |
|
7 #include <glib.h> |
|
8 #include <glib-object.h> |
|
9 |
|
10 #ifdef SYMBIAN |
|
11 #include "glib_global.h" |
|
12 #include "mrt2_glib2_test.h" |
|
13 #define MULTITHREAD |
|
14 //#define TEST_STOP_EMISSION |
|
15 //#define VERBOSE |
|
16 #define LOOP 3 |
|
17 int TESTNUM; |
|
18 int notifynum; |
|
19 int handlernum; |
|
20 gulong hookid; |
|
21 GValue gv ; |
|
22 GSignalQuery gq; |
|
23 guint gi; |
|
24 #endif /*SYMBIAN*/ |
|
25 |
|
26 |
|
27 #define G_TYPE_TEST (g_test_get_type ()) |
|
28 #define G_TEST(test) (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest)) |
|
29 #define G_IS_TEST(test) (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST)) |
|
30 #define G_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass)) |
|
31 #define G_IS_TEST_CLASS(tclass) (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST)) |
|
32 #define G_TEST_GET_CLASS(test) (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass)) |
|
33 |
|
34 static GRand *rand; |
|
35 |
|
36 typedef struct _GTest GTest; |
|
37 typedef struct _GTestClass GTestClass; |
|
38 |
|
39 struct _GTest |
|
40 { |
|
41 GObject object; |
|
42 |
|
43 gint value; |
|
44 }; |
|
45 |
|
46 struct _GTestClass |
|
47 { |
|
48 GObjectClass parent_class; |
|
49 |
|
50 void (*test_signal1) (GTest * test, gint an_int); |
|
51 void (*test_signal2) (GTest * test, gint an_int); |
|
52 }; |
|
53 |
|
54 static GType g_test_get_type (void); |
|
55 static volatile gboolean stopping; |
|
56 |
|
57 /* Element signals and args */ |
|
58 enum |
|
59 { |
|
60 TEST_SIGNAL1, |
|
61 TEST_SIGNAL2, |
|
62 /* add more above */ |
|
63 LAST_SIGNAL |
|
64 }; |
|
65 |
|
66 enum |
|
67 { |
|
68 ARG_0, |
|
69 ARG_TEST_PROP |
|
70 }; |
|
71 |
|
72 static void g_test_class_init (GTestClass * klass); |
|
73 static void g_test_init (GTest * test); |
|
74 static void g_test_dispose (GObject * object); |
|
75 |
|
76 static void signal2_handler (GTest * test, gint anint); |
|
77 |
|
78 static void g_test_set_property (GObject * object, guint prop_id, |
|
79 const GValue * value, GParamSpec * pspec); |
|
80 static void g_test_get_property (GObject * object, guint prop_id, |
|
81 GValue * value, GParamSpec * pspec); |
|
82 |
|
83 static GObjectClass *parent_class = NULL; |
|
84 |
|
85 static guint g_test_signals[LAST_SIGNAL] = { 0 }; |
|
86 |
|
87 static GType |
|
88 g_test_get_type (void) |
|
89 { |
|
90 static GType test_type = 0; |
|
91 |
|
92 if (!test_type) { |
|
93 static const GTypeInfo test_info = { |
|
94 sizeof (GTestClass), |
|
95 NULL, |
|
96 NULL, |
|
97 (GClassInitFunc) g_test_class_init, |
|
98 NULL, |
|
99 NULL, |
|
100 sizeof (GTest), |
|
101 0, |
|
102 (GInstanceInitFunc) g_test_init, |
|
103 NULL |
|
104 }; |
|
105 |
|
106 rand = g_rand_new(); |
|
107 |
|
108 test_type = g_type_register_static (G_TYPE_OBJECT, "GTest", |
|
109 &test_info, 0); |
|
110 } |
|
111 return test_type; |
|
112 } |
|
113 |
|
114 static void |
|
115 g_test_class_init (GTestClass * klass) |
|
116 { |
|
117 GObjectClass *gobject_class; |
|
118 |
|
119 gobject_class = (GObjectClass *) klass; |
|
120 |
|
121 parent_class = g_type_class_ref (G_TYPE_OBJECT); |
|
122 #ifndef SYMBIAN |
|
123 if (!g_thread_supported ()) |
|
124 g_thread_init (NULL); |
|
125 #else |
|
126 |
|
127 #ifdef MULTITHREAD |
|
128 if (!g_thread_supported ()) |
|
129 g_thread_init (NULL); |
|
130 #endif /*MULTITHREAD*/ |
|
131 |
|
132 #endif /*SYMBAIN*/ |
|
133 |
|
134 gobject_class->dispose = g_test_dispose; |
|
135 gobject_class->set_property = g_test_set_property; |
|
136 gobject_class->get_property = g_test_get_property; |
|
137 |
|
138 g_test_signals[TEST_SIGNAL1] = |
|
139 g_signal_new ("test-signal1", G_TYPE_FROM_CLASS (klass), |
|
140 G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal1), NULL, |
|
141 NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); |
|
142 g_test_signals[TEST_SIGNAL2] = |
|
143 g_signal_new ("test-signal2", G_TYPE_FROM_CLASS (klass), |
|
144 G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal2), NULL, |
|
145 NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT); |
|
146 |
|
147 g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TEST_PROP, |
|
148 g_param_spec_int ("test-prop", "Test Prop", "Test property", |
|
149 0, 1, 0, G_PARAM_READWRITE)); |
|
150 |
|
151 klass->test_signal2 = signal2_handler; |
|
152 } |
|
153 |
|
154 static void |
|
155 g_test_init (GTest * test) |
|
156 { |
|
157 #ifndef SYMBIAN |
|
158 g_print ("init %p\n", test); |
|
159 #else |
|
160 |
|
161 #ifdef VERBOSE |
|
162 g_print ("init %p\n", test); |
|
163 #endif |
|
164 |
|
165 #endif /*SYMBIAN*/ |
|
166 |
|
167 test->value = 0; |
|
168 } |
|
169 |
|
170 static void |
|
171 g_test_dispose (GObject * object) |
|
172 { |
|
173 GTest *test; |
|
174 |
|
175 test = G_TEST (object); |
|
176 |
|
177 g_print ("dispose %p!\n", object); |
|
178 |
|
179 G_OBJECT_CLASS (parent_class)->dispose (object); |
|
180 } |
|
181 |
|
182 static void |
|
183 g_test_set_property (GObject * object, guint prop_id, |
|
184 const GValue * value, GParamSpec * pspec) |
|
185 { |
|
186 GTest *test; |
|
187 |
|
188 test = G_TEST (object); |
|
189 |
|
190 switch (prop_id) { |
|
191 case ARG_TEST_PROP: |
|
192 test->value = g_value_get_int (value); |
|
193 break; |
|
194 default: |
|
195 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
|
196 break; |
|
197 } |
|
198 } |
|
199 |
|
200 static void |
|
201 g_test_get_property (GObject * object, guint prop_id, |
|
202 GValue * value, GParamSpec * pspec) |
|
203 { |
|
204 GTest *test; |
|
205 |
|
206 test = G_TEST (object); |
|
207 |
|
208 switch (prop_id) { |
|
209 case ARG_TEST_PROP: |
|
210 g_value_set_int (value, test->value); |
|
211 break; |
|
212 default: |
|
213 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
|
214 break; |
|
215 } |
|
216 } |
|
217 |
|
218 static void |
|
219 g_test_do_signal1 (GTest * test) |
|
220 { |
|
221 g_signal_emit (G_OBJECT (test), g_test_signals[TEST_SIGNAL1], 0, 0); |
|
222 } |
|
223 |
|
224 static void |
|
225 signal2_handler (GTest * test, gint anint) |
|
226 { |
|
227 #ifdef VERBOSE |
|
228 g_print ("Function: signal2_handler called\n"); |
|
229 #endif |
|
230 |
|
231 handlernum++; |
|
232 } |
|
233 |
|
234 static void |
|
235 g_test_do_signal2 (GTest * test) |
|
236 { |
|
237 g_signal_emit (G_OBJECT (test), g_test_signals[TEST_SIGNAL2], 0, 0); |
|
238 } |
|
239 |
|
240 static void |
|
241 g_test_do_prop (GTest * test) |
|
242 { |
|
243 test->value = g_rand_int (rand); |
|
244 g_object_notify (G_OBJECT (test), "test-prop"); |
|
245 } |
|
246 |
|
247 static gpointer |
|
248 run_thread (GTest * test) |
|
249 { |
|
250 gint i = 1; |
|
251 |
|
252 #ifndef SYMBIAN |
|
253 while (!stopping) |
|
254 { |
|
255 if (TESTNUM == 1) |
|
256 g_test_do_signal1 (test); |
|
257 if (TESTNUM == 2) |
|
258 g_test_do_signal2 (test); |
|
259 if (TESTNUM == 3) |
|
260 g_test_do_prop (test); |
|
261 if ((i++ % 10000) == 0) { |
|
262 g_print ("."); |
|
263 g_thread_yield(); /*force context switch */ |
|
264 } |
|
265 } |
|
266 #else |
|
267 |
|
268 #ifdef MULTITHREAD |
|
269 while (!stopping) |
|
270 { |
|
271 if (TESTNUM == 1) |
|
272 g_test_do_signal1 (test); |
|
273 if (TESTNUM == 2) |
|
274 g_test_do_signal2 (test); |
|
275 if (TESTNUM == 3) |
|
276 g_test_do_prop (test); |
|
277 if ((i++ % 10/*000*/) == 0) |
|
278 { |
|
279 #ifdef VERBOSE |
|
280 g_print ("."); |
|
281 #endif /*VERBOSE*/ |
|
282 g_thread_yield(); /* force context switch */ |
|
283 } |
|
284 } |
|
285 #else |
|
286 for(i=0;i <= LOOP;i++) |
|
287 { |
|
288 if (TESTNUM == 1) |
|
289 g_test_do_signal1 (test); |
|
290 if (TESTNUM == 2) |
|
291 g_test_do_signal2 (test); |
|
292 if (TESTNUM == 3) |
|
293 g_test_do_prop (test); |
|
294 |
|
295 #ifdef VERBOSE |
|
296 g_print("."); |
|
297 #endif |
|
298 } |
|
299 #endif /*MULTITHREAD*/ |
|
300 |
|
301 #endif /*SYMBIAN*/ |
|
302 |
|
303 return NULL; |
|
304 } |
|
305 |
|
306 |
|
307 |
|
308 |
|
309 static void |
|
310 notify (GObject *object, GParamSpec *spec, gpointer user_data) |
|
311 { |
|
312 gint value; |
|
313 |
|
314 notifynum++; |
|
315 #ifdef VERBOSE |
|
316 g_print ("Function: notify called\n"); |
|
317 #endif |
|
318 |
|
319 g_object_get (object, "test-prop", &value, NULL); |
|
320 //g_print ("+ %d", value); |
|
321 } |
|
322 |
|
323 #ifdef SYMBIAN |
|
324 void hook_function() |
|
325 { |
|
326 #ifdef VERBOSE |
|
327 g_print ("Function: hook_function called\n"); |
|
328 #endif |
|
329 handlernum++; |
|
330 } |
|
331 #endif |
|
332 |
|
333 int |
|
334 main (int argc, char **argv) |
|
335 { |
|
336 gint i; |
|
337 GTest *test1, *test2; |
|
338 GArray *test_threads; |
|
339 const gint n_threads = 1; |
|
340 |
|
341 #ifdef SYMBIAN |
|
342 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); |
|
343 g_set_print_handler(mrtPrintHandler); |
|
344 #endif /*SYMBIAN*/ |
|
345 |
|
346 g_thread_init (NULL); |
|
347 |
|
348 #ifndef SYMBIAN |
|
349 g_print ("START: %s\n", argv[0]); |
|
350 #else |
|
351 |
|
352 #ifdef VERBOSE |
|
353 g_print ("START: %s\n", argv[0]); |
|
354 #endif |
|
355 |
|
356 #endif /*SYMBIAN*/ |
|
357 g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK)); |
|
358 g_type_init (); |
|
359 |
|
360 test1 = g_object_new (G_TYPE_TEST, NULL); |
|
361 test2 = g_object_new (G_TYPE_TEST, NULL); |
|
362 |
|
363 g_signal_connect (test1, "notify::test-prop", G_CALLBACK (notify), NULL); |
|
364 g_signal_connect (test1, "test-signal1", G_CALLBACK (notify), NULL); |
|
365 g_signal_connect (test1, "test-signal2", G_CALLBACK (notify), NULL); |
|
366 |
|
367 |
|
368 |
|
369 |
|
370 #ifndef SYMBIAN |
|
371 test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); |
|
372 |
|
373 stopping = FALSE; |
|
374 |
|
375 for (i = 0; i < n_threads; i++) { |
|
376 GThread *thread; |
|
377 |
|
378 thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); |
|
379 g_array_append_val (test_threads, thread); |
|
380 |
|
381 thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); |
|
382 g_array_append_val (test_threads, thread); |
|
383 } |
|
384 g_usleep (500000); |
|
385 |
|
386 stopping = TRUE; |
|
387 |
|
388 g_print ("\nstopping\n"); |
|
389 |
|
390 /* join all threads */ |
|
391 for (i = 0; i < 2 * n_threads; i++) { |
|
392 GThread *thread; |
|
393 |
|
394 thread = g_array_index (test_threads, GThread *, i); |
|
395 g_thread_join (thread); |
|
396 } |
|
397 |
|
398 g_print ("stopped:%d\n",TESTNUM); |
|
399 #else |
|
400 |
|
401 #ifdef MULTITHREAD |
|
402 |
|
403 test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); |
|
404 stopping = FALSE; |
|
405 TESTNUM=1; |
|
406 notifynum=0; |
|
407 handlernum=0; |
|
408 for (i = 0; i < n_threads; i++) |
|
409 { |
|
410 GThread *thread; |
|
411 |
|
412 thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); |
|
413 g_array_append_val (test_threads, thread); |
|
414 |
|
415 thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); |
|
416 g_array_append_val (test_threads, thread); |
|
417 } |
|
418 g_usleep (500000); |
|
419 |
|
420 stopping = TRUE; |
|
421 |
|
422 #ifdef VERBOSE |
|
423 g_print ("\nstopping\n"); |
|
424 #endif |
|
425 /* join all threads */ |
|
426 for (i = 0; i < 2 * n_threads; i++) |
|
427 { |
|
428 GThread *thread; |
|
429 |
|
430 thread = g_array_index (test_threads, GThread *, i); |
|
431 g_thread_join (thread); |
|
432 } |
|
433 |
|
434 g_assert(notifynum != 0); |
|
435 g_assert(handlernum == 0); |
|
436 |
|
437 g_array_free (test_threads, TRUE); |
|
438 |
|
439 #ifdef VERBOSE |
|
440 g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM); |
|
441 #endif |
|
442 |
|
443 |
|
444 |
|
445 test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); |
|
446 stopping = FALSE; |
|
447 TESTNUM=2; |
|
448 notifynum=0; |
|
449 handlernum=0; |
|
450 |
|
451 for (i = 0; i < n_threads; i++) |
|
452 { |
|
453 GThread *thread; |
|
454 |
|
455 thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); |
|
456 g_array_append_val (test_threads, thread); |
|
457 |
|
458 thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); |
|
459 g_array_append_val (test_threads, thread); |
|
460 } |
|
461 g_usleep (500000); |
|
462 |
|
463 stopping = TRUE; |
|
464 |
|
465 #ifdef VERBOSE |
|
466 g_print ("\nstopping\n"); |
|
467 #endif |
|
468 /* join all threads */ |
|
469 for (i = 0; i < 2 * n_threads; i++) |
|
470 { |
|
471 GThread *thread; |
|
472 |
|
473 thread = g_array_index (test_threads, GThread *, i); |
|
474 g_thread_join (thread); |
|
475 } |
|
476 |
|
477 g_assert(notifynum != 0); |
|
478 g_assert(handlernum != 0); |
|
479 |
|
480 g_array_free (test_threads, TRUE); |
|
481 |
|
482 #ifdef VERBOSE |
|
483 g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM); |
|
484 #endif |
|
485 |
|
486 |
|
487 test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *)); |
|
488 stopping = FALSE; |
|
489 TESTNUM=3; |
|
490 notifynum=0; |
|
491 handlernum=0; |
|
492 |
|
493 for (i = 0; i < n_threads; i++) |
|
494 { |
|
495 GThread *thread; |
|
496 |
|
497 thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL); |
|
498 g_array_append_val (test_threads, thread); |
|
499 |
|
500 thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL); |
|
501 g_array_append_val (test_threads, thread); |
|
502 } |
|
503 g_usleep (5000000); |
|
504 |
|
505 stopping = TRUE; |
|
506 |
|
507 #ifdef VERBOSE |
|
508 g_print ("\nstopping\n"); |
|
509 #endif |
|
510 /* join all threads */ |
|
511 for (i = 0; i < 2 * n_threads; i++) |
|
512 { |
|
513 GThread *thread; |
|
514 |
|
515 thread = g_array_index (test_threads, GThread *, i); |
|
516 g_thread_join (thread); |
|
517 } |
|
518 |
|
519 g_assert(notifynum != 0); |
|
520 g_assert(handlernum == 0); |
|
521 |
|
522 g_array_free (test_threads, TRUE); |
|
523 |
|
524 #ifdef VERBOSE |
|
525 g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM); |
|
526 #endif |
|
527 |
|
528 #else /* ! MULTITHREAD*/ |
|
529 |
|
530 |
|
531 TESTNUM=1; |
|
532 #ifdef VERBOSE |
|
533 g_print ("\nStarting with TESTNUM=%d\n",TESTNUM); |
|
534 #endif |
|
535 |
|
536 notifynum=0; |
|
537 handlernum=0; |
|
538 run_thread(test1); |
|
539 g_assert(notifynum == LOOP +1); |
|
540 g_assert(handlernum ==0); |
|
541 |
|
542 notifynum=0; |
|
543 handlernum=0; |
|
544 run_thread(test2); |
|
545 g_assert(notifynum == 0); |
|
546 g_assert(handlernum == 0); |
|
547 |
|
548 TESTNUM=2; |
|
549 #ifdef VERBOSE |
|
550 g_print ("\nStarting with TESTNUM=%d\n",TESTNUM); |
|
551 #endif |
|
552 |
|
553 notifynum=0; |
|
554 handlernum=0; |
|
555 run_thread(test1); |
|
556 g_assert(notifynum == LOOP+1); |
|
557 g_assert(handlernum == LOOP+1); |
|
558 |
|
559 notifynum=0; |
|
560 handlernum=0; |
|
561 run_thread(test2); |
|
562 g_assert(notifynum == 0); |
|
563 g_assert(handlernum == LOOP+1); |
|
564 |
|
565 TESTNUM=3; |
|
566 #ifdef VERBOSE |
|
567 g_print ("\nStarting with TESTNUM=%d\n",TESTNUM); |
|
568 #endif |
|
569 |
|
570 notifynum=0; |
|
571 handlernum=0; |
|
572 run_thread(test1); |
|
573 g_assert(notifynum == LOOP +1); |
|
574 g_assert(handlernum ==0); |
|
575 |
|
576 notifynum=0; |
|
577 handlernum=0; |
|
578 run_thread(test2); |
|
579 g_assert(notifynum == 0); |
|
580 g_assert(handlernum == 0); |
|
581 |
|
582 g_assert(g_signal_has_handler_pending(G_OBJECT(test1),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==TRUE); |
|
583 g_assert(g_signal_has_handler_pending(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==FALSE); |
|
584 |
|
585 g_assert(g_signal_handler_is_connected(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST))==TRUE); |
|
586 g_assert(g_signal_handler_is_connected(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST))==FALSE); |
|
587 |
|
588 handlernum=g_signal_lookup("test-signal1",G_TYPE_TEST); |
|
589 #ifdef VERBOSE |
|
590 g_print("Signal id: %d\n",handlernum); |
|
591 #endif |
|
592 |
|
593 g_signal_connect (test2, "test-signal1", G_CALLBACK (notify), NULL); |
|
594 |
|
595 hookid=g_signal_add_emission_hook(handlernum,NULL,(GSignalEmissionHook) hook_function,NULL,NULL); |
|
596 |
|
597 #ifdef VERBOSE |
|
598 g_print("Hookid: %d\n",hookid); |
|
599 #endif |
|
600 /********************/ |
|
601 |
|
602 #ifdef TEST_STOP_EMISSION |
|
603 /* |
|
604 notifynum=0; |
|
605 handlernum=0; |
|
606 g_print("The following call stops signal emission\n"); |
|
607 g_signal_stop_emission(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST),0); |
|
608 |
|
609 g_print("The following call should abort and it is normal\n"); |
|
610 run_thread(test1); |
|
611 printf("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum); |
|
612 |
|
613 */ |
|
614 notifynum=0; |
|
615 handlernum=0; |
|
616 g_signal_stop_emission_by_name(G_OBJECT(test1),"test-signal1"); |
|
617 //run_thread(test1); |
|
618 g_print("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum); |
|
619 |
|
620 |
|
621 #endif /*TEST_STOP_EMISSION*/ |
|
622 |
|
623 /*******************/ |
|
624 |
|
625 |
|
626 handlernum=0; |
|
627 g_signal_emit(G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0); |
|
628 g_signal_emit(G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0); |
|
629 g_assert(handlernum==2); |
|
630 |
|
631 |
|
632 g_signal_remove_emission_hook(g_signal_lookup("test-signal1",G_TYPE_TEST),hookid); |
|
633 |
|
634 #ifdef VERBOSE |
|
635 g_print("Emitting signal again after removing emission hook\n"); |
|
636 #endif |
|
637 |
|
638 handlernum=0; |
|
639 g_signal_emit (G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0); |
|
640 g_signal_emit (G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0); |
|
641 g_assert(handlernum==0); |
|
642 |
|
643 g_assert (strcmp ("test-signal1", g_signal_name (g_signal_lookup("test-signal1",G_TYPE_TEST))) == 0); |
|
644 g_assert (strcmp ("test-signal2", g_signal_name (g_signal_lookup("test-signal2",G_TYPE_TEST))) == 0); |
|
645 |
|
646 |
|
647 memset(&gv,0,sizeof(gv)); |
|
648 g_value_init(&gv,G_TYPE_OBJECT); |
|
649 g_value_set_object(&gv,test1); |
|
650 |
|
651 gi=0; |
|
652 g_signal_list_ids(G_OBJECT_TYPE(test1),&gi); |
|
653 g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gi); |
|
654 |
|
655 notifynum=0; |
|
656 g_signal_emitv (&gv, g_test_signals[TEST_SIGNAL1], 0, &gv); |
|
657 g_assert(notifynum==1); |
|
658 |
|
659 g_signal_query(g_signal_lookup("test-signal1",G_TYPE_TEST),&gq); |
|
660 g_assert(strcmp("test-signal1",gq.signal_name)==0); |
|
661 g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gq.signal_id); |
|
662 |
|
663 |
|
664 g_assert(g_signal_handler_find(G_OBJECT(test1), G_SIGNAL_RUN_LAST,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,NULL,NULL)==2); |
|
665 |
|
666 |
|
667 notifynum=g_signal_handlers_block_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL); |
|
668 handlernum=g_signal_handlers_unblock_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL); |
|
669 g_assert(notifynum==handlernum); |
|
670 |
|
671 #endif /*MULTITHREAD*/ |
|
672 |
|
673 #ifdef VERBOSE |
|
674 g_printf ("\nsignals.c: Completed all tests\n"); |
|
675 #endif |
|
676 |
|
677 #endif /*SYMBIAN*/ |
|
678 |
|
679 |
|
680 |
|
681 #if SYMBIAN |
|
682 testResultXml("signals-multithread"); |
|
683 #endif /* EMULATOR */ |
|
684 |
|
685 return 0; |
|
686 } |