mono/tests/pinvoke_ppcc.cs

   1 // pinvoke_ppcc.cs - Test cases for passing structures to and and returning
   2 //                   structures from functions.  This particular test is for
   3 //                   structures consisting wholy of 1 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_sbyte {
  21
  22         [DllImport ("libtest", EntryPoint="mono_return_sbyte1")]
  23         public static extern sbyte mono_return_sbyte1 (sbyte1 s, int addend);
  24         [StructLayout(LayoutKind.Sequential)]
  25         public struct sbyte1 {
  26                 public sbyte f1;
  27         }
  28         [DllImport ("libtest", EntryPoint="mono_return_sbyte2")]
  29         public static extern sbyte mono_return_sbyte2 (sbyte2 s, int addend);
  30         [StructLayout(LayoutKind.Sequential)]
  31         public struct sbyte2 {
  32                 public sbyte f1,f2;
  33         }
  34         [DllImport ("libtest", EntryPoint="mono_return_sbyte3")]
  35         public static extern sbyte mono_return_sbyte3 (sbyte3 s, int addend);
  36         [StructLayout(LayoutKind.Sequential)]
  37         public struct sbyte3 {
  38                 public sbyte f1,f2,f3;
  39         }
  40         [DllImport ("libtest", EntryPoint="mono_return_sbyte4")]
  41         public static extern sbyte mono_return_sbyte4 (sbyte4 s, int addend);
  42         [StructLayout(LayoutKind.Sequential)]
  43         public struct sbyte4 {
  44                 public sbyte f1,f2,f3,f4;
  45         }
  46         [DllImport ("libtest", EntryPoint="mono_return_sbyte5")]
  47         public static extern sbyte mono_return_sbyte5 (sbyte5 s, int addend);
  48         [StructLayout(LayoutKind.Sequential)]
  49         public struct sbyte5 {
  50                 public sbyte f1,f2,f3,f4,f5;
  51         }
  52         [DllImport ("libtest", EntryPoint="mono_return_sbyte6")]
  53         public static extern sbyte mono_return_sbyte6 (sbyte6 s, int addend);
  54         [StructLayout(LayoutKind.Sequential)]
  55         public struct sbyte6 {
  56                 public sbyte f1,f2,f3,f4,f5,f6;
  57         }
  58         [DllImport ("libtest", EntryPoint="mono_return_sbyte7")]
  59         public static extern sbyte mono_return_sbyte7 (sbyte7 s, int addend);
  60         [StructLayout(LayoutKind.Sequential)]
  61         public struct sbyte7 {
  62                 public sbyte f1,f2,f3,f4,f5,f6,f7;
  63         }
  64         [DllImport ("libtest", EntryPoint="mono_return_sbyte8")]
  65         public static extern sbyte mono_return_sbyte8 (sbyte8 s, int addend);
  66         [StructLayout(LayoutKind.Sequential)]
  67         public struct sbyte8 {
  68                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8;
  69         }
  70         [DllImport ("libtest", EntryPoint="mono_return_sbyte9")]
  71         public static extern sbyte mono_return_sbyte9 (sbyte9 s, int addend);
  72         [StructLayout(LayoutKind.Sequential)]
  73         public struct sbyte9 {
  74                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9;
  75         }
  76         [DllImport ("libtest", EntryPoint="mono_return_sbyte10")]
  77         public static extern sbyte mono_return_sbyte10 (sbyte10 s, int addend);
  78         [StructLayout(LayoutKind.Sequential)]
  79         public struct sbyte10 {
  80                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10;
  81         }
  82         [DllImport ("libtest", EntryPoint="mono_return_sbyte11")]
  83         public static extern sbyte mono_return_sbyte11 (sbyte11 s, int addend);
  84         [StructLayout(LayoutKind.Sequential)]
  85         public struct sbyte11 {
  86                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11;
  87         }
  88         [DllImport ("libtest", EntryPoint="mono_return_sbyte12")]
  89         public static extern sbyte mono_return_sbyte12 (sbyte12 s, int addend);
  90         [StructLayout(LayoutKind.Sequential)]
  91         public struct sbyte12 {
  92                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12;
  93         }
  94         [DllImport ("libtest", EntryPoint="mono_return_sbyte13")]
  95         public static extern sbyte mono_return_sbyte13 (sbyte13 s, int addend);
  96         [StructLayout(LayoutKind.Sequential)]
  97         public struct sbyte13 {
  98                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13;
  99         }
 100         [DllImport ("libtest", EntryPoint="mono_return_sbyte14")]
 101         public static extern sbyte mono_return_sbyte14 (sbyte14 s, int addend);
 102         [StructLayout(LayoutKind.Sequential)]
 103         public struct sbyte14 {
 104                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14;
 105         }
 106         [DllImport ("libtest", EntryPoint="mono_return_sbyte15")]
 107         public static extern sbyte mono_return_sbyte15 (sbyte15 s, int addend);
 108         [StructLayout(LayoutKind.Sequential)]
 109         public struct sbyte15 {
 110                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15;
 111         }
 112         [DllImport ("libtest", EntryPoint="mono_return_sbyte16")]
 113         public static extern sbyte mono_return_sbyte16 (sbyte16 s, int addend);
 114         [StructLayout(LayoutKind.Sequential)]
 115         public struct sbyte16 {
 116                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16;
 117         }
 118         // This structure is 1 element too large to use the special return
 119         //  rules.
 120         [DllImport ("libtest", EntryPoint="mono_return_sbyte17")]
 121         public static extern sbyte mono_return_sbyte17 (sbyte17 s, int addend);
 122         [StructLayout(LayoutKind.Sequential)]
 123         public struct sbyte17 {
 124                 public sbyte f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17;
 125         }
 126
 127         // This structure has nested structures within it but they are
 128         //  homogenous and thus should still use the special rules.
 129         public struct sbyte16_nested1 {
 130                 public sbyte f1;
 131         };
 132         public struct sbyte16_nested2 {
 133                 public sbyte f16;
 134         };
 135         [DllImport ("libtest", EntryPoint="mono_return_sbyte16_nested")]
 136         public static extern sbyte16_nested mono_return_sbyte16_nested (sbyte16_nested s, int addend);
 137         [StructLayout(LayoutKind.Sequential)]
 138         public struct sbyte16_nested {
 139                 public sbyte16_nested1 nested1;
 140                 public sbyte f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15;
 141                 public sbyte16_nested2 nested2;
 142         }
 143
 144         public static int Main (string[] args) {
 145
 146                 sbyte1 s1;
 147                 s1.f1 = 1;
 148                 sbyte retval1 = mono_return_sbyte1(s1, 9);
 149                 if (retval1 != 2*9) {
 150                         Console.WriteLine("   sbyte1 retval1: got {0} but expected {1}", retval1, 2*9);
 151                         return 1;
 152                 }
 153
 154                 sbyte2 s2;
 155                 s2.f1 = 1;
 156                 s2.f2 = 2;
 157                 sbyte retval2 = mono_return_sbyte2(s2, 9);
 158                 if (retval2 != 2*9) {
 159                         Console.WriteLine("   sbyte2 retval2: got {0} but expected {1}", retval2, 2*9);
 160                         return 1;
 161                 }
 162
 163                 sbyte3 s3;
 164                 s3.f1 = 1;
 165                 s3.f2 = 2;
 166                 s3.f3 = 3;
 167                 sbyte retval3 = mono_return_sbyte3(s3, 9);
 168                 if (retval3 != 2*9) {
 169                         Console.WriteLine("   sbyte3 retval3: got {0} but expected {1}", retval3, 2*9);
 170                         return 1;
 171                 }
 172
 173                 sbyte4 s4;
 174                 s4.f1 = 1;
 175                 s4.f2 = 2;
 176                 s4.f3 = 3;
 177                 s4.f4 = 4;
 178                 sbyte retval4 = mono_return_sbyte4(s4, 9);
 179                 if (retval4 != 2*9) {
 180                         Console.WriteLine("   sbyte4 retval4: got {0} but expected {1}", retval4, 2*9);
 181                         return 1;
 182                 }
 183
 184                 sbyte5 s5;
 185                 s5.f1 = 1;
 186                 s5.f2 = 2;
 187                 s5.f3 = 3;
 188                 s5.f4 = 4;
 189                 s5.f5 = 5;
 190                 sbyte retval5 = mono_return_sbyte5(s5, 9);
 191                 if (retval5 != 2*9) {
 192                         Console.WriteLine("   sbyte5 retval5: got {0} but expected {1}", retval5, 2*9);
 193                         return 1;
 194                 }
 195
 196                 sbyte6 s6;
 197                 s6.f1 = 1;
 198                 s6.f2 = 2;
 199                 s6.f3 = 3;
 200                 s6.f4 = 4;
 201                 s6.f5 = 5;
 202                 s6.f6 = 6;
 203                 sbyte retval6 = mono_return_sbyte6(s6, 9);
 204                 if (retval6 != 2*9) {
 205                         Console.WriteLine("   sbyte6 retval6: got {0} but expected {1}", retval6, 2*9);
 206                         return 1;
 207                 }
 208
 209                 sbyte7 s7;
 210                 s7.f1 = 1;
 211                 s7.f2 = 2;
 212                 s7.f3 = 3;
 213                 s7.f4 = 4;
 214                 s7.f5 = 5;
 215                 s7.f6 = 6;
 216                 s7.f7 = 7;
 217                 sbyte retval7 = mono_return_sbyte7(s7, 9);
 218                 if (retval7 != 2*9) {
 219                         Console.WriteLine("   sbyte7 retval7: got {0} but expected {1}", retval7, 2*9);
 220                         return 1;
 221                 }
 222
 223                 sbyte8 s8;
 224                 s8.f1 = 1;
 225                 s8.f2 = 2;
 226                 s8.f3 = 3;
 227                 s8.f4 = 4;
 228                 s8.f5 = 5;
 229                 s8.f6 = 6;
 230                 s8.f7 = 7;
 231                 s8.f8 = 8;
 232                 sbyte retval8 = mono_return_sbyte8(s8, 9);
 233                 if (retval8 != 2*9) {
 234                         Console.WriteLine("   sbyte8 retval8: got {0} but expected {1}", retval8, 2*9);
 235                         return 1;
 236                 }
 237
 238                 sbyte9 s9;
 239                 s9.f1 = 1;
 240                 s9.f2 = 2;
 241                 s9.f3 = 3;
 242                 s9.f4 = 4;
 243                 s9.f5 = 5;
 244                 s9.f6 = 6;
 245                 s9.f7 = 7;
 246                 s9.f8 = 8;
 247                 s9.f9 = 9;
 248                 sbyte retval9 = mono_return_sbyte9(s9, 9);
 249                 if (retval9 != 2*9) {
 250                         Console.WriteLine("   sbyte9 retval9: got {0} but expected {1}", retval9, 2*9);
 251                         return 1;
 252                 }
 253
 254                 sbyte10 s10;
 255                 s10.f1 = 1;
 256                 s10.f2 = 2;
 257                 s10.f3 = 3;
 258                 s10.f4 = 4;
 259                 s10.f5 = 5;
 260                 s10.f6 = 6;
 261                 s10.f7 = 7;
 262                 s10.f8 = 8;
 263                 s10.f9 = 9;
 264                 s10.f10 = 10;
 265                 sbyte retval10 = mono_return_sbyte10(s10, 9);
 266                 if (retval10 != 2*9) {
 267                         Console.WriteLine("   sbyte10 retval10: got {0} but expected {1}", retval10, 2*9);
 268                         return 1;
 269                 }
 270
 271                 sbyte11 s11;
 272                 s11.f1 = 1;
 273                 s11.f2 = 2;
 274                 s11.f3 = 3;
 275                 s11.f4 = 4;
 276                 s11.f5 = 5;
 277                 s11.f6 = 6;
 278                 s11.f7 = 7;
 279                 s11.f8 = 8;
 280                 s11.f9 = 9;
 281                 s11.f10 = 10;
 282                 s11.f11 = 11;
 283                 sbyte retval11 = mono_return_sbyte11(s11, 9);
 284                 if (retval11 != 2*9) {
 285                         Console.WriteLine("   sbyte11 retval11: got {0} but expected {1}", retval11, 2*9);
 286                         return 1;
 287                 }
 288
 289                 sbyte12 s12;
 290                 s12.f1 = 1;
 291                 s12.f2 = 2;
 292                 s12.f3 = 3;
 293                 s12.f4 = 4;
 294                 s12.f5 = 5;
 295                 s12.f6 = 6;
 296                 s12.f7 = 7;
 297                 s12.f8 = 8;
 298                 s12.f9 = 9;
 299                 s12.f10 = 10;
 300                 s12.f11 = 11;
 301                 s12.f12 = 12;
 302                 sbyte retval12 = mono_return_sbyte12(s12, 9);
 303                 if (retval12 != 2*9) {
 304                         Console.WriteLine("   sbyte12 retval12: got {0} but expected {1}", retval12, 2*9);
 305                         return 1;
 306                 }
 307
 308                 sbyte13 s13;
 309                 s13.f1 = 1;
 310                 s13.f2 = 2;
 311                 s13.f3 = 3;
 312                 s13.f4 = 4;
 313                 s13.f5 = 5;
 314                 s13.f6 = 6;
 315                 s13.f7 = 7;
 316                 s13.f8 = 8;
 317                 s13.f9 = 9;
 318                 s13.f10 = 10;
 319                 s13.f11 = 11;
 320                 s13.f12 = 12;
 321                 s13.f13 = 13;
 322                 sbyte retval13 = mono_return_sbyte13(s13, 9);
 323                 if (retval13 != 2*9) {
 324                         Console.WriteLine("   sbyte13 retval13: got {0} but expected {1}", retval13, 2*9);
 325                         return 1;
 326                 }
 327
 328                 sbyte14 s14;
 329                 s14.f1 = 1;
 330                 s14.f2 = 2;
 331                 s14.f3 = 3;
 332                 s14.f4 = 4;
 333                 s14.f5 = 5;
 334                 s14.f6 = 6;
 335                 s14.f7 = 7;
 336                 s14.f8 = 8;
 337                 s14.f9 = 9;
 338                 s14.f10 = 10;
 339                 s14.f11 = 11;
 340                 s14.f12 = 12;
 341                 s14.f13 = 13;
 342                 s14.f14 = 14;
 343                 sbyte retval14 = mono_return_sbyte14(s14, 9);
 344                 if (retval14 != 2*9) {
 345                         Console.WriteLine("   sbyte14 retval14: got {0} but expected {1}", retval14, 2*9);
 346                         return 1;
 347                 }
 348
 349                 sbyte15 s15;
 350                 s15.f1 = 1;
 351                 s15.f2 = 2;
 352                 s15.f3 = 3;
 353                 s15.f4 = 4;
 354                 s15.f5 = 5;
 355                 s15.f6 = 6;
 356                 s15.f7 = 7;
 357                 s15.f8 = 8;
 358                 s15.f9 = 9;
 359                 s15.f10 = 10;
 360                 s15.f11 = 11;
 361                 s15.f12 = 12;
 362                 s15.f13 = 13;
 363                 s15.f14 = 14;
 364                 s15.f15 = 15;
 365                 sbyte retval15 = mono_return_sbyte15(s15, 9);
 366                 if (retval15 != 2*9) {
 367                         Console.WriteLine("   sbyte15 retval15: got {0} but expected {1}", retval15, 2*9);
 368                         return 1;
 369                 }
 370
 371                 sbyte16 s16;
 372                 s16.f1 = 1;
 373                 s16.f2 = 2;
 374                 s16.f3 = 3;
 375                 s16.f4 = 4;
 376                 s16.f5 = 5;
 377                 s16.f6 = 6;
 378                 s16.f7 = 7;
 379                 s16.f8 = 8;
 380                 s16.f9 = 9;
 381                 s16.f10 = 10;
 382                 s16.f11 = 11;
 383                 s16.f12 = 12;
 384                 s16.f13 = 13;
 385                 s16.f14 = 14;
 386                 s16.f15 = 15;
 387                 s16.f16 = 16;
 388                 sbyte retval16 = mono_return_sbyte16(s16, 9);
 389                 if (retval16 != 2*9) {
 390                         Console.WriteLine("   sbyte16 retval16: got {0} but expected {1}", retval16, 2*9);
 391                         return 1;
 392                 }
 393
 394                 sbyte17 s17;
 395                 s17.f1 = 1;
 396                 s17.f2 = 2;
 397                 s17.f3 = 3;
 398                 s17.f4 = 4;
 399                 s17.f5 = 5;
 400                 s17.f6 = 6;
 401                 s17.f7 = 7;
 402                 s17.f8 = 8;
 403                 s17.f9 = 9;
 404                 s17.f10 = 10;
 405                 s17.f11 = 11;
 406                 s17.f12 = 12;
 407                 s17.f13 = 13;
 408                 s17.f14 = 14;
 409                 s17.f15 = 15;
 410                 s17.f16 = 16;
 411                 s17.f17 = 17;
 412                 sbyte retval17 = mono_return_sbyte17(s17, 9);
 413                 if (retval17 != 2*9) {
 414                         Console.WriteLine("   sbyte17 retval17: got {0} but expected {1}", retval17, 2*9);
 415                         return 1;
 416                 }
 417
 418
 419                 return 0;
 420         } // end Main
 421 } // end class Test_sbyte
 422
 423
 424
 425
 426