tests/src/Interop/PInvoke/Array/MarshalArrayAsField/AsLPArray/AsLPArrayTest.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System;
   6 using System.Runtime.InteropServices;
   7 using TestLibrary;
   8
   9 class Test
  10 {
  11     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  12     static extern bool TakeIntArraySeqStructByVal([In]S_INTArray_Seq s, [In]int size);
  13     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  14     static extern bool TakeUIntArraySeqStructByVal([In]S_UINTArray_Seq s, [In]int size);
  15     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  16     static extern bool TakeShortArraySeqStructByVal([In]S_SHORTArray_Seq s, [In]int size);
  17     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  18     static extern bool TakeWordArraySeqStructByVal([In]S_WORDArray_Seq s, [In]int size);
  19     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  20     static extern bool TakeLong64ArraySeqStructByVal([In]S_LONG64Array_Seq s, [In]int size);
  21     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  22     static extern bool TakeULong64ArraySeqStructByVal([In]S_ULONG64Array_Seq s, [In]int size);
  23     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  24     static extern bool TakeDoubleArraySeqStructByVal([In]S_DOUBLEArray_Seq s, [In]int size);
  25     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  26     static extern bool TakeFloatArraySeqStructByVal([In]S_FLOATArray_Seq s, [In]int size);
  27     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  28     static extern bool TakeByteArraySeqStructByVal([In]S_BYTEArray_Seq s, [In]int size);
  29     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  30     static extern bool TakeCharArraySeqStructByVal([In]S_CHARArray_Seq s, [In]int size);
  31     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  32     static extern bool TakeLPSTRArraySeqStructByVal([In]S_LPSTRArray_Seq s, [In]int size);
  33     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  34     static extern bool TakeLPCSTRArraySeqStructByVal([In]S_LPCSTRArray_Seq s, [In]int size);
  35     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  36     static extern bool TakeBSTRArraySeqStructByVal([In]S_BSTRArray_Seq s, [In]int size);
  37     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  38     static extern bool TakeStructArraySeqStructByVal([In]S_StructArray_Seq s, [In]int size);
  39     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  40     static extern bool TakeIntArraySeqClassByVal([In]C_INTArray_Seq c, [In]int size);
  41     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  42     static extern bool TakeUIntArraySeqClassByVal([In]C_UINTArray_Seq c, [In]int size);
  43     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  44     static extern bool TakeShortArraySeqClassByVal([In]C_SHORTArray_Seq c, [In]int size);
  45     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  46     static extern bool TakeWordArraySeqClassByVal([In]C_WORDArray_Seq c, [In]int size);
  47     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  48     static extern bool TakeLong64ArraySeqClassByVal([In]C_LONG64Array_Seq c, [In]int size);
  49     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  50     static extern bool TakeULong64ArraySeqClassByVal([In]C_ULONG64Array_Seq c, [In]int size);
  51     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  52     static extern bool TakeDoubleArraySeqClassByVal([In]C_DOUBLEArray_Seq c, [In]int size);
  53     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  54     static extern bool TakeFloatArraySeqClassByVal([In]C_FLOATArray_Seq c, [In]int size);
  55     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  56     static extern bool TakeByteArraySeqClassByVal([In]C_BYTEArray_Seq c, [In]int size);
  57     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  58     static extern bool TakeCharArraySeqClassByVal([In]C_CHARArray_Seq c, [In]int size);
  59     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  60     static extern bool TakeLPSTRArraySeqClassByVal([In]C_LPSTRArray_Seq c, [In]int size);
  61     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  62     static extern bool TakeLPCSTRArraySeqClassByVal([In]C_LPCSTRArray_Seq c, [In]int size);
  63     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  64     static extern bool TakeBSTRArraySeqClassByVal([In]C_BSTRArray_Seq c, [In]int size);
  65     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  66     static extern bool TakeStructArraySeqClassByVal([In]C_StructArray_Seq c, [In]int size);
  67
  68     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  69     static extern bool TakeIntArrayExpStructByVal([In]S_INTArray_Exp s, [In]int size);
  70     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  71     static extern bool TakeUIntArrayExpStructByVal([In]S_UINTArray_Exp s, [In]int size);
  72     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  73     static extern bool TakeShortArrayExpStructByVal([In]S_SHORTArray_Exp s, [In]int size);
  74     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  75     static extern bool TakeWordArrayExpStructByVal([In]S_WORDArray_Exp s, [In]int size);
  76     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  77     static extern bool TakeLong64ArrayExpStructByVal([In]S_LONG64Array_Exp s, [In]int size);
  78     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  79     static extern bool TakeULong64ArrayExpStructByVal([In]S_ULONG64Array_Exp s, [In]int size);
  80     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  81     static extern bool TakeDoubleArrayExpStructByVal([In]S_DOUBLEArray_Exp s, [In]int size);
  82     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  83     static extern bool TakeFloatArrayExpStructByVal([In]S_FLOATArray_Exp s, [In]int size);
  84     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  85     static extern bool TakeByteArrayExpStructByVal([In]S_BYTEArray_Exp s, [In]int size);
  86     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  87     static extern bool TakeCharArrayExpStructByVal([In]S_CHARArray_Exp s, [In]int size);
  88     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  89     static extern bool TakeLPSTRArrayExpStructByVal([In]S_LPSTRArray_Exp s, [In]int size);
  90     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  91     static extern bool TakeLPCSTRArrayExpStructByVal([In]S_LPCSTRArray_Exp s, [In]int size);
  92     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  93     static extern bool TakeBSTRArrayExpStructByVal([In]S_BSTRArray_Exp s, [In]int size);
  94     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  95     static extern bool TakeStructArrayExpStructByVal([In]S_StructArray_Exp s, [In]int size);
  96     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  97     static extern bool TakeIntArrayExpClassByVal([In]C_INTArray_Exp c, [In]int size);
  98     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
  99     static extern bool TakeUIntArrayExpClassByVal([In]C_UINTArray_Exp c, [In]int size);
 100     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 101     static extern bool TakeShortArrayExpClassByVal([In]C_SHORTArray_Exp c, [In]int size);
 102     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 103     static extern bool TakeWordArrayExpClassByVal([In]C_WORDArray_Exp c, [In]int size);
 104     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 105     static extern bool TakeLong64ArrayExpClassByVal([In]C_LONG64Array_Exp c, [In]int size);
 106     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 107     static extern bool TakeULong64ArrayExpClassByVal([In]C_ULONG64Array_Exp c, [In]int size);
 108     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 109     static extern bool TakeDoubleArrayExpClassByVal([In]C_DOUBLEArray_Exp c, [In]int size);
 110     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 111     static extern bool TakeFloatArrayExpClassByVal([In]C_FLOATArray_Exp c, [In]int size);
 112     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 113     static extern bool TakeByteArrayExpClassByVal([In]C_BYTEArray_Exp c, [In]int size);
 114     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 115     static extern bool TakeCharArrayExpClassByVal([In]C_CHARArray_Exp c, [In]int size);
 116     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 117     static extern bool TakeLPSTRArrayExpClassByVal([In]C_LPSTRArray_Exp c, [In]int size);
 118     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 119     static extern bool TakeLPCSTRArrayExpClassByVal([In]C_LPCSTRArray_Exp c, [In]int size);
 120     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 121     static extern bool TakeBSTRArrayExpClassByVal([In]C_BSTRArray_Exp c, [In]int size);
 122     [DllImport("MarshalArrayByValArrayNative", CallingConvention = CallingConvention.Cdecl)]
 123     static extern bool TakeStructArrayExpClassByVal([In]C_StructArray_Exp c, [In]int size);
 124
 125     #region Helper
 126
 127     internal const int ARRAY_SIZE = 100;
 128
 129     static T[] InitArray<T>(int size)
 130     {
 131         T[] array = new T[size];
 132
 133         for (int i = 0; i < array.Length; i++)
 134             array[i] = (T)Convert.ChangeType(i, typeof(T));
 135
 136         return array;
 137     }
 138
 139     static TestStruct[] InitStructArray(int size)
 140     {
 141         TestStruct[] array = new TestStruct[size];
 142
 143         for (int i = 0; i < array.Length; i++)
 144         {
 145             array[i].x = i;
 146             array[i].d = i;
 147             array[i].l = i;
 148             array[i].str = i.ToString();
 149         }
 150
 151         return array;
 152     }
 153
 154     static bool[] InitBoolArray(int size)
 155     {
 156         bool[] array = new bool[size];
 157
 158         for (int i = 0; i < array.Length; i++)
 159         {
 160             if (i % 2 == 0)
 161                 array[i] = true;
 162             else
 163                 array[i] = false;
 164         }
 165
 166         return array;
 167     }
 168
 169     #endregion
 170
 171     static void RunTest1(string report)
 172     {
 173         Console.WriteLine(report);
 174         S_INTArray_Seq s1 = new S_INTArray_Seq();
 175         s1.arr = InitArray<int>(ARRAY_SIZE);
 176         Assert.Throws<TypeLoadException>(() => TakeIntArraySeqStructByVal(s1, ARRAY_SIZE), "TakeIntArraySeqStructByVal");
 177
 178         S_UINTArray_Seq s2 = new S_UINTArray_Seq();
 179         s2.arr = InitArray<uint>(ARRAY_SIZE);
 180         Assert.Throws<TypeLoadException>(() => TakeUIntArraySeqStructByVal(s2, ARRAY_SIZE), "TakeUIntArraySeqStructByVal");
 181
 182         S_SHORTArray_Seq s3 = new S_SHORTArray_Seq();
 183         s3.arr = InitArray<short>(ARRAY_SIZE);
 184         Assert.Throws<TypeLoadException>(() => TakeShortArraySeqStructByVal(s3, ARRAY_SIZE), "TakeShortArraySeqStructByVal");
 185
 186         S_WORDArray_Seq s4 = new S_WORDArray_Seq();
 187         s4.arr = InitArray<ushort>(ARRAY_SIZE);
 188         Assert.Throws<TypeLoadException>(() => TakeWordArraySeqStructByVal(s4, ARRAY_SIZE), "TakeWordArraySeqStructByVal");
 189
 190         S_LONG64Array_Seq s5 = new S_LONG64Array_Seq();
 191         s5.arr = InitArray<long>(ARRAY_SIZE);
 192         Assert.Throws<TypeLoadException>(() => TakeLong64ArraySeqStructByVal(s5, ARRAY_SIZE), "TakeLong64ArraySeqStructByVal");
 193
 194         S_ULONG64Array_Seq s6 = new S_ULONG64Array_Seq();
 195         s6.arr = InitArray<ulong>(ARRAY_SIZE);
 196         Assert.Throws<TypeLoadException>(() => TakeULong64ArraySeqStructByVal(s6, ARRAY_SIZE), "TakeULong64ArraySeqStructByVal");
 197
 198         S_DOUBLEArray_Seq s7 = new S_DOUBLEArray_Seq();
 199         s7.arr = InitArray<double>(ARRAY_SIZE);
 200         Assert.Throws<TypeLoadException>(() => TakeDoubleArraySeqStructByVal(s7, ARRAY_SIZE), "TakeDoubleArraySeqStructByVal");
 201
 202         S_FLOATArray_Seq s8 = new S_FLOATArray_Seq();
 203         s8.arr = InitArray<float>(ARRAY_SIZE);
 204         Assert.Throws<TypeLoadException>(() => TakeFloatArraySeqStructByVal(s8, ARRAY_SIZE), "TakeFloatArraySeqStructByVal");
 205
 206         S_BYTEArray_Seq s9 = new S_BYTEArray_Seq();
 207         s9.arr = InitArray<byte>(ARRAY_SIZE);
 208         Assert.Throws<TypeLoadException>(() => TakeByteArraySeqStructByVal(s9, ARRAY_SIZE), "TakeByteArraySeqStructByVal");
 209
 210         S_CHARArray_Seq s10 = new S_CHARArray_Seq();
 211         s10.arr = InitArray<char>(ARRAY_SIZE);
 212         Assert.Throws<TypeLoadException>(() => TakeCharArraySeqStructByVal(s10, ARRAY_SIZE), "TakeCharArraySeqStructByVal");
 213
 214         S_LPSTRArray_Seq s11 = new S_LPSTRArray_Seq();
 215         s11.arr = InitArray<string>(ARRAY_SIZE);
 216         Assert.Throws<TypeLoadException>(() => TakeLPSTRArraySeqStructByVal(s11, ARRAY_SIZE), "TakeLPSTRArraySeqStructByVal");
 217
 218         S_LPCSTRArray_Seq s12 = new S_LPCSTRArray_Seq();
 219         s12.arr = InitArray<string>(ARRAY_SIZE);
 220         Assert.Throws<TypeLoadException>(() => TakeLPCSTRArraySeqStructByVal(s12, ARRAY_SIZE), "TakeLPCSTRArraySeqStructByVal");
 221
 222         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
 223         {
 224             S_BSTRArray_Seq s13 = new S_BSTRArray_Seq();
 225             s13.arr = InitArray<string>(ARRAY_SIZE);
 226             Assert.Throws<TypeLoadException>(() => TakeBSTRArraySeqStructByVal(s13, ARRAY_SIZE), "TakeBSTRArraySeqStructByVal");
 227         }
 228
 229         S_StructArray_Seq s14 = new S_StructArray_Seq();
 230         s14.arr = InitStructArray(ARRAY_SIZE);
 231         Assert.Throws<TypeLoadException>(() => TakeStructArraySeqStructByVal(s14, ARRAY_SIZE), "TakeStructArraySeqStructByVal");
 232     }
 233
 234     static void RunTest2(string report)
 235     {
 236         Console.WriteLine(report);
 237         C_INTArray_Seq c1 = new C_INTArray_Seq();
 238         c1.arr = InitArray<int>(ARRAY_SIZE);
 239         Assert.Throws<TypeLoadException>(() => TakeIntArraySeqClassByVal(c1, ARRAY_SIZE), "TakeIntArraySeqClassByVal");
 240
 241         C_UINTArray_Seq c2 = new C_UINTArray_Seq();
 242         c2.arr = InitArray<uint>(ARRAY_SIZE);
 243         Assert.Throws<TypeLoadException>(() => TakeUIntArraySeqClassByVal(c2, ARRAY_SIZE), "TakeUIntArraySeqClassByVal");
 244
 245         C_SHORTArray_Seq c3 = new C_SHORTArray_Seq();
 246         c3.arr = InitArray<short>(ARRAY_SIZE);
 247         Assert.Throws<TypeLoadException>(() => TakeShortArraySeqClassByVal(c3, ARRAY_SIZE), "TakeShortArraySeqClassByVal");
 248
 249         C_WORDArray_Seq c4 = new C_WORDArray_Seq();
 250         c4.arr = InitArray<ushort>(ARRAY_SIZE);
 251         Assert.Throws<TypeLoadException>(() => TakeWordArraySeqClassByVal(c4, ARRAY_SIZE), "TakeWordArraySeqClassByVal");
 252
 253         C_LONG64Array_Seq c5 = new C_LONG64Array_Seq();
 254         c5.arr = InitArray<long>(ARRAY_SIZE);
 255         Assert.Throws<TypeLoadException>(() => TakeLong64ArraySeqClassByVal(c5, ARRAY_SIZE), "TakeLong64ArraySeqClassByVal");
 256
 257         C_ULONG64Array_Seq c6 = new C_ULONG64Array_Seq();
 258         c6.arr = InitArray<ulong>(ARRAY_SIZE);
 259         Assert.Throws<TypeLoadException>(() => TakeULong64ArraySeqClassByVal(c6, ARRAY_SIZE), "TakeULong64ArraySeqClassByVal");
 260
 261         C_DOUBLEArray_Seq c7 = new C_DOUBLEArray_Seq();
 262         c7.arr = InitArray<double>(ARRAY_SIZE);
 263         Assert.Throws<TypeLoadException>(() => TakeDoubleArraySeqClassByVal(c7, ARRAY_SIZE), "TakeDoubleArraySeqClassByVal");
 264
 265         C_FLOATArray_Seq c8 = new C_FLOATArray_Seq();
 266         c8.arr = InitArray<float>(ARRAY_SIZE);
 267         Assert.Throws<TypeLoadException>(() => TakeFloatArraySeqClassByVal(c8, ARRAY_SIZE), "TakeFloatArraySeqClassByVal");
 268
 269         C_BYTEArray_Seq c9 = new C_BYTEArray_Seq();
 270         c9.arr = InitArray<byte>(ARRAY_SIZE);
 271         Assert.Throws<TypeLoadException>(() => TakeByteArraySeqClassByVal(c9, ARRAY_SIZE), "TakeByteArraySeqClassByVal");
 272
 273         C_CHARArray_Seq c10 = new C_CHARArray_Seq();
 274         c10.arr = InitArray<char>(ARRAY_SIZE);
 275         Assert.Throws<TypeLoadException>(() => TakeCharArraySeqClassByVal(c10, ARRAY_SIZE), "TakeCharArraySeqClassByVal");
 276
 277         C_LPSTRArray_Seq c11 = new C_LPSTRArray_Seq();
 278         c11.arr = InitArray<string>(ARRAY_SIZE);
 279         Assert.Throws<TypeLoadException>(() => TakeLPSTRArraySeqClassByVal(c11, ARRAY_SIZE), "TakeLPSTRArraySeqClassByVal");
 280
 281         C_LPCSTRArray_Seq c12 = new C_LPCSTRArray_Seq();
 282         c12.arr = InitArray<string>(ARRAY_SIZE);
 283         Assert.Throws<TypeLoadException>(() => TakeLPCSTRArraySeqClassByVal(c12, ARRAY_SIZE), "TakeLPCSTRArraySeqClassByVal");
 284
 285         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
 286         {
 287             C_BSTRArray_Seq c13 = new C_BSTRArray_Seq();
 288             c13.arr = InitArray<string>(ARRAY_SIZE);
 289             Assert.Throws<TypeLoadException>(() => TakeBSTRArraySeqClassByVal(c13, ARRAY_SIZE), "TakeBSTRArraySeqClassByVal");
 290         }
 291
 292         C_StructArray_Seq c14 = new C_StructArray_Seq();
 293         c14.arr = InitStructArray(ARRAY_SIZE);
 294         Assert.Throws<TypeLoadException>(() => TakeStructArraySeqClassByVal(c14, ARRAY_SIZE), "TakeStructArraySeqClassByVal");
 295     }
 296
 297     static void RunTest3(string report)
 298     {
 299         Console.WriteLine(report);
 300
 301         S_INTArray_Exp s1 = new S_INTArray_Exp();
 302         s1.arr = InitArray<int>(ARRAY_SIZE);
 303         Assert.Throws<TypeLoadException>(() => TakeIntArrayExpStructByVal(s1, ARRAY_SIZE), "TakeIntArrayExpStructByVal");
 304
 305         S_UINTArray_Exp s2 = new S_UINTArray_Exp();
 306         s2.arr = InitArray<uint>(ARRAY_SIZE);
 307         Assert.Throws<TypeLoadException>(() => TakeUIntArrayExpStructByVal(s2, ARRAY_SIZE), "TakeUIntArrayExpStructByVal");
 308
 309         S_SHORTArray_Exp s3 = new S_SHORTArray_Exp();
 310         s3.arr = InitArray<short>(ARRAY_SIZE);
 311         Assert.Throws<TypeLoadException>(() => TakeShortArrayExpStructByVal(s3, ARRAY_SIZE), "TakeShortArrayExpStructByVal");
 312
 313         S_WORDArray_Exp s4 = new S_WORDArray_Exp();
 314         s4.arr = InitArray<ushort>(ARRAY_SIZE);
 315         Assert.Throws<TypeLoadException>(() => TakeWordArrayExpStructByVal(s4, ARRAY_SIZE), "TakeWordArrayExpStructByVal");
 316
 317         S_LONG64Array_Exp s5 = new S_LONG64Array_Exp();
 318         s5.arr = InitArray<long>(ARRAY_SIZE);
 319         Assert.Throws<TypeLoadException>(() => TakeLong64ArrayExpStructByVal(s5, ARRAY_SIZE), "TakeLong64ArrayExpStructByVal");
 320
 321         S_ULONG64Array_Exp s6 = new S_ULONG64Array_Exp();
 322         s6.arr = InitArray<ulong>(ARRAY_SIZE);
 323         Assert.Throws<TypeLoadException>(() => TakeULong64ArrayExpStructByVal(s6, ARRAY_SIZE), "TakeULong64ArrayExpStructByVal");
 324
 325         S_DOUBLEArray_Exp s7 = new S_DOUBLEArray_Exp();
 326         s7.arr = InitArray<double>(ARRAY_SIZE);
 327         Assert.Throws<TypeLoadException>(() => TakeDoubleArrayExpStructByVal(s7, ARRAY_SIZE), "TakeDoubleArrayExpStructByVal");
 328
 329         S_FLOATArray_Exp s8 = new S_FLOATArray_Exp();
 330         s8.arr = InitArray<float>(ARRAY_SIZE);
 331         Assert.Throws<TypeLoadException>(() => TakeFloatArrayExpStructByVal(s8, ARRAY_SIZE), "TakeFloatArrayExpStructByVal");
 332
 333         S_BYTEArray_Exp s9 = new S_BYTEArray_Exp();
 334         s9.arr = InitArray<byte>(ARRAY_SIZE);
 335         Assert.Throws<TypeLoadException>(() => TakeByteArrayExpStructByVal(s9, ARRAY_SIZE), "TakeByteArrayExpStructByVal");
 336
 337         S_CHARArray_Exp s10 = new S_CHARArray_Exp();
 338         s10.arr = InitArray<char>(ARRAY_SIZE);
 339         Assert.Throws<TypeLoadException>(() => TakeCharArrayExpStructByVal(s10, ARRAY_SIZE), "TakeCharArrayExpStructByVal");
 340
 341         S_LPSTRArray_Exp s11 = new S_LPSTRArray_Exp();
 342         s11.arr = InitArray<string>(ARRAY_SIZE);
 343         Assert.Throws<TypeLoadException>(() => TakeLPSTRArrayExpStructByVal(s11, ARRAY_SIZE), "TakeLPSTRArrayExpStructByVal");
 344
 345         S_LPCSTRArray_Exp s12 = new S_LPCSTRArray_Exp();
 346         s12.arr = InitArray<string>(ARRAY_SIZE);
 347         Assert.Throws<TypeLoadException>(() => TakeLPCSTRArrayExpStructByVal(s12, ARRAY_SIZE), "TakeLPCSTRArrayExpStructByVal");
 348
 349         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
 350         {
 351             S_BSTRArray_Exp s13 = new S_BSTRArray_Exp();
 352             s13.arr = InitArray<string>(ARRAY_SIZE);
 353             Assert.Throws<TypeLoadException>(() => TakeBSTRArrayExpStructByVal(s13, ARRAY_SIZE), "TakeBSTRArrayExpStructByVal");
 354         }
 355
 356         S_StructArray_Exp s14 = new S_StructArray_Exp();
 357         s14.arr = InitStructArray(ARRAY_SIZE);
 358         Assert.Throws<TypeLoadException>(() => TakeStructArrayExpStructByVal(s14, ARRAY_SIZE), "TakeStructArrayExpStructByVal");
 359     }
 360
 361     static void RunTest4(string report)
 362     {
 363         Console.WriteLine(report);
 364
 365         C_INTArray_Exp c1 = new C_INTArray_Exp();
 366         c1.arr = InitArray<int>(ARRAY_SIZE);
 367         Assert.Throws<TypeLoadException>(() => TakeIntArrayExpClassByVal(c1, ARRAY_SIZE), "TakeIntArrayExpClassByVal");
 368
 369         C_UINTArray_Exp c2 = new C_UINTArray_Exp();
 370         c2.arr = InitArray<uint>(ARRAY_SIZE);
 371         Assert.Throws<TypeLoadException>(() => TakeUIntArrayExpClassByVal(c2, ARRAY_SIZE), "TakeUIntArrayExpClassByVal");
 372
 373         C_SHORTArray_Exp c3 = new C_SHORTArray_Exp();
 374         c3.arr = InitArray<short>(ARRAY_SIZE);
 375         Assert.Throws<TypeLoadException>(() => TakeShortArrayExpClassByVal(c3, ARRAY_SIZE), "TakeShortArrayExpClassByVal");
 376
 377         C_WORDArray_Exp c4 = new C_WORDArray_Exp();
 378         c4.arr = InitArray<ushort>(ARRAY_SIZE);
 379         Assert.Throws<TypeLoadException>(() => TakeWordArrayExpClassByVal(c4, ARRAY_SIZE), "TakeWordArrayExpClassByVal");
 380
 381         C_LONG64Array_Exp c5 = new C_LONG64Array_Exp();
 382         c5.arr = InitArray<long>(ARRAY_SIZE);
 383         Assert.Throws<TypeLoadException>(() => TakeLong64ArrayExpClassByVal(c5, ARRAY_SIZE), "TakeLong64ArrayExpClassByVal");
 384
 385         C_ULONG64Array_Exp c6 = new C_ULONG64Array_Exp();
 386         c6.arr = InitArray<ulong>(ARRAY_SIZE);
 387         Assert.Throws<TypeLoadException>(() => TakeULong64ArrayExpClassByVal(c6, ARRAY_SIZE), "TakeULong64ArrayExpClassByVal");
 388
 389         C_DOUBLEArray_Exp c7 = new C_DOUBLEArray_Exp();
 390         c7.arr = InitArray<double>(ARRAY_SIZE);
 391         Assert.Throws<TypeLoadException>(() => TakeDoubleArrayExpClassByVal(c7, ARRAY_SIZE), "TakeDoubleArrayExpClassByVal");
 392
 393         C_FLOATArray_Exp c8 = new C_FLOATArray_Exp();
 394         c8.arr = InitArray<float>(ARRAY_SIZE);
 395         Assert.Throws<TypeLoadException>(() => TakeFloatArrayExpClassByVal(c8, ARRAY_SIZE), "TakeFloatArrayExpClassByVal");
 396
 397         C_BYTEArray_Exp c9 = new C_BYTEArray_Exp();
 398         c9.arr = InitArray<byte>(ARRAY_SIZE);
 399         Assert.Throws<TypeLoadException>(() => TakeByteArrayExpClassByVal(c9, ARRAY_SIZE), "TakeByteArrayExpClassByVal");
 400
 401         C_CHARArray_Exp c10 = new C_CHARArray_Exp();
 402         c10.arr = InitArray<char>(ARRAY_SIZE);
 403         Assert.Throws<TypeLoadException>(() => TakeCharArrayExpClassByVal(c10, ARRAY_SIZE), "TakeCharArrayExpClassByVal");
 404
 405         C_LPSTRArray_Exp c11 = new C_LPSTRArray_Exp();
 406         c11.arr = InitArray<string>(ARRAY_SIZE);
 407         Assert.Throws<TypeLoadException>(() => TakeLPSTRArrayExpClassByVal(c11, ARRAY_SIZE), "TakeLPSTRArrayExpClassByVal");
 408
 409         C_LPCSTRArray_Exp c12 = new C_LPCSTRArray_Exp();
 410         c12.arr = InitArray<string>(ARRAY_SIZE);
 411         Assert.Throws<TypeLoadException>(() => TakeLPCSTRArrayExpClassByVal(c12, ARRAY_SIZE), "TakeLPCSTRArrayExpClassByVal");
 412
 413         if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
 414         {
 415             C_BSTRArray_Exp c13 = new C_BSTRArray_Exp();
 416             c13.arr = InitArray<string>(ARRAY_SIZE);
 417             Assert.Throws<TypeLoadException>(() => TakeBSTRArrayExpClassByVal(c13, ARRAY_SIZE), "TakeBSTRArrayExpClassByVal");
 418         }
 419
 420         C_StructArray_Exp c14 = new C_StructArray_Exp();
 421         c14.arr = InitStructArray(ARRAY_SIZE);
 422         Assert.Throws<TypeLoadException>(() => TakeStructArrayExpClassByVal(c14, ARRAY_SIZE), "TakeStructArrayExpClassByVal");
 423     }
 424
 425     static int Main(string[] args)
 426     {
 427         try
 428         {
 429             RunTest1("RunTest 1 : Marshal Array In Sequential Struct As LPArray. ");
 430             RunTest2("RunTest 2 : Marshal Array In Sequential Class As LPArray. ");
 431             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
 432             {
 433                 RunTest3("RunTest 3 : Marshal Array In Explicit Struct As LPArray. ");
 434             }
 435             RunTest4("RunTest 4 : Marshal Array In Explicit Class As LPArray. ");
 436             Console.WriteLine("\nTest PASS.");
 437             return 100;
 438         }
 439         catch (Exception e)
 440         {
 441             Console.WriteLine($"\nTest FAIL: {e}");
 442             return 101;
 443         }
 444     }
 445 }