mono/tests/pinvoke_ppcd.cs

   1 // pinvoke_ppcd.cs - Test cases for passing structures to and and returning
   2 //                   structures from functions.  This particular test is for
   3 //                   structures consisting wholy of 8 byte fields.
   4 //
   5 //                   The Power ABI version 2 allows for special parameter
   6 //                   passing and returning optimizations for certain
   7 //                   structures of homogenous composition (like all ints).
   8 //                   This set of tests checks all the possible combinations
   9 //                   that use the special parm/return rules and one beyond.
  10 //
  11 // Bill Seurer (seurer@linux.vnet.ibm.com)
  12 //
  13 // (C) {Copyright holder}
  14 //
  15
  16 using System;
  17 using System.Runtime.InteropServices;
  18
  19
  20 public class Test_double {
  21
  22         [DllImport ("libtest", EntryPoint="mono_return_double1")]
  23         public static extern double mono_return_double1 (double1 s, int addend);
  24         [StructLayout(LayoutKind.Sequential)]
  25         public struct double1 {
  26                 public double f1;
  27         }
  28         [DllImport ("libtest", EntryPoint="mono_return_double2")]
  29         public static extern double mono_return_double2 (double2 s, int addend);
  30         [StructLayout(LayoutKind.Sequential)]
  31         public struct double2 {
  32                 public double f1,f2;
  33         }
  34         // This structure is 1 element too large to use the special return
  35         //  rules.
  36         [DllImport ("libtest", EntryPoint="mono_return_double3")]
  37         public static extern double mono_return_double3 (double3 s, int addend);
  38         [StructLayout(LayoutKind.Sequential)]
  39         public struct double3 {
  40                 public double f1,f2,f3;
  41         }
  42         [DllImport ("libtest", EntryPoint="mono_return_double4")]
  43         public static extern double mono_return_double4 (double4 s, int addend);
  44         [StructLayout(LayoutKind.Sequential)]
  45         public struct double4 {
  46                 public double f1,f2,f3,f4;
  47         }
  48         [DllImport ("libtest", EntryPoint="mono_return_double5")]
  49         public static extern double mono_return_double5 (double5 s, int addend);
  50         [StructLayout(LayoutKind.Sequential)]
  51         public struct double5 {
  52                 public double f1,f2,f3,f4,f5;
  53         }
  54         [DllImport ("libtest", EntryPoint="mono_return_double6")]
  55         public static extern double mono_return_double6 (double6 s, int addend);
  56         [StructLayout(LayoutKind.Sequential)]
  57         public struct double6 {
  58                 public double f1,f2,f3,f4,f5,f6;
  59         }
  60         [DllImport ("libtest", EntryPoint="mono_return_double7")]
  61         public static extern double mono_return_double7 (double7 s, int addend);
  62         [StructLayout(LayoutKind.Sequential)]
  63         public struct double7 {
  64                 public double f1,f2,f3,f4,f5,f6,f7;
  65         }
  66         [DllImport ("libtest", EntryPoint="mono_return_double8")]
  67         public static extern double mono_return_double8 (double8 s, int addend);
  68         [StructLayout(LayoutKind.Sequential)]
  69         public struct double8 {
  70                 public double f1,f2,f3,f4,f5,f6,f7,f8;
  71         }
  72         // This structure is 1 element too large to use the special parameter
  73         //  passing rules.
  74         [DllImport ("libtest", EntryPoint="mono_return_double9")]
  75         public static extern double mono_return_double9 (double9 s, int addend);
  76         [StructLayout(LayoutKind.Sequential)]
  77         public struct double9 {
  78                 public double f1,f2,f3,f4,f5,f6,f7,f8,f9;
  79         }
  80
  81         // This structure has nested structures within it but they are
  82         //  homogenous and thus should still use the special rules.
  83         public struct double2_nested1 {
  84                 public double f1;
  85         };
  86         public struct double2_nested2 {
  87                 public double f2;
  88         };
  89         [DllImport ("libtest", EntryPoint="mono_return_double2_nested")]
  90         public static extern double2_nested mono_return_double2_nested (double2_nested s, int addend);
  91         [StructLayout(LayoutKind.Sequential)]
  92         public struct double2_nested {
  93                 public double2_nested1 nested1;
  94                 public double2_nested2 nested2;
  95         }
  96
  97         public static int Main (string[] args) {
  98
  99                 double1 s1;
 100                 s1.f1 = 1;
 101                 double retval1 = mono_return_double1(s1, 9);
 102                 if (retval1 != 2*9) {
 103                         Console.WriteLine("   double1 retval1: got {0} but expected {1}", retval1, 2*9);
 104                         return 1;
 105                 }
 106
 107                 double2 s2;
 108                 s2.f1 = 1;
 109                 s2.f2 = 2;
 110                 double retval2 = mono_return_double2(s2, 9);
 111                 if (retval2 != 2*9) {
 112                         Console.WriteLine("   double2 retval2: got {0} but expected {1}", retval2, 2*9);
 113                         return 1;
 114                 }
 115
 116                 double3 s3;
 117                 s3.f1 = 1;
 118                 s3.f2 = 2;
 119                 s3.f3 = 3;
 120                 double retval3 = mono_return_double3(s3, 9);
 121                 if (retval3 != 2*9) {
 122                         Console.WriteLine("   double3 retval3: got {0} but expected {1}", retval3, 2*9);
 123                         return 1;
 124                 }
 125
 126                 double4 s4;
 127                 s4.f1 = 1;
 128                 s4.f2 = 2;
 129                 s4.f3 = 3;
 130                 s4.f4 = 4;
 131                 double retval4 = mono_return_double4(s4, 9);
 132                 if (retval4 != 2*9) {
 133                         Console.WriteLine("   double4 retval4: got {0} but expected {1}", retval4, 2*9);
 134                         return 1;
 135                 }
 136
 137                 double5 s5;
 138                 s5.f1 = 1;
 139                 s5.f2 = 2;
 140                 s5.f3 = 3;
 141                 s5.f4 = 4;
 142                 s5.f5 = 5;
 143                 double retval5 = mono_return_double5(s5, 9);
 144                 if (retval5 != 2*9) {
 145                         Console.WriteLine("   double5 retval5: got {0} but expected {1}", retval5, 2*9);
 146                         return 1;
 147                 }
 148
 149                 double6 s6;
 150                 s6.f1 = 1;
 151                 s6.f2 = 2;
 152                 s6.f3 = 3;
 153                 s6.f4 = 4;
 154                 s6.f5 = 5;
 155                 s6.f6 = 6;
 156                 double retval6 = mono_return_double6(s6, 9);
 157                 if (retval6 != 2*9) {
 158                         Console.WriteLine("   double6 retval6: got {0} but expected {1}", retval6, 2*9);
 159                         return 1;
 160                 }
 161
 162                 double7 s7;
 163                 s7.f1 = 1;
 164                 s7.f2 = 2;
 165                 s7.f3 = 3;
 166                 s7.f4 = 4;
 167                 s7.f5 = 5;
 168                 s7.f6 = 6;
 169                 s7.f7 = 7;
 170                 double retval7 = mono_return_double7(s7, 9);
 171                 if (retval7 != 2*9) {
 172                         Console.WriteLine("   double7 retval7: got {0} but expected {1}", retval7, 2*9);
 173                         return 1;
 174                 }
 175
 176                 double8 s8;
 177                 s8.f1 = 1;
 178                 s8.f2 = 2;
 179                 s8.f3 = 3;
 180                 s8.f4 = 4;
 181                 s8.f5 = 5;
 182                 s8.f6 = 6;
 183                 s8.f7 = 7;
 184                 s8.f8 = 8;
 185                 double retval8 = mono_return_double8(s8, 9);
 186                 if (retval8 != 2*9) {
 187                         Console.WriteLine("   double8 retval8: got {0} but expected {1}", retval8, 2*9);
 188                         return 1;
 189                 }
 190
 191                 double9 s9;
 192                 s9.f1 = 1;
 193                 s9.f2 = 2;
 194                 s9.f3 = 3;
 195                 s9.f4 = 4;
 196                 s9.f5 = 5;
 197                 s9.f6 = 6;
 198                 s9.f7 = 7;
 199                 s9.f8 = 8;
 200                 s9.f9 = 9;
 201                 double retval9 = mono_return_double9(s9, 9);
 202                 if (retval9 != 2*9) {
 203                         Console.WriteLine("   double9 retval9: got {0} but expected {1}", retval9, 2*9);
 204                         return 1;
 205                 }
 206
 207
 208                 return 0;
 209         } // end Main
 210 } // end class Test_double
 211
 212
 213
 214
 215