mono/tests/libtest.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <glib.h>
   5 #include <errno.h>
   6 #include <time.h>
   7
   8 #ifdef WIN32
   9 #include <windows.h>
  10 #include "initguid.h"
  11 #endif
  12
  13 #ifdef WIN32
  14 #define STDCALL __stdcall
  15 #else
  16 #define STDCALL
  17 #endif
  18
  19 #ifdef WIN32
  20 extern __declspec(dllimport) __stdcall void CoTaskMemFree(void *ptr);
  21 #endif
  22
  23 typedef int (STDCALL *SimpleDelegate) (int a);
  24
  25 static void marshal_free (void *ptr)
  26 {
  27 #ifdef WIN32
  28         CoTaskMemFree (ptr);
  29 #else
  30         g_free (ptr);
  31 #endif
  32 }
  33
  34 STDCALL unsigned short*
  35 test_lpwstr_marshal (unsigned short* chars, long length)
  36 {
  37         int i = 0;
  38         unsigned short *res;
  39
  40         res = malloc (2 * (length + 1));
  41
  42         // printf("test_lpwstr_marshal()\n");
  43
  44         while ( i < length ) {
  45                 // printf("X|%u|\n", chars[i]);
  46                 res [i] = chars[i];
  47                 i++;
  48         }
  49
  50         res [i] = 0;
  51
  52         return res;
  53 }
  54
  55 typedef struct {
  56         int b;
  57         int a;
  58         int c;
  59 } union_test_1_type;
  60
  61 STDCALL int
  62 mono_union_test_1 (union_test_1_type u1) {
  63         // printf ("Got values %d %d %d\n", u1.b, u1.a, u1.c);
  64         return u1.a + u1.b + u1.c;
  65 }
  66
  67 STDCALL int
  68 mono_return_int (int a) {
  69         // printf ("Got value %d\n", a);
  70         return a;
  71 }
  72
  73 struct ss
  74 {
  75         int i;
  76 };
  77
  78 STDCALL int
  79 mono_return_int_ss (struct ss a) {
  80         // printf ("Got value %d\n", a.i);
  81         return a.i;
  82 }
  83
  84 STDCALL struct ss
  85 mono_return_ss (struct ss a) {
  86         // printf ("Got value %d\n", a.i);
  87         a.i++;
  88         return a;
  89 }
  90
  91 struct sc1
  92 {
  93         char c[1];
  94 };
  95
  96 STDCALL struct sc1
  97 mono_return_sc1 (struct sc1 a) {
  98         // printf ("Got value %d\n", a.c[0]);
  99         a.c[0]++;
 100         return a;
 101 }
 102
 103
 104 struct sc3
 105 {
 106         char c[3];
 107 };
 108
 109 STDCALL struct sc3
 110 mono_return_sc3 (struct sc3 a) {
 111         // printf ("Got values %d %d %d\n", a.c[0], a.c[1], a.c[2]);
 112         a.c[0]++;
 113         a.c[1] += 2;
 114         a.c[2] += 3;
 115         return a;
 116 }
 117
 118 struct sc5
 119 {
 120         char c[5];
 121 };
 122
 123 STDCALL struct sc5
 124 mono_return_sc5 (struct sc5 a) {
 125         // printf ("Got values %d %d %d %d %d\n", a.c[0], a.c[1], a.c[2], a.c[3], a.c[4]);
 126         a.c[0]++;
 127         a.c[1] += 2;
 128         a.c[2] += 3;
 129         a.c[3] += 4;
 130         a.c[4] += 5;
 131         return a;
 132 }
 133
 134 union su
 135 {
 136         int i1;
 137         int i2;
 138 };
 139
 140 STDCALL int
 141 mono_return_int_su (union su a) {
 142         // printf ("Got value %d\n", a.i1);
 143         return a.i1;
 144 }
 145
 146 STDCALL int
 147 mono_test_many_int_arguments (int a, int b, int c, int d, int e,
 148                                                           int f, int g, int h, int i, int j);
 149 STDCALL short
 150 mono_test_many_short_arguments (short a, short b, short c, short d, short e,
 151                                                                 short f, short g, short h, short i, short j);
 152 STDCALL char
 153 mono_test_many_char_arguments (char a, char b, char c, char d, char e,
 154                                                            char f, char g, char h, char i, char j);
 155
 156 STDCALL int
 157 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)
 158 {
 159         return a + b + c + d + e + f + g + h + i + j;
 160 }
 161
 162 STDCALL short
 163 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)
 164 {
 165         return a + b + c + d + e + f + g + h + i + j;
 166 }
 167
 168 STDCALL char
 169 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)
 170 {
 171         return a + b + c + d + e + f + g + h + i + j;
 172 }
 173
 174 STDCALL float
 175 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)
 176 {
 177         return a + b + c + d + e + f + g + h + i + j;
 178 }
 179
 180 STDCALL double
 181 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)
 182 {
 183         return a + b + c + d + e + f + g + h + i + j;
 184 }
 185
 186 STDCALL double
 187 mono_test_split_double_arguments (double a, double b, float c, double d, double e)
 188 {
 189         return a + b + c + d + e;
 190 }
 191
 192 STDCALL int
 193 mono_test_puts_static (char *s)
 194 {
 195         // printf ("TEST %s\n", s);
 196         return 1;
 197 }
 198
 199 typedef int (STDCALL *SimpleDelegate3) (int a, int b);
 200
 201 STDCALL int
 202 mono_invoke_delegate (SimpleDelegate3 delegate)
 203 {
 204         int res;
 205
 206         // printf ("start invoke %p\n", delegate);
 207
 208         res = delegate (2, 3);
 209
 210         // printf ("end invoke\n");
 211
 212         return res;
 213 }
 214
 215 STDCALL int
 216 mono_test_marshal_char (short a1)
 217 {
 218         if (a1 == 'a')
 219                 return 0;
 220
 221         return 1;
 222 }
 223
 224 STDCALL void
 225 mono_test_marshal_char_array (gunichar2 *s)
 226 {
 227         const char m[] = "abcdef";
 228         gunichar2* s2;
 229         glong len;
 230
 231         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
 232
 233         len = (len * 2) + 2;
 234         memcpy (s, s2, len);
 235
 236         g_free (s2);
 237 }
 238
 239 STDCALL int
 240 mono_test_empty_pinvoke (int i)
 241 {
 242         return i;
 243 }
 244
 245 STDCALL int
 246 mono_test_marshal_bool_byref (int a, int *b, int c)
 247 {
 248     int res = *b;
 249
 250         *b = 1;
 251
 252         return res;
 253 }
 254
 255 STDCALL int
 256 mono_test_marshal_bool_in_as_I1_U1 (char bTrue, char bFalse)
 257 {
 258         if (!bTrue)
 259                 return 1;
 260         if (bFalse)
 261                 return 2;
 262         return 0;
 263 }
 264
 265 STDCALL int
 266 mono_test_marshal_bool_out_as_I1_U1 (char* bTrue, char* bFalse)
 267 {
 268         if (!bTrue || !bFalse)
 269                 return 3;
 270
 271         *bTrue = 1;
 272         *bFalse = 0;
 273
 274         return 0;
 275 }
 276
 277 STDCALL int
 278 mono_test_marshal_bool_ref_as_I1_U1 (char* bTrue, char* bFalse)
 279 {
 280         if (!bTrue || !bFalse)
 281                 return 4;
 282
 283         if (!(*bTrue))
 284                 return 5;
 285         if (*bFalse)
 286                 return 6;
 287
 288         *bFalse = 1;
 289         *bTrue = 0;
 290
 291         return 0;
 292 }
 293
 294 STDCALL int
 295 mono_test_marshal_array (int *a1)
 296 {
 297         int i, sum = 0;
 298
 299         for (i = 0; i < 50; i++)
 300                 sum += a1 [i];
 301
 302         return sum;
 303 }
 304
 305 STDCALL int
 306 mono_test_marshal_inout_array (int *a1)
 307 {
 308         int i, sum = 0;
 309
 310         for (i = 0; i < 50; i++) {
 311                 sum += a1 [i];
 312                 a1 [i] = 50 - a1 [i];
 313         }
 314
 315         return sum;
 316 }
 317
 318 STDCALL int
 319 mono_test_marshal_out_array (int *a1)
 320 {
 321         int i;
 322
 323         for (i = 0; i < 50; i++) {
 324                 a1 [i] = i;
 325         }
 326
 327         return 0;
 328 }
 329
 330 STDCALL int
 331 mono_test_marshal_inout_nonblittable_array (gunichar2 *a1)
 332 {
 333         int i, sum = 0;
 334
 335         for (i = 0; i < 10; i++) {
 336                 a1 [i] = 'F';
 337         }
 338
 339         return sum;
 340 }
 341
 342 typedef struct {
 343         int a;
 344         int b;
 345         int c;
 346         const char *d;
 347         gunichar2 *d2;
 348 } simplestruct;
 349
 350 typedef struct {
 351         double x;
 352         double y;
 353 } point;
 354
 355 STDCALL simplestruct
 356 mono_test_return_vtype (int i)
 357 {
 358         simplestruct res;
 359         static gunichar2 test2 [] = { 'T', 'E', 'S', 'T', '2', 0 };
 360
 361         res.a = 0;
 362         res.b = 1;
 363         res.c = 0;
 364         res.d = "TEST";
 365         res.d2 = test2;
 366
 367         return res;
 368 }
 369
 370 STDCALL void
 371 mono_test_delegate_struct (void)
 372 {
 373         // printf ("TEST\n");
 374 }
 375
 376 typedef char* (STDCALL *ReturnStringDelegate) (const char *s);
 377
 378 STDCALL char *
 379 mono_test_return_string (ReturnStringDelegate func)
 380 {
 381         char *res;
 382
 383         // printf ("mono_test_return_string\n");
 384
 385         res = func ("TEST");
 386         marshal_free (res);
 387
 388         // printf ("got string: %s\n", res);
 389         return g_strdup ("12345");
 390 }
 391
 392 typedef int (STDCALL *RefVTypeDelegate) (int a, simplestruct *ss, int b);
 393
 394 STDCALL int
 395 mono_test_ref_vtype (int a, simplestruct *ss, int b, RefVTypeDelegate func)
 396 {
 397         if (a == 1 && b == 2 && ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 398             !strcmp (ss->d, "TEST1")) {
 399                 ss->a = 1;
 400                 ss->b = 0;
 401                 ss->c = 1;
 402                 ss->d = "TEST2";
 403
 404                 return func (a, ss, b);
 405         }
 406
 407         return 1;
 408 }
 409
 410 typedef int (STDCALL *OutVTypeDelegate) (int a, simplestruct *ss, int b);
 411
 412 STDCALL int
 413 mono_test_marshal_out_struct (int a, simplestruct *ss, int b, OutVTypeDelegate func)
 414 {
 415         /* Check that the input pointer is ignored */
 416         ss->d = (gpointer)0x12345678;
 417
 418         func (a, ss, b);
 419
 420         if (ss->a && ss->b && ss->c && !strcmp (ss->d, "TEST3"))
 421                 return 0;
 422         else
 423                 return 1;
 424 }
 425
 426 typedef struct {
 427         int a;
 428         SimpleDelegate func, func2;
 429 } DelegateStruct;
 430
 431 STDCALL DelegateStruct
 432 mono_test_marshal_delegate_struct (DelegateStruct ds)
 433 {
 434         DelegateStruct res;
 435
 436         res.a = ds.func (ds.a) + ds.func2 (ds.a);
 437         res.func = ds.func;
 438         res.func2 = ds.func2;
 439
 440         return res;
 441 }
 442
 443 STDCALL int
 444 mono_test_marshal_struct (simplestruct ss)
 445 {
 446         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 447             !strcmp (ss.d, "TEST"))
 448                 return 0;
 449
 450         return 1;
 451 }
 452
 453 STDCALL int
 454 mono_test_marshal_byref_struct (simplestruct *ss, int a, int b, int c, char *d)
 455 {
 456         gboolean res = (ss->a == a && ss->b == b && ss->c == c && strcmp (ss->d, d) == 0);
 457
 458         marshal_free (ss->d);
 459
 460         ss->a = !ss->a;
 461         ss->b = !ss->b;
 462         ss->c = !ss->c;
 463         ss->d = g_strdup ("DEF");
 464
 465         return res ? 0 : 1;
 466 }
 467
 468 typedef struct {
 469         int a;
 470         int b;
 471         int c;
 472         char *d;
 473         unsigned char e;
 474         double f;
 475         unsigned char g;
 476         guint64 h;
 477 } simplestruct2;
 478
 479 STDCALL int
 480 mono_test_marshal_struct2 (simplestruct2 ss)
 481 {
 482         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 483             !strcmp (ss.d, "TEST") &&
 484             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
 485                 return 0;
 486
 487         return 1;
 488 }
 489
 490 /* on HP some of the struct should be on the stack and not in registers */
 491 STDCALL int
 492 mono_test_marshal_struct2_2 (int i, int j, int k, simplestruct2 ss)
 493 {
 494         if (i != 10 || j != 11 || k != 12)
 495                 return 1;
 496         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 497             !strcmp (ss.d, "TEST") &&
 498             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
 499                 return 0;
 500
 501         return 1;
 502 }
 503
 504 STDCALL int
 505 mono_test_marshal_lpstruct (simplestruct *ss)
 506 {
 507         if (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 508             !strcmp (ss->d, "TEST"))
 509                 return 0;
 510
 511         return 1;
 512 }
 513
 514 STDCALL int
 515 mono_test_marshal_lpstruct_blittable (point *p)
 516 {
 517         if (p->x == 1.0 && p->y == 2.0)
 518                 return 0;
 519         else
 520                 return 1;
 521 }
 522
 523 STDCALL int
 524 mono_test_marshal_struct_array (simplestruct2 *ss)
 525 {
 526         if (! (ss[0].a == 0 && ss[0].b == 1 && ss[0].c == 0 &&
 527                    !strcmp (ss[0].d, "TEST") &&
 528                    ss[0].e == 99 && ss[0].f == 1.5 && ss[0].g == 42 && ss[0].h == (guint64)123))
 529                 return 1;
 530
 531         if (! (ss[1].a == 0 && ss[1].b == 0 && ss[1].c == 0 &&
 532                    !strcmp (ss[1].d, "TEST2") &&
 533                    ss[1].e == 100 && ss[1].f == 2.5 && ss[1].g == 43 && ss[1].h == (guint64)124))
 534                 return 1;
 535
 536         return 0;
 537 }
 538
 539 typedef struct long_align_struct {
 540         gint32 a;
 541         gint64 b;
 542         gint64 c;
 543 } long_align_struct;
 544
 545 STDCALL int
 546 mono_test_marshal_long_align_struct_array (long_align_struct *ss)
 547 {
 548         return ss[0].a + ss[0].b + ss[0].c + ss[1].a + ss[1].b + ss[1].c;
 549 }
 550
 551 STDCALL simplestruct2 *
 552 mono_test_marshal_class (int i, int j, int k, simplestruct2 *ss, int l)
 553 {
 554         simplestruct2 *res;
 555
 556         if (!ss)
 557                 return NULL;
 558
 559         if (i != 10 || j != 11 || k != 12 || l != 14)
 560                 return NULL;
 561         if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 562                    !strcmp (ss->d, "TEST") &&
 563                    ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
 564                 return NULL;
 565
 566         res = g_new0 (simplestruct2, 1);
 567         memcpy (res, ss, sizeof (simplestruct2));
 568         res->d = g_strdup ("TEST");
 569         return res;
 570 }
 571
 572 STDCALL int
 573 mono_test_marshal_byref_class (simplestruct2 **ssp)
 574 {
 575         simplestruct2 *ss = *ssp;
 576         simplestruct2 *res;
 577
 578         if (! (ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 579                    !strcmp (ss->d, "TEST") &&
 580                    ss->e == 99 && ss->f == 1.5 && ss->g == 42 && ss->h == (guint64)123))
 581                 return 1;
 582
 583         res = g_new0 (simplestruct2, 1);
 584         memcpy (res, ss, sizeof (simplestruct2));
 585         res->d = g_strdup ("TEST-RES");
 586
 587         *ssp = res;
 588         return 0;
 589 }
 590
 591 static void *
 592 get_sp (void)
 593 {
 594         int i;
 595         void *p;
 596
 597         /* Yes, this is correct, we are only trying to determine the value of the stack here */
 598         p = &i;
 599         return p;
 600 }
 601
 602 STDCALL int
 603 reliable_delegate (int a)
 604 {
 605         return a;
 606 }
 607
 608 /*
 609  * Checks whether get_sp() works as expected. It doesn't work with gcc-2.95.3 on linux.
 610  */
 611 static gboolean
 612 is_get_sp_reliable (void)
 613 {
 614         void *sp1, *sp2;
 615
 616         reliable_delegate(1);
 617         sp1 = get_sp();
 618         reliable_delegate(1);
 619         sp2 = get_sp();
 620         return sp1 == sp2;
 621 }
 622
 623 STDCALL int
 624 mono_test_marshal_delegate (SimpleDelegate delegate)
 625 {
 626         void *sp1, *sp2;
 627
 628         /* Check that the delegate wrapper is stdcall */
 629         delegate (2);
 630         sp1 = get_sp ();
 631         delegate (2);
 632         sp2 = get_sp ();
 633         if (is_get_sp_reliable())
 634                 g_assert (sp1 == sp2);
 635
 636         return delegate (2);
 637 }
 638
 639 STDCALL SimpleDelegate
 640 mono_test_marshal_return_delegate (SimpleDelegate delegate)
 641 {
 642         return delegate;
 643 }
 644
 645 static STDCALL int
 646 return_plus_one (int i)
 647 {
 648         return i + 1;
 649 }
 650
 651 STDCALL SimpleDelegate
 652 mono_test_marshal_return_delegate_2 ()
 653 {
 654         return return_plus_one;
 655 }
 656
 657 typedef simplestruct (STDCALL *SimpleDelegate2) (simplestruct ss);
 658
 659 static gboolean
 660 is_utf16_equals (gunichar2 *s1, const char *s2)
 661 {
 662         char *s;
 663         int res;
 664
 665         s = g_utf16_to_utf8 (s1, -1, NULL, NULL, NULL);
 666         res = strcmp (s, s2);
 667         g_free (s);
 668
 669         return res == 0;
 670 }
 671
 672 STDCALL int
 673 mono_test_marshal_delegate2 (SimpleDelegate2 delegate)
 674 {
 675         simplestruct ss, res;
 676
 677         ss.a = 0;
 678         ss.b = 1;
 679         ss.c = 0;
 680         ss.d = "TEST";
 681         ss.d2 = g_utf8_to_utf16 ("TEST2", -1, NULL, NULL, NULL);
 682
 683         res = delegate (ss);
 684         if (! (res.a && !res.b && res.c && !strcmp (res.d, "TEST-RES") && is_utf16_equals (res.d2, "TEST2-RES")))
 685                 return 1;
 686
 687         return 0;
 688 }
 689
 690 typedef simplestruct* (STDCALL *SimpleDelegate4) (simplestruct *ss);
 691
 692 STDCALL int
 693 mono_test_marshal_delegate4 (SimpleDelegate4 delegate)
 694 {
 695         simplestruct ss;
 696         simplestruct *res;
 697
 698         ss.a = 0;
 699         ss.b = 1;
 700         ss.c = 0;
 701         ss.d = "TEST";
 702
 703         /* Check argument */
 704         res = delegate (&ss);
 705         if (!res)
 706                 return 1;
 707
 708         /* Check return value */
 709         if (! (!res->a && res->b && !res->c && !strcmp (res->d, "TEST")))
 710                 return 2;
 711
 712         /* Check NULL argument and NULL result */
 713         res = delegate (NULL);
 714         if (res)
 715                 return 3;
 716
 717         return 0;
 718 }
 719
 720 typedef int (STDCALL *SimpleDelegate5) (simplestruct **ss);
 721
 722 STDCALL int
 723 mono_test_marshal_delegate5 (SimpleDelegate5 delegate)
 724 {
 725         simplestruct ss;
 726         int res;
 727         simplestruct *ptr;
 728
 729         ss.a = 0;
 730         ss.b = 1;
 731         ss.c = 0;
 732         ss.d = "TEST";
 733
 734         ptr = &ss;
 735
 736         res = delegate (&ptr);
 737         if (res != 0)
 738                 return 1;
 739
 740         if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
 741                 return 2;
 742
 743         return 0;
 744 }
 745
 746 STDCALL int
 747 mono_test_marshal_delegate6 (SimpleDelegate5 delegate)
 748 {
 749         int res;
 750
 751         res = delegate (NULL);
 752
 753         return 0;
 754 }
 755
 756 typedef int (STDCALL *SimpleDelegate7) (simplestruct **ss);
 757
 758 STDCALL int
 759 mono_test_marshal_delegate7 (SimpleDelegate7 delegate)
 760 {
 761         int res;
 762         simplestruct *ptr;
 763
 764         /* Check that the input pointer is ignored */
 765         ptr = (gpointer)0x12345678;
 766
 767         res = delegate (&ptr);
 768         if (res != 0)
 769                 return 1;
 770
 771         if (!(ptr->a && !ptr->b && ptr->c && !strcmp (ptr->d, "RES")))
 772                 return 2;
 773
 774         return 0;
 775 }
 776
 777 typedef int (STDCALL *InOutByvalClassDelegate) (simplestruct *ss);
 778
 779 STDCALL int
 780 mono_test_marshal_inout_byval_class_delegate (InOutByvalClassDelegate delegate)
 781 {
 782         int res;
 783         simplestruct ss;
 784
 785         ss.a = FALSE;
 786         ss.b = TRUE;
 787         ss.c = FALSE;
 788         ss.d = g_strdup_printf ("%s", "FOO");
 789
 790         res = delegate (&ss);
 791         if (res != 0)
 792                 return 1;
 793
 794         if (!(ss.a && !ss.b && ss.c && !strcmp (ss.d, "RES")))
 795                 return 2;
 796
 797         return 0;
 798 }
 799
 800 typedef int (STDCALL *SimpleDelegate8) (gunichar2 *s);
 801
 802 STDCALL int
 803 mono_test_marshal_delegate8 (SimpleDelegate8 delegate, gunichar2 *s)
 804 {
 805         return delegate (s);
 806 }
 807
 808 typedef int (STDCALL *return_int_fnt) (int i);
 809 typedef int (STDCALL *SimpleDelegate9) (return_int_fnt d);
 810
 811 STDCALL int
 812 mono_test_marshal_delegate9 (SimpleDelegate9 delegate, gpointer ftn)
 813 {
 814         return delegate (ftn);
 815 }
 816
 817 STDCALL static int
 818 return_self (int i)
 819 {
 820         return i;
 821 }
 822
 823 STDCALL int
 824 mono_test_marshal_delegate10 (SimpleDelegate9 delegate)
 825 {
 826         return delegate (return_self);
 827 }
 828
 829 typedef int (STDCALL *PrimitiveByrefDelegate) (int *i);
 830
 831 STDCALL int
 832 mono_test_marshal_primitive_byref_delegate (PrimitiveByrefDelegate delegate)
 833 {
 834         int i = 1;
 835
 836         int res = delegate (&i);
 837         if (res != 0)
 838                 return res;
 839
 840         if (i != 2)
 841                 return 2;
 842
 843         return 0;
 844 }
 845
 846 typedef int (STDCALL *return_int_delegate) (int i);
 847
 848 typedef return_int_delegate (STDCALL *ReturnDelegateDelegate) (void);
 849
 850 STDCALL int
 851 mono_test_marshal_return_delegate_delegate (ReturnDelegateDelegate d)
 852 {
 853         return (d ()) (55);
 854 }
 855
 856 STDCALL int
 857 mono_test_marshal_stringbuilder (char *s, int n)
 858 {
 859         const char m[] = "This is my message.  Isn't it nice?";
 860
 861         if (strcmp (s, "ABCD") != 0)
 862                 return 1;
 863         strncpy(s, m, n);
 864         s [n] = '\0';
 865         return 0;
 866 }
 867
 868 STDCALL int
 869 mono_test_marshal_stringbuilder_default (char *s, int n)
 870 {
 871         const char m[] = "This is my message.  Isn't it nice?";
 872
 873         strncpy(s, m, n);
 874         s [n] = '\0';
 875         return 0;
 876 }
 877
 878 STDCALL int
 879 mono_test_marshal_stringbuilder_unicode (gunichar2 *s, int n)
 880 {
 881         const char m[] = "This is my message.  Isn't it nice?";
 882         gunichar2* s2;
 883         glong len;
 884
 885         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
 886
 887         len = (len * 2) + 2;
 888         if (len > (n * 2))
 889                 len = n * 2;
 890         memcpy (s, s2, len);
 891
 892         g_free (s2);
 893
 894         return 0;
 895 }
 896
 897 typedef struct {
 898 #ifndef __GNUC__
 899     char a;
 900 #endif
 901 } EmptyStruct;
 902
 903 STDCALL int
 904 mono_test_marshal_empty_string_array (char **array)
 905 {
 906         return (array == NULL) ? 0 : 1;
 907 }
 908
 909 STDCALL int
 910 mono_test_marshal_string_array (char **array)
 911 {
 912         if (strcmp (array [0], "ABC"))
 913                 return 1;
 914         if (strcmp (array [1], "DEF"))
 915                 return 2;
 916
 917         if (array [2] != NULL)
 918                 return 3;
 919
 920         return 0;
 921 }
 922
 923 STDCALL int
 924 mono_test_marshal_byref_string_array (char ***array)
 925 {
 926         if (*array == NULL)
 927                 return 0;
 928
 929         if (strcmp ((*array) [0], "Alpha"))
 930                 return 2;
 931         if (strcmp ((*array) [1], "Beta"))
 932                 return 2;
 933         if (strcmp ((*array) [2], "Gamma"))
 934                 return 2;
 935
 936         return 1;
 937 }
 938
 939 STDCALL int
 940 mono_test_marshal_stringbuilder_array (char **array)
 941 {
 942         if (strcmp (array [0], "ABC"))
 943                 return 1;
 944         if (strcmp (array [1], "DEF"))
 945                 return 2;
 946
 947         strcpy (array [0], "DEF");
 948         strcpy (array [1], "ABC");
 949
 950         return 0;
 951 }
 952
 953 STDCALL int
 954 mono_test_marshal_unicode_string_array (gunichar2 **array, char **array2)
 955 {
 956         GError *error = NULL;
 957         char *s;
 958
 959         s = g_utf16_to_utf8 (array [0], -1, NULL, NULL, &error);
 960         if (strcmp (s, "ABC")) {
 961                 g_free (s);
 962                 return 1;
 963         }
 964         else
 965                 g_free (s);
 966
 967         s = g_utf16_to_utf8 (array [1], -1, NULL, NULL, &error);
 968         if (strcmp (s, "DEF")) {
 969                 g_free (s);
 970                 return 2;
 971         }
 972         else
 973                 g_free (s);
 974
 975         if (strcmp (array2 [0], "ABC"))
 976                 return 3;
 977
 978         if (strcmp (array2 [1], "DEF"))
 979                 return 4;
 980
 981         return 0;
 982 }
 983
 984 /* this does not work on Redhat gcc 2.96 */
 985 STDCALL int
 986 mono_test_empty_struct (int a, EmptyStruct es, int b)
 987 {
 988         // printf ("mono_test_empty_struct %d %d\n", a, b);
 989
 990         // Intel icc on ia64 passes 'es' in 2 registers
 991 #if defined(__ia64) && defined(__INTEL_COMPILER)
 992         return 0;
 993 #else
 994         if (a == 1 && b == 2)
 995                 return 0;
 996         return 1;
 997 #endif
 998 }
 999
1000 typedef struct {
1001        char a[100];
1002 } ByValStrStruct;
1003
1004 STDCALL ByValStrStruct *
1005 mono_test_byvalstr_gen (void)
1006 {
1007         ByValStrStruct *ret;
1008
1009         ret = malloc(sizeof(ByValStrStruct));
1010         memset(ret, 'a', sizeof(ByValStrStruct)-1);
1011         ret->a[sizeof(ByValStrStruct)-1] = 0;
1012
1013         return ret;
1014 }
1015
1016 STDCALL int
1017 mono_test_byvalstr_check (ByValStrStruct* data, char* correctString)
1018 {
1019         int ret;
1020
1021         ret = strcmp(data->a, correctString);
1022         // printf ("T1: %s\n", data->a);
1023         // printf ("T2: %s\n", correctString);
1024
1025         marshal_free (data);
1026         return (ret != 0);
1027 }
1028
1029 typedef struct {
1030         guint16 a[4];
1031         int  flag;
1032 } ByValStrStruct_Unicode;
1033
1034 STDCALL int
1035 mono_test_byvalstr_check_unicode (ByValStrStruct_Unicode *ref, int test)
1036 {
1037         if (ref->flag != 0x1234abcd){
1038                 printf ("overwritten data");
1039                 return 1;
1040         }
1041
1042         if (test == 1 || test == 3){
1043                 if (ref->a [0] != '1' ||
1044                     ref->a [1] != '2'   ||
1045                     ref->a [2] != '3')
1046                         return 1;
1047                 return 0;
1048         }
1049         if (test == 2){
1050                 if (ref->a [0] != '1' ||
1051                     ref->a [1] != '2')
1052                         return 1;
1053                 return 0;
1054         }
1055         return 10;
1056 }
1057
1058 STDCALL int
1059 NameManglingAnsi (char *data)
1060 {
1061         return data [0] + data [1] + data [2];
1062 }
1063
1064 STDCALL int
1065 NameManglingAnsiA (char *data)
1066 {
1067         g_assert_not_reached ();
1068 }
1069
1070 STDCALL int
1071 NameManglingAnsiW (char *data)
1072 {
1073         g_assert_not_reached ();
1074 }
1075
1076 STDCALL int
1077 NameManglingAnsi2A (char *data)
1078 {
1079         return data [0] + data [1] + data [2];
1080 }
1081
1082 STDCALL int
1083 NameManglingAnsi2W (char *data)
1084 {
1085         g_assert_not_reached ();
1086 }
1087
1088 STDCALL int
1089 NameManglingUnicode (char *data)
1090 {
1091         g_assert_not_reached ();
1092 }
1093
1094 STDCALL int
1095 NameManglingUnicodeW (gunichar2 *data)
1096 {
1097         return data [0] + data [1] + data [2];
1098 }
1099
1100 STDCALL int
1101 NameManglingUnicode2 (gunichar2 *data)
1102 {
1103         return data [0] + data [1] + data [2];
1104 }
1105
1106 STDCALL int
1107 NameManglingAutoW (char *data)
1108 {
1109 #ifdef WIN32
1110         return (data [0] + data [1] + data [2]) == 131 ? 0 : 1;
1111 #else
1112         g_assert_not_reached ();
1113 #endif
1114 }
1115
1116 STDCALL int
1117 NameManglingAuto (char *data)
1118 {
1119 #ifndef WIN32
1120         return (data [0] + data [1] + data [2]) == 198 ? 0 : 1;
1121 #else
1122         g_assert_not_reached ();
1123 #endif
1124 }
1125
1126 typedef int (STDCALL *intcharFunc)(const char*);
1127
1128 STDCALL void
1129 callFunction (intcharFunc f)
1130 {
1131         f ("ABC");
1132 }
1133
1134 typedef struct {
1135         const char* str;
1136         int i;
1137 } SimpleObj;
1138
1139 STDCALL int
1140 class_marshal_test0 (SimpleObj *obj1)
1141 {
1142         // printf ("class_marshal_test0 %s %d\n", obj1->str, obj1->i);
1143
1144         if (strcmp(obj1->str, "T1"))
1145                 return -1;
1146         if (obj1->i != 4)
1147                 return -2;
1148
1149         return 0;
1150 }
1151
1152 STDCALL int
1153 class_marshal_test4 (SimpleObj *obj1)
1154 {
1155         if (obj1)
1156                 return -1;
1157
1158         return 0;
1159 }
1160
1161 STDCALL void
1162 class_marshal_test1 (SimpleObj **obj1)
1163 {
1164         SimpleObj *res = malloc (sizeof (SimpleObj));
1165
1166         res->str = g_strdup ("ABC");
1167         res->i = 5;
1168
1169         *obj1 = res;
1170 }
1171
1172 STDCALL int
1173 class_marshal_test2 (SimpleObj **obj1)
1174 {
1175         // printf ("class_marshal_test2 %s %d\n", (*obj1)->str, (*obj1)->i);
1176
1177         if (strcmp((*obj1)->str, "ABC"))
1178                 return -1;
1179         if ((*obj1)->i != 5)
1180                 return -2;
1181
1182         return 0;
1183 }
1184
1185 STDCALL int
1186 string_marshal_test0 (char *str)
1187 {
1188         if (strcmp (str, "TEST0"))
1189                 return -1;
1190
1191         return 0;
1192 }
1193
1194 STDCALL void
1195 string_marshal_test1 (const char **str)
1196 {
1197         *str = "TEST1";
1198 }
1199
1200 STDCALL int
1201 string_marshal_test2 (char **str)
1202 {
1203         // printf ("string_marshal_test2 %s\n", *str);
1204
1205         if (strcmp (*str, "TEST1"))
1206                 return -1;
1207
1208         return 0;
1209 }
1210
1211 STDCALL int
1212 string_marshal_test3 (char *str)
1213 {
1214         if (str)
1215                 return -1;
1216
1217         return 0;
1218 }
1219
1220 typedef struct {
1221         int a;
1222         int b;
1223 } BlittableClass;
1224
1225 STDCALL BlittableClass*
1226 TestBlittableClass (BlittableClass *vl)
1227 {
1228         BlittableClass *res;
1229
1230         // printf ("TestBlittableClass %d %d\n", vl->a, vl->b);
1231
1232         if (vl) {
1233                 vl->a++;
1234                 vl->b++;
1235
1236                 res = g_new0 (BlittableClass, 1);
1237                 memcpy (res, vl, sizeof (BlittableClass));
1238         } else {
1239                 res = g_new0 (BlittableClass, 1);
1240                 res->a = 42;
1241                 res->b = 43;
1242         }
1243
1244         return res;
1245 }
1246
1247 typedef struct OSVERSIONINFO_STRUCT
1248 {
1249         int a;
1250         int b;
1251 } OSVERSIONINFO_STRUCT;
1252
1253 STDCALL int
1254 MyGetVersionEx (OSVERSIONINFO_STRUCT *osvi)
1255 {
1256
1257         // printf ("GOT %d %d\n", osvi->a, osvi->b);
1258
1259         osvi->a += 1;
1260         osvi->b += 1;
1261
1262         return osvi->a + osvi->b;
1263 }
1264
1265 STDCALL int
1266 BugGetVersionEx (int a, int b, int c, int d, int e, int f, int g, int h, OSVERSIONINFO_STRUCT *osvi)
1267 {
1268
1269         // printf ("GOT %d %d\n", osvi->a, osvi->b);
1270
1271         osvi->a += 1;
1272         osvi->b += 1;
1273
1274         return osvi->a + osvi->b;
1275 }
1276
1277 STDCALL int
1278 mono_test_marshal_point (point pt)
1279 {
1280         // printf("point %g %g\n", pt.x, pt.y);
1281         if (pt.x == 1.25 && pt.y == 3.5)
1282                 return 0;
1283
1284         return 1;
1285 }
1286
1287 typedef struct {
1288         int x;
1289         double y;
1290 } mixed_point;
1291
1292 STDCALL int
1293 mono_test_marshal_mixed_point (mixed_point pt)
1294 {
1295         // printf("mixed point %d %g\n", pt.x, pt.y);
1296         if (pt.x == 5 && pt.y == 6.75)
1297                 return 0;
1298
1299         return 1;
1300 }
1301
1302 STDCALL int
1303 mono_test_marshal_mixed_point_2 (mixed_point *pt)
1304 {
1305         if (pt->x != 5 || pt->y != 6.75)
1306                 return 1;
1307
1308         pt->x = 10;
1309         pt->y = 12.35;
1310
1311         return 0;
1312 }
1313
1314 STDCALL int
1315 marshal_test_ref_bool(int i, char *b1, short *b2, int *b3)
1316 {
1317     int res = 1;
1318     if (*b1 != 0 && *b1 != 1)
1319         return 1;
1320     if (*b2 != 0 && *b2 != -1) /* variant_bool */
1321         return 1;
1322     if (*b3 != 0 && *b3 != 1)
1323         return 1;
1324     if (i == ((*b1 << 2) | (-*b2 << 1) | *b3))
1325         res = 0;
1326     *b1 = !*b1;
1327     *b2 = ~*b2;
1328     *b3 = !*b3;
1329     return res;
1330 }
1331
1332 struct BoolStruct
1333 {
1334     int i;
1335     char b1;
1336     short b2; /* variant_bool */
1337     int b3;
1338 };
1339
1340 STDCALL int
1341 marshal_test_bool_struct(struct BoolStruct *s)
1342 {
1343     int res = 1;
1344     if (s->b1 != 0 && s->b1 != 1)
1345         return 1;
1346     if (s->b2 != 0 && s->b2 != -1)
1347         return 1;
1348     if (s->b3 != 0 && s->b3 != 1)
1349         return 1;
1350     if (s->i == ((s->b1 << 2) | (-s->b2 << 1) | s->b3))
1351         res = 0;
1352     s->b1 = !s->b1;
1353     s->b2 = ~s->b2;
1354     s->b3 = !s->b3;
1355     return res;
1356 }
1357
1358 STDCALL void
1359 mono_test_last_error (int err)
1360 {
1361 #ifdef WIN32
1362         SetLastError (err);
1363 #else
1364         errno = err;
1365 #endif
1366 }
1367
1368 STDCALL int
1369 mono_test_asany (void *ptr, int what)
1370 {
1371         switch (what) {
1372         case 1:
1373                 return (*(int*)ptr == 5) ? 0 : 1;
1374         case 2:
1375                 return strcmp (ptr, "ABC") == 0 ? 0 : 1;
1376         case 3: {
1377                 simplestruct2 ss = *(simplestruct2*)ptr;
1378
1379                 if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
1380             !strcmp (ss.d, "TEST") &&
1381             ss.e == 99 && ss.f == 1.5 && ss.g == 42 && ss.h == (guint64)123)
1382                         return 0;
1383                 else
1384                         return 1;
1385         }
1386         case 4: {
1387                 GError *error = NULL;
1388                 char *s;
1389
1390                 s = g_utf16_to_utf8 (ptr, -1, NULL, NULL, &error);
1391                 if (!strcmp (s, "ABC")) {
1392                         g_free (s);
1393                         return 0;
1394                 }
1395                 else {
1396                         g_free (s);
1397                         return 1;
1398                 }
1399         }
1400         default:
1401                 g_assert_not_reached ();
1402         }
1403
1404         return 1;
1405 }
1406
1407 typedef struct
1408 {
1409         int i;
1410         int j;
1411         int k;
1412         char *s;
1413 } AsAnyStruct;
1414
1415 STDCALL int
1416 mono_test_marshal_asany_in (void* ptr)
1417 {
1418         AsAnyStruct* asAny = ptr;
1419         int res = asAny->i + asAny->j + asAny->k;
1420
1421         return res;
1422 }
1423
1424 STDCALL int
1425 mono_test_marshal_asany_inout (void* ptr)
1426 {
1427         AsAnyStruct* asAny = ptr;
1428         int res = asAny->i + asAny->j + asAny->k;
1429
1430         marshal_free (asAny->s);
1431
1432         asAny->i = 10;
1433         asAny->j = 20;
1434         asAny->k = 30;
1435         asAny->s = 0;
1436
1437         return res;
1438 }
1439
1440 STDCALL int
1441 mono_test_marshal_asany_out (void* ptr)
1442 {
1443         AsAnyStruct* asAny = ptr;
1444         int res = asAny->i + asAny->j + asAny->k;
1445
1446         asAny->i = 10;
1447         asAny->j = 20;
1448         asAny->k = 30;
1449         asAny->s = 0;
1450
1451         return res;
1452 }
1453
1454 /*
1455  * AMD64 marshalling tests.
1456  */
1457
1458 typedef struct amd64_struct1 {
1459         int i;
1460         int j;
1461         int k;
1462         int l;
1463 } amd64_struct1;
1464
1465 STDCALL amd64_struct1
1466 mono_test_marshal_amd64_pass_return_struct1 (amd64_struct1 s)
1467 {
1468         s.i ++;
1469         s.j ++;
1470         s.k ++;
1471         s.l ++;
1472
1473         return s;
1474 }
1475
1476 typedef struct amd64_struct2 {
1477         int i;
1478         int j;
1479 } amd64_struct2;
1480
1481 STDCALL amd64_struct2
1482 mono_test_marshal_amd64_pass_return_struct2 (amd64_struct2 s)
1483 {
1484         s.i ++;
1485         s.j ++;
1486
1487         return s;
1488 }
1489
1490 typedef struct amd64_struct3 {
1491         int i;
1492 } amd64_struct3;
1493
1494 STDCALL amd64_struct3
1495 mono_test_marshal_amd64_pass_return_struct3 (amd64_struct3 s)
1496 {
1497         s.i ++;
1498
1499         return s;
1500 }
1501
1502 typedef struct amd64_struct4 {
1503         double d1, d2;
1504 } amd64_struct4;
1505
1506 STDCALL amd64_struct4
1507 mono_test_marshal_amd64_pass_return_struct4 (amd64_struct4 s)
1508 {
1509         s.d1 ++;
1510         s.d2 ++;
1511
1512         return s;
1513 }
1514
1515 /*
1516  * IA64 marshalling tests.
1517  */
1518 typedef struct test_struct5 {
1519         float d1, d2;
1520 } test_struct5;
1521
1522 STDCALL test_struct5
1523 mono_test_marshal_ia64_pass_return_struct5 (double d1, double d2, test_struct5 s, double d3, double d4)
1524 {
1525         s.d1 += d1 + d2;
1526         s.d2 += d3 + d4;
1527
1528         return s;
1529 }
1530
1531 typedef struct test_struct6 {
1532         double d1, d2;
1533 } test_struct6;
1534
1535 STDCALL test_struct6
1536 mono_test_marshal_ia64_pass_return_struct6 (double d1, double d2, test_struct6 s, double d3, double d4)
1537 {
1538         s.d1 += d1 + d2;
1539         s.d2 += d3 + d4;
1540
1541         return s;
1542 }
1543
1544 static guint32 custom_res [2];
1545
1546 STDCALL void*
1547 mono_test_marshal_pass_return_custom (int i, guint32 *ptr, int j)
1548 {
1549         /* ptr will be freed by CleanupNative, so make a copy */
1550         custom_res [0] = 0; /* not allocated by AllocHGlobal */
1551         custom_res [1] = ptr [1];
1552
1553         return &custom_res;
1554 }
1555
1556 STDCALL int
1557 mono_test_marshal_pass_out_custom (int i, guint32 **ptr, int j)
1558 {
1559         custom_res [0] = 0;
1560         custom_res [1] = i + j + 10;
1561
1562         *ptr = custom_res;
1563
1564         return 0;
1565 }
1566
1567 STDCALL int
1568 mono_test_marshal_pass_inout_custom (int i, guint32 *ptr, int j)
1569 {
1570         ptr [0] = 0;
1571         ptr [1] = i + ptr [1] + j;
1572
1573         return 0;
1574 }
1575
1576 STDCALL int
1577 mono_test_marshal_pass_out_byval_custom (int i, guint32 *ptr, int j)
1578 {
1579         return ptr == NULL ? 0 : 1;
1580 }
1581
1582 STDCALL int
1583 mono_test_marshal_pass_byref_custom (int i, guint32 **ptr, int j)
1584 {
1585         (*ptr)[1] += i + j;
1586
1587         return 0;
1588 }
1589
1590 STDCALL void*
1591 mono_test_marshal_pass_return_custom2 (int i, guint32 *ptr, int j)
1592 {
1593         g_assert_not_reached ();
1594
1595         return NULL;
1596 }
1597
1598 STDCALL void*
1599 mono_test_marshal_pass_return_custom_null (int i, guint32 *ptr, int j)
1600 {
1601         g_assert (ptr == NULL);
1602
1603         return NULL;
1604 }
1605
1606 typedef void *(STDCALL *PassReturnPtrDelegate) (void *ptr);
1607
1608 STDCALL int
1609 mono_test_marshal_pass_return_custom_in_delegate (PassReturnPtrDelegate del)
1610 {
1611         guint32 buf [2];
1612         guint32 res;
1613         guint32 *ptr;
1614
1615         buf [0] = 0;
1616         buf [1] = 10;
1617
1618         ptr = del (&buf);
1619
1620         res = ptr [1];
1621
1622 #ifdef WIN32
1623         /* FIXME: Freed with FreeHGlobal */
1624 #else
1625         g_free (ptr);
1626 #endif
1627
1628         return res;
1629 }
1630
1631 STDCALL int
1632 mono_test_marshal_pass_return_custom_null_in_delegate (PassReturnPtrDelegate del)
1633 {
1634         void *ptr = del (NULL);
1635
1636         return (ptr == NULL) ? 15 : 0;
1637 }
1638
1639 typedef void (STDCALL *CustomOutParamDelegate) (void **pptr);
1640
1641 STDCALL int
1642 mono_test_marshal_custom_out_param_delegate (CustomOutParamDelegate del)
1643 {
1644         void* pptr = del;
1645
1646         del (&pptr);
1647
1648         if(pptr != NULL)
1649                 return 1;
1650
1651         return 0;
1652 }
1653
1654 typedef int (STDCALL *ReturnEnumDelegate) (int e);
1655
1656 STDCALL int
1657 mono_test_marshal_return_enum_delegate (ReturnEnumDelegate func)
1658 {
1659         return func (1);
1660 }
1661
1662 typedef struct {
1663         int a, b, c;
1664         gint64 d;
1665 } BlittableStruct;
1666
1667 typedef BlittableStruct (STDCALL *SimpleDelegate10) (BlittableStruct ss);
1668
1669 STDCALL int
1670 mono_test_marshal_blittable_struct_delegate (SimpleDelegate10 delegate)
1671 {
1672         BlittableStruct ss, res;
1673
1674         ss.a = 1;
1675         ss.b = 2;
1676         ss.c = 3;
1677         ss.d = 55;
1678
1679         res = delegate (ss);
1680         if (! ((res.a == -1) && (res.b == -2) && (res.c == -3) && (res.d == -55)))
1681                 return 1;
1682
1683         return 0;
1684 }
1685
1686 STDCALL int
1687 mono_test_stdcall_name_mangling (int a, int b, int c)
1688 {
1689         return a + b + c;
1690 }
1691
1692 /*
1693  * PASSING AND RETURNING SMALL STRUCTURES FROM DELEGATES TESTS
1694  */
1695
1696 typedef struct {
1697         int i;
1698 } SmallStruct1;
1699
1700 typedef SmallStruct1 (STDCALL *SmallStructDelegate1) (SmallStruct1 ss);
1701
1702 STDCALL int
1703 mono_test_marshal_small_struct_delegate1 (SmallStructDelegate1 delegate)
1704 {
1705         SmallStruct1 ss, res;
1706
1707         ss.i = 1;
1708
1709         res = delegate (ss);
1710         if (! (res.i == -1))
1711                 return 1;
1712
1713         return 0;
1714 }
1715
1716 typedef struct {
1717         gint16 i, j;
1718 } SmallStruct2;
1719
1720 typedef SmallStruct2 (STDCALL *SmallStructDelegate2) (SmallStruct2 ss);
1721
1722 STDCALL int
1723 mono_test_marshal_small_struct_delegate2 (SmallStructDelegate2 delegate)
1724 {
1725         SmallStruct2 ss, res;
1726
1727         ss.i = 2;
1728         ss.j = 3;
1729
1730         res = delegate (ss);
1731         if (! ((res.i == -2) && (res.j == -3)))
1732                 return 1;
1733
1734         return 0;
1735 }
1736
1737 typedef struct {
1738         gint16 i;
1739         gint8 j;
1740 } SmallStruct3;
1741
1742 typedef SmallStruct3 (STDCALL *SmallStructDelegate3) (SmallStruct3 ss);
1743
1744 STDCALL int
1745 mono_test_marshal_small_struct_delegate3 (SmallStructDelegate3 delegate)
1746 {
1747         SmallStruct3 ss, res;
1748
1749         ss.i = 1;
1750         ss.j = 2;
1751
1752         res = delegate (ss);
1753         if (! ((res.i == -1) && (res.j == -2)))
1754                 return 1;
1755
1756         return 0;
1757 }
1758
1759 typedef struct {
1760         gint16 i;
1761 } SmallStruct4;
1762
1763 typedef SmallStruct4 (STDCALL *SmallStructDelegate4) (SmallStruct4 ss);
1764
1765 STDCALL int
1766 mono_test_marshal_small_struct_delegate4 (SmallStructDelegate4 delegate)
1767 {
1768         SmallStruct4 ss, res;
1769
1770         ss.i = 1;
1771
1772         res = delegate (ss);
1773         if (! (res.i == -1))
1774                 return 1;
1775
1776         return 0;
1777 }
1778
1779 typedef struct {
1780         gint64 i;
1781 } SmallStruct5;
1782
1783 typedef SmallStruct5 (STDCALL *SmallStructDelegate5) (SmallStruct5 ss);
1784
1785 STDCALL int
1786 mono_test_marshal_small_struct_delegate5 (SmallStructDelegate5 delegate)
1787 {
1788         SmallStruct5 ss, res;
1789
1790         ss.i = 5;
1791
1792         res = delegate (ss);
1793         if (! (res.i == -5))
1794                 return 1;
1795
1796         return 0;
1797 }
1798
1799 typedef struct {
1800         int i, j;
1801 } SmallStruct6;
1802
1803 typedef SmallStruct6 (STDCALL *SmallStructDelegate6) (SmallStruct6 ss);
1804
1805 STDCALL int
1806 mono_test_marshal_small_struct_delegate6 (SmallStructDelegate6 delegate)
1807 {
1808         SmallStruct6 ss, res;
1809
1810         ss.i = 1;
1811         ss.j = 2;
1812
1813         res = delegate (ss);
1814         if (! ((res.i == -1) && (res.j == -2)))
1815                 return 1;
1816
1817         return 0;
1818 }
1819
1820 typedef struct {
1821         int i;
1822         gint16 j;
1823 } SmallStruct7;
1824
1825 typedef SmallStruct7 (STDCALL *SmallStructDelegate7) (SmallStruct7 ss);
1826
1827 STDCALL int
1828 mono_test_marshal_small_struct_delegate7 (SmallStructDelegate7 delegate)
1829 {
1830         SmallStruct7 ss, res;
1831
1832         ss.i = 1;
1833         ss.j = 2;
1834
1835         res = delegate (ss);
1836         if (! ((res.i == -1) && (res.j == -2)))
1837                 return 1;
1838
1839         return 0;
1840 }
1841
1842 typedef struct {
1843         float i;
1844 } SmallStruct8;
1845
1846 typedef SmallStruct8 (STDCALL *SmallStructDelegate8) (SmallStruct8 ss);
1847
1848 STDCALL int
1849 mono_test_marshal_small_struct_delegate8 (SmallStructDelegate8 delegate)
1850 {
1851         SmallStruct8 ss, res;
1852
1853         ss.i = 1.0;
1854
1855         res = delegate (ss);
1856         if (! ((res.i == -1.0)))
1857                 return 1;
1858
1859         return 0;
1860 }
1861
1862 typedef struct {
1863         double i;
1864 } SmallStruct9;
1865
1866 typedef SmallStruct9 (STDCALL *SmallStructDelegate9) (SmallStruct9 ss);
1867
1868 STDCALL int
1869 mono_test_marshal_small_struct_delegate9 (SmallStructDelegate9 delegate)
1870 {
1871         SmallStruct9 ss, res;
1872
1873         ss.i = 1.0;
1874
1875         res = delegate (ss);
1876         if (! ((res.i == -1.0)))
1877                 return 1;
1878
1879         return 0;
1880 }
1881
1882 typedef struct {
1883         float i, j;
1884 } SmallStruct10;
1885
1886 typedef SmallStruct10 (STDCALL *SmallStructDelegate10) (SmallStruct10 ss);
1887
1888 STDCALL int
1889 mono_test_marshal_small_struct_delegate10 (SmallStructDelegate10 delegate)
1890 {
1891         SmallStruct10 ss, res;
1892
1893         ss.i = 1.0;
1894         ss.j = 2.0;
1895
1896         res = delegate (ss);
1897         if (! ((res.i == -1.0) && (res.j == -2.0)))
1898                 return 1;
1899
1900         return 0;
1901 }
1902
1903 typedef struct {
1904         float i;
1905         int j;
1906 } SmallStruct11;
1907
1908 typedef SmallStruct11 (STDCALL *SmallStructDelegate11) (SmallStruct11 ss);
1909
1910 STDCALL int
1911 mono_test_marshal_small_struct_delegate11 (SmallStructDelegate11 delegate)
1912 {
1913         SmallStruct11 ss, res;
1914
1915         ss.i = 1.0;
1916         ss.j = 2;
1917
1918         res = delegate (ss);
1919         if (! ((res.i == -1.0) && (res.j == -2)))
1920                 return 1;
1921
1922         return 0;
1923 }
1924
1925 typedef int (STDCALL *ArrayDelegate) (int i, char *j, void *arr);
1926
1927 STDCALL int
1928 mono_test_marshal_array_delegate (void *arr, int len, ArrayDelegate del)
1929 {
1930         return del (len, NULL, arr);
1931 }
1932
1933 STDCALL int
1934 mono_test_marshal_out_array_delegate (int *arr, int len, ArrayDelegate del)
1935 {
1936         del (len, NULL, arr);
1937
1938         if ((arr [0] != 1) || (arr [1] != 2))
1939                 return 1;
1940         else
1941                 return 0;
1942 }
1943
1944 typedef gunichar2* (STDCALL *UnicodeStringDelegate) (gunichar2 *message);
1945
1946 STDCALL int
1947 mono_test_marshal_return_unicode_string_delegate (UnicodeStringDelegate del)
1948 {
1949         const char m[] = "abcdef";
1950         gunichar2 *s2, *res;
1951         glong len;
1952
1953         s2 = g_utf8_to_utf16 (m, -1, NULL, &len, NULL);
1954
1955         res = del (s2);
1956
1957         marshal_free (res);
1958
1959         return 0;
1960 }
1961
1962 STDCALL int
1963 mono_test_marshal_out_string_array_delegate (char **arr, int len, ArrayDelegate del)
1964 {
1965         del (len, NULL, arr);
1966
1967         if (!strcmp (arr [0], "ABC") && !strcmp (arr [1], "DEF"))
1968                 return 0;
1969         else
1970                 return 1;
1971 }
1972
1973 typedef int (*CdeclDelegate) (int i, int j);
1974
1975 STDCALL int
1976 mono_test_marshal_cdecl_delegate (CdeclDelegate del)
1977 {
1978         int i;
1979
1980         for (i = 0; i < 1000; ++i)
1981                 del (1, 2);
1982
1983         return 0;
1984 }
1985
1986 typedef char** (*ReturnStringArrayDelegate) (int i);
1987
1988 STDCALL int
1989 mono_test_marshal_return_string_array_delegate (ReturnStringArrayDelegate d)
1990 {
1991         char **arr = d (2);
1992         int res;
1993
1994         if (arr == NULL)
1995                 return 3;
1996
1997         if (strcmp (arr [0], "ABC") || strcmp (arr [1], "DEF"))
1998                 res = 1;
1999         else
2000                 res = 0;
2001
2002         marshal_free (arr);
2003
2004         return res;
2005 }
2006
2007 STDCALL int
2008 add_delegate (int i, int j)
2009 {
2010         return i + j;
2011 }
2012
2013 STDCALL gpointer
2014 mono_test_marshal_return_fnptr (void)
2015 {
2016         return &add_delegate;
2017 }
2018
2019 STDCALL int
2020 mono_xr (int code)
2021 {
2022         printf ("codigo %x\n", code);
2023         return code + 1234;
2024 }
2025
2026 typedef struct {
2027         int handle;
2028 } HandleRef;
2029
2030 STDCALL HandleRef
2031 mono_xr_as_handle (int code)
2032 {
2033         HandleRef ref;
2034
2035         return ref;
2036 }
2037
2038 typedef struct {
2039         int   a;
2040         void *handle1;
2041         void *handle2;
2042         int   b;
2043 } HandleStructs;
2044
2045 STDCALL int
2046 mono_safe_handle_struct_ref (HandleStructs *x)
2047 {
2048         printf ("Dingus Ref! \n");
2049         printf ("Values: %d %d %d %d\n", x->a, x->b, x->handle1, x->handle2);
2050         if (x->a != 1234)
2051                 return 1;
2052         if (x->b != 8743)
2053                 return 2;
2054
2055         if (x->handle1 != (void*) 0x7080feed)
2056                 return 3;
2057
2058         if (x->handle2 != (void*) 0x1234abcd)
2059                 return 4;
2060
2061         return 0xf00d;
2062 }
2063
2064 STDCALL int
2065 mono_safe_handle_struct (HandleStructs x)
2066 {
2067         printf ("Dingus Standard! \n");
2068         printf ("Values: %d %d %d %d\n", x.a, x.b, x.handle1, x.handle2);
2069         if (x.a != 1234)
2070                 return 1;
2071         if (x.b != 8743)
2072                 return 2;
2073
2074         if (x.handle1 != (void*) 0x7080feed)
2075                 return 3;
2076
2077         if (x.handle2 != (void*) 0x1234abcd)
2078                 return 4;
2079
2080         return 0xf00f;
2081 }
2082
2083 typedef struct {
2084         void *a;
2085 } TrivialHandle;
2086
2087 STDCALL int
2088 mono_safe_handle_struct_simple (TrivialHandle x)
2089 {
2090         printf ("The value is %d\n", x.a);
2091         return ((int)x.a) * 2;
2092 }
2093
2094 STDCALL int
2095 mono_safe_handle_return ()
2096 {
2097         return 0x1000f00d;
2098 }
2099
2100 STDCALL void
2101 mono_safe_handle_ref (void **handle)
2102 {
2103         if (*handle != 0){
2104                 *handle = (void *) 0xbad;
2105                 return;
2106         }
2107
2108         *handle = (void *) 0x800d;
2109 }
2110 /*
2111  * COM INTEROP TESTS
2112  */
2113
2114 #ifdef WIN32
2115
2116 STDCALL int
2117 mono_test_marshal_bstr_in(BSTR bstr)
2118 {
2119         if (!wcscmp(bstr, L"mono_test_marshal_bstr_in"))
2120                 return 0;
2121         return 1;
2122 }
2123
2124 STDCALL int
2125 mono_test_marshal_bstr_out(BSTR* bstr)
2126 {
2127         *bstr = SysAllocString(L"mono_test_marshal_bstr_out");
2128         return 0;
2129 }
2130
2131 STDCALL int
2132 mono_test_marshal_bstr_in_null(BSTR bstr)
2133 {
2134         if (!bstr)
2135                 return 0;
2136         return 1;
2137 }
2138
2139 STDCALL int
2140 mono_test_marshal_bstr_out_null(BSTR* bstr)
2141 {
2142         *bstr = NULL;
2143         return 0;
2144 }
2145
2146 STDCALL int
2147 mono_test_marshal_variant_in_sbyte(VARIANT variant)
2148 {
2149         if (variant.vt == VT_I1 && variant.cVal == 100)
2150                 return 0;
2151         return 1;
2152 }
2153
2154 STDCALL int
2155 mono_test_marshal_variant_in_byte(VARIANT variant)
2156 {
2157         if (variant.vt == VT_UI1 && variant.bVal == 100)
2158                 return 0;
2159         return 1;
2160 }
2161
2162 STDCALL int
2163 mono_test_marshal_variant_in_short(VARIANT variant)
2164 {
2165         if (variant.vt == VT_I2 && variant.iVal == 314)
2166                 return 0;
2167         return 1;
2168 }
2169
2170 STDCALL int
2171 mono_test_marshal_variant_in_ushort(VARIANT variant)
2172 {
2173         if (variant.vt == VT_UI2 && variant.uiVal == 314)
2174                 return 0;
2175         return 1;
2176 }
2177
2178 STDCALL int
2179 mono_test_marshal_variant_in_int(VARIANT variant)
2180 {
2181         if (variant.vt == VT_I4 && variant.lVal == 314)
2182                 return 0;
2183         return 1;
2184 }
2185
2186 STDCALL int
2187 mono_test_marshal_variant_in_uint(VARIANT variant)
2188 {
2189         if (variant.vt == VT_UI4 && variant.ulVal == 314)
2190                 return 0;
2191         return 1;
2192 }
2193
2194 STDCALL int
2195 mono_test_marshal_variant_in_long(VARIANT variant)
2196 {
2197         if (variant.vt == VT_I8 && variant.llVal == 314)
2198                 return 0;
2199         return 1;
2200 }
2201
2202 STDCALL int
2203 mono_test_marshal_variant_in_ulong(VARIANT variant)
2204 {
2205         if (variant.vt == VT_UI8 && variant.ullVal == 314)
2206                 return 0;
2207         return 1;
2208 }
2209
2210 STDCALL int
2211 mono_test_marshal_variant_in_float(VARIANT variant)
2212 {
2213         if (variant.vt == VT_R4 && (variant.fltVal - 3.14)/3.14 < .001)
2214                 return 0;
2215         return 1;
2216 }
2217
2218 STDCALL int
2219 mono_test_marshal_variant_in_double(VARIANT variant)
2220 {
2221         if (variant.vt == VT_R8 && (variant.dblVal - 3.14)/3.14 < .001)
2222                 return 0;
2223         return 1;
2224 }
2225
2226 STDCALL int
2227 mono_test_marshal_variant_in_bstr(VARIANT variant)
2228 {
2229         if (variant.vt == VT_BSTR && !wcscmp(variant.bstrVal, L"PI"))
2230                 return 0;
2231         return 1;
2232 }
2233
2234 STDCALL int
2235 mono_test_marshal_variant_in_bool_true (VARIANT variant)
2236 {
2237         if (variant.vt == VT_BOOL && variant.boolVal == VARIANT_TRUE)
2238                 return 0;
2239         return 1;
2240 }
2241
2242 STDCALL int
2243 mono_test_marshal_variant_in_bool_false (VARIANT variant)
2244 {
2245         if (variant.vt == VT_BOOL && variant.boolVal == VARIANT_FALSE)
2246                 return 0;
2247         return 1;
2248 }
2249
2250 STDCALL int
2251 mono_test_marshal_variant_out_sbyte(VARIANT* variant)
2252 {
2253         variant->vt = VT_I1;
2254         variant->cVal = 100;
2255
2256         return 0;
2257 }
2258
2259 STDCALL int
2260 mono_test_marshal_variant_out_byte(VARIANT* variant)
2261 {
2262         variant->vt = VT_UI1;
2263         variant->bVal = 100;
2264
2265         return 0;
2266 }
2267
2268 STDCALL int
2269 mono_test_marshal_variant_out_short(VARIANT* variant)
2270 {
2271         variant->vt = VT_I2;
2272         variant->iVal = 314;
2273
2274         return 0;
2275 }
2276
2277 STDCALL int
2278 mono_test_marshal_variant_out_ushort(VARIANT* variant)
2279 {
2280         variant->vt = VT_UI2;
2281         variant->uiVal = 314;
2282
2283         return 0;
2284 }
2285
2286 STDCALL int
2287 mono_test_marshal_variant_out_int(VARIANT* variant)
2288 {
2289         variant->vt = VT_I4;
2290         variant->lVal = 314;
2291
2292         return 0;
2293 }
2294
2295 STDCALL int
2296 mono_test_marshal_variant_out_uint(VARIANT* variant)
2297 {
2298         variant->vt = VT_UI4;
2299         variant->ulVal = 314;
2300
2301         return 0;
2302 }
2303
2304 STDCALL int
2305 mono_test_marshal_variant_out_long(VARIANT* variant)
2306 {
2307         variant->vt = VT_I8;
2308         variant->llVal = 314;
2309
2310         return 0;
2311 }
2312
2313 STDCALL int
2314 mono_test_marshal_variant_out_ulong(VARIANT* variant)
2315 {
2316         variant->vt = VT_UI8;
2317         variant->ullVal = 314;
2318
2319         return 0;
2320 }
2321
2322 STDCALL int
2323 mono_test_marshal_variant_out_float(VARIANT* variant)
2324 {
2325         variant->vt = VT_R4;
2326         variant->fltVal = 3.14;
2327
2328         return 0;
2329 }
2330
2331 STDCALL int
2332 mono_test_marshal_variant_out_double(VARIANT* variant)
2333 {
2334         variant->vt = VT_R8;
2335         variant->dblVal = 3.14;
2336
2337         return 0;
2338 }
2339
2340 STDCALL int
2341 mono_test_marshal_variant_out_bstr(VARIANT* variant)
2342 {
2343         variant->vt = VT_BSTR;
2344         variant->bstrVal = SysAllocString(L"PI");
2345
2346         return 0;
2347 }
2348
2349 STDCALL int
2350 mono_test_marshal_variant_out_bool_true (VARIANT* variant)
2351 {
2352         variant->vt = VT_BOOL;
2353         variant->boolVal = VARIANT_TRUE;
2354
2355         return 0;
2356 }
2357
2358 STDCALL int
2359 mono_test_marshal_variant_out_bool_false (VARIANT* variant)
2360 {
2361         variant->vt = VT_BOOL;
2362         variant->boolVal = VARIANT_FALSE;
2363
2364         return 0;
2365 }
2366
2367 typedef int (STDCALL *VarFunc) (int vt, VARIANT variant);
2368 typedef int (STDCALL *VarRefFunc) (int vt, VARIANT* variant);
2369
2370 STDCALL int
2371 mono_test_marshal_variant_in_sbyte_unmanaged(VarFunc func)
2372 {
2373         VARIANT vt;
2374         vt.vt = VT_I1;
2375         vt.cVal = -100;
2376         return func (VT_I1, vt);
2377 }
2378
2379 STDCALL int
2380 mono_test_marshal_variant_in_byte_unmanaged(VarFunc func)
2381 {
2382         VARIANT vt;
2383         vt.vt = VT_UI1;
2384         vt.bVal = 100;
2385         return func (VT_UI1, vt);
2386 }
2387
2388 STDCALL int
2389 mono_test_marshal_variant_in_short_unmanaged(VarFunc func)
2390 {
2391         VARIANT vt;
2392         vt.vt = VT_I2;
2393         vt.iVal = -100;
2394         return func (VT_I2, vt);
2395 }
2396
2397 STDCALL int
2398 mono_test_marshal_variant_in_ushort_unmanaged(VarFunc func)
2399 {
2400         VARIANT vt;
2401         vt.vt = VT_UI2;
2402         vt.uiVal = 100;
2403         return func (VT_UI2, vt);
2404 }
2405
2406 STDCALL int
2407 mono_test_marshal_variant_in_int_unmanaged(VarFunc func)
2408 {
2409         VARIANT vt;
2410         vt.vt = VT_I4;
2411         vt.lVal = -100;
2412         return func (VT_I4, vt);
2413 }
2414
2415 STDCALL int
2416 mono_test_marshal_variant_in_uint_unmanaged(VarFunc func)
2417 {
2418         VARIANT vt;
2419         vt.vt = VT_UI4;
2420         vt.ulVal = 100;
2421         return func (VT_UI4, vt);
2422 }
2423
2424 STDCALL int
2425 mono_test_marshal_variant_in_long_unmanaged(VarFunc func)
2426 {
2427         VARIANT vt;
2428         vt.vt = VT_I8;
2429         vt.llVal = -100;
2430         return func (VT_I8, vt);
2431 }
2432
2433 STDCALL int
2434 mono_test_marshal_variant_in_ulong_unmanaged(VarFunc func)
2435 {
2436         VARIANT vt;
2437         vt.vt = VT_UI8;
2438         vt.ullVal = 100;
2439         return func (VT_UI8, vt);
2440 }
2441
2442 STDCALL int
2443 mono_test_marshal_variant_in_float_unmanaged(VarFunc func)
2444 {
2445         VARIANT vt;
2446         vt.vt = VT_R4;
2447         vt.fltVal = 3.14;
2448         return func (VT_R4, vt);
2449 }
2450
2451 STDCALL int
2452 mono_test_marshal_variant_in_double_unmanaged(VarFunc func)
2453 {
2454         VARIANT vt;
2455         vt.vt = VT_R8;
2456         vt.dblVal = 3.14;
2457         return func (VT_R8, vt);
2458 }
2459
2460 STDCALL int
2461 mono_test_marshal_variant_in_bstr_unmanaged(VarFunc func)
2462 {
2463         VARIANT vt;
2464         vt.vt = VT_BSTR;
2465         vt.bstrVal = SysAllocString(L"PI");
2466         return func (VT_BSTR, vt);
2467 }
2468
2469 STDCALL int
2470 mono_test_marshal_variant_in_bool_true_unmanaged(VarFunc func)
2471 {
2472         VARIANT vt;
2473         vt.vt = VT_BOOL;
2474         vt.boolVal = VARIANT_TRUE;
2475         return func (VT_BOOL, vt);
2476 }
2477
2478 STDCALL int
2479 mono_test_marshal_variant_in_bool_false_unmanaged(VarFunc func)
2480 {
2481         VARIANT vt;
2482         vt.vt = VT_BOOL;
2483         vt.boolVal = VARIANT_FALSE;
2484         return func (VT_BOOL, vt);
2485 }
2486
2487 STDCALL int
2488 mono_test_marshal_variant_out_sbyte_unmanaged(VarRefFunc func)
2489 {
2490         VARIANT vt;
2491         VariantInit (&vt);
2492         func (VT_I1, &vt);
2493         if (vt.vt == VT_I1 && vt.cVal == -100)
2494                 return 0;
2495         return 1;
2496 }
2497
2498 STDCALL int
2499 mono_test_marshal_variant_out_byte_unmanaged(VarRefFunc func)
2500 {
2501         VARIANT vt;
2502         VariantInit (&vt);
2503         func (VT_UI1, &vt);
2504         if (vt.vt == VT_UI1 && vt.bVal == 100)
2505                 return 0;
2506         return 1;
2507 }
2508
2509 STDCALL int
2510 mono_test_marshal_variant_out_short_unmanaged(VarRefFunc func)
2511 {
2512         VARIANT vt;
2513         VariantInit (&vt);
2514         func (VT_I2, &vt);
2515         if (vt.vt == VT_I2 && vt.iVal == -100)
2516                 return 0;
2517         return 1;
2518 }
2519
2520 STDCALL int
2521 mono_test_marshal_variant_out_ushort_unmanaged(VarRefFunc func)
2522 {
2523         VARIANT vt;
2524         VariantInit (&vt);
2525         func (VT_UI2, &vt);
2526         if (vt.vt == VT_UI2 && vt.uiVal == 100)
2527                 return 0;
2528         return 1;
2529 }
2530
2531 STDCALL int
2532 mono_test_marshal_variant_out_int_unmanaged(VarRefFunc func)
2533 {
2534         VARIANT vt;
2535         VariantInit (&vt);
2536         func (VT_I4, &vt);
2537         if (vt.vt == VT_I4 && vt.lVal == -100)
2538                 return 0;
2539         return 1;
2540 }
2541
2542 STDCALL int
2543 mono_test_marshal_variant_out_uint_unmanaged(VarRefFunc func)
2544 {
2545         VARIANT vt;
2546         VariantInit (&vt);
2547         func (VT_UI4, &vt);
2548         if (vt.vt == VT_UI4 && vt.ulVal == 100)
2549                 return 0;
2550         return 1;
2551 }
2552
2553 STDCALL int
2554 mono_test_marshal_variant_out_long_unmanaged(VarRefFunc func)
2555 {
2556         VARIANT vt;
2557         VariantInit (&vt);
2558         func (VT_I8, &vt);
2559         if (vt.vt == VT_I8 && vt.llVal == -100)
2560                 return 0;
2561         return 1;
2562 }
2563
2564 STDCALL int
2565 mono_test_marshal_variant_out_ulong_unmanaged(VarRefFunc func)
2566 {
2567         VARIANT vt;
2568         VariantInit (&vt);
2569         func (VT_UI8, &vt);
2570         if (vt.vt == VT_UI8 && vt.ullVal == 100)
2571                 return 0;
2572         return 1;
2573 }
2574
2575 STDCALL int
2576 mono_test_marshal_variant_out_float_unmanaged(VarRefFunc func)
2577 {
2578         VARIANT vt;
2579         VariantInit (&vt);
2580         func (VT_R4, &vt);
2581         if (vt.vt == VT_R4 && fabs (vt.fltVal - 3.14f) < 1e-10)
2582                 return 0;
2583         return 1;
2584 }
2585
2586 STDCALL int
2587 mono_test_marshal_variant_out_double_unmanaged(VarRefFunc func)
2588 {
2589         VARIANT vt;
2590         VariantInit (&vt);
2591         func (VT_R8, &vt);
2592         if (vt.vt == VT_R8 && fabs (vt.dblVal - 3.14) < 1e-10)
2593                 return 0;
2594         return 1;
2595 }
2596
2597 STDCALL int
2598 mono_test_marshal_variant_out_bstr_unmanaged(VarRefFunc func)
2599 {
2600         VARIANT vt;
2601         VariantInit (&vt);
2602         func (VT_BSTR, &vt);
2603         if (vt.vt == VT_BSTR && !wcscmp(vt.bstrVal, L"PI"))
2604                 return 0;
2605         return 1;
2606 }
2607
2608 STDCALL int
2609 mono_test_marshal_variant_out_bool_true_unmanaged(VarRefFunc func)
2610 {
2611         VARIANT vt;
2612         VariantInit (&vt);
2613         func (VT_BOOL, &vt);
2614         if (vt.vt == VT_BOOL && vt.boolVal == VARIANT_TRUE)
2615                 return 0;
2616         return 1;
2617 }
2618
2619 STDCALL int
2620 mono_test_marshal_variant_out_bool_false_unmanaged(VarRefFunc func)
2621 {
2622         VARIANT vt;
2623         VariantInit (&vt);
2624         func (VT_BOOL, &vt);
2625         if (vt.vt == VT_BOOL && vt.boolVal == VARIANT_TRUE)
2626                 return 0;
2627         return 1;
2628 }
2629
2630 typedef struct MonoComObject MonoComObject;
2631
2632 typedef struct
2633 {
2634         int (STDCALL *QueryInterface)(MonoComObject* pUnk, gpointer riid, gpointer* ppv);
2635         int (STDCALL *AddRef)(MonoComObject* pUnk);
2636         int (STDCALL *Release)(MonoComObject* pUnk);
2637         int (STDCALL *get_ITest)(MonoComObject* pUnk, MonoComObject* *ppUnk);
2638         int (STDCALL *SByteIn)(MonoComObject* pUnk, char a);
2639         int (STDCALL *ByteIn)(MonoComObject* pUnk, unsigned char a);
2640         int (STDCALL *ShortIn)(MonoComObject* pUnk, short a);
2641         int (STDCALL *UShortIn)(MonoComObject* pUnk, unsigned short a);
2642         int (STDCALL *IntIn)(MonoComObject* pUnk, int a);
2643         int (STDCALL *UIntIn)(MonoComObject* pUnk, unsigned int a);
2644         int (STDCALL *LongIn)(MonoComObject* pUnk, LONGLONG a);
2645         int (STDCALL *ULongIn)(MonoComObject* pUnk, ULONGLONG a);
2646         int (STDCALL *FloatIn)(MonoComObject* pUnk, float a);
2647         int (STDCALL *DoubleIn)(MonoComObject* pUnk, double a);
2648         int (STDCALL *ITestIn)(MonoComObject* pUnk, MonoComObject* pUnk2);
2649         int (STDCALL *ITestOut)(MonoComObject* pUnk, MonoComObject* *ppUnk);
2650 } MonoIUnknown;
2651
2652 struct MonoComObject
2653 {
2654         MonoIUnknown* vtbl;
2655         int m_ref;
2656 };
2657
2658 DEFINE_GUID(IID_ITest, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1);
2659 DEFINE_GUID(IID_IMonoUnknown, 0, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 0x46);
2660 DEFINE_GUID(IID_IMonoDispatch, 0x00020400, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 0x46);
2661
2662 int STDCALL MonoQueryInterface(MonoComObject* pUnk, gpointer riid, gpointer* ppv)
2663 {
2664         *ppv = NULL;
2665         if (!memcmp(riid, &IID_IMonoUnknown, sizeof(GUID))) {
2666                 *ppv = pUnk;
2667                 return S_OK;
2668         }
2669         else if (!memcmp(riid, &IID_ITest, sizeof(GUID))) {
2670                 *ppv = pUnk;
2671                 return S_OK;
2672         }
2673         else if (!memcmp(riid, &IID_IMonoDispatch, sizeof(GUID))) {
2674                 *ppv = pUnk;
2675                 return S_OK;
2676         }
2677         return E_NOINTERFACE;
2678 }
2679
2680 int STDCALL MonoAddRef(MonoComObject* pUnk)
2681 {
2682         return ++(pUnk->m_ref);
2683 }
2684
2685 int STDCALL MonoRelease(MonoComObject* pUnk)
2686 {
2687         return --(pUnk->m_ref);
2688 }
2689
2690 int STDCALL SByteIn(MonoComObject* pUnk, char a)
2691 {
2692         return S_OK;
2693 }
2694
2695 int STDCALL ByteIn(MonoComObject* pUnk, unsigned char a)
2696 {
2697         return S_OK;
2698 }
2699
2700 int STDCALL ShortIn(MonoComObject* pUnk, short a)
2701 {
2702         return S_OK;
2703 }
2704
2705 int STDCALL UShortIn(MonoComObject* pUnk, unsigned short a)
2706 {
2707         return S_OK;
2708 }
2709
2710 int STDCALL IntIn(MonoComObject* pUnk, int a)
2711 {
2712         return S_OK;
2713 }
2714
2715 int STDCALL UIntIn(MonoComObject* pUnk, unsigned int a)
2716 {
2717         return S_OK;
2718 }
2719
2720 int STDCALL LongIn(MonoComObject* pUnk, LONGLONG a)
2721 {
2722         return S_OK;
2723 }
2724
2725 int STDCALL ULongIn(MonoComObject* pUnk, ULONGLONG a)
2726 {
2727         return S_OK;
2728 }
2729
2730 int STDCALL FloatIn(MonoComObject* pUnk, float a)
2731 {
2732         return S_OK;
2733 }
2734
2735 int STDCALL DoubleIn(MonoComObject* pUnk, double a)
2736 {
2737         return S_OK;
2738 }
2739
2740 int STDCALL ITestIn(MonoComObject* pUnk, MonoComObject *pUnk2)
2741 {
2742         return S_OK;
2743 }
2744
2745 int STDCALL ITestOut(MonoComObject* pUnk, MonoComObject* *ppUnk)
2746 {
2747         return S_OK;
2748 }
2749
2750 int STDCALL get_ITest(MonoComObject* pUnk, MonoComObject* *ppUnk)
2751 {
2752         return S_OK;
2753 }
2754
2755 static void create_com_object (MonoComObject** pOut)
2756 {
2757         *pOut = g_new0 (MonoComObject, 1);
2758         (*pOut)->vtbl = g_new0 (MonoIUnknown, 1);
2759
2760         (*pOut)->m_ref = 1;
2761         (*pOut)->vtbl->QueryInterface = MonoQueryInterface;
2762         (*pOut)->vtbl->AddRef = MonoAddRef;
2763         (*pOut)->vtbl->Release = MonoRelease;
2764         (*pOut)->vtbl->SByteIn = SByteIn;
2765         (*pOut)->vtbl->ByteIn = ByteIn;
2766         (*pOut)->vtbl->ShortIn = ShortIn;
2767         (*pOut)->vtbl->UShortIn = UShortIn;
2768         (*pOut)->vtbl->IntIn = IntIn;
2769         (*pOut)->vtbl->UIntIn = UIntIn;
2770         (*pOut)->vtbl->LongIn = LongIn;
2771         (*pOut)->vtbl->ULongIn = ULongIn;
2772         (*pOut)->vtbl->FloatIn = FloatIn;
2773         (*pOut)->vtbl->DoubleIn = DoubleIn;
2774         (*pOut)->vtbl->ITestIn = ITestIn;
2775         (*pOut)->vtbl->ITestOut = ITestOut;
2776         (*pOut)->vtbl->get_ITest = get_ITest;
2777 }
2778
2779 static MonoComObject* same_object = NULL;
2780
2781 STDCALL int
2782 mono_test_marshal_com_object_create(MonoComObject* *pUnk)
2783 {
2784         create_com_object (pUnk);
2785
2786         if (!same_object)
2787                 same_object = *pUnk;
2788
2789         return 0;
2790 }
2791
2792 STDCALL int
2793 mono_test_marshal_com_object_same(MonoComObject* *pUnk)
2794 {
2795         *pUnk = same_object;
2796
2797         return 0;
2798 }
2799
2800 STDCALL int
2801 mono_test_marshal_com_object_destroy(MonoComObject *pUnk)
2802 {
2803         int ref = --(pUnk->m_ref);
2804         g_free(pUnk->vtbl);
2805         g_free(pUnk);
2806
2807         return ref;
2808 }
2809
2810 STDCALL int
2811 mono_test_marshal_com_object_ref_count(MonoComObject *pUnk)
2812 {
2813         return pUnk->m_ref;
2814 }
2815
2816 STDCALL int
2817 mono_test_marshal_ccw_itest (MonoComObject *pUnk)
2818 {
2819         int hr = 0;
2820         MonoComObject* pTest;
2821
2822         if (!pUnk)
2823                 return 1;
2824
2825         hr = pUnk->vtbl->SByteIn (pUnk, -100);
2826         if (hr != 0)
2827                 return 2;
2828         hr = pUnk->vtbl->ByteIn (pUnk, 100);
2829         if (hr != 0)
2830                 return 3;
2831         hr = pUnk->vtbl->ShortIn (pUnk, -100);
2832         if (hr != 0)
2833                 return 4;
2834         hr = pUnk->vtbl->UShortIn (pUnk, 100);
2835         if (hr != 0)
2836                 return 5;
2837         hr = pUnk->vtbl->IntIn (pUnk, -100);
2838         if (hr != 0)
2839                 return 6;
2840         hr = pUnk->vtbl->UIntIn (pUnk, 100);
2841         if (hr != 0)
2842                 return 7;
2843         hr = pUnk->vtbl->LongIn (pUnk, -100);
2844         if (hr != 0)
2845                 return 8;
2846         hr = pUnk->vtbl->ULongIn (pUnk, 100);
2847         if (hr != 0)
2848                 return 9;
2849         hr = pUnk->vtbl->FloatIn (pUnk, 3.14f);
2850         if (hr != 0)
2851                 return 10;
2852         hr = pUnk->vtbl->DoubleIn (pUnk, 3.14);
2853         if (hr != 0)
2854                 return 11;
2855         hr = pUnk->vtbl->ITestIn (pUnk, pUnk);
2856         if (hr != 0)
2857                 return 12;
2858         hr = pUnk->vtbl->ITestOut (pUnk, &pTest);
2859         if (hr != 0)
2860                 return 13;
2861
2862         return 0;
2863 }
2864
2865
2866 #endif //NOT_YET