1 /*
2 * %CopyrightBegin%
3 *
4 * Copyright Ericsson AB 2001-2020. All Rights Reserved.
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * %CopyrightEnd%
19 *
20 */
21 /* C-client for test of IC.
22 *
23 */
24
25 #include <stdio.h>
26 #include <stdlib.h>
27
28 #ifndef __WIN32__
29 # include <unistd.h>
30 #endif
31
32 #include <string.h>
33
34 #ifdef __WIN32__
35 # include <time.h>
36 # include <sys/timeb.h>
37 #elif defined VXWORKS
38 #include <time.h>
39 #include <sys/times.h>
40 #else
41 #include <sys/time.h>
42 #endif
43
44 #include <ctype.h>
45
46 #ifdef __WIN32__
47 # include <winsock2.h>
48 # include <windows.h>
49 #else
50 # include <sys/types.h>
51 # include <sys/socket.h>
52 # include <netinet/in.h>
53 # include <arpa/inet.h>
54 # include <netdb.h>
55 #endif
56
57 #include "ic.h"
58 #include "ei.h"
59 #include "m_i.h"
60
61 #define HOSTNAMESZ 255
62 #define NODENAMESZ 512
63
64 #define INBUFSZ 10
65 #define OUTBUFSZ 0
66
67 #define MAXTRIES 5
68
69 #define CHECK_EXCEPTION(x) \
70 if ((x)->_major != CORBA_NO_EXCEPTION) { \
71 fprintf(stderr,"\n\nException: %s\n\n", \
72 (char *)CORBA_exception_value((x))); \
73 CORBA_exception_free((x)); \
74 return -1; \
75 } \
76
77 #define cmp_str(x,y) (!strcmp((x),(y)))
78 #define cmp_wstr(x,y) (!ic_wstrcmp((x),(y)))
79
80 typedef CORBA_Environment IC_Env;
81
82 typedef int (*TestFunc)(IC_Env *);
83 typedef struct {
84 char *name;
85 TestFunc func;
86 } TestCase;
87
88 static char longtext[] =
89 "Introduction The IC application is an IDL compiler implemented in Erlang."
90 " The IDL compiler generates client stubs and server skeletons."
91 " Several back-ends are supported, and they fall into three main groups."
92 " For more details on IC compiler options consult the ic(3) manual page."
93 " Argument passing cases 1 Caller allocates all necessary storage,"
94 " except that which may be encapsulated and managed within the parameter itself."
95 " 2 The caller allocates a pointer and passes it by reference to the callee."
96 " The callee sets the pointer to point to a valid instance of the parameter's type."
97 " The caller is responsible for releasing the returned storage."
98 " Following completion of a request, the caller is not allowed to modify any values"
99 " in the returned storage. To do so the caller must first copy the returned instance"
100 " into a new instance, then modify the new instance. 3 The caller allocates a"
101 " pointer to an array slice which has all the same dimensions of the original"
102 " array except the first, and passes it by reference to the callee. The callee sets"
103 " the pointer to point to a valid instance of the array. The caller is responsible for"
104 " releasing the returned storage. Following completion of a request, the caller is not"
105 " allowed to modify any values in the returned storage. To do so the caller must first"
106 " copy the returned instance into a new instance, then modify the new instance."
107 " Generated Files Two files will be generated for each scope. One set of files will be"
108 " generated for each module and each interface scope. An extra set is generated for"
109 " those definitions at top level scope. One of the files is a header file(.h), and the"
110 " other file is a C source code file (.c). In addition to these files a number of C"
111 " source files will be generated for type encodings, they are named according to the "
112 "following template: oe_code_<type>.c.";
113 static char this_node[NODENAMESZ + 1];
114 static char *progname;
115
116 /* Test function prototypes */
117
118 static int void_test(IC_Env *env);
119 static int long_test(IC_Env *env);
120 static int long_long_test(IC_Env *env);
121 static int unsigned_short_test(IC_Env *env);
122 static int unsigned_long_test(IC_Env *env);
123 static int unsigned_long_long_test(IC_Env *env);
124 static int double_test(IC_Env *env);
125 static int char_test(IC_Env *env);
126 static int wchar_test(IC_Env *env);
127 static int octet_test(IC_Env *env);
128 static int bool_test(IC_Env *env);
129 static int struct_test(IC_Env *env);
130 static int struct2_test(IC_Env *env);
131 static int seq1_test(IC_Env *env);
132 static int seq2_test(IC_Env *env);
133 static int seq3_test(IC_Env *env);
134 static int seq4_test(IC_Env *env);
135 static int seq5_test(IC_Env *env);
136 static int array1_test(IC_Env *env);
137 static int array2_test(IC_Env *env);
138 static int enum_test(IC_Env *env);
139 static int string1_test(IC_Env *env);
140 static int string2_test(IC_Env *env);
141 static int string3_test(IC_Env *env);
142 static int string4_test(IC_Env *env);
143 static int pid_test(IC_Env *env);
144 static int port_test(IC_Env *env);
145 static int ref_test(IC_Env *env);
146 static int term_test(IC_Env *env);
147 static int typedef_test(IC_Env *env);
148 static int inline_sequence_test(IC_Env *env);
149 static int term_sequence_test(IC_Env *env);
150 static int term_struct_test(IC_Env *env);
151 static int wstring1_test(IC_Env *env);
152
153 static TestCase test_cases[] = {
154 {"void_test", void_test},
155 {"long_test", long_test},
156 {"long_long_test", long_long_test},
157 {"unsigned_short_test", unsigned_short_test},
158 {"unsigned_long_test", unsigned_long_test},
159 {"unsigned_long_long_test", unsigned_long_long_test},
160 {"double_test", double_test},
161 {"char_test", char_test},
162 {"wchar_test", wchar_test},
163 {"octet_test", octet_test},
164 {"bool_test", bool_test},
165 {"struct_test", struct_test},
166 {"struct2_test", struct2_test},
167 {"seq1_test", seq1_test},
168 {"seq2_test", seq2_test},
169 {"seq3_test", seq3_test},
170 {"seq4_test", seq4_test},
171 {"seq5_test", seq5_test},
172 {"array1_test", array1_test},
173 {"array2_test", array2_test},
174 {"enum_test", enum_test},
175 {"string1_test", string1_test},
176 {"string2_test", string2_test},
177 {"string3_test", string3_test},
178 {"string4_test", string4_test},
179 {"pid_test", pid_test},
180 {"port_test", port_test},
181 {"ref_test", ref_test},
182 {"term_test", term_test},
183 {"typedef_test", typedef_test},
184 {"inline_sequence_test", inline_sequence_test},
185 {"term_sequence_test", term_sequence_test},
186 {"term_struct_test", term_struct_test},
187 {"wstring1_test", wstring1_test},
188 {"", NULL}
189 };
190
191 /* Other prototypes */
192 static void create_ic_term(ic_erlang_term** term, char* atom_name);
193 static int cmp_aseq(m_aseq *a1, m_aseq *a2);
194 static int cmp_a(m_a *a1, m_a *a2);
195 static int cmp_bseq(m_bseq *b1, m_bseq *b2);
196 static int cmp_b(m_b *b1, m_b *b2);
197 static int cmp_lseq(m_lseq *b1, m_lseq *b2);
198 static int cmp_etseq(m_etseq *b1, m_etseq *b2);
199 static int cmp_et(m_et* b1, m_et *b2);
200 static int cmp_es(m_es *b1, m_es *b2);
201 static int cmp_arr1(m_arr1 b1, m_arr1 b2);
202 static int cmp_dd(m_dd b1, m_dd b2);
203 static int cmp_strRec(m_strRec *b1, m_strRec *b2);
204 static int cmp_sseq(m_sseq *b1, m_sseq *b2);
205 static int cmp_pid(erlang_pid *p1, erlang_pid *p2);
206 static int cmp_port(erlang_port *p1, erlang_port *p2);
207 static int cmp_ref(erlang_ref *p1, erlang_ref *p2);
208 static int cmp_s(m_s *b1, m_s *b2);
209 static int cmp_ssstr3(m_ssstr3 *b1, m_ssstr3 *b2);
210 static int cmp_ssarr3(m_ssarr3 *b1, m_ssarr3 *b2);
211 static int cmp_sarr3(m_sarr3 *b1, m_sarr3 *b2);
212 static int cmp_arr3(m_arr3 b1, m_arr3 b2);
213
214 static void print_aseq(m_aseq *a);
215 static void print_a(m_a *a);
216 static void print_bseq(m_bseq *b);
217 static void print_lseq(m_lseq *b);
218 static void print_b(m_b *b);
219 static void print_etseq(m_etseq *b);
220 static void print_et(m_et* b);
221 static void print_es(m_es *b);
222 static void print_arr1(long a[500]);
223 static void print_dd(long a[2][3]);
224 static void print_strRec(m_strRec* sr);
225 static void print_sseq(m_sseq *b);
226 static void print_pid(erlang_pid *p);
227 static void print_port(erlang_port *p);
228 static void print_ref(erlang_ref *p);
229 static void print_term(ic_erlang_term *t);
230 static void print_s(m_s *p);
231 static void print_ssstr3(m_ssstr3 *b1);
232 static void print_ssarr3(m_ssarr3 *b1);
233 static void print_sarr3(m_sarr3 *b1);
234 static void print_arr3(m_arr3 b1);
235 static void print_wstr(CORBA_wchar *ws);
236
237 static void free_etseq_buf(m_etseq *b);
238 static void free_et(m_et* b);
239
240 #ifdef __WIN32__
241 typedef struct {
242 long tv_sec;
243 long tv_usec;
244 } MyTimeval;
245 #else
246 typedef struct timeval MyTimeval;
247 #endif
248 static void my_gettimeofday(MyTimeval *tv);
249 static void showtime(MyTimeval *start, MyTimeval *stop);
250 static void usage(void);
251 static void done(int r);
252
253
254
255 /* main */
256
257 #ifdef VXWORKS
client(int argc,char ** argv)258 int client(int argc, char **argv)
259 #else
260 int main(int argc, char **argv)
261 #endif
262 {
263 struct hostent *hp;
264 erlang_pid pid;
265 MyTimeval start, stop;
266 int i, fd, ires, tres;
267 IC_Env *env;
268 int tries = 0;
269 char *this_node_name = NULL;
270 char *peer_node = NULL;
271 char *peer_process_name = NULL;
272 char *cookie = NULL;
273 char host[HOSTNAMESZ + 1];
274 TestFunc test_func = NULL;
275 TestCase *test_case;
276 char *test_case_name = NULL;
277 ei_cnode ec;
278
279 #ifdef __WIN32__
280 WORD wVersionRequested;
281 WSADATA wsaData;
282
283 wVersionRequested = MAKEWORD(2, 0);
284
285 if (WSAStartup(wVersionRequested, &wsaData) != 0) {
286 fprintf(stderr, "Could not load winsock2 v2.0 compatible DLL");
287 exit(1);
288 }
289 #endif
290
291 progname = argv[0];
292 host[HOSTNAMESZ] = '\0';
293 if (gethostname(host, HOSTNAMESZ + 1) < 0) {
294 fprintf(stderr, "Can't find own hostname\n");
295 done(1);
296 }
297 if ((hp = gethostbyname(host)) == 0) {
298 fprintf(stderr, "Can't get ip address for host %s\n", host);
299 done(1);
300 }
301 for (i = 1; i < argc; i++) {
302 if (cmp_str(argv[i], "-help")) {
303 usage();
304 done(0);
305 } else if (cmp_str(argv[i], "-this-node-name")) {
306 i++;
307 this_node_name = argv[i];
308 } else if (cmp_str(argv[i], "-peer-node")) {
309 i++;
310 peer_node = argv[i];
311 } else if (cmp_str(argv[i], "-peer-process-name")) {
312 i++;
313 peer_process_name = argv[i];
314 } else if (cmp_str(argv[i], "-cookie")) {
315 i++;
316 cookie = argv[i];
317 } else if (cmp_str(argv[i], "-test-case")) {
318 i++;
319 test_case_name = argv[i];
320 } else {
321 fprintf(stderr, "Error : invalid argument \"%s\"\n", argv[i]);
322 usage();
323 done(1);
324 }
325 }
326
327 if (this_node_name == NULL || peer_node == NULL || test_case_name == NULL
328 || peer_process_name == NULL || cookie == NULL) {
329 fprintf(stderr, "Error: missing option\n");
330 usage();
331 done(1);
332 }
333
334 test_case = test_cases;
335 while (test_case->func) {
336 if (cmp_str(test_case->name, test_case_name)) {
337 test_func = test_case->func;
338 break;
339 }
340 test_case++;
341 }
342 if (test_func == NULL) {
343 fprintf(stderr, "Error: illegal test case: \"%s\"\n", test_case_name);
344 done(1);
345 }
346
347 /* Behead hostname at first dot */
348 for (i=0; host[i] != '\0'; i++) {
349 if (host[i] == '.') { host[i] = '\0'; break; }
350 }
351 sprintf(this_node, "%s@%s", this_node_name, host);
352 fprintf(stderr, "c_client: this node: \"%s\"\n", this_node);
353 fprintf(stderr, "c_client: peer node: \"%s\"\n", peer_node);
354 fprintf(stderr, "c_client: test case: \"%s\"\n", test_case_name);
355
356 fprintf(stderr, "c_client: starting\n");
357
358 /* initialize erl_interface */
359 ei_init();
360
361 for (tries = 0; tries < MAXTRIES; tries++) {
362
363 /* connect to erlang node */
364
365 ires = ei_connect_xinit(&ec, host, this_node_name, this_node,
366 (struct in_addr *)*hp->h_addr_list,
367 cookie, 0);
368
369 fprintf(stderr, "c_client: ei_connect_xinit(): %d\n", ires);
370
371 fd = ei_connect(&ec, peer_node);
372 fprintf(stderr, "c_client: ei_connect(): %d\n", fd);
373
374 if (fd >= 0)
375 break;
376 fprintf(stderr, "c_client: cannot connect, retrying\n");
377 }
378 if (fd < 0) {
379 fprintf(stderr, "c_client: cannot connect, exiting\n");
380 done(1);
381 }
382 env = CORBA_Environment_alloc(INBUFSZ, OUTBUFSZ);
383 env->_fd = fd;
384 env->_ec = &ec;
385 strcpy(env->_regname, peer_process_name);
386 env->_to_pid = NULL;
387 env->_from_pid = &pid;
388 env->_memchunk = 32;
389
390 strcpy(pid.node, this_node);
391 pid.num = fd;
392 pid.serial = 0;
393 pid.creation = 0;
394
395 my_gettimeofday(&start);
396 tres = test_func(env); /* Call test case */
397 my_gettimeofday(&stop);
398 showtime(&start, &stop);
399 ei_close_connection(fd);
400
401 printf("c_client: env->_inbuf before : %d\n", INBUFSZ);
402 printf("c_client: env->_outbuf before : %d\n", OUTBUFSZ);
403 printf("c_client: env->_inbuf after : %d\n", env->_inbufsz);
404 printf("c_client: env->_outbuf after : %d\n", env->_outbufsz);
405
406 CORBA_free(env->_inbuf);
407 CORBA_free(env->_outbuf);
408 CORBA_free(env);
409 done(tres);
410 }
411
usage()412 static void usage()
413 {
414 fprintf(stderr, "Usage: %s [-help] -this-node-name <name> "
415 "-peer-node <nodename> -peer-process-name <name> "
416 "-cookie <cookie> -test-case <test case name>\n", progname);
417 fprintf(stderr, "Example:\n %s -this-node-name kalle "
418 "-peer-node olle@home -peer-process-name idltest "
419 "-cookie oa678er -test-case octet_test\n", progname);
420 }
421
done(int r)422 static void done(int r)
423 {
424 #ifdef __WIN32__
425 WSACleanup();
426 #endif
427 exit(r);
428 }
429
430
431 /* TESTS */
432
void_test(IC_Env * env)433 static int void_test(IC_Env *env)
434 {
435 int retVal = 0;
436 fprintf(stdout, "\n======== m_i_void test ======\n\n");
437 m_i_void_test(NULL,env);
438 CHECK_EXCEPTION(env);
439
440 return retVal;
441 }
442
long_test(IC_Env * env)443 static int long_test(IC_Env *env)
444 {
445 int retVal = 0;
446 long l = 4711, lo, lr;
447
448 fprintf(stdout, "\n======== m_i_long test ======\n\n");
449 lr = m_i_long_test(NULL, l, &lo, env);
450 CHECK_EXCEPTION(env);
451 if(l == lo && l == lr) goto ok;
452 if (l != lo)
453 fprintf(stdout, " out parameter error, sent: %ld, got: %ld\n", l, lo);
454 if (l != lr)
455 fprintf(stdout, " result error, sent: %ld, got: %ld\n", l, lr);
456 retVal = -1;
457
458 ok:
459 return retVal;
460 }
461
long_long_test(IC_Env * env)462 static int long_long_test(IC_Env *env)
463 {
464 int retVal = 0;
465 CORBA_long_long ll = 4711, llo, llr;
466
467 fprintf(stdout, "\n======== m_i_longlong test ======\n\n");
468 llr = m_i_longlong_test(NULL, ll, &llo, env);
469 CHECK_EXCEPTION(env);
470 if(ll == llo && ll == llr) goto ok;
471 if (ll != llo)
472 fprintf(stdout, " out parameter error, sent: %ld, got: %ld\n",
473 ll, llo);
474 if (ll != llr)
475 fprintf(stdout, " result error, sent: %ld, got: %ld\n", ll, llr);
476 retVal = -1;
477
478 ok:
479 return retVal;
480 }
481
unsigned_short_test(IC_Env * env)482 static int unsigned_short_test(IC_Env *env)
483 {
484 int retVal = 0;
485 unsigned short x, y = 2, z;
486
487 fprintf(stdout, "\n======== m_i_ushort test ======\n\n");
488 x = m_i_ushort_test(NULL, y, &z, env);
489 CHECK_EXCEPTION(env);
490 if(y == z && y == x) goto ok;
491 if (y != z)
492 fprintf(stdout, " out parameter error, sent: %d, got: %d\n", y, z);
493 if (y != x)
494 fprintf(stdout, " result error, sent: %d, got: %d\n", y, x);
495 retVal = -1;
496
497 ok:
498 return retVal;
499 }
500
501
unsigned_long_test(IC_Env * env)502 static int unsigned_long_test(IC_Env *env)
503 {
504 int retVal = 0;
505 unsigned long ul = 5050, ulo, ulr;
506
507 fprintf(stdout, "\n======== m_i_ulong test ======\n\n");
508 ulr = m_i_ulong_test(NULL, ul, &ulo, env);
509 CHECK_EXCEPTION(env);
510 if(ul == ulo && ul == ulr) goto ok;
511 if (ul != ulo)
512 fprintf(stdout, " out parameter error, sent: %lu, got: %lu\n",
513 ul, ulo);
514 if (ul != ulr)
515 fprintf(stdout, " result error, sent: %lu, got: %lu\n", ul, ulr);
516 retVal = -1;
517
518 ok:
519 return retVal;
520 }
521
522 /*
523 * Note: CORBA_unsigned_long_long is in fact a plain long.
524 */
unsigned_long_long_test(IC_Env * env)525 static int unsigned_long_long_test(IC_Env *env)
526 {
527 int retVal = 0;
528 CORBA_unsigned_long_long ull = 5050, ullo, ullr;
529
530 fprintf(stdout, "\n======== m_i_ulonglong test ======\n\n");
531 ullr = m_i_ulonglong_test(NULL, ull, &ullo, env);
532 CHECK_EXCEPTION(env);
533 if(ull == ullo && ull == ullr) goto ok;
534 if (ull != ullo)
535 fprintf(stdout, " out parameter error, sent: %lu, got: %lu\n",
536 ull, ullo);
537 if (ull != ullr)
538 fprintf(stdout, " result error, sent: %lu, got: %lu\n",
539 ull, ullr);
540 retVal = -1;
541
542 ok:
543 return retVal;
544 }
545
double_test(IC_Env * env)546 static int double_test(IC_Env *env)
547 {
548 int retVal = 0;
549 double d = 12.1212, db, dr;
550
551 fprintf(stdout, "\n======== m_i_double test ======\n\n");
552 dr = m_i_double_test(NULL, d, &db, env);
553 CHECK_EXCEPTION(env);
554 if(d == db && d == dr) goto ok;
555 if (d != db)
556 fprintf(stdout, " out parameter error, sent: %f, got: %f\n", d, db);
557 if (d != dr)
558 fprintf(stdout, " result error, sent: %f, got: %f\n", d, dr);
559 retVal = -1;
560
561 ok:
562 return retVal;
563 }
564
char_test(IC_Env * env)565 static int char_test(IC_Env *env)
566 {
567 int retVal = 0;
568 char c = 'g', co, cr;
569
570 /* char test */
571 fprintf(stdout, "\n======== m_i_char test ======\n\n");
572 cr = m_i_char_test(NULL, c, &co, env);
573 CHECK_EXCEPTION(env);
574 if(c == co && c == cr) goto ok;
575 if (c !=co)
576 fprintf(stdout, " out parameter error, sent: %c, got: %c\n", c, co);
577 if (c != cr)
578 fprintf(stdout, " result error, sent: %c, got: %c\n", c, cr);
579 retVal = -1;
580
581 ok:
582 return retVal;
583 }
584
wchar_test(IC_Env * env)585 static int wchar_test(IC_Env *env)
586 {
587 int retVal = 0;
588 CORBA_wchar wc = 103, wco, wcr;
589
590 fprintf(stdout, "\n======== m_i_wchar test ======\n\n");
591 wcr = m_i_wchar_test(NULL, wc, &wco, env);
592 CHECK_EXCEPTION(env);
593 if(wc == wco && wc == wcr) goto ok;
594 if (wc != wco)
595 fprintf(stdout, " out parameter error, sent: %lu, got: %lu\n",
596 wc, wco);
597 if (wc != wcr)
598 fprintf(stdout, " result error, sent: %lu, got: %lu\n",
599 wc, wcr);
600 retVal = -1;
601
602 ok:
603 return retVal;
604 }
605
octet_test(IC_Env * env)606 static int octet_test(IC_Env *env)
607 {
608 int retVal = 0;
609 char o ='r', oo, or;
610
611 fprintf(stdout, "\n======== m_i_octet test ======\n\n");
612 or = m_i_octet_test(NULL, o, &oo, env);
613 CHECK_EXCEPTION(env);
614 if(o == oo && o == or) goto ok;
615 if (o != oo)
616 fprintf(stdout, " out parameter error, sent: %c, got: %c\n", o, oo);
617 if (o != or)
618 fprintf(stdout, " result error, sent: %c, got: %c\n", o, or);
619 retVal = -1;
620
621 ok:
622 return retVal;
623 }
624
bool_test(IC_Env * env)625 static int bool_test(IC_Env *env)
626 {
627 int retVal = 0;
628 unsigned char i = 0, io, ir;
629
630 fprintf(stdout, "\n======== m_i_bool test ======\n\n");
631 ir = m_i_bool_test(NULL, i, &io, env);
632 CHECK_EXCEPTION(env);
633 if(i == io && i == ir) goto ok;
634 if (i != io)
635 fprintf(stdout, " out parameter error, sent: %d, got: %d\n", i, io);
636 if (i != ir)
637 fprintf(stdout, " result error, sent: %d, got: %d\n", i, ir);
638 retVal = -1;
639
640 ok:
641 return retVal;
642 }
643
struct_test(IC_Env * env)644 static int struct_test(IC_Env *env)
645 {
646 int retVal = 0;
647 m_b b = {4711, 'a'}, bo, br;
648
649 fprintf(stdout, "\n======== m_i_struct test ======\n\n");
650 br = m_i_struct_test(NULL, &b, &bo, env);
651 CHECK_EXCEPTION(env);
652 if(cmp_b(&b, &bo) && cmp_b(&b, &br)) goto ok;
653 if (!cmp_b(&b, &bo)) {
654 fprintf(stdout, " out parameter error, sent:\n");
655 print_b(&b);
656 fprintf(stdout, " got:\n");
657 print_b(&bo);
658 fprintf(stdout, "\n");
659 }
660 if (!cmp_b(&b, &br)) {
661 fprintf(stdout, " result error, sent:\n");
662 print_b(&b);
663 fprintf(stdout, " got:\n");
664 print_b(&br);
665 fprintf(stdout, "\n");
666 }
667 retVal = -1;
668
669 ok:
670 return retVal;
671 }
672
struct2_test(IC_Env * env)673 static int struct2_test(IC_Env *env)
674 {
675 int retVal = 0;
676 m_es esi = {m_peach, 5050}, eso, esr;
677
678 fprintf(stdout, "\n======== m_i_struct2 test ======\n\n");
679 esr = m_i_struct2_test(NULL, &esi, &eso, env);
680 CHECK_EXCEPTION(env);
681 if(cmp_es(&esi, &eso) && cmp_es(&esi, &esr)) goto ok;
682 if (!cmp_es(&esi, &eso)) {
683 fprintf(stdout, " out parameter error, sent:\n");
684 print_es(&esi);
685 fprintf(stdout, " got:\n");
686 print_es(&eso);
687 fprintf(stdout, "\n");
688 }
689 if (!cmp_es(&esi, &esr)) {
690 fprintf(stdout, " result error, sent:\n");
691 print_es(&esi);
692 fprintf(stdout, " got:\n");
693 print_es(&esr);
694 fprintf(stdout, "\n");
695 }
696 retVal = -1;
697
698 ok:
699 return retVal;
700 }
701
702
seq1_test(IC_Env * env)703 static int seq1_test(IC_Env *env)
704 {
705 int retVal = 0;
706 m_bseq bs, *bso, *bsr;
707
708 m_b ba[3] = {{4711, 'a'}, {4712, 'b'}, {4713, 'c'}};
709 bs._length = 3;
710 bs._buffer = ba;
711
712 fprintf(stdout, "\n======== m_i_seq1 test ======\n\n");
713 bsr = m_i_seq1_test(NULL, &bs, &bso, env);
714 CHECK_EXCEPTION(env);
715 if(cmp_bseq(&bs, bso) && cmp_bseq(&bs, bsr)) goto ok;
716 if (!cmp_bseq(&bs, bso)) {
717 fprintf(stdout, " out parameter error, sent:\n");
718 print_bseq(&bs);
719 fprintf(stdout, " got:\n");
720 print_bseq(bso);
721 fprintf(stdout, "\n");
722 }
723 if (!cmp_bseq(&bs, bsr)) {
724 fprintf(stdout, " result error, sent:\n");
725 print_bseq(&bs);
726 fprintf(stdout, " got:\n");
727 print_bseq(bsr);
728 fprintf(stdout, "\n");
729 }
730 retVal = -1;
731
732 ok:
733 CORBA_free(bso);
734 CORBA_free(bsr);
735 return retVal;
736 }
737
seq2_test(IC_Env * env)738 static int seq2_test(IC_Env *env)
739 {
740 int retVal = 0;
741 m_b ba[3] = {{4711, 'a'}, {4712, 'b'}, {4713, 'c'}};
742 m_a a;
743 m_a aa[2];
744 m_aseq as, *aso, *asr;
745
746 a.l = 9999;
747 a.y._length = 3;
748 a.y._buffer = ba;
749 a.d = 66.89898989;
750
751 aa[0] = a;
752 aa[1] = a;
753 as._length = 2;
754 as._buffer = aa;
755
756 fprintf(stdout, "\n======== m_i_seq2 test ======\n\n");
757 asr = m_i_seq2_test(NULL, &as, &aso, env);
758 CHECK_EXCEPTION(env);
759 if(cmp_aseq(&as, aso) && cmp_aseq(&as, asr)) goto ok;
760 if (!cmp_aseq(&as, aso)) {
761 fprintf(stdout, " out parameter error, sent:\n");
762 print_aseq(&as);
763 fprintf(stdout, " got:\n");
764 print_aseq(aso);
765 fprintf(stdout, "\n");
766 }
767 if (!cmp_aseq(&as, asr)) {
768 fprintf(stdout, " result error, sent:\n");
769 print_aseq(&as);
770 fprintf(stdout, " got:\n");
771 print_aseq(asr);
772 fprintf(stdout, "\n");
773 }
774 retVal = -1;
775
776 ok:
777 CORBA_free(aso);
778 CORBA_free(asr);
779 return retVal;
780 }
781
seq3_test(IC_Env * env)782 static int seq3_test(IC_Env *env)
783 {
784 int retVal = 0;
785 m_lseq lsi, *lso, *lsr;
786 long al[500];
787 int i=0;
788
789 for (i = 0; i < 500; i++)
790 al[i]=i;
791 lsi._length = 500;
792 lsi._buffer = al;
793
794 fprintf(stdout, "\n======== m_i_seq3 test ======\n\n");
795 lsr = m_i_seq3_test(NULL, &lsi, &lso, env);
796 CHECK_EXCEPTION(env);
797 if(cmp_lseq(&lsi, lso) && cmp_lseq(&lsi, lsr)) goto ok;
798 if (!cmp_lseq(&lsi, lso)) {
799 fprintf(stdout, " out parameter error, sent:\n");
800 print_lseq(&lsi);
801 fprintf(stdout, " got:\n");
802 print_lseq(lso);
803 fprintf(stdout, "\n");
804 }
805 if (!cmp_lseq(&lsi, lsr)) {
806 fprintf(stdout, " result error, sent:\n");
807 print_lseq(&lsi);
808 fprintf(stdout, " got:\n");
809 print_lseq(lsr);
810 fprintf(stdout, "\n");
811 }
812 retVal = -1;
813
814 ok:
815 CORBA_free(lso);
816 CORBA_free(lsr);
817 return retVal;
818 }
819
seq4_test(IC_Env * env)820 static int seq4_test(IC_Env *env)
821 {
822 int retVal = 0;
823 char *stra0[3] = {"a", "long", "time"};
824 char *stra1[3] = {"ago", "there", "was"};
825 char *stra2[3] = {"a", "buggy", "compiler"};
826 m_sstr3 str3s[3] = {{3, 3, stra0}, {3, 3, stra1}, {3, 3, stra2}};
827 m_ssstr3 str3ssi = {3, 3, str3s};
828 m_ssstr3 *str3sso, *str3ssr;
829
830 fprintf(stdout, "\n======== m_i_seq4 test ======\n\n");
831 str3ssr = m_i_seq4_test(NULL, &str3ssi, &str3sso, env);
832 CHECK_EXCEPTION(env);
833 if(cmp_ssstr3(&str3ssi, str3sso) &&
834 cmp_ssstr3(&str3ssi, str3ssr)) goto ok;
835 if (!cmp_ssstr3(&str3ssi, str3sso)){
836 fprintf(stdout, " out parameter error, sent:\n");
837 print_ssstr3(&str3ssi);
838 fprintf(stdout, " got:\n");
839 print_ssstr3(str3sso);
840 fprintf(stdout, "\n");
841 }
842 if (!cmp_ssstr3(&str3ssi, str3ssr)) {
843 fprintf(stdout, " result error, sent:\n");
844 print_ssstr3(&str3ssi);
845 fprintf(stdout, " got:\n");
846 print_ssstr3(str3ssr);
847 fprintf(stdout, "\n");
848 }
849 retVal = -1;
850
851 ok:
852 CORBA_free(str3sso);
853 CORBA_free(str3ssr);
854 return retVal;
855 }
856
seq5_test(IC_Env * env)857 static int seq5_test(IC_Env *env)
858 {
859 int retVal = 0;
860 m_arr3 arr3a[3] = {
861 {4711, 18931947, 3},
862 {4711, 18931947, 3},
863 {4711, 18931947, 3}};
864 m_sarr3 arr3sa[3] = {{3, 3, arr3a}, {3, 3, arr3a}, {3, 3, arr3a}};
865 m_ssarr3 arr3ssi = {3, 3, arr3sa};
866 m_ssarr3 *arr3sso;
867 m_ssarr3 *arr3ssr;
868
869 fprintf(stdout, "\n======== m_i_seq5 test ======\n\n");
870 arr3ssr = m_i_seq5_test(NULL, &arr3ssi, &arr3sso, env);
871 CHECK_EXCEPTION(env);
872 if(cmp_ssarr3(&arr3ssi, arr3sso) &&
873 cmp_ssarr3(&arr3ssi, arr3ssr)) goto ok;
874 if (!cmp_ssarr3(&arr3ssi, arr3sso)) {
875 fprintf(stdout, " out parameter error, sent:\n");
876 print_ssarr3(&arr3ssi);
877 fprintf(stdout, " got:\n");
878 print_ssarr3(arr3sso);
879 fprintf(stdout, "\n");
880 }
881 if (!cmp_ssarr3(&arr3ssi, arr3ssr)) {
882 fprintf(stdout, " result error, sent:\n");
883 print_ssarr3(&arr3ssi);
884 fprintf(stdout, " got:\n");
885 print_ssarr3(arr3ssr);
886 fprintf(stdout, "\n");
887 }
888 retVal = -1;
889
890 ok:
891 CORBA_free(arr3sso);
892 CORBA_free(arr3ssr);
893 return retVal;
894 }
895
array1_test(IC_Env * env)896 static int array1_test(IC_Env *env)
897 {
898 int retVal = 0;
899 int i;
900 long al[500];
901 m_arr1 alo;
902 m_arr1_slice* alr;
903
904 for (i = 0; i < 500; i++)
905 al[i]=i;
906
907 fprintf(stdout, "\n======== m_i_array1 test ======\n\n");
908 alr = m_i_array1_test(NULL, al, alo, env);
909 CHECK_EXCEPTION(env);
910 if(cmp_arr1(al, alo) && cmp_arr1(al, alr)) goto ok;
911 if (!cmp_arr1(al, alo)) {
912 fprintf(stdout, " out parameter error, sent:\n");
913 print_arr1(al);
914 fprintf(stdout, " got:\n");
915 print_arr1(alo);
916 fprintf(stdout, "\n");
917 }
918 if (!cmp_arr1(al,alr)) {
919 fprintf(stdout, " result error, sent:\n");
920 print_arr1(al);
921 fprintf(stdout, " got:\n");
922 print_arr1(alr);
923 fprintf(stdout, "\n");
924 }
925 retVal = -1;
926
927 ok:
928 free(alr);
929 return retVal;
930 }
931
array2_test(IC_Env * env)932 static int array2_test(IC_Env *env)
933 {
934 int retVal = 0;
935 long dl[2][3] = {{11, 2, 7}, {22, 8 ,13}};
936 m_dd dlo;
937 m_dd_slice* dlr;
938
939 fprintf(stdout, "\n======== m_i_array2 test ======\n\n");
940 dlr = m_i_array2_test(NULL, dl, dlo, env);
941 CHECK_EXCEPTION(env);
942 if(cmp_dd(dl,dlo) && cmp_dd(dl,dlr)) goto ok;
943 if (!cmp_dd(dl,dlo)) {
944 fprintf(stdout, " out parameter error, sent:\n");
945 print_dd(dl);
946 fprintf(stdout, " got:\n");
947 print_dd(dlo);
948 fprintf(stdout, "\n");
949 }
950 if (!cmp_dd(dl,dlr)) {
951 fprintf(stdout, " result error, sent:\n");
952 print_dd(dl);
953 fprintf(stdout, " got:\n");
954 print_dd(dlr);
955 fprintf(stdout, "\n");
956 }
957 retVal = -1;
958
959 ok:
960 free(*dlr);
961 return retVal;
962 }
963
enum_test(IC_Env * env)964 static int enum_test(IC_Env *env)
965 {
966 int retVal = 0;
967 m_fruit ei = m_banana, eo, er;
968
969 fprintf(stdout, "\n======== m_i_enum test ======\n\n");
970 er = m_i_enum_test(NULL, ei, &eo, env);
971 CHECK_EXCEPTION(env);
972 if(ei == eo && ei == er) goto ok;
973 if (ei != eo)
974 fprintf(stdout, " out parameter error, sent: %d, got: %d\n", ei, eo);
975 if (ei != er)
976 fprintf(stdout, " result error, sent: %d, got: %d\n", ei, er);
977 retVal = -1;
978
979 ok:
980 return retVal;
981 }
982
string1_test(IC_Env * env)983 static int string1_test(IC_Env *env)
984 {
985 int retVal = 0;
986 char* si = longtext;
987 char* so;
988 char* sr;
989
990 fprintf(stdout, "\n======== m_i_string1 test ======\n\n");
991 sr = m_i_string1_test(NULL, si, &so, env);
992 CHECK_EXCEPTION(env);
993 if(cmp_str(si, so) && cmp_str(si, sr)) goto ok;
994 if (!cmp_str(si, so))
995 fprintf(stdout, " out parameter error, sent: %s, got: %s\n", si, so);
996 if (!cmp_str(si, sr))
997 fprintf(stdout, " result error, sent: %s, got: %s\n", si, sr);
998 retVal = -1;
999
1000 ok:
1001 CORBA_free(so);
1002 CORBA_free(sr);
1003 return retVal;
1004 }
1005
string2_test(IC_Env * env)1006 static int string2_test(IC_Env *env)
1007 {
1008 int retVal = 0;
1009 char* sa[3] = {"hello", "foo", "bar"};
1010 m_sseq ssi = {3, 3, sa};
1011 m_sseq *sso, *ssr;
1012
1013 fprintf(stdout, "\n======== m_i_string2 test ======\n\n");
1014 ssr = m_i_string2_test(NULL, &ssi, &sso, env);
1015 CHECK_EXCEPTION(env);
1016 if(cmp_sseq(&ssi, sso) && cmp_sseq(&ssi, sso)) goto ok;
1017 if (!cmp_sseq(&ssi, sso)) {
1018 fprintf(stdout, " out parameter error, sent:\n");
1019 print_sseq(&ssi);
1020 fprintf(stdout, "got:\n");
1021 print_sseq(sso);
1022 }
1023 if (!cmp_sseq(&ssi, ssr)) {
1024 fprintf(stdout, " result error, sent:\n");
1025 print_sseq(&ssi);
1026 fprintf(stdout, "got:\n");
1027 print_sseq(ssr);
1028 }
1029 retVal = -1;
1030
1031 ok:
1032 CORBA_free(sso);
1033 CORBA_free(ssr);
1034 return retVal;
1035 }
1036
string3_test(IC_Env * env)1037 static int string3_test(IC_Env *env)
1038 {
1039 int retVal = 0;
1040 char* si = longtext;
1041 char* so;
1042 char* sr;
1043
1044 fprintf(stdout, "\n======== m_i_string3 test ======\n\n");
1045 sr = m_i_string3_test(NULL, si, &so, env);
1046 CHECK_EXCEPTION(env);
1047 if(cmp_str(si, so) && cmp_str(si, so)) goto ok;
1048 if (!cmp_str(si, so))
1049 fprintf(stdout, " out parameter error, sent: %s, got: %s\n", si, so);
1050 if (!cmp_str(si, sr))
1051 fprintf(stdout, " result error, sent: %s, got: %s\n", si, sr);
1052 retVal = -1;
1053
1054 ok:
1055 CORBA_free(so);
1056 CORBA_free(sr);
1057 return retVal;
1058 }
1059
string4_test(IC_Env * env)1060 static int string4_test(IC_Env *env)
1061 {
1062 int retVal = 0;
1063 char as1[100] = "a string", as2[200] = "help", as3[200] = "hello there";
1064 m_strRec stri = { 1, /* dd */
1065 as1, /* str4 */
1066 {{'a', 'k'}, {'z', 'g'}, {'n', 'q'}}, /* str7 */
1067 {3, 3, "buf"}, /* str5 */
1068 as2, /* str6 */
1069 {'m', 'f', 'o'}, /* str8 */
1070 as3, /* str9 */
1071 {3, 3, "stu"} /* str10 */
1072 };
1073 m_strRec *stro, *strr;
1074
1075 fprintf(stdout, "\n======== m_i_string4 test ======\n\n");
1076 strr = m_i_string4_test(NULL, &stri, &stro, env);
1077 CHECK_EXCEPTION(env);
1078 if(cmp_strRec(&stri,stro) && cmp_strRec(&stri,strr)) goto ok;
1079 if (!cmp_strRec(&stri,stro)) {
1080 fprintf(stdout, " out parameter error, sent:\n");
1081 print_strRec(&stri);
1082 fprintf(stdout, " got:\n");
1083 print_strRec(stro);
1084 fprintf(stdout, "\n");
1085 }
1086 if (!cmp_strRec(&stri,strr)) {
1087 fprintf(stdout, " result error, sent:\n");
1088 print_strRec(&stri);
1089 fprintf(stdout, " got:\n");
1090 print_strRec(strr);
1091 fprintf(stdout, "\n");
1092 }
1093 retVal = -1;
1094
1095 ok:
1096 CORBA_free(stro);
1097 CORBA_free(strr);
1098 return retVal;
1099 }
1100
1101
pid_test(IC_Env * env)1102 static int pid_test(IC_Env *env)
1103 {
1104 int retVal = 0;
1105 erlang_pid pid = {"", 7, 0, 0}, pido, pidr;
1106
1107 strcpy(pid.node, this_node); /* this currently running node */
1108 fprintf(stdout, "\n======== m_i_pid test ======\n\n");
1109 pidr = m_i_pid_test(NULL, &pid, &pido, env);
1110 CHECK_EXCEPTION(env);
1111 if(cmp_pid(&pid, &pido) && cmp_pid(&pid, &pidr)) goto ok;
1112 if (!cmp_pid(&pid, &pido)) {
1113 fprintf(stdout, " out parameter error, sent:\n");
1114 print_pid(&pid);
1115 fprintf(stdout, "got:\n");
1116 print_pid(&pido);
1117 }
1118 if (!cmp_pid(&pid, &pidr)) {
1119 fprintf(stdout, " result error, sent:\n");
1120 print_pid(&pid);
1121 fprintf(stdout, "got:\n");
1122 print_pid(&pidr);
1123 }
1124 retVal = -1;
1125
1126 ok:
1127 return retVal;
1128 }
1129
port_test(IC_Env * env)1130 static int port_test(IC_Env *env)
1131 {
1132 int retVal = 0;
1133 erlang_port porti = {"node", 5, 1}, porto, portr;
1134
1135 fprintf(stdout, "\n======== m_i_port test ======\n\n");
1136 portr = m_i_port_test(NULL, &porti, &porto, env);
1137 CHECK_EXCEPTION(env);
1138 if(cmp_port(&porti, &porto) && cmp_port(&porti, &portr)) goto ok;
1139 if (!cmp_port(&porti, &porto)) {
1140 fprintf(stdout, " out parameter error, sent:\n");
1141 print_port(&porti);
1142 fprintf(stdout, "got:\n");
1143 print_port(&porto);
1144 }
1145 if (!cmp_port(&porti, &portr)) {
1146 fprintf(stdout, " result error, sent:\n");
1147 print_port(&porti);
1148 fprintf(stdout, "got:\n");
1149 print_port(&portr);
1150 }
1151 retVal = -1;
1152
1153 ok:
1154 return retVal;
1155 }
1156
ref_test(IC_Env * env)1157 static int ref_test(IC_Env *env)
1158 {
1159 int retVal = 0;
1160 erlang_ref refi = { "node1", 3, {1, 2, 3}, 1},
1161 refo, refr;
1162
1163 fprintf(stdout, "\n======== m_i_ref test ======\n\n");
1164 refr = m_i_ref_test(NULL, &refi, &refo, env);
1165 CHECK_EXCEPTION(env);
1166 if(cmp_ref(&refi, &refo) && cmp_ref(&refi, &refr)) goto ok;
1167 if (!cmp_ref(&refi, &refo)) {
1168 fprintf(stdout, " out parameter error, sent:\n");
1169 print_ref(&refi);
1170 fprintf(stdout, "got:\n");
1171 print_ref(&refo);
1172 }
1173 if (!cmp_ref(&refi, &refr)) {
1174 fprintf(stdout, " result error, sent:\n");
1175 print_ref(&refi);
1176 fprintf(stdout, "got:\n");
1177 print_ref(&refr);
1178 }
1179 retVal = -1;
1180
1181 ok:
1182 return retVal;
1183 }
1184
term_test(IC_Env * env)1185 static int term_test(IC_Env *env)
1186 {
1187 int retVal = 0;
1188 ic_erlang_term *ti, *to, *tr;
1189
1190 // [{hej, 1, 23}, \"string\", {1.23, 45}]
1191 create_ic_term(&ti, "hej");
1192
1193 fprintf(stdout, "\n======== m_i_term test ======\n\n");
1194 tr = m_i_term_test(NULL, ti, &to, env);
1195 CHECK_EXCEPTION(env);
1196 if(ic_erlang_term_is_equal(ti, to) &&
1197 ic_erlang_term_is_equal(ti, tr)) goto ok;
1198 if (!ic_erlang_term_is_equal(ti, to)) {
1199 fprintf(stdout, " out parameter error, sent:\n");
1200 print_term(ti);
1201 fprintf(stdout, "got:\n");
1202 print_term(to);
1203 }
1204 if (!ic_erlang_term_is_equal(ti, tr)) {
1205 fprintf(stdout, " result error, sent:\n");
1206 print_term(ti);
1207 fprintf(stdout, "got:\n");
1208 print_term(tr);
1209 }
1210 retVal = -1;
1211
1212 ok:
1213 ic_free_erlang_term(ti);
1214 ic_free_erlang_term(to);
1215 ic_free_erlang_term(tr);
1216
1217 return retVal;
1218 }
1219
typedef_test(IC_Env * env)1220 static int typedef_test(IC_Env *env)
1221 {
1222 int retVal = 0;
1223 m_banan mbi, mbo; /* erlang_port */
1224 m_apa mai; /* ic_erlang_term */
1225 m_apa mao = NULL;
1226 long tl;
1227
1228 strcpy(mbi.node,"node");
1229 mbi.id = 15;
1230 mbi.creation = 1;
1231
1232 fprintf(stdout, "\n======== m_i_typedef test ======\n\n");
1233 //[{hej, 1, 23}, \"string\", {1.23, 45}]
1234 create_ic_term(&mai, "hej");
1235
1236 tl = m_i_typedef_test(NULL, mai, &mbi, &mao, &mbo, env);
1237 CHECK_EXCEPTION(env);
1238 if(ic_erlang_term_is_equal(mai, mao) && cmp_port(&mbi, &mbo) &&
1239 tl == 4711) goto ok;
1240 if (!ic_erlang_term_is_equal(mai, mao)) {
1241 fprintf(stdout, " out parameter error (term), sent:\n");
1242 print_term(mai);
1243 fprintf(stdout, "got:\n");
1244 print_term(mao);
1245 }
1246 if (!cmp_port(&mbi, &mbo)) {
1247 fprintf(stdout, " out parameter error (port), sent:\n");
1248 print_port(&mbi);
1249 fprintf(stdout, "got:\n");
1250 print_port(&mbo);
1251 }
1252 if (tl != 4711) {
1253 fprintf(stdout, " result error, sent: 4711, got %ld\n", tl);
1254 }
1255 retVal = -1;
1256
1257 ok:
1258 ic_free_erlang_term(mai);
1259 ic_free_erlang_term(mao);
1260 return retVal;
1261 }
1262
inline_sequence_test(IC_Env * env)1263 static int inline_sequence_test(IC_Env *env)
1264 {
1265 int retVal = 0;
1266 int i;
1267 long al[500];
1268 m_s isi = {4711, {500, 10, al}},
1269 *iso, *isr;
1270
1271 for (i = 0; i < 500; i++)
1272 al[i]=i;
1273 fprintf(stdout, "\n======== m_i_inline_sequence test ======\n\n");
1274 isr = m_i_inline_sequence_test(NULL, &isi, &iso, env);
1275 CHECK_EXCEPTION(env);
1276 if(cmp_s(&isi, iso) && cmp_s(&isi, isr)) goto ok;
1277 if (!cmp_s(&isi, iso)) {
1278 fprintf(stdout, " out parameter error, sent:\n");
1279 print_s(&isi);
1280 fprintf(stdout, "got:\n");
1281 print_s(iso);
1282 }
1283 if (!cmp_s(&isi, isr)) {
1284 fprintf(stdout, " result error, sent:\n");
1285 print_s(&isi);
1286 fprintf(stdout, "got:\n");
1287 print_s(isr);
1288 }
1289 retVal = -1;
1290
1291 ok:
1292 CORBA_free(iso);
1293 CORBA_free(isr);
1294 return retVal;
1295 }
1296
term_sequence_test(IC_Env * env)1297 static int term_sequence_test(IC_Env *env)
1298 {
1299 int retVal = 0;
1300 ic_erlang_term* et_array[4];
1301 m_etseq etsi = {4, 4, et_array}, *etso, *etsr;
1302
1303 // [{apa, 1, 23}, \"string\", {1.23, 45}]
1304 create_ic_term(&et_array[0], "apa");
1305 // [{banan, 1, 23}, \"string\", {1.23, 45}]
1306 create_ic_term(&et_array[1], "banan");
1307 // [{apelsin, 1, 23}, \"string\", {1.23, 45}]
1308 create_ic_term(&et_array[2], "apelsin");
1309 // [{mango, 1, 23}, \"string\", {1.23, 45}]
1310 create_ic_term(&et_array[3], "mango");
1311
1312 fprintf(stdout, "\n======== m_i_term_sequence test ======\n\n");
1313 etsr = m_i_term_sequence_test(NULL, &etsi, &etso, env);
1314 CHECK_EXCEPTION(env);
1315 if(cmp_etseq(&etsi, etso) && cmp_etseq(&etsi, etsr)) goto ok;
1316 if (!cmp_etseq(&etsi, etso)) {
1317 fprintf(stdout, " out parameter error, sent:\n");
1318 print_etseq(&etsi);
1319 fprintf(stdout, "got:\n");
1320 print_etseq(etso);
1321 }
1322 if (!cmp_etseq(&etsi, etsr)) {
1323 fprintf(stdout, " result error, sent:\n");
1324 print_etseq(&etsi);
1325 fprintf(stdout, "got:\n");
1326 print_etseq(etsr);
1327 }
1328 retVal = -1;
1329
1330 ok:
1331 free_etseq_buf(&etsi);
1332 free_etseq_buf(etso);
1333 free_etseq_buf(etsr);
1334 CORBA_free(etso);
1335 CORBA_free(etsr);
1336 return retVal;
1337 }
1338
term_struct_test(IC_Env * env)1339 static int term_struct_test(IC_Env *env)
1340 {
1341 int retVal = 0;
1342 ic_erlang_term *eti_term;
1343 m_et eti;
1344 m_et eto, etr;
1345
1346 // [{hej, 1, 23}, \"string\", {1.23, 45}]
1347 create_ic_term(&eti_term, "hej");
1348 eti.e = eti_term;
1349 eti.l = 121212;
1350
1351 fprintf(stdout, "\n======== m_i_term_struct test ======\n\n");
1352 etr = m_i_term_struct_test(NULL, &eti, &eto, env);
1353 CHECK_EXCEPTION(env);
1354 if(cmp_et(&eti, &eto) && cmp_et(&eti, &etr)) goto ok;
1355 if (!cmp_et(&eti, &eto)) {
1356 fprintf(stdout, " out parameter error, sent:\n");
1357 print_et(&eti);
1358 fprintf(stdout, "got:\n");
1359 print_et(&eto);
1360 }
1361 if (!cmp_et(&eti, &etr)) {
1362 fprintf(stdout, " result error, sent:\n");
1363 print_et(&eti);
1364 fprintf(stdout, "got:\n");
1365 print_et(&etr);
1366 }
1367 retVal = -1;
1368
1369 ok:
1370 free_et(&eti);
1371 free_et(&eto);
1372 free_et(&etr);
1373 return retVal;
1374 }
1375
wstring1_test(IC_Env * env)1376 static int wstring1_test(IC_Env *env)
1377 {
1378 int retVal = 0;
1379 CORBA_wchar wsi[] = {100, 101, 102, 103, 104, 0}, *wso, *wsr;
1380
1381 fprintf(stdout, "\n======== m_i_wstring1 test ======\n\n");
1382 wsr = m_i_wstring1_test(NULL, wsi, &wso, env);
1383 CHECK_EXCEPTION(env);
1384 if(cmp_wstr(wsi, wso) && cmp_wstr(wsi, wsr)) goto ok;
1385 if (!cmp_wstr(wsi, wso)) {
1386 fprintf(stdout, " out parameter error, sent: \n");
1387 print_wstr(wsi);
1388 fprintf(stdout, "got:\n");
1389 print_wstr(wso);
1390 }
1391 if (!cmp_wstr(wsi, wsr)) {
1392 fprintf(stdout, " result error, sent: \n");
1393 print_wstr(wsi);
1394 fprintf(stdout, "got:\n");
1395 print_wstr(wsr);
1396 }
1397 retVal = -1;
1398
1399 ok:
1400 CORBA_free(wso);
1401 CORBA_free(wsr);
1402 return retVal;
1403 }
1404
1405
1406 /* Create test term */
create_ic_term(ic_erlang_term ** term,char * atom_name)1407 void create_ic_term(ic_erlang_term** term, char* atom_name)
1408 {
1409 ic_erlang_term* temp_term;
1410 ic_erlang_term *tuple, *elem;
1411
1412 temp_term = ic_mk_list_term();
1413
1414 tuple = ic_mk_tuple_term(3);
1415 elem = ic_mk_atom_term(atom_name);
1416 ic_tuple_add_elem(tuple, elem, 0);
1417 elem = ic_mk_int_term(1);
1418 ic_tuple_add_elem(tuple, elem, 1);
1419 elem = ic_mk_int_term(23);
1420 ic_tuple_add_elem(tuple, elem, 2);
1421
1422 ic_list_add_elem(temp_term, tuple);
1423
1424 elem = ic_mk_list_term_from_string("string");
1425 ic_list_add_elem(temp_term, elem);
1426
1427 tuple = ic_mk_tuple_term(2);
1428 elem = ic_mk_float_term(1.23);
1429 ic_tuple_add_elem(tuple, elem, 0);
1430 elem = ic_mk_int_term(45);
1431 ic_tuple_add_elem(tuple, elem, 1);
1432
1433 ic_list_add_elem(temp_term, tuple);
1434
1435 *term = temp_term;
1436 return;
1437 }
1438
1439 /* Compare functions */
cmp_aseq(m_aseq * a1,m_aseq * a2)1440 static int cmp_aseq(m_aseq *a1, m_aseq *a2)
1441 {
1442 int i;
1443
1444 if (a1->_length != a2->_length)
1445 return 0;
1446 for (i = 0; i < a1->_length; i++)
1447 if (cmp_a(&(a1->_buffer[i]), &(a2->_buffer[i])) == 0)
1448 return 0;
1449 return 1;
1450 }
1451
cmp_a(m_a * a1,m_a * a2)1452 static int cmp_a(m_a *a1, m_a *a2)
1453 {
1454 return a1->l == a2->l &&
1455 a1->d == a2->d &&
1456 cmp_bseq(&a1->y, &a2->y);
1457 }
1458
cmp_bseq(m_bseq * b1,m_bseq * b2)1459 static int cmp_bseq(m_bseq *b1, m_bseq *b2)
1460 {
1461 int i;
1462
1463 if (b1->_length != b2->_length)
1464 return 0;
1465 for (i = 0; i < b1->_length; i++)
1466 if (cmp_b(&(b1->_buffer[i]), &(b2->_buffer[i])) == 0)
1467 return 0;
1468 return 1;
1469 }
1470
cmp_b(m_b * b1,m_b * b2)1471 static int cmp_b(m_b *b1, m_b *b2)
1472 {
1473 return b1->l == b2->l && b1->c == b2->c;
1474 }
1475
cmp_lseq(m_lseq * b1,m_lseq * b2)1476 static int cmp_lseq(m_lseq *b1, m_lseq *b2)
1477 {
1478 int i;
1479
1480 if (b1->_length != b2->_length)
1481 return 0;
1482 for (i = 0; i < b1->_length; i++)
1483 if (b1->_buffer[i] != b2->_buffer[i])
1484 return 0;
1485 return 1;
1486 }
1487
cmp_etseq(m_etseq * b1,m_etseq * b2)1488 static int cmp_etseq(m_etseq *b1, m_etseq *b2)
1489 {
1490 int i;
1491
1492 if (b1->_length != b2->_length)
1493 return 0;
1494 for (i = 0; i < b1->_length; i++)
1495 if (!ic_erlang_term_is_equal(b1->_buffer[i], b2->_buffer[i]))
1496 return 0;
1497 return 1;
1498 }
1499
cmp_et(m_et * b1,m_et * b2)1500 static int cmp_et(m_et* b1, m_et *b2)
1501 {
1502 return ic_erlang_term_is_equal(b1->e, b2->e) && b1->l == b2->l;
1503 }
1504
cmp_es(m_es * b1,m_es * b2)1505 static int cmp_es(m_es *b1, m_es *b2)
1506 {
1507 return b1->f == b2->f && b1->l == b2->l;
1508 }
1509
cmp_arr1(m_arr1 b1,m_arr1 b2)1510 static int cmp_arr1(m_arr1 b1, m_arr1 b2)
1511 {
1512 int i;
1513
1514 for (i = 0; i < 500; i++)
1515 if (b1[i] != b2[i])
1516 return 0;
1517 return 1;
1518 }
1519
cmp_dd(m_dd b1,m_dd b2)1520 static int cmp_dd(m_dd b1, m_dd b2)
1521 {
1522
1523 int i, j;
1524
1525 for (i = 0; i < 2; i++)
1526 for (j = 0; j < 3; j++)
1527 if (b1[i][j] != b2[i][j])
1528 return 0;
1529 return 1;
1530 }
1531
1532
1533
cmp_strRec(m_strRec * b1,m_strRec * b2)1534 static int cmp_strRec(m_strRec *b1, m_strRec *b2)
1535 {
1536 int i, j;
1537
1538 if (b1->bb != b2->bb)
1539 return 0;
1540 if (!cmp_str(b1->str4,b2->str4))
1541 return 0;
1542 if (b1->str5._length != b2->str5._length)
1543 return 0;
1544 for (j = 0; j < b1->str5._length; j++)
1545 if (b1->str5._buffer[j] != b2->str5._buffer[j])
1546 return 0;
1547 if (!cmp_str(b1->str6,b2->str6))
1548 return 0;
1549 for (i = 0; i < 3; i++)
1550 for (j = 0; j < 2; j++)
1551 if (b1->str7[i][j] != b2->str7[i][j])
1552 return 0;
1553 for (j = 0; j < 3; j++)
1554 if (b1->str8[j] != b2->str8[j])
1555 return 0;
1556 if (!cmp_str(b1->str9,b2->str9))
1557 return 0;
1558 if (b1->str10._length != b2->str10._length)
1559 return 0;
1560 for (j = 0; j < b1->str10._length; j++)
1561 if (b1->str10._buffer[j] != b2->str10._buffer[j])
1562 return 0;
1563 return 1;
1564 }
1565
1566
cmp_sseq(m_sseq * b1,m_sseq * b2)1567 static int cmp_sseq(m_sseq *b1, m_sseq *b2)
1568 {
1569 int i;
1570
1571 if (b1->_length != b2->_length)
1572 return 0;
1573 for (i = 0; i < b1->_length; i++)
1574 if (!cmp_str(b1->_buffer[i], b2->_buffer[i]))
1575 return 0;
1576 return 1;
1577 }
1578
1579
cmp_pid(erlang_pid * p1,erlang_pid * p2)1580 static int cmp_pid(erlang_pid *p1, erlang_pid *p2)
1581 {
1582 return cmp_str(p1->node,p2-> node) &&
1583 p1->num == p2->num &&
1584 p1->serial == p2->serial &&
1585 p1->creation == p2->creation;
1586 }
1587
cmp_port(erlang_port * p1,erlang_port * p2)1588 static int cmp_port(erlang_port *p1, erlang_port *p2)
1589 {
1590 return cmp_str(p1->node,p2-> node) && p1->id == p2->id;
1591 }
1592
cmp_ref(erlang_ref * p1,erlang_ref * p2)1593 static int cmp_ref(erlang_ref *p1, erlang_ref *p2)
1594 {
1595 return cmp_str(p1->node, p2->node) &&
1596 p1->len == p2->len &&
1597 (p1->len < 1 || p1->n[0] == p2->n[0]) &&
1598 (p1->len < 2 || p1->n[1] == p2->n[1]) &&
1599 (p1->len < 3 || p1->n[2] == p2->n[2]);
1600 }
1601
cmp_s(m_s * b1,m_s * b2)1602 static int cmp_s(m_s *b1, m_s *b2)
1603 {
1604 int i;
1605
1606 if (b1->l != b2->l)
1607 return 0;
1608 if (b1->sl._length != b2->sl._length)
1609 return 0;
1610 for (i = 0; i < b1->sl._length; i++)
1611 if (b1->sl._buffer[i] != b2->sl._buffer[i])
1612 return 0;
1613 return 1;
1614 }
1615
1616
cmp_ssstr3(m_ssstr3 * b1,m_ssstr3 * b2)1617 static int cmp_ssstr3(m_ssstr3 *b1, m_ssstr3 *b2)
1618 {
1619 int i,j;
1620
1621 if (b1->_length != b2->_length)
1622 return 0;
1623 for (i = 0; i < b1->_length; i++) {
1624 if (b1->_buffer[i]._length != b2->_buffer[i]._length)
1625 return 0;
1626 for (j = 0; j < b1->_buffer[i]._length; j++)
1627 if (!cmp_str(b1->_buffer[i]._buffer[j],
1628 b2->_buffer[i]._buffer[j]))
1629 return 0;
1630 }
1631 return 1;
1632 }
1633
1634
1635
cmp_ssarr3(m_ssarr3 * b1,m_ssarr3 * b2)1636 static int cmp_ssarr3(m_ssarr3 *b1, m_ssarr3 *b2)
1637 {
1638 int i;
1639
1640 if (b1->_length != b2->_length)
1641 return 0;
1642 for (i = 0; i < b1->_length; i++) {
1643 if (!cmp_sarr3(&b1->_buffer[i], &b2->_buffer[i]))
1644 return 0;
1645 }
1646 return 1;
1647 }
1648
cmp_sarr3(m_sarr3 * b1,m_sarr3 * b2)1649 static int cmp_sarr3(m_sarr3 *b1, m_sarr3 *b2)
1650 {
1651 int i;
1652
1653 if (b1->_length != b2->_length)
1654 return 0;
1655 for (i = 0; i < b1->_length; i++) {
1656 if (!cmp_arr3(b1->_buffer[i], b2->_buffer[i]))
1657 return 0;
1658 }
1659 return 1;
1660 }
1661
cmp_arr3(m_arr3 b1,m_arr3 b2)1662 static int cmp_arr3(m_arr3 b1, m_arr3 b2)
1663 {
1664 int i;
1665
1666 for (i = 0; i < sizeof(m_arr3)/sizeof(CORBA_long); i++) {
1667 if (b1[i] != b2[i])
1668 return 0;
1669 }
1670 return 1;
1671 }
1672
1673 /* Print functions */
print_aseq(m_aseq * a)1674 static void print_aseq(m_aseq *a)
1675 {
1676 int i;
1677 fprintf(stdout, "\nm_aseq size: %ld --------\n", a->_length);
1678 for (i = 0; i < a->_length; i++)
1679 print_a(&(a->_buffer[i]));
1680 }
1681
print_a(m_a * a)1682 static void print_a(m_a *a)
1683 {
1684 fprintf(stdout, "\nm_a --------\n l: %ld\n d:%f\n", a->l, a->d);
1685 print_bseq(&a->y);
1686 }
1687
print_bseq(m_bseq * b)1688 static void print_bseq(m_bseq *b)
1689 {
1690 int i;
1691
1692 fprintf(stdout, "\nm_bseq size: %ld --------\n",b->_length);
1693 for (i = 0; i < b->_length; i++)
1694 print_b(&(b->_buffer[i]));
1695 }
1696
print_lseq(m_lseq * b)1697 static void print_lseq(m_lseq *b)
1698 {
1699 int i;
1700
1701 fprintf(stdout, "\nm_lseq size: %ld --------\n",b->_length);
1702 for (i = 0; i < b->_length; i++)
1703 fprintf(stdout, "[%d]: %ld\n", i, b->_buffer[i]);
1704 }
1705
print_b(m_b * b)1706 static void print_b(m_b *b)
1707 {
1708 fprintf(stdout, "\nm_b --------\n l: %ld\n c: %c\n", b->l, b->c);
1709 }
1710
1711
print_etseq(m_etseq * b)1712 static void print_etseq(m_etseq *b)
1713 {
1714 int i;
1715
1716 for (i = 0; i < b->_length; i++) {
1717 fprintf(stdout, "[%d]:\n", i);
1718 ic_print_erlang_term(b->_buffer[i]);
1719 }
1720 }
1721
1722
print_et(m_et * b)1723 static void print_et(m_et* b)
1724 {
1725 fprintf(stdout, "\net struct --------\n");
1726 ic_print_erlang_term(b->e);
1727 fprintf(stdout, "long: %ld\n", b->l);
1728 fprintf(stdout, "\n--------\n");
1729 }
1730
print_es(m_es * b)1731 static void print_es(m_es *b)
1732 {
1733 fprintf(stdout, "\nm_es --------\n f: %d\n l: %ld\n", b->f, b->l);
1734 }
1735
1736
print_arr1(long a[10])1737 static void print_arr1(long a[10])
1738 {
1739 int i;
1740
1741 for (i = 0; i < 10; i++)
1742 fprintf(stdout, "\n[%d]: %ld\n", i, a[i]);
1743 }
1744
print_dd(long a[2][3])1745 static void print_dd(long a[2][3])
1746 {
1747 int i, j;
1748
1749 fprintf(stdout, "\nlong dd[2][3] --------\n");
1750 for (i = 0; i < 2; i++)
1751 for (j = 0; j < 3; j++)
1752 fprintf(stdout, "\n[%d][%d]: %ld\n", i, j, a[i][j]);
1753 }
1754
1755
print_strRec(m_strRec * sr)1756 static void print_strRec(m_strRec* sr)
1757 {
1758 int i, j;
1759
1760 fprintf(stdout, "\nboolean bb : %d\n",sr->bb);
1761 fprintf(stdout, "string str4 : %s\n",sr->str4);
1762 fprintf(stdout, "str7[2][3] :\n");
1763 for (i = 0; i < 3; i++)
1764 for (j = 0; j < 2; j++)
1765 fprintf(stdout, "str7[%d][%d]: %ld\n", i, j, sr->str7[i][j]);
1766 fprintf(stdout, "str5._length : %ld\n",sr->str5._length);
1767 for (j = 0; j < sr->str5._length; j++)
1768 fprintf(stdout, "str5._buffer[%d]: %c\n", j, sr->str5._buffer[j]);
1769 fprintf(stdout, "string str6 : %s\n",sr->str6);
1770 fprintf(stdout, "str8 :\n");
1771 for (j = 0; j < 3; j++)
1772 fprintf(stdout, "str8[%d]: %c\n", j, sr->str8[j]);
1773 fprintf(stdout, "string str9 : %s\n",sr->str9);
1774 fprintf(stdout, "str10._length : %ld\n",sr->str10._length);
1775 for (j = 0; j < sr->str10._length; j++)
1776 fprintf(stdout, "str10._buffer[%d]: %c\n", j, sr->str10._buffer[j]);
1777 }
1778
print_sseq(m_sseq * b)1779 static void print_sseq(m_sseq *b)
1780 {
1781 int i;
1782
1783 fprintf(stdout, "\nm_sseq size: %ld --------\n",b->_length);
1784 for (i = 0; i < b->_length; i++)
1785 fprintf(stdout, "%s\n", b->_buffer[i]);
1786
1787 }
1788
1789
print_pid(erlang_pid * p)1790 static void print_pid(erlang_pid *p)
1791 {
1792 fprintf(stdout, "\nerlang_pid --------\n node: %s\n num: %d\n "
1793 "serial: %d\n creation: %d\n",
1794 p->node, p->num, p->serial, p->creation);
1795 }
1796
print_port(erlang_port * p)1797 static void print_port(erlang_port *p)
1798 {
1799 fprintf(stdout, "\nerlang_port --------\n node: %s\n id: %d\n "
1800 "creation: %d\n", p->node, p->id, p->creation);
1801 }
1802
print_ref(erlang_ref * p)1803 static void print_ref(erlang_ref *p)
1804 {
1805 fprintf(stdout, "\nerlang_ref --------\n node: %s\n len: %d\n "
1806 "n[0]: %d\n n[1]: %d\n n[2]: %d\n creation: %d\n",
1807 p->node, p->len, p->n[0], p->n[1], p->n[2], p->creation);
1808 }
1809
print_term(ic_erlang_term * t)1810 static void print_term(ic_erlang_term *t)
1811 {
1812 fprintf(stdout, "\nic_erlang_term --------\n");
1813 ic_print_erlang_term(t);
1814 fprintf(stdout, "\n--------\n");
1815 }
1816
print_s(m_s * p)1817 static void print_s(m_s *p)
1818 {
1819 int i;
1820
1821 fprintf(stdout, "\n%ld\n", p->l);
1822 for (i = 0; i < p->sl._length; i++)
1823 fprintf(stdout, "\n[%d]: %ld\n", i, p->sl._buffer[i]);
1824 }
1825
1826
print_ssstr3(m_ssstr3 * b1)1827 static void print_ssstr3(m_ssstr3 *b1)
1828 {
1829 int i,j;
1830
1831 fprintf(stdout, "\nSSSTR3 --------\n");
1832 fprintf(stdout,"b1->_length = %ld\n",b1->_length);
1833 for (i = 0; i < b1->_length; i++) {
1834 fprintf(stdout,"\nb1->_buffer[%d]._length %ld\n",
1835 i, b1->_buffer[i]._length);
1836 for (j = 0; j < b1->_buffer[i]._length; j++)
1837 fprintf(stdout,"b1->_buffer[%d]._buffer[%d] = %s\n",
1838 i, j, b1->_buffer[i]._buffer[j]);
1839 }
1840 fprintf(stdout, "\n--------\n");
1841 }
1842
print_wstr(CORBA_wchar * ws)1843 static void print_wstr(CORBA_wchar *ws)
1844 {
1845 int i = 0;
1846
1847 fprintf(stdout, "\nwstr --------\n");
1848 while (ws[i]) {
1849 fprintf(stdout, "[%d]: %ld\n", i, ws[i]);
1850 i++;
1851 }
1852 fprintf(stdout, "\n--------\n");
1853 }
1854
1855
print_ssarr3(m_ssarr3 * b1)1856 static void print_ssarr3(m_ssarr3 *b1)
1857 {
1858 int i;
1859
1860 fprintf(stdout, "\nssarr3 --------\n");
1861 fprintf(stdout,"length: %ld\n",b1->_length);
1862 fprintf(stdout, "buffer:\n");
1863 for (i = 0; i < b1->_length; i++)
1864 print_sarr3(&b1->_buffer[i]);
1865 fprintf(stdout, "\n--------\n");
1866 }
1867
print_sarr3(m_sarr3 * b1)1868 static void print_sarr3(m_sarr3 *b1)
1869 {
1870 int i;
1871
1872 fprintf(stdout, "\nsarr3 --------\n");
1873 fprintf(stdout,"length: %ld\n",b1->_length);
1874 fprintf(stdout, "buffer:\n");
1875 for (i = 0; i < b1->_length; i++)
1876 print_arr3(b1->_buffer[i]);
1877 fprintf(stdout, "\n--------\n");
1878 }
1879
print_arr3(m_arr3 b1)1880 static void print_arr3(m_arr3 b1)
1881 {
1882 int i;
1883
1884 fprintf(stdout, "\narr3 --------\n");
1885 for (i = 0; i < sizeof(m_arr3)/sizeof(CORBA_long); i++)
1886 fprintf(stdout, "%ld ", b1[i]);
1887 fprintf(stdout, "\n--------\n");
1888 }
1889
free_etseq_buf(m_etseq * b)1890 static void free_etseq_buf(m_etseq *b)
1891 {
1892 int i;
1893
1894 for (i = 0; i < b->_length; i++)
1895 ic_free_erlang_term(b->_buffer[i]);
1896 }
1897
free_et(m_et * b)1898 static void free_et(m_et* b)
1899 {
1900 ic_free_erlang_term(b->e);
1901 }
1902
showtime(MyTimeval * start,MyTimeval * stop)1903 static void showtime(MyTimeval *start, MyTimeval *stop)
1904 {
1905 MyTimeval elapsed;
1906
1907 elapsed.tv_sec = stop->tv_sec - start->tv_sec;
1908 elapsed.tv_usec = stop->tv_usec - start->tv_usec;
1909 while (elapsed.tv_usec < 0) {
1910 elapsed.tv_sec -= 1;
1911 elapsed.tv_usec += 1000000;
1912 }
1913 fprintf(stderr,"%ld.%06ld seconds\n",elapsed.tv_sec, elapsed.tv_usec);
1914 }
1915
my_gettimeofday(MyTimeval * tv)1916 static void my_gettimeofday(MyTimeval *tv)
1917 #ifdef __WIN32__
1918 #define EPOCH_JULIAN_DIFF 11644473600i64
1919 {
1920 SYSTEMTIME t;
1921 FILETIME ft;
1922 LONGLONG lft;
1923
1924 GetSystemTime(&t);
1925 SystemTimeToFileTime(&t, &ft);
1926 memcpy(&lft, &ft, sizeof(lft));
1927 tv->tv_usec = (long) ((lft / 10i64) % 1000000i64);
1928 tv->tv_sec = (long) ((lft / 10000000i64) - EPOCH_JULIAN_DIFF);
1929 }
1930 #elif defined VXWORKS
1931 {
1932 int rate = sysClkRateGet(); /* Ticks per second */
1933 unsigned long ctick = tickGet();
1934 tv->tv_sec = ctick / rate; /* secs since reboot */
1935 tv->tv_usec = ((ctick - (tv->tv_sec * rate))*1000000)/rate;
1936 }
1937 #else
1938 {
1939 gettimeofday(tv, NULL);
1940 }
1941 #endif
1942