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