?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[WCF] mark JsonReader tests that proves referencesource bugs as [Ignore]d.
[mono-project.git] / mono / tests / pinvoke2.cs
blobabc81f8d70d77fe44b7a2588b0c7e98d96825339
1 //
2 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
3 //
4
5 using System;
6 using System.Text;
7 using System.Runtime.InteropServices;
8 using System.Runtime.CompilerServices;
9 using System.Reflection.Emit;
10
11 public class Tests {
12
13 public int int_field;
14
15 public static int delegate_test (int a)
16 {
17 if (a == 2)
18 return 0;
19
20 return 1;
21 }
22
23 public int delegate_test_instance (int a)
24 {
25 return int_field + a;
26 }
27
28 [StructLayout (LayoutKind.Sequential)]
29 public struct SimpleStruct {
30 public bool a;
31 public bool b;
32 public bool c;
33 public string d;
34 [MarshalAs(UnmanagedType.LPWStr)]
35 public string d2;
36 }
37
38 [StructLayout (LayoutKind.Sequential)]
39 public struct SimpleStructGen<T> {
40 public bool a;
41 public bool b;
42 public bool c;
43 public string d;
44 [MarshalAs(UnmanagedType.LPWStr)]
45 public string d2;
46 }
47
48 [StructLayout (LayoutKind.Sequential)]
49 public struct SimpleStruct2 {
50 public bool a;
51 public bool b;
52 public bool c;
53 public string d;
54 public byte e;
55 public double f;
56 public byte g;
57 public long h;
58 }
59
60 [StructLayout (LayoutKind.Sequential, Size=0)]
61 public struct EmptyStruct {
62 }
63
64 [StructLayout (LayoutKind.Sequential)]
65 public struct DelegateStruct {
66 public int a;
67 public SimpleDelegate del;
68 [MarshalAs(UnmanagedType.FunctionPtr)]
69 public SimpleDelegate del2;
70 [MarshalAs(UnmanagedType.FunctionPtr)]
71 public SimpleDelegate del3;
72 }
73
74 [StructLayout (LayoutKind.Sequential)]
75 public struct SingleDoubleStruct {
76 public double d;
77 }
78
79 /* sparcv9 has complex conventions when passing structs with doubles in them
80 by value, some simple tests for them */
81 [StructLayout (LayoutKind.Sequential)]
82 public struct Point {
83 public double x;
84 public double y;
85 }
86
87 [StructLayout (LayoutKind.Sequential)]
88 public struct MixedPoint {
89 public int x;
90 public double y;
91 }
92
93 [StructLayout (LayoutKind.Sequential)]
94 public struct TinyStruct {
95 public TinyStruct (int i)
96 {
97 this.i = i;
98 }
99 public int i;
100 }
101
102 [StructLayout (LayoutKind.Sequential)]
103 public class SimpleClass {
104 public bool a;
105 public bool b;
106 public bool c;
107 public string d;
108 public byte e;
109 public double f;
110 public byte g;
111 public long h;
112 }
113
114 [StructLayout (LayoutKind.Sequential)]
115 public class EmptyClass {
116 }
117
118 [StructLayout (LayoutKind.Sequential)]
119 public struct LongAlignStruct {
120 public int a;
121 public long b;
122 public long c;
123 }
124
125 [StructLayout(LayoutKind.Sequential)]
126 public class BlittableClass
127 {
128 public int a = 1;
129 public int b = 2;
130 }
131
132 [StructLayout (LayoutKind.Sequential)]
133 class SimpleObj
134 {
135 public string str;
136 public int i;
137 }
138
139 [StructLayout(LayoutKind.Sequential)]
140 struct AsAnyStruct
141 {
142 public int i;
143 public int j;
144 public int k;
145 public String s;
146
147 public AsAnyStruct(int i, int j, int k, String s) {
148 this.i = i;
149 this.j = j;
150 this.k = k;
151 this.s = s;
152 }
153 }
154
155 [StructLayout(LayoutKind.Sequential)]
156 class AsAnyClass
157 {
158 public int i;
159 public int j;
160 public int k;
161 public String s;
162
163 public AsAnyClass(int i, int j, int k, String s) {
164 this.i = i;
165 this.j = j;
166 this.k = k;
167 }
168 }
169
170 [DllImport ("libnot-found", EntryPoint="not_found")]
171 public static extern int mono_library_not_found ();
172
173 [DllImport ("libtest", EntryPoint="not_found")]
174 public static extern int mono_entry_point_not_found ();
175
176 [DllImport ("libtest.dll", EntryPoint="mono_test_marshal_char")]
177 public static extern int mono_test_marshal_char_2 (char a1);
178
179 [DllImport ("test", EntryPoint="mono_test_marshal_char")]
180 public static extern int mono_test_marshal_char_3 (char a1);
181
182 [DllImport ("libtest", EntryPoint="mono_test_marshal_char")]
183 public static extern int mono_test_marshal_char (char a1);
184
185 [DllImport ("libtest", EntryPoint="mono_test_marshal_char_array", CharSet=CharSet.Unicode)]
186 public static extern int mono_test_marshal_char_array (char[] a1);
187
188 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_byref")]
189 public static extern int mono_test_marshal_bool_byref (int a, ref bool b, int c);
190
191 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_in_as_I1_U1")]
192 public static extern int mono_test_marshal_bool_in_as_I1 ([MarshalAs (UnmanagedType.I1)] bool bTrue, [MarshalAs (UnmanagedType.I1)] bool bFalse);
193
194 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_in_as_I1_U1")]
195 public static extern int mono_test_marshal_bool_in_as_U1 ([MarshalAs (UnmanagedType.U1)] bool bTrue, [MarshalAs (UnmanagedType.U1)] bool bFalse);
196
197 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_out_as_I1_U1")]
198 public static extern int mono_test_marshal_bool_out_as_I1 ([MarshalAs (UnmanagedType.I1)] out bool bTrue, [MarshalAs (UnmanagedType.I1)] out bool bFalse);
199
200 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_out_as_I1_U1")]
201 public static extern int mono_test_marshal_bool_out_as_U1 ([MarshalAs (UnmanagedType.U1)] out bool bTrue, [MarshalAs (UnmanagedType.U1)] out bool bFalse);
202
203 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_ref_as_I1_U1")]
204 public static extern int mono_test_marshal_bool_ref_as_I1 ([MarshalAs (UnmanagedType.I1)] ref bool bTrue, [MarshalAs (UnmanagedType.I1)] ref bool bFalse);
205
206 [DllImport ("libtest", EntryPoint="mono_test_marshal_bool_ref_as_I1_U1")]
207 public static extern int mono_test_marshal_bool_ref_as_U1 ([MarshalAs (UnmanagedType.U1)] ref bool bTrue, [MarshalAs (UnmanagedType.U1)] ref bool bFalse);
208
209 [DllImport ("libtest", EntryPoint="mono_test_marshal_array")]
210 public static extern int mono_test_marshal_array (int [] a1);
211
212 [DllImport ("libtest", EntryPoint="mono_test_marshal_empty_string_array")]
213 public static extern int mono_test_marshal_empty_string_array (string [] a1);
214
215 [DllImport ("libtest", EntryPoint="mono_test_marshal_string_array")]
216 public static extern int mono_test_marshal_string_array (string [] a1);
217
218 [DllImport ("libtest", EntryPoint="mono_test_marshal_unicode_string_array", CharSet=CharSet.Unicode)]
219 public static extern int mono_test_marshal_unicode_string_array (string [] a1, [MarshalAs(UnmanagedType.LPArray, ArraySubType=UnmanagedType.LPStr)]string [] a2);
220
221 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_array")]
222 public static extern int mono_test_marshal_stringbuilder_array (StringBuilder [] a1);
223
224 [DllImport ("libtest", EntryPoint="mono_test_marshal_inout_array")]
225 public static extern int mono_test_marshal_inout_array ([In, Out] int [] a1);
226
227 [DllImport ("libtest", EntryPoint="mono_test_marshal_out_array")]
228 public static extern int mono_test_marshal_out_array ([Out] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] int [] a1, int n);
229
230 [DllImport ("libtest", EntryPoint="mono_test_marshal_out_byref_array_out_size_param")]
231 public static extern int mono_test_marshal_out_byref_array_out_size_param ([Out] [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] out int [] a1, out int n);
232
233 [DllImport ("libtest", EntryPoint="mono_test_marshal_inout_nonblittable_array", CharSet = CharSet.Unicode)]
234 public static extern int mono_test_marshal_inout_nonblittable_array ([In, Out] char [] a1);
235
236 [DllImport ("libtest", EntryPoint="mono_test_marshal_struct")]
237 public static extern int mono_test_marshal_struct (SimpleStruct ss);
238
239 [DllImport ("libtest", EntryPoint="mono_test_marshal_struct")]
240 public static extern int mono_test_marshal_struct_gen (SimpleStructGen<string> ss);
241
242 [DllImport ("libtest", EntryPoint="mono_test_marshal_struct2")]
243 public static extern int mono_test_marshal_struct2 (SimpleStruct2 ss);
244
245 [DllImport ("libtest", EntryPoint="mono_test_marshal_struct2_2")]
246 public static extern int mono_test_marshal_struct2_2 (int i, int j, int k, SimpleStruct2 ss);
247
248 [DllImport ("libtest", EntryPoint="mono_test_marshal_byref_struct")]
249 public static extern int mono_test_marshal_byref_struct (ref SimpleStruct ss, bool a, bool b, bool c, String d);
250
251 [DllImport ("libtest", EntryPoint="mono_test_marshal_byref_struct")]
252 public static extern int mono_test_marshal_byref_struct_in ([In] ref SimpleStruct ss, bool a, bool b, bool c, String d);
253
254 [DllImport ("libtest", EntryPoint="mono_test_marshal_byref_struct")]
255 public static extern int mono_test_marshal_byref_struct_inout ([In, Out] ref SimpleStruct ss, bool a, bool b, bool c, String d);
256
257 [DllImport ("libtest", EntryPoint="mono_test_marshal_point")]
258 public static extern int mono_test_marshal_point (Point p);
259
260 [DllImport ("libtest", EntryPoint="mono_test_marshal_mixed_point")]
261 public static extern int mono_test_marshal_mixed_point (MixedPoint p);
262
263 [DllImport ("libtest", EntryPoint="mono_test_empty_struct")]
264 public static extern int mono_test_empty_struct (int a, EmptyStruct es, int b);
265
266 [DllImport ("libtest", EntryPoint="mono_test_marshal_lpstruct")]
267 public static extern int mono_test_marshal_lpstruct ([In, MarshalAs(UnmanagedType.LPStruct)] SimpleStruct ss);
268
269 [DllImport ("libtest", EntryPoint="mono_test_marshal_lpstruct_blittable")]
270 public static extern int mono_test_marshal_lpstruct_blittable ([In, MarshalAs(UnmanagedType.LPStruct)] Point p);
271
272 [DllImport ("libtest", EntryPoint="mono_test_marshal_struct_array")]
273 public static extern int mono_test_marshal_struct_array (SimpleStruct2[] ss);
274
275 [DllImport ("libtest", EntryPoint="mono_test_marshal_long_align_struct_array")]
276 public static extern int mono_test_marshal_long_align_struct_array (LongAlignStruct[] ss);
277
278 [DllImport ("libtest", EntryPoint="mono_test_marshal_class")]
279 public static extern SimpleClass mono_test_marshal_class (int i, int j, int k, SimpleClass ss, int l);
280
281 [DllImport ("libtest", EntryPoint="mono_test_marshal_byref_class")]
282 public static extern int mono_test_marshal_byref_class (ref SimpleClass ss);
283
284 [DllImport ("libtest", EntryPoint="mono_test_marshal_delegate")]
285 public static extern int mono_test_marshal_delegate (SimpleDelegate d);
286
287 [DllImport ("libtest", EntryPoint="mono_test_marshal_delegate_struct")]
288 public static extern DelegateStruct mono_test_marshal_delegate_struct (DelegateStruct d);
289
290 [DllImport ("libtest", EntryPoint="mono_test_marshal_return_delegate")]
291 public static extern SimpleDelegate mono_test_marshal_return_delegate (SimpleDelegate d);
292
293 [DllImport ("libtest", EntryPoint="mono_test_return_vtype")]
294 public static extern SimpleStruct mono_test_return_vtype (IntPtr i);
295
296 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder")]
297 public static extern void mono_test_marshal_stringbuilder (StringBuilder sb, int len);
298
299 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_default")]
300 public static extern void mono_test_marshal_stringbuilder_default (StringBuilder sb, int len);
301
302 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_append")]
303 public static extern void mono_test_marshal_stringbuilder_append (StringBuilder sb, int len);
304
305 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_unicode", CharSet=CharSet.Unicode)]
306 public static extern void mono_test_marshal_stringbuilder_unicode (StringBuilder sb, int len);
307
308 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_out")]
309 public static extern void mono_test_marshal_stringbuilder_out (out StringBuilder sb);
310
311 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_ref")]
312 public static extern int mono_test_marshal_stringbuilder_ref (ref StringBuilder sb);
313
314 [DllImport ("libtest", EntryPoint="mono_test_marshal_stringbuilder_out_unicode", CharSet=CharSet.Unicode)]
315 public static extern void mono_test_marshal_stringbuilder_out_unicode (out StringBuilder sb);
316
317 [DllImport ("libtest", EntryPoint="mono_test_last_error", SetLastError=true)]
318 public static extern void mono_test_last_error (int err);
319
320 [DllImport ("libtest", EntryPoint="mono_test_asany")]
321 public static extern int mono_test_asany ([MarshalAs (UnmanagedType.AsAny)] object o, int what);
322
323 [DllImport ("libtest", EntryPoint="mono_test_asany", CharSet=CharSet.Unicode)]
324 public static extern int mono_test_asany_unicode ([MarshalAs (UnmanagedType.AsAny)] object o, int what);
325
326 [DllImport("libtest", EntryPoint="mono_test_marshal_asany_in")]
327 static extern void mono_test_asany_in ([MarshalAs(UnmanagedType.AsAny)][In] object obj);
328
329 [DllImport("libtest", EntryPoint="mono_test_marshal_asany_out")]
330 static extern void mono_test_asany_out ([MarshalAs(UnmanagedType.AsAny)][Out] object obj);
331 [DllImport("libtest", EntryPoint="mono_test_marshal_asany_inout")]
332 static extern void mono_test_asany_inout ([MarshalAs(UnmanagedType.AsAny)][In, Out] object obj);
333
334 [DllImport ("libtest")]
335 static extern int class_marshal_test0 (SimpleObj obj);
336
337 [DllImport ("libtest")]
338 static extern void class_marshal_test1 (out SimpleObj obj);
339
340 [DllImport ("libtest")]
341 static extern int class_marshal_test4 (SimpleObj obj);
342
343 [DllImport ("libtest")]
344 static extern int string_marshal_test0 (string str);
345
346 [DllImport ("libtest")]
347 static extern void string_marshal_test1 (out string str);
348
349 [DllImport ("libtest")]
350 static extern int string_marshal_test2 (ref string str);
351
352 [DllImport ("libtest")]
353 static extern int string_marshal_test3 (string str);
354
355 public delegate int SimpleDelegate (int a);
356
357 public static int Main (string[] args) {
358 return TestDriver.RunTests (typeof (Tests), args);
359 }
360
361 public static int test_0_marshal_char () {
362 return mono_test_marshal_char ('a');
363 }
364
365 public static int test_0_marshal_char_array () {
366 // a unicode char[] is implicitly marshalled as [Out]
367 char[] buf = new char [32];
368 mono_test_marshal_char_array (buf);
369 string s = new string (buf);
370 if (s.StartsWith ("abcdef"))
371 return 0;
372 else
373 return 1;
374 }
375
376 public static int test_1225_marshal_array () {
377 int [] a1 = new int [50];
378 for (int i = 0; i < 50; i++)
379 a1 [i] = i;
380
381 return mono_test_marshal_array (a1);
382 }
383
384 public static int test_1225_marshal_inout_array () {
385 int [] a1 = new int [50];
386 for (int i = 0; i < 50; i++)
387 a1 [i] = i;
388
389 int res = mono_test_marshal_inout_array (a1);
390
391 for (int i = 0; i < 50; i++)
392 if (a1 [i] != 50 - i) {
393 Console.WriteLine ("X: " + i + " " + a1 [i]);
394 return 2;
395 }
396
397 return res;
398 }
399
400 public static int test_0_marshal_out_array () {
401 int [] a1 = new int [50];
402
403 int res = mono_test_marshal_out_array (a1, 0);
404
405 for (int i = 0; i < 50; i++)
406 if (a1 [i] != i) {
407 Console.WriteLine ("X: " + i + " " + a1 [i]);
408 return 2;
409 }
410
411 return 0;
412 }
413
414 public static int test_0_marshal_out_byref_array_out_size_param () {
415 int [] a1 = null;
416 int len;
417
418 int res = mono_test_marshal_out_byref_array_out_size_param (out a1, out len);
419 if (len != 4)
420 return 1;
421 for (int i = 0; i < len; i++)
422 if (a1 [i] != i)
423 return 2;
424 return 0;
425 }
426
427 public static int test_0_marshal_inout_nonblittable_array () {
428 char [] a1 = new char [10];
429 for (int i = 0; i < 10; i++)
430 a1 [i] = "Hello, World" [i];
431
432 int res = mono_test_marshal_inout_nonblittable_array (a1);
433
434 for (int i = 0; i < 10; i++)
435 if (a1 [i] != 'F')
436 return 2;
437
438 return res;
439 }
440
441 public static int test_0_marshal_struct () {
442 SimpleStruct ss = new SimpleStruct ();
443 ss.b = true;
444 ss.d = "TEST";
445
446 return mono_test_marshal_struct (ss);
447 }
448
449 public static int test_0_marshal_struct_gen () {
450 SimpleStructGen<string> ss = new SimpleStructGen<string> ();
451 ss.b = true;
452 ss.d = "TEST";
453
454 return mono_test_marshal_struct_gen (ss);
455 }
456
457 public static int test_0_marshal_struct2 () {
458 SimpleStruct2 ss2 = new SimpleStruct2 ();
459 ss2.b = true;
460 ss2.d = "TEST";
461 ss2.e = 99;
462 ss2.f = 1.5;
463 ss2.g = 42;
464 ss2.h = 123L;
465
466 return mono_test_marshal_struct2 (ss2);
467 }
468
469 public static int test_0_marshal_struct3 () {
470 SimpleStruct2 ss2 = new SimpleStruct2 ();
471 ss2.b = true;
472 ss2.d = "TEST";
473 ss2.e = 99;
474 ss2.f = 1.5;
475 ss2.g = 42;
476 ss2.h = 123L;
477
478 return mono_test_marshal_struct2_2 (10, 11, 12, ss2);
479 }
480
481 public static int test_0_marshal_empty_struct () {
482 EmptyStruct es = new EmptyStruct ();
483
484 if (mono_test_empty_struct (1, es, 2) != 0)
485 return 1;
486
487 return 0;
488 }
489
490 public static int test_0_marshal_lpstruct () {
491 SimpleStruct ss = new SimpleStruct ();
492 ss.b = true;
493 ss.d = "TEST";
494
495 return mono_test_marshal_lpstruct (ss);
496 }
497
498 public static int test_0_marshal_lpstruct_blittable () {
499 Point p = new Point ();
500 p.x = 1.0;
501 p.y = 2.0;
502
503 return mono_test_marshal_lpstruct_blittable (p);
504 }
505
506 public static int test_0_marshal_struct_array () {
507 SimpleStruct2[] ss_arr = new SimpleStruct2 [2];
508
509 SimpleStruct2 ss2 = new SimpleStruct2 ();
510 ss2.b = true;
511 ss2.d = "TEST";
512 ss2.e = 99;
513 ss2.f = 1.5;
514 ss2.g = 42;
515 ss2.h = 123L;
516
517 ss_arr [0] = ss2;
518
519 ss2.b = false;
520 ss2.d = "TEST2";
521 ss2.e = 100;
522 ss2.f = 2.5;
523 ss2.g = 43;
524 ss2.h = 124L;
525
526 ss_arr [1] = ss2;
527
528 return mono_test_marshal_struct_array (ss_arr);
529 }
530
531 public static int test_105_marshal_long_align_struct_array () {
532 LongAlignStruct[] ss_arr = new LongAlignStruct [2];
533
534 LongAlignStruct ss = new LongAlignStruct ();
535 ss.a = 5;
536 ss.b = 10;
537 ss.c = 15;
538
539 ss_arr [0] = ss;
540
541 ss.a = 20;
542 ss.b = 25;
543 ss.c = 30;
544
545 ss_arr [1] = ss;
546
547 return mono_test_marshal_long_align_struct_array (ss_arr);
548 }
549
550 /* Test classes as arguments and return values */
551 public static int test_0_marshal_class () {
552 SimpleClass ss = new SimpleClass ();
553 ss.b = true;
554 ss.d = "TEST";
555 ss.e = 99;
556 ss.f = 1.5;
557 ss.g = 42;
558 ss.h = 123L;
559
560 SimpleClass res = mono_test_marshal_class (10, 11, 12, ss, 14);
561 if (res == null)
562 return 1;
563 if (! (res.a == ss.a && res.b == ss.b && res.c == ss.c &&
564 res.d == ss.d && res.e == ss.e && res.f == ss.f &&
565 res.g == ss.g && res.h == ss.h))
566 return 2;
567
568 /* Test null arguments and results */
569 res = mono_test_marshal_class (10, 11, 12, null, 14);
570 if (res != null)
571 return 3;
572
573 return 0;
574 }
575
576 public static int test_0_marshal_byref_class () {
577 SimpleClass ss = new SimpleClass ();
578 ss.b = true;
579 ss.d = "TEST";
580 ss.e = 99;
581 ss.f = 1.5;
582 ss.g = 42;
583 ss.h = 123L;
584
585 int res = mono_test_marshal_byref_class (ref ss);
586 if (ss.d != "TEST-RES")
587 return 1;
588
589 return 0;
590 }
591
592 public static int test_0_marshal_delegate () {
593 SimpleDelegate d = new SimpleDelegate (delegate_test);
594
595 return mono_test_marshal_delegate (d);
596 }
597
598 public static int test_34_marshal_instance_delegate () {
599 Tests t = new Tests ();
600 t.int_field = 32;
601 SimpleDelegate d = new SimpleDelegate (t.delegate_test_instance);
602
603 return mono_test_marshal_delegate (d);
604 }
605
606 /* Static delegates closed over their first argument */
607 public static int closed_delegate (Tests t, int a) {
608 return t.int_field + a;
609 }
610
611 public static int test_34_marshal_closed_static_delegate () {
612 Tests t = new Tests ();
613 t.int_field = 32;
614 SimpleDelegate d = (SimpleDelegate)Delegate.CreateDelegate (typeof (SimpleDelegate), t, typeof (Tests).GetMethod ("closed_delegate"));
615
616 return mono_test_marshal_delegate (d);
617 }
618
619 public static int test_0_marshal_return_delegate () {
620 SimpleDelegate d = new SimpleDelegate (delegate_test);
621
622 SimpleDelegate d2 = mono_test_marshal_return_delegate (d);
623
624 return d2 (2);
625 }
626
627 public static int test_0_marshal_delegate_struct () {
628 DelegateStruct s = new DelegateStruct ();
629
630 s.a = 2;
631 s.del = new SimpleDelegate (delegate_test);
632 s.del2 = new SimpleDelegate (delegate_test);
633 s.del3 = null;
634
635 DelegateStruct res = mono_test_marshal_delegate_struct (s);
636
637 if (res.a != 0)
638 return 1;
639 if (res.del (2) != 0)
640 return 2;
641 if (res.del2 (2) != 0)
642 return 3;
643 if (res.del3 != null)
644 return 4;
645
646 return 0;
647 }
648
649 [DllImport ("libtest", EntryPoint="mono_test_marshal_out_delegate")]
650 public static extern int mono_test_marshal_out_delegate (out SimpleDelegate d);
651
652 public static int test_3_marshal_out_delegate () {
653 SimpleDelegate d = null;
654
655 mono_test_marshal_out_delegate (out d);
656
657 return d (2);
658 }
659
660 public static int test_0_marshal_byref_struct () {
661 SimpleStruct s = new SimpleStruct ();
662 s.a = true;
663 s.b = false;
664 s.c = true;
665 s.d = "ABC";
666 s.d2 = "DEF";
667
668 int res = mono_test_marshal_byref_struct (ref s, true, false, true, "ABC");
669 if (res != 0)
670 return 1;
671 if (s.a != false || s.b != true || s.c != false || s.d != "DEF")
672 return 2;
673 return 0;
674 }
675
676 public static int test_0_marshal_byref_struct_in () {
677 SimpleStruct s = new SimpleStruct ();
678 s.a = true;
679 s.b = false;
680 s.c = true;
681 s.d = "ABC";
682 s.d2 = "DEF";
683
684 int res = mono_test_marshal_byref_struct_in (ref s, true, false, true, "ABC");
685 if (res != 0)
686 return 1;
687 if (s.a != true || s.b != false || s.c != true || s.d != "ABC")
688 return 2;
689 return 0;
690 }
691
692 public static int test_0_marshal_byref_struct_inout () {
693 SimpleStruct s = new SimpleStruct ();
694 s.a = true;
695 s.b = false;
696 s.c = true;
697 s.d = "ABC";
698 s.d2 = "DEF";
699
700 int res = mono_test_marshal_byref_struct_inout (ref s, true, false, true, "ABC");
701 if (res != 0)
702 return 1;
703 if (s.a != false || s.b != true || s.c != false || s.d != "DEF")
704 return 2;
705 return 0;
706 }
707
708 public static int test_0_marshal_point () {
709 Point pt = new Point();
710 pt.x = 1.25;
711 pt.y = 3.5;
712
713 return mono_test_marshal_point(pt);
714 }
715
716 public static int test_0_marshal_mixed_point () {
717 MixedPoint mpt = new MixedPoint();
718 mpt.x = 5;
719 mpt.y = 6.75;
720
721 return mono_test_marshal_mixed_point(mpt);
722 }
723
724 public static int test_0_marshal_bool_byref () {
725 bool b = true;
726 if (mono_test_marshal_bool_byref (99, ref b, 100) != 1)
727 return 1;
728 b = false;
729 if (mono_test_marshal_bool_byref (99, ref b, 100) != 0)
730 return 12;
731 if (b != true)
732 return 13;
733
734 return 0;
735 }
736
737 public static int test_0_marshal_bool_as_I1 () {
738
739 int ret;
740 bool bTrue, bFalse;
741 if ((ret = mono_test_marshal_bool_in_as_I1 (true, false)) != 0)
742 return ret;
743
744 if ((ret = mono_test_marshal_bool_out_as_I1 (out bTrue, out bFalse)) != 0)
745 return ret;
746
747 if(!bTrue)
748 return 10;
749
750 if(bFalse)
751 return 11;
752
753 if ((ret = mono_test_marshal_bool_ref_as_I1 (ref bTrue, ref bFalse)) != 0)
754 return ret;
755
756 if(bTrue)
757 return 12;
758
759 if(!bFalse)
760 return 13;
761
762 return 0;
763 }
764
765 public static int test_0_marshal_bool_as_U1 () {
766
767 int ret;
768 bool bTrue, bFalse;
769 if ((ret = mono_test_marshal_bool_in_as_U1 (true, false)) != 0)
770 return ret;
771
772 if ((ret = mono_test_marshal_bool_out_as_U1 (out bTrue, out bFalse)) != 0)
773 return ret;
774
775 if(!bTrue)
776 return 10;
777
778 if(bFalse)
779 return 11;
780
781 if ((ret = mono_test_marshal_bool_ref_as_U1 (ref bTrue, ref bFalse)) != 0)
782 return ret;
783
784 if(bTrue)
785 return 12;
786
787 if(!bFalse)
788 return 13;
789
790 return 0;
791 }
792
793 public static int test_0_return_vtype () {
794 SimpleStruct ss = mono_test_return_vtype (new IntPtr (5));
795
796 if (!ss.a && ss.b && !ss.c && ss.d == "TEST" && ss.d2 == "TEST2")
797 return 0;
798
799 return 1;
800 }
801
802 public static int test_0_marshal_stringbuilder () {
803 StringBuilder sb = new StringBuilder(255);
804 sb.Append ("ABCD");
805 mono_test_marshal_stringbuilder (sb, sb.Capacity);
806 String res = sb.ToString();
807
808 if (res != "This is my message. Isn't it nice?")
809 return 1;
810
811 // Test StringBuilder with default capacity (16)
812 StringBuilder sb2 = new StringBuilder();
813 mono_test_marshal_stringbuilder_default (sb2, sb2.Capacity);
814 if (sb2.ToString () != "This is my messa")
815 return 3;
816
817 return 0;
818 }
819
820 public static int test_0_marshal_stringbuilder_append () {
821 const String in_sentinel = "MONO_";
822 const String out_sentinel = "CSHARP_";
823 const int iterations = 100;
824 StringBuilder sb = new StringBuilder(255);
825 StringBuilder check = new StringBuilder(255);
826
827 for (int i = 0; i < iterations; i++) {
828 sb.Append (in_sentinel[i % in_sentinel.Length]);
829 check.Append (out_sentinel[i % out_sentinel.Length]);
830
831 mono_test_marshal_stringbuilder_append (sb, sb.Length);
832
833 String res = sb.ToString();
834 String checkRev = check.ToString();
835 if (res != checkRev)
836 return 1;
837 }
838
839 // Test StringBuilder with default capacity (16)
840 StringBuilder sb2 = new StringBuilder();
841 mono_test_marshal_stringbuilder_default (sb2, sb2.Capacity);
842 if (sb2.ToString () != "This is my messa")
843 return 3;
844
845 return 0;
846 }
847
848 public static int test_0_marshal_stringbuilder_unicode () {
849 StringBuilder sb = new StringBuilder(255);
850 mono_test_marshal_stringbuilder_unicode (sb, sb.Capacity);
851 String res = sb.ToString();
852
853 if (res != "This is my message. Isn't it nice?")
854 return 1;
855
856 // Test StringBuilder with default capacity (16)
857 StringBuilder sb2 = new StringBuilder();
858 mono_test_marshal_stringbuilder_unicode (sb2, sb2.Capacity);
859 if (sb2.ToString () != "This is my messa")
860 return 2;
861
862 return 0;
863 }
864
865 public static int test_0_marshal_stringbuilder_out () {
866 StringBuilder sb;
867 mono_test_marshal_stringbuilder_out (out sb);
868
869 if (sb.ToString () != "This is my message. Isn't it nice?")
870 return 1;
871 return 0;
872 }
873
874 public static int test_0_marshal_stringbuilder_out_unicode () {
875 StringBuilder sb;
876 mono_test_marshal_stringbuilder_out_unicode (out sb);
877
878 if (sb.ToString () != "This is my message. Isn't it nice?")
879 return 1;
880 return 0;
881 }
882
883 public static int test_0_marshal_stringbuilder_ref () {
884 StringBuilder sb = new StringBuilder ();
885 sb.Append ("ABC");
886 int res = mono_test_marshal_stringbuilder_ref (ref sb);
887 if (res != 0)
888 return 1;
889
890 if (sb.ToString () != "This is my message. Isn't it nice?")
891 return 2;
892 return 0;
893 }
894
895 public static int test_0_marshal_empty_string_array () {
896 return mono_test_marshal_empty_string_array (null);
897 }
898
899 public static int test_0_marshal_string_array () {
900 return mono_test_marshal_string_array (new String [] { "ABC", "DEF" });
901 }
902
903 public static int test_0_marshal_unicode_string_array () {
904 return mono_test_marshal_unicode_string_array (new String [] { "ABC", "DEF" }, new String [] { "ABC", "DEF" });
905 }
906
907 public static int test_0_marshal_stringbuilder_array () {
908 StringBuilder sb1 = new StringBuilder ("ABC");
909 StringBuilder sb2 = new StringBuilder ("DEF");
910
911 int res = mono_test_marshal_stringbuilder_array (new StringBuilder [] { sb1, sb2 });
912 if (res != 0)
913 return res;
914 if (sb1.ToString () != "DEF")
915 return 5;
916 if (sb2.ToString () != "ABC")
917 return 6;
918 return 0;
919 }
920
921 public static int test_0_last_error () {
922 mono_test_last_error (5);
923 if (Marshal.GetLastWin32Error () == 5)
924 return 0;
925 else
926 return 1;
927 }
928
929 public static int test_0_entry_point_not_found () {
930
931 try {
932 mono_entry_point_not_found ();
933 return 1;
934 }
935 catch (EntryPointNotFoundException) {
936 }
937
938 return 0;
939 }
940
941 public static int test_0_library_not_found () {
942
943 try {
944 mono_library_not_found ();
945 return 1;
946 }
947 catch (DllNotFoundException) {
948 }
949
950 return 0;
951 }
952
953 /* Check that the runtime trims .dll from the library name */
954 public static int test_0_trim_dll_from_name () {
955
956 mono_test_marshal_char_2 ('A');
957
958 return 0;
959 }
960
961 /* Check that the runtime adds lib to to the library name */
962 public static int test_0_add_lib_to_name () {
963
964 mono_test_marshal_char_3 ('A');
965
966 return 0;
967 }
968
969 class C {
970 public int i;
971 }
972
973 public static int test_0_asany () {
974 if (mono_test_asany (5, 1) != 0)
975 return 1;
976
977 if (mono_test_asany ("ABC", 2) != 0)
978 return 2;
979
980 SimpleStruct2 ss2 = new SimpleStruct2 ();
981 ss2.b = true;
982 ss2.d = "TEST";
983 ss2.e = 99;
984 ss2.f = 1.5;
985 ss2.g = 42;
986 ss2.h = 123L;
987
988 if (mono_test_asany (ss2, 3) != 0)
989 return 3;
990
991 if (mono_test_asany_unicode ("ABC", 4) != 0)
992 return 4;
993
994 try {
995 C c = new C ();
996 c.i = 5;
997 mono_test_asany (c, 0);
998 return 5;
999 }
1000 catch (ArgumentException) {
1001 }
1002
1003 try {
1004 mono_test_asany (new Object (), 0);
1005 return 6;
1006 }
1007 catch (ArgumentException) {
1008 }
1009
1010 return 0;
1011 }
1012
1013 /* AsAny marshalling + [In, Out] */
1014
1015 public static int test_0_asany_in () {
1016 // Struct
1017 AsAnyStruct str = new AsAnyStruct(1,2,3, "ABC");
1018 mono_test_asany_in (str);
1019
1020 // Formatted Class
1021 AsAnyClass cls = new AsAnyClass(1,2,3, "ABC");
1022 mono_test_asany_in (cls);
1023 if ((cls.i != 1) || (cls.j != 2) || (cls.k != 3))
1024 return 1;
1025
1026 // Boxed Struct
1027 object obj = new AsAnyStruct(1,2,3, "ABC");
1028 mono_test_asany_in (obj);
1029 str = (AsAnyStruct)obj;
1030 if ((str.i != 1) || (str.j != 2) || (str.k != 3))
1031 return 2;
1032
1033 return 0;
1034 }
1035
1036 public static int test_0_asany_out () {
1037 // Struct
1038 AsAnyStruct str = new AsAnyStruct(1,2,3, "ABC");
1039 mono_test_asany_out (str);
1040
1041 // Formatted Class
1042 AsAnyClass cls = new AsAnyClass(1,2,3, "ABC");
1043 mono_test_asany_out (cls);
1044 if ((cls.i != 10) || (cls.j != 20) || (cls.k != 30))
1045 return 1;
1046
1047 // Boxed Struct
1048 object obj = new AsAnyStruct(1,2,3, "ABC");
1049 mono_test_asany_out (obj);
1050 str = (AsAnyStruct)obj;
1051 if ((str.i != 10) || (str.j != 20) || (str.k != 30))
1052 return 2;
1053
1054 return 0;
1055 }
1056
1057 public static int test_0_asany_inout () {
1058 // Struct
1059 AsAnyStruct str = new AsAnyStruct(1,2,3, "ABC");
1060 mono_test_asany_inout (str);
1061
1062 // Formatted Class
1063 AsAnyClass cls = new AsAnyClass(1,2,3, "ABC");
1064 mono_test_asany_inout (cls);
1065 if ((cls.i != 10) || (cls.j != 20) || (cls.k != 30))
1066 return 1;
1067
1068 // Boxed Struct
1069 object obj = new AsAnyStruct(1,2,3, "ABC");
1070 mono_test_asany_inout (obj);
1071 str = (AsAnyStruct)obj;
1072 if ((str.i != 10) || (str.j != 20) || (str.k != 30))
1073 return 2;
1074
1075 return 0;
1076 }
1077
1078 /* Byref String Array */
1079
1080 [DllImport ("libtest", EntryPoint="mono_test_marshal_byref_string_array")]
1081 public static extern int mono_test_marshal_byref_string_array (ref string[] data);
1082
1083 public static int test_0_byref_string_array () {
1084
1085 string[] arr = null;
1086
1087 if (mono_test_marshal_byref_string_array (ref arr) != 0)
1088 return 1;
1089
1090 arr = new string[] { "Alpha", "Beta", "Gamma" };
1091
1092 if (mono_test_marshal_byref_string_array (ref arr) != 1)
1093 return 2;
1094
1095 /* FIXME: Test returned array and out case */
1096
1097 return 0;
1098 }
1099
1100 /*
1101 * AMD64 small structs-by-value tests.
1102 */
1103
1104 /* TEST 1: 16 byte long INTEGER struct */
1105
1106 [StructLayout(LayoutKind.Sequential)]
1107 public struct Amd64Struct1 {
1108 public int i;
1109 public int j;
1110 public int k;
1111 public int l;
1112 }
1113
1114 [DllImport ("libtest", EntryPoint="mono_test_marshal_amd64_pass_return_struct1")]
1115 public static extern Amd64Struct1 mono_test_marshal_amd64_pass_return_struct1 (Amd64Struct1 s);
1116
1117 [DllImport ("libtest", EntryPoint="mono_test_marshal_amd64_pass_return_struct1_many_args")]
1118 public static extern Amd64Struct1 mono_test_marshal_amd64_pass_return_struct1_many_args (Amd64Struct1 s, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8);
1119
1120 public static int test_0_amd64_struct1 () {
1121 Amd64Struct1 s = new Amd64Struct1 ();
1122 s.i = 5;
1123 s.j = -5;
1124 s.k = 0xffffff;
1125 s.l = 0xfffffff;
1126
1127 Amd64Struct1 s2 = mono_test_marshal_amd64_pass_return_struct1 (s);
1128
1129 return ((s2.i == 6) && (s2.j == -4) && (s2.k == 0x1000000) && (s2.l == 0x10000000)) ? 0 : 1;
1130 }
1131
1132 public static int test_0_amd64_struct1_many_args () {
1133 Amd64Struct1 s = new Amd64Struct1 ();
1134 s.i = 5;
1135 s.j = -5;
1136 s.k = 0xffffff;
1137 s.l = 0xfffffff;
1138
1139 Amd64Struct1 s2 = mono_test_marshal_amd64_pass_return_struct1_many_args (s, 1, 2, 3, 4, 5, 6, 7, 8);
1140
1141 return ((s2.i == 6) && (s2.j == -4) && (s2.k == 0x1000000) && (s2.l == 0x10000000 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8)) ? 0 : 1;
1142 }
1143
1144 /* TEST 2: 8 byte long INTEGER struct */
1145
1146 [StructLayout(LayoutKind.Sequential)]
1147 public struct Amd64Struct2 {
1148 public int i;
1149 public int j;
1150 }
1151
1152 [DllImport ("libtest", EntryPoint="mono_test_marshal_amd64_pass_return_struct2")]
1153 public static extern Amd64Struct2 mono_test_marshal_amd64_pass_return_struct2 (Amd64Struct2 s);
1154
1155 public static int test_0_amd64_struct2 () {
1156 Amd64Struct2 s = new Amd64Struct2 ();
1157 s.i = 5;
1158 s.j = -5;
1159
1160 Amd64Struct2 s2 = mono_test_marshal_amd64_pass_return_struct2 (s);
1161
1162 return ((s2.i == 6) && (s2.j == -4)) ? 0 : 1;
1163 }
1164
1165 /* TEST 3: 4 byte long INTEGER struct */
1166
1167 [StructLayout(LayoutKind.Sequential)]
1168 public struct Amd64Struct3 {
1169 public int i;
1170 }
1171
1172 [DllImport ("libtest", EntryPoint="mono_test_marshal_amd64_pass_return_struct3")]
1173 public static extern Amd64Struct3 mono_test_marshal_amd64_pass_return_struct3 (Amd64Struct3 s);
1174
1175 public static int test_0_amd64_struct3 () {
1176 Amd64Struct3 s = new Amd64Struct3 ();
1177 s.i = -5;
1178
1179 Amd64Struct3 s2 = mono_test_marshal_amd64_pass_return_struct3 (s);
1180
1181 return (s2.i == -4) ? 0 : 1;
1182 }
1183
1184 /* Test 4: 16 byte long FLOAT struct */
1185
1186 [StructLayout(LayoutKind.Sequential)]
1187 public struct Amd64Struct4 {
1188 public double d1, d2;
1189 }
1190
1191 [DllImport ("libtest", EntryPoint="mono_test_marshal_amd64_pass_return_struct4")]
1192 public static extern Amd64Struct4 mono_test_marshal_amd64_pass_return_struct4 (Amd64Struct4 s);
1193
1194 public static int test_0_amd64_struct4 () {
1195 Amd64Struct4 s = new Amd64Struct4 ();
1196 s.d1 = 5.0;
1197 s.d2 = -5.0;
1198
1199 Amd64Struct4 s2 = mono_test_marshal_amd64_pass_return_struct4 (s);
1200
1201 return (s2.d1 == 6.0 && s2.d2 == -4.0) ? 0 : 1;
1202 }
1203
1204 /*
1205 * IA64 struct tests
1206 */
1207
1208 /* Test 5: Float HFA */
1209
1210 [StructLayout(LayoutKind.Sequential)]
1211 public struct TestStruct5 {
1212 public float d1, d2;
1213 }
1214
1215 [DllImport ("libtest", EntryPoint="mono_test_marshal_ia64_pass_return_struct5")]
1216 public static extern TestStruct5 mono_test_marshal_ia64_pass_return_struct5 (double d1, double d2, TestStruct5 s, int i, double f3, double f4);
1217
1218 public static int test_0_ia64_struct5 () {
1219 TestStruct5 s = new TestStruct5 ();
1220 s.d1 = 5.0f;
1221 s.d2 = -5.0f;
1222
1223 TestStruct5 s2 = mono_test_marshal_ia64_pass_return_struct5 (1.0, 2.0, s, 5, 3.0, 4.0);
1224
1225 return (s2.d1 == 13.0 && s2.d2 == 7.0) ? 0 : 1;
1226 }
1227
1228 /* Test 6: Double HFA */
1229
1230 [StructLayout(LayoutKind.Sequential)]
1231 public struct TestStruct6 {
1232 public double d1, d2;
1233 }
1234
1235 [DllImport ("libtest", EntryPoint="mono_test_marshal_ia64_pass_return_struct6")]
1236 public static extern TestStruct6 mono_test_marshal_ia64_pass_return_struct6 (double d1, double d2, TestStruct6 s, int i, double f3, double f4);
1237
1238 public static int test_0_ia64_struct6 () {
1239 TestStruct6 s = new TestStruct6 ();
1240 s.d1 = 6.0;
1241 s.d2 = -6.0;
1242
1243 TestStruct6 s2 = mono_test_marshal_ia64_pass_return_struct6 (1.0, 2.0, s, 3, 4.0, 5.0);
1244
1245 return (s2.d1 == 12.0 && s2.d2 == 3.0) ? 0 : 1;
1246 }
1247
1248 /* Blittable class */
1249 [DllImport("libtest")]
1250 private static extern BlittableClass TestBlittableClass (BlittableClass vl);
1251
1252 public static int test_0_marshal_blittable_class () {
1253 BlittableClass v1 = new BlittableClass ();
1254
1255 /* Since it is blittable, it looks like it is passed as in/out */
1256 BlittableClass v2 = TestBlittableClass (v1);
1257
1258 if (v1.a != 2 || v1.b != 3)
1259 return 1;
1260
1261 if (v2.a != 2 || v2.b != 3)
1262 return 2;
1263
1264 // Test null
1265 BlittableClass v3 = TestBlittableClass (null);
1266
1267 if (v3.a != 42 || v3.b != 43)
1268 return 3;
1269
1270 return 0;
1271 }
1272
1273 /*
1274 * Generic structures
1275 */
1276
1277 [StructLayout(LayoutKind.Sequential)]
1278 public struct Amd64Struct1Gen<T> {
1279 public T i;
1280 public T j;
1281 public T k;
1282 public T l;
1283 }
1284
1285 [DllImport ("libtest", EntryPoint="mono_test_marshal_amd64_pass_return_struct1")]
1286 public static extern Amd64Struct1Gen<int> mono_test_marshal_amd64_pass_return_struct1_gen (Amd64Struct1Gen<int> s);
1287
1288 public static int test_0_amd64_struct1_gen () {
1289 Amd64Struct1Gen<int> s = new Amd64Struct1Gen<int> ();
1290 s.i = 5;
1291 s.j = -5;
1292 s.k = 0xffffff;
1293 s.l = 0xfffffff;
1294
1295 Amd64Struct1Gen<int> s2 = mono_test_marshal_amd64_pass_return_struct1_gen (s);
1296
1297 return ((s2.i == 6) && (s2.j == -4) && (s2.k == 0x1000000) && (s2.l == 0x10000000)) ? 0 : 1;
1298 }
1299
1300 /*
1301 * Other tests
1302 */
1303
1304 public static int test_0_marshal_byval_class () {
1305 SimpleObj obj0 = new SimpleObj ();
1306 obj0.str = "T1";
1307 obj0.i = 4;
1308
1309 if (class_marshal_test0 (obj0) != 0)
1310 return 1;
1311
1312 return 0;
1313 }
1314
1315 public static int test_0_marshal_byval_class_null () {
1316 if (class_marshal_test4 (null) != 0)
1317 return 1;
1318
1319 return 0;
1320 }
1321
1322 public static int test_0_marshal_out_class () {
1323 SimpleObj obj1;
1324
1325 class_marshal_test1 (out obj1);
1326
1327 if (obj1.str != "ABC")
1328 return 1;
1329
1330 if (obj1.i != 5)
1331 return 2;
1332
1333 return 0;
1334 }
1335
1336 public static int test_0_marshal_string () {
1337 return string_marshal_test0 ("TEST0");
1338 }
1339
1340 public static int test_0_marshal_out_string () {
1341 string res;
1342
1343 string_marshal_test1 (out res);
1344
1345 if (res != "TEST1")
1346 return 1;
1347
1348 return 0;
1349 }
1350
1351 public static int test_0_marshal_byref_string () {
1352 string res = "TEST1";
1353
1354 int r = string_marshal_test2 (ref res);
1355 if (r != 0)
1356 return 1;
1357 if (res != "TEST2")
1358 return 2;
1359 return 0;
1360 }
1361
1362 public static int test_0_marshal_null_string () {
1363 return string_marshal_test3 (null);
1364 }
1365
1366 #if FALSE
1367 [DllImport ("libtest", EntryPoint="mono_test_stdcall_mismatch_1", CallingConvention=CallingConvention.StdCall)]
1368 public static extern int mono_test_stdcall_mismatch_1 (int a, int b, int c);
1369
1370 /* Test mismatched called conventions, the native function is cdecl */
1371 public static int test_0_stdcall_mismatch_1 () {
1372 mono_test_stdcall_mismatch_1 (0, 1, 2);
1373 return 0;
1374 }
1375
1376 [DllImport ("libtest", EntryPoint="mono_test_stdcall_mismatch_2", CallingConvention=CallingConvention.Cdecl)]
1377 public static extern int mono_test_stdcall_mismatch_2 (int a, int b, int c);
1378
1379 /* Test mismatched called conventions, the native function is stdcall */
1380 public static int test_0_stdcall_mismatch_2 () {
1381 mono_test_stdcall_mismatch_2 (0, 1, 2);
1382 return 0;
1383 }
1384 #endif
1385
1386 [DllImport ("libtest", EntryPoint="mono_test_stdcall_name_mangling", CallingConvention=CallingConvention.StdCall)]
1387 public static extern int mono_test_stdcall_name_mangling (int a, int b, int c);
1388
1389 public static int test_0_stdcall_name_mangling () {
1390 return mono_test_stdcall_name_mangling (0, 1, 2) == 3 ? 0 : 1;
1391 }
1392
1393 /* Float test */
1394
1395 [DllImport ("libtest", EntryPoint="mono_test_marshal_pass_return_float")]
1396 public static extern float mono_test_marshal_pass_return_float (float f);
1397
1398 public static int test_0_pass_return_float () {
1399 float f = mono_test_marshal_pass_return_float (1.5f);
1400
1401 return (f == 2.5f) ? 0 : 1;
1402 }
1403
1404 /*
1405 * Pointers to structures can not be passed
1406 */
1407
1408 /* This seems to be allowed by MS in some cases */
1409 /*
1410 public struct CharInfo {
1411 public char Character;
1412 public short Attributes;
1413 }
1414
1415 [DllImport ("libtest", EntryPoint="mono_test_marshal_struct")]
1416 public static unsafe extern int mono_test_marshal_ptr_to_struct (CharInfo *ptr);
1417
1418 public static unsafe int test_0_marshal_ptr_to_struct () {
1419 CharInfo [] buffer = new CharInfo [1];
1420 fixed (CharInfo *ptr = &buffer [0]) {
1421 try {
1422 mono_test_marshal_ptr_to_struct (ptr);
1423 return 1;
1424 }
1425 catch (MarshalDirectiveException) {
1426 return 0;
1427 }
1428 }
1429 return 1;
1430 }
1431 */
1432
1433 /*
1434 * LPWStr marshalling
1435 */
1436
1437 [DllImport("libtest", EntryPoint="test_lpwstr_marshal")]
1438 [return: MarshalAs(UnmanagedType.LPWStr)]
1439 private static extern string mono_test_marshal_lpwstr_marshal(
1440 [MarshalAs(UnmanagedType.LPWStr)] string s,
1441 int length );
1442
1443 [DllImport("libtest", EntryPoint="test_lpwstr_marshal", CharSet=CharSet.Unicode)]
1444 private static extern string mono_test_marshal_lpwstr_marshal2(
1445 string s,
1446 int length );
1447
1448 [DllImport("libtest", EntryPoint="test_lpwstr_marshal_out")]
1449 private static extern void mono_test_marshal_lpwstr_out_marshal(
1450 [MarshalAs(UnmanagedType.LPWStr)] out string s);
1451
1452 [DllImport("libtest", EntryPoint="test_lpwstr_marshal_out", CharSet=CharSet.Unicode)]
1453 private static extern void mono_test_marshal_lpwstr_out_marshal2(
1454 out string s);
1455
1456 public static int test_0_pass_return_lwpstr () {
1457 string s;
1458
1459 mono_test_marshal_lpwstr_out_marshal (out s);
1460
1461 if (s != "ABC")
1462 return 1;
1463
1464 s = null;
1465 mono_test_marshal_lpwstr_out_marshal2 (out s);
1466
1467 if (s != "ABC")
1468 return 2;
1469
1470 return 0;
1471 }
1472
1473 public static int test_0_out_lwpstr () {
1474 string s = "ABC";
1475
1476 string res = mono_test_marshal_lpwstr_marshal (s, s.Length);
1477
1478 if (res != "ABC")
1479 return 1;
1480
1481 string res2 = mono_test_marshal_lpwstr_marshal2 (s, s.Length);
1482
1483 if (res2 != "ABC")
1484 return 2;
1485
1486 return 0;
1487 }
1488
1489 /*
1490 * Byref bool marshalling
1491 */
1492
1493 [DllImport("libtest")]
1494 extern static int marshal_test_ref_bool
1495 (
1496 int i,
1497 [MarshalAs(UnmanagedType.I1)] ref bool b1,
1498 [MarshalAs(UnmanagedType.VariantBool)] ref bool b2,
1499 ref bool b3
1500 );
1501
1502 public static int test_0_pass_byref_bool () {
1503 for (int i = 0; i < 8; i++)
1504 {
1505 bool b1 = (i & 4) != 0;
1506 bool b2 = (i & 2) != 0;
1507 bool b3 = (i & 1) != 0;
1508 bool orig_b1 = b1, orig_b2 = b2, orig_b3 = b3;
1509 if (marshal_test_ref_bool(i, ref b1, ref b2, ref b3) != 0)
1510 return 4 * i + 1;
1511 if (b1 != !orig_b1)
1512 return 4 * i + 2;
1513 if (b2 != !orig_b2)
1514 return 4 * i + 3;
1515 if (b3 != !orig_b3)
1516 return 4 * i + 4;
1517 }
1518
1519 return 0;
1520 }
1521
1522 /*
1523 * Bool struct field marshalling
1524 */
1525
1526 struct BoolStruct
1527 {
1528 public int i;
1529 [MarshalAs(UnmanagedType.I1)] public bool b1;
1530 [MarshalAs(UnmanagedType.VariantBool)] public bool b2;
1531 public bool b3;
1532 }
1533
1534 [DllImport("libtest")]
1535 extern static int marshal_test_bool_struct(ref BoolStruct s);
1536
1537 public static int test_0_pass_bool_in_struct () {
1538 for (int i = 0; i < 8; i++)
1539 {
1540 BoolStruct s = new BoolStruct();
1541 s.i = i;
1542 s.b1 = (i & 4) != 0;
1543 s.b2 = (i & 2) != 0;
1544 s.b3 = (i & 1) != 0;
1545 BoolStruct orig = s;
1546 if (marshal_test_bool_struct(ref s) != 0)
1547 return 4 * i + 33;
1548 if (s.b1 != !orig.b1)
1549 return 4 * i + 34;
1550 if (s.b2 != !orig.b2)
1551 return 4 * i + 35;
1552 if (s.b3 != !orig.b3)
1553 return 4 * i + 36;
1554 }
1555
1556 return 0;
1557 }
1558
1559 /*
1560 * Alignment of structs containing longs
1561 */
1562
1563 struct LongStruct2 {
1564 public long l;
1565 }
1566
1567 struct LongStruct {
1568 public int i;
1569 public LongStruct2 l;
1570 }
1571
1572 [DllImport("libtest")]
1573 extern static int mono_test_marshal_long_struct (ref LongStruct s);
1574
1575 public static int test_47_pass_long_struct () {
1576 LongStruct s = new LongStruct ();
1577 s.i = 5;
1578 s.l = new LongStruct2 ();
1579 s.l.l = 42;
1580
1581 return mono_test_marshal_long_struct (ref s);
1582 }
1583
1584 /*
1585 * Invoking pinvoke methods through delegates
1586 */
1587
1588 delegate int MyDelegate (string name);
1589
1590 [DllImport ("libtest", EntryPoint="mono_test_puts_static")]
1591 public static extern int puts_static (string name);
1592
1593 public static int test_0_invoke_pinvoke_through_delegate () {
1594 puts_static ("A simple Test for PInvoke 1");
1595
1596 MyDelegate d = new MyDelegate (puts_static);
1597 d ("A simple Test for PInvoke 2");
1598
1599 object [] args = {"A simple Test for PInvoke 3"};
1600 d.DynamicInvoke (args);
1601
1602 return 0;
1603 }
1604
1605 /*
1606 * Missing virtual pinvoke methods
1607 */
1608
1609 public class T {
1610
1611 public virtual object MyClone ()
1612 {
1613 return null;
1614 }
1615 }
1616
1617 public class T2 : T {
1618 [MethodImplAttribute(MethodImplOptions.InternalCall)]
1619 public override extern object MyClone ();
1620 }
1621
1622 public static int test_0_missing_virtual_pinvoke_method () {
1623 T2 t = new T2 ();
1624
1625 try {
1626 t.MyClone ();
1627 } catch (Exception ex) {
1628 return 0;
1629 }
1630
1631 return 1;
1632 }
1633
1634 /*
1635 * Marshalling of type 'object'
1636 */
1637
1638 [DllImport ("libtest", EntryPoint="mono_test_marshal_class")]
1639 public static extern SimpleClass mono_test_marshal_object (int i, int j, int k, object ss, int l);
1640
1641 public static int test_0_marshal_object () {
1642 try {
1643 mono_test_marshal_object (0, 0, 0, null, 0);
1644 return 1;
1645 } catch (Exception) {
1646 return 0;
1647 }
1648 }
1649
1650 /*
1651 * Marshalling of DateTime to OLE DATE (double)
1652 */
1653 [DllImport ("libtest", EntryPoint="mono_test_marshal_date_time")]
1654 public static extern double mono_test_marshal_date_time (DateTime d, out DateTime d2);
1655
1656 public static int test_0_marshal_date_time () {
1657 DateTime d = new DateTime (2009, 12, 6);
1658 DateTime d2;
1659 double d3 = mono_test_marshal_date_time (d, out d2);
1660 if (d3 != 40153.0)
1661 return 1;
1662 if (d2 != d)
1663 return 2;
1664 return 0;
1665 }
1666
1667 /*
1668 * Calling pinvoke functions dynamically using calli
1669 */
1670
1671 [DllImport("libtest")]
1672 private static extern IntPtr mono_test_marshal_lookup_symbol (string fileName);
1673
1674 delegate void CalliDel (IntPtr a, int[] f);
1675
1676 public static int test_0_calli_dynamic () {
1677 /* we need the cdecl version because the icall convention demands it under Windows */
1678 IntPtr func = mono_test_marshal_lookup_symbol ("mono_test_marshal_inout_array_cdecl");
1679
1680 DynamicMethod dm = new DynamicMethod ("calli", typeof (void), new Type [] { typeof (IntPtr), typeof (int[]) });
1681
1682 var il = dm.GetILGenerator ();
1683 var signature = SignatureHelper.GetMethodSigHelper (CallingConvention.Cdecl, typeof (void));
1684
1685 il.Emit (OpCodes.Ldarg, 1);
1686 signature.AddArgument (typeof (byte[]));
1687
1688 il.Emit (OpCodes.Ldarg_0);
1689
1690 il.Emit (OpCodes.Calli, signature);
1691 il.Emit (OpCodes.Ret);
1692
1693 var f = (CalliDel)dm.CreateDelegate (typeof (CalliDel));
1694
1695 int[] arr = new int [1000];
1696 for (int i = 0; i < 50; ++i)
1697 arr [i] = (int)i;
1698 f (func, arr);
1699 if (arr.Length != 1000)
1700 return 1;
1701 for (int i = 0; i < 50; ++i)
1702 if (arr [i] != 50 - i)
1703 return 2;
1704
1705 return 0;
1706 }
1707
1708
1709 /*char array marshaling */
1710 [DllImport ("libtest", EntryPoint="mono_test_marshal_ansi_char_array", CharSet=CharSet.Ansi)]
1711 public static extern int mono_test_marshal_ansi_char_array (char[] a1);
1712
1713 public static int test_0_marshal_ansi_char_array () {
1714 char[] buf = new char [32];
1715 buf [0] = 'q';
1716 buf [1] = 'w';
1717 buf [2] = 'e';
1718 buf [3] = 'r';
1719
1720 if (mono_test_marshal_ansi_char_array (buf) != 0)
1721 return 1;
1722
1723 string s = new string (buf);
1724 if (s.StartsWith ("qwer"))
1725 return 0;
1726 else
1727 return 2;
1728 }
1729
1730 /*char array marshaling */
1731 [DllImport ("libtest", EntryPoint="mono_test_marshal_unicode_char_array", CharSet=CharSet.Unicode)]
1732 public static extern int mono_test_marshal_unicode_char_array (char[] a1);
1733
1734 public static int test_0_marshal_unicode_char_array () {
1735 char[] buf = new char [32];
1736 buf [0] = 'q';
1737 buf [1] = 'w';
1738 buf [2] = 'e';
1739 buf [3] = 'r';
1740
1741 if (mono_test_marshal_unicode_char_array (buf) != 0)
1742 return 1;
1743
1744 string s = new string (buf);
1745 if (s.StartsWith ("abcdef"))
1746 return 0;
1747 else
1748 return 2;
1749 }
1750
1751 [DllImport ("libtest", EntryPoint="mono_test_marshal_lpstr")]
1752 public static extern int mono_test_marshal_lpstr ([MarshalAs(UnmanagedType.LPStr)] string str);
1753
1754 public static int test_0_mono_test_marshal_lpstr () {
1755 string str = "ABC";
1756
1757 if (mono_test_marshal_lpstr (str) != 0)
1758 return 1;
1759
1760 return 0;
1761 }
1762
1763 [DllImport ("libtest", EntryPoint="mono_test_marshal_lpwstr")]
1764 public static extern int mono_test_marshal_lpwstr ([MarshalAs(UnmanagedType.LPWStr)] string str);
1765
1766 public static int test_0_mono_test_marshal_lpwstr () {
1767 string str = "ABC";
1768
1769 if (mono_test_marshal_lpwstr (str) != 0)
1770 return 1;
1771
1772 return 0;
1773 }
1774
1775
1776 [method: DllImport ("libtest", EntryPoint="mono_test_marshal_return_lpstr")]
1777 [return: MarshalAs(UnmanagedType.LPStr)]
1778 public static extern string mono_test_marshal_return_lpstr ();
1779
1780 public static int test_0_mono_test_marshal_return_lpstr () {
1781 string str = mono_test_marshal_return_lpstr ();
1782 if ("XYZ" == str)
1783 return 0;
1784
1785 return 1;
1786 }
1787
1788 [method: DllImport ("libtest", EntryPoint="mono_test_marshal_return_lpwstr")]
1789 [return: MarshalAs(UnmanagedType.LPWStr)]
1790 public static extern string mono_test_marshal_return_lpwstr ();
1791
1792 public static int test_0_mono_test_marshal_return_lpwstr () {
1793 string str = mono_test_marshal_return_lpwstr ();
1794 if ("XYZ" == str)
1795 return 0;
1796
1797 return 1;
1798 }
1799
1800 [DllImport ("libtest", EntryPoint="mono_test_has_thiscall")]
1801 public static extern int mono_test_has_thiscall ();
1802
1803 [DllImport ("libtest", EntryPoint = "_mono_test_native_thiscall1", CallingConvention=CallingConvention.ThisCall)]
1804 public static extern int mono_test_native_thiscall (int a);
1805
1806 [DllImport ("libtest", EntryPoint = "_mono_test_native_thiscall2", CallingConvention=CallingConvention.ThisCall)]
1807 public static extern int mono_test_native_thiscall (int a, int b);
1808
1809 [DllImport ("libtest", EntryPoint = "_mono_test_native_thiscall3", CallingConvention=CallingConvention.ThisCall)]
1810 public static extern int mono_test_native_thiscall (int a, int b, int c);
1811
1812 [DllImport ("libtest", EntryPoint = "_mono_test_native_thiscall1", CallingConvention=CallingConvention.ThisCall)]
1813 public static extern int mono_test_native_thiscall (TinyStruct a);
1814
1815 [DllImport ("libtest", EntryPoint = "_mono_test_native_thiscall2", CallingConvention=CallingConvention.ThisCall)]
1816 public static extern int mono_test_native_thiscall (TinyStruct a, int b);
1817
1818 [DllImport ("libtest", EntryPoint = "_mono_test_native_thiscall3", CallingConvention=CallingConvention.ThisCall)]
1819 public static extern int mono_test_native_thiscall (TinyStruct a, int b, int c);
1820
1821 public static int test_0_native_thiscall ()
1822 {
1823 if (mono_test_has_thiscall () == 0)
1824 return 0;
1825
1826 if (mono_test_native_thiscall (1968329802) != 1968329802)
1827 return 1;
1828
1829 if (mono_test_native_thiscall (268894549, 1212675791) != 1481570339)
1830 return 2;
1831
1832 if (mono_test_native_thiscall (1288082683, -421187449, -1733670329) != -866775098)
1833 return 3;
1834
1835 if (mono_test_native_thiscall (new TinyStruct(1968329802)) != 1968329802)
1836 return 4;
1837
1838 if (mono_test_native_thiscall (new TinyStruct(268894549), 1212675791) != 1481570339)
1839 return 5;
1840
1841 if (mono_test_native_thiscall (new TinyStruct(1288082683), -421187449, -1733670329) != -866775098)
1842 return 6;
1843
1844 return 0;
1845 }
1846
1847 [DllImport ("libtest", EntryPoint = "mono_test_marshal_return_single_double_struct")]
1848 public static extern SingleDoubleStruct mono_test_marshal_return_single_double_struct ();
1849
1850 public static int test_0_x86_single_double_struct_ret () {
1851 double d = mono_test_marshal_return_single_double_struct ().d;
1852 if (d != 3.0)
1853 return 1;
1854 else
1855 return 0;
1856 }
1857 }
1858
Mirror of the official Mono project git repository