mono/tests/libtest.c

   1 #include <stdio.h>
   2 #include <string.h>
   3
   4 unsigned short*
   5 test_lpwstr_marshal (unsigned short* chars, long length)
   6 {
   7         int i = 0;
   8
   9         printf("test_lpwstr_marshal()\n");
  10
  11         while ( i < length )
  12                 printf("X|%u|\n", chars[i++]);
  13
  14         return chars;
  15 }
  16
  17 typedef struct {
  18         int b;
  19         int a;
  20         int c;
  21 } union_test_1_type;
  22
  23 int mono_union_test_1 (union_test_1_type u1) {
  24         printf ("Got values %d %d %d\n", u1.b, u1.a, u1.c);
  25         return u1.a + u1.b + u1.c;
  26 }
  27
  28 int mono_return_int (int a) {
  29         printf ("Got value %d\n", a);
  30         return a;
  31 }
  32 int mono_test_many_int_arguments (int a, int b, int c, int d, int e,
  33                                   int f, int g, int h, int i, int j);
  34 short mono_test_many_short_arguments (short a, short b, short c, short d, short e,
  35                                       short f, short g, short h, short i, short j);
  36 char mono_test_many_char_arguments (char a, char b, char c, char d, char e,
  37                                     char f, char g, char h, char i, char j);
  38
  39 int
  40 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)
  41 {
  42         return a + b + c + d + e + f + g + h + i + j;
  43 }
  44
  45 short
  46 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)
  47 {
  48         return a + b + c + d + e + f + g + h + i + j;
  49 }
  50
  51 char
  52 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)
  53 {
  54         return a + b + c + d + e + f + g + h + i + j;
  55 }
  56
  57 int
  58 mono_test_puts_static (char *s)
  59 {
  60         printf ("TEST %s\n", s);
  61         return 1;
  62 }
  63
  64 typedef int (*SimpleDelegate3) (int a, int b);
  65
  66 int
  67 mono_invoke_delegate (SimpleDelegate3 delegate)
  68 {
  69         int res;
  70
  71         printf ("start invoke %p\n", delegate);
  72
  73         res = delegate (2, 3);
  74
  75         printf ("end invoke\n");
  76
  77         return res;
  78 }
  79
  80 int
  81 mono_test_marshal_char (short a1)
  82 {
  83         if (a1 = 'a')
  84                 return 0;
  85
  86         return 1;
  87 }
  88
  89 int
  90 mono_test_marshal_array (int *a1)
  91 {
  92         int i, sum = 0;
  93
  94         for (i = 0; i < 50; i++)
  95                 sum += a1 [i];
  96
  97         return sum;
  98 }
  99
 100 typedef struct {
 101         int a;
 102         int b;
 103         int c;
 104         char *d;
 105 } simplestruct;
 106
 107 simplestruct
 108 mono_test_return_vtype ()
 109 {
 110         simplestruct res;
 111
 112         res.a = 0;
 113         res.b = 1;
 114         res.c = 0;
 115         res.d = "TEST";
 116         printf ("mono_test_return_vtype\n");
 117         return res;
 118 }
 119
 120 void
 121 mono_test_delegate_struct ()
 122 {
 123         printf ("TEST\n");
 124 }
 125
 126 typedef simplestruct (*ReturnVTypeDelegate) (simplestruct ss);
 127
 128 simplestruct
 129 mono_test_return_vtype2 (ReturnVTypeDelegate func)
 130 {
 131         simplestruct res;
 132         simplestruct res1;
 133
 134         res.a = 1;
 135         res.b = 0;
 136         res.c = 1;
 137         res.d = "TEST";
 138         printf ("mono_test_return_vtype2\n");
 139
 140         res1 = func (res);
 141
 142         printf ("UA: %d\n", res1.a);
 143         printf ("UB: %d\n", res1.b);
 144         printf ("UC: %d\n", res1.c);
 145         printf ("UD: %s\n", res1.d);
 146
 147         return res1;
 148 }
 149
 150 typedef char* (*ReturnStringDelegate) (char *s);
 151
 152 char *
 153 mono_test_return_string (ReturnStringDelegate func)
 154 {
 155         char *res;
 156
 157         printf ("mono_test_return_string\n");
 158
 159         res = func ("TEST");
 160
 161         printf ("got string: %s\n", res);
 162         return res;
 163 }
 164
 165 typedef int (*RefVTypeDelegate) (int a, simplestruct *ss, int b);
 166
 167 int
 168 mono_test_ref_vtype (int a, simplestruct *ss, int b, RefVTypeDelegate func)
 169 {
 170         if (a == 1 && b == 2 && ss->a == 0 && ss->b == 1 && ss->c == 0 &&
 171             !strcmp (ss->d, "TEST1")) {
 172                 ss->a = 1;
 173                 ss->b = 0;
 174                 ss->c = 1;
 175                 ss->d = "TEST2";
 176
 177                 return func (a, ss, b);
 178         }
 179
 180         return 1;
 181 }
 182
 183 typedef struct {
 184         int a;
 185         int (*func) (int);
 186 } DelegateStruct;
 187
 188 int
 189 mono_test_marshal_delegate_struct (DelegateStruct ds)
 190 {
 191         return ds.func (ds.a);
 192 }
 193
 194 int
 195 mono_test_marshal_struct (simplestruct ss)
 196 {
 197         if (ss.a == 0 && ss.b == 1 && ss.c == 0 &&
 198             !strcmp (ss.d, "TEST"))
 199                 return 0;
 200
 201         return 1;
 202 }
 203
 204
 205 typedef int (*SimpleDelegate) (int a);
 206
 207 int
 208 mono_test_marshal_delegate (SimpleDelegate delegate)
 209 {
 210         return delegate (2);
 211 }
 212
 213 typedef int (*SimpleDelegate2) (simplestruct ss);
 214
 215 int
 216 mono_test_marshal_delegate2 (SimpleDelegate2 delegate)
 217 {
 218         simplestruct ss;
 219         int res;
 220
 221         ss.a = 0;
 222         ss.b = 1;
 223         ss.c = 0;
 224         ss.d = "TEST";
 225
 226         printf ("Calling delegate from unmanaged code\n");
 227         res = delegate (ss);
 228         printf ("GOT %d\n", res);
 229
 230         return res;
 231 }
 232
 233 int
 234 mono_test_marshal_stringbuilder (char *s, int n)
 235 {
 236         const char m[] = "This is my message.  Isn't it nice?";
 237         strncpy(s, m, n);
 238         return 0;
 239 }
 240
 241 typedef struct {
 242 } EmptyStruct;
 243
 244 int
 245 mono_test_marshal_string_array (char **array)
 246 {
 247         printf ("%p\n", array);
 248         return 0;
 249 }
 250
 251 /* this does not work on Redhat gcc 2.96 */
 252 #if 0
 253 int
 254 mono_test_empty_struct (int a, EmptyStruct es, int b)
 255 {
 256         if (a == 1 && b == 2)
 257                 return 0;
 258         return 1;
 259 }
 260 #endif
 261
 262
 263 typedef struct {
 264        char a[100];
 265 } ByValStrStruct;
 266
 267 ByValStrStruct *
 268 mono_test_byvalstr_gen (void)
 269 {
 270         ByValStrStruct *ret;
 271         int i;
 272
 273         ret = g_malloc(sizeof(ByValStrStruct));
 274         memset(ret, 'a', sizeof(ByValStrStruct)-1);
 275         ret->a[sizeof(ByValStrStruct)-1] = 0;
 276
 277         return ret;
 278 }
 279
 280 int
 281 mono_test_byvalstr_check (ByValStrStruct* data, char* correctString)
 282 {
 283         int ret;
 284
 285         ret = strcmp(data->a, correctString);
 286         printf ("T1: %s\n", data->a);
 287         printf ("T2: %s\n", correctString);
 288
 289         g_free(data);
 290         return (ret != 0);
 291 }