?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[System.ServiceModel] Prevent crash in Dispatcher.ListenerLoopManager… (#7136)
[mono-project.git] / mono / tests / libtest.c
blobe1c68d5ca8b25c0e0b0c471ceb5ea335670f714d
1 #include <config.h>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <glib.h>
6 #include <gmodule.h>
7 #include <errno.h>
8 #include <time.h>
9 #include <math.h>
10
11 #ifdef WIN32
12 #include <windows.h>
13 #include "initguid.h"
14 #else
15 #include <pthread.h>
16 #endif
17
18 #ifdef WIN32
19 #define STDCALL __stdcall
20 #else
21 #define STDCALL
22 #endif
23
24 #ifdef __GNUC__
25 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
26 #endif
27
28 #ifdef WIN32
29 extern __declspec(dllimport) void __stdcall CoTaskMemFree(void *ptr);
30 #endif
31
32 typedef int (STDCALL *SimpleDelegate) (int a);
33
34 #if defined(WIN32) && defined (_MSC_VER)
35 #define LIBTEST_API __declspec(dllexport)
36 #elif defined(__GNUC__)
37 #define LIBTEST_API __attribute__ ((__visibility__ ("default")))
38 #else
39 #define LIBTEST_API
40 #endif
41
42 static void marshal_free (void *ptr)
43 {
44 #ifdef WIN32
45 CoTaskMemFree (ptr);
46 #else
47 g_free (ptr);
48 #endif
49 }
50
51 static void* marshal_alloc (gsize size)
52 {
53 #ifdef WIN32
54 return CoTaskMemAlloc (size);
55 #else
56 return g_malloc (size);
57 #endif
58 }
59
60 static void* marshal_alloc0 (gsize size)
61 {
62 #ifdef WIN32
63 void* ptr = CoTaskMemAlloc (size);
64 memset(ptr, 0, size);
65 return ptr;
66 #else
67 return g_malloc0 (size);
68 #endif
69 }
70
71 static char* marshal_strdup (const char *str)
72 {
73 #ifdef WIN32
74 int len;
75 char *buf;
76
77 if (!str)
78 return NULL;
79
80 len = strlen (str);
81 buf = (char *) CoTaskMemAlloc (len + 1);
82 return strcpy (buf, str);
83 #else
84 return g_strdup (str);
85 #endif
86 }
87
88 static gunichar2* marshal_bstr_alloc(const gchar* str)
89 {
90 #ifdef WIN32
91 gunichar2* ret = NULL;
92 gunichar2* temp = NULL;
93 temp = g_utf8_to_utf16 (str, -1, NULL, NULL, NULL);
94 ret = SysAllocString (temp);
95 g_free (temp);
96 return ret;
97 #else
98 gchar* ret = NULL;
99 int slen = strlen (str);
100 gunichar2* temp;
101 /* allocate len + 1 utf16 characters plus 4 byte integer for length*/
102 ret = (gchar *)g_malloc ((slen + 1) * sizeof(gunichar2) + sizeof(guint32));
103 if (ret == NULL)
104 return NULL;
105 temp = g_utf8_to_utf16 (str, -1, NULL, NULL, NULL);
106 memcpy (ret + sizeof(guint32), temp, slen * sizeof(gunichar2));
107 * ((guint32 *) ret) = slen * sizeof(gunichar2);
108 ret [4 + slen * sizeof(gunichar2)] = 0;
109 ret [5 + slen * sizeof(gunichar2)] = 0;
110
111 return (gunichar2*)(ret + 4);
112 #endif
113 }
114
115 #define marshal_new0(type,size) ((type *) marshal_alloc0 (sizeof (type)* (size)))
116
117 LIBTEST_API int STDCALL
118 mono_cominterop_is_supported (void)
119 {
120 #if defined(TARGET_X86) || defined(TARGET_AMD64)
121 return 1;
122 #endif
123 return 0;
124 }
125
126 LIBTEST_API unsigned short* STDCALL
127 test_lpwstr_marshal (unsigned short* chars, long length)
128 {
129 int i = 0;
130 unsigned short *res;
131
132 res = (unsigned short *)marshal_alloc (2 * (length + 1));
133
134 // printf("test_lpwstr_marshal()\n");
135
136 while ( i < length ) {
137 // printf("X|%u|\n", chars[i]);
138 res [i] = chars[i];
139 i++;
140 }
141
142 res [i] = 0;
143
144 return res;
145 }
146
147
148 LIBTEST_API void STDCALL
149 test_lpwstr_marshal_out (unsigned short** chars)
150 {
151 int i = 0;
152 const char abc[] = "ABC";
153 glong len = strlen(abc);
154
155 *chars = (unsigned short *)marshal_alloc (2 * (len + 1));
156
157 while ( i < len ) {
158 (*chars) [i] = abc[i];
159 i++;
160 }
161
162 (*chars) [i] = 0;
163 }
164
165 typedef struct {
166 int b;
167 int a;
168 int c;
169 } union_test_1_type;
170
171 LIBTEST_API int STDCALL
172 mono_union_test_1 (union_test_1_type u1) {
173 // printf ("Got values %d %d %d\n", u1.b, u1.a, u1.c);
174 return u1.a + u1.b + u1.c;
175 }
176
177 LIBTEST_API int STDCALL
178 mono_return_int (int a) {
179 // printf ("Got value %d\n", a);
180 return a;
181 }
182
183 LIBTEST_API float STDCALL
184 mono_test_marshal_pass_return_float (float f) {
185 return f + 1.0;
186 }
187
188 struct ss
189 {
190 int i;
191 };
192
193 LIBTEST_API int STDCALL
194 mono_return_int_ss (struct ss a) {
195 // printf ("Got value %d\n", a.i);
196 return a.i;
197 }
198
199 LIBTEST_API struct ss STDCALL
200 mono_return_ss (struct ss a) {
201 // printf ("Got value %d\n", a.i);
202 a.i++;
203 return a;
204 }
205
206 struct sc1
207 {
208 char c[1];
209 };
210
211 LIBTEST_API struct sc1 STDCALL
212 mono_return_sc1 (struct sc1 a) {
213 // printf ("Got value %d\n", a.c[0]);
214 a.c[0]++;
215 return a;
216 }
217
218
219 struct sc3
220 {
221 char c[3];
222 };
223
224 LIBTEST_API struct sc3 STDCALL
225 mono_return_sc3 (struct sc3 a) {
226 // printf ("Got values %d %d %d\n", a.c[0], a.c[1], a.c[2]);
227 a.c[0]++;
228 a.c[1] += 2;
229 a.c[2] += 3;
230 return a;
231 }
232
233 struct sc5
234 {
235 char c[5];
236 };
237
238 LIBTEST_API struct sc5 STDCALL
239 mono_return_sc5 (struct sc5 a) {
240 // printf ("Got values %d %d %d %d %d\n", a.c[0], a.c[1], a.c[2], a.c[3], a.c[4]);
241 a.c[0]++;
242 a.c[1] += 2;
243 a.c[2] += 3;
244 a.c[3] += 4;
245 a.c[4] += 5;
246 return a;
247 }
248
249 union su
250 {
251 int i1;
252 int i2;
253 };
254
255 LIBTEST_API int STDCALL
256 mono_return_int_su (union su a) {
257 // printf ("Got value %d\n", a.i1);
258 return a.i1;
259 }
260
261 struct FI {
262 float f1;
263 float f2;
264 float f3;
265 };
266
267 struct NestedFloat {
268 struct FI fi;
269 float f4;
270 };
271
272 LIBTEST_API struct NestedFloat STDCALL
273 mono_return_nested_float (void)
274 {
275 struct NestedFloat f;
276 f.fi.f1 = 1.0;
277 f.fi.f2 = 2.0;
278 f.fi.f3 = 3.0;
279 f.f4 = 4.0;
280 return f;
281 }
282
283 LIBTEST_API int STDCALL
284 mono_test_many_int_arguments (int a, int b, int c, int d, int e,
285 int f, int g, int h, int i, int j);
286 LIBTEST_API short STDCALL
287 mono_test_many_short_arguments (short a, short b, short c, short d, short e,
288 short f, short g, short h, short i, short j);
289 LIBTEST_API char STDCALL
290 mono_test_many_char_arguments (char a, char b, char c, char d, char e,
291 char f, char g, char h, char i, char j);
292
293 LIBTEST_API int STDCALL
294 mono_test_many_int_arguments (int a, int b, int c, int d, int e, int f, int g, int h, int i, int j)
295 {
296 return a + b + c + d + e + f + g + h + i + j;
297 }
298
299 LIBTEST_API short STDCALL
300 mono_test_many_short_arguments (short a, short b, short c, short d, short e, short f, short g, short h, short i, short j)
301 {
302 return a + b + c + d + e + f + g + h + i + j;
303 }
304
305 LIBTEST_API char STDCALL
306 mono_test_many_byte_arguments (char a, char b, char c, char d, char e, char f, char g, char h, char i, char j)
307 {
308 return a + b + c + d + e + f + g + h + i + j;
309 }
310
311 LIBTEST_API float STDCALL
312 mono_test_many_float_arguments (float a, float b, float c, float d, float e, float f, float g, float h, float i, float j)
313 {
314 return a + b + c + d + e + f + g + h + i + j;
315 }
316
317 LIBTEST_API double STDCALL
318 mono_test_many_double_arguments (double a, double b, double c, double d, double e, double f, double g, double h, double i, double j)
319 {
320 return a + b + c + d + e + f + g + h + i + j;
321 }
322
323 LIBTEST_API double STDCALL
324 mono_test_split_double_arguments (double a, double b, float c, double d, double e)
325 {
326 return a + b + c + d + e;
327 }
328
329 LIBTEST_API int STDCALL
330 mono_test_puts_static (char *s)
331 {
332 // printf ("TEST %s\n", s);
333 return 1;
334 }
335
336 typedef int (STDCALL *SimpleDelegate3) (int a, int b);
337
338 LIBTEST_API int STDCALL
339 mono_invoke_delegate (SimpleDelegate3 delegate)
340 {
341 int res;
342
343 // printf ("start invoke %p\n", delegate);
344
345 res = delegate (2, 3);
346
347 // printf ("end invoke\n");
348
349 return res;
350 }
351
352 LIBTEST_API int STDCALL
353 mono_invoke_simple_delegate (SimpleDelegate d)
354 {
355 return d (4);
356 }
357
358 LIBTEST_API int STDCALL
359 mono_test_marshal_char (short a1)
360 {
361 if (a1 == 'a')
362 return 0;
363
364 return 1;
365 }
366
367 LIBTEST_API void STDCALL
368 mono_test_marshal_char_array (gunichar2 *s)
369 {
370 const char m[] = "abcdef";
371 gunichar2* s2;
372 glong len;
373
374 s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
375
376 len = (len * 2) + 2;
377 memcpy (s, s2, len);
378
379 g_free (s2);
380 }
381
382 LIBTEST_API int STDCALL
383 mono_test_marshal_ansi_char_array (char *s)
384 {
385 const char m[] = "abcdef";
386
387 if (strncmp ("qwer", s, 4))
388 return 1;
389
390 memcpy (s, m, sizeof (m));
391 return 0;
392 }
393
394 LIBTEST_API int STDCALL
395 mono_test_marshal_unicode_char_array (gunichar2 *s)
396 {
397 const char m[] = "abcdef";
398 const char expected[] = "qwer";
399 gunichar2 *s1, *s2;
400 glong len1, len2;
401
402 s1 = g_utf8_to_utf16 (m, -1, NULL, &len1, NULL);
403 s2 = g_utf8_to_utf16 (expected, -1, NULL, &len2, NULL);
404 len1 = (len1 * 2);
405 len2 = (len2 * 2);
406
407 if (memcmp (s, s2, len2))
408 return 1;
409
410 memcpy (s, s1, len1);
411 return 0;
412 }
413
414 LIBTEST_API int STDCALL
415 mono_test_empty_pinvoke (int i)
416 {
417 return i;
418 }
419
420 LIBTEST_API int STDCALL
421 mono_test_marshal_bool_byref (int a, int *b, int c)
422 {
423 int res = *b;
424
425 *b = 1;
426
427 return res;
428 }
429
430 LIBTEST_API int STDCALL
431 mono_test_marshal_bool_in_as_I1_U1 (char bTrue, char bFalse)
432 {
433 if (!bTrue)
434 return 1;
435 if (bFalse)
436 return 2;
437 return 0;
438 }
439
440 LIBTEST_API int STDCALL
441 mono_test_marshal_bool_out_as_I1_U1 (char* bTrue, char* bFalse)
442 {
443 if (!bTrue || !bFalse)
444 return 3;
445
446 *bTrue = 1;
447 *bFalse = 0;
448
449 return 0;
450 }
451
452 LIBTEST_API int STDCALL
453 mono_test_marshal_bool_ref_as_I1_U1 (char* bTrue, char* bFalse)
454 {
455 if (!bTrue || !bFalse)
456 return 4;
457
458 if (!(*bTrue))
459 return 5;
460 if (*bFalse)
461 return 6;
462
463 *bFalse = 1;
464 *bTrue = 0;
465
466 return 0;
467 }
468
469 LIBTEST_API int STDCALL
470 mono_test_marshal_array (int *a1)
471 {
472 int i, sum = 0;
473
474 for (i = 0; i < 50; i++)
475 sum += a1 [i];
476
477 return sum;
478 }
479
480 LIBTEST_API int STDCALL
481 mono_test_marshal_inout_array (int *a1)
482 {
483 int i, sum = 0;
484
485 for (i = 0; i < 50; i++) {
486 sum += a1 [i];
487 a1 [i] = 50 - a1 [i];
488 }
489
490 return sum;
491 }
492
493 LIBTEST_API int /* cdecl */
494 mono_test_marshal_inout_array_cdecl (int *a1)
495 {
496 return mono_test_marshal_inout_array (a1);
497 }
498
499 LIBTEST_API int STDCALL
500 mono_test_marshal_out_array (int *a1)
501 {
502 int i;
503
504 for (i = 0; i < 50; i++) {
505 a1 [i] = i;
506 }
507
508 return 0;
509 }
510
511 LIBTEST_API int STDCALL
512 mono_test_marshal_out_byref_array_out_size_param (int **out_arr, int *out_len)
513 {
514 int *arr;
515 int i, len;
516
517 len = 4;
518 arr = (gint32 *)marshal_alloc (sizeof (gint32) * len);
519 for (i = 0; i < len; ++i)
520 arr [i] = i;
521 *out_arr = arr;
522 *out_len = len;
523
524 return 0;
525 }
526
527 LIBTEST_API int STDCALL
528 mono_test_marshal_out_lparray_out_size_param (int *arr, int *out_len)
529 {
530 int i, len;
531
532 len = 4;
533 for (i = 0; i < len; ++i)
534 arr [i] = i;
535 *out_len = len;
536
537 return 0;
538 }
539
540 LIBTEST_API int STDCALL
541 mono_test_marshal_inout_nonblittable_array (gunichar2 *a1)
542 {
543 int i, sum = 0;
544
545 for (i = 0; i < 10; i++) {
546 a1 [i] = 'F';
547 }
548
549 return sum;
550 }
551
552 typedef struct {
553 int a;
554 int b;
555 int c;
556 const char *d;
557 gunichar2 *d2;
558 } simplestruct;
559
560 typedef struct {
561 double x;
562 double y;
563 } point;
564
565 LIBTEST_API simplestruct STDCALL
566 mono_test_return_vtype (int i)
567 {
568 simplestruct res;
569 static gunichar2 test2 [] = { 'T', 'E', 'S', 'T', '2', 0 };
570
571 res.a = 0;
572 res.b = 1;
573 res.c = 0;
574 res.d = "TEST";
575 res.d2 = test2;
576
577 return res;
578 }
579
580 LIBTEST_API void STDCALL
581 mono_test_delegate_struct (void)
582 {
583 // printf ("TEST\n");
584 }
585
586 typedef char* (STDCALL *ReturnStringDelegate) (const char *s);
587
588 LIBTEST_API char * STDCALL
589 mono_test_return_string (ReturnStringDelegate func)
590 {
591 char *res;
592
593 // printf ("mono_test_return_string\n");
594
595 res = func ("TEST");
596 marshal_free (res);
597
598 // printf ("got string: %s\n", res);
599 return marshal_strdup ("12345");
600 }
601
602 typedef int (STDCALL *RefVTypeDelegate) (int a, simplestruct *ss, int b);
603
604 LIBTEST_API int STDCALL
605 mono_test_ref_vtype (int a, simplestruct *ss, int b, RefVTypeDelegate func)
606 {
607 if (a == 1 && b == 2 && ss->a == 0 && ss->b == 1 && ss->c == 0 &&
608 !strcmp (ss->d, "TEST1")) {
609 ss->a = 1;
610 ss->b = 0;
611 ss->c = 1;
612 ss->d = "TEST2";
613
614 return func (a, ss, b);
615 }
616
617 return 1;
618 }
619
620 typedef int (STDCALL *OutVTypeDelegate) (int a, simplestruct *ss, int b);
621
622 LIBTEST_API int STDCALL
623 mono_test_marshal_out_struct (int a, simplestruct *ss, int b, OutVTypeDelegate func)
624 {
625 /* Check that the input pointer is ignored */
626 ss->d = (const char *)0x12345678;
627
628 func (a, ss, b);
629
630 if (ss->a && ss->b && ss->c && !strcmp (ss->d, "TEST3"))
631 return 0;
632 else
633 return 1;
634 }
635
636 typedef int (STDCALL *InVTypeDelegate) (int a, simplestruct *ss, int b);
637
638 LIBTEST_API int STDCALL
639 mono_test_marshal_in_struct (int a, simplestruct *ss, int b, InVTypeDelegate func)
640 {
641 simplestruct ss2;
642 int res;
643
644 memcpy (&ss2, ss, sizeof (simplestruct));
645
646 res = func (a, ss, b);
647 if (res) {
648 printf ("mono_test_marshal_in_struct () failed: %d\n", res);
649 return 1;
650 }
651
652 /* Check that no modifications is made to the struct */
653 if (ss2.a == ss->a && ss2.b == ss->b && ss2.c == ss->c && ss2.d == ss->d)
654 return 0;
655 else
656 return 1;
657 }
658
659 typedef struct {
660 int a;
661 SimpleDelegate func, func2, func3;
662 } DelegateStruct;
663
664 LIBTEST_API DelegateStruct STDCALL
665 mono_test_marshal_delegate_struct (DelegateStruct ds)
666 {
667 DelegateStruct res;
668
669 res.a = ds.func (ds.a) + ds.func2 (ds.a) + (ds.func3 == NULL ? 0 : 1);
670 res.func = ds.func;
671 res.func2 = ds.func2;
672 res.func3 = NULL;
673
674 return res;
675 }
676
677 LIBTEST_API int STDCALL
678 mono_test_marshal_struct (simplestruct ss)
679 {
680 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
681 !strcmp (ss.d, "TEST"))
682 return 0;
683
684 return 1;
685 }
686
687 LIBTEST_API int STDCALL
688 mono_test_marshal_byref_struct (simplestruct *ss, int a, int b, int c, char *d)
689 {
690 gboolean res = (ss->a == a && ss->b == b && ss->c == c && strcmp (ss->d, d) == 0);
691
692 marshal_free ((char*)ss->d);
693
694 ss->a = !ss->a;
695 ss->b = !ss->b;
696 ss->c = !ss->c;
697 ss->d = marshal_strdup ("DEF");
698
699 return res ? 0 : 1;
700 }
701
702 typedef struct {
703 int a;
704 int b;
705 int c;
706 char *d;
707 unsigned char e;
708 double f;
709 unsigned char g;
710 guint64 h;
711 } simplestruct2;
712
713 LIBTEST_API int STDCALL
714 mono_test_marshal_struct2 (simplestruct2 ss)
715 {
716 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
717 !strcmp (ss.d, "TEST") &&
718 ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
719 return 0;
720
721 return 1;
722 }
723
724 /* on HP some of the struct should be on the stack and not in registers */
725 LIBTEST_API int STDCALL
726 mono_test_marshal_struct2_2 (int i, int j, int k, simplestruct2 ss)
727 {
728 if (i != 10 || j != 11 || k != 12)
729 return 1;
730 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
731 !strcmp (ss.d, "TEST") &&
732 ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
733 return 0;
734
735 return 1;
736 }
737
738 LIBTEST_API int STDCALL
739 mono_test_marshal_lpstruct (simplestruct *ss)
740 {
741 if (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
742 !strcmp (ss->d, "TEST"))
743 return 0;
744
745 return 1;
746 }
747
748 LIBTEST_API int STDCALL
749 mono_test_marshal_lpstruct_blittable (point *p)
750 {
751 if (p->x == 1.0 && p->y == 2.0)
752 return 0;
753 else
754 return 1;
755 }
756
757 LIBTEST_API int STDCALL
758 mono_test_marshal_struct_array (simplestruct2 *ss)
759 {
760 if (! (ss[0].a == 0 && ss[0].b == 1 && ss[0].c == 0 &&
761 !strcmp (ss[0].d, "TEST") &&
762 ss[0].e == 99 && ss[0].f == 1.5 && ss[0].g == 42 && ss[0].h == (guint64)123))
763 return 1;
764
765 if (! (ss[1].a == 0 && ss[1].b == 0 && ss[1].c == 0 &&
766 !strcmp (ss[1].d, "TEST2") &&
767 ss[1].e == 100 && ss[1].f == 2.5 && ss[1].g == 43 && ss[1].h == (guint64)124))
768 return 1;
769
770 return 0;
771 }
772
773 typedef struct long_align_struct {
774 gint32 a;
775 gint64 b;
776 gint64 c;
777 } long_align_struct;
778
779 LIBTEST_API int STDCALL
780 mono_test_marshal_long_align_struct_array (long_align_struct *ss)
781 {
782 return ss[0].a + ss[0].b + ss[0].c + ss[1].a + ss[1].b + ss[1].c;
783 }
784
785 LIBTEST_API simplestruct2 * STDCALL
786 mono_test_marshal_class (int i, int j, int k, simplestruct2 *ss, int l)
787 {
788 simplestruct2 *res;
789
790 if (!ss)
791 return NULL;
792
793 if (i != 10 || j != 11 || k != 12 || l != 14)
794 return NULL;
795 if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
796 !strcmp (ss->d, "TEST") &&
797 ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
798 return NULL;
799
800 res = marshal_new0 (simplestruct2, 1);
801 memcpy (res, ss, sizeof (simplestruct2));
802 res->d = marshal_strdup ("TEST");
803 return res;
804 }
805
806 LIBTEST_API int STDCALL
807 mono_test_marshal_byref_class (simplestruct2 **ssp)
808 {
809 simplestruct2 *ss = *ssp;
810 simplestruct2 *res;
811
812 if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
813 !strcmp (ss->d, "TEST") &&
814 ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
815 return 1;
816
817 res = marshal_new0 (simplestruct2, 1);
818 memcpy (res, ss, sizeof (simplestruct2));
819 res->d = marshal_strdup ("TEST-RES");
820
821 *ssp = res;
822 return 0;
823 }
824
825 static void *
826 get_sp (void)
827 {
828 int i;
829 void *p;
830
831 /* Yes, this is correct, we are only trying to determine the value of the stack here */
832 p = &i;
833 return p;
834 }
835
836 LIBTEST_API int STDCALL
837 reliable_delegate (int a)
838 {
839 return a;
840 }
841
842 /*
843 * Checks whether get_sp() works as expected. It doesn't work with gcc-2.95.3 on linux.
844 */
845 static gboolean
846 is_get_sp_reliable (void)
847 {
848 void *sp1, *sp2;
849
850 reliable_delegate(1);
851 sp1 = get_sp();
852 reliable_delegate(1);
853 sp2 = get_sp();
854 return sp1 == sp2;
855 }
856
857 LIBTEST_API int STDCALL
858 mono_test_marshal_delegate (SimpleDelegate delegate)
859 {
860 void *sp1, *sp2;
861
862 /* Check that the delegate wrapper is stdcall */
863 delegate (2);
864 sp1 = get_sp ();
865 delegate (2);
866 sp2 = get_sp ();
867 if (is_get_sp_reliable())
868 g_assert (sp1 == sp2);
869
870 return delegate (2);
871 }
872
873 static int STDCALL inc_cb (int i)
874 {
875 return i + 1;
876 }
877
878 LIBTEST_API int STDCALL
879 mono_test_marshal_out_delegate (SimpleDelegate *delegate)
880 {
881 *delegate = inc_cb;
882
883 return 0;
884 }
885
886 LIBTEST_API SimpleDelegate STDCALL
887 mono_test_marshal_return_delegate (SimpleDelegate delegate)
888 {
889 return delegate;
890 }
891
892 typedef int (STDCALL *DelegateByrefDelegate) (void *);
893
894 LIBTEST_API int STDCALL
895 mono_test_marshal_delegate_ref_delegate (DelegateByrefDelegate del)
896 {
897 int (STDCALL *ptr) (int i);
898
899 del (&ptr);
900
901 return ptr (54);
902 }
903
904 static int STDCALL
905 return_plus_one (int i)
906 {
907 return i + 1;
908 }
909
910 LIBTEST_API SimpleDelegate STDCALL
911 mono_test_marshal_return_delegate_2 (void)
912 {
913 return return_plus_one;
914 }
915
916 typedef simplestruct (STDCALL *SimpleDelegate2) (simplestruct ss);
917
918 static gboolean
919 is_utf16_equals (gunichar2 *s1, const char *s2)
920 {
921 char *s;
922 int res;
923
924 s = g_utf16_to_utf8 (s1, -1, NULL, NULL, NULL);
925 res = strcmp (s, s2);
926 g_free (s);
927
928 return res == 0;
929 }
930
931 LIBTEST_API int STDCALL
932 mono_test_marshal_delegate2 (SimpleDelegate2 delegate)
933 {
934 simplestruct ss, res;
935
936 ss.a = 0;
937 ss.b = 1;
938 ss.c = 0;
939 ss.d = "TEST";
940 ss.d2 = g_utf8_to_utf16 ("TEST2", -1, NULL, NULL, NULL);
941
942 res = delegate (ss);
943 if (! (res.a && !res.b && res.c && !strcmp (res.d, "TEST-RES") && is_utf16_equals (res.d2, "TEST2-RES")))
944 return 1;
945
946 return 0;
947 }
948
949 typedef simplestruct* (STDCALL *SimpleDelegate4) (simplestruct *ss);
950
951 LIBTEST_API int STDCALL
952 mono_test_marshal_delegate4 (SimpleDelegate4 delegate)
953 {
954 simplestruct ss;
955 simplestruct *res;
956
957 ss.a = 0;
958 ss.b = 1;
959 ss.c = 0;
960 ss.d = "TEST";
961
962 /* Check argument */
963 res = delegate (&ss);
964 if (!res)
965 return 1;
966
967 /* Check return value */
968 if (! (!res->a && res->b && !res->c && !strcmp (res->d, "TEST")))
969 return 2;
970
971 /* Check NULL argument and NULL result */
972 res = delegate (NULL);
973 if (res)
974 return 3;
975
976 return 0;
977 }
978
979 typedef int (STDCALL *SimpleDelegate5) (simplestruct **ss);
980
981 LIBTEST_API int STDCALL
982 mono_test_marshal_delegate5 (SimpleDelegate5 delegate)
983 {
984 simplestruct ss;
985 int res;
986 simplestruct *ptr;
987
988 ss.a = 0;
989 ss.b = 1;
990 ss.c = 0;
991 ss.d = "TEST";
992
993 ptr = &ss;
994
995 res = delegate (&ptr);
996 if (res != 0)
997 return 1;
998
999 if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
1000 return 2;
1001
1002 return 0;
1003 }
1004
1005 LIBTEST_API int STDCALL
1006 mono_test_marshal_delegate6 (SimpleDelegate5 delegate)
1007 {
1008 delegate (NULL);
1009 return 0;
1010 }
1011
1012 typedef int (STDCALL *SimpleDelegate7) (simplestruct **ss);
1013
1014 LIBTEST_API int STDCALL
1015 mono_test_marshal_delegate7 (SimpleDelegate7 delegate)
1016 {
1017 int res;
1018 simplestruct *ptr;
1019
1020 /* Check that the input pointer is ignored */
1021 ptr = (simplestruct *)0x12345678;
1022
1023 res = delegate (&ptr);
1024 if (res != 0)
1025 return 1;
1026
1027 if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
1028 return 2;
1029
1030 return 0;
1031 }
1032
1033 typedef int (STDCALL *InOutByvalClassDelegate) (simplestruct *ss);
1034
1035 LIBTEST_API int STDCALL
1036 mono_test_marshal_inout_byval_class_delegate (InOutByvalClassDelegate delegate)
1037 {
1038 int res;
1039 simplestruct ss;
1040
1041 ss.a = FALSE;
1042 ss.b = TRUE;
1043 ss.c = FALSE;
1044 ss.d = g_strdup_printf ("%s", "FOO");
1045
1046 res = delegate (&ss);
1047 if (res != 0)
1048 return 1;
1049
1050 if (!(ss.a && !ss.b && ss.c && !strcmp (ss.d, "RES")))
1051 return 2;
1052
1053 return 0;
1054 }
1055
1056 typedef int (STDCALL *SimpleDelegate8) (gunichar2 *s);
1057
1058 LIBTEST_API int STDCALL
1059 mono_test_marshal_delegate8 (SimpleDelegate8 delegate, gunichar2 *s)
1060 {
1061 return delegate (s);
1062 }
1063
1064 typedef int (STDCALL *return_int_fnt) (int i);
1065 typedef int (STDCALL *SimpleDelegate9) (return_int_fnt d);
1066
1067 LIBTEST_API int STDCALL
1068 mono_test_marshal_delegate9 (SimpleDelegate9 delegate, gpointer ftn)
1069 {
1070 return delegate ((return_int_fnt)ftn);
1071 }
1072
1073 static int STDCALL
1074 return_self (int i)
1075 {
1076 return i;
1077 }
1078
1079 LIBTEST_API int STDCALL
1080 mono_test_marshal_delegate10 (SimpleDelegate9 delegate)
1081 {
1082 return delegate (return_self);
1083 }
1084
1085 typedef int (STDCALL *PrimitiveByrefDelegate) (int *i);
1086
1087 LIBTEST_API int STDCALL
1088 mono_test_marshal_primitive_byref_delegate (PrimitiveByrefDelegate delegate)
1089 {
1090 int i = 1;
1091
1092 int res = delegate (&i);
1093 if (res != 0)
1094 return res;
1095
1096 if (i != 2)
1097 return 2;
1098
1099 return 0;
1100 }
1101
1102 typedef int (STDCALL *return_int_delegate) (int i);
1103
1104 typedef return_int_delegate (STDCALL *ReturnDelegateDelegate) (void);
1105
1106 LIBTEST_API int STDCALL
1107 mono_test_marshal_return_delegate_delegate (ReturnDelegateDelegate d)
1108 {
1109 return (d ()) (55);
1110 }
1111
1112 typedef int (STDCALL *VirtualDelegate) (int);
1113
1114 LIBTEST_API int STDCALL
1115 mono_test_marshal_virtual_delegate (VirtualDelegate del)
1116 {
1117 return del (42);
1118 }
1119
1120 typedef char* (STDCALL *IcallDelegate) (const char *);
1121 LIBTEST_API int STDCALL
1122 mono_test_marshal_icall_delegate (IcallDelegate del)
1123 {
1124 char *res = del ("ABC");
1125 return strcmp (res, "ABC") == 0 ? 0 : 1;
1126 }
1127
1128 LIBTEST_API int STDCALL
1129 mono_test_marshal_stringbuilder (char *s, int n)
1130 {
1131 const char m[] = "This is my message. Isn't it nice?";
1132
1133 if (strcmp (s, "ABCD") != 0)
1134 return 1;
1135 memcpy(s, m, n);
1136 s [n] = '\0';
1137 return 0;
1138 }
1139
1140 LIBTEST_API int STDCALL
1141 mono_test_marshal_stringbuilder_append (char *s, int length)
1142 {
1143 const char out_sentinel[] = "CSHARP_";
1144 const char out_len = strlen (out_sentinel);
1145
1146 for (int i=0; i < length; i++) {
1147 s [i] = out_sentinel [i % out_len];
1148 }
1149
1150 s [length] = '\0';
1151
1152
1153 return 0;
1154 }
1155
1156 LIBTEST_API int STDCALL
1157 mono_test_marshal_stringbuilder_default (char *s, int n)
1158 {
1159 const char m[] = "This is my message. Isn't it nice?";
1160
1161 memcpy(s, m, n);
1162 s [n] = '\0';
1163 return 0;
1164 }
1165
1166 LIBTEST_API int STDCALL
1167 mono_test_marshal_stringbuilder_unicode (gunichar2 *s, int n)
1168 {
1169 const char m[] = "This is my message. Isn't it nice?";
1170 gunichar2* s2;
1171 glong len;
1172
1173 s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
1174
1175 len = (len * 2) + 2;
1176 if (len > (n * 2))
1177 len = n * 2;
1178 memcpy (s, s2, len);
1179
1180 g_free (s2);
1181
1182 return 0;
1183 }
1184
1185 LIBTEST_API void STDCALL
1186 mono_test_marshal_stringbuilder_out (char **s)
1187 {
1188 const char m[] = "This is my message. Isn't it nice?";
1189 char *str;
1190
1191 str = (char *)marshal_alloc (strlen (m) + 1);
1192 memcpy (str, m, strlen (m) + 1);
1193
1194 *s = str;
1195 }
1196
1197 LIBTEST_API int STDCALL
1198 mono_test_marshal_stringbuilder_out_unicode (gunichar2 **s)
1199 {
1200 const char m[] = "This is my message. Isn't it nice?";
1201 gunichar2 *s2;
1202 glong len;
1203
1204 s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
1205
1206 len = (len * 2) + 2;
1207 *s = (gunichar2 *)marshal_alloc (len);
1208 memcpy (*s, s2, len);
1209
1210 g_free (s2);
1211
1212 return 0;
1213 }
1214
1215 LIBTEST_API int STDCALL
1216 mono_test_marshal_stringbuilder_ref (char **s)
1217 {
1218 const char m[] = "This is my message. Isn't it nice?";
1219 char *str;
1220
1221 if (strcmp (*s, "ABC"))
1222 return 1;
1223
1224 str = (char *)marshal_alloc (strlen (m) + 1);
1225 memcpy (str, m, strlen (m) + 1);
1226
1227 *s = str;
1228 return 0;
1229 }
1230
1231 #ifdef __GNUC__
1232 #pragma GCC diagnostic push
1233 #pragma GCC diagnostic ignored "-Wc++-compat"
1234 #endif
1235
1236 /*
1237 * Standard C and C++ doesn't allow empty structs, empty structs will always have a size of 1 byte.
1238 * GCC have an extension to allow empty structs, https://gcc.gnu.org/onlinedocs/gcc/Empty-Structures.html.
1239 * This cause a little dilemma since runtime build using none GCC compiler will not be compatible with
1240 * GCC build C libraries and the other way around. On platforms where empty structs has size of 1 byte
1241 * it must be represented in call and cannot be dropped. On Windows x64 structs will always be represented in the call
1242 * meaning that an empty struct must have a representation in the callee in order to correctly follow the ABI used by the
1243 * C/C++ standard and the runtime.
1244 */
1245 typedef struct {
1246 #if !defined(__GNUC__) || defined(TARGET_WIN32)
1247 char a;
1248 #endif
1249 } EmptyStruct;
1250
1251 #ifdef __GNUC__
1252 #pragma GCC diagnostic pop
1253 #endif
1254
1255 LIBTEST_API int STDCALL
1256 mono_test_marshal_empty_string_array (char **array)
1257 {
1258 return (array == NULL) ? 0 : 1;
1259 }
1260
1261 LIBTEST_API int STDCALL
1262 mono_test_marshal_string_array (char **array)
1263 {
1264 if (strcmp (array [0], "ABC"))
1265 return 1;
1266 if (strcmp (array [1], "DEF"))
1267 return 2;
1268
1269 if (array [2] != NULL)
1270 return 3;
1271
1272 return 0;
1273 }
1274
1275 LIBTEST_API int STDCALL
1276 mono_test_marshal_byref_string_array (char ***array)
1277 {
1278 if (*array == NULL)
1279 return 0;
1280
1281 if (strcmp ((*array) [0], "Alpha"))
1282 return 2;
1283 if (strcmp ((*array) [1], "Beta"))
1284 return 2;
1285 if (strcmp ((*array) [2], "Gamma"))
1286 return 2;
1287
1288 return 1;
1289 }
1290
1291 LIBTEST_API int STDCALL
1292 mono_test_marshal_stringbuilder_array (char **array)
1293 {
1294 if (strcmp (array [0], "ABC"))
1295 return 1;
1296 if (strcmp (array [1], "DEF"))
1297 return 2;
1298
1299 strcpy (array [0], "DEF");
1300 strcpy (array [1], "ABC");
1301
1302 return 0;
1303 }
1304
1305 LIBTEST_API int STDCALL
1306 mono_test_marshal_unicode_string_array (gunichar2 **array, char **array2)
1307 {
1308 GError *gerror = NULL;
1309 char *s;
1310
1311 s = g_utf16_to_utf8 (array [0], -1, NULL, NULL, &gerror);
1312 if (strcmp (s, "ABC")) {
1313 g_free (s);
1314 return 1;
1315 }
1316 else
1317 g_free (s);
1318
1319 s = g_utf16_to_utf8 (array [1], -1, NULL, NULL, &gerror);
1320 if (strcmp (s, "DEF")) {
1321 g_free (s);
1322 return 2;
1323 }
1324 else
1325 g_free (s);
1326
1327 if (strcmp (array2 [0], "ABC"))
1328 return 3;
1329
1330 if (strcmp (array2 [1], "DEF"))
1331 return 4;
1332
1333 return 0;
1334 }
1335
1336 /* this does not work on Redhat gcc 2.96 */
1337 LIBTEST_API int STDCALL
1338 mono_test_empty_struct (int a, EmptyStruct es, int b)
1339 {
1340 // printf ("mono_test_empty_struct %d %d\n", a, b);
1341
1342 // Intel icc on ia64 passes 'es' in 2 registers
1343 #if defined(__ia64) && defined(__INTEL_COMPILER)
1344 return 0;
1345 #else
1346 if (a == 1 && b == 2)
1347 return 0;
1348 return 1;
1349 #endif
1350 }
1351
1352 LIBTEST_API EmptyStruct STDCALL
1353 mono_test_return_empty_struct (int a)
1354 {
1355 EmptyStruct s;
1356
1357 memset (&s, 0, sizeof (s));
1358
1359 #if !(defined(__i386__) && defined(__clang__))
1360 /* https://bugzilla.xamarin.com/show_bug.cgi?id=58901 */
1361 g_assert (a == 42);
1362 #endif
1363
1364 return s;
1365 }
1366
1367 typedef struct {
1368 char a[100];
1369 } ByValStrStruct;
1370
1371 LIBTEST_API ByValStrStruct * STDCALL
1372 mono_test_byvalstr_gen (void)
1373 {
1374 ByValStrStruct *ret;
1375
1376 ret = (ByValStrStruct *)malloc (sizeof (ByValStrStruct));
1377 memset(ret, 'a', sizeof(ByValStrStruct)-1);
1378 ret->a[sizeof(ByValStrStruct)-1] = 0;
1379
1380 return ret;
1381 }
1382
1383 LIBTEST_API int STDCALL
1384 mono_test_byvalstr_check (ByValStrStruct* data, char* correctString)
1385 {
1386 int ret;
1387
1388 ret = strcmp(data->a, correctString);
1389 // printf ("T1: %s\n", data->a);
1390 // printf ("T2: %s\n", correctString);
1391
1392 /* we need g_free because the allocation was performed by mono_test_byvalstr_gen */
1393 g_free (data);
1394 return (ret != 0);
1395 }
1396
1397 typedef struct {
1398 guint16 a[4];
1399 int flag;
1400 } ByValStrStruct_Unicode;
1401
1402 LIBTEST_API int STDCALL
1403 mono_test_byvalstr_check_unicode (ByValStrStruct_Unicode *ref, int test)
1404 {
1405 if (ref->flag != 0x1234abcd){
1406 printf ("overwritten data");
1407 return 1;
1408 }
1409
1410 if (test == 1 || test == 3){
1411 if (ref->a [0] != '1' ||
1412 ref->a [1] != '2' ||
1413 ref->a [2] != '3')
1414 return 1;
1415 return 0;
1416 }
1417 if (test == 2){
1418 if (ref->a [0] != '1' ||
1419 ref->a [1] != '2')
1420 return 1;
1421 return 0;
1422 }
1423 return 10;
1424 }
1425
1426 LIBTEST_API int STDCALL
1427 NameManglingAnsi (char *data)
1428 {
1429 return data [0] + data [1] + data [2];
1430 }
1431
1432 LIBTEST_API int STDCALL
1433 NameManglingAnsiA (char *data)
1434 {
1435 g_assert_not_reached ();
1436 }
1437
1438 LIBTEST_API int STDCALL
1439 NameManglingAnsiW (char *data)
1440 {
1441 g_assert_not_reached ();
1442 }
1443
1444 LIBTEST_API int STDCALL
1445 NameManglingAnsi2A (char *data)
1446 {
1447 return data [0] + data [1] + data [2];
1448 }
1449
1450 LIBTEST_API int STDCALL
1451 NameManglingAnsi2W (char *data)
1452 {
1453 g_assert_not_reached ();
1454 }
1455
1456 LIBTEST_API int STDCALL
1457 NameManglingUnicode (char *data)
1458 {
1459 g_assert_not_reached ();
1460 }
1461
1462 LIBTEST_API int STDCALL
1463 NameManglingUnicodeW (gunichar2 *data)
1464 {
1465 return data [0] + data [1] + data [2];
1466 }
1467
1468 LIBTEST_API int STDCALL
1469 NameManglingUnicode2 (gunichar2 *data)
1470 {
1471 return data [0] + data [1] + data [2];
1472 }
1473
1474 LIBTEST_API int STDCALL
1475 NameManglingAutoW (char *data)
1476 {
1477 #ifdef WIN32
1478 return (data [0] + data [1] + data [2]) == 131 ? 0 : 1;
1479 #else
1480 g_assert_not_reached ();
1481 #endif
1482 }
1483
1484 LIBTEST_API int STDCALL
1485 NameManglingAuto (char *data)
1486 {
1487 #ifndef WIN32
1488 return (data [0] + data [1] + data [2]) == 198 ? 0 : 1;
1489 #else
1490 g_assert_not_reached ();
1491 #endif
1492 }
1493
1494 typedef int (STDCALL *intcharFunc)(const char*);
1495
1496 LIBTEST_API void STDCALL
1497 callFunction (intcharFunc f)
1498 {
1499 f ("ABC");
1500 }
1501
1502 typedef struct {
1503 const char* str;
1504 int i;
1505 } SimpleObj;
1506
1507 LIBTEST_API int STDCALL
1508 class_marshal_test0 (SimpleObj *obj1)
1509 {
1510 // printf ("class_marshal_test0 %s %d\n", obj1->str, obj1->i);
1511
1512 if (strcmp(obj1->str, "T1"))
1513 return -1;
1514 if (obj1->i != 4)
1515 return -2;
1516
1517 return 0;
1518 }
1519
1520 LIBTEST_API int STDCALL
1521 class_marshal_test4 (SimpleObj *obj1)
1522 {
1523 if (obj1)
1524 return -1;
1525
1526 return 0;
1527 }
1528
1529 LIBTEST_API void STDCALL
1530 class_marshal_test1 (SimpleObj **obj1)
1531 {
1532 SimpleObj *res = (SimpleObj *)malloc (sizeof (SimpleObj));
1533
1534 res->str = marshal_strdup ("ABC");
1535 res->i = 5;
1536
1537 *obj1 = res;
1538 }
1539
1540 LIBTEST_API int STDCALL
1541 class_marshal_test2 (SimpleObj **obj1)
1542 {
1543 // printf ("class_marshal_test2 %s %d\n", (*obj1)->str, (*obj1)->i);
1544
1545 if (strcmp((*obj1)->str, "ABC"))
1546 return -1;
1547 if ((*obj1)->i != 5)
1548 return -2;
1549
1550 return 0;
1551 }
1552
1553 LIBTEST_API int STDCALL
1554 string_marshal_test0 (char *str)
1555 {
1556 if (strcmp (str, "TEST0"))
1557 return -1;
1558
1559 return 0;
1560 }
1561
1562 LIBTEST_API void STDCALL
1563 string_marshal_test1 (const char **str)
1564 {
1565 *str = marshal_strdup ("TEST1");
1566 }
1567
1568 LIBTEST_API int STDCALL
1569 string_marshal_test2 (char **str)
1570 {
1571 // printf ("string_marshal_test2 %s\n", *str);
1572
1573 if (strcmp (*str, "TEST1"))
1574 return -1;
1575
1576 *str = marshal_strdup ("TEST2");
1577
1578 return 0;
1579 }
1580
1581 LIBTEST_API int STDCALL
1582 string_marshal_test3 (char *str)
1583 {
1584 if (str)
1585 return -1;
1586
1587 return 0;
1588 }
1589
1590 typedef struct {
1591 int a;
1592 int b;
1593 } BlittableClass;
1594
1595 LIBTEST_API BlittableClass* STDCALL
1596 TestBlittableClass (BlittableClass *vl)
1597 {
1598 BlittableClass *res;
1599
1600 // printf ("TestBlittableClass %d %d\n", vl->a, vl->b);
1601
1602 if (vl) {
1603 vl->a++;
1604 vl->b++;
1605
1606 res = marshal_new0 (BlittableClass, 1);
1607 memcpy (res, vl, sizeof (BlittableClass));
1608 } else {
1609 res = marshal_new0 (BlittableClass, 1);
1610 res->a = 42;
1611 res->b = 43;
1612 }
1613
1614 return res;
1615 }
1616
1617 typedef struct OSVERSIONINFO_STRUCT
1618 {
1619 int a;
1620 int b;
1621 } OSVERSIONINFO_STRUCT;
1622
1623 LIBTEST_API int STDCALL
1624 MyGetVersionEx (OSVERSIONINFO_STRUCT *osvi)
1625 {
1626
1627 // printf ("GOT %d %d\n", osvi->a, osvi->b);
1628
1629 osvi->a += 1;
1630 osvi->b += 1;
1631
1632 return osvi->a + osvi->b;
1633 }
1634
1635 LIBTEST_API int STDCALL
1636 BugGetVersionEx (int a, int b, int c, int d, int e, int f, int g, int h, OSVERSIONINFO_STRUCT *osvi)
1637 {
1638
1639 // printf ("GOT %d %d\n", osvi->a, osvi->b);
1640
1641 osvi->a += 1;
1642 osvi->b += 1;
1643
1644 return osvi->a + osvi->b;
1645 }
1646
1647 LIBTEST_API int STDCALL
1648 mono_test_marshal_point (point pt)
1649 {
1650 // printf("point %g %g\n", pt.x, pt.y);
1651 if (pt.x == 1.25 && pt.y == 3.5)
1652 return 0;
1653
1654 return 1;
1655 }
1656
1657 typedef struct {
1658 int x;
1659 double y;
1660 } mixed_point;
1661
1662 LIBTEST_API int STDCALL
1663 mono_test_marshal_mixed_point (mixed_point pt)
1664 {
1665 // printf("mixed point %d %g\n", pt.x, pt.y);
1666 if (pt.x == 5 && pt.y == 6.75)
1667 return 0;
1668
1669 return 1;
1670 }
1671
1672 LIBTEST_API int STDCALL
1673 mono_test_marshal_mixed_point_2 (mixed_point *pt)
1674 {
1675 if (pt->x != 5 || pt->y != 6.75)
1676 return 1;
1677
1678 pt->x = 10;
1679 pt->y = 12.35;
1680
1681 return 0;
1682 }
1683
1684 LIBTEST_API int STDCALL
1685 marshal_test_ref_bool(int i, char *b1, short *b2, int *b3)
1686 {
1687 int res = 1;
1688 if (*b1 != 0 && *b1 != 1)
1689 return 1;
1690 if (*b2 != 0 && *b2 != -1) /* variant_bool */
1691 return 1;
1692 if (*b3 != 0 && *b3 != 1)
1693 return 1;
1694 if (i == ((*b1 << 2) | (-*b2 << 1) | *b3))
1695 res = 0;
1696 *b1 = !*b1;
1697 *b2 = ~*b2;
1698 *b3 = !*b3;
1699 return res;
1700 }
1701
1702 struct BoolStruct
1703 {
1704 int i;
1705 char b1;
1706 short b2; /* variant_bool */
1707 int b3;
1708 };
1709
1710 LIBTEST_API int STDCALL
1711 marshal_test_bool_struct(struct BoolStruct *s)
1712 {
1713 int res = 1;
1714 if (s->b1 != 0 && s->b1 != 1)
1715 return 1;
1716 if (s->b2 != 0 && s->b2 != -1)
1717 return 1;
1718 if (s->b3 != 0 && s->b3 != 1)
1719 return 1;
1720 if (s->i == ((s->b1 << 2) | (-s->b2 << 1) | s->b3))
1721 res = 0;
1722 s->b1 = !s->b1;
1723 s->b2 = ~s->b2;
1724 s->b3 = !s->b3;
1725 return res;
1726 }
1727
1728 typedef struct {
1729 gint64 l;
1730 } LongStruct2;
1731
1732 typedef struct {
1733 int i;
1734 LongStruct2 l;
1735 } LongStruct;
1736
1737 LIBTEST_API int STDCALL
1738 mono_test_marshal_long_struct (LongStruct *s)
1739 {
1740 return s->i + s->l.l;
1741 }
1742
1743 LIBTEST_API void STDCALL
1744 mono_test_last_error (int err)
1745 {
1746 #ifdef WIN32
1747 SetLastError (err);
1748 #else
1749 errno = err;
1750 #endif
1751 }
1752
1753 LIBTEST_API int STDCALL
1754 mono_test_asany (void *ptr, int what)
1755 {
1756 switch (what) {
1757 case 1:
1758 return (*(int*)ptr == 5) ? 0 : 1;
1759 case 2:
1760 return strcmp (ptr, "ABC") == 0 ? 0 : 1;
1761 case 3: {
1762 simplestruct2 ss = *(simplestruct2*)ptr;
1763
1764 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
1765 !strcmp (ss.d, "TEST") &&
1766 ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
1767 return 0;
1768 else
1769 return 1;
1770 }
1771 case 4: {
1772 GError *gerror = NULL;
1773 char *s;
1774
1775 s = g_utf16_to_utf8 ((const gunichar2 *)ptr, -1, NULL, NULL, &gerror);
1776
1777 if (!s)
1778 return 1;
1779
1780 if (!strcmp (s, "ABC")) {
1781 g_free (s);
1782 return 0;
1783 }
1784 else {
1785 g_free (s);
1786 return 1;
1787 }
1788 }
1789 default:
1790 g_assert_not_reached ();
1791 }
1792
1793 return 1;
1794 }
1795
1796 typedef struct
1797 {
1798 int i;
1799 int j;
1800 int k;
1801 char *s;
1802 } AsAnyStruct;
1803
1804 LIBTEST_API int STDCALL
1805 mono_test_marshal_asany_in (void* ptr)
1806 {
1807 AsAnyStruct *asAny = (AsAnyStruct *)ptr;
1808 int res = asAny->i + asAny->j + asAny->k;
1809
1810 return res;
1811 }
1812
1813 LIBTEST_API int STDCALL
1814 mono_test_marshal_asany_inout (void* ptr)
1815 {
1816 AsAnyStruct *asAny = (AsAnyStruct *)ptr;
1817 int res = asAny->i + asAny->j + asAny->k;
1818
1819 marshal_free (asAny->s);
1820
1821 asAny->i = 10;
1822 asAny->j = 20;
1823 asAny->k = 30;
1824 asAny->s = 0;
1825
1826 return res;
1827 }
1828
1829 LIBTEST_API int STDCALL
1830 mono_test_marshal_asany_out (void* ptr)
1831 {
1832 AsAnyStruct *asAny = (AsAnyStruct *)ptr;
1833 int res = asAny->i + asAny->j + asAny->k;
1834
1835 asAny->i = 10;
1836 asAny->j = 20;
1837 asAny->k = 30;
1838 asAny->s = 0;
1839
1840 return res;
1841 }
1842
1843 /*
1844 * AMD64 marshalling tests.
1845 */
1846
1847 typedef struct amd64_struct1 {
1848 int i;
1849 int j;
1850 int k;
1851 int l;
1852 } amd64_struct1;
1853
1854 LIBTEST_API amd64_struct1 STDCALL
1855 mono_test_marshal_amd64_pass_return_struct1 (amd64_struct1 s)
1856 {
1857 s.i ++;
1858 s.j ++;
1859 s.k ++;
1860 s.l ++;
1861
1862 return s;
1863 }
1864
1865 LIBTEST_API amd64_struct1 STDCALL
1866 mono_test_marshal_amd64_pass_return_struct1_many_args (amd64_struct1 s, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8)
1867 {
1868 s.i ++;
1869 s.j ++;
1870 s.k ++;
1871 s.l += 1 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8;
1872
1873 return s;
1874 }
1875
1876 typedef struct amd64_struct2 {
1877 int i;
1878 int j;
1879 } amd64_struct2;
1880
1881 LIBTEST_API amd64_struct2 STDCALL
1882 mono_test_marshal_amd64_pass_return_struct2 (amd64_struct2 s)
1883 {
1884 s.i ++;
1885 s.j ++;
1886
1887 return s;
1888 }
1889
1890 typedef struct amd64_struct3 {
1891 int i;
1892 } amd64_struct3;
1893
1894 LIBTEST_API amd64_struct3 STDCALL
1895 mono_test_marshal_amd64_pass_return_struct3 (amd64_struct3 s)
1896 {
1897 s.i ++;
1898
1899 return s;
1900 }
1901
1902 typedef struct amd64_struct4 {
1903 double d1, d2;
1904 } amd64_struct4;
1905
1906 LIBTEST_API amd64_struct4 STDCALL
1907 mono_test_marshal_amd64_pass_return_struct4 (amd64_struct4 s)
1908 {
1909 s.d1 ++;
1910 s.d2 ++;
1911
1912 return s;
1913 }
1914
1915 /*
1916 * IA64 marshalling tests.
1917 */
1918 typedef struct test_struct5 {
1919 float d1, d2;
1920 } test_struct5;
1921
1922 LIBTEST_API test_struct5 STDCALL
1923 mono_test_marshal_ia64_pass_return_struct5 (double d1, double d2, test_struct5 s, int i, double d3, double d4)
1924 {
1925 s.d1 += d1 + d2 + i;
1926 s.d2 += d3 + d4 + i;
1927
1928 return s;
1929 }
1930
1931 typedef struct test_struct6 {
1932 double d1, d2;
1933 } test_struct6;
1934
1935 LIBTEST_API test_struct6 STDCALL
1936 mono_test_marshal_ia64_pass_return_struct6 (double d1, double d2, test_struct6 s, int i, double d3, double d4)
1937 {
1938 s.d1 += d1 + d2 + i;
1939 s.d2 += d3 + d4;
1940
1941 return s;
1942 }
1943
1944 static guint32 custom_res [2];
1945
1946 LIBTEST_API void* STDCALL
1947 mono_test_marshal_pass_return_custom (int i, guint32 *ptr, int j)
1948 {
1949 /* ptr will be freed by CleanupNative, so make a copy */
1950 custom_res [0] = 0; /* not allocated by AllocHGlobal */
1951 custom_res [1] = ptr [1];
1952
1953 return &custom_res;
1954 }
1955
1956 LIBTEST_API int STDCALL
1957 mono_test_marshal_pass_out_custom (int i, guint32 **ptr, int j)
1958 {
1959 custom_res [0] = 0;
1960 custom_res [1] = i + j + 10;
1961
1962 *ptr = custom_res;
1963
1964 return 0;
1965 }
1966
1967 LIBTEST_API int STDCALL
1968 mono_test_marshal_pass_inout_custom (int i, guint32 *ptr, int j)
1969 {
1970 ptr [0] = 0;
1971 ptr [1] = i + ptr [1] + j;
1972
1973 return 0;
1974 }
1975
1976 LIBTEST_API int STDCALL
1977 mono_test_marshal_pass_out_byval_custom (int i, guint32 *ptr, int j)
1978 {
1979 return ptr == NULL ? 0 : 1;
1980 }
1981
1982 LIBTEST_API int STDCALL
1983 mono_test_marshal_pass_byref_custom (int i, guint32 **ptr, int j)
1984 {
1985 (*ptr)[1] += i + j;
1986
1987 return 0;
1988 }
1989
1990 LIBTEST_API void* STDCALL
1991 mono_test_marshal_pass_return_custom2 (int i, guint32 *ptr, int j)
1992 {
1993 g_assert_not_reached ();
1994
1995 return NULL;
1996 }
1997
1998 LIBTEST_API void* STDCALL
1999 mono_test_marshal_pass_return_custom_null (int i, guint32 *ptr, int j)
2000 {
2001 g_assert (ptr == NULL);
2002
2003 return NULL;
2004 }
2005
2006 typedef void *(STDCALL *PassReturnPtrDelegate) (void *ptr);
2007
2008 LIBTEST_API int STDCALL
2009 mono_test_marshal_pass_return_custom_in_delegate (PassReturnPtrDelegate del)
2010 {
2011 guint32 buf [2];
2012 guint32 res;
2013 guint32 *ptr;
2014
2015 buf [0] = 0;
2016 buf [1] = 10;
2017
2018 ptr = (guint32 *)del (&buf);
2019
2020 res = ptr [1];
2021
2022 #ifdef WIN32
2023 /* FIXME: Freed with FreeHGlobal */
2024 #else
2025 g_free (ptr);
2026 #endif
2027
2028 return res;
2029 }
2030
2031 LIBTEST_API int STDCALL
2032 mono_test_marshal_pass_return_custom_null_in_delegate (PassReturnPtrDelegate del)
2033 {
2034 void *ptr = del (NULL);
2035
2036 return (ptr == NULL) ? 15 : 0;
2037 }
2038
2039 typedef void (STDCALL *CustomOutParamDelegate) (void **pptr);
2040
2041 LIBTEST_API int STDCALL
2042 mono_test_marshal_custom_out_param_delegate (CustomOutParamDelegate del)
2043 {
2044 void* pptr = del;
2045
2046 del (&pptr);
2047
2048 if(pptr != NULL)
2049 return 1;
2050
2051 return 0;
2052 }
2053
2054 typedef int (STDCALL *ReturnEnumDelegate) (int e);
2055
2056 LIBTEST_API int STDCALL
2057 mono_test_marshal_return_enum_delegate (ReturnEnumDelegate func)
2058 {
2059 return func (1);
2060 }
2061
2062 typedef struct {
2063 int a, b, c;
2064 gint64 d;
2065 } BlittableStruct;
2066
2067 typedef BlittableStruct (STDCALL *SimpleDelegate10) (BlittableStruct ss);
2068
2069 LIBTEST_API int STDCALL
2070 mono_test_marshal_blittable_struct_delegate (SimpleDelegate10 delegate)
2071 {
2072 BlittableStruct ss, res;
2073
2074 ss.a = 1;
2075 ss.b = 2;
2076 ss.c = 3;
2077 ss.d = 55;
2078
2079 res = delegate (ss);
2080 if (! ((res.a == -1) && (res.b == -2) && (res.c == -3) && (res.d == -55)))
2081 return 1;
2082
2083 return 0;
2084 }
2085
2086 LIBTEST_API int STDCALL
2087 mono_test_stdcall_name_mangling (int a, int b, int c)
2088 {
2089 return a + b + c;
2090 }
2091
2092 LIBTEST_API int
2093 mono_test_stdcall_mismatch_1 (int a, int b, int c)
2094 {
2095 return a + b + c;
2096 }
2097
2098 LIBTEST_API int STDCALL
2099 mono_test_stdcall_mismatch_2 (int a, int b, int c)
2100 {
2101 return a + b + c;
2102 }
2103
2104 /*
2105 * PASSING AND RETURNING SMALL STRUCTURES FROM DELEGATES TESTS
2106 */
2107
2108 typedef struct {
2109 int i;
2110 } SmallStruct1;
2111
2112 typedef SmallStruct1 (STDCALL *SmallStructDelegate1) (SmallStruct1 ss);
2113
2114 LIBTEST_API int STDCALL
2115 mono_test_marshal_small_struct_delegate1 (SmallStructDelegate1 delegate)
2116 {
2117 SmallStruct1 ss, res;
2118
2119 ss.i = 1;
2120
2121 res = delegate (ss);
2122 if (! (res.i == -1))
2123 return 1;
2124
2125 return 0;
2126 }
2127
2128 typedef struct {
2129 gint16 i, j;
2130 } SmallStruct2;
2131
2132 typedef SmallStruct2 (STDCALL *SmallStructDelegate2) (SmallStruct2 ss);
2133
2134 LIBTEST_API int STDCALL
2135 mono_test_marshal_small_struct_delegate2 (SmallStructDelegate2 delegate)
2136 {
2137 SmallStruct2 ss, res;
2138
2139 ss.i = 2;
2140 ss.j = 3;
2141
2142 res = delegate (ss);
2143 if (! ((res.i == -2) && (res.j == -3)))
2144 return 1;
2145
2146 return 0;
2147 }
2148
2149 typedef struct {
2150 gint16 i;
2151 gint8 j;
2152 } SmallStruct3;
2153
2154 typedef SmallStruct3 (STDCALL *SmallStructDelegate3) (SmallStruct3 ss);
2155
2156 LIBTEST_API int STDCALL
2157 mono_test_marshal_small_struct_delegate3 (SmallStructDelegate3 delegate)
2158 {
2159 SmallStruct3 ss, res;
2160
2161 ss.i = 1;
2162 ss.j = 2;
2163
2164 res = delegate (ss);
2165 if (! ((res.i == -1) && (res.j == -2)))
2166 return 1;
2167
2168 return 0;
2169 }
2170
2171 typedef struct {
2172 gint16 i;
2173 } SmallStruct4;
2174
2175 typedef SmallStruct4 (STDCALL *SmallStructDelegate4) (SmallStruct4 ss);
2176
2177 LIBTEST_API int STDCALL
2178 mono_test_marshal_small_struct_delegate4 (SmallStructDelegate4 delegate)
2179 {
2180 SmallStruct4 ss, res;
2181
2182 ss.i = 1;
2183
2184 res = delegate (ss);
2185 if (! (res.i == -1))
2186 return 1;
2187
2188 return 0;
2189 }
2190
2191 typedef struct {
2192 gint64 i;
2193 } SmallStruct5;
2194
2195 typedef SmallStruct5 (STDCALL *SmallStructDelegate5) (SmallStruct5 ss);
2196
2197 LIBTEST_API int STDCALL
2198 mono_test_marshal_small_struct_delegate5 (SmallStructDelegate5 delegate)
2199 {
2200 SmallStruct5 ss, res;
2201
2202 ss.i = 5;
2203
2204 res = delegate (ss);
2205 if (! (res.i == -5))
2206 return 1;
2207
2208 return 0;
2209 }
2210
2211 typedef struct {
2212 int i, j;
2213 } SmallStruct6;
2214
2215 typedef SmallStruct6 (STDCALL *SmallStructDelegate6) (SmallStruct6 ss);
2216
2217 LIBTEST_API int STDCALL
2218 mono_test_marshal_small_struct_delegate6 (SmallStructDelegate6 delegate)
2219 {
2220 SmallStruct6 ss, res;
2221
2222 ss.i = 1;
2223 ss.j = 2;
2224
2225 res = delegate (ss);
2226 if (! ((res.i == -1) && (res.j == -2)))
2227 return 1;
2228
2229 return 0;
2230 }
2231
2232 typedef struct {
2233 int i;
2234 gint16 j;
2235 } SmallStruct7;
2236
2237 typedef SmallStruct7 (STDCALL *SmallStructDelegate7) (SmallStruct7 ss);
2238
2239 LIBTEST_API int STDCALL
2240 mono_test_marshal_small_struct_delegate7 (SmallStructDelegate7 delegate)
2241 {
2242 SmallStruct7 ss, res;
2243
2244 ss.i = 1;
2245 ss.j = 2;
2246
2247 res = delegate (ss);
2248 if (! ((res.i == -1) && (res.j == -2)))
2249 return 1;
2250
2251 return 0;
2252 }
2253
2254 typedef struct {
2255 float i;
2256 } SmallStruct8;
2257
2258 typedef SmallStruct8 (STDCALL *SmallStructDelegate8) (SmallStruct8 ss);
2259
2260 LIBTEST_API int STDCALL
2261 mono_test_marshal_small_struct_delegate8 (SmallStructDelegate8 delegate)
2262 {
2263 SmallStruct8 ss, res;
2264
2265 ss.i = 1.0;
2266
2267 res = delegate (ss);
2268 if (! ((res.i == -1.0)))
2269 return 1;
2270
2271 return 0;
2272 }
2273
2274 typedef struct {
2275 double i;
2276 } SmallStruct9;
2277
2278 typedef SmallStruct9 (STDCALL *SmallStructDelegate9) (SmallStruct9 ss);
2279
2280 LIBTEST_API int STDCALL
2281 mono_test_marshal_small_struct_delegate9 (SmallStructDelegate9 delegate)
2282 {
2283 SmallStruct9 ss, res;
2284
2285 ss.i = 1.0;
2286
2287 res = delegate (ss);
2288 if (! ((res.i == -1.0)))
2289 return 1;
2290
2291 return 0;
2292 }
2293
2294 typedef struct {
2295 float i, j;
2296 } SmallStruct10;
2297
2298 typedef SmallStruct10 (STDCALL *SmallStructDelegate10) (SmallStruct10 ss);
2299
2300 LIBTEST_API int STDCALL
2301 mono_test_marshal_small_struct_delegate10 (SmallStructDelegate10 delegate)
2302 {
2303 SmallStruct10 ss, res;
2304
2305 ss.i = 1.0;
2306 ss.j = 2.0;
2307
2308 res = delegate (ss);
2309 if (! ((res.i == -1.0) && (res.j == -2.0)))
2310 return 1;
2311
2312 return 0;
2313 }
2314
2315 typedef struct {
2316 float i;
2317 int j;
2318 } SmallStruct11;
2319
2320 typedef SmallStruct11 (STDCALL *SmallStructDelegate11) (SmallStruct11 ss);
2321
2322 LIBTEST_API int STDCALL
2323 mono_test_marshal_small_struct_delegate11 (SmallStructDelegate11 delegate)
2324 {
2325 SmallStruct11 ss, res;
2326
2327 ss.i = 1.0;
2328 ss.j = 2;
2329
2330 res = delegate (ss);
2331 if (! ((res.i == -1.0) && (res.j == -2)))
2332 return 1;
2333
2334 return 0;
2335 }
2336
2337 typedef int (STDCALL *ArrayDelegate) (int i, char *j, void *arr);
2338
2339 LIBTEST_API int STDCALL
2340 mono_test_marshal_array_delegate (void *arr, int len, ArrayDelegate del)
2341 {
2342 return del (len, NULL, arr);
2343 }
2344
2345 typedef int (STDCALL *ArrayDelegateLong) (gint64 i, char *j, void *arr);
2346
2347 LIBTEST_API int STDCALL
2348 mono_test_marshal_array_delegate_long (void *arr, gint64 len, ArrayDelegateLong del)
2349 {
2350 return del (len, NULL, arr);
2351 }
2352
2353 LIBTEST_API int STDCALL
2354 mono_test_marshal_out_array_delegate (int *arr, int len, ArrayDelegate del)
2355 {
2356 del (len, NULL, arr);
2357
2358 if ((arr [0] != 1) || (arr [1] != 2))
2359 return 1;
2360 else
2361 return 0;
2362 }
2363
2364 typedef gunichar2* (STDCALL *UnicodeStringDelegate) (gunichar2 *message);
2365
2366 LIBTEST_API int STDCALL
2367 mono_test_marshal_return_unicode_string_delegate (UnicodeStringDelegate del)
2368 {
2369 const char m[] = "abcdef";
2370 gunichar2 *s2, *res;
2371 glong len;
2372
2373 s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
2374
2375 res = del (s2);
2376
2377 marshal_free (res);
2378
2379 return 0;
2380 }
2381
2382 LIBTEST_API int STDCALL
2383 mono_test_marshal_out_string_array_delegate (char **arr, int len, ArrayDelegate del)
2384 {
2385 del (len, NULL, arr);
2386
2387 if (!strcmp (arr [0], "ABC") && !strcmp (arr [1], "DEF"))
2388 return 0;
2389 else
2390 return 1;
2391 }
2392
2393 typedef int (*CdeclDelegate) (int i, int j);
2394
2395 LIBTEST_API int STDCALL
2396 mono_test_marshal_cdecl_delegate (CdeclDelegate del)
2397 {
2398 int i;
2399
2400 for (i = 0; i < 1000; ++i)
2401 del (1, 2);
2402
2403 return 0;
2404 }
2405
2406 typedef char** (STDCALL *ReturnStringArrayDelegate) (int i);
2407
2408 LIBTEST_API int STDCALL
2409 mono_test_marshal_return_string_array_delegate (ReturnStringArrayDelegate d)
2410 {
2411 char **arr = d (2);
2412 int res;
2413
2414 if (arr == NULL)
2415 return 3;
2416
2417 if (strcmp (arr [0], "ABC") || strcmp (arr [1], "DEF"))
2418 res = 1;
2419 else
2420 res = 0;
2421
2422 marshal_free (arr);
2423
2424 return res;
2425 }
2426
2427 typedef int (STDCALL *ByrefStringDelegate) (char **s);
2428
2429 LIBTEST_API int STDCALL
2430 mono_test_marshal_byref_string_delegate (ByrefStringDelegate d)
2431 {
2432 char *s = (char*)"ABC";
2433 int res;
2434
2435 res = d (&s);
2436 if (res != 0)
2437 return res;
2438
2439 if (!strcmp (s, "DEF"))
2440 res = 0;
2441 else
2442 res = 2;
2443
2444 marshal_free (s);
2445
2446 return res;
2447 }
2448
2449 LIBTEST_API int STDCALL
2450 add_delegate (int i, int j)
2451 {
2452 return i + j;
2453 }
2454
2455 LIBTEST_API gpointer STDCALL
2456 mono_test_marshal_return_fnptr (void)
2457 {
2458 return &add_delegate;
2459 }
2460
2461 LIBTEST_API int STDCALL
2462 mono_xr (int code)
2463 {
2464 printf ("codigo %x\n", code);
2465 return code + 1234;
2466 }
2467
2468 typedef struct {
2469 int handle;
2470 } HandleRef;
2471
2472 LIBTEST_API HandleRef STDCALL
2473 mono_xr_as_handle (int code)
2474 {
2475 HandleRef ref;
2476
2477 memset (&ref, 0, sizeof (ref));
2478
2479 return ref;
2480 }
2481
2482 typedef struct {
2483 int a;
2484 void *handle1;
2485 void *handle2;
2486 int b;
2487 } HandleStructs;
2488
2489 LIBTEST_API int STDCALL
2490 mono_safe_handle_struct_ref (HandleStructs *x)
2491 {
2492 printf ("Dingus Ref! \n");
2493 printf ("Values: %d %d %p %p\n", x->a, x->b, x->handle1, x->handle2);
2494 if (x->a != 1234)
2495 return 1;
2496 if (x->b != 8743)
2497 return 2;
2498
2499 if (x->handle1 != (void*) 0x7080feed)
2500 return 3;
2501
2502 if (x->handle2 != (void*) 0x1234abcd)
2503 return 4;
2504
2505 return 0xf00d;
2506 }
2507
2508 LIBTEST_API int STDCALL
2509 mono_safe_handle_struct (HandleStructs x)
2510 {
2511 printf ("Dingus Standard! \n");
2512 printf ("Values: %d %d %p %p\n", x.a, x.b, x.handle1, x.handle2);
2513 if (x.a != 1234)
2514 return 1;
2515 if (x.b != 8743)
2516 return 2;
2517
2518 if (x.handle1 != (void*) 0x7080feed)
2519 return 3;
2520
2521 if (x.handle2 != (void*) 0x1234abcd)
2522 return 4;
2523
2524 return 0xf00f;
2525 }
2526
2527 typedef struct {
2528 void *a;
2529 } TrivialHandle;
2530
2531 LIBTEST_API int STDCALL
2532 mono_safe_handle_struct_simple (TrivialHandle x)
2533 {
2534 printf ("The value is %p\n", x.a);
2535 return ((int)(gsize)x.a) * 2;
2536 }
2537
2538 LIBTEST_API int STDCALL
2539 mono_safe_handle_return (void)
2540 {
2541 return 0x1000f00d;
2542 }
2543
2544 LIBTEST_API void STDCALL
2545 mono_safe_handle_ref (void **handle)
2546 {
2547 if (*handle != 0){
2548 *handle = (void *) 0xbad;
2549 return;
2550 }
2551
2552 *handle = (void *) 0x800d;
2553 }
2554
2555 LIBTEST_API double STDCALL
2556 mono_test_marshal_date_time (double d, double *d2)
2557 {
2558 *d2 = d;
2559 return d;
2560 }
2561
2562 /*
2563 * COM INTEROP TESTS
2564 */
2565
2566 #ifndef WIN32
2567
2568 typedef struct {
2569 guint16 vt;
2570 guint16 wReserved1;
2571 guint16 wReserved2;
2572 guint16 wReserved3;
2573 union {
2574 gint64 llVal;
2575 gint32 lVal;
2576 guint8 bVal;
2577 gint16 iVal;
2578 float fltVal;
2579 double dblVal;
2580 gint16 boolVal;
2581 gunichar2* bstrVal;
2582 gint8 cVal;
2583 guint16 uiVal;
2584 guint32 ulVal;
2585 guint64 ullVal;
2586 gpointer byref;
2587 struct {
2588 gpointer pvRecord;
2589 gpointer pRecInfo;
2590 };
2591 };
2592 } VARIANT;
2593
2594 typedef enum {
2595 VARIANT_TRUE = -1,
2596 VARIANT_FALSE = 0
2597 } VariantBool;
2598
2599 typedef enum {
2600 VT_EMPTY = 0,
2601 VT_NULL = 1,
2602 VT_I2 = 2,
2603 VT_I4 = 3,
2604 VT_R4 = 4,
2605 VT_R8 = 5,
2606 VT_CY = 6,
2607 VT_DATE = 7,
2608 VT_BSTR = 8,
2609 VT_DISPATCH = 9,
2610 VT_ERROR = 10,
2611 VT_BOOL = 11,
2612 VT_VARIANT = 12,
2613 VT_UNKNOWN = 13,
2614 VT_DECIMAL = 14,
2615 VT_I1 = 16,
2616 VT_UI1 = 17,
2617 VT_UI2 = 18,
2618 VT_UI4 = 19,
2619 VT_I8 = 20,
2620 VT_UI8 = 21,
2621 VT_INT = 22,
2622 VT_UINT = 23,
2623 VT_VOID = 24,
2624 VT_HRESULT = 25,
2625 VT_PTR = 26,
2626 VT_SAFEARRAY = 27,
2627 VT_CARRAY = 28,
2628 VT_USERDEFINED = 29,
2629 VT_LPSTR = 30,
2630 VT_LPWSTR = 31,
2631 VT_RECORD = 36,
2632 VT_FILETIME = 64,
2633 VT_BLOB = 65,
2634 VT_STREAM = 66,
2635 VT_STORAGE = 67,
2636 VT_STREAMED_OBJECT = 68,
2637 VT_STORED_OBJECT = 69,
2638 VT_BLOB_OBJECT = 70,
2639 VT_CF = 71,
2640 VT_CLSID = 72,
2641 VT_VECTOR = 4096,
2642 VT_ARRAY = 8192,
2643 VT_BYREF = 16384
2644 } VarEnum;
2645
2646 void VariantInit(VARIANT* vt)
2647 {
2648 vt->vt = VT_EMPTY;
2649 }
2650
2651 typedef struct
2652 {
2653 guint32 a;
2654 guint16 b;
2655 guint16 c;
2656 guint8 d[8];
2657 } GUID;
2658
2659 #define S_OK 0
2660
2661 #endif
2662
2663 LIBTEST_API int STDCALL
2664 mono_test_marshal_bstr_in(gunichar2* bstr)
2665 {
2666 gint32 result = 0;
2667 gchar* bstr_utf8 = g_utf16_to_utf8 (bstr, -1, NULL, NULL, NULL);
2668 result = strcmp("mono_test_marshal_bstr_in", bstr_utf8);
2669 g_free(bstr_utf8);
2670 if (result == 0)
2671 return 0;
2672 return 1;
2673 }
2674
2675 LIBTEST_API int STDCALL
2676 mono_test_marshal_bstr_out(gunichar2** bstr)
2677 {
2678 *bstr = marshal_bstr_alloc ("mono_test_marshal_bstr_out");
2679 return 0;
2680 }
2681
2682 LIBTEST_API int STDCALL
2683 mono_test_marshal_bstr_in_null(gunichar2* bstr)
2684 {
2685 if (!bstr)
2686 return 0;
2687 return 1;
2688 }
2689
2690 LIBTEST_API int STDCALL
2691 mono_test_marshal_bstr_out_null(gunichar2** bstr)
2692 {
2693 *bstr = NULL;
2694 return 0;
2695 }
2696
2697 LIBTEST_API int STDCALL
2698 mono_test_marshal_variant_in_sbyte(VARIANT variant)
2699 {
2700 if (variant.vt == VT_I1 && variant.cVal == 100)
2701 return 0;
2702 return 1;
2703 }
2704
2705 LIBTEST_API int STDCALL
2706 mono_test_marshal_variant_in_byte(VARIANT variant)
2707 {
2708 if (variant.vt == VT_UI1 && variant.bVal == 100)
2709 return 0;
2710 return 1;
2711 }
2712
2713 LIBTEST_API int STDCALL
2714 mono_test_marshal_variant_in_short(VARIANT variant)
2715 {
2716 if (variant.vt == VT_I2 && variant.iVal == 314)
2717 return 0;
2718 return 1;
2719 }
2720
2721 LIBTEST_API int STDCALL
2722 mono_test_marshal_variant_in_ushort(VARIANT variant)
2723 {
2724 if (variant.vt == VT_UI2 && variant.uiVal == 314)
2725 return 0;
2726 return 1;
2727 }
2728
2729 LIBTEST_API int STDCALL
2730 mono_test_marshal_variant_in_int(VARIANT variant)
2731 {
2732 if (variant.vt == VT_I4 && variant.lVal == 314)
2733 return 0;
2734 return 1;
2735 }
2736
2737 LIBTEST_API int STDCALL
2738 mono_test_marshal_variant_in_uint(VARIANT variant)
2739 {
2740 if (variant.vt == VT_UI4 && variant.ulVal == 314)
2741 return 0;
2742 return 1;
2743 }
2744
2745 LIBTEST_API int STDCALL
2746 mono_test_marshal_variant_in_long(VARIANT variant)
2747 {
2748 if (variant.vt == VT_I8 && variant.llVal == 314)
2749 return 0;
2750 return 1;
2751 }
2752
2753 LIBTEST_API int STDCALL
2754 mono_test_marshal_variant_in_ulong(VARIANT variant)
2755 {
2756 if (variant.vt == VT_UI8 && variant.ullVal == 314)
2757 return 0;
2758 return 1;
2759 }
2760
2761 LIBTEST_API int STDCALL
2762 mono_test_marshal_variant_in_float(VARIANT variant)
2763 {
2764 if (variant.vt == VT_R4 && (variant.fltVal - 3.14)/3.14 < .001)
2765 return 0;
2766 return 1;
2767 }
2768
2769 LIBTEST_API int STDCALL
2770 mono_test_marshal_variant_in_double(VARIANT variant)
2771 {
2772 if (variant.vt == VT_R8 && (variant.dblVal - 3.14)/3.14 < .001)
2773 return 0;
2774 return 1;
2775 }
2776
2777 LIBTEST_API int STDCALL
2778 mono_test_marshal_variant_in_bstr(VARIANT variant)
2779 {
2780 gint32 result = 0;
2781 gchar* bstr_utf8 = g_utf16_to_utf8 (variant.bstrVal, -1, NULL, NULL, NULL);
2782 result = strcmp("PI", bstr_utf8);
2783 g_free(bstr_utf8);
2784
2785 if (variant.vt == VT_BSTR && !result)
2786 return 0;
2787 return 1;
2788 }
2789
2790 LIBTEST_API int STDCALL
2791 mono_test_marshal_variant_in_bool_true (VARIANT variant)
2792 {
2793 if (variant.vt == VT_BOOL && variant.boolVal == VARIANT_TRUE)
2794 return 0;
2795 return 1;
2796 }
2797
2798 LIBTEST_API int STDCALL
2799 mono_test_marshal_variant_in_bool_false (VARIANT variant)
2800 {
2801 if (variant.vt == VT_BOOL && variant.boolVal == VARIANT_FALSE)
2802 return 0;
2803 return 1;
2804 }
2805
2806 LIBTEST_API int STDCALL
2807 mono_test_marshal_variant_out_sbyte(VARIANT* variant)
2808 {
2809 variant->vt = VT_I1;
2810 variant->cVal = 100;
2811
2812 return 0;
2813 }
2814
2815 LIBTEST_API int STDCALL
2816 mono_test_marshal_variant_out_sbyte_byref(VARIANT* variant)
2817 {
2818 variant->vt = VT_I1|VT_BYREF;
2819 variant->byref = marshal_alloc(1);
2820 *((gint8*)variant->byref) = 100;
2821
2822 return 0;
2823 }
2824
2825 LIBTEST_API int STDCALL
2826 mono_test_marshal_variant_out_byte(VARIANT* variant)
2827 {
2828 variant->vt = VT_UI1;
2829 variant->bVal = 100;
2830
2831 return 0;
2832 }
2833
2834 LIBTEST_API int STDCALL
2835 mono_test_marshal_variant_out_byte_byref(VARIANT* variant)
2836 {
2837 variant->vt = VT_UI1|VT_BYREF;
2838 variant->byref = marshal_alloc(1);
2839 *((gint8*)variant->byref) = 100;
2840
2841 return 0;
2842 }
2843
2844 LIBTEST_API int STDCALL
2845 mono_test_marshal_variant_out_short(VARIANT* variant)
2846 {
2847 variant->vt = VT_I2;
2848 variant->iVal = 314;
2849
2850 return 0;
2851 }
2852
2853 LIBTEST_API int STDCALL
2854 mono_test_marshal_variant_out_short_byref(VARIANT* variant)
2855 {
2856 variant->vt = VT_I2|VT_BYREF;
2857 variant->byref = marshal_alloc(2);
2858 *((gint16*)variant->byref) = 314;
2859
2860 return 0;
2861 }
2862
2863 LIBTEST_API int STDCALL
2864 mono_test_marshal_variant_out_ushort(VARIANT* variant)
2865 {
2866 variant->vt = VT_UI2;
2867 variant->uiVal = 314;
2868
2869 return 0;
2870 }
2871
2872 LIBTEST_API int STDCALL
2873 mono_test_marshal_variant_out_ushort_byref(VARIANT* variant)
2874 {
2875 variant->vt = VT_UI2|VT_BYREF;
2876 variant->byref = marshal_alloc(2);
2877 *((guint16*)variant->byref) = 314;
2878
2879 return 0;
2880 }
2881
2882 LIBTEST_API int STDCALL
2883 mono_test_marshal_variant_out_int(VARIANT* variant)
2884 {
2885 variant->vt = VT_I4;
2886 variant->lVal = 314;
2887
2888 return 0;
2889 }
2890
2891 LIBTEST_API int STDCALL
2892 mono_test_marshal_variant_out_int_byref(VARIANT* variant)
2893 {
2894 variant->vt = VT_I4|VT_BYREF;
2895 variant->byref = marshal_alloc(4);
2896 *((gint32*)variant->byref) = 314;
2897
2898 return 0;
2899 }
2900
2901 LIBTEST_API int STDCALL
2902 mono_test_marshal_variant_out_uint(VARIANT* variant)
2903 {
2904 variant->vt = VT_UI4;
2905 variant->ulVal = 314;
2906
2907 return 0;
2908 }
2909
2910 LIBTEST_API int STDCALL
2911 mono_test_marshal_variant_out_uint_byref(VARIANT* variant)
2912 {
2913 variant->vt = VT_UI4|VT_BYREF;
2914 variant->byref = marshal_alloc(4);
2915 *((guint32*)variant->byref) = 314;
2916
2917 return 0;
2918 }
2919
2920 LIBTEST_API int STDCALL
2921 mono_test_marshal_variant_out_long(VARIANT* variant)
2922 {
2923 variant->vt = VT_I8;
2924 variant->llVal = 314;
2925
2926 return 0;
2927 }
2928
2929 LIBTEST_API int STDCALL
2930 mono_test_marshal_variant_out_long_byref(VARIANT* variant)
2931 {
2932 variant->vt = VT_I8|VT_BYREF;
2933 variant->byref = marshal_alloc(8);
2934 *((gint64*)variant->byref) = 314;
2935
2936 return 0;
2937 }
2938
2939 LIBTEST_API int STDCALL
2940 mono_test_marshal_variant_out_ulong(VARIANT* variant)
2941 {
2942 variant->vt = VT_UI8;
2943 variant->ullVal = 314;
2944
2945 return 0;
2946 }
2947
2948 LIBTEST_API int STDCALL
2949 mono_test_marshal_variant_out_ulong_byref(VARIANT* variant)
2950 {
2951 variant->vt = VT_UI8|VT_BYREF;
2952 variant->byref = marshal_alloc(8);
2953 *((guint64*)variant->byref) = 314;
2954
2955 return 0;
2956 }
2957
2958 LIBTEST_API int STDCALL
2959 mono_test_marshal_variant_out_float(VARIANT* variant)
2960 {
2961 variant->vt = VT_R4;
2962 variant->fltVal = 3.14;
2963
2964 return 0;
2965 }
2966
2967 LIBTEST_API int STDCALL
2968 mono_test_marshal_variant_out_float_byref(VARIANT* variant)
2969 {
2970 variant->vt = VT_R4|VT_BYREF;
2971 variant->byref = marshal_alloc(4);
2972 *((float*)variant->byref) = 3.14;
2973
2974 return 0;
2975 }
2976
2977 LIBTEST_API int STDCALL
2978 mono_test_marshal_variant_out_double(VARIANT* variant)
2979 {
2980 variant->vt = VT_R8;
2981 variant->dblVal = 3.14;
2982
2983 return 0;
2984 }
2985
2986 LIBTEST_API int STDCALL
2987 mono_test_marshal_variant_out_double_byref(VARIANT* variant)
2988 {
2989 variant->vt = VT_R8|VT_BYREF;
2990 variant->byref = marshal_alloc(8);
2991 *((double*)variant->byref) = 3.14;
2992
2993 return 0;
2994 }
2995
2996 LIBTEST_API int STDCALL
2997 mono_test_marshal_variant_out_bstr(VARIANT* variant)
2998 {
2999 variant->vt = VT_BSTR;
3000 variant->bstrVal = marshal_bstr_alloc("PI");
3001
3002 return 0;
3003 }
3004
3005 LIBTEST_API int STDCALL
3006 mono_test_marshal_variant_out_bstr_byref(VARIANT* variant)
3007 {
3008 variant->vt = VT_BSTR|VT_BYREF;
3009 variant->byref = marshal_alloc(sizeof(gpointer));
3010 *((gunichar**)variant->byref) = (gunichar*)marshal_bstr_alloc("PI");
3011
3012 return 0;
3013 }
3014
3015 LIBTEST_API int STDCALL
3016 mono_test_marshal_variant_out_bool_true (VARIANT* variant)
3017 {
3018 variant->vt = VT_BOOL;
3019 variant->boolVal = VARIANT_TRUE;
3020
3021 return 0;
3022 }
3023
3024 LIBTEST_API int STDCALL
3025 mono_test_marshal_variant_out_bool_true_byref (VARIANT* variant)
3026 {
3027 variant->vt = VT_BOOL|VT_BYREF;
3028 variant->byref = marshal_alloc(2);
3029 *((gint16*)variant->byref) = VARIANT_TRUE;
3030
3031 return 0;
3032 }
3033
3034 LIBTEST_API int STDCALL
3035 mono_test_marshal_variant_out_bool_false (VARIANT* variant)
3036 {
3037 variant->vt = VT_BOOL;
3038 variant->boolVal = VARIANT_FALSE;
3039
3040 return 0;
3041 }
3042
3043 LIBTEST_API int STDCALL
3044 mono_test_marshal_variant_out_bool_false_byref (VARIANT* variant)
3045 {
3046 variant->vt = VT_BOOL|VT_BYREF;
3047 variant->byref = marshal_alloc(2);
3048 *((gint16*)variant->byref) = VARIANT_FALSE;
3049
3050 return 0;
3051 }
3052
3053 typedef int (STDCALL *VarFunc) (int vt, VARIANT variant);
3054 typedef int (STDCALL *VarRefFunc) (int vt, VARIANT* variant);
3055
3056 LIBTEST_API int STDCALL
3057 mono_test_marshal_variant_in_sbyte_unmanaged(VarFunc func)
3058 {
3059 VARIANT vt;
3060 vt.vt = VT_I1;
3061 vt.cVal = -100;
3062 return func (VT_I1, vt);
3063 }
3064
3065 LIBTEST_API int STDCALL
3066 mono_test_marshal_variant_in_byte_unmanaged(VarFunc func)
3067 {
3068 VARIANT vt;
3069 vt.vt = VT_UI1;
3070 vt.bVal = 100;
3071 return func (VT_UI1, vt);
3072 }
3073
3074 LIBTEST_API int STDCALL
3075 mono_test_marshal_variant_in_short_unmanaged(VarFunc func)
3076 {
3077 VARIANT vt;
3078 vt.vt = VT_I2;
3079 vt.iVal = -100;
3080 return func (VT_I2, vt);
3081 }
3082
3083 LIBTEST_API int STDCALL
3084 mono_test_marshal_variant_in_ushort_unmanaged(VarFunc func)
3085 {
3086 VARIANT vt;
3087 vt.vt = VT_UI2;
3088 vt.uiVal = 100;
3089 return func (VT_UI2, vt);
3090 }
3091
3092 LIBTEST_API int STDCALL
3093 mono_test_marshal_variant_in_int_unmanaged(VarFunc func)
3094 {
3095 VARIANT vt;
3096 vt.vt = VT_I4;
3097 vt.lVal = -100;
3098 return func (VT_I4, vt);
3099 }
3100
3101 LIBTEST_API int STDCALL
3102 mono_test_marshal_variant_in_uint_unmanaged(VarFunc func)
3103 {
3104 VARIANT vt;
3105 vt.vt = VT_UI4;
3106 vt.ulVal = 100;
3107 return func (VT_UI4, vt);
3108 }
3109
3110 LIBTEST_API int STDCALL
3111 mono_test_marshal_variant_in_long_unmanaged(VarFunc func)
3112 {
3113 VARIANT vt;
3114 vt.vt = VT_I8;
3115 vt.llVal = -100;
3116 return func (VT_I8, vt);
3117 }
3118
3119 LIBTEST_API int STDCALL
3120 mono_test_marshal_variant_in_ulong_unmanaged(VarFunc func)
3121 {
3122 VARIANT vt;
3123 vt.vt = VT_UI8;
3124 vt.ullVal = 100;
3125 return func (VT_UI8, vt);
3126 }
3127
3128 LIBTEST_API int STDCALL
3129 mono_test_marshal_variant_in_float_unmanaged(VarFunc func)
3130 {
3131 VARIANT vt;
3132 vt.vt = VT_R4;
3133 vt.fltVal = 3.14;
3134 return func (VT_R4, vt);
3135 }
3136
3137 LIBTEST_API int STDCALL
3138 mono_test_marshal_variant_in_double_unmanaged(VarFunc func)
3139 {
3140 VARIANT vt;
3141 vt.vt = VT_R8;
3142 vt.dblVal = 3.14;
3143 return func (VT_R8, vt);
3144 }
3145
3146 LIBTEST_API int STDCALL
3147 mono_test_marshal_variant_in_bstr_unmanaged(VarFunc func)
3148 {
3149 VARIANT vt;
3150 vt.vt = VT_BSTR;
3151 vt.bstrVal = marshal_bstr_alloc("PI");
3152 return func (VT_BSTR, vt);
3153 }
3154
3155 LIBTEST_API int STDCALL
3156 mono_test_marshal_variant_in_bool_true_unmanaged(VarFunc func)
3157 {
3158 VARIANT vt;
3159 vt.vt = VT_BOOL;
3160 vt.boolVal = VARIANT_TRUE;
3161 return func (VT_BOOL, vt);
3162 }
3163
3164 LIBTEST_API int STDCALL
3165 mono_test_marshal_variant_in_bool_false_unmanaged(VarFunc func)
3166 {
3167 VARIANT vt;
3168 vt.vt = VT_BOOL;
3169 vt.boolVal = VARIANT_FALSE;
3170 return func (VT_BOOL, vt);
3171 }
3172
3173 LIBTEST_API int STDCALL
3174 mono_test_marshal_variant_out_sbyte_unmanaged(VarRefFunc func)
3175 {
3176 VARIANT vt;
3177 VariantInit (&vt);
3178 func (VT_I1, &vt);
3179 if (vt.vt == VT_I1 && vt.cVal == -100)
3180 return 0;
3181 return 1;
3182 }
3183
3184 LIBTEST_API int STDCALL
3185 mono_test_marshal_variant_out_byte_unmanaged(VarRefFunc func)
3186 {
3187 VARIANT vt;
3188 VariantInit (&vt);
3189 func (VT_UI1, &vt);
3190 if (vt.vt == VT_UI1 && vt.bVal == 100)
3191 return 0;
3192 return 1;
3193 }
3194
3195 LIBTEST_API int STDCALL
3196 mono_test_marshal_variant_out_short_unmanaged(VarRefFunc func)
3197 {
3198 VARIANT vt;
3199 VariantInit (&vt);
3200 func (VT_I2, &vt);
3201 if (vt.vt == VT_I2 && vt.iVal == -100)
3202 return 0;
3203 return 1;
3204 }
3205
3206 LIBTEST_API int STDCALL
3207 mono_test_marshal_variant_out_ushort_unmanaged(VarRefFunc func)
3208 {
3209 VARIANT vt;
3210 VariantInit (&vt);
3211 func (VT_UI2, &vt);
3212 if (vt.vt == VT_UI2 && vt.uiVal == 100)
3213 return 0;
3214 return 1;
3215 }
3216
3217 LIBTEST_API int STDCALL
3218 mono_test_marshal_variant_out_int_unmanaged(VarRefFunc func)
3219 {
3220 VARIANT vt;
3221 VariantInit (&vt);
3222 func (VT_I4, &vt);
3223 if (vt.vt == VT_I4 && vt.lVal == -100)
3224 return 0;
3225 return 1;
3226 }
3227
3228 LIBTEST_API int STDCALL
3229 mono_test_marshal_variant_out_uint_unmanaged(VarRefFunc func)
3230 {
3231 VARIANT vt;
3232 VariantInit (&vt);
3233 func (VT_UI4, &vt);
3234 if (vt.vt == VT_UI4 && vt.ulVal == 100)
3235 return 0;
3236 return 1;
3237 }
3238
3239 LIBTEST_API int STDCALL
3240 mono_test_marshal_variant_out_long_unmanaged(VarRefFunc func)
3241 {
3242 VARIANT vt;
3243 VariantInit (&vt);
3244 func (VT_I8, &vt);
3245 if (vt.vt == VT_I8 && vt.llVal == -100)
3246 return 0;
3247 return 1;
3248 }
3249
3250 LIBTEST_API int STDCALL
3251 mono_test_marshal_variant_out_ulong_unmanaged(VarRefFunc func)
3252 {
3253 VARIANT vt;
3254 VariantInit (&vt);
3255 func (VT_UI8, &vt);
3256 if (vt.vt == VT_UI8 && vt.ullVal == 100)
3257 return 0;
3258 return 1;
3259 }
3260
3261 LIBTEST_API int STDCALL
3262 mono_test_marshal_variant_out_float_unmanaged(VarRefFunc func)
3263 {
3264 VARIANT vt;
3265 VariantInit (&vt);
3266 func (VT_R4, &vt);
3267 if (vt.vt == VT_R4 && fabs (vt.fltVal - 3.14f) < 1e-10)
3268 return 0;
3269 return 1;
3270 }
3271
3272 LIBTEST_API int STDCALL
3273 mono_test_marshal_variant_out_double_unmanaged(VarRefFunc func)
3274 {
3275 VARIANT vt;
3276 VariantInit (&vt);
3277 func (VT_R8, &vt);
3278 if (vt.vt == VT_R8 && fabs (vt.dblVal - 3.14) < 1e-10)
3279 return 0;
3280 return 1;
3281 }
3282
3283 LIBTEST_API int STDCALL
3284 mono_test_marshal_variant_out_bstr_unmanaged(VarRefFunc func)
3285 {
3286 VARIANT vt;
3287 gchar* bstr_utf8;
3288 gint32 result = 0;
3289
3290
3291 VariantInit (&vt);
3292 func (VT_BSTR, &vt);
3293 bstr_utf8 = g_utf16_to_utf8 (vt.bstrVal, -1, NULL, NULL, NULL);
3294 result = strcmp("PI", bstr_utf8);
3295 g_free(bstr_utf8);
3296 if (vt.vt == VT_BSTR && !result)
3297 return 0;
3298 return 1;
3299 }
3300
3301 LIBTEST_API int STDCALL
3302 mono_test_marshal_variant_out_bool_true_unmanaged(VarRefFunc func)
3303 {
3304 VARIANT vt;
3305 VariantInit (&vt);
3306 func (VT_BOOL, &vt);
3307 if (vt.vt == VT_BOOL && vt.boolVal == VARIANT_TRUE)
3308 return 0;
3309 return 1;
3310 }
3311
3312 LIBTEST_API int STDCALL
3313 mono_test_marshal_variant_out_bool_false_unmanaged(VarRefFunc func)
3314 {
3315 VARIANT vt;
3316 VariantInit (&vt);
3317 func (VT_BOOL, &vt);
3318 if (vt.vt == VT_BOOL && vt.boolVal == VARIANT_TRUE)
3319 return 0;
3320 return 1;
3321 }
3322
3323 typedef struct MonoComObject MonoComObject;
3324
3325 typedef struct
3326 {
3327 int (STDCALL *QueryInterface)(MonoComObject* pUnk, gpointer riid, gpointer* ppv);
3328 int (STDCALL *AddRef)(MonoComObject* pUnk);
3329 int (STDCALL *Release)(MonoComObject* pUnk);
3330 int (STDCALL *get_ITest)(MonoComObject* pUnk, MonoComObject* *ppUnk);
3331 int (STDCALL *SByteIn)(MonoComObject* pUnk, char a);
3332 int (STDCALL *ByteIn)(MonoComObject* pUnk, unsigned char a);
3333 int (STDCALL *ShortIn)(MonoComObject* pUnk, short a);
3334 int (STDCALL *UShortIn)(MonoComObject* pUnk, unsigned short a);
3335 int (STDCALL *IntIn)(MonoComObject* pUnk, int a);
3336 int (STDCALL *UIntIn)(MonoComObject* pUnk, unsigned int a);
3337 int (STDCALL *LongIn)(MonoComObject* pUnk, gint64 a);
3338 int (STDCALL *ULongIn)(MonoComObject* pUnk, guint64 a);
3339 int (STDCALL *FloatIn)(MonoComObject* pUnk, float a);
3340 int (STDCALL *DoubleIn)(MonoComObject* pUnk, double a);
3341 int (STDCALL *ITestIn)(MonoComObject* pUnk, MonoComObject* pUnk2);
3342 int (STDCALL *ITestOut)(MonoComObject* pUnk, MonoComObject* *ppUnk);
3343 int (STDCALL *Return22NoICall)(MonoComObject* pUnk);
3344 } MonoIUnknown;
3345
3346 struct MonoComObject
3347 {
3348 MonoIUnknown* vtbl;
3349 int m_ref;
3350 };
3351
3352 static GUID IID_ITest = {0, 0, 0, {0,0,0,0,0,0,0,1}};
3353 static GUID IID_IMonoUnknown = {0, 0, 0, {0xc0,0,0,0,0,0,0,0x46}};
3354 static GUID IID_IMonoDispatch = {0x00020400, 0, 0, {0xc0,0,0,0,0,0,0,0x46}};
3355
3356 LIBTEST_API int STDCALL
3357 MonoQueryInterface(MonoComObject* pUnk, gpointer riid, gpointer* ppv)
3358 {
3359
3360 *ppv = NULL;
3361 if (!memcmp(riid, &IID_IMonoUnknown, sizeof(GUID))) {
3362 *ppv = pUnk;
3363 return S_OK;
3364 }
3365 else if (!memcmp(riid, &IID_ITest, sizeof(GUID))) {
3366 *ppv = pUnk;
3367 return S_OK;
3368 }
3369 else if (!memcmp(riid, &IID_IMonoDispatch, sizeof(GUID))) {
3370 *ppv = pUnk;
3371 return S_OK;
3372 }
3373 return 0x80004002; //E_NOINTERFACE;
3374 }
3375
3376 LIBTEST_API int STDCALL
3377 MonoAddRef(MonoComObject* pUnk)
3378 {
3379 return ++(pUnk->m_ref);
3380 }
3381
3382 LIBTEST_API int STDCALL
3383 MonoRelease(MonoComObject* pUnk)
3384 {
3385 return --(pUnk->m_ref);
3386 }
3387
3388 LIBTEST_API int STDCALL
3389 SByteIn(MonoComObject* pUnk, char a)
3390 {
3391 return S_OK;
3392 }
3393
3394 LIBTEST_API int STDCALL
3395 ByteIn(MonoComObject* pUnk, unsigned char a)
3396 {
3397 return S_OK;
3398 }
3399
3400 LIBTEST_API int STDCALL
3401 ShortIn(MonoComObject* pUnk, short a)
3402 {
3403 return S_OK;
3404 }
3405
3406 LIBTEST_API int STDCALL
3407 UShortIn(MonoComObject* pUnk, unsigned short a)
3408 {
3409 return S_OK;
3410 }
3411
3412 LIBTEST_API int STDCALL
3413 IntIn(MonoComObject* pUnk, int a)
3414 {
3415 return S_OK;
3416 }
3417
3418 LIBTEST_API int STDCALL
3419 UIntIn(MonoComObject* pUnk, unsigned int a)
3420 {
3421 return S_OK;
3422 }
3423
3424 LIBTEST_API int STDCALL
3425 LongIn(MonoComObject* pUnk, gint64 a)
3426 {
3427 return S_OK;
3428 }
3429
3430 LIBTEST_API int STDCALL
3431 ULongIn(MonoComObject* pUnk, guint64 a)
3432 {
3433 return S_OK;
3434 }
3435
3436 LIBTEST_API int STDCALL
3437 FloatIn(MonoComObject* pUnk, float a)
3438 {
3439 return S_OK;
3440 }
3441
3442 LIBTEST_API int STDCALL
3443 DoubleIn(MonoComObject* pUnk, double a)
3444 {
3445 return S_OK;
3446 }
3447
3448 LIBTEST_API int STDCALL
3449 ITestIn(MonoComObject* pUnk, MonoComObject *pUnk2)
3450 {
3451 return S_OK;
3452 }
3453
3454 LIBTEST_API int STDCALL
3455 ITestOut(MonoComObject* pUnk, MonoComObject* *ppUnk)
3456 {
3457 return S_OK;
3458 }
3459
3460 LIBTEST_API int STDCALL
3461 Return22NoICall(MonoComObject* pUnk)
3462 {
3463 return 22;
3464 }
3465
3466
3467 static void create_com_object (MonoComObject** pOut);
3468
3469 LIBTEST_API int STDCALL
3470 get_ITest(MonoComObject* pUnk, MonoComObject* *ppUnk)
3471 {
3472 create_com_object (ppUnk);
3473 return S_OK;
3474 }
3475
3476 static void create_com_object (MonoComObject** pOut)
3477 {
3478 *pOut = marshal_new0 (MonoComObject, 1);
3479 (*pOut)->vtbl = marshal_new0 (MonoIUnknown, 1);
3480
3481 (*pOut)->m_ref = 1;
3482 (*pOut)->vtbl->QueryInterface = MonoQueryInterface;
3483 (*pOut)->vtbl->AddRef = MonoAddRef;
3484 (*pOut)->vtbl->Release = MonoRelease;
3485 (*pOut)->vtbl->SByteIn = SByteIn;
3486 (*pOut)->vtbl->ByteIn = ByteIn;
3487 (*pOut)->vtbl->ShortIn = ShortIn;
3488 (*pOut)->vtbl->UShortIn = UShortIn;
3489 (*pOut)->vtbl->IntIn = IntIn;
3490 (*pOut)->vtbl->UIntIn = UIntIn;
3491 (*pOut)->vtbl->LongIn = LongIn;
3492 (*pOut)->vtbl->ULongIn = ULongIn;
3493 (*pOut)->vtbl->FloatIn = FloatIn;
3494 (*pOut)->vtbl->DoubleIn = DoubleIn;
3495 (*pOut)->vtbl->ITestIn = ITestIn;
3496 (*pOut)->vtbl->ITestOut = ITestOut;
3497 (*pOut)->vtbl->get_ITest = get_ITest;
3498 (*pOut)->vtbl->Return22NoICall = Return22NoICall;
3499 }
3500
3501 static MonoComObject* same_object = NULL;
3502
3503 LIBTEST_API int STDCALL
3504 mono_test_marshal_com_object_create(MonoComObject* *pUnk)
3505 {
3506 create_com_object (pUnk);
3507
3508 if (!same_object)
3509 same_object = *pUnk;
3510
3511 return 0;
3512 }
3513
3514 LIBTEST_API int STDCALL
3515 mono_test_marshal_com_object_same(MonoComObject* *pUnk)
3516 {
3517 *pUnk = same_object;
3518
3519 return 0;
3520 }
3521
3522 LIBTEST_API int STDCALL
3523 mono_test_marshal_com_object_destroy(MonoComObject *pUnk)
3524 {
3525 int ref = --(pUnk->m_ref);
3526 g_free(pUnk->vtbl);
3527 g_free(pUnk);
3528
3529 return ref;
3530 }
3531
3532 LIBTEST_API int STDCALL
3533 mono_test_marshal_com_object_ref_count(MonoComObject *pUnk)
3534 {
3535 return pUnk->m_ref;
3536 }
3537
3538 LIBTEST_API int STDCALL
3539 mono_test_marshal_ccw_itest (MonoComObject *pUnk)
3540 {
3541 int hr = 0;
3542 MonoComObject* pTest;
3543
3544 if (!pUnk)
3545 return 1;
3546
3547 hr = pUnk->vtbl->SByteIn (pUnk, -100);
3548 if (hr != 0)
3549 return 2;
3550 hr = pUnk->vtbl->ByteIn (pUnk, 100);
3551 if (hr != 0)
3552 return 3;
3553 hr = pUnk->vtbl->ShortIn (pUnk, -100);
3554 if (hr != 0)
3555 return 4;
3556 hr = pUnk->vtbl->UShortIn (pUnk, 100);
3557 if (hr != 0)
3558 return 5;
3559 hr = pUnk->vtbl->IntIn (pUnk, -100);
3560 if (hr != 0)
3561 return 6;
3562 hr = pUnk->vtbl->UIntIn (pUnk, 100);
3563 if (hr != 0)
3564 return 7;
3565 hr = pUnk->vtbl->LongIn (pUnk, -100);
3566 if (hr != 0)
3567 return 8;
3568 hr = pUnk->vtbl->ULongIn (pUnk, 100);
3569 if (hr != 0)
3570 return 9;
3571 hr = pUnk->vtbl->FloatIn (pUnk, 3.14f);
3572 if (hr != 0)
3573 return 10;
3574 hr = pUnk->vtbl->DoubleIn (pUnk, 3.14);
3575 if (hr != 0)
3576 return 11;
3577 hr = pUnk->vtbl->ITestIn (pUnk, pUnk);
3578 if (hr != 0)
3579 return 12;
3580 hr = pUnk->vtbl->ITestOut (pUnk, &pTest);
3581 if (hr != 0)
3582 return 13;
3583
3584 return 0;
3585 }
3586
3587 // Xamarin-47560
3588 LIBTEST_API int STDCALL
3589 mono_test_marshal_array_ccw_itest (int count, MonoComObject ** ppUnk)
3590 {
3591 int hr = 0;
3592
3593 if (!ppUnk)
3594 return 1;
3595
3596 if (count < 1)
3597 return 2;
3598
3599 if (!ppUnk[0])
3600 return 3;
3601
3602 hr = ppUnk[0]->vtbl->SByteIn (ppUnk[0], -100);
3603 if (hr != 0)
3604 return 4;
3605
3606 return 0;
3607 }
3608
3609 /*
3610 * mono_method_get_unmanaged_thunk tests
3611 */
3612
3613 #if defined(__GNUC__) && ((defined(__i386__) && (defined(__linux__) || defined (__APPLE__)) || defined (__FreeBSD__) || defined(__OpenBSD__)) || (defined(__ppc__) && defined(__APPLE__)))
3614 #define ALIGN(size) __attribute__ ((__aligned__(size)))
3615 #else
3616 #define ALIGN(size)
3617 #endif
3618
3619
3620 /* thunks.cs:TestStruct */
3621 typedef struct _TestStruct {
3622 int A;
3623 double B;
3624 } TestStruct;
3625
3626 /* Searches for mono symbols in all loaded modules */
3627 static gpointer
3628 lookup_mono_symbol (const char *symbol_name)
3629 {
3630 gpointer symbol;
3631 if (g_module_symbol (g_module_open (NULL, G_MODULE_BIND_LAZY), symbol_name, &symbol))
3632 return symbol;
3633 else
3634 return NULL;
3635 }
3636
3637 LIBTEST_API gpointer STDCALL
3638 mono_test_marshal_lookup_symbol (const char *symbol_name)
3639 {
3640 return lookup_mono_symbol (symbol_name);
3641 }
3642
3643 #define MONO_BEGIN_EFRAME { void *__dummy; void *__region_cookie = mono_threads_enter_gc_unsafe_region ? mono_threads_enter_gc_unsafe_region (&__dummy) : NULL;
3644 #define MONO_END_EFRAME if (mono_threads_exit_gc_unsafe_region) mono_threads_exit_gc_unsafe_region (__region_cookie, &__dummy); }
3645
3646 /**
3647 * test_method_thunk:
3648 *
3649 * @test_id: the test number
3650 * @test_method_handle: MonoMethod* of the C# test method
3651 * @create_object_method_handle: MonoMethod* of thunks.cs:Test.CreateObject
3652 */
3653 LIBTEST_API int STDCALL
3654 test_method_thunk (int test_id, gpointer test_method_handle, gpointer create_object_method_handle)
3655 {
3656 int ret = 0;
3657
3658 gpointer (*mono_method_get_unmanaged_thunk)(gpointer)
3659 = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_method_get_unmanaged_thunk");
3660
3661 gpointer (*mono_string_new_wrapper)(const char *)
3662 = (gpointer (*)(const char *))lookup_mono_symbol ("mono_string_new_wrapper");
3663
3664 char *(*mono_string_to_utf8)(gpointer)
3665 = (char *(*)(gpointer))lookup_mono_symbol ("mono_string_to_utf8");
3666
3667 gpointer (*mono_object_unbox)(gpointer)
3668 = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_object_unbox");
3669
3670 gpointer (*mono_threads_enter_gc_unsafe_region) (gpointer)
3671 = (gpointer (*)(gpointer))lookup_mono_symbol ("mono_threads_enter_gc_unsafe_region");
3672
3673 void (*mono_threads_exit_gc_unsafe_region) (gpointer, gpointer)
3674 = (void (*)(gpointer, gpointer))lookup_mono_symbol ("mono_threads_exit_gc_unsafe_region");
3675
3676
3677
3678 gpointer test_method, ex = NULL;
3679 gpointer (STDCALL *CreateObject)(gpointer*);
3680
3681 MONO_BEGIN_EFRAME;
3682
3683 if (!mono_method_get_unmanaged_thunk) {
3684 ret = 1;
3685 goto done;
3686 }
3687
3688 test_method = mono_method_get_unmanaged_thunk (test_method_handle);
3689 if (!test_method) {
3690 ret = 2;
3691 goto done;
3692 }
3693
3694 CreateObject = (gpointer (STDCALL *)(gpointer *))mono_method_get_unmanaged_thunk (create_object_method_handle);
3695 if (!CreateObject) {
3696 ret = 3;
3697 goto done;
3698 }
3699
3700
3701 switch (test_id) {
3702
3703 case 0: {
3704 /* thunks.cs:Test.Test0 */
3705 void (STDCALL *F)(gpointer *) = (void (STDCALL *)(gpointer *))test_method;
3706 F (&ex);
3707 break;
3708 }
3709
3710 case 1: {
3711 /* thunks.cs:Test.Test1 */
3712 int (STDCALL *F)(gpointer *) = (int (STDCALL *)(gpointer *))test_method;
3713 if (F (&ex) != 42) {
3714 ret = 4;
3715 goto done;
3716 }
3717 break;
3718 }
3719
3720 case 2: {
3721 /* thunks.cs:Test.Test2 */
3722 gpointer (STDCALL *F)(gpointer, gpointer*) = (gpointer (STDCALL *)(gpointer, gpointer *))test_method;
3723 gpointer str = mono_string_new_wrapper ("foo");
3724 if (str != F (str, &ex)) {
3725 ret = 4;
3726 goto done;
3727 }
3728 break;
3729 }
3730
3731 case 3: {
3732 /* thunks.cs:Test.Test3 */
3733 gpointer (STDCALL *F)(gpointer, gpointer, gpointer*);
3734 gpointer obj;
3735 gpointer str;
3736
3737 F = (gpointer (STDCALL *)(gpointer, gpointer, gpointer *))test_method;
3738 obj = CreateObject (&ex);
3739 str = mono_string_new_wrapper ("bar");
3740
3741 if (str != F (obj, str, &ex)) {
3742 ret = 4;
3743 goto done;
3744 }
3745 break;
3746 }
3747
3748 case 4: {
3749 /* thunks.cs:Test.Test4 */
3750 int (STDCALL *F)(gpointer, gpointer, int, gpointer*);
3751 gpointer obj;
3752 gpointer str;
3753
3754 F = (int (STDCALL *)(gpointer, gpointer, int, gpointer *))test_method;
3755 obj = CreateObject (&ex);
3756 str = mono_string_new_wrapper ("bar");
3757
3758 if (42 != F (obj, str, 42, &ex)) {
3759 ret = 4;
3760 goto done;
3761 }
3762
3763 break;
3764 }
3765
3766 case 5: {
3767 /* thunks.cs:Test.Test5 */
3768 int (STDCALL *F)(gpointer, gpointer, int, gpointer*);
3769 gpointer obj;
3770 gpointer str;
3771
3772 F = (int (STDCALL *)(gpointer, gpointer, int, gpointer *))test_method;
3773 obj = CreateObject (&ex);
3774 str = mono_string_new_wrapper ("bar");
3775
3776 F (obj, str, 42, &ex);
3777 if (!ex) {
3778 ret = 4;
3779 goto done;
3780 }
3781
3782 break;
3783 }
3784
3785 case 6: {
3786 /* thunks.cs:Test.Test6 */
3787 int (STDCALL *F)(gpointer, guint8, gint16, gint32, gint64, float, double,
3788 gpointer, gpointer*);
3789 gpointer obj;
3790 gpointer str = mono_string_new_wrapper ("Test6");
3791 int res;
3792
3793 F = (int (STDCALL *)(gpointer, guint8, gint16, gint32, gint64, float, double, gpointer, gpointer *))test_method;
3794 obj = CreateObject (&ex);
3795
3796 res = F (obj, 254, 32700, -245378, 6789600, 3.1415, 3.1415, str, &ex);
3797 if (ex) {
3798 ret = 4;
3799 goto done;
3800 }
3801
3802 if (!res) {
3803 ret = 5;
3804 goto done;
3805 }
3806
3807 break;
3808 }
3809
3810 case 7: {
3811 /* thunks.cs:Test.Test7 */
3812 gint64 (STDCALL *F)(gpointer*) = (gint64 (STDCALL *)(gpointer *))test_method;
3813 if (F (&ex) != G_MAXINT64) {
3814 ret = 4;
3815 goto done;
3816 }
3817 break;
3818 }
3819
3820 case 8: {
3821 /* thunks.cs:Test.Test8 */
3822 void (STDCALL *F)(guint8*, gint16*, gint32*, gint64*, float*, double*,
3823 gpointer*, gpointer*);
3824
3825 guint8 a1;
3826 gint16 a2;
3827 gint32 a3;
3828 gint64 a4;
3829 float a5;
3830 double a6;
3831 gpointer a7;
3832
3833 F = (void (STDCALL *)(guint8 *, gint16 *, gint32 *, gint64 *, float *, double *,
3834 gpointer *, gpointer *))test_method;
3835
3836 F (&a1, &a2, &a3, &a4, &a5, &a6, &a7, &ex);
3837 if (ex) {
3838 ret = 4;
3839 goto done;
3840 }
3841
3842 if (!(a1 == 254 &&
3843 a2 == 32700 &&
3844 a3 == -245378 &&
3845 a4 == 6789600 &&
3846 (fabs (a5 - 3.1415) < 0.001) &&
3847 (fabs (a6 - 3.1415) < 0.001) &&
3848 strcmp (mono_string_to_utf8 (a7), "Test8") == 0)){
3849 ret = 5;
3850 goto done;
3851 }
3852
3853 break;
3854 }
3855
3856 case 9: {
3857 /* thunks.cs:Test.Test9 */
3858 void (STDCALL *F)(guint8*, gint16*, gint32*, gint64*, float*, double*,
3859 gpointer*, gpointer*);
3860
3861 guint8 a1;
3862 gint16 a2;
3863 gint32 a3;
3864 gint64 a4;
3865 float a5;
3866 double a6;
3867 gpointer a7;
3868
3869 F = (void (STDCALL *)(guint8 *, gint16 *, gint32 *, gint64 *, float *, double *,
3870 gpointer *, gpointer *))test_method;
3871
3872 F (&a1, &a2, &a3, &a4, &a5, &a6, &a7, &ex);
3873 if (!ex) {
3874 ret = 4;
3875 goto done;
3876 }
3877
3878 break;
3879 }
3880
3881 case 10: {
3882 /* thunks.cs:Test.Test10 */
3883 void (STDCALL *F)(gpointer*, gpointer*);
3884
3885 gpointer obj1, obj2;
3886
3887 obj1 = obj2 = CreateObject (&ex);
3888 if (ex) {
3889 ret = 4;
3890 goto done;
3891 }
3892
3893 F = (void (STDCALL *)(gpointer *, gpointer *))test_method;
3894
3895 F (&obj1, &ex);
3896 if (ex) {
3897 ret = 5;
3898 goto done;
3899 }
3900
3901 if (obj1 == obj2) {
3902 ret = 6;
3903 goto done;
3904 }
3905
3906 break;
3907 }
3908
3909 case 100: {
3910 /* thunks.cs:TestStruct.Test0 */
3911 int (STDCALL *F)(gpointer*, gpointer*);
3912
3913 gpointer obj;
3914 TestStruct *a1;
3915 int res;
3916
3917 obj = CreateObject (&ex);
3918 if (ex) {
3919 ret = 4;
3920 goto done;
3921 }
3922
3923 if (!obj) {
3924 ret = 5;
3925 goto done;
3926 }
3927
3928 a1 = (TestStruct *)mono_object_unbox (obj);
3929 if (!a1) {
3930 ret = 6;
3931 goto done;
3932 }
3933
3934 a1->A = 42;
3935 a1->B = 3.1415;
3936
3937 F = (int (STDCALL *)(gpointer *, gpointer *))test_method;
3938
3939 res = F ((gpointer *)obj, &ex);
3940 if (ex) {
3941 ret = 7;
3942 goto done;
3943 }
3944
3945 if (!res) {
3946 ret = 8;
3947 goto done;
3948 }
3949
3950 /* check whether the call was really by value */
3951 if (a1->A != 42 || a1->B != 3.1415) {
3952 ret = 9;
3953 goto done;
3954 }
3955
3956 break;
3957 }
3958
3959 case 101: {
3960 /* thunks.cs:TestStruct.Test1 */
3961 void (STDCALL *F)(gpointer, gpointer*);
3962
3963 TestStruct *a1;
3964 gpointer obj;
3965
3966 obj = CreateObject (&ex);
3967 if (ex) {
3968 ret = 4;
3969 goto done;
3970 }
3971
3972 if (!obj) {
3973 ret = 5;
3974 goto done;
3975 }
3976
3977 a1 = (TestStruct *)mono_object_unbox (obj);
3978 if (!a1) {
3979 ret = 6;
3980 goto done;
3981 }
3982
3983 F = (void (STDCALL *)(gpointer, gpointer *))test_method;
3984
3985 F (obj, &ex);
3986 if (ex) {
3987 ret = 7;
3988 goto done;
3989 }
3990
3991 if (a1->A != 42) {
3992 ret = 8;
3993 goto done;
3994 }
3995
3996 if (!(fabs (a1->B - 3.1415) < 0.001)) {
3997 ret = 9;
3998 goto done;
3999 }
4000
4001 break;
4002 }
4003
4004 case 102: {
4005 /* thunks.cs:TestStruct.Test2 */
4006 gpointer (STDCALL *F)(gpointer*);
4007
4008 TestStruct *a1;
4009 gpointer obj;
4010
4011 F = (gpointer (STDCALL *)(gpointer *))test_method;
4012
4013 obj = F (&ex);
4014 if (ex) {
4015 ret = 4;
4016 goto done;
4017 }
4018
4019 if (!obj) {
4020 ret = 5;
4021 goto done;
4022 }
4023
4024 a1 = (TestStruct *)mono_object_unbox (obj);
4025
4026 if (a1->A != 42) {
4027 ret = 5;
4028 goto done;
4029 }
4030
4031 if (!(fabs (a1->B - 3.1415) < 0.001)) {
4032 ret = 6;
4033 goto done;
4034 }
4035
4036 break;
4037 }
4038
4039 case 103: {
4040 /* thunks.cs:TestStruct.Test3 */
4041 void (STDCALL *F)(gpointer, gpointer*);
4042
4043 TestStruct *a1;
4044 gpointer obj;
4045
4046 obj = CreateObject (&ex);
4047 if (ex) {
4048 ret = 4;
4049 goto done;
4050 }
4051
4052 if (!obj) {
4053 ret = 5;
4054 goto done;
4055 }
4056
4057 a1 = (TestStruct *)mono_object_unbox (obj);
4058
4059 if (!a1) {
4060 ret = 6;
4061 goto done;
4062 }
4063
4064 a1->A = 42;
4065 a1->B = 3.1415;
4066
4067 F = (void (STDCALL *)(gpointer, gpointer *))test_method;
4068
4069 F (obj, &ex);
4070 if (ex) {
4071 ret = 4;
4072 goto done;
4073 }
4074
4075 if (a1->A != 1) {
4076 ret = 5;
4077 goto done;
4078 }
4079
4080 if (a1->B != 17) {
4081 ret = 6;
4082 goto done;
4083 }
4084
4085 break;
4086 }
4087
4088 default:
4089 ret = 9;
4090
4091 }
4092 done:
4093 MONO_END_EFRAME;
4094
4095 return ret;
4096 }
4097
4098 typedef struct
4099 {
4100 char a;
4101 } winx64_struct1;
4102
4103 LIBTEST_API int STDCALL
4104 mono_test_Winx64_struct1_in (winx64_struct1 var)
4105 {
4106 if (var.a != 123)
4107 return 1;
4108 return 0;
4109 }
4110
4111 typedef struct
4112 {
4113 char a;
4114 char b;
4115 } winx64_struct2;
4116
4117 LIBTEST_API int STDCALL
4118 mono_test_Winx64_struct2_in (winx64_struct2 var)
4119 {
4120 if (var.a != 4)
4121 return 1;
4122 if (var.b != 5)
4123 return 2;
4124 return 0;
4125 }
4126
4127
4128 typedef struct
4129 {
4130 char a;
4131 char b;
4132 short c;
4133 } winx64_struct3;
4134
4135 LIBTEST_API int STDCALL
4136 mono_test_Winx64_struct3_in (winx64_struct3 var)
4137 {
4138 if (var.a != 4)
4139 return 1;
4140 if (var.b != 5)
4141 return 2;
4142 if (var.c != 0x1234)
4143 return 3;
4144 return 0;
4145 }
4146
4147 typedef struct
4148 {
4149 char a;
4150 char b;
4151 short c;
4152 unsigned int d;
4153 } winx64_struct4;
4154
4155 LIBTEST_API int STDCALL
4156 mono_test_Winx64_struct4_in (winx64_struct4 var)
4157 {
4158 if (var.a != 4)
4159 return 1;
4160 if (var.b != 5)
4161 return 2;
4162 if (var.c != 0x1234)
4163 return 3;
4164 if (var.d != 0x87654321)
4165 return 4;
4166 return 0;
4167 }
4168
4169 typedef struct
4170 {
4171 char a;
4172 char b;
4173 char c;
4174 } winx64_struct5;
4175
4176 LIBTEST_API int STDCALL
4177 mono_test_Winx64_struct5_in (winx64_struct5 var)
4178 {
4179 if (var.a != 4)
4180 return 1;
4181 if (var.b != 5)
4182 return 2;
4183 if (var.c != 6)
4184 return 3;
4185 return 0;
4186 }
4187
4188 typedef struct
4189 {
4190 winx64_struct1 a;
4191 short b;
4192 char c;
4193 } winx64_struct6;
4194
4195 LIBTEST_API int STDCALL
4196 mono_test_Winx64_struct6_in (winx64_struct6 var)
4197 {
4198 if (var.a.a != 4)
4199 return 1;
4200 if (var.b != 5)
4201 return 2;
4202 if (var.c != 6)
4203 return 3;
4204 return 0;
4205 }
4206
4207 LIBTEST_API int STDCALL
4208 mono_test_Winx64_structs_in1 (winx64_struct1 var1,
4209 winx64_struct2 var2,
4210 winx64_struct3 var3,
4211 winx64_struct4 var4)
4212 {
4213 if (var1.a != 123)
4214 return 1;
4215
4216 if (var2.a != 4)
4217 return 2;
4218 if (var2.b != 5)
4219 return 3;
4220
4221 if (var3.a != 4)
4222 return 4;
4223 if (var3.b != 5)
4224 return 2;
4225 if (var3.c != 0x1234)
4226 return 5;
4227
4228 if (var4.a != 4)
4229 return 6;
4230 if (var4.b != 5)
4231 return 7;
4232 if (var4.c != 0x1234)
4233 return 8;
4234 if (var4.d != 0x87654321)
4235 return 9;
4236 return 0;
4237 }
4238
4239 LIBTEST_API int STDCALL
4240 mono_test_Winx64_structs_in2 (winx64_struct1 var1,
4241 winx64_struct1 var2,
4242 winx64_struct1 var3,
4243 winx64_struct1 var4,
4244 winx64_struct1 var5)
4245 {
4246 if (var1.a != 1)
4247 return 1;
4248 if (var2.a != 2)
4249 return 2;
4250 if (var3.a != 3)
4251 return 3;
4252 if (var4.a != 4)
4253 return 4;
4254 if (var5.a != 5)
4255 return 5;
4256
4257 return 0;
4258 }
4259
4260 LIBTEST_API int STDCALL
4261 mono_test_Winx64_structs_in3 (winx64_struct1 var1,
4262 winx64_struct5 var2,
4263 winx64_struct1 var3,
4264 winx64_struct5 var4,
4265 winx64_struct1 var5,
4266 winx64_struct5 var6)
4267 {
4268 if (var1.a != 1)
4269 return 1;
4270
4271 if (var2.a != 2)
4272 return 2;
4273 if (var2.b != 3)
4274 return 2;
4275 if (var2.c != 4)
4276 return 4;
4277
4278 if (var3.a != 5)
4279 return 5;
4280
4281 if (var4.a != 6)
4282 return 6;
4283 if (var4.b != 7)
4284 return 7;
4285 if (var4.c != 8)
4286 return 8;
4287
4288 if (var5.a != 9)
4289 return 9;
4290
4291 if (var6.a != 10)
4292 return 10;
4293 if (var6.b != 11)
4294 return 11;
4295 if (var6.c != 12)
4296 return 12;
4297
4298 return 0;
4299 }
4300
4301 LIBTEST_API winx64_struct1 STDCALL
4302 mono_test_Winx64_struct1_ret (void)
4303 {
4304 winx64_struct1 ret;
4305 ret.a = 123;
4306 return ret;
4307 }
4308
4309 LIBTEST_API winx64_struct2 STDCALL
4310 mono_test_Winx64_struct2_ret (void)
4311 {
4312 winx64_struct2 ret;
4313 ret.a = 4;
4314 ret.b = 5;
4315 return ret;
4316 }
4317
4318 LIBTEST_API winx64_struct3 STDCALL
4319 mono_test_Winx64_struct3_ret (void)
4320 {
4321 winx64_struct3 ret;
4322 ret.a = 4;
4323 ret.b = 5;
4324 ret.c = 0x1234;
4325 return ret;
4326 }
4327
4328 LIBTEST_API winx64_struct4 STDCALL
4329 mono_test_Winx64_struct4_ret (void)
4330 {
4331 winx64_struct4 ret;
4332 ret.a = 4;
4333 ret.b = 5;
4334 ret.c = 0x1234;
4335 ret.d = 0x87654321;
4336 return ret;
4337 }
4338
4339 LIBTEST_API winx64_struct5 STDCALL
4340 mono_test_Winx64_struct5_ret (void)
4341 {
4342 winx64_struct5 ret;
4343 ret.a = 4;
4344 ret.b = 5;
4345 ret.c = 6;
4346 return ret;
4347 }
4348
4349 LIBTEST_API winx64_struct1 STDCALL
4350 mono_test_Winx64_struct1_ret_5_args (char a, char b, char c, char d, char e)
4351 {
4352 winx64_struct1 ret;
4353 ret.a = a + b + c + d + e;
4354 return ret;
4355 }
4356
4357 LIBTEST_API winx64_struct5 STDCALL
4358 mono_test_Winx64_struct5_ret6_args (char a, char b, char c, char d, char e)
4359 {
4360 winx64_struct5 ret;
4361 ret.a = a + b;
4362 ret.b = c + d;
4363 ret.c = e;
4364 return ret;
4365 }
4366
4367 typedef struct
4368 {
4369 float a;
4370 float b;
4371 } winx64_floatStruct;
4372
4373 LIBTEST_API int STDCALL
4374 mono_test_Winx64_floatStruct (winx64_floatStruct a)
4375 {
4376 if (a.a > 5.6 || a.a < 5.4)
4377 return 1;
4378
4379 if (a.b > 9.6 || a.b < 9.4)
4380 return 2;
4381
4382 return 0;
4383 }
4384
4385 typedef struct
4386 {
4387 double a;
4388 } winx64_doubleStruct;
4389
4390 LIBTEST_API int STDCALL
4391 mono_test_Winx64_doubleStruct (winx64_doubleStruct a)
4392 {
4393 if (a.a > 5.6 || a.a < 5.4)
4394 return 1;
4395
4396 return 0;
4397 }
4398
4399 typedef int (STDCALL *managed_struct1_delegate) (winx64_struct1 a);
4400
4401 LIBTEST_API int STDCALL
4402 mono_test_managed_Winx64_struct1_in(managed_struct1_delegate func)
4403 {
4404 winx64_struct1 val;
4405 val.a = 5;
4406 return func (val);
4407 }
4408
4409 typedef int (STDCALL *managed_struct5_delegate) (winx64_struct5 a);
4410
4411 LIBTEST_API int STDCALL
4412 mono_test_managed_Winx64_struct5_in(managed_struct5_delegate func)
4413 {
4414 winx64_struct5 val;
4415 val.a = 5;
4416 val.b = 0x10;
4417 val.c = 0x99;
4418 return func (val);
4419 }
4420
4421 typedef int (STDCALL *managed_struct1_struct5_delegate) (winx64_struct1 a, winx64_struct5 b,
4422 winx64_struct1 c, winx64_struct5 d,
4423 winx64_struct1 e, winx64_struct5 f);
4424
4425 LIBTEST_API int STDCALL
4426 mono_test_managed_Winx64_struct1_struct5_in(managed_struct1_struct5_delegate func)
4427 {
4428 winx64_struct1 a, c, e;
4429 winx64_struct5 b, d, f;
4430 a.a = 1;
4431 b.a = 2; b.b = 3; b.c = 4;
4432 c.a = 5;
4433 d.a = 6; d.b = 7; d.c = 8;
4434 e.a = 9;
4435 f.a = 10; f.b = 11; f.c = 12;
4436
4437 return func (a, b, c, d, e, f);
4438 }
4439
4440 typedef winx64_struct1 (STDCALL *managed_struct1_ret_delegate) (void);
4441
4442 LIBTEST_API int STDCALL
4443 mono_test_Winx64_struct1_ret_managed (managed_struct1_ret_delegate func)
4444 {
4445 winx64_struct1 ret;
4446
4447 ret = func ();
4448
4449 if (ret.a != 0x45)
4450 return 1;
4451
4452 return 0;
4453 }
4454
4455 typedef winx64_struct5 (STDCALL *managed_struct5_ret_delegate) (void);
4456
4457 LIBTEST_API int STDCALL
4458 mono_test_Winx64_struct5_ret_managed (managed_struct5_ret_delegate func)
4459 {
4460 winx64_struct5 ret;
4461
4462 ret = func ();
4463
4464 if (ret.a != 0x12)
4465 return 1;
4466 if (ret.b != 0x34)
4467 return 2;
4468 if (ret.c != 0x56)
4469 return 3;
4470
4471 return 0;
4472 }
4473
4474 LIBTEST_API int STDCALL
4475 mono_test_marshal_bool_in (int arg, unsigned int expected, unsigned int bDefaultMarsh, unsigned int bBoolCustMarsh,
4476 char bI1CustMarsh, unsigned char bU1CustMarsh, short bVBCustMarsh)
4477 {
4478 switch (arg) {
4479 case 1:
4480 if (bDefaultMarsh != expected)
4481 return 1;
4482 break;
4483 case 2:
4484 if (bBoolCustMarsh != expected)
4485 return 2;
4486 break;
4487 case 3:
4488 if (bI1CustMarsh != expected)
4489 return 3;
4490 break;
4491 case 4:
4492 if (bU1CustMarsh != expected)
4493 return 4;
4494 break;
4495 case 5:
4496 if (bVBCustMarsh != expected)
4497 return 5;
4498 break;
4499 default:
4500 return 999;
4501 }
4502 return 0;
4503 }
4504
4505 LIBTEST_API int STDCALL
4506 mono_test_marshal_bool_out (int arg, unsigned int testVal, unsigned int* bDefaultMarsh, unsigned int* bBoolCustMarsh,
4507 char* bI1CustMarsh, unsigned char* bU1CustMarsh, unsigned short* bVBCustMarsh)
4508 {
4509 switch (arg) {
4510 case 1:
4511 if (!bDefaultMarsh)
4512 return 1;
4513 *bDefaultMarsh = testVal;
4514 break;
4515 case 2:
4516 if (!bBoolCustMarsh)
4517 return 2;
4518 *bBoolCustMarsh = testVal;
4519 break;
4520 case 3:
4521 if (!bI1CustMarsh)
4522 return 3;
4523 *bI1CustMarsh = (char)testVal;
4524 break;
4525 case 4:
4526 if (!bU1CustMarsh)
4527 return 4;
4528 *bU1CustMarsh = (unsigned char)testVal;
4529 break;
4530 case 5:
4531 if (!bVBCustMarsh)
4532 return 5;
4533 *bVBCustMarsh = (unsigned short)testVal;
4534 break;
4535 default:
4536 return 999;
4537 }
4538 return 0;
4539 }
4540
4541 LIBTEST_API int STDCALL
4542 mono_test_marshal_bool_ref (int arg, unsigned int expected, unsigned int testVal, unsigned int* bDefaultMarsh,
4543 unsigned int* bBoolCustMarsh, char* bI1CustMarsh, unsigned char* bU1CustMarsh,
4544 unsigned short* bVBCustMarsh)
4545 {
4546 switch (arg) {
4547 case 1:
4548 if (!bDefaultMarsh)
4549 return 1;
4550 if (*bDefaultMarsh != expected)
4551 return 2;
4552 *bDefaultMarsh = testVal;
4553 break;
4554 case 2:
4555 if (!bBoolCustMarsh)
4556 return 3;
4557 if (*bBoolCustMarsh != expected)
4558 return 4;
4559 *bBoolCustMarsh = testVal;
4560 break;
4561 case 3:
4562 if (!bI1CustMarsh)
4563 return 5;
4564 if (*bI1CustMarsh != expected)
4565 return 6;
4566 *bI1CustMarsh = (char)testVal;
4567 break;
4568 case 4:
4569 if (!bU1CustMarsh)
4570 return 7;
4571 if (*bU1CustMarsh != expected)
4572 return 8;
4573 *bU1CustMarsh = (unsigned char)testVal;
4574 break;
4575 case 5:
4576 if (!bVBCustMarsh)
4577 return 9;
4578 if (*bVBCustMarsh != expected)
4579 return 10;
4580 *bVBCustMarsh = (unsigned short)testVal;
4581 break;
4582 default:
4583 return 999;
4584 }
4585 return 0;
4586 }
4587
4588
4589 typedef int (STDCALL *MarshalBoolInDelegate) (int arg, unsigned int expected, unsigned int bDefaultMarsh,
4590 unsigned int bBoolCustMarsh, char bI1CustMarsh, unsigned char bU1CustMarsh, unsigned short bVBCustMarsh);
4591
4592 LIBTEST_API int STDCALL
4593 mono_test_managed_marshal_bool_in (int arg, unsigned int expected, unsigned int testVal, MarshalBoolInDelegate pfcn)
4594 {
4595 if (!pfcn)
4596 return 0x9900;
4597
4598 switch (arg) {
4599 case 1:
4600 return pfcn (arg, expected, testVal, 0, 0, 0, 0);
4601 case 2:
4602 return pfcn (arg, expected, 0, testVal, 0, 0, 0);
4603 case 3:
4604 return pfcn (arg, expected, 0, 0, testVal, 0, 0);
4605 case 4:
4606 return pfcn (arg, expected, 0, 0, 0, testVal, 0);
4607 case 5:
4608 return pfcn (arg, expected, 0, 0, 0, 0, testVal);
4609 default:
4610 return 0x9800;
4611 }
4612
4613 return 0;
4614 }
4615
4616 typedef int (STDCALL *MarshalBoolOutDelegate) (int arg, unsigned int expected, unsigned int* bDefaultMarsh,
4617 unsigned int* bBoolCustMarsh, char* bI1CustMarsh, unsigned char* bU1CustMarsh, unsigned short* bVBCustMarsh);
4618
4619 LIBTEST_API int STDCALL
4620 mono_test_managed_marshal_bool_out (int arg, unsigned int expected, unsigned int testVal, MarshalBoolOutDelegate pfcn)
4621 {
4622 int ret;
4623 unsigned int lDefaultMarsh, lBoolCustMarsh;
4624 char lI1CustMarsh = 0;
4625 unsigned char lU1CustMarsh = 0;
4626 unsigned short lVBCustMarsh = 0;
4627 lDefaultMarsh = lBoolCustMarsh = 0;
4628
4629 if (!pfcn)
4630 return 0x9900;
4631
4632 switch (arg) {
4633 case 1: {
4634 unsigned int ltVal = 0;
4635 ret = pfcn (arg, testVal, &ltVal, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4636 if (ret)
4637 return 0x0100 + ret;
4638 if (expected != ltVal)
4639 return 0x0200;
4640 break;
4641 }
4642 case 2: {
4643 unsigned int ltVal = 0;
4644 ret = pfcn (arg, testVal, &lDefaultMarsh, &ltVal, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4645 if (ret)
4646 return 0x0300 + ret;
4647 if (expected != ltVal)
4648 return 0x0400;
4649 break;
4650 }
4651 case 3: {
4652 char ltVal = 0;
4653 ret = pfcn (arg, testVal, &lDefaultMarsh, &lBoolCustMarsh, &ltVal, &lU1CustMarsh, &lVBCustMarsh);
4654 if (ret)
4655 return 0x0500 + ret;
4656 if (expected != ltVal)
4657 return 0x0600;
4658 break;
4659 }
4660 case 4: {
4661 unsigned char ltVal = 0;
4662 ret = pfcn (arg, testVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &ltVal, &lVBCustMarsh);
4663 if (ret)
4664 return 0x0700 + ret;
4665 if (expected != ltVal)
4666 return 0x0800;
4667 break;
4668 }
4669 case 5: {
4670 unsigned short ltVal = 0;
4671 ret = pfcn (arg, testVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &ltVal);
4672 if (ret)
4673 return 0x0900 + ret;
4674 if (expected != ltVal)
4675 return 0x1000;
4676 break;
4677 }
4678 default:
4679 return 0x9800;
4680 }
4681
4682 return 0;
4683 }
4684
4685 typedef int (STDCALL *MarshalBoolRefDelegate) (int arg, unsigned int expected, unsigned int testVal, unsigned int* bDefaultMarsh,
4686 unsigned int* bBoolCustMarsh, char* bI1CustMarsh, unsigned char* bU1CustMarsh, unsigned short* bVBCustMarsh);
4687
4688 LIBTEST_API int STDCALL
4689 mono_test_managed_marshal_bool_ref (int arg, unsigned int expected, unsigned int testVal, unsigned int outExpected,
4690 unsigned int outTestVal, MarshalBoolRefDelegate pfcn)
4691 {
4692 int ret;
4693 unsigned int lDefaultMarsh, lBoolCustMarsh;
4694 char lI1CustMarsh = 0;
4695 unsigned char lU1CustMarsh = 0;
4696 unsigned short lVBCustMarsh = 0;
4697 lDefaultMarsh = lBoolCustMarsh = 0;
4698
4699 if (!pfcn)
4700 return 0x9900;
4701
4702 switch (arg) {
4703 case 1:
4704 {
4705 unsigned int ltestVal = testVal;
4706 ret = pfcn (arg, expected, outTestVal, &ltestVal, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4707 if (ret)
4708 return 0x0100 + ret;
4709 if (outExpected != ltestVal)
4710 return 0x0200;
4711 break;
4712 }
4713 case 2:
4714 {
4715 unsigned int ltestVal = testVal;
4716 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &ltestVal, &lI1CustMarsh, &lU1CustMarsh, &lVBCustMarsh);
4717 if (ret)
4718 return 0x0300 + ret;
4719 if (outExpected != ltestVal)
4720 return 0x0400;
4721 break;
4722 }
4723 case 3:
4724 {
4725 char ltestVal = testVal;
4726 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &lBoolCustMarsh, &ltestVal, &lU1CustMarsh, &lVBCustMarsh);
4727 if (ret)
4728 return 0x0500 + ret;
4729 if (outExpected != ltestVal)
4730 return 0x0600;
4731 break;
4732 }
4733 case 4:
4734 {
4735 unsigned char ltestVal = testVal;
4736 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &ltestVal, &lVBCustMarsh);
4737 if (ret)
4738 return 0x0700 + ret;
4739 if (outExpected != ltestVal)
4740 return 0x0800;
4741 break;
4742 }
4743 case 5:
4744 {
4745 unsigned short ltestVal = testVal;
4746 ret = pfcn (arg, expected, outTestVal, &lDefaultMarsh, &lBoolCustMarsh, &lI1CustMarsh, &lU1CustMarsh, &ltestVal);
4747 if (ret)
4748 return 0x0900 + ret;
4749 if (outExpected != ltestVal)
4750 return 0x1000;
4751 break;
4752 }
4753 default:
4754 return 0x9800;
4755 }
4756
4757 return 0;
4758 }
4759
4760 #ifdef WIN32
4761
4762 LIBTEST_API int STDCALL
4763 mono_test_marshal_safearray_out_1dim_vt_bstr_empty (SAFEARRAY** safearray)
4764 {
4765 /* Create an empty one-dimensional array of variants */
4766 SAFEARRAY *pSA;
4767 SAFEARRAYBOUND dimensions [1];
4768
4769 dimensions [0].lLbound = 0;
4770 dimensions [0].cElements = 0;
4771
4772 pSA= SafeArrayCreate (VT_VARIANT, 1, dimensions);
4773 *safearray = pSA;
4774 return S_OK;
4775 }
4776
4777 LIBTEST_API int STDCALL
4778 mono_test_marshal_safearray_out_1dim_vt_bstr (SAFEARRAY** safearray)
4779 {
4780 /* Create a one-dimensional array of 10 variants filled with "0" to "9" */
4781 SAFEARRAY *pSA;
4782 SAFEARRAYBOUND dimensions [1];
4783 long i;
4784 gchar buffer [20];
4785 HRESULT hr = S_OK;
4786 long indices [1];
4787
4788 dimensions [0].lLbound = 0;
4789 dimensions [0].cElements = 10;
4790
4791 pSA= SafeArrayCreate (VT_VARIANT, 1, dimensions);
4792 for (i= dimensions [0].lLbound; i< (dimensions [0].cElements + dimensions [0].lLbound); i++) {
4793 VARIANT vOut;
4794 VariantInit (&vOut);
4795 vOut.vt = VT_BSTR;
4796 _ltoa (i,buffer,10);
4797 vOut.bstrVal= marshal_bstr_alloc (buffer);
4798 indices [0] = i;
4799 if ((hr = SafeArrayPutElement (pSA, indices, &vOut)) != S_OK) {
4800 VariantClear (&vOut);
4801 SafeArrayDestroy (pSA);
4802 return hr;
4803 }
4804 VariantClear (&vOut);
4805 }
4806 *safearray = pSA;
4807 return hr;
4808 }
4809
4810 LIBTEST_API int STDCALL
4811 mono_test_marshal_safearray_out_2dim_vt_i4 (SAFEARRAY** safearray)
4812 {
4813 /* Create a two-dimensional array of 4x3 variants filled with 11, 12, 13, etc. */
4814 SAFEARRAY *pSA;
4815 SAFEARRAYBOUND dimensions [2];
4816 long i, j;
4817 HRESULT hr = S_OK;
4818 long indices [2];
4819
4820 dimensions [0].lLbound = 0;
4821 dimensions [0].cElements = 4;
4822 dimensions [1].lLbound = 0;
4823 dimensions [1].cElements = 3;
4824
4825 pSA= SafeArrayCreate(VT_VARIANT, 2, dimensions);
4826 for (i= dimensions [0].lLbound; i< (dimensions [0].cElements + dimensions [0].lLbound); i++) {
4827 for (j= dimensions [1].lLbound; j< (dimensions [1].cElements + dimensions [1].lLbound); j++) {
4828 VARIANT vOut;
4829 VariantInit (&vOut);
4830 vOut.vt = VT_I4;
4831 vOut.lVal = (i+1)*10+(j+1);
4832 indices [0] = i;
4833 indices [1] = j;
4834 if ((hr = SafeArrayPutElement (pSA, indices, &vOut)) != S_OK) {
4835 VariantClear (&vOut);
4836 SafeArrayDestroy (pSA);
4837 return hr;
4838 }
4839 VariantClear (&vOut); // does a deep destroy of source VARIANT
4840 }
4841 }
4842 *safearray = pSA;
4843 return hr;
4844 }
4845
4846 LIBTEST_API int STDCALL
4847 mono_test_marshal_safearray_out_4dim_vt_i4 (SAFEARRAY** safearray)
4848 {
4849 /* Create a four-dimensional array of 10x3x6x7 variants filled with their indices */
4850 /* Also use non zero lower bounds */
4851 SAFEARRAY *pSA;
4852 SAFEARRAYBOUND dimensions [4];
4853 long i;
4854 HRESULT hr = S_OK;
4855 VARIANT *pData;
4856
4857 dimensions [0].lLbound = 15;
4858 dimensions [0].cElements = 10;
4859 dimensions [1].lLbound = 20;
4860 dimensions [1].cElements = 3;
4861 dimensions [2].lLbound = 5;
4862 dimensions [2].cElements = 6;
4863 dimensions [3].lLbound = 12;
4864 dimensions [3].cElements = 7;
4865
4866 pSA= SafeArrayCreate (VT_VARIANT, 4, dimensions);
4867
4868 SafeArrayAccessData (pSA, (void **)&pData);
4869
4870 for (i= 0; i< 10*3*6*7; i++) {
4871 VariantInit(&pData [i]);
4872 pData [i].vt = VT_I4;
4873 pData [i].lVal = i;
4874 }
4875 SafeArrayUnaccessData (pSA);
4876 *safearray = pSA;
4877 return hr;
4878 }
4879
4880 LIBTEST_API int STDCALL
4881 mono_test_marshal_safearray_in_byval_1dim_empty (SAFEARRAY* safearray)
4882 {
4883 /* Check that array is one dimensional and empty */
4884
4885 UINT dim;
4886 long lbound, ubound;
4887
4888 dim = SafeArrayGetDim (safearray);
4889 if (dim != 1)
4890 return 1;
4891
4892 SafeArrayGetLBound (safearray, 1, &lbound);
4893 SafeArrayGetUBound (safearray, 1, &ubound);
4894
4895 if ((lbound > 0) || (ubound > 0))
4896 return 1;
4897
4898 return 0;
4899 }
4900
4901 LIBTEST_API int STDCALL
4902 mono_test_marshal_safearray_in_byval_1dim_vt_i4 (SAFEARRAY* safearray)
4903 {
4904 /* Check that array is one dimensional containing integers from 1 to 10 */
4905
4906 UINT dim;
4907 long lbound, ubound;
4908 VARIANT *pData;
4909 long i;
4910 int result=0;
4911
4912 dim = SafeArrayGetDim (safearray);
4913 if (dim != 1)
4914 return 1;
4915
4916 SafeArrayGetLBound (safearray, 1, &lbound);
4917 SafeArrayGetUBound (safearray, 1, &ubound);
4918
4919 if ((lbound != 0) || (ubound != 9))
4920 return 1;
4921
4922 SafeArrayAccessData (safearray, (void **)&pData);
4923 for (i= lbound; i <= ubound; i++) {
4924 if ((VariantChangeType (&pData [i], &pData [i], VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK) || (pData [i].lVal != i + 1))
4925 result = 1;
4926 }
4927 SafeArrayUnaccessData (safearray);
4928
4929 return result;
4930 }
4931
4932 LIBTEST_API int STDCALL
4933 mono_test_marshal_safearray_in_byval_1dim_vt_mixed (SAFEARRAY* safearray)
4934 {
4935 /* Check that array is one dimensional containing integers mixed with strings from 0 to 12 */
4936
4937 UINT dim;
4938 long lbound, ubound;
4939 VARIANT *pData;
4940 long i;
4941 long indices [1];
4942 VARIANT element;
4943 int result=0;
4944
4945 VariantInit (&element);
4946
4947 dim = SafeArrayGetDim (safearray);
4948 if (dim != 1)
4949 return 1;
4950
4951 SafeArrayGetLBound (safearray, 1, &lbound);
4952 SafeArrayGetUBound (safearray, 1, &ubound);
4953
4954 if ((lbound != 0) || (ubound != 12))
4955 return 1;
4956
4957 SafeArrayAccessData (safearray, (void **)&pData);
4958 for (i= lbound; i <= ubound; i++) {
4959 if ((i%2 == 0) && (pData [i].vt != VT_I4))
4960 result = 1;
4961 if ((i%2 == 1) && (pData [i].vt != VT_BSTR))
4962 result = 1;
4963 if ((VariantChangeType (&pData [i], &pData [i], VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK) || (pData [i].lVal != i))
4964 result = 1;
4965 }
4966 SafeArrayUnaccessData (safearray);
4967
4968 /* Change the first element of the array to verify that [in] parameters are not marshalled back to the managed side */
4969
4970 indices [0] = 0;
4971 element.vt = VT_I4;
4972 element.lVal = 333;
4973 SafeArrayPutElement (safearray, indices, &element);
4974 VariantClear (&element);
4975
4976 return result;
4977 }
4978
4979 LIBTEST_API int STDCALL
4980 mono_test_marshal_safearray_in_byval_2dim_vt_i4 (SAFEARRAY* safearray)
4981 {
4982 /* Check that array is one dimensional containing integers mixed with strings from 0 to 12 */
4983
4984 UINT dim;
4985 long lbound1, ubound1, lbound2, ubound2;
4986 long i, j, failed;
4987 long indices [2];
4988 VARIANT element;
4989
4990 VariantInit (&element);
4991
4992 dim = SafeArrayGetDim (safearray);
4993 if (dim != 2)
4994 return 1;
4995
4996 SafeArrayGetLBound (safearray, 1, &lbound1);
4997 SafeArrayGetUBound (safearray, 1, &ubound1);
4998
4999 if ((lbound1 != 0) || (ubound1 != 1))
5000 return 1;
5001
5002 SafeArrayGetLBound (safearray, 2, &lbound2);
5003 SafeArrayGetUBound (safearray, 2, &ubound2);
5004
5005 if ((lbound2 != 0) || (ubound2 != 3)) {
5006 return 1;
5007 }
5008
5009 for (i= lbound1; i <= ubound1; i++) {
5010 indices [0] = i;
5011 for (j= lbound2; j <= ubound2; j++) {
5012 indices [1] = j;
5013 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5014 return 1;
5015 failed = ((element.vt != VT_I4) || (element.lVal != 10*(i+1)+(j+1)));
5016 VariantClear (&element);
5017 if (failed)
5018 return 1;
5019 }
5020 }
5021
5022 /* Change the first element of the array to verify that [in] parameters are not marshalled back to the managed side */
5023
5024 indices [0] = 0;
5025 indices [1] = 0;
5026 element.vt = VT_I4;
5027 element.lVal = 333;
5028 SafeArrayPutElement (safearray, indices, &element);
5029 VariantClear (&element);
5030
5031 return 0;
5032 }
5033
5034 LIBTEST_API int STDCALL
5035 mono_test_marshal_safearray_in_byval_3dim_vt_bstr (SAFEARRAY* safearray)
5036 {
5037 /* Check that array is one dimensional containing integers mixed with strings from 0 to 12 */
5038
5039 UINT dim;
5040 long lbound1, ubound1, lbound2, ubound2, lbound3, ubound3;
5041 long i, j, k, failed;
5042 long indices [3];
5043 VARIANT element;
5044
5045 VariantInit (&element);
5046
5047 dim = SafeArrayGetDim (safearray);
5048 if (dim != 3)
5049 return 1;
5050
5051 SafeArrayGetLBound (safearray, 1, &lbound1);
5052 SafeArrayGetUBound (safearray, 1, &ubound1);
5053
5054 if ((lbound1 != 0) || (ubound1 != 1))
5055 return 1;
5056
5057 SafeArrayGetLBound (safearray, 2, &lbound2);
5058 SafeArrayGetUBound (safearray, 2, &ubound2);
5059
5060 if ((lbound2 != 0) || (ubound2 != 1))
5061 return 1;
5062
5063 SafeArrayGetLBound (safearray, 3, &lbound3);
5064 SafeArrayGetUBound (safearray, 3, &ubound3);
5065
5066 if ((lbound3 != 0) || (ubound3 != 2))
5067 return 1;
5068
5069 for (i= lbound1; i <= ubound1; i++) {
5070 indices [0] = i;
5071 for (j= lbound2; j <= ubound2; j++) {
5072 indices [1] = j;
5073 for (k= lbound3; k <= ubound3; k++) {
5074 indices [2] = k;
5075 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5076 return 1;
5077 failed = ((element.vt != VT_BSTR)
5078 || (VariantChangeType (&element, &element, VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK)
5079 || (element.lVal != 100*(i+1)+10*(j+1)+(k+1)));
5080 VariantClear (&element);
5081 if (failed)
5082 return 1;
5083 }
5084 }
5085 }
5086
5087 /* Change the first element of the array to verify that [in] parameters are not marshalled back to the managed side */
5088
5089 indices [0] = 0;
5090 indices [1] = 0;
5091 indices [2] = 0;
5092 element.vt = VT_BSTR;
5093 element.bstrVal = SysAllocString(L"Should not be copied");
5094 SafeArrayPutElement (safearray, indices, &element);
5095 VariantClear (&element);
5096
5097 return 0;
5098 }
5099
5100 LIBTEST_API int STDCALL
5101 mono_test_marshal_safearray_in_byref_3dim_vt_bstr (SAFEARRAY** safearray)
5102 {
5103 return mono_test_marshal_safearray_in_byval_3dim_vt_bstr (*safearray);
5104 }
5105
5106 LIBTEST_API int STDCALL
5107 mono_test_marshal_safearray_in_out_byref_1dim_empty (SAFEARRAY** safearray)
5108 {
5109 /* Check that the input array is what is expected and change it so the caller can check */
5110 /* correct marshalling back to managed code */
5111
5112 UINT dim;
5113 long lbound, ubound;
5114 SAFEARRAYBOUND dimensions [1];
5115 long i;
5116 wchar_t buffer [20];
5117 HRESULT hr = S_OK;
5118 long indices [1];
5119
5120 /* Check that in array is one dimensional and empty */
5121
5122 dim = SafeArrayGetDim (*safearray);
5123 if (dim != 1) {
5124 return 1;
5125 }
5126
5127 SafeArrayGetLBound (*safearray, 1, &lbound);
5128 SafeArrayGetUBound (*safearray, 1, &ubound);
5129
5130 if ((lbound > 0) || (ubound > 0)) {
5131 return 1;
5132 }
5133
5134 /* Re-dimension the array and return a one-dimensional array of 8 variants filled with "0" to "7" */
5135
5136 dimensions [0].lLbound = 0;
5137 dimensions [0].cElements = 8;
5138
5139 hr = SafeArrayRedim (*safearray, dimensions);
5140 if (hr != S_OK)
5141 return 1;
5142
5143 for (i= dimensions [0].lLbound; i< (dimensions [0].lLbound + dimensions [0].cElements); i++) {
5144 VARIANT vOut;
5145 VariantInit (&vOut);
5146 vOut.vt = VT_BSTR;
5147 _ltow (i,buffer,10);
5148 vOut.bstrVal = SysAllocString (buffer);
5149 indices [0] = i;
5150 if ((hr = SafeArrayPutElement (*safearray, indices, &vOut)) != S_OK) {
5151 VariantClear (&vOut);
5152 SafeArrayDestroy (*safearray);
5153 return hr;
5154 }
5155 VariantClear (&vOut);
5156 }
5157 return hr;
5158 }
5159
5160 LIBTEST_API int STDCALL
5161 mono_test_marshal_safearray_in_out_byref_3dim_vt_bstr (SAFEARRAY** safearray)
5162 {
5163 /* Check that the input array is what is expected and change it so the caller can check */
5164 /* correct marshalling back to managed code */
5165
5166 UINT dim;
5167 long lbound1, ubound1, lbound2, ubound2, lbound3, ubound3;
5168 SAFEARRAYBOUND dimensions [1];
5169 long i, j, k, failed;
5170 wchar_t buffer [20];
5171 HRESULT hr = S_OK;
5172 long indices [3];
5173 VARIANT element;
5174
5175 VariantInit (&element);
5176
5177 /* Check that in array is three dimensional and contains the expected values */
5178
5179 dim = SafeArrayGetDim (*safearray);
5180 if (dim != 3)
5181 return 1;
5182
5183 SafeArrayGetLBound (*safearray, 1, &lbound1);
5184 SafeArrayGetUBound (*safearray, 1, &ubound1);
5185
5186 if ((lbound1 != 0) || (ubound1 != 1))
5187 return 1;
5188
5189 SafeArrayGetLBound (*safearray, 2, &lbound2);
5190 SafeArrayGetUBound (*safearray, 2, &ubound2);
5191
5192 if ((lbound2 != 0) || (ubound2 != 1))
5193 return 1;
5194
5195 SafeArrayGetLBound (*safearray, 3, &lbound3);
5196 SafeArrayGetUBound (*safearray, 3, &ubound3);
5197
5198 if ((lbound3 != 0) || (ubound3 != 2))
5199 return 1;
5200
5201 for (i= lbound1; i <= ubound1; i++) {
5202 indices [0] = i;
5203 for (j= lbound2; j <= ubound2; j++) {
5204 indices [1] = j;
5205 for (k= lbound3; k <= ubound3; k++) {
5206 indices [2] = k;
5207 if (SafeArrayGetElement (*safearray, indices, &element) != S_OK)
5208 return 1;
5209 failed = ((element.vt != VT_BSTR)
5210 || (VariantChangeType (&element, &element, VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK)
5211 || (element.lVal != 100*(i+1)+10*(j+1)+(k+1)));
5212 VariantClear (&element);
5213 if (failed)
5214 return 1;
5215 }
5216 }
5217 }
5218
5219 hr = SafeArrayDestroy (*safearray);
5220 if (hr != S_OK)
5221 return 1;
5222
5223 /* Return a new one-dimensional array of 8 variants filled with "0" to "7" */
5224
5225 dimensions [0].lLbound = 0;
5226 dimensions [0].cElements = 8;
5227
5228 *safearray = SafeArrayCreate (VT_VARIANT, 1, dimensions);
5229
5230 for (i= dimensions [0].lLbound; i< (dimensions [0].lLbound + dimensions [0].cElements); i++) {
5231 VARIANT vOut;
5232 VariantInit (&vOut);
5233 vOut.vt = VT_BSTR;
5234 _ltow (i,buffer,10);
5235 vOut.bstrVal = SysAllocString (buffer);
5236 indices [0] = i;
5237 if ((hr = SafeArrayPutElement (*safearray, indices, &vOut)) != S_OK) {
5238 VariantClear (&vOut);
5239 SafeArrayDestroy (*safearray);
5240 return hr;
5241 }
5242 VariantClear (&vOut);
5243 }
5244 return hr;
5245 }
5246
5247 LIBTEST_API int STDCALL
5248 mono_test_marshal_safearray_in_out_byref_1dim_vt_i4 (SAFEARRAY** safearray)
5249 {
5250 /* Check that the input array is what is expected and change it so the caller can check */
5251 /* correct marshalling back to managed code */
5252
5253 UINT dim;
5254 long lbound1, ubound1;
5255 long i, failed;
5256 HRESULT hr = S_OK;
5257 long indices [1];
5258 VARIANT element;
5259
5260 VariantInit (&element);
5261
5262 /* Check that in array is one dimensional and contains the expected value */
5263
5264 dim = SafeArrayGetDim (*safearray);
5265 if (dim != 1)
5266 return 1;
5267
5268 SafeArrayGetLBound (*safearray, 1, &lbound1);
5269 SafeArrayGetUBound (*safearray, 1, &ubound1);
5270
5271 ubound1 = 1;
5272 if ((lbound1 != 0) || (ubound1 != 1))
5273 return 1;
5274 ubound1 = 0;
5275
5276 for (i= lbound1; i <= ubound1; i++) {
5277 indices [0] = i;
5278 if (SafeArrayGetElement (*safearray, indices, &element) != S_OK)
5279 return 1;
5280 failed = (element.vt != VT_I4) || (element.lVal != i+1);
5281 VariantClear (&element);
5282 if (failed)
5283 return 1;
5284 }
5285
5286 /* Change one of the elements of the array to verify that [out] parameter is marshalled back to the managed side */
5287
5288 indices [0] = 0;
5289 element.vt = VT_I4;
5290 element.lVal = -1;
5291 SafeArrayPutElement (*safearray, indices, &element);
5292 VariantClear (&element);
5293
5294 return hr;
5295 }
5296
5297 LIBTEST_API int STDCALL
5298 mono_test_marshal_safearray_in_out_byval_1dim_vt_i4 (SAFEARRAY* safearray)
5299 {
5300 /* Check that the input array is what is expected and change it so the caller can check */
5301 /* correct marshalling back to managed code */
5302
5303 UINT dim;
5304 long lbound1, ubound1;
5305 SAFEARRAYBOUND dimensions [1];
5306 long i, failed;
5307 HRESULT hr = S_OK;
5308 long indices [1];
5309 VARIANT element;
5310
5311 VariantInit (&element);
5312
5313 /* Check that in array is one dimensional and contains the expected value */
5314
5315 dim = SafeArrayGetDim (safearray);
5316 if (dim != 1)
5317 return 1;
5318
5319 SafeArrayGetLBound (safearray, 1, &lbound1);
5320 SafeArrayGetUBound (safearray, 1, &ubound1);
5321
5322 if ((lbound1 != 0) || (ubound1 != 0))
5323 return 1;
5324
5325 for (i= lbound1; i <= ubound1; i++) {
5326 indices [0] = i;
5327 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5328 return 1;
5329 failed = (element.vt != VT_I4) || (element.lVal != i+1);
5330 VariantClear (&element);
5331 if (failed)
5332 return 1;
5333 }
5334
5335 /* Change the array to verify how [out] parameter is marshalled back to the managed side */
5336
5337 /* Redimension the array */
5338 dimensions [0].lLbound = lbound1;
5339 dimensions [0].cElements = 2;
5340 hr = SafeArrayRedim(safearray, dimensions);
5341
5342 indices [0] = 0;
5343 element.vt = VT_I4;
5344 element.lVal = 12345;
5345 SafeArrayPutElement (safearray, indices, &element);
5346 VariantClear (&element);
5347
5348 indices [0] = 1;
5349 element.vt = VT_I4;
5350 element.lVal = -12345;
5351 SafeArrayPutElement (safearray, indices, &element);
5352 VariantClear (&element);
5353
5354 return hr;
5355 }
5356
5357 LIBTEST_API int STDCALL
5358 mono_test_marshal_safearray_in_out_byval_3dim_vt_bstr (SAFEARRAY* safearray)
5359 {
5360 /* Check that the input array is what is expected and change it so the caller can check */
5361 /* correct marshalling back to managed code */
5362
5363 UINT dim;
5364 long lbound1, ubound1, lbound2, ubound2, lbound3, ubound3;
5365 long i, j, k, failed;
5366 HRESULT hr = S_OK;
5367 long indices [3];
5368 VARIANT element;
5369
5370 VariantInit (&element);
5371
5372 /* Check that in array is three dimensional and contains the expected values */
5373
5374 dim = SafeArrayGetDim (safearray);
5375 if (dim != 3)
5376 return 1;
5377
5378 SafeArrayGetLBound (safearray, 1, &lbound1);
5379 SafeArrayGetUBound (safearray, 1, &ubound1);
5380
5381 if ((lbound1 != 0) || (ubound1 != 1))
5382 return 1;
5383
5384 SafeArrayGetLBound (safearray, 2, &lbound2);
5385 SafeArrayGetUBound (safearray, 2, &ubound2);
5386
5387 if ((lbound2 != 0) || (ubound2 != 1))
5388 return 1;
5389
5390 SafeArrayGetLBound (safearray, 3, &lbound3);
5391 SafeArrayGetUBound (safearray, 3, &ubound3);
5392
5393 if ((lbound3 != 0) || (ubound3 != 2))
5394 return 1;
5395
5396 for (i= lbound1; i <= ubound1; i++) {
5397 indices [0] = i;
5398 for (j= lbound2; j <= ubound2; j++) {
5399 indices [1] = j;
5400 for (k= lbound3; k <= ubound3; k++) {
5401 indices [2] = k;
5402 if (SafeArrayGetElement (safearray, indices, &element) != S_OK)
5403 return 1;
5404 failed = ((element.vt != VT_BSTR)
5405 || (VariantChangeType (&element, &element, VARIANT_NOUSEROVERRIDE, VT_I4) != S_OK)
5406 || (element.lVal != 100*(i+1)+10*(j+1)+(k+1)));
5407 VariantClear (&element);
5408 if (failed)
5409 return 1;
5410 }
5411 }
5412 }
5413
5414 /* Change the elements of the array to verify that [out] parameter is marshalled back to the managed side */
5415
5416 indices [0] = 1;
5417 indices [1] = 1;
5418 indices [2] = 2;
5419 element.vt = VT_I4;
5420 element.lVal = 333;
5421 SafeArrayPutElement (safearray, indices, &element);
5422 VariantClear (&element);
5423
5424 indices [0] = 1;
5425 indices [1] = 1;
5426 indices [2] = 1;
5427 element.vt = VT_I4;
5428 element.lVal = 111;
5429 SafeArrayPutElement (safearray, indices, &element);
5430 VariantClear (&element);
5431
5432 indices [0] = 0;
5433 indices [1] = 1;
5434 indices [2] = 0;
5435 element.vt = VT_BSTR;
5436 element.bstrVal = marshal_bstr_alloc("ABCDEFG");
5437 SafeArrayPutElement (safearray, indices, &element);
5438 VariantClear (&element);
5439
5440 return hr;
5441 }
5442
5443 LIBTEST_API int STDCALL
5444 mono_test_marshal_safearray_mixed(
5445 SAFEARRAY *safearray1,
5446 SAFEARRAY **safearray2,
5447 SAFEARRAY *safearray3,
5448 SAFEARRAY **safearray4
5449 )
5450 {
5451 HRESULT hr = S_OK;
5452
5453 /* Initialize out parameters */
5454 *safearray2 = NULL;
5455
5456 /* array1: Check that in array is one dimensional and contains the expected value */
5457 hr = mono_test_marshal_safearray_in_out_byval_1dim_vt_i4 (safearray1);
5458
5459 /* array2: Fill in with some values to check on the managed side */
5460 if (hr == S_OK)
5461 hr = mono_test_marshal_safearray_out_1dim_vt_bstr (safearray2);
5462
5463 /* array3: Check that in array is one dimensional and contains the expected value */
5464 if (hr == S_OK)
5465 hr = mono_test_marshal_safearray_in_byval_1dim_vt_mixed(safearray3);
5466
5467 /* array4: Check input values and fill in with some values to check on the managed side */
5468 if (hr == S_OK)
5469 hr = mono_test_marshal_safearray_in_out_byref_3dim_vt_bstr(safearray4);
5470
5471 return hr;
5472 }
5473
5474 #endif
5475
5476 static int call_managed_res;
5477
5478 static void
5479 call_managed (gpointer arg)
5480 {
5481 SimpleDelegate del = (SimpleDelegate)arg;
5482
5483 call_managed_res = del (42);
5484 }
5485
5486 LIBTEST_API int STDCALL
5487 mono_test_marshal_thread_attach (SimpleDelegate del)
5488 {
5489 #ifdef WIN32
5490 return 43;
5491 #else
5492 int res;
5493 pthread_t t;
5494
5495 res = pthread_create (&t, NULL, (gpointer (*)(gpointer))call_managed, del);
5496 g_assert (res == 0);
5497 pthread_join (t, NULL);
5498
5499 return call_managed_res;
5500 #endif
5501 }
5502
5503 typedef struct {
5504 char arr [4 * 1024];
5505 } LargeStruct;
5506
5507 typedef int (STDCALL *LargeStructDelegate) (LargeStruct *s);
5508
5509 static void
5510 call_managed_large_vt (gpointer arg)
5511 {
5512 LargeStructDelegate del = (LargeStructDelegate)arg;
5513 LargeStruct s;
5514
5515 call_managed_res = del (&s);
5516 }
5517
5518 LIBTEST_API int STDCALL
5519 mono_test_marshal_thread_attach_large_vt (SimpleDelegate del)
5520 {
5521 #ifdef WIN32
5522 return 43;
5523 #else
5524 int res;
5525 pthread_t t;
5526
5527 res = pthread_create (&t, NULL, (gpointer (*)(gpointer))call_managed_large_vt, del);
5528 g_assert (res == 0);
5529 pthread_join (t, NULL);
5530
5531 return call_managed_res;
5532 #endif
5533 }
5534
5535 typedef int (STDCALL *Callback) (void);
5536
5537 static Callback callback;
5538
5539 LIBTEST_API void STDCALL
5540 mono_test_marshal_set_callback (Callback cb)
5541 {
5542 callback = cb;
5543 }
5544
5545 LIBTEST_API int STDCALL
5546 mono_test_marshal_call_callback (void)
5547 {
5548 return callback ();
5549 }
5550
5551 LIBTEST_API int STDCALL
5552 mono_test_marshal_lpstr (char *str)
5553 {
5554 return strcmp ("ABC", str);
5555 }
5556
5557 LIBTEST_API int STDCALL
5558 mono_test_marshal_lpwstr (gunichar2 *str)
5559 {
5560 char *s;
5561 int res;
5562
5563 s = g_utf16_to_utf8 (str, -1, NULL, NULL, NULL);
5564 res = strcmp ("ABC", s);
5565 g_free (s);
5566
5567 return res;
5568 }
5569
5570 LIBTEST_API char* STDCALL
5571 mono_test_marshal_return_lpstr (void)
5572 {
5573 char *res = (char *)marshal_alloc (4);
5574 strcpy (res, "XYZ");
5575 return res;
5576 }
5577
5578
5579 LIBTEST_API gunichar2* STDCALL
5580 mono_test_marshal_return_lpwstr (void)
5581 {
5582 gunichar2 *res = (gunichar2 *)marshal_alloc (8);
5583 gunichar2* tmp = g_utf8_to_utf16 ("XYZ", -1, NULL, NULL, NULL);
5584
5585 memcpy (res, tmp, 8);
5586 g_free (tmp);
5587
5588 return res;
5589 }
5590
5591 typedef struct {
5592 double d;
5593 } SingleDoubleStruct;
5594
5595 LIBTEST_API SingleDoubleStruct STDCALL
5596 mono_test_marshal_return_single_double_struct (void)
5597 {
5598 SingleDoubleStruct res;
5599
5600 res.d = 3.0;
5601
5602 return res;
5603 }
5604
5605
5606 #ifndef TARGET_X86
5607
5608 LIBTEST_API int STDCALL
5609 mono_test_has_thiscall (void)
5610 {
5611 return 1;
5612 }
5613
5614 LIBTEST_API int
5615 _mono_test_native_thiscall1 (int arg)
5616 {
5617 return arg;
5618 }
5619
5620 LIBTEST_API int
5621 _mono_test_native_thiscall2 (int arg, int arg2)
5622 {
5623 return arg + (arg2^1);
5624 }
5625
5626 LIBTEST_API int
5627 _mono_test_native_thiscall3 (int arg, int arg2, int arg3)
5628 {
5629 return arg + (arg2^1) + (arg3^2);
5630 }
5631
5632 #elif defined(__GNUC__)
5633
5634 LIBTEST_API int STDCALL
5635 mono_test_has_thiscall (void)
5636 {
5637 return 1;
5638 }
5639
5640 #define def_asm_fn(name) \
5641 "\t.align 4\n" \
5642 "\t.globl _" #name "\n" \
5643 "_" #name ":\n" \
5644 "\t.globl __" #name "\n" \
5645 "__" #name ":\n"
5646
5647 asm(".text\n"
5648
5649 def_asm_fn(mono_test_native_thiscall1)
5650 "\tmovl %ecx,%eax\n"
5651 "\tret\n"
5652
5653 def_asm_fn(mono_test_native_thiscall2)
5654 "\tmovl %ecx,%eax\n"
5655 "\tmovl 4(%esp),%ecx\n"
5656 "\txorl $1,%ecx\n"
5657 "\taddl %ecx,%eax\n"
5658 "\tret $4\n"
5659
5660 def_asm_fn(mono_test_native_thiscall3)
5661 "\tmovl %ecx,%eax\n"
5662 "\tmovl 4(%esp),%ecx\n"
5663 "\txorl $1,%ecx\n"
5664 "\taddl %ecx,%eax\n"
5665 "\tmovl 8(%esp),%ecx\n"
5666 "\txorl $2,%ecx\n"
5667 "\taddl %ecx,%eax\n"
5668 "\tret $8\n"
5669
5670 );
5671
5672 #else
5673
5674 LIBTEST_API int STDCALL
5675 mono_test_has_thiscall (void)
5676 {
5677 return 0;
5678 }
5679
5680 #endif
5681
5682
5683 typedef struct {
5684 char f1;
5685 } sbyte1;
5686
5687 LIBTEST_API sbyte1 STDCALL
5688 mono_return_sbyte1 (sbyte1 s1, int addend) {
5689 if (s1.f1 != 1) {
5690 fprintf(stderr, "mono_return_sbyte1 s1.f1: got %d but expected %d\n", s1.f1, 1);
5691 }
5692 s1.f1+=addend;
5693 return s1;
5694 }
5695
5696 typedef struct {
5697 char f1,f2;
5698 } sbyte2;
5699
5700 LIBTEST_API sbyte2 STDCALL
5701 mono_return_sbyte2 (sbyte2 s2, int addend) {
5702 if (s2.f1 != 1) {
5703 fprintf(stderr, "mono_return_sbyte2 s2.f1: got %d but expected %d\n", s2.f1, 1);
5704 }
5705 if (s2.f2 != 2) {
5706 fprintf(stderr, "mono_return_sbyte2 s2.f2: got %d but expected %d\n", s2.f2, 2);
5707 }
5708 s2.f1+=addend; s2.f2+=addend;
5709 return s2;
5710 }
5711
5712 typedef struct {
5713 char f1,f2,f3;
5714 } sbyte3;
5715
5716 LIBTEST_API sbyte3 STDCALL
5717 mono_return_sbyte3 (sbyte3 s3, int addend) {
5718 if (s3.f1 != 1) {
5719 fprintf(stderr, "mono_return_sbyte3 s3.f1: got %d but expected %d\n", s3.f1, 1);
5720 }
5721 if (s3.f2 != 2) {
5722 fprintf(stderr, "mono_return_sbyte3 s3.f2: got %d but expected %d\n", s3.f2, 2);
5723 }
5724 if (s3.f3 != 3) {
5725 fprintf(stderr, "mono_return_sbyte3 s3.f3: got %d but expected %d\n", s3.f3, 3);
5726 }
5727 s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
5728 return s3;
5729 }
5730
5731 typedef struct {
5732 char f1,f2,f3,f4;
5733 } sbyte4;
5734
5735 LIBTEST_API sbyte4 STDCALL
5736 mono_return_sbyte4 (sbyte4 s4, int addend) {
5737 if (s4.f1 != 1) {
5738 fprintf(stderr, "mono_return_sbyte4 s4.f1: got %d but expected %d\n", s4.f1, 1);
5739 }
5740 if (s4.f2 != 2) {
5741 fprintf(stderr, "mono_return_sbyte4 s4.f2: got %d but expected %d\n", s4.f2, 2);
5742 }
5743 if (s4.f3 != 3) {
5744 fprintf(stderr, "mono_return_sbyte4 s4.f3: got %d but expected %d\n", s4.f3, 3);
5745 }
5746 if (s4.f4 != 4) {
5747 fprintf(stderr, "mono_return_sbyte4 s4.f4: got %d but expected %d\n", s4.f4, 4);
5748 }
5749 s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
5750 return s4;
5751 }
5752
5753 typedef struct {
5754 char f1,f2,f3,f4,f5;
5755 } sbyte5;
5756
5757 LIBTEST_API sbyte5 STDCALL
5758 mono_return_sbyte5 (sbyte5 s5, int addend) {
5759 if (s5.f1 != 1) {
5760 fprintf(stderr, "mono_return_sbyte5 s5.f1: got %d but expected %d\n", s5.f1, 1);
5761 }
5762 if (s5.f2 != 2) {
5763 fprintf(stderr, "mono_return_sbyte5 s5.f2: got %d but expected %d\n", s5.f2, 2);
5764 }
5765 if (s5.f3 != 3) {
5766 fprintf(stderr, "mono_return_sbyte5 s5.f3: got %d but expected %d\n", s5.f3, 3);
5767 }
5768 if (s5.f4 != 4) {
5769 fprintf(stderr, "mono_return_sbyte5 s5.f4: got %d but expected %d\n", s5.f4, 4);
5770 }
5771 if (s5.f5 != 5) {
5772 fprintf(stderr, "mono_return_sbyte5 s5.f5: got %d but expected %d\n", s5.f5, 5);
5773 }
5774 s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
5775 return s5;
5776 }
5777
5778 typedef struct {
5779 char f1,f2,f3,f4,f5,f6;
5780 } sbyte6;
5781
5782 LIBTEST_API sbyte6 STDCALL
5783 mono_return_sbyte6 (sbyte6 s6, int addend) {
5784 if (s6.f1 != 1) {
5785 fprintf(stderr, "mono_return_sbyte6 s6.f1: got %d but expected %d\n", s6.f1, 1);
5786 }
5787 if (s6.f2 != 2) {
5788 fprintf(stderr, "mono_return_sbyte6 s6.f2: got %d but expected %d\n", s6.f2, 2);
5789 }
5790 if (s6.f3 != 3) {
5791 fprintf(stderr, "mono_return_sbyte6 s6.f3: got %d but expected %d\n", s6.f3, 3);
5792 }
5793 if (s6.f4 != 4) {
5794 fprintf(stderr, "mono_return_sbyte6 s6.f4: got %d but expected %d\n", s6.f4, 4);
5795 }
5796 if (s6.f5 != 5) {
5797 fprintf(stderr, "mono_return_sbyte6 s6.f5: got %d but expected %d\n", s6.f5, 5);
5798 }
5799 if (s6.f6 != 6) {
5800 fprintf(stderr, "mono_return_sbyte6 s6.f6: got %d but expected %d\n", s6.f6, 6);
5801 }
5802 s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
5803 return s6;
5804 }
5805
5806 typedef struct {
5807 char f1,f2,f3,f4,f5,f6,f7;
5808 } sbyte7;
5809
5810 LIBTEST_API sbyte7 STDCALL
5811 mono_return_sbyte7 (sbyte7 s7, int addend) {
5812 if (s7.f1 != 1) {
5813 fprintf(stderr, "mono_return_sbyte7 s7.f1: got %d but expected %d\n", s7.f1, 1);
5814 }
5815 if (s7.f2 != 2) {
5816 fprintf(stderr, "mono_return_sbyte7 s7.f2: got %d but expected %d\n", s7.f2, 2);
5817 }
5818 if (s7.f3 != 3) {
5819 fprintf(stderr, "mono_return_sbyte7 s7.f3: got %d but expected %d\n", s7.f3, 3);
5820 }
5821 if (s7.f4 != 4) {
5822 fprintf(stderr, "mono_return_sbyte7 s7.f4: got %d but expected %d\n", s7.f4, 4);
5823 }
5824 if (s7.f5 != 5) {
5825 fprintf(stderr, "mono_return_sbyte7 s7.f5: got %d but expected %d\n", s7.f5, 5);
5826 }
5827 if (s7.f6 != 6) {
5828 fprintf(stderr, "mono_return_sbyte7 s7.f6: got %d but expected %d\n", s7.f6, 6);
5829 }
5830 if (s7.f7 != 7) {
5831 fprintf(stderr, "mono_return_sbyte7 s7.f7: got %d but expected %d\n", s7.f7, 7);
5832 }
5833 s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
5834 return s7;
5835 }
5836
5837 typedef struct {
5838 char f1,f2,f3,f4,f5,f6,f7,f8;
5839 } sbyte8;
5840
5841 LIBTEST_API sbyte8 STDCALL
5842 mono_return_sbyte8 (sbyte8 s8, int addend) {
5843 if (s8.f1 != 1) {
5844 fprintf(stderr, "mono_return_sbyte8 s8.f1: got %d but expected %d\n", s8.f1, 1);
5845 }
5846 if (s8.f2 != 2) {
5847 fprintf(stderr, "mono_return_sbyte8 s8.f2: got %d but expected %d\n", s8.f2, 2);
5848 }
5849 if (s8.f3 != 3) {
5850 fprintf(stderr, "mono_return_sbyte8 s8.f3: got %d but expected %d\n", s8.f3, 3);
5851 }
5852 if (s8.f4 != 4) {
5853 fprintf(stderr, "mono_return_sbyte8 s8.f4: got %d but expected %d\n", s8.f4, 4);
5854 }
5855 if (s8.f5 != 5) {
5856 fprintf(stderr, "mono_return_sbyte8 s8.f5: got %d but expected %d\n", s8.f5, 5);
5857 }
5858 if (s8.f6 != 6) {
5859 fprintf(stderr, "mono_return_sbyte8 s8.f6: got %d but expected %d\n", s8.f6, 6);
5860 }
5861 if (s8.f7 != 7) {
5862 fprintf(stderr, "mono_return_sbyte8 s8.f7: got %d but expected %d\n", s8.f7, 7);
5863 }
5864 if (s8.f8 != 8) {
5865 fprintf(stderr, "mono_return_sbyte8 s8.f8: got %d but expected %d\n", s8.f8, 8);
5866 }
5867 s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
5868 return s8;
5869 }
5870
5871 typedef struct {
5872 char f1,f2,f3,f4,f5,f6,f7,f8,f9;
5873 } sbyte9;
5874
5875 LIBTEST_API sbyte9 STDCALL
5876 mono_return_sbyte9 (sbyte9 s9, int addend) {
5877 if (s9.f1 != 1) {
5878 fprintf(stderr, "mono_return_sbyte9 s9.f1: got %d but expected %d\n", s9.f1, 1);
5879 }
5880 if (s9.f2 != 2) {
5881 fprintf(stderr, "mono_return_sbyte9 s9.f2: got %d but expected %d\n", s9.f2, 2);
5882 }
5883 if (s9.f3 != 3) {
5884 fprintf(stderr, "mono_return_sbyte9 s9.f3: got %d but expected %d\n", s9.f3, 3);
5885 }
5886 if (s9.f4 != 4) {
5887 fprintf(stderr, "mono_return_sbyte9 s9.f4: got %d but expected %d\n", s9.f4, 4);
5888 }
5889 if (s9.f5 != 5) {
5890 fprintf(stderr, "mono_return_sbyte9 s9.f5: got %d but expected %d\n", s9.f5, 5);
5891 }
5892 if (s9.f6 != 6) {
5893 fprintf(stderr, "mono_return_sbyte9 s9.f6: got %d but expected %d\n", s9.f6, 6);
5894 }
5895 if (s9.f7 != 7) {
5896 fprintf(stderr, "mono_return_sbyte9 s9.f7: got %d but expected %d\n", s9.f7, 7);
5897 }
5898 if (s9.f8 != 8) {
5899 fprintf(stderr, "mono_return_sbyte9 s9.f8: got %d but expected %d\n", s9.f8, 8);
5900 }
5901 if (s9.f9 != 9) {
5902 fprintf(stderr, "mono_return_sbyte9 s9.f9: got %d but expected %d\n", s9.f9, 9);
5903 }
5904 s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
5905 return s9;
5906 }
5907
5908 typedef struct {
5909 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10;
5910 } sbyte10;
5911
5912 LIBTEST_API sbyte10 STDCALL
5913 mono_return_sbyte10 (sbyte10 s10, int addend) {
5914 if (s10.f1 != 1) {
5915 fprintf(stderr, "mono_return_sbyte10 s10.f1: got %d but expected %d\n", s10.f1, 1);
5916 }
5917 if (s10.f2 != 2) {
5918 fprintf(stderr, "mono_return_sbyte10 s10.f2: got %d but expected %d\n", s10.f2, 2);
5919 }
5920 if (s10.f3 != 3) {
5921 fprintf(stderr, "mono_return_sbyte10 s10.f3: got %d but expected %d\n", s10.f3, 3);
5922 }
5923 if (s10.f4 != 4) {
5924 fprintf(stderr, "mono_return_sbyte10 s10.f4: got %d but expected %d\n", s10.f4, 4);
5925 }
5926 if (s10.f5 != 5) {
5927 fprintf(stderr, "mono_return_sbyte10 s10.f5: got %d but expected %d\n", s10.f5, 5);
5928 }
5929 if (s10.f6 != 6) {
5930 fprintf(stderr, "mono_return_sbyte10 s10.f6: got %d but expected %d\n", s10.f6, 6);
5931 }
5932 if (s10.f7 != 7) {
5933 fprintf(stderr, "mono_return_sbyte10 s10.f7: got %d but expected %d\n", s10.f7, 7);
5934 }
5935 if (s10.f8 != 8) {
5936 fprintf(stderr, "mono_return_sbyte10 s10.f8: got %d but expected %d\n", s10.f8, 8);
5937 }
5938 if (s10.f9 != 9) {
5939 fprintf(stderr, "mono_return_sbyte10 s10.f9: got %d but expected %d\n", s10.f9, 9);
5940 }
5941 if (s10.f10 != 10) {
5942 fprintf(stderr, "mono_return_sbyte10 s10.f10: got %d but expected %d\n", s10.f10, 10);
5943 }
5944 s10.f1+=addend; s10.f2+=addend; s10.f3+=addend; s10.f4+=addend; s10.f5+=addend; s10.f6+=addend; s10.f7+=addend; s10.f8+=addend; s10.f9+=addend; s10.f10+=addend;
5945 return s10;
5946 }
5947
5948 typedef struct {
5949 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11;
5950 } sbyte11;
5951
5952 LIBTEST_API sbyte11 STDCALL
5953 mono_return_sbyte11 (sbyte11 s11, int addend) {
5954 if (s11.f1 != 1) {
5955 fprintf(stderr, "mono_return_sbyte11 s11.f1: got %d but expected %d\n", s11.f1, 1);
5956 }
5957 if (s11.f2 != 2) {
5958 fprintf(stderr, "mono_return_sbyte11 s11.f2: got %d but expected %d\n", s11.f2, 2);
5959 }
5960 if (s11.f3 != 3) {
5961 fprintf(stderr, "mono_return_sbyte11 s11.f3: got %d but expected %d\n", s11.f3, 3);
5962 }
5963 if (s11.f4 != 4) {
5964 fprintf(stderr, "mono_return_sbyte11 s11.f4: got %d but expected %d\n", s11.f4, 4);
5965 }
5966 if (s11.f5 != 5) {
5967 fprintf(stderr, "mono_return_sbyte11 s11.f5: got %d but expected %d\n", s11.f5, 5);
5968 }
5969 if (s11.f6 != 6) {
5970 fprintf(stderr, "mono_return_sbyte11 s11.f6: got %d but expected %d\n", s11.f6, 6);
5971 }
5972 if (s11.f7 != 7) {
5973 fprintf(stderr, "mono_return_sbyte11 s11.f7: got %d but expected %d\n", s11.f7, 7);
5974 }
5975 if (s11.f8 != 8) {
5976 fprintf(stderr, "mono_return_sbyte11 s11.f8: got %d but expected %d\n", s11.f8, 8);
5977 }
5978 if (s11.f9 != 9) {
5979 fprintf(stderr, "mono_return_sbyte11 s11.f9: got %d but expected %d\n", s11.f9, 9);
5980 }
5981 if (s11.f10 != 10) {
5982 fprintf(stderr, "mono_return_sbyte11 s11.f10: got %d but expected %d\n", s11.f10, 10);
5983 }
5984 if (s11.f11 != 11) {
5985 fprintf(stderr, "mono_return_sbyte11 s11.f11: got %d but expected %d\n", s11.f11, 11);
5986 }
5987 s11.f1+=addend; s11.f2+=addend; s11.f3+=addend; s11.f4+=addend; s11.f5+=addend; s11.f6+=addend; s11.f7+=addend; s11.f8+=addend; s11.f9+=addend; s11.f10+=addend; s11.f11+=addend;
5988 return s11;
5989 }
5990
5991 typedef struct {
5992 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12;
5993 } sbyte12;
5994
5995 LIBTEST_API sbyte12 STDCALL
5996 mono_return_sbyte12 (sbyte12 s12, int addend) {
5997 if (s12.f1 != 1) {
5998 fprintf(stderr, "mono_return_sbyte12 s12.f1: got %d but expected %d\n", s12.f1, 1);
5999 }
6000 if (s12.f2 != 2) {
6001 fprintf(stderr, "mono_return_sbyte12 s12.f2: got %d but expected %d\n", s12.f2, 2);
6002 }
6003 if (s12.f3 != 3) {
6004 fprintf(stderr, "mono_return_sbyte12 s12.f3: got %d but expected %d\n", s12.f3, 3);
6005 }
6006 if (s12.f4 != 4) {
6007 fprintf(stderr, "mono_return_sbyte12 s12.f4: got %d but expected %d\n", s12.f4, 4);
6008 }
6009 if (s12.f5 != 5) {
6010 fprintf(stderr, "mono_return_sbyte12 s12.f5: got %d but expected %d\n", s12.f5, 5);
6011 }
6012 if (s12.f6 != 6) {
6013 fprintf(stderr, "mono_return_sbyte12 s12.f6: got %d but expected %d\n", s12.f6, 6);
6014 }
6015 if (s12.f7 != 7) {
6016 fprintf(stderr, "mono_return_sbyte12 s12.f7: got %d but expected %d\n", s12.f7, 7);
6017 }
6018 if (s12.f8 != 8) {
6019 fprintf(stderr, "mono_return_sbyte12 s12.f8: got %d but expected %d\n", s12.f8, 8);
6020 }
6021 if (s12.f9 != 9) {
6022 fprintf(stderr, "mono_return_sbyte12 s12.f9: got %d but expected %d\n", s12.f9, 9);
6023 }
6024 if (s12.f10 != 10) {
6025 fprintf(stderr, "mono_return_sbyte12 s12.f10: got %d but expected %d\n", s12.f10, 10);
6026 }
6027 if (s12.f11 != 11) {
6028 fprintf(stderr, "mono_return_sbyte12 s12.f11: got %d but expected %d\n", s12.f11, 11);
6029 }
6030 if (s12.f12 != 12) {
6031 fprintf(stderr, "mono_return_sbyte12 s12.f12: got %d but expected %d\n", s12.f12, 12);
6032 }
6033 s12.f1+=addend; s12.f2+=addend; s12.f3+=addend; s12.f4+=addend; s12.f5+=addend; s12.f6+=addend; s12.f7+=addend; s12.f8+=addend; s12.f9+=addend; s12.f10+=addend; s12.f11+=addend; s12.f12+=addend;
6034 return s12;
6035 }
6036
6037 typedef struct {
6038 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13;
6039 } sbyte13;
6040
6041 LIBTEST_API sbyte13 STDCALL
6042 mono_return_sbyte13 (sbyte13 s13, int addend) {
6043 if (s13.f1 != 1) {
6044 fprintf(stderr, "mono_return_sbyte13 s13.f1: got %d but expected %d\n", s13.f1, 1);
6045 }
6046 if (s13.f2 != 2) {
6047 fprintf(stderr, "mono_return_sbyte13 s13.f2: got %d but expected %d\n", s13.f2, 2);
6048 }
6049 if (s13.f3 != 3) {
6050 fprintf(stderr, "mono_return_sbyte13 s13.f3: got %d but expected %d\n", s13.f3, 3);
6051 }
6052 if (s13.f4 != 4) {
6053 fprintf(stderr, "mono_return_sbyte13 s13.f4: got %d but expected %d\n", s13.f4, 4);
6054 }
6055 if (s13.f5 != 5) {
6056 fprintf(stderr, "mono_return_sbyte13 s13.f5: got %d but expected %d\n", s13.f5, 5);
6057 }
6058 if (s13.f6 != 6) {
6059 fprintf(stderr, "mono_return_sbyte13 s13.f6: got %d but expected %d\n", s13.f6, 6);
6060 }
6061 if (s13.f7 != 7) {
6062 fprintf(stderr, "mono_return_sbyte13 s13.f7: got %d but expected %d\n", s13.f7, 7);
6063 }
6064 if (s13.f8 != 8) {
6065 fprintf(stderr, "mono_return_sbyte13 s13.f8: got %d but expected %d\n", s13.f8, 8);
6066 }
6067 if (s13.f9 != 9) {
6068 fprintf(stderr, "mono_return_sbyte13 s13.f9: got %d but expected %d\n", s13.f9, 9);
6069 }
6070 if (s13.f10 != 10) {
6071 fprintf(stderr, "mono_return_sbyte13 s13.f10: got %d but expected %d\n", s13.f10, 10);
6072 }
6073 if (s13.f11 != 11) {
6074 fprintf(stderr, "mono_return_sbyte13 s13.f11: got %d but expected %d\n", s13.f11, 11);
6075 }
6076 if (s13.f12 != 12) {
6077 fprintf(stderr, "mono_return_sbyte13 s13.f12: got %d but expected %d\n", s13.f12, 12);
6078 }
6079 if (s13.f13 != 13) {
6080 fprintf(stderr, "mono_return_sbyte13 s13.f13: got %d but expected %d\n", s13.f13, 13);
6081 }
6082 s13.f1+=addend; s13.f2+=addend; s13.f3+=addend; s13.f4+=addend; s13.f5+=addend; s13.f6+=addend; s13.f7+=addend; s13.f8+=addend; s13.f9+=addend; s13.f10+=addend; s13.f11+=addend; s13.f12+=addend; s13.f13+=addend;
6083 return s13;
6084 }
6085
6086 typedef struct {
6087 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14;
6088 } sbyte14;
6089
6090 LIBTEST_API sbyte14 STDCALL
6091 mono_return_sbyte14 (sbyte14 s14, int addend) {
6092 if (s14.f1 != 1) {
6093 fprintf(stderr, "mono_return_sbyte14 s14.f1: got %d but expected %d\n", s14.f1, 1);
6094 }
6095 if (s14.f2 != 2) {
6096 fprintf(stderr, "mono_return_sbyte14 s14.f2: got %d but expected %d\n", s14.f2, 2);
6097 }
6098 if (s14.f3 != 3) {
6099 fprintf(stderr, "mono_return_sbyte14 s14.f3: got %d but expected %d\n", s14.f3, 3);
6100 }
6101 if (s14.f4 != 4) {
6102 fprintf(stderr, "mono_return_sbyte14 s14.f4: got %d but expected %d\n", s14.f4, 4);
6103 }
6104 if (s14.f5 != 5) {
6105 fprintf(stderr, "mono_return_sbyte14 s14.f5: got %d but expected %d\n", s14.f5, 5);
6106 }
6107 if (s14.f6 != 6) {
6108 fprintf(stderr, "mono_return_sbyte14 s14.f6: got %d but expected %d\n", s14.f6, 6);
6109 }
6110 if (s14.f7 != 7) {
6111 fprintf(stderr, "mono_return_sbyte14 s14.f7: got %d but expected %d\n", s14.f7, 7);
6112 }
6113 if (s14.f8 != 8) {
6114 fprintf(stderr, "mono_return_sbyte14 s14.f8: got %d but expected %d\n", s14.f8, 8);
6115 }
6116 if (s14.f9 != 9) {
6117 fprintf(stderr, "mono_return_sbyte14 s14.f9: got %d but expected %d\n", s14.f9, 9);
6118 }
6119 if (s14.f10 != 10) {
6120 fprintf(stderr, "mono_return_sbyte14 s14.f10: got %d but expected %d\n", s14.f10, 10);
6121 }
6122 if (s14.f11 != 11) {
6123 fprintf(stderr, "mono_return_sbyte14 s14.f11: got %d but expected %d\n", s14.f11, 11);
6124 }
6125 if (s14.f12 != 12) {
6126 fprintf(stderr, "mono_return_sbyte14 s14.f12: got %d but expected %d\n", s14.f12, 12);
6127 }
6128 if (s14.f13 != 13) {
6129 fprintf(stderr, "mono_return_sbyte14 s14.f13: got %d but expected %d\n", s14.f13, 13);
6130 }
6131 if (s14.f14 != 14) {
6132 fprintf(stderr, "mono_return_sbyte14 s14.f14: got %d but expected %d\n", s14.f14, 14);
6133 }
6134 s14.f1+=addend; s14.f2+=addend; s14.f3+=addend; s14.f4+=addend; s14.f5+=addend; s14.f6+=addend; s14.f7+=addend; s14.f8+=addend; s14.f9+=addend; s14.f10+=addend; s14.f11+=addend; s14.f12+=addend; s14.f13+=addend; s14.f14+=addend;
6135 return s14;
6136 }
6137
6138 typedef struct {
6139 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15;
6140 } sbyte15;
6141
6142 LIBTEST_API sbyte15 STDCALL
6143 mono_return_sbyte15 (sbyte15 s15, int addend) {
6144 if (s15.f1 != 1) {
6145 fprintf(stderr, "mono_return_sbyte15 s15.f1: got %d but expected %d\n", s15.f1, 1);
6146 }
6147 if (s15.f2 != 2) {
6148 fprintf(stderr, "mono_return_sbyte15 s15.f2: got %d but expected %d\n", s15.f2, 2);
6149 }
6150 if (s15.f3 != 3) {
6151 fprintf(stderr, "mono_return_sbyte15 s15.f3: got %d but expected %d\n", s15.f3, 3);
6152 }
6153 if (s15.f4 != 4) {
6154 fprintf(stderr, "mono_return_sbyte15 s15.f4: got %d but expected %d\n", s15.f4, 4);
6155 }
6156 if (s15.f5 != 5) {
6157 fprintf(stderr, "mono_return_sbyte15 s15.f5: got %d but expected %d\n", s15.f5, 5);
6158 }
6159 if (s15.f6 != 6) {
6160 fprintf(stderr, "mono_return_sbyte15 s15.f6: got %d but expected %d\n", s15.f6, 6);
6161 }
6162 if (s15.f7 != 7) {
6163 fprintf(stderr, "mono_return_sbyte15 s15.f7: got %d but expected %d\n", s15.f7, 7);
6164 }
6165 if (s15.f8 != 8) {
6166 fprintf(stderr, "mono_return_sbyte15 s15.f8: got %d but expected %d\n", s15.f8, 8);
6167 }
6168 if (s15.f9 != 9) {
6169 fprintf(stderr, "mono_return_sbyte15 s15.f9: got %d but expected %d\n", s15.f9, 9);
6170 }
6171 if (s15.f10 != 10) {
6172 fprintf(stderr, "mono_return_sbyte15 s15.f10: got %d but expected %d\n", s15.f10, 10);
6173 }
6174 if (s15.f11 != 11) {
6175 fprintf(stderr, "mono_return_sbyte15 s15.f11: got %d but expected %d\n", s15.f11, 11);
6176 }
6177 if (s15.f12 != 12) {
6178 fprintf(stderr, "mono_return_sbyte15 s15.f12: got %d but expected %d\n", s15.f12, 12);
6179 }
6180 if (s15.f13 != 13) {
6181 fprintf(stderr, "mono_return_sbyte15 s15.f13: got %d but expected %d\n", s15.f13, 13);
6182 }
6183 if (s15.f14 != 14) {
6184 fprintf(stderr, "mono_return_sbyte15 s15.f14: got %d but expected %d\n", s15.f14, 14);
6185 }
6186 if (s15.f15 != 15) {
6187 fprintf(stderr, "mono_return_sbyte15 s15.f15: got %d but expected %d\n", s15.f15, 15);
6188 }
6189 s15.f1+=addend; s15.f2+=addend; s15.f3+=addend; s15.f4+=addend; s15.f5+=addend; s15.f6+=addend; s15.f7+=addend; s15.f8+=addend; s15.f9+=addend; s15.f10+=addend; s15.f11+=addend; s15.f12+=addend; s15.f13+=addend; s15.f14+=addend; s15.f15+=addend;
6190 return s15;
6191 }
6192
6193 typedef struct {
6194 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16;
6195 } sbyte16;
6196
6197 LIBTEST_API sbyte16 STDCALL
6198 mono_return_sbyte16 (sbyte16 s16, int addend) {
6199 if (s16.f1 != 1) {
6200 fprintf(stderr, "mono_return_sbyte16 s16.f1: got %d but expected %d\n", s16.f1, 1);
6201 }
6202 if (s16.f2 != 2) {
6203 fprintf(stderr, "mono_return_sbyte16 s16.f2: got %d but expected %d\n", s16.f2, 2);
6204 }
6205 if (s16.f3 != 3) {
6206 fprintf(stderr, "mono_return_sbyte16 s16.f3: got %d but expected %d\n", s16.f3, 3);
6207 }
6208 if (s16.f4 != 4) {
6209 fprintf(stderr, "mono_return_sbyte16 s16.f4: got %d but expected %d\n", s16.f4, 4);
6210 }
6211 if (s16.f5 != 5) {
6212 fprintf(stderr, "mono_return_sbyte16 s16.f5: got %d but expected %d\n", s16.f5, 5);
6213 }
6214 if (s16.f6 != 6) {
6215 fprintf(stderr, "mono_return_sbyte16 s16.f6: got %d but expected %d\n", s16.f6, 6);
6216 }
6217 if (s16.f7 != 7) {
6218 fprintf(stderr, "mono_return_sbyte16 s16.f7: got %d but expected %d\n", s16.f7, 7);
6219 }
6220 if (s16.f8 != 8) {
6221 fprintf(stderr, "mono_return_sbyte16 s16.f8: got %d but expected %d\n", s16.f8, 8);
6222 }
6223 if (s16.f9 != 9) {
6224 fprintf(stderr, "mono_return_sbyte16 s16.f9: got %d but expected %d\n", s16.f9, 9);
6225 }
6226 if (s16.f10 != 10) {
6227 fprintf(stderr, "mono_return_sbyte16 s16.f10: got %d but expected %d\n", s16.f10, 10);
6228 }
6229 if (s16.f11 != 11) {
6230 fprintf(stderr, "mono_return_sbyte16 s16.f11: got %d but expected %d\n", s16.f11, 11);
6231 }
6232 if (s16.f12 != 12) {
6233 fprintf(stderr, "mono_return_sbyte16 s16.f12: got %d but expected %d\n", s16.f12, 12);
6234 }
6235 if (s16.f13 != 13) {
6236 fprintf(stderr, "mono_return_sbyte16 s16.f13: got %d but expected %d\n", s16.f13, 13);
6237 }
6238 if (s16.f14 != 14) {
6239 fprintf(stderr, "mono_return_sbyte16 s16.f14: got %d but expected %d\n", s16.f14, 14);
6240 }
6241 if (s16.f15 != 15) {
6242 fprintf(stderr, "mono_return_sbyte16 s16.f15: got %d but expected %d\n", s16.f15, 15);
6243 }
6244 if (s16.f16 != 16) {
6245 fprintf(stderr, "mono_return_sbyte16 s16.f16: got %d but expected %d\n", s16.f16, 16);
6246 }
6247 s16.f1+=addend; s16.f2+=addend; s16.f3+=addend; s16.f4+=addend; s16.f5+=addend; s16.f6+=addend; s16.f7+=addend; s16.f8+=addend; s16.f9+=addend; s16.f10+=addend; s16.f11+=addend; s16.f12+=addend; s16.f13+=addend; s16.f14+=addend; s16.f15+=addend; s16.f16+=addend;
6248 return s16;
6249 }
6250
6251 typedef struct {
6252 char f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17;
6253 } sbyte17;
6254
6255 LIBTEST_API sbyte17 STDCALL
6256 mono_return_sbyte17 (sbyte17 s17, int addend) {
6257 if (s17.f1 != 1) {
6258 fprintf(stderr, "mono_return_sbyte17 s17.f1: got %d but expected %d\n", s17.f1, 1);
6259 }
6260 if (s17.f2 != 2) {
6261 fprintf(stderr, "mono_return_sbyte17 s17.f2: got %d but expected %d\n", s17.f2, 2);
6262 }
6263 if (s17.f3 != 3) {
6264 fprintf(stderr, "mono_return_sbyte17 s17.f3: got %d but expected %d\n", s17.f3, 3);
6265 }
6266 if (s17.f4 != 4) {
6267 fprintf(stderr, "mono_return_sbyte17 s17.f4: got %d but expected %d\n", s17.f4, 4);
6268 }
6269 if (s17.f5 != 5) {
6270 fprintf(stderr, "mono_return_sbyte17 s17.f5: got %d but expected %d\n", s17.f5, 5);
6271 }
6272 if (s17.f6 != 6) {
6273 fprintf(stderr, "mono_return_sbyte17 s17.f6: got %d but expected %d\n", s17.f6, 6);
6274 }
6275 if (s17.f7 != 7) {
6276 fprintf(stderr, "mono_return_sbyte17 s17.f7: got %d but expected %d\n", s17.f7, 7);
6277 }
6278 if (s17.f8 != 8) {
6279 fprintf(stderr, "mono_return_sbyte17 s17.f8: got %d but expected %d\n", s17.f8, 8);
6280 }
6281 if (s17.f9 != 9) {
6282 fprintf(stderr, "mono_return_sbyte17 s17.f9: got %d but expected %d\n", s17.f9, 9);
6283 }
6284 if (s17.f10 != 10) {
6285 fprintf(stderr, "mono_return_sbyte17 s17.f10: got %d but expected %d\n", s17.f10, 10);
6286 }
6287 if (s17.f11 != 11) {
6288 fprintf(stderr, "mono_return_sbyte17 s17.f11: got %d but expected %d\n", s17.f11, 11);
6289 }
6290 if (s17.f12 != 12) {
6291 fprintf(stderr, "mono_return_sbyte17 s17.f12: got %d but expected %d\n", s17.f12, 12);
6292 }
6293 if (s17.f13 != 13) {
6294 fprintf(stderr, "mono_return_sbyte17 s17.f13: got %d but expected %d\n", s17.f13, 13);
6295 }
6296 if (s17.f14 != 14) {
6297 fprintf(stderr, "mono_return_sbyte17 s17.f14: got %d but expected %d\n", s17.f14, 14);
6298 }
6299 if (s17.f15 != 15) {
6300 fprintf(stderr, "mono_return_sbyte17 s17.f15: got %d but expected %d\n", s17.f15, 15);
6301 }
6302 if (s17.f16 != 16) {
6303 fprintf(stderr, "mono_return_sbyte17 s17.f16: got %d but expected %d\n", s17.f16, 16);
6304 }
6305 if (s17.f17 != 17) {
6306 fprintf(stderr, "mono_return_sbyte17 s17.f17: got %d but expected %d\n", s17.f17, 17);
6307 }
6308 s17.f1+=addend; s17.f2+=addend; s17.f3+=addend; s17.f4+=addend; s17.f5+=addend; s17.f6+=addend; s17.f7+=addend; s17.f8+=addend; s17.f9+=addend; s17.f10+=addend; s17.f11+=addend; s17.f12+=addend; s17.f13+=addend; s17.f14+=addend; s17.f15+=addend; s17.f16+=addend; s17.f17+=addend;
6309 return s17;
6310 }
6311
6312 typedef struct {
6313 struct {
6314 char f1;
6315 } nested1;
6316 char f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15;
6317 struct {
6318 char f16;
6319 } nested2;
6320 } sbyte16_nested;
6321
6322 LIBTEST_API sbyte16_nested STDCALL
6323 mono_return_sbyte16_nested (sbyte16_nested sn16, int addend) {
6324 if (sn16.nested1.f1 != 1) {
6325 fprintf(stderr, "mono_return_sbyte16_nested sn16.nested1.f1: got %d but expected %d\n", sn16.nested1.f1, 1);
6326 }
6327 if (sn16.f2 != 2) {
6328 fprintf(stderr, "mono_return_sbyte16_nested sn16.f2: got %d but expected %d\n", sn16.f2, 2);
6329 }
6330 if (sn16.f3 != 3) {
6331 fprintf(stderr, "mono_return_sbyte16_nested sn16.f3: got %d but expected %d\n", sn16.f3, 3);
6332 }
6333 if (sn16.f4 != 4) {
6334 fprintf(stderr, "mono_return_sbyte16_nested sn16.f4: got %d but expected %d\n", sn16.f4, 4);
6335 }
6336 if (sn16.f5 != 5) {
6337 fprintf(stderr, "mono_return_sbyte16_nested sn16.f5: got %d but expected %d\n", sn16.f5, 5);
6338 }
6339 if (sn16.f6 != 6) {
6340 fprintf(stderr, "mono_return_sbyte16_nested sn16.f6: got %d but expected %d\n", sn16.f6, 6);
6341 }
6342 if (sn16.f7 != 7) {
6343 fprintf(stderr, "mono_return_sbyte16_nested sn16.f7: got %d but expected %d\n", sn16.f7, 7);
6344 }
6345 if (sn16.f8 != 8) {
6346 fprintf(stderr, "mono_return_sbyte16_nested sn16.f8: got %d but expected %d\n", sn16.f8, 8);
6347 }
6348 if (sn16.f9 != 9) {
6349 fprintf(stderr, "mono_return_sbyte16_nested sn16.f9: got %d but expected %d\n", sn16.f9, 9);
6350 }
6351 if (sn16.f10 != 10) {
6352 fprintf(stderr, "mono_return_sbyte16_nested sn16.f10: got %d but expected %d\n", sn16.f10, 10);
6353 }
6354 if (sn16.f11 != 11) {
6355 fprintf(stderr, "mono_return_sbyte16_nested sn16.f11: got %d but expected %d\n", sn16.f11, 11);
6356 }
6357 if (sn16.f12 != 12) {
6358 fprintf(stderr, "mono_return_sbyte16_nested sn16.f12: got %d but expected %d\n", sn16.f12, 12);
6359 }
6360 if (sn16.f13 != 13) {
6361 fprintf(stderr, "mono_return_sbyte16_nested sn16.f13: got %d but expected %d\n", sn16.f13, 13);
6362 }
6363 if (sn16.f14 != 14) {
6364 fprintf(stderr, "mono_return_sbyte16_nested sn16.f14: got %d but expected %d\n", sn16.f14, 14);
6365 }
6366 if (sn16.f15 != 15) {
6367 fprintf(stderr, "mono_return_sbyte16_nested sn16.f15: got %d but expected %d\n", sn16.f15, 15);
6368 }
6369 if (sn16.nested2.f16 != 16) {
6370 fprintf(stderr, "mono_return_sbyte16_nested sn16.nested2.f16: got %d but expected %d\n", sn16.nested2.f16, 16);
6371 }
6372 sn16.nested1.f1+=addend; sn16.f2+=addend; sn16.f3+=addend; sn16.f4+=addend; sn16.f5+=addend; sn16.f6+=addend; sn16.f7+=addend; sn16.f8+=addend; sn16.f9+=addend; sn16.f10+=addend; sn16.f11+=addend; sn16.f12+=addend; sn16.f13+=addend; sn16.f14+=addend; sn16.f15+=addend; sn16.nested2.f16+=addend;
6373 return sn16;
6374 }
6375
6376
6377 typedef struct {
6378 short f1;
6379 } short1;
6380
6381 LIBTEST_API short1 STDCALL
6382 mono_return_short1 (short1 s1, int addend) {
6383 if (s1.f1 != 1) {
6384 fprintf(stderr, "mono_return_short1 s1.f1: got %d but expected %d\n", s1.f1, 1);
6385 }
6386 s1.f1+=addend;
6387 return s1;
6388 }
6389
6390 typedef struct {
6391 short f1,f2;
6392 } short2;
6393
6394 LIBTEST_API short2 STDCALL
6395 mono_return_short2 (short2 s2, int addend) {
6396 if (s2.f1 != 1) {
6397 fprintf(stderr, "mono_return_short2 s2.f1: got %d but expected %d\n", s2.f1, 1);
6398 }
6399 if (s2.f2 != 2) {
6400 fprintf(stderr, "mono_return_short2 s2.f2: got %d but expected %d\n", s2.f2, 2);
6401 }
6402 s2.f1+=addend; s2.f2+=addend;
6403 return s2;
6404 }
6405
6406 typedef struct {
6407 short f1,f2,f3;
6408 } short3;
6409
6410 LIBTEST_API short3 STDCALL
6411 mono_return_short3 (short3 s3, int addend) {
6412 if (s3.f1 != 1) {
6413 fprintf(stderr, "mono_return_short3 s3.f1: got %d but expected %d\n", s3.f1, 1);
6414 }
6415 if (s3.f2 != 2) {
6416 fprintf(stderr, "mono_return_short3 s3.f2: got %d but expected %d\n", s3.f2, 2);
6417 }
6418 if (s3.f3 != 3) {
6419 fprintf(stderr, "mono_return_short3 s3.f3: got %d but expected %d\n", s3.f3, 3);
6420 }
6421 s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
6422 return s3;
6423 }
6424
6425 typedef struct {
6426 short f1,f2,f3,f4;
6427 } short4;
6428
6429 LIBTEST_API short4 STDCALL
6430 mono_return_short4 (short4 s4, int addend) {
6431 if (s4.f1 != 1) {
6432 fprintf(stderr, "mono_return_short4 s4.f1: got %d but expected %d\n", s4.f1, 1);
6433 }
6434 if (s4.f2 != 2) {
6435 fprintf(stderr, "mono_return_short4 s4.f2: got %d but expected %d\n", s4.f2, 2);
6436 }
6437 if (s4.f3 != 3) {
6438 fprintf(stderr, "mono_return_short4 s4.f3: got %d but expected %d\n", s4.f3, 3);
6439 }
6440 if (s4.f4 != 4) {
6441 fprintf(stderr, "mono_return_short4 s4.f4: got %d but expected %d\n", s4.f4, 4);
6442 }
6443 s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
6444 return s4;
6445 }
6446
6447 typedef struct {
6448 short f1,f2,f3,f4,f5;
6449 } short5;
6450
6451 LIBTEST_API short5 STDCALL
6452 mono_return_short5 (short5 s5, int addend) {
6453 if (s5.f1 != 1) {
6454 fprintf(stderr, "mono_return_short5 s5.f1: got %d but expected %d\n", s5.f1, 1);
6455 }
6456 if (s5.f2 != 2) {
6457 fprintf(stderr, "mono_return_short5 s5.f2: got %d but expected %d\n", s5.f2, 2);
6458 }
6459 if (s5.f3 != 3) {
6460 fprintf(stderr, "mono_return_short5 s5.f3: got %d but expected %d\n", s5.f3, 3);
6461 }
6462 if (s5.f4 != 4) {
6463 fprintf(stderr, "mono_return_short5 s5.f4: got %d but expected %d\n", s5.f4, 4);
6464 }
6465 if (s5.f5 != 5) {
6466 fprintf(stderr, "mono_return_short5 s5.f5: got %d but expected %d\n", s5.f5, 5);
6467 }
6468 s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
6469 return s5;
6470 }
6471
6472 typedef struct {
6473 short f1,f2,f3,f4,f5,f6;
6474 } short6;
6475
6476 LIBTEST_API short6 STDCALL
6477 mono_return_short6 (short6 s6, int addend) {
6478 if (s6.f1 != 1) {
6479 fprintf(stderr, "mono_return_short6 s6.f1: got %d but expected %d\n", s6.f1, 1);
6480 }
6481 if (s6.f2 != 2) {
6482 fprintf(stderr, "mono_return_short6 s6.f2: got %d but expected %d\n", s6.f2, 2);
6483 }
6484 if (s6.f3 != 3) {
6485 fprintf(stderr, "mono_return_short6 s6.f3: got %d but expected %d\n", s6.f3, 3);
6486 }
6487 if (s6.f4 != 4) {
6488 fprintf(stderr, "mono_return_short6 s6.f4: got %d but expected %d\n", s6.f4, 4);
6489 }
6490 if (s6.f5 != 5) {
6491 fprintf(stderr, "mono_return_short6 s6.f5: got %d but expected %d\n", s6.f5, 5);
6492 }
6493 if (s6.f6 != 6) {
6494 fprintf(stderr, "mono_return_short6 s6.f6: got %d but expected %d\n", s6.f6, 6);
6495 }
6496 s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
6497 return s6;
6498 }
6499
6500 typedef struct {
6501 short f1,f2,f3,f4,f5,f6,f7;
6502 } short7;
6503
6504 LIBTEST_API short7 STDCALL
6505 mono_return_short7 (short7 s7, int addend) {
6506 if (s7.f1 != 1) {
6507 fprintf(stderr, "mono_return_short7 s7.f1: got %d but expected %d\n", s7.f1, 1);
6508 }
6509 if (s7.f2 != 2) {
6510 fprintf(stderr, "mono_return_short7 s7.f2: got %d but expected %d\n", s7.f2, 2);
6511 }
6512 if (s7.f3 != 3) {
6513 fprintf(stderr, "mono_return_short7 s7.f3: got %d but expected %d\n", s7.f3, 3);
6514 }
6515 if (s7.f4 != 4) {
6516 fprintf(stderr, "mono_return_short7 s7.f4: got %d but expected %d\n", s7.f4, 4);
6517 }
6518 if (s7.f5 != 5) {
6519 fprintf(stderr, "mono_return_short7 s7.f5: got %d but expected %d\n", s7.f5, 5);
6520 }
6521 if (s7.f6 != 6) {
6522 fprintf(stderr, "mono_return_short7 s7.f6: got %d but expected %d\n", s7.f6, 6);
6523 }
6524 if (s7.f7 != 7) {
6525 fprintf(stderr, "mono_return_short7 s7.f7: got %d but expected %d\n", s7.f7, 7);
6526 }
6527 s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
6528 return s7;
6529 }
6530
6531 typedef struct {
6532 short f1,f2,f3,f4,f5,f6,f7,f8;
6533 } short8;
6534
6535 LIBTEST_API short8 STDCALL
6536 mono_return_short8 (short8 s8, int addend) {
6537 if (s8.f1 != 1) {
6538 fprintf(stderr, "mono_return_short8 s8.f1: got %d but expected %d\n", s8.f1, 1);
6539 }
6540 if (s8.f2 != 2) {
6541 fprintf(stderr, "mono_return_short8 s8.f2: got %d but expected %d\n", s8.f2, 2);
6542 }
6543 if (s8.f3 != 3) {
6544 fprintf(stderr, "mono_return_short8 s8.f3: got %d but expected %d\n", s8.f3, 3);
6545 }
6546 if (s8.f4 != 4) {
6547 fprintf(stderr, "mono_return_short8 s8.f4: got %d but expected %d\n", s8.f4, 4);
6548 }
6549 if (s8.f5 != 5) {
6550 fprintf(stderr, "mono_return_short8 s8.f5: got %d but expected %d\n", s8.f5, 5);
6551 }
6552 if (s8.f6 != 6) {
6553 fprintf(stderr, "mono_return_short8 s8.f6: got %d but expected %d\n", s8.f6, 6);
6554 }
6555 if (s8.f7 != 7) {
6556 fprintf(stderr, "mono_return_short8 s8.f7: got %d but expected %d\n", s8.f7, 7);
6557 }
6558 if (s8.f8 != 8) {
6559 fprintf(stderr, "mono_return_short8 s8.f8: got %d but expected %d\n", s8.f8, 8);
6560 }
6561 s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
6562 return s8;
6563 }
6564
6565 typedef struct {
6566 short f1,f2,f3,f4,f5,f6,f7,f8,f9;
6567 } short9;
6568
6569 LIBTEST_API short9 STDCALL
6570 mono_return_short9 (short9 s9, int addend) {
6571 if (s9.f1 != 1) {
6572 fprintf(stderr, "mono_return_short9 s9.f1: got %d but expected %d\n", s9.f1, 1);
6573 }
6574 if (s9.f2 != 2) {
6575 fprintf(stderr, "mono_return_short9 s9.f2: got %d but expected %d\n", s9.f2, 2);
6576 }
6577 if (s9.f3 != 3) {
6578 fprintf(stderr, "mono_return_short9 s9.f3: got %d but expected %d\n", s9.f3, 3);
6579 }
6580 if (s9.f4 != 4) {
6581 fprintf(stderr, "mono_return_short9 s9.f4: got %d but expected %d\n", s9.f4, 4);
6582 }
6583 if (s9.f5 != 5) {
6584 fprintf(stderr, "mono_return_short9 s9.f5: got %d but expected %d\n", s9.f5, 5);
6585 }
6586 if (s9.f6 != 6) {
6587 fprintf(stderr, "mono_return_short9 s9.f6: got %d but expected %d\n", s9.f6, 6);
6588 }
6589 if (s9.f7 != 7) {
6590 fprintf(stderr, "mono_return_short9 s9.f7: got %d but expected %d\n", s9.f7, 7);
6591 }
6592 if (s9.f8 != 8) {
6593 fprintf(stderr, "mono_return_short9 s9.f8: got %d but expected %d\n", s9.f8, 8);
6594 }
6595 if (s9.f9 != 9) {
6596 fprintf(stderr, "mono_return_short9 s9.f9: got %d but expected %d\n", s9.f9, 9);
6597 }
6598 s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
6599 return s9;
6600 }
6601
6602 typedef struct {
6603 struct {
6604 short f1;
6605 } nested1;
6606 short f2,f3,f4,f5,f6,f7;
6607 struct {
6608 short f8;
6609 } nested2;
6610 } short8_nested;
6611
6612 LIBTEST_API short8_nested STDCALL
6613 mono_return_short8_nested (short8_nested sn8, int addend) {
6614 if (sn8.nested1.f1 != 1) {
6615 fprintf(stderr, "mono_return_short8_nested sn8.nested1.f1: got %d but expected %d\n", sn8.nested1.f1, 1);
6616 }
6617 if (sn8.f2 != 2) {
6618 fprintf(stderr, "mono_return_short8_nested sn8.f2: got %d but expected %d\n", sn8.f2, 2);
6619 }
6620 if (sn8.f3 != 3) {
6621 fprintf(stderr, "mono_return_short8_nested sn8.f3: got %d but expected %d\n", sn8.f3, 3);
6622 }
6623 if (sn8.f4 != 4) {
6624 fprintf(stderr, "mono_return_short8_nested sn8.f4: got %d but expected %d\n", sn8.f4, 4);
6625 }
6626 if (sn8.f5 != 5) {
6627 fprintf(stderr, "mono_return_short8_nested sn8.f5: got %d but expected %d\n", sn8.f5, 5);
6628 }
6629 if (sn8.f6 != 6) {
6630 fprintf(stderr, "mono_return_short8_nested sn8.f6: got %d but expected %d\n", sn8.f6, 6);
6631 }
6632 if (sn8.f7 != 7) {
6633 fprintf(stderr, "mono_return_short8_nested sn8.f7: got %d but expected %d\n", sn8.f7, 7);
6634 }
6635 if (sn8.nested2.f8 != 8) {
6636 fprintf(stderr, "mono_return_short8_nested sn8.nested2.f8: got %d but expected %d\n", sn8.nested2.f8, 8);
6637 }
6638 sn8.nested1.f1+=addend; sn8.f2+=addend; sn8.f3+=addend; sn8.f4+=addend; sn8.f5+=addend; sn8.f6+=addend; sn8.f7+=addend; sn8.nested2.f8+=addend;
6639 return sn8;
6640 }
6641
6642
6643 typedef struct {
6644 int f1;
6645 } int1;
6646
6647 LIBTEST_API int1 STDCALL
6648 mono_return_int1 (int1 s1, int addend) {
6649 if (s1.f1 != 1) {
6650 fprintf(stderr, "mono_return_int1 s1.f1: got %d but expected %d\n", s1.f1, 1);
6651 }
6652 s1.f1+=addend;
6653 return s1;
6654 }
6655
6656 typedef struct {
6657 int f1,f2;
6658 } int2;
6659
6660 LIBTEST_API int2 STDCALL
6661 mono_return_int2 (int2 s2, int addend) {
6662 if (s2.f1 != 1) {
6663 fprintf(stderr, "mono_return_int2 s2.f1: got %d but expected %d\n", s2.f1, 1);
6664 }
6665 if (s2.f2 != 2) {
6666 fprintf(stderr, "mono_return_int2 s2.f2: got %d but expected %d\n", s2.f2, 2);
6667 }
6668 s2.f1+=addend; s2.f2+=addend;
6669 return s2;
6670 }
6671
6672 typedef struct {
6673 int f1,f2,f3;
6674 } int3;
6675
6676 LIBTEST_API int3 STDCALL
6677 mono_return_int3 (int3 s3, int addend) {
6678 if (s3.f1 != 1) {
6679 fprintf(stderr, "mono_return_int3 s3.f1: got %d but expected %d\n", s3.f1, 1);
6680 }
6681 if (s3.f2 != 2) {
6682 fprintf(stderr, "mono_return_int3 s3.f2: got %d but expected %d\n", s3.f2, 2);
6683 }
6684 if (s3.f3 != 3) {
6685 fprintf(stderr, "mono_return_int3 s3.f3: got %d but expected %d\n", s3.f3, 3);
6686 }
6687 s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
6688 return s3;
6689 }
6690
6691 typedef struct {
6692 int f1,f2,f3,f4;
6693 } int4;
6694
6695 LIBTEST_API int4 STDCALL
6696 mono_return_int4 (int4 s4, int addend) {
6697 if (s4.f1 != 1) {
6698 fprintf(stderr, "mono_return_int4 s4.f1: got %d but expected %d\n", s4.f1, 1);
6699 }
6700 if (s4.f2 != 2) {
6701 fprintf(stderr, "mono_return_int4 s4.f2: got %d but expected %d\n", s4.f2, 2);
6702 }
6703 if (s4.f3 != 3) {
6704 fprintf(stderr, "mono_return_int4 s4.f3: got %d but expected %d\n", s4.f3, 3);
6705 }
6706 if (s4.f4 != 4) {
6707 fprintf(stderr, "mono_return_int4 s4.f4: got %d but expected %d\n", s4.f4, 4);
6708 }
6709 s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
6710 return s4;
6711 }
6712
6713 typedef struct {
6714 int f1,f2,f3,f4,f5;
6715 } int5;
6716
6717 LIBTEST_API int5 STDCALL
6718 mono_return_int5 (int5 s5, int addend) {
6719 if (s5.f1 != 1) {
6720 fprintf(stderr, "mono_return_int5 s5.f1: got %d but expected %d\n", s5.f1, 1);
6721 }
6722 if (s5.f2 != 2) {
6723 fprintf(stderr, "mono_return_int5 s5.f2: got %d but expected %d\n", s5.f2, 2);
6724 }
6725 if (s5.f3 != 3) {
6726 fprintf(stderr, "mono_return_int5 s5.f3: got %d but expected %d\n", s5.f3, 3);
6727 }
6728 if (s5.f4 != 4) {
6729 fprintf(stderr, "mono_return_int5 s5.f4: got %d but expected %d\n", s5.f4, 4);
6730 }
6731 if (s5.f5 != 5) {
6732 fprintf(stderr, "mono_return_int5 s5.f5: got %d but expected %d\n", s5.f5, 5);
6733 }
6734 s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
6735 return s5;
6736 }
6737
6738 typedef struct {
6739 struct {
6740 int f1;
6741 } nested1;
6742 int f2,f3;
6743 struct {
6744 int f4;
6745 } nested2;
6746 } int4_nested;
6747
6748 LIBTEST_API int4_nested STDCALL
6749 mono_return_int4_nested (int4_nested sn4, int addend) {
6750 if (sn4.nested1.f1 != 1) {
6751 fprintf(stderr, "mono_return_int4_nested sn4.nested1.f1: got %d but expected %d\n", sn4.nested1.f1, 1);
6752 }
6753 if (sn4.f2 != 2) {
6754 fprintf(stderr, "mono_return_int4_nested sn4.f2: got %d but expected %d\n", sn4.f2, 2);
6755 }
6756 if (sn4.f3 != 3) {
6757 fprintf(stderr, "mono_return_int4_nested sn4.f3: got %d but expected %d\n", sn4.f3, 3);
6758 }
6759 if (sn4.nested2.f4 != 4) {
6760 fprintf(stderr, "mono_return_int4_nested sn4.nested2.f4: got %d but expected %d\n", sn4.nested2.f4, 4);
6761 }
6762 sn4.nested1.f1+=addend; sn4.f2+=addend; sn4.f3+=addend; sn4.nested2.f4+=addend;
6763 return sn4;
6764 }
6765
6766 typedef struct {
6767 float f1;
6768 } float1;
6769
6770 LIBTEST_API float1 STDCALL
6771 mono_return_float1 (float1 s1, int addend) {
6772 if (s1.f1 != 1) {
6773 fprintf(stderr, "mono_return_float1 s1.f1: got %f but expected %d\n", s1.f1, 1);
6774 }
6775 s1.f1+=addend;
6776 return s1;
6777 }
6778
6779 typedef struct {
6780 float f1,f2;
6781 } float2;
6782
6783 LIBTEST_API float2 STDCALL
6784 mono_return_float2 (float2 s2, int addend) {
6785 if (s2.f1 != 1) {
6786 fprintf(stderr, "mono_return_float2 s2.f1: got %f but expected %d\n", s2.f1, 1);
6787 }
6788 if (s2.f2 != 2) {
6789 fprintf(stderr, "mono_return_float2 s2.f2: got %f but expected %d\n", s2.f2, 2);
6790 }
6791 s2.f1+=addend; s2.f2+=addend;
6792 return s2;
6793 }
6794
6795 typedef struct {
6796 float f1,f2,f3;
6797 } float3;
6798
6799 LIBTEST_API float3 STDCALL
6800 mono_return_float3 (float3 s3, int addend) {
6801 if (s3.f1 != 1) {
6802 fprintf(stderr, "mono_return_float3 s3.f1: got %f but expected %d\n", s3.f1, 1);
6803 }
6804 if (s3.f2 != 2) {
6805 fprintf(stderr, "mono_return_float3 s3.f2: got %f but expected %d\n", s3.f2, 2);
6806 }
6807 if (s3.f3 != 3) {
6808 fprintf(stderr, "mono_return_float3 s3.f3: got %f but expected %d\n", s3.f3, 3);
6809 }
6810 s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
6811 return s3;
6812 }
6813
6814 typedef struct {
6815 float f1,f2,f3,f4;
6816 } float4;
6817
6818 LIBTEST_API float4 STDCALL
6819 mono_return_float4 (float4 s4, int addend) {
6820 if (s4.f1 != 1) {
6821 fprintf(stderr, "mono_return_float4 s4.f1: got %f but expected %d\n", s4.f1, 1);
6822 }
6823 if (s4.f2 != 2) {
6824 fprintf(stderr, "mono_return_float4 s4.f2: got %f but expected %d\n", s4.f2, 2);
6825 }
6826 if (s4.f3 != 3) {
6827 fprintf(stderr, "mono_return_float4 s4.f3: got %f but expected %d\n", s4.f3, 3);
6828 }
6829 if (s4.f4 != 4) {
6830 fprintf(stderr, "mono_return_float4 s4.f4: got %f but expected %d\n", s4.f4, 4);
6831 }
6832 s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
6833 return s4;
6834 }
6835
6836 typedef struct {
6837 float f1,f2,f3,f4,f5;
6838 } float5;
6839
6840 LIBTEST_API float5 STDCALL
6841 mono_return_float5 (float5 s5, int addend) {
6842 if (s5.f1 != 1) {
6843 fprintf(stderr, "mono_return_float5 s5.f1: got %f but expected %d\n", s5.f1, 1);
6844 }
6845 if (s5.f2 != 2) {
6846 fprintf(stderr, "mono_return_float5 s5.f2: got %f but expected %d\n", s5.f2, 2);
6847 }
6848 if (s5.f3 != 3) {
6849 fprintf(stderr, "mono_return_float5 s5.f3: got %f but expected %d\n", s5.f3, 3);
6850 }
6851 if (s5.f4 != 4) {
6852 fprintf(stderr, "mono_return_float5 s5.f4: got %f but expected %d\n", s5.f4, 4);
6853 }
6854 if (s5.f5 != 5) {
6855 fprintf(stderr, "mono_return_float5 s5.f5: got %f but expected %d\n", s5.f5, 5);
6856 }
6857 s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
6858 return s5;
6859 }
6860
6861 typedef struct {
6862 float f1,f2,f3,f4,f5,f6;
6863 } float6;
6864
6865 LIBTEST_API float6 STDCALL
6866 mono_return_float6 (float6 s6, int addend) {
6867 if (s6.f1 != 1) {
6868 fprintf(stderr, "mono_return_float6 s6.f1: got %f but expected %d\n", s6.f1, 1);
6869 }
6870 if (s6.f2 != 2) {
6871 fprintf(stderr, "mono_return_float6 s6.f2: got %f but expected %d\n", s6.f2, 2);
6872 }
6873 if (s6.f3 != 3) {
6874 fprintf(stderr, "mono_return_float6 s6.f3: got %f but expected %d\n", s6.f3, 3);
6875 }
6876 if (s6.f4 != 4) {
6877 fprintf(stderr, "mono_return_float6 s6.f4: got %f but expected %d\n", s6.f4, 4);
6878 }
6879 if (s6.f5 != 5) {
6880 fprintf(stderr, "mono_return_float6 s6.f5: got %f but expected %d\n", s6.f5, 5);
6881 }
6882 if (s6.f6 != 6) {
6883 fprintf(stderr, "mono_return_float6 s6.f6: got %f but expected %d\n", s6.f6, 6);
6884 }
6885 s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
6886 return s6;
6887 }
6888
6889 typedef struct {
6890 float f1,f2,f3,f4,f5,f6,f7;
6891 } float7;
6892
6893 LIBTEST_API float7 STDCALL
6894 mono_return_float7 (float7 s7, int addend) {
6895 if (s7.f1 != 1) {
6896 fprintf(stderr, "mono_return_float7 s7.f1: got %f but expected %d\n", s7.f1, 1);
6897 }
6898 if (s7.f2 != 2) {
6899 fprintf(stderr, "mono_return_float7 s7.f2: got %f but expected %d\n", s7.f2, 2);
6900 }
6901 if (s7.f3 != 3) {
6902 fprintf(stderr, "mono_return_float7 s7.f3: got %f but expected %d\n", s7.f3, 3);
6903 }
6904 if (s7.f4 != 4) {
6905 fprintf(stderr, "mono_return_float7 s7.f4: got %f but expected %d\n", s7.f4, 4);
6906 }
6907 if (s7.f5 != 5) {
6908 fprintf(stderr, "mono_return_float7 s7.f5: got %f but expected %d\n", s7.f5, 5);
6909 }
6910 if (s7.f6 != 6) {
6911 fprintf(stderr, "mono_return_float7 s7.f6: got %f but expected %d\n", s7.f6, 6);
6912 }
6913 if (s7.f7 != 7) {
6914 fprintf(stderr, "mono_return_float7 s7.f7: got %f but expected %d\n", s7.f7, 7);
6915 }
6916 s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
6917 return s7;
6918 }
6919
6920 typedef struct {
6921 float f1,f2,f3,f4,f5,f6,f7,f8;
6922 } float8;
6923
6924 LIBTEST_API float8 STDCALL
6925 mono_return_float8 (float8 s8, int addend) {
6926 if (s8.f1 != 1) {
6927 fprintf(stderr, "mono_return_float8 s8.f1: got %f but expected %d\n", s8.f1, 1);
6928 }
6929 if (s8.f2 != 2) {
6930 fprintf(stderr, "mono_return_float8 s8.f2: got %f but expected %d\n", s8.f2, 2);
6931 }
6932 if (s8.f3 != 3) {
6933 fprintf(stderr, "mono_return_float8 s8.f3: got %f but expected %d\n", s8.f3, 3);
6934 }
6935 if (s8.f4 != 4) {
6936 fprintf(stderr, "mono_return_float8 s8.f4: got %f but expected %d\n", s8.f4, 4);
6937 }
6938 if (s8.f5 != 5) {
6939 fprintf(stderr, "mono_return_float8 s8.f5: got %f but expected %d\n", s8.f5, 5);
6940 }
6941 if (s8.f6 != 6) {
6942 fprintf(stderr, "mono_return_float8 s8.f6: got %f but expected %d\n", s8.f6, 6);
6943 }
6944 if (s8.f7 != 7) {
6945 fprintf(stderr, "mono_return_float8 s8.f7: got %f but expected %d\n", s8.f7, 7);
6946 }
6947 if (s8.f8 != 8) {
6948 fprintf(stderr, "mono_return_float8 s8.f8: got %f but expected %d\n", s8.f8, 8);
6949 }
6950 s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
6951 return s8;
6952 }
6953
6954 typedef struct {
6955 float f1,f2,f3,f4,f5,f6,f7,f8,f9;
6956 } float9;
6957
6958 LIBTEST_API float9 STDCALL
6959 mono_return_float9 (float9 s9, int addend) {
6960 if (s9.f1 != 1) {
6961 fprintf(stderr, "mono_return_float9 s9.f1: got %f but expected %d\n", s9.f1, 1);
6962 }
6963 if (s9.f2 != 2) {
6964 fprintf(stderr, "mono_return_float9 s9.f2: got %f but expected %d\n", s9.f2, 2);
6965 }
6966 if (s9.f3 != 3) {
6967 fprintf(stderr, "mono_return_float9 s9.f3: got %f but expected %d\n", s9.f3, 3);
6968 }
6969 if (s9.f4 != 4) {
6970 fprintf(stderr, "mono_return_float9 s9.f4: got %f but expected %d\n", s9.f4, 4);
6971 }
6972 if (s9.f5 != 5) {
6973 fprintf(stderr, "mono_return_float9 s9.f5: got %f but expected %d\n", s9.f5, 5);
6974 }
6975 if (s9.f6 != 6) {
6976 fprintf(stderr, "mono_return_float9 s9.f6: got %f but expected %d\n", s9.f6, 6);
6977 }
6978 if (s9.f7 != 7) {
6979 fprintf(stderr, "mono_return_float9 s9.f7: got %f but expected %d\n", s9.f7, 7);
6980 }
6981 if (s9.f8 != 8) {
6982 fprintf(stderr, "mono_return_float9 s9.f8: got %f but expected %d\n", s9.f8, 8);
6983 }
6984 if (s9.f9 != 9) {
6985 fprintf(stderr, "mono_return_float9 s9.f9: got %f but expected %d\n", s9.f9, 9);
6986 }
6987 s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
6988 return s9;
6989 }
6990
6991 typedef struct {
6992 struct {
6993 float f1;
6994 } nested1;
6995 float f2,f3;
6996 struct {
6997 float f4;
6998 } nested2;
6999 } float4_nested;
7000
7001 LIBTEST_API float4_nested STDCALL
7002 mono_return_float4_nested (float4_nested sn4, int addend) {
7003 if (sn4.nested1.f1 != 1) {
7004 fprintf(stderr, "mono_return_float4_nested sn4.nested1.f1: got %f but expected %d\n", sn4.nested1.f1, 1);
7005 }
7006 if (sn4.f2 != 2) {
7007 fprintf(stderr, "mono_return_float4_nested sn4.f2: got %f but expected %d\n", sn4.f2, 2);
7008 }
7009 if (sn4.f3 != 3) {
7010 fprintf(stderr, "mono_return_float4_nested sn4.f3: got %f but expected %d\n", sn4.f3, 3);
7011 }
7012 if (sn4.nested2.f4 != 4) {
7013 fprintf(stderr, "mono_return_float4_nested sn4.nested2.f4: got %f but expected %d\n", sn4.nested2.f4, 4);
7014 }
7015 sn4.nested1.f1+=addend; sn4.f2+=addend; sn4.f3+=addend; sn4.nested2.f4+=addend;
7016 return sn4;
7017 }
7018
7019 typedef struct {
7020 double f1;
7021 } double1;
7022
7023 LIBTEST_API double1 STDCALL
7024 mono_return_double1 (double1 s1, int addend) {
7025 if (s1.f1 != 1) {
7026 fprintf(stderr, "mono_return_double1 s1.f1: got %f but expected %d\n", s1.f1, 1);
7027 }
7028 s1.f1+=addend;
7029 return s1;
7030 }
7031
7032 typedef struct {
7033 double f1,f2;
7034 } double2;
7035
7036 LIBTEST_API double2 STDCALL
7037 mono_return_double2 (double2 s2, int addend) {
7038 if (s2.f1 != 1) {
7039 fprintf(stderr, "mono_return_double2 s2.f1: got %f but expected %d\n", s2.f1, 1);
7040 }
7041 if (s2.f2 != 2) {
7042 fprintf(stderr, "mono_return_double2 s2.f2: got %f but expected %d\n", s2.f2, 2);
7043 }
7044 s2.f1+=addend; s2.f2+=addend;
7045 return s2;
7046 }
7047
7048 typedef struct {
7049 double f1,f2,f3;
7050 } double3;
7051
7052 LIBTEST_API double3 STDCALL
7053 mono_return_double3 (double3 s3, int addend) {
7054 if (s3.f1 != 1) {
7055 fprintf(stderr, "mono_return_double3 s3.f1: got %f but expected %d\n", s3.f1, 1);
7056 }
7057 if (s3.f2 != 2) {
7058 fprintf(stderr, "mono_return_double3 s3.f2: got %f but expected %d\n", s3.f2, 2);
7059 }
7060 if (s3.f3 != 3) {
7061 fprintf(stderr, "mono_return_double3 s3.f3: got %f but expected %d\n", s3.f3, 3);
7062 }
7063 s3.f1+=addend; s3.f2+=addend; s3.f3+=addend;
7064 return s3;
7065 }
7066
7067 typedef struct {
7068 double f1,f2,f3,f4;
7069 } double4;
7070
7071 LIBTEST_API double4 STDCALL
7072 mono_return_double4 (double4 s4, int addend) {
7073 if (s4.f1 != 1) {
7074 fprintf(stderr, "mono_return_double4 s4.f1: got %f but expected %d\n", s4.f1, 1);
7075 }
7076 if (s4.f2 != 2) {
7077 fprintf(stderr, "mono_return_double4 s4.f2: got %f but expected %d\n", s4.f2, 2);
7078 }
7079 if (s4.f3 != 3) {
7080 fprintf(stderr, "mono_return_double4 s4.f3: got %f but expected %d\n", s4.f3, 3);
7081 }
7082 if (s4.f4 != 4) {
7083 fprintf(stderr, "mono_return_double4 s4.f4: got %f but expected %d\n", s4.f4, 4);
7084 }
7085 s4.f1+=addend; s4.f2+=addend; s4.f3+=addend; s4.f4+=addend;
7086 return s4;
7087 }
7088
7089 typedef struct {
7090 double f1,f2,f3,f4,f5;
7091 } double5;
7092
7093 LIBTEST_API double5 STDCALL
7094 mono_return_double5 (double5 s5, int addend) {
7095 if (s5.f1 != 1) {
7096 fprintf(stderr, "mono_return_double5 s5.f1: got %f but expected %d\n", s5.f1, 1);
7097 }
7098 if (s5.f2 != 2) {
7099 fprintf(stderr, "mono_return_double5 s5.f2: got %f but expected %d\n", s5.f2, 2);
7100 }
7101 if (s5.f3 != 3) {
7102 fprintf(stderr, "mono_return_double5 s5.f3: got %f but expected %d\n", s5.f3, 3);
7103 }
7104 if (s5.f4 != 4) {
7105 fprintf(stderr, "mono_return_double5 s5.f4: got %f but expected %d\n", s5.f4, 4);
7106 }
7107 if (s5.f5 != 5) {
7108 fprintf(stderr, "mono_return_double5 s5.f5: got %f but expected %d\n", s5.f5, 5);
7109 }
7110 s5.f1+=addend; s5.f2+=addend; s5.f3+=addend; s5.f4+=addend; s5.f5+=addend;
7111 return s5;
7112 }
7113
7114 typedef struct {
7115 double f1,f2,f3,f4,f5,f6;
7116 } double6;
7117
7118 LIBTEST_API double6 STDCALL
7119 mono_return_double6 (double6 s6, int addend) {
7120 if (s6.f1 != 1) {
7121 fprintf(stderr, "mono_return_double6 s6.f1: got %f but expected %d\n", s6.f1, 1);
7122 }
7123 if (s6.f2 != 2) {
7124 fprintf(stderr, "mono_return_double6 s6.f2: got %f but expected %d\n", s6.f2, 2);
7125 }
7126 if (s6.f3 != 3) {
7127 fprintf(stderr, "mono_return_double6 s6.f3: got %f but expected %d\n", s6.f3, 3);
7128 }
7129 if (s6.f4 != 4) {
7130 fprintf(stderr, "mono_return_double6 s6.f4: got %f but expected %d\n", s6.f4, 4);
7131 }
7132 if (s6.f5 != 5) {
7133 fprintf(stderr, "mono_return_double6 s6.f5: got %f but expected %d\n", s6.f5, 5);
7134 }
7135 if (s6.f6 != 6) {
7136 fprintf(stderr, "mono_return_double6 s6.f6: got %f but expected %d\n", s6.f6, 6);
7137 }
7138 s6.f1+=addend; s6.f2+=addend; s6.f3+=addend; s6.f4+=addend; s6.f5+=addend; s6.f6+=addend;
7139 return s6;
7140 }
7141
7142 typedef struct {
7143 double f1,f2,f3,f4,f5,f6,f7;
7144 } double7;
7145
7146 LIBTEST_API double7 STDCALL
7147 mono_return_double7 (double7 s7, int addend) {
7148 if (s7.f1 != 1) {
7149 fprintf(stderr, "mono_return_double7 s7.f1: got %f but expected %d\n", s7.f1, 1);
7150 }
7151 if (s7.f2 != 2) {
7152 fprintf(stderr, "mono_return_double7 s7.f2: got %f but expected %d\n", s7.f2, 2);
7153 }
7154 if (s7.f3 != 3) {
7155 fprintf(stderr, "mono_return_double7 s7.f3: got %f but expected %d\n", s7.f3, 3);
7156 }
7157 if (s7.f4 != 4) {
7158 fprintf(stderr, "mono_return_double7 s7.f4: got %f but expected %d\n", s7.f4, 4);
7159 }
7160 if (s7.f5 != 5) {
7161 fprintf(stderr, "mono_return_double7 s7.f5: got %f but expected %d\n", s7.f5, 5);
7162 }
7163 if (s7.f6 != 6) {
7164 fprintf(stderr, "mono_return_double7 s7.f6: got %f but expected %d\n", s7.f6, 6);
7165 }
7166 if (s7.f7 != 7) {
7167 fprintf(stderr, "mono_return_double7 s7.f7: got %f but expected %d\n", s7.f7, 7);
7168 }
7169 s7.f1+=addend; s7.f2+=addend; s7.f3+=addend; s7.f4+=addend; s7.f5+=addend; s7.f6+=addend; s7.f7+=addend;
7170 return s7;
7171 }
7172
7173 typedef struct {
7174 double f1,f2,f3,f4,f5,f6,f7,f8;
7175 } double8;
7176
7177 LIBTEST_API double8 STDCALL
7178 mono_return_double8 (double8 s8, int addend) {
7179 if (s8.f1 != 1) {
7180 fprintf(stderr, "mono_return_double8 s8.f1: got %f but expected %d\n", s8.f1, 1);
7181 }
7182 if (s8.f2 != 2) {
7183 fprintf(stderr, "mono_return_double8 s8.f2: got %f but expected %d\n", s8.f2, 2);
7184 }
7185 if (s8.f3 != 3) {
7186 fprintf(stderr, "mono_return_double8 s8.f3: got %f but expected %d\n", s8.f3, 3);
7187 }
7188 if (s8.f4 != 4) {
7189 fprintf(stderr, "mono_return_double8 s8.f4: got %f but expected %d\n", s8.f4, 4);
7190 }
7191 if (s8.f5 != 5) {
7192 fprintf(stderr, "mono_return_double8 s8.f5: got %f but expected %d\n", s8.f5, 5);
7193 }
7194 if (s8.f6 != 6) {
7195 fprintf(stderr, "mono_return_double8 s8.f6: got %f but expected %d\n", s8.f6, 6);
7196 }
7197 if (s8.f7 != 7) {
7198 fprintf(stderr, "mono_return_double8 s8.f7: got %f but expected %d\n", s8.f7, 7);
7199 }
7200 if (s8.f8 != 8) {
7201 fprintf(stderr, "mono_return_double8 s8.f8: got %f but expected %d\n", s8.f8, 8);
7202 }
7203 s8.f1+=addend; s8.f2+=addend; s8.f3+=addend; s8.f4+=addend; s8.f5+=addend; s8.f6+=addend; s8.f7+=addend; s8.f8+=addend;
7204 return s8;
7205 }
7206
7207 typedef struct {
7208 double f1,f2,f3,f4,f5,f6,f7,f8,f9;
7209 } double9;
7210
7211 LIBTEST_API double9 STDCALL
7212 mono_return_double9 (double9 s9, int addend) {
7213 if (s9.f1 != 1) {
7214 fprintf(stderr, "mono_return_double9 s9.f1: got %f but expected %d\n", s9.f1, 1);
7215 }
7216 if (s9.f2 != 2) {
7217 fprintf(stderr, "mono_return_double9 s9.f2: got %f but expected %d\n", s9.f2, 2);
7218 }
7219 if (s9.f3 != 3) {
7220 fprintf(stderr, "mono_return_double9 s9.f3: got %f but expected %d\n", s9.f3, 3);
7221 }
7222 if (s9.f4 != 4) {
7223 fprintf(stderr, "mono_return_double9 s9.f4: got %f but expected %d\n", s9.f4, 4);
7224 }
7225 if (s9.f5 != 5) {
7226 fprintf(stderr, "mono_return_double9 s9.f5: got %f but expected %d\n", s9.f5, 5);
7227 }
7228 if (s9.f6 != 6) {
7229 fprintf(stderr, "mono_return_double9 s9.f6: got %f but expected %d\n", s9.f6, 6);
7230 }
7231 if (s9.f7 != 7) {
7232 fprintf(stderr, "mono_return_double9 s9.f7: got %f but expected %d\n", s9.f7, 7);
7233 }
7234 if (s9.f8 != 8) {
7235 fprintf(stderr, "mono_return_double9 s9.f8: got %f but expected %d\n", s9.f8, 8);
7236 }
7237 if (s9.f9 != 9) {
7238 fprintf(stderr, "mono_return_double9 s9.f9: got %f but expected %d\n", s9.f9, 9);
7239 }
7240 s9.f1+=addend; s9.f2+=addend; s9.f3+=addend; s9.f4+=addend; s9.f5+=addend; s9.f6+=addend; s9.f7+=addend; s9.f8+=addend; s9.f9+=addend;
7241 return s9;
7242 }
7243
7244 typedef struct {
7245 struct {
7246 double f1;
7247 } nested1;
7248 struct {
7249 double f2;
7250 } nested2;
7251 } double2_nested;
7252
7253 LIBTEST_API double2_nested STDCALL
7254 mono_return_double2_nested (double2_nested sn2, int addend) {
7255 if (sn2.nested1.f1 != 1) {
7256 fprintf(stderr, "mono_return_double2_nested sn2.nested1.f1: got %f but expected %d\n", sn2.nested1.f1, 1);
7257 }
7258 if (sn2.nested2.f2 != 2) {
7259 fprintf(stderr, "mono_return_double2_nested sn2.nested2.f2: got %f but expected %d\n", sn2.nested2.f2, 2);
7260 }
7261 sn2.nested1.f1+=addend; sn2.nested2.f2+=addend;
7262 return sn2;
7263 }
7264
7265
7266
7267 typedef struct {
7268 double f1[4];
7269 } double_array4;
7270
7271 LIBTEST_API double_array4 STDCALL
7272 mono_return_double_array4 (double_array4 sa4, int addend) {
7273 if (sa4.f1[0] != 1) {
7274 fprintf(stderr, "mono_return_double_array4 sa4.f1[0]: got %f but expected %d\n", sa4.f1[0], 1);
7275 }
7276 if (sa4.f1[1] != 2) {
7277 fprintf(stderr, "mono_return_double_array4 sa4.f1[1]: got %f but expected %d\n", sa4.f1[1], 2);
7278 }
7279 if (sa4.f1[2] != 3) {
7280 fprintf(stderr, "mono_return_double_array4 sa4.f1[2]: got %f but expected %d\n", sa4.f1[2], 3);
7281 }
7282 if (sa4.f1[3] != 4) {
7283 fprintf(stderr, "mono_return_double_array4 sa4.f1[3]: got %f but expected %d\n", sa4.f1[3], 4);
7284 }
7285 sa4.f1[0]+=addend; sa4.f1[1]+=addend; sa4.f1[2]+=addend; sa4.f1[3]+=addend;
7286 return sa4;
7287 }
7288
7289 typedef struct {
7290 int array [3];
7291 } FixedArrayStruct;
7292
7293 LIBTEST_API int STDCALL
7294 mono_test_marshal_fixed_array (FixedArrayStruct s)
7295 {
7296 return s.array [0] + s.array [1] + s.array [2];
7297 }
7298
7299 typedef struct {
7300 char array [16];
7301 char c;
7302 } FixedBufferChar;
7303
7304 LIBTEST_API int STDCALL
7305 mono_test_marshal_fixed_buffer_char (FixedBufferChar *s)
7306 {
7307 if (!(s->array [0] == 'A' && s->array [1] == 'B' && s->array [2] == 'C' && s->c == 'D'))
7308 return 1;
7309 s->array [0] = 'E';
7310 s->array [1] = 'F';
7311 s->c = 'G';
7312 return 0;
7313 }
7314
7315 typedef struct {
7316 short array [16];
7317 short c;
7318 } FixedBufferUnicode;
7319
7320 LIBTEST_API int STDCALL
7321 mono_test_marshal_fixed_buffer_unicode (FixedBufferUnicode *s)
7322 {
7323 if (!(s->array [0] == 'A' && s->array [1] == 'B' && s->array [2] == 'C' && s->c == 'D'))
7324 return 1;
7325 s->array [0] = 'E';
7326 s->array [1] = 'F';
7327 s->c = 'G';
7328 return 0;
7329 }
7330
7331 const int NSTRINGS = 6;
7332 //test strings
7333 const char *utf8Strings[] = {
7334 "Managed",
7335 "Sîne klâwen durh die wolken sint geslagen" ,
7336 "काचं शक्नोम्यत्तुम् । नोपहिनस्ति माम्",
7337 "我能吞下玻璃而不伤身体",
7338 "ღმერთსი შემვედრე,შემვედრე, ნუთუ კვლა დამხსნას შემვედრე,სოფლისა შემვედრე, შემვედრე,შემვედრე,შემვედრე,შრომასა, ცეცხლს, წყალსა და მიწასა, ჰაერთა თანა მრომასა; მომცნეს ფრთენი და აღვფრინდე, მივჰხვდე მას ჩემსა ნდომასა, დღისით და ღამით ვჰხედვიდე მზისა ელვათა კრთომაასაშემვედრე,შემვედრე,",
7339 "Τη γλώσσα μου έδωσαν ελληνική",
7340 "\0"
7341 };
7342
7343 LIBTEST_API char *
7344 build_return_string(const char* pReturn)
7345 {
7346 char *ret = 0;
7347 if (pReturn == 0 || *pReturn == 0)
7348 return ret;
7349
7350 size_t strLength = strlen(pReturn);
7351 ret = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7352 memcpy(ret, pReturn, strLength);
7353 ret [strLength] = '\0';
7354 return ret;
7355 }
7356
7357 LIBTEST_API char *
7358 StringParameterInOut(/*[In,Out]*/ char *s, int index)
7359 {
7360 // return a copy
7361 return build_return_string(s);
7362 }
7363
7364 LIBTEST_API void
7365 StringParameterRefOut(/*out*/ char **s, int index)
7366 {
7367 char *pszTextutf8 = (char*)utf8Strings[index];
7368 size_t strLength = strlen(pszTextutf8);
7369 *s = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7370 memcpy(*s, pszTextutf8, strLength);
7371 (*s)[strLength] = '\0';
7372 }
7373
7374 LIBTEST_API void
7375 StringParameterRef(/*ref*/ char **s, int index)
7376 {
7377 char *pszTextutf8 = (char*)utf8Strings[index];
7378 size_t strLength = strlen(pszTextutf8);
7379 // do byte by byte validation of in string
7380 size_t szLen = strlen(*s);
7381 for (size_t i = 0; i < szLen; i++)
7382 {
7383 if ((*s)[i] != pszTextutf8[i])
7384 {
7385 printf("[in] managed string do not match native string\n");
7386 abort ();
7387 }
7388 }
7389
7390 if (*s)
7391 {
7392 marshal_free (*s);
7393 }
7394 // overwrite the orginal
7395 *s = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7396 memcpy(*s, pszTextutf8, strLength);
7397 (*s)[strLength] = '\0';
7398 }
7399
7400 LIBTEST_API void
7401 StringBuilderParameterInOut(/*[In,Out] StringBuilder*/ char *s, int index)
7402 {
7403 // if string.empty
7404 if (s == 0 || *s == 0)
7405 return;
7406
7407 char *pszTextutf8 = (char*)utf8Strings[index];
7408
7409 // do byte by byte validation of in string
7410 size_t szLen = strlen(s);
7411 for (size_t i = 0; i < szLen; i++)
7412 {
7413 if (s[i] != pszTextutf8[i])
7414 {
7415 printf("[in] managed string do not match native string\n");
7416 abort ();
7417 }
7418 }
7419
7420 // modify the string inplace
7421 size_t outLen = strlen(pszTextutf8);
7422 for (size_t i = 0; i < outLen; i++) {
7423 s[i] = pszTextutf8[i];
7424 }
7425 s[outLen] = '\0';
7426 }
7427
7428 //out string builder
7429 LIBTEST_API void
7430 StringBuilderParameterOut(/*[Out] StringBuilder*/ char *s, int index)
7431 {
7432 char *pszTextutf8 = (char*)utf8Strings[index];
7433
7434 printf ("SBPO: Receiving %s\n", s);
7435 // modify the string inplace
7436 size_t outLen = strlen(pszTextutf8);
7437 for (size_t i = 0; i < outLen; i++) {
7438 s[i] = pszTextutf8[i];
7439 }
7440 s[outLen] = '\0';
7441 }
7442
7443 LIBTEST_API char *
7444 StringParameterOut(/*[Out]*/ char *s, int index)
7445 {
7446 // return a copy
7447 return build_return_string(s);
7448 }
7449
7450 // Utf8 field
7451 typedef struct FieldWithUtf8
7452 {
7453 char *pFirst;
7454 int index;
7455 }FieldWithUtf8;
7456
7457 //utf8 struct field
7458 LIBTEST_API void
7459 TestStructWithUtf8Field(struct FieldWithUtf8 fieldStruct)
7460 {
7461 char *pszManagedutf8 = fieldStruct.pFirst;
7462 int stringIndex = fieldStruct.index;
7463 char *pszNative = 0;
7464 size_t outLen = 0;
7465
7466 if (pszManagedutf8 == 0 || *pszManagedutf8 == 0)
7467 return;
7468
7469 pszNative = (char*)utf8Strings[stringIndex];
7470
7471 outLen = strlen(pszNative);
7472 // do byte by byte comparision
7473 for (size_t i = 0; i < outLen; i++)
7474 {
7475 if (pszNative[i] != pszManagedutf8[i])
7476 {
7477 printf("Native and managed string do not match.\n");
7478 abort ();
7479 }
7480 }
7481 }
7482
7483 typedef void (* Callback2)(char *text, int index);
7484
7485 LIBTEST_API void
7486 Utf8DelegateAsParameter(Callback2 managedCallback)
7487 {
7488 for (int i = 0; i < NSTRINGS; ++i)
7489 {
7490 char *pszNative = 0;
7491 pszNative = (char*)utf8Strings[i];
7492 managedCallback(pszNative, i);
7493 }
7494 }
7495
7496
7497 LIBTEST_API char*
7498 StringBuilderParameterReturn(int index)
7499 {
7500 char *pszTextutf8 = (char*)utf8Strings[index];
7501 size_t strLength = strlen(pszTextutf8);
7502 char * ret = (char *)(marshal_alloc (sizeof(char)* (strLength + 1)));
7503 memcpy(ret, pszTextutf8, strLength);
7504 ret[strLength] = '\0';
7505
7506 return ret;
7507 }
7508
7509 LIBTEST_API int STDCALL
7510 mono_test_marshal_pointer_array (int *arr[])
7511 {
7512 int i;
7513
7514 for (i = 0; i < 10; ++i) {
7515 if (*arr [i] != -1)
7516 return 1;
7517 }
7518 return 0;
7519 }
7520
7521 #ifndef WIN32
7522
7523 typedef void (*NativeToManagedExceptionRethrowFunc) (void);
7524
7525 void *mono_test_native_to_managed_exception_rethrow_thread (void *arg)
7526 {
7527 NativeToManagedExceptionRethrowFunc func = (NativeToManagedExceptionRethrowFunc) arg;
7528 func ();
7529 return NULL;
7530 }
7531
7532 LIBTEST_API void STDCALL
7533 mono_test_native_to_managed_exception_rethrow (NativeToManagedExceptionRethrowFunc func)
7534 {
7535 pthread_t t;
7536 pthread_create (&t, NULL, mono_test_native_to_managed_exception_rethrow_thread, func);
7537 pthread_join (t, NULL);
7538 }
7539 #endif
Mirror of the official Mono project git repository