source: trunk/ORBit2-2.14.0/test/test-dynany.c

Last change on this file was 92, checked in by cinc, 19 years ago

Orbit2 modified for use with NOM
File size: 13.5 KB
Line 
1#include <math.h>
2#include <stdio.h>
3#include <stdlib.h>
4#include <string.h>
5
6#include <orbit/orbit.h>
7#include "dynany.h"
8
9#define CHECK_OK(ev) g_assert ((ev)->_major == CORBA_NO_EXCEPTION)
10#define CHECK_TYPE_MISMATCH(ev) \
11 do { \
12 g_assert ((ev)->_major == CORBA_USER_EXCEPTION && \
13 !strcmp ((ev)->_id, ex_DynamicAny_DynAny_TypeMismatch)); \
14 CORBA_exception_free (ev); \
15 } while (0)
16#define CHECK_INVALID_VALUE(ev) \
17 do { \
18 g_assert ((ev)->_major == CORBA_USER_EXCEPTION && \
19 !strcmp ((ev)->_id, ex_DynamicAny_DynAny_InvalidValue)); \
20 CORBA_exception_free (ev); \
21 } while (0)
22#define CHECK_OBJECT_NOT_EXIST(ev) \
23 do { \
24 g_assert ((ev)->_major == CORBA_SYSTEM_EXCEPTION && \
25 !strcmp ((ev)->_id, ex_CORBA_OBJECT_NOT_EXIST)); \
26 CORBA_exception_free (ev); \
27 } while (0)
28
29
30static DynamicAny_DynAny
31create_basic_dyn_any (CORBA_ORB orb,
32 CORBA_TypeCode type,
33 CORBA_Environment *ev)
34{
35 DynamicAny_DynAnyFactory f;
36 DynamicAny_DynAny d;
37
38 f = (DynamicAny_DynAnyFactory)
39 CORBA_ORB_resolve_initial_references (
40 orb, "DynAnyFactory", ev);
41 CHECK_OK (ev);
42
43 d = DynamicAny_DynAnyFactory_create_dyn_any_from_type_code (
44 f, type, ev);
45 CHECK_OK (ev);
46
47 CORBA_Object_release ((CORBA_Object)f, ev);
48 CHECK_OK (ev);
49
50 return d;
51}
52
53static DynamicAny_DynAny
54create_dyn_any (CORBA_ORB orb,
55 const CORBA_any *any,
56 CORBA_Environment *ev)
57{
58 DynamicAny_DynAnyFactory f;
59 DynamicAny_DynAny d;
60
61 f = (DynamicAny_DynAnyFactory)
62 CORBA_ORB_resolve_initial_references (
63 orb, "DynAnyFactory", ev);
64 CHECK_OK (ev);
65
66 d = DynamicAny_DynAnyFactory_create_dyn_any (
67 f, any, ev);
68 CHECK_OK (ev);
69
70 CORBA_Object_release ((CORBA_Object)f, ev);
71 CHECK_OK (ev);
72
73 return d;
74}
75
76static int
77double_equal (double a, double b)
78{
79 const double delta = 0.0001;
80
81 if (fabs (a - b) < delta)
82 return TRUE;
83 else
84 return FALSE;
85}
86
87static void
88test_long (CORBA_ORB orb, CORBA_Environment *ev)
89{
90 DynamicAny_DynAny dyn_any;
91 CORBA_long value;
92 CORBA_TypeCode type;
93
94 dyn_any = create_basic_dyn_any (orb, TC_CORBA_long, ev);
95 CHECK_OK (ev);
96 g_assert (dyn_any != CORBA_OBJECT_NIL);
97
98 /* 1. Inserting */
99 DynamicAny_DynAny_insert_long (dyn_any, 2, ev);
100 CHECK_OK (ev);
101
102 DynamicAny_DynAny_insert_boolean (dyn_any, TRUE, ev);
103 CHECK_TYPE_MISMATCH (ev);
104
105 DynamicAny_DynAny_insert_double (dyn_any, 1.3267, ev);
106 CHECK_TYPE_MISMATCH (ev);
107
108 DynamicAny_DynAny_insert_reference (dyn_any, (CORBA_Object) dyn_any, ev);
109 CHECK_TYPE_MISMATCH (ev);
110
111 /* 2. Getting */
112 DynamicAny_DynAny_get_boolean (dyn_any, ev);
113 CHECK_TYPE_MISMATCH (ev);
114
115 DynamicAny_DynAny_get_double (dyn_any, ev);
116 CHECK_TYPE_MISMATCH (ev);
117
118 DynamicAny_DynAny_get_reference (dyn_any, ev);
119 CHECK_TYPE_MISMATCH (ev);
120
121 value = DynamicAny_DynAny_get_long (dyn_any, ev);
122 CHECK_OK (ev);
123 g_assert (value == 2);
124
125 type = DynamicAny_DynAny_type (dyn_any, ev);
126 CHECK_OK (ev);
127
128 g_assert (CORBA_TypeCode_equal (type, TC_CORBA_long, ev));
129 CHECK_OK (ev);
130
131 CORBA_Object_release ((CORBA_Object) type, ev);
132 CHECK_OK (ev);
133
134 CORBA_Object_release ((CORBA_Object) dyn_any, ev);
135 CHECK_OK (ev);
136}
137
138static void
139test_string (CORBA_ORB orb, CORBA_Environment *ev)
140{
141 DynamicAny_DynAny dyn_any;
142 CORBA_char *value;
143 const char string[] = "Hello World";
144
145 dyn_any = create_basic_dyn_any (orb, TC_CORBA_string, ev);
146 CHECK_OK (ev);
147 g_assert (dyn_any != CORBA_OBJECT_NIL);
148
149 /* 1. Inserting */
150 DynamicAny_DynAny_insert_string (dyn_any, (CORBA_char *)string, ev);
151 CHECK_OK (ev);
152
153 DynamicAny_DynAny_insert_boolean (dyn_any, TRUE, ev);
154 CHECK_TYPE_MISMATCH (ev);
155
156 DynamicAny_DynAny_insert_double (dyn_any, 1.3267, ev);
157 CHECK_TYPE_MISMATCH (ev);
158
159 /* 2. Getting */
160
161 DynamicAny_DynAny_get_boolean (dyn_any, ev);
162 CHECK_TYPE_MISMATCH (ev);
163
164 DynamicAny_DynAny_get_double (dyn_any, ev);
165 CHECK_TYPE_MISMATCH (ev);
166
167 DynamicAny_DynAny_get_reference (dyn_any, ev);
168 CHECK_TYPE_MISMATCH (ev);
169
170 value = DynamicAny_DynAny_get_string (dyn_any, ev);
171 CHECK_OK (ev);
172 g_assert (!strcmp (value, string));
173 CORBA_free (value);
174
175 CORBA_Object_release ((CORBA_Object) dyn_any, ev);
176 CHECK_OK (ev);
177}
178
179static void
180test_copy (CORBA_ORB orb, CORBA_Environment *ev)
181{
182 DynamicAny_DynAny dyn_any;
183 DynamicAny_DynAny dyn_any_copy;
184 CORBA_any *any;
185 const char string[] = "Hello World2";
186
187 dyn_any = create_basic_dyn_any (orb, TC_CORBA_string, ev);
188 CHECK_OK (ev);
189 g_assert (dyn_any != CORBA_OBJECT_NIL);
190
191 DynamicAny_DynAny_insert_string (dyn_any, (CORBA_char *)string, ev);
192 CHECK_OK (ev);
193
194 any = DynamicAny_DynAny_to_any (dyn_any, ev);
195 CHECK_OK (ev);
196 g_assert (any != NULL);
197
198 dyn_any_copy = create_dyn_any (orb, any, ev);
199 CHECK_OK (ev);
200 g_assert (dyn_any_copy != NULL);
201 CORBA_free (any);
202
203 g_assert (DynamicAny_DynAny_equal (dyn_any_copy, dyn_any, ev));
204 CHECK_OK (ev);
205
206 { /* Knock up an integer any */
207 DynamicAny_DynAny int_any = create_basic_dyn_any (
208 orb, TC_CORBA_long, ev);
209 CHECK_OK (ev);
210
211 DynamicAny_DynAny_insert_long (int_any, 57, ev);
212 CHECK_OK (ev);
213
214 any = DynamicAny_DynAny_to_any (int_any, ev);
215 CHECK_OK (ev);
216
217 CORBA_Object_release ((CORBA_Object) int_any, ev);
218 CHECK_OK (ev);
219 }
220
221 DynamicAny_DynAny_from_any (dyn_any, any, ev);
222 CHECK_TYPE_MISMATCH (ev);
223 CORBA_free (any);
224
225 DynamicAny_DynAny_assign (dyn_any, dyn_any_copy, ev);
226 CHECK_OK (ev);
227
228 g_assert (DynamicAny_DynAny_equal (dyn_any_copy, dyn_any, ev));
229 CHECK_OK (ev);
230
231 CORBA_Object_release ((CORBA_Object) dyn_any, ev);
232 CHECK_OK (ev);
233
234 CORBA_Object_release ((CORBA_Object) dyn_any_copy, ev);
235 CHECK_OK (ev);
236}
237
238static void
239test_sequence (CORBA_ORB orb, CORBA_Environment *ev)
240{
241 DynamicAny_DynAny dyn_any;
242 DynamicAny_DynSequence dyn_seq;
243 int i, len;
244
245 dyn_any = create_basic_dyn_any (
246 orb, TC_CORBA_sequence_CORBA_octet, ev);
247 dyn_seq = (DynamicAny_DynSequence) dyn_any;
248 CHECK_OK (ev);
249 g_assert (dyn_any != CORBA_OBJECT_NIL);
250
251 DynamicAny_DynAny_insert_long (dyn_any, 5, ev);
252 CHECK_TYPE_MISMATCH (ev);
253
254 DynamicAny_DynSequence_set_length (dyn_seq, 100, ev);
255 CHECK_OK (ev);
256
257 for (i = 0; i < 100; i++) {
258 g_assert (DynamicAny_DynAny_seek (dyn_any, i, ev));
259 CHECK_OK (ev);
260 DynamicAny_DynAny_insert_octet (dyn_any, 100 - i, ev);
261 CHECK_OK (ev);
262 }
263
264 len = DynamicAny_DynAny_component_count (dyn_any, ev);
265 CHECK_OK (ev);
266 g_assert (len == 100);
267
268 len = DynamicAny_DynSequence_get_length (dyn_seq, ev);
269 CHECK_OK (ev);
270 g_assert (len == 100);
271
272 /* Only growing the length for now */
273 DynamicAny_DynAny_seek (dyn_any, -1, ev);
274 CHECK_OK (ev);
275
276 DynamicAny_DynSequence_set_length (dyn_seq, 150, ev);
277 CHECK_OK (ev);
278
279 len = DynamicAny_DynSequence_get_length (dyn_seq, ev);
280 CHECK_OK (ev);
281 g_assert (len == 150);
282
283 DynamicAny_DynAny_insert_octet (dyn_any, 137, ev);
284 CHECK_OK (ev);
285
286 i = DynamicAny_DynAny_get_octet (dyn_any, ev);
287 CHECK_OK (ev);
288
289 g_assert (i == 137);
290
291 DynamicAny_DynSequence_set_length (dyn_seq, 200, ev);
292 CHECK_OK (ev);
293
294 i = DynamicAny_DynAny_get_octet (dyn_any, ev);
295 CHECK_OK (ev);
296
297 g_assert (i == 137);
298
299 len = DynamicAny_DynSequence_get_length (dyn_seq, ev);
300 CHECK_OK (ev);
301 g_assert (len == 200);
302
303 {
304 DynamicAny_AnySeq *seq;
305
306 seq = DynamicAny_DynSequence_get_elements (dyn_seq, ev);
307 CHECK_OK (ev);
308
309 DynamicAny_DynSequence_set_elements (dyn_seq, seq, ev);
310 CHECK_OK (ev);
311
312 CORBA_free (seq);
313 }
314
315 CORBA_Object_release ((CORBA_Object) dyn_any, ev);
316 CHECK_OK (ev);
317}
318
319static void
320test_array (CORBA_ORB orb, CORBA_Environment *ev)
321{
322 DynamicAny_DynAny dyn_any;
323 CORBA_double d;
324 int i;
325
326 dyn_any = create_basic_dyn_any (
327 orb, TC_Test_MyArray, ev);
328 CHECK_OK (ev);
329 g_assert (dyn_any != CORBA_OBJECT_NIL);
330
331 g_assert (DynamicAny_DynAny_seek (dyn_any, 99, ev));
332 CHECK_OK (ev);
333
334 DynamicAny_DynAny_insert_long (dyn_any, 2, ev);
335 CHECK_TYPE_MISMATCH (ev);
336
337 DynamicAny_DynAny_insert_double (dyn_any, 2.71828182845, ev);
338 CHECK_OK (ev);
339
340 /* 1. Insert */
341 for (i = 0; i < 37; i+= 3) {
342 d = i * 2.7 + 3.1;
343
344 DynamicAny_DynAny_seek (dyn_any, i, ev);
345 CHECK_OK (ev);
346
347 DynamicAny_DynAny_insert_double (dyn_any, d, ev);
348 CHECK_OK (ev);
349 }
350
351 /* 1. Extract */
352 for (i = 0; i < 37; i+= 3) {
353 d = i * 2.7 + 3.1;
354
355 DynamicAny_DynAny_seek (dyn_any, i, ev);
356 CHECK_OK (ev);
357
358 g_assert (double_equal (DynamicAny_DynAny_get_double (dyn_any, ev), d));
359 CHECK_OK (ev);
360 }
361
362 CORBA_Object_release ((CORBA_Object) dyn_any, ev);
363 CHECK_OK (ev);
364}
365
366static const char *
367enum_subnames_array [] = {
368 "KIPPER",
369 "BLOATER",
370 "HERRING"
371};
372
373static void
374test_enum (CORBA_ORB orb, CORBA_Environment *ev)
375{
376 int i;
377 DynamicAny_DynEnum dyn_enum;
378
379 dyn_enum = (DynamicAny_DynEnum)
380 create_basic_dyn_any (
381 orb, TC_Test_Fishy, ev);
382 CHECK_OK (ev);
383 g_assert (dyn_enum != CORBA_OBJECT_NIL);
384
385 i = DynamicAny_DynEnum_get_as_ulong (dyn_enum, ev);
386 CHECK_OK (ev);
387 g_assert (i == 0);
388
389 for (i = 0; i < sizeof (enum_subnames_array) / sizeof (const char *); i++) {
390
391 DynamicAny_DynEnum_set_as_string (dyn_enum, enum_subnames_array [i], ev);
392 CHECK_OK (ev);
393
394 g_assert (DynamicAny_DynEnum_get_as_ulong (dyn_enum, ev) == i);
395 CHECK_OK (ev);
396 }
397
398 for (i = 0; i < sizeof (enum_subnames_array) / sizeof (const char *); i++) {
399 CORBA_char *str;
400
401 DynamicAny_DynEnum_set_as_ulong (dyn_enum, i, ev);
402 CHECK_OK (ev);
403
404 str = DynamicAny_DynEnum_get_as_string (dyn_enum, ev);
405 CHECK_OK (ev);
406
407 g_assert (!strcmp (str, enum_subnames_array [i]));
408 CORBA_free (str);
409 }
410
411 CORBA_Object_release ((CORBA_Object) dyn_enum, ev);
412 CHECK_OK (ev);
413}
414
415static const char *
416union_subnames_array [] = {
417 "tgw",
418 "nut",
419 "atl",
420 "rmt",
421 "ibid"
422};
423
424static CORBA_TypeCode
425union_subtypes_array [] = {
426 TC_CORBA_long,
427 TC_CORBA_double,
428 TC_CORBA_string,
429 TC_Test_Fishy,
430 TC_Test_OSeq
431};
432
433static void
434test_union (CORBA_ORB orb, CORBA_Environment *ev)
435{
436 DynamicAny_DynUnion dyn_union;
437 CORBA_TCKind kind;
438
439 dyn_union = (DynamicAny_DynUnion)
440 create_basic_dyn_any (
441 orb, TC_Test_English, ev);
442 CHECK_OK (ev);
443 g_assert (dyn_union != CORBA_OBJECT_NIL);
444
445 kind = DynamicAny_DynUnion_discriminator_kind (dyn_union, ev);
446 CHECK_OK (ev);
447 g_assert (kind == CORBA_tk_ulong);
448
449 CORBA_Object_release ((CORBA_Object) dyn_union, ev);
450 CHECK_OK (ev);
451}
452
453static void
454test_struct (CORBA_ORB orb, CORBA_Environment *ev)
455{
456 DynamicAny_DynAny dyn_any, sub_any;
457 DynamicAny_DynStruct dyn_struct;
458 DynamicAny_NameValuePairSeq *members;
459 /* DynamicAny_NameDynAnyPairSeq *dyn_members; */
460 CORBA_TCKind kind;
461 CORBA_char *str;
462 CORBA_double dv = 1.23;
463 const char *test_str = "one is not amused";
464 int i;
465
466 dyn_any = create_basic_dyn_any (
467 orb, TC_Test_Unions, ev);
468 dyn_struct = (DynamicAny_DynStruct) dyn_any;
469 CHECK_OK (ev);
470 g_assert (dyn_any != CORBA_OBJECT_NIL);
471
472 g_assert (!DynamicAny_DynStruct_seek (dyn_any, 6, ev));
473 CHECK_OK (ev);
474
475 for (i = 0; i < 5; i++) {
476 DynamicAny_DynStruct_seek (dyn_any, i, ev);
477 CHECK_OK (ev);
478
479 kind = DynamicAny_DynStruct_current_member_kind (dyn_struct, ev);
480 CHECK_OK (ev);
481
482 g_assert (union_subtypes_array [i]->kind == kind);
483
484 str = DynamicAny_DynStruct_current_member_name (dyn_struct, ev);
485 CHECK_OK (ev);
486
487 g_assert (!strcmp (union_subnames_array [i], str));
488 CORBA_free (str);
489 }
490
491 g_assert (DynamicAny_DynStruct_seek (dyn_any, 0, ev));
492 CHECK_OK (ev);
493
494 DynamicAny_DynAny_insert_long (dyn_any, 345, ev);
495 CHECK_OK (ev);
496
497 g_assert (DynamicAny_DynAny_next (dyn_any, ev));
498 CHECK_OK (ev);
499
500 DynamicAny_DynAny_insert_double (dyn_any, dv, ev);
501 CHECK_OK (ev);
502
503 g_assert (DynamicAny_DynAny_next (dyn_any, ev));
504 CHECK_OK (ev);
505
506 DynamicAny_DynAny_insert_string (dyn_any, test_str, ev);
507 CHECK_OK (ev);
508
509 sub_any = DynamicAny_DynAny_current_component (dyn_any, ev);
510 CHECK_OK (ev);
511
512 str = DynamicAny_DynAny_get_string (sub_any, ev);
513 CHECK_OK (ev);
514
515 g_assert (!strcmp (test_str, str));
516
517 CORBA_free (str);
518
519 g_assert (DynamicAny_DynStruct_seek (dyn_any, 0, ev));
520 CHECK_OK (ev);
521
522 g_assert (DynamicAny_DynAny_get_long (dyn_any, ev) == 345);
523 CHECK_OK (ev);
524
525 g_assert (DynamicAny_DynAny_next (dyn_any, ev));
526 CHECK_OK (ev);
527
528 g_assert (double_equal (DynamicAny_DynAny_get_double (dyn_any, ev), dv));
529 CHECK_OK (ev);
530
531 g_assert (DynamicAny_DynAny_next (dyn_any, ev));
532 CHECK_OK (ev);
533
534 members = DynamicAny_DynStruct_get_members (dyn_struct, ev);
535 g_assert (members != NULL);
536 CHECK_OK (ev);
537
538 DynamicAny_DynStruct_set_members (dyn_struct, members, ev);
539 CHECK_OK (ev);
540
541 CORBA_free (members);
542
543/* it's not clear how best to deal with this:
544
545 dyn_members = DynamicAny_DynStruct_get_members_as_dyn_any (dyn_any, ev);
546 g_assert (dyn_members != NULL);
547 CHECK_OK (ev);
548
549 DynamicAny_DynStruct_set_members_as_dyn_any (dyn_any, dyn_members, ev);
550 CHECK_OK (ev);
551
552 CORBA_free (dyn_members);*/
553
554 CORBA_Object_release ((CORBA_Object) dyn_any, ev);
555 CHECK_OK (ev);
556
557 str = DynamicAny_DynAny_get_string (sub_any, ev);
558 CHECK_OBJECT_NOT_EXIST (ev);
559
560 CORBA_Object_release ((CORBA_Object) sub_any, ev);
561 CHECK_OK (ev);
562}
563
564#define d_printf printf
565
566int
567main (int argc, char *argv[])
568{
569 CORBA_Environment ev;
570 CORBA_ORB orb;
571
572 free (malloc (8));
573
574 CORBA_exception_init (&ev);
575 orb = CORBA_ORB_init (NULL, NULL, "orbit-local-orb", &ev);
576
577 /*
578 * Since the API is entirely macro generated
579 * we only need to test a few cases.
580 */
581 d_printf ("Testing basic DynAny ...\n");
582 d_printf (" + long ops ...\n");
583 test_long (orb, &ev);
584
585 d_printf (" + string ops ...\n");
586 test_string (orb, &ev);
587
588 d_printf (" + copying ...\n");
589 test_copy (orb, &ev);
590
591 d_printf ("Testing DynSequence ...\n");
592 test_sequence (orb, &ev);
593
594 d_printf ("Testing DynEnum ...\n");
595 test_enum (orb, &ev);
596
597 d_printf ("Testing DynUnion ...\n");
598 test_union (orb, &ev);
599
600 d_printf ("Testing DynArray...\n");
601 test_array (orb, &ev);
602
603 d_printf ("Testing DynStruct...\n");
604 test_struct (orb, &ev);
605
606 CORBA_ORB_destroy (orb, &ev);
607 CHECK_OK (&ev);
608 CORBA_Object_release ((CORBA_Object) orb, &ev);
609 CHECK_OK (&ev);
610
611 d_printf ("all DynAny tests passed ok.\n");
612
613 return 0;
614}
Note: See TracBrowser for help on using the repository browser.