From 4b4aad7217d3292650e77eec2cf4c198ea9c3b4b Mon Sep 17 00:00:00 2001 From: Jiyoung Yun Date: Wed, 23 Nov 2016 19:09:09 +0900 Subject: Imported Upstream version 1.1.0 --- .../ArrayMarshalling/BoolArray/CMakeLists.txt | 13 + .../BoolArray/MarshalBoolArrayNative.cpp | 236 +++++ .../BoolArray/MarshalBoolArrayTest.cs | 276 +++++ .../BoolArray/MarshalBoolArrayTest.csproj | 44 + .../ArrayMarshalling/ByValArray/CMakeLists.txt | 13 + .../ByValArray/MarshalArrayByValNative.cpp | 602 +++++++++++ .../ByValArray/MarshalArrayByValTest.cs | 1074 ++++++++++++++++++++ .../ByValArray/MarshalArrayByValTest.csproj | 45 + 8 files changed, 2303 insertions(+) create mode 100644 tests/src/Interop/ArrayMarshalling/BoolArray/CMakeLists.txt create mode 100644 tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayNative.cpp create mode 100644 tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayTest.cs create mode 100644 tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayTest.csproj create mode 100644 tests/src/Interop/ArrayMarshalling/ByValArray/CMakeLists.txt create mode 100644 tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValNative.cpp create mode 100644 tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.cs create mode 100644 tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.csproj (limited to 'tests/src/Interop/ArrayMarshalling') diff --git a/tests/src/Interop/ArrayMarshalling/BoolArray/CMakeLists.txt b/tests/src/Interop/ArrayMarshalling/BoolArray/CMakeLists.txt new file mode 100644 index 0000000000..da43913b33 --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/BoolArray/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required (VERSION 2.6) +project (MarshalBoolArrayNative) +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES MarshalBoolArrayNative.cpp) + +# add the executable +add_library (MarshalBoolArrayNative SHARED ${SOURCES}) +target_link_libraries(MarshalBoolArrayNative ${LINK_LIBRARIES_ADDITIONAL}) + +# add the install targets +install (TARGETS MarshalBoolArrayNative DESTINATION bin) + + diff --git a/tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayNative.cpp b/tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayNative.cpp new file mode 100644 index 0000000000..5fbfcc382f --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayNative.cpp @@ -0,0 +1,236 @@ +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +#include +#include +#include + +const int iManaged = 10; +const int iNative = 11; + +const int ArraySIZE = 5; + + +//Rule for Passing Value +// Reverse Pinvoke +//M--->N true,true,true,true,true +//N----M true,false,true,false,true + +//Reverse PInvoke +//Pass by value +typedef BOOL (__stdcall *CallBackIn)(int size,bool arr[]); +extern "C" DLL_EXPORT BOOL DoCallBackIn(CallBackIn callback) +{ + //Init + bool * arr = (bool*)CoTaskMemAlloc(ArraySIZE); + for(int i = 0;i < ArraySIZE; i++ ) + { + if( 0 == i%2) + { + arr[i] =true; + } + else + { + arr[i] = false; + } + } + + if(!callback(ArraySIZE,arr)) + { + printf("Native Side: in DoCallBackIn, The Callback return wrong value"); + return false; + } + + //Check the data + for(int i = 0;i < ArraySIZE; i++ )//Expected:true,false,true,false,true + { + if((0 == (i%2)) && !arr[i]) //expect true + { + printf("Native Side:Error in DoCallBackIn.The Item is %d\n",i+1); + CoTaskMemFree(arr); + return false; + } + else if((1 == (i%2))&&arr[i]) //expect false + { + printf("Native Side:Error in DoCallBackIn.The Item is %d\n",i+1); + CoTaskMemFree(arr); + return false; + } + } + CoTaskMemFree(arr); + return true; +} + +typedef BOOL (__stdcall *CallBackOut)(int size,bool arr[]); +extern "C" DLL_EXPORT BOOL DoCallBackOut(CallBackOut callback) +{ + bool * arr =(bool *)CoTaskMemAlloc(ArraySIZE); + + if(!callback(ArraySIZE,arr)) + { + printf("Native Side: in DoCallBackOut, The Callback return wrong value"); + return FALSE; + } + + //Check the data returnd from Managed Side + for(int i = 0;i < ArraySIZE; i++ ) + { + if(!arr[i]) //expect true + { + printf("Native Side:Error in DoCallBackOut.The Item is %d\n",i+1); + CoTaskMemFree(arr); + return false; + } + } + CoTaskMemFree(arr); + return true; +} + +typedef BOOL (__stdcall *CallBackInOut)(int size,bool arr[]); +extern "C" DLL_EXPORT BOOL DoCallBackInOut(CallBackInOut callback) +{ + //Init + bool * arr =(bool *)CoTaskMemAlloc(ArraySIZE); + for(int i = 0;i < ArraySIZE; i++ ) + { + if( 0 == i%2) + { + arr[i] = true; + } + else + { + arr[i] = false; + } + } + + if(!callback(ArraySIZE,arr)) + { + printf("Native Side: in DoCallBackInOut, The Callback return wrong value"); + + return FALSE; + } + + //Check the data + for(int i = 0;i < ArraySIZE; i++ ) + { + if(!arr[i]) //expect true + { + printf("Native Side:Error in DoCallBackInOut.The Item is %d\n",i+1); + CoTaskMemFree(arr); + return false; + } + } + CoTaskMemFree(arr); + return true; +} + + +//Reverse PInvoke +//Pass by reference +typedef BOOL (__stdcall *CallBackRefIn)(int size,bool ** arr); +extern "C" DLL_EXPORT BOOL DoCallBackRefIn(CallBackRefIn callback) +{ + //Init:true,false,true,false,true + bool *parr = (bool *)CoTaskMemAlloc(ArraySIZE); + + for(int i = 0;i < ArraySIZE;++i) + { + if( 0 == i%2) + { + parr[i] = true; + } + else + { + parr[i] = false; + } + } + + if(!callback(ArraySIZE,&parr)) // &parr + { + printf("Native Side: in DoCallBackRefIn, The Callback return wrong value"); + return FALSE; + } + + //Check the data werent changed + for(int i = 0;iN true,true,true,true,true +//N----M true,false,true,false,true +using System; +using System.Text; +using System.Security; +using System.Runtime.InteropServices; +using TestLibrary; + +public class MarshalBoolArray +{ + #region"variable" + const int SIZE = 5; + #endregion + + #region "Reverse PInvoke" + + #region "Bool Array" + [DllImport("MarshalBoolArrayNative")] + private static extern bool DoCallBackIn(CallBackIn callback); + private delegate bool CallBackIn([In]int size, [In, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1, SizeConst = SIZE)] bool[] array); + private static bool TestMethod_CallBackIn(int size, bool[] array) + { + bool retVal = true; + + //Check the Input + if (SIZE != size) + { + retVal = false; + //TestFramework.LogError("001","Failed on the Managed Side:TestMethod_CallBackIn:Parameter Size is wrong"); + } + for (int i = 0; i < SIZE; ++i) //Reverse PInvoke, true,false,true false,true + { + if ((0 == i % 2) && !array[i]) + { + retVal = false; + //TestFramework.LogError("002","Failed on the Managed Side:TestMethod_CallBackIn. The " + (i + 1) + "st Item failed"); + } + else if ((1 == i % 2) && array[i]) + { + retVal = false; + //TestFramework.LogError("003","Failed on the Managed Side:TestMethod_CallBackIn. The " + (i + 1) + "st Item failed"); + } + } + return retVal; + } + + [DllImport("MarshalBoolArrayNative")] + private static extern bool DoCallBackOut(CallBackOut callback); + private delegate bool CallBackOut([In]int size, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.U1, SizeConst = SIZE)] bool[] array); + private static bool TestMethod_CallBackOut(int size, bool[] array) + { + bool retVal = true; + //Check the Input + if (SIZE != size) + { + retVal = false; + //TestFramework.LogError("004","Failed on the Managed Side:TestMethod_CallBackOut:Parameter Size is wrong"); + } + + for (int i = 0; i < SIZE; ++i) //Reverse PInvoke, true,true,true true,true + { + array[i] = true; + } + return retVal; + } + + [DllImport("MarshalBoolArrayNative")] + private static extern bool DoCallBackInOut(CallBackInOut callback); + private delegate bool CallBackInOut([In]int size, [In, Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1, SizeConst = SIZE)] bool[] array); + + private static bool TestMethod_CallBackInOut(int size, bool[] array) + { + bool retVal = true; + //Check the Input + if (SIZE != size) + { + retVal = false; + //TestFramework.LogError("005","Failed on the Managed Side:TestMethod_CallBackInOut:Parameter Size is wrong"); + } + for (int i = 0; i < SIZE; ++i) //Reverse PInvoke, true,false,true false,true + { + if ((0 == i % 2) && !array[i]) + { + retVal = false; + TestFramework.LogError("006","Failed on the Managed Side:TestMethod_CallBackInOut. The " + (i + 1) + "st Item failed"); + } + else if ((1 == i % 2) && array[i]) + { + retVal = false; + //TestFramework.LogError("007","Failed on the Managed Side:TestMethod_CallBackInOut. The " + (i + 1) + "st Item failed"); + } + } + + //Check the output + for (int i = 0; i < size; ++i) //Reverse PInvoke, true,true,true true,true + { + array[i] = true; + } + return retVal; + } + #endregion + + #region"Bool Array Reference" + [DllImport("MarshalBoolArrayNative")] + private static extern bool DoCallBackRefIn(CallBackRefIn callback); + private delegate bool CallBackRefIn([In]int size, [In, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.U1)] ref bool[] array); + + private static bool TestMethod_CallBackRefIn(int size, ref bool[] array) + { + bool retVal = true; + //Check the Input + if (SIZE != size) + { + retVal = false; + //TestFramework.LogError("008","Failed on the Managed Side:TestMethod_CallBackRefIn:Parameter Size is wrong"); + } + //TODO: UnComment these line if the SizeConst attributes is support + //Since now the sizeconst doesnt support on ref,so only check the first item instead. + //Unhandled Exception: System.Runtime.InteropServices.MarshalDirectiveException: Cannot marshal 'parameter #2': Cannot use SizeParamIndex for ByRef array parameters. + //for (int i = 0; i < size; ++i) //Reverse PInvoke, true,false,true false,true + //{ + // if ((0 == i % 2) && !array[i]) + // { + // ReportFailure("Failed on the Managed Side:TestMethod_CallBackRefIn. The " + (i + 1) + "st Item failed", true.ToString(), false.ToString()); + // } + // else if ((1 == i % 2) && array[i]) + // { + // ReportFailure("Failed on the Managed Side:TestMethod_CallBackRefIn. The " + (i + 1) + "st Item failed", false.ToString(), true.ToString()); + // } + // } + if (!array[0]) + { + retVal = false; + //TestFramework.LogError("009","Failed on the Managed Side:TestMethod_CallBackRefIn. The first Item failed"); + } + return retVal; + } + + + + [DllImport("MarshalBoolArrayNative")] + private static extern bool DoCallBackRefOut(CallBackRefOut callback); + private delegate bool CallBackRefOut([In]int size, [Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.I1)] out bool[] array); + + private static bool TestMethod_CallBackRefOut(int size, out bool[] array) + { + bool retVal = true; + + //Check the Input + if (size != SIZE) + { + retVal = false; + //TestFramework.LogError("010","Failed on the Managed Side:TestMethod_CallBackRefOut:Parameter Size is wrong"); + } + + array = new bool[SIZE]; + for (int i = 0; i < SIZE; ++i) //Reverse PInvoke, true,true,true true,true + { + array[i] = true; + } + return retVal; + } + + [DllImport("MarshalBoolArrayNative")] + private static extern bool DoCallBackRefInOut(CallBackRefInOut callback); + private delegate bool CallBackRefInOut([In]int size, [In, Out, MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.U1)] ref bool[] array); + + private static bool TestMethod_CallBackRefInOut(int size, ref bool[] array) + { + bool retVal = true; + //Check the Input + if (SIZE != size) + { + retVal = false; + //TestFramework.LogError("011","Failed on the Managed Side:TestMethod_CallBackRefInOut:Parameter Size is wrong"); + } + //TODO: UnComment these line if the SizeConst attributes is support + //Since now the sizeconst doesnt support on ref,so only check the first item instead. + //Unhandled Exception: System.Runtime.InteropServices.MarshalDirectiveException: Cannot marshal 'parameter #2': Cannot use SizeParamIndex for ByRef array parameters. + //for (int i = 0; i < size; ++i) //Reverse PInvoke, true,false,true false,true + //{ + // if ((0 == i % 2) && !array[i]) + // { + // ReportFailure("Failed on the Managed Side:TestMethod_CallBackRefInOut. The " + (i + 1) + "st Item failed", true.ToString(), false.ToString()); + // } + // else if ((1 == i % 2) && array[i]) + // { + // ReportFailure("Failed on the Managed Side:TestMethod_CallBackRefInOut. The " + (i + 1) + "st Item failed", false.ToString(), true.ToString()); + // } + // } + if (!array[0]) + { + retVal = false; + //TestFramework.LogError("012","Failed on the Managed Side:TestMethod_CallBackRefInOut. The first Item failed"); + } + + //Output + array = new bool[SIZE]; + for (int i = 0; i < size; ++i) //Reverse PInvoke, true,true,true true,true + { + array[i] = true; + } + return retVal; + } + #endregion + + #endregion + + [System.Security.SecuritySafeCritical] + static int Main() + { + bool retVal = true; + + //TestFramework.BeginScenario("Reverse PInvoke with In attribute"); + if (!DoCallBackIn(new CallBackIn(TestMethod_CallBackIn))) + { + retVal = false; + //TestFramework.LogError("013","Error happens in Native side:DoCallBackIn"); + } + + //TestFramework.BeginScenario("Reverse PInvoke with Out attribute"); + if (!DoCallBackOut(new CallBackOut(TestMethod_CallBackOut))) + { + retVal = false; + //TestFramework.LogError("014","Error happens in Native side:DoCallBackOut"); + } + + // TestFramework.BeginScenario("Reverse PInvoke with InOut attribute"); + if (!DoCallBackInOut(new CallBackInOut(TestMethod_CallBackInOut))) + { + retVal = false; + TestFramework.LogError("015","Error happens in Native side:DoCallBackInOut"); + } + + // TestFramework.BeginScenario("Reverse PInvoke Reference In"); + if (!DoCallBackRefIn(new CallBackRefIn(TestMethod_CallBackRefIn))) + { + retVal = false; + //TestFramework.LogError("016","Error happens in Native side:DoCallBackRefIn"); + } + + // TestFramework.BeginScenario("Reverse PInvoke Reference Out"); + if (!DoCallBackRefOut(new CallBackRefOut(TestMethod_CallBackRefOut))) + { + retVal = false; + //TestFramework.LogError("017","Error happens in Native side:DoCallBackRefOut"); + } + + //TestFramework.BeginScenario("Reverse PInvoke Reference InOut"); + if (!DoCallBackRefInOut(new CallBackRefInOut(TestMethod_CallBackRefInOut))) + { + retVal = false; + //TestFramework.LogError("019","Error happens in Native side:DoCallBackRefInOut"); + } + + if(retVal) + { + //Console.WriteLine("Succeeded!"); + return 100; + } + + throw new Exception("Failed"); + // return 101; + } +} diff --git a/tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayTest.csproj b/tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayTest.csproj new file mode 100644 index 0000000000..06452f1273 --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/BoolArray/MarshalBoolArrayTest.csproj @@ -0,0 +1,44 @@ + + + + + Debug + AnyCPU + MarshalBoolArrayTest + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + Properties + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + $(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages + ..\..\ + + 7a9bfb7d + $(DefineConstants);STATIC + + + + + + + + + False + + + + + + + + + + + {c8c0dc74-fac4-45b1-81fe-70c4808366e0} + CoreCLRTestLibrary + + + + + diff --git a/tests/src/Interop/ArrayMarshalling/ByValArray/CMakeLists.txt b/tests/src/Interop/ArrayMarshalling/ByValArray/CMakeLists.txt new file mode 100644 index 0000000000..043339cd08 --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/ByValArray/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required (VERSION 2.6) +project (MarshalArrayByValNative) +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES MarshalArrayByValNative.cpp) + +# add the executable +add_library (MarshalArrayByValNative SHARED ${SOURCES}) +target_link_libraries(MarshalArrayByValNative ${LINK_LIBRARIES_ADDITIONAL}) + +# add the install targets +install (TARGETS MarshalArrayByValNative DESTINATION bin) + + diff --git a/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValNative.cpp b/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValNative.cpp new file mode 100644 index 0000000000..bf3d66d41c --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValNative.cpp @@ -0,0 +1,602 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +#include + +const int ARRAY_SIZE = 100; +template bool IsObjectEquals(T o1, T o2); + +/*---------------------------------------------------------------------------- +macro definition +----------------------------------------------------------------------------*/ + +#define ENTERFUNC() printf("========== [%s]\t ==========\n", __FUNCTION__) + +#define CHECK_PARAM_NOT_EMPTY(__p) \ + ENTERFUNC(); \ + if ( (__p) == NULL ) \ +{ \ + printf("[%s] Error: parameter actual is NULL\n", __FUNCTION__); \ + return false; \ +} \ + else + +#define INIT_EXPECTED(__type, __size) \ + __type expected[(__size)]; \ + for ( size_t i = 0; i < (__size); ++i) \ + expected[i] = (__type)i + +#define INIT_EXPECTED_STRUCT(__type, __size, __array_type) \ + __type *expected = (__type *)::CoTaskMemAlloc( sizeof(__type) ); \ + for ( size_t i = 0; i < (__size); ++i) \ + expected->arr[i] = (__array_type)i + +#define EQUALS(__actual, __cActual, __expected) Equals((__actual), (__cActual), (__expected), (int)sizeof(__expected) / sizeof(__expected[0])) + +/*---------------------------------------------------------------------------- +struct definition +----------------------------------------------------------------------------*/ + +typedef struct { INT arr[ARRAY_SIZE]; } S_INTArray; +typedef struct { UINT arr[ARRAY_SIZE]; } S_UINTArray; +typedef struct { SHORT arr[ARRAY_SIZE]; } S_SHORTArray; +typedef struct { WORD arr[ARRAY_SIZE]; } S_WORDArray; +typedef struct { LONG64 arr[ARRAY_SIZE]; } S_LONG64Array; + +typedef struct { ULONG64 arr[ARRAY_SIZE]; } S_ULONG64Array; +typedef struct { DOUBLE arr[ARRAY_SIZE]; } S_DOUBLEArray; +typedef struct { FLOAT arr[ARRAY_SIZE]; } S_FLOATArray; +typedef struct { BYTE arr[ARRAY_SIZE]; } S_BYTEArray; +typedef struct { CHAR arr[ARRAY_SIZE]; } S_CHARArray; + +typedef struct { DWORD_PTR arr[ARRAY_SIZE]; } S_DWORD_PTRArray; + +typedef struct { LPSTR arr[ARRAY_SIZE]; } S_LPSTRArray; +typedef struct { LPCSTR arr[ARRAY_SIZE]; } S_LPCSTRArray; + +//struct array in a struct +typedef struct { INT x; DOUBLE d; +LONG64 l; LPSTR str; } TestStruct; + +typedef struct { TestStruct arr[ARRAY_SIZE]; } S_StructArray; + +typedef struct { BOOL arr[ARRAY_SIZE]; } S_BOOLArray; + +/*---------------------------------------------------------------------------- +helper function +----------------------------------------------------------------------------*/ + + +LPSTR ToString(int i) +{ + CHAR *pBuffer = (CHAR *)::CoTaskMemAlloc(10 * sizeof(CHAR)); // 10 is enough for our case, WCHAR for BSTR + snprintf(pBuffer, 10, "%d", i); + return pBuffer; +} + + + +TestStruct* InitTestStruct() +{ + TestStruct *expected = (TestStruct *)CoTaskMemAlloc( sizeof(TestStruct) * ARRAY_SIZE ); + + for ( int i = 0; i < ARRAY_SIZE; i++) + { + expected[i].x = i; + expected[i].d = i; + expected[i].l = i; + expected[i].str = ToString(i); + } + + return expected; +} + +template +BOOL Equals(T *pActual, int cActual, T *pExpected, int cExpected) +{ + if ( pActual == NULL && pExpected == NULL ) + return TRUE; + else if ( cActual != cExpected ) + { + printf("WARNING: Test error - %s\n", __FUNCSIG__); + return FALSE; + } + + for ( int i = 0; i < cExpected; ++i ) + { + if ( !IsObjectEquals(pActual[i], pExpected[i]) ) + { + printf("WARNING: Test error - %s\n", __FUNCSIG__); + return FALSE; + } + } + + return TRUE; +} + +template bool IsObjectEquals(T o1, T o2) +{ + // T::operator== required. + return o1 == o2; +} + +template<> +bool IsObjectEquals(LPSTR o1, LPSTR o2) +{ + size_t cLen1 = strlen(o1); + size_t cLen2 = strlen(o2); + + if (cLen1 != cLen2 ) + { + printf("Not equals in %s\n",__FUNCTION__); + return false; + } + + return strncmp(o1, o2, cLen1) == 0; +} + +template<> +bool IsObjectEquals(LPCSTR o1, LPCSTR o2) +{ + size_t cLen1 = strlen(o1); + size_t cLen2 = strlen(o2); + + if (cLen1 != cLen2 ) + { + printf("Not equals in %s\n",__FUNCTION__); + return false; + } + + return strncmp(o1, o2, cLen1) == 0; +} + + +bool TestStructEquals(TestStruct Actual[], TestStruct Expected[]) +{ + if ( Actual == NULL && Expected == NULL ) + return true; + else if ( Actual == NULL && Expected != NULL ) + return false; + else if ( Actual != NULL && Expected == NULL ) + return false; + + for ( size_t i = 0; i < ARRAY_SIZE; ++i ) + { + if ( !(IsObjectEquals(Actual[i].x, Expected[i].x) && + IsObjectEquals(Actual[i].d, Expected[i].d) && + IsObjectEquals(Actual[i].l, Expected[i].l) && + IsObjectEquals(Actual[i].str, Expected[i].str) )) + { + printf("WARNING: Test error - %s\n", __FUNCSIG__); + return false; + } + } + + return true; +} + +/*---------------------------------------------------------------------------- + +Function + +----------------------------------------------------------------------------*/ + +/*---------------------------------------------------------------------------- +marshal sequential strut +----------------------------------------------------------------------------*/ +extern "C" DLL_EXPORT BOOL TakeIntArraySeqStructByVal( S_INTArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( INT, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeUIntArraySeqStructByVal( S_UINTArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( UINT, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeShortArraySeqStructByVal( S_SHORTArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( SHORT, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeWordArraySeqStructByVal( S_WORDArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( WORD, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeLong64ArraySeqStructByVal( S_LONG64Array s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( LONG64, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeULong64ArraySeqStructByVal( S_ULONG64Array s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( ULONG64, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeDoubleArraySeqStructByVal( S_DOUBLEArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( DOUBLE, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeFloatArraySeqStructByVal( S_FLOATArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( FLOAT, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeByteArraySeqStructByVal( S_BYTEArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( BYTE, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeCharArraySeqStructByVal( S_CHARArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + INIT_EXPECTED( CHAR, ARRAY_SIZE ); + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeIntPtrArraySeqStructByVal(S_DWORD_PTRArray s, int size) +{ + CHECK_PARAM_NOT_EMPTY(s.arr); + INIT_EXPECTED( DWORD_PTR, ARRAY_SIZE); + return Equals(s.arr, size, expected, ARRAY_SIZE); +} + +extern "C" DLL_EXPORT BOOL TakeLPSTRArraySeqStructByVal( S_LPSTRArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + + LPSTR expected[ARRAY_SIZE]; + for ( int i = 0; i < ARRAY_SIZE; ++i ) + expected[i] = ToString(i); + + return Equals( s.arr, size, expected, ARRAY_SIZE ); +} + +extern "C" DLL_EXPORT BOOL TakeLPCSTRArraySeqStructByVal( S_LPCSTRArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + + LPSTR expected[ARRAY_SIZE]; + for ( int i = 0; i < ARRAY_SIZE; ++i ) + expected[i] = ToString(i); + + return Equals( s.arr, size, (LPCSTR *)expected, ARRAY_SIZE ); +} + + + +extern "C" DLL_EXPORT BOOL TakeStructArraySeqStructByVal( S_StructArray s, int size ) +{ + CHECK_PARAM_NOT_EMPTY( s.arr ); + + TestStruct *expected = InitTestStruct(); + return TestStructEquals( s.arr,expected ); +} + +/*---------------------------------------------------------------------------- +marshal sequential class +----------------------------------------------------------------------------*/ +extern "C" DLL_EXPORT BOOL TakeIntArraySeqClassByVal( S_INTArray *s, int size ) +{ + return TakeIntArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeUIntArraySeqClassByVal( S_UINTArray *s, int size ) +{ + return TakeUIntArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeShortArraySeqClassByVal( S_SHORTArray *s, int size ) +{ + return TakeShortArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeWordArraySeqClassByVal( S_WORDArray *s, int size ) +{ + return TakeWordArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLong64ArraySeqClassByVal( S_LONG64Array *s, int size ) +{ + return TakeLong64ArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeULong64ArraySeqClassByVal( S_ULONG64Array *s, int size ) +{ + return TakeULong64ArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeDoubleArraySeqClassByVal( S_DOUBLEArray *s, int size ) +{ + return TakeDoubleArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeFloatArraySeqClassByVal( S_FLOATArray *s, int size ) +{ + return TakeFloatArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeByteArraySeqClassByVal( S_BYTEArray *s, int size ) +{ + return TakeByteArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeCharArraySeqClassByVal( S_CHARArray *s, int size ) +{ + return TakeCharArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLPSTRArraySeqClassByVal( S_LPSTRArray *s, int size ) +{ + return TakeLPSTRArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLPCSTRArraySeqClassByVal( S_LPCSTRArray *s, int size ) +{ + return TakeLPCSTRArraySeqStructByVal( *s, size ); +} + + + +extern "C" DLL_EXPORT BOOL TakeStructArraySeqClassByVal( S_StructArray *s, int size ) +{ + return TakeStructArraySeqStructByVal( *s, size ); +} + +/*---------------------------------------------------------------------------- +marshal explicit struct +----------------------------------------------------------------------------*/ +extern "C" DLL_EXPORT BOOL TakeIntArrayExpStructByVal( S_INTArray s, int size ) +{ + return TakeIntArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeUIntArrayExpStructByVal( S_UINTArray s, int size ) +{ + return TakeUIntArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeShortArrayExpStructByVal( S_SHORTArray s, int size ) +{ + return TakeShortArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeWordArrayExpStructByVal( S_WORDArray s, int size ) +{ + return TakeWordArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLong64ArrayExpStructByVal( S_LONG64Array s, int size ) +{ + return TakeLong64ArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeULong64ArrayExpStructByVal( S_ULONG64Array s, int size ) +{ + return TakeULong64ArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeDoubleArrayExpStructByVal( S_DOUBLEArray s, int size ) +{ + return TakeDoubleArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeFloatArrayExpStructByVal( S_FLOATArray s, int size ) +{ + return TakeFloatArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeByteArrayExpStructByVal( S_BYTEArray s, int size ) +{ + return TakeByteArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeCharArrayExpStructByVal( S_CHARArray s, int size ) +{ + return TakeCharArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLPSTRArrayExpStructByVal( S_LPSTRArray s, int size ) +{ + return TakeLPSTRArraySeqStructByVal( s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLPCSTRArrayExpStructByVal( S_LPCSTRArray s, int size ) +{ + return TakeLPCSTRArraySeqStructByVal( s, size ); +} + + + +extern "C" DLL_EXPORT BOOL TakeStructArrayExpStructByVal( S_StructArray s, int size ) +{ + return TakeStructArraySeqStructByVal( s, size ); +} + +/*---------------------------------------------------------------------------- +marshal explicit class +----------------------------------------------------------------------------*/ +extern "C" DLL_EXPORT BOOL TakeIntArrayExpClassByVal( S_INTArray *s, int size ) +{ + return TakeIntArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeUIntArrayExpClassByVal( S_UINTArray *s, int size ) +{ + return TakeUIntArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeShortArrayExpClassByVal( S_SHORTArray *s, int size ) +{ + return TakeShortArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeWordArrayExpClassByVal( S_WORDArray *s, int size ) +{ + return TakeWordArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLong64ArrayExpClassByVal( S_LONG64Array *s, int size ) +{ + return TakeLong64ArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeULong64ArrayExpClassByVal( S_ULONG64Array *s, int size ) +{ + return TakeULong64ArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeDoubleArrayExpClassByVal( S_DOUBLEArray *s, int size ) +{ + return TakeDoubleArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeFloatArrayExpClassByVal( S_FLOATArray *s, int size ) +{ + return TakeFloatArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeByteArrayExpClassByVal( S_BYTEArray *s, int size ) +{ + return TakeByteArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeCharArrayExpClassByVal( S_CHARArray *s, int size ) +{ + return TakeCharArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLPSTRArrayExpClassByVal( S_LPSTRArray *s, int size ) +{ + return TakeLPSTRArraySeqStructByVal( *s, size ); +} + +extern "C" DLL_EXPORT BOOL TakeLPCSTRArrayExpClassByVal( S_LPCSTRArray *s, int size ) +{ + return TakeLPCSTRArraySeqStructByVal( *s, size ); +} + + + +extern "C" DLL_EXPORT BOOL TakeStructArrayExpClassByVal( S_StructArray *s, int size ) +{ + return TakeStructArraySeqStructByVal( *s, size ); +} + +/*---------------------------------------------------------------------------- +return a struct including a C array +----------------------------------------------------------------------------*/ +extern "C" DLL_EXPORT S_INTArray* S_INTArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_INTArray, ARRAY_SIZE, INT ); + + return expected; +} + +extern "C" DLL_EXPORT S_UINTArray* S_UINTArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_UINTArray, ARRAY_SIZE, UINT ); + + return expected; +} + +extern "C" DLL_EXPORT S_SHORTArray* S_SHORTArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_SHORTArray, ARRAY_SIZE, SHORT ); + + return expected; +} + +extern "C" DLL_EXPORT S_WORDArray* S_WORDArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_WORDArray, ARRAY_SIZE, WORD ); + + return expected; +} + +extern "C" DLL_EXPORT S_LONG64Array* S_LONG64Array_Ret() +{ + INIT_EXPECTED_STRUCT( S_LONG64Array, ARRAY_SIZE, LONG64 ); + + return expected; +} + +extern "C" DLL_EXPORT S_ULONG64Array* S_ULONG64Array_Ret() +{ + INIT_EXPECTED_STRUCT( S_ULONG64Array, ARRAY_SIZE, ULONG64 ); + + return expected; +} + +extern "C" DLL_EXPORT S_DOUBLEArray* S_DOUBLEArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_DOUBLEArray, ARRAY_SIZE, DOUBLE ); + + return expected; +} + +extern "C" DLL_EXPORT S_FLOATArray* S_FLOATArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_FLOATArray, ARRAY_SIZE, FLOAT ); + + return expected; +} + +extern "C" DLL_EXPORT S_BYTEArray* S_BYTEArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_BYTEArray, ARRAY_SIZE, BYTE ); + + return expected; +} + +extern "C" DLL_EXPORT S_CHARArray* S_CHARArray_Ret() +{ + INIT_EXPECTED_STRUCT( S_CHARArray, ARRAY_SIZE, CHAR ); + + return expected; +} + +extern "C" DLL_EXPORT S_LPSTRArray* S_LPSTRArray_Ret() +{ + S_LPSTRArray *expected = (S_LPSTRArray *)::CoTaskMemAlloc( sizeof(S_LPSTRArray) ); + for ( int i = 0; i < ARRAY_SIZE; ++i ) + expected->arr[i] = ToString(i); + + return expected; +} + + +extern "C" DLL_EXPORT S_StructArray* S_StructArray_Ret() +{ + S_StructArray *expected = (S_StructArray *)::CoTaskMemAlloc( sizeof(S_StructArray) ); + for ( int i = 0; i < ARRAY_SIZE; ++i ) + { + expected->arr[i].x = i; + expected->arr[i].d = i; + expected->arr[i].l = i; + expected->arr[i].str = ToString(i); + } + + return expected; +} diff --git a/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.cs b/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.cs new file mode 100644 index 0000000000..7bad4d302e --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.cs @@ -0,0 +1,1074 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.InteropServices; + +class TestHelper +{ + public static void Assert(bool exp,string msg="") + { + CoreFXTestLibrary.Assert.IsTrue(exp, msg); + } +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_INTArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public int[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_UINTArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public uint[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_SHORTArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public short[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_WORDArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ushort[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_LONG64Array_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public long[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_ULONG64Array_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ulong[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_DOUBLEArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public double[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_FLOATArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public float[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_BYTEArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public byte[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_CHARArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public char[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_INTPTRArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public IntPtr[] arr; +} + +//struct array in a struct +[StructLayout(LayoutKind.Sequential)] +public struct TestStruct +{ + public int x; + public double d; + public long l; + public string str; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_StructArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public TestStruct[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S_BOOLArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public bool[] arr; +} + + +[StructLayout(LayoutKind.Sequential)] +public class C_INTArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public int[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_UINTArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public uint[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_SHORTArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public short[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_WORDArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ushort[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_LONG64Array_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public long[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_ULONG64Array_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ulong[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_DOUBLEArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public double[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_FLOATArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public float[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_BYTEArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public byte[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_CHARArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public char[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_LPSTRArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public string[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_LPCSTRArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public string[] arr; +} + + + +//struct array in a class +[StructLayout(LayoutKind.Sequential)] +public class C_StructArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public TestStruct[] arr; +} + +[StructLayout(LayoutKind.Sequential)] +public class C_BOOLArray_Seq +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public bool[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_INTArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public int[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_UINTArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public uint[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_SHORTArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public short[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_WORDArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ushort[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_LONG64Array_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE, ArraySubType = UnmanagedType.I8)] + public long[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_ULONG64Array_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ulong[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_DOUBLEArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public double[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_FLOATArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public float[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_BYTEArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public byte[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_CHARArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public char[] arr; +} + + +[StructLayout(LayoutKind.Explicit)] +public struct S_LPSTRArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public string[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public struct S_LPCSTRArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public string[] arr; +} + + + +//struct array in a struct +[StructLayout(LayoutKind.Explicit)] +public struct S_StructArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public TestStruct[] arr; +} + + +[StructLayout(LayoutKind.Explicit)] +public struct S_BOOLArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public bool[] arr; +} + + +[StructLayout(LayoutKind.Explicit)] +public class C_INTArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public int[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_UINTArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public uint[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_SHORTArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public short[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_WORDArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ushort[] arr; +} + +[StructLayout(LayoutKind.Explicit, Pack = 8)] +public class C_LONG64Array_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public long[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_ULONG64Array_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public ulong[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_DOUBLEArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public double[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_FLOATArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public float[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_BYTEArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public byte[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_CHARArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public char[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_LPSTRArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public string[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_LPCSTRArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public string[] arr; +} + + + +//struct array in a class +[StructLayout(LayoutKind.Explicit)] +public class C_StructArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public TestStruct[] arr; +} + +[StructLayout(LayoutKind.Explicit)] +public class C_BOOLArray_Exp +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Test.ARRAY_SIZE)] + public bool[] arr; +} + +class Test +{ + //for RunTest1 + [DllImport("MarshalArrayByValNative")] + static extern bool TakeIntArraySeqStructByVal([In]S_INTArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeUIntArraySeqStructByVal([In]S_UINTArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeShortArraySeqStructByVal([In]S_SHORTArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeWordArraySeqStructByVal([In]S_WORDArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLong64ArraySeqStructByVal([In]S_LONG64Array_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeULong64ArraySeqStructByVal([In]S_ULONG64Array_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeDoubleArraySeqStructByVal([In]S_DOUBLEArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeFloatArraySeqStructByVal([In]S_FLOATArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeByteArraySeqStructByVal([In]S_BYTEArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeCharArraySeqStructByVal([In]S_CHARArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeIntPtrArraySeqStructByVal([In]S_INTPTRArray_Seq s, int size); + + + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeStructArraySeqStructByVal([In]S_StructArray_Seq s, int size); + + + + //for RunTest2 + [DllImport("MarshalArrayByValNative")] + static extern bool TakeIntArraySeqClassByVal([In]C_INTArray_Seq c, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeUIntArraySeqClassByVal([In]C_UINTArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeShortArraySeqClassByVal([In]C_SHORTArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeWordArraySeqClassByVal([In]C_WORDArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLong64ArraySeqClassByVal([In]C_LONG64Array_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeULong64ArraySeqClassByVal([In]C_ULONG64Array_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeDoubleArraySeqClassByVal([In]C_DOUBLEArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeFloatArraySeqClassByVal([In]C_FLOATArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeByteArraySeqClassByVal([In]C_BYTEArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeCharArraySeqClassByVal([In]C_CHARArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLPSTRArraySeqClassByVal([In]C_LPSTRArray_Seq s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLPCSTRArraySeqClassByVal([In]C_LPCSTRArray_Seq s, int size); + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeStructArraySeqClassByVal([In]C_StructArray_Seq s, int size); + + + //for RunTest3 + [DllImport("MarshalArrayByValNative")] + static extern bool TakeIntArrayExpStructByVal([In]S_INTArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeUIntArrayExpStructByVal([In]S_UINTArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeShortArrayExpStructByVal([In]S_SHORTArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeWordArrayExpStructByVal([In]S_WORDArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLong64ArrayExpStructByVal([In]S_LONG64Array_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeULong64ArrayExpStructByVal([In]S_ULONG64Array_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeDoubleArrayExpStructByVal([In]S_DOUBLEArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeFloatArrayExpStructByVal([In]S_FLOATArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeByteArrayExpStructByVal([In]S_BYTEArray_Exp s, int size); + + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeCharArrayExpStructByVal([In]S_CHARArray_Exp s, int size); + + + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLPSTRArrayExpStructByVal([In]S_LPSTRArray_Exp s, int size); + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLPCSTRArrayExpStructByVal([In]S_LPCSTRArray_Exp s, int size); + + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeStructArrayExpStructByVal([In]S_StructArray_Exp s, int size); + + + + //for RunTest4 + [DllImport("MarshalArrayByValNative")] + static extern bool TakeIntArrayExpClassByVal([In]C_INTArray_Exp c, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeUIntArrayExpClassByVal([In]C_UINTArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeShortArrayExpClassByVal([In]C_SHORTArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeWordArrayExpClassByVal([In]C_WORDArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLong64ArrayExpClassByVal([In]C_LONG64Array_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeULong64ArrayExpClassByVal([In]C_ULONG64Array_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeDoubleArrayExpClassByVal([In]C_DOUBLEArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeFloatArrayExpClassByVal([In]C_FLOATArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeByteArrayExpClassByVal([In]C_BYTEArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeCharArrayExpClassByVal([In]C_CHARArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLPSTRArrayExpClassByVal([In]C_LPSTRArray_Exp s, int size); + [DllImport("MarshalArrayByValNative")] + static extern bool TakeLPCSTRArrayExpClassByVal([In]C_LPCSTRArray_Exp s, int size); + + [DllImport("MarshalArrayByValNative")] + static extern bool TakeStructArrayExpClassByVal([In]C_StructArray_Exp s, int size); + + //for RunTest5 + //get struct on C++ side as sequential class + [DllImport("MarshalArrayByValNative")] + static extern C_INTArray_Seq S_INTArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_UINTArray_Seq S_UINTArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_SHORTArray_Seq S_SHORTArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_WORDArray_Seq S_WORDArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_LONG64Array_Seq S_LONG64Array_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_ULONG64Array_Seq S_ULONG64Array_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_DOUBLEArray_Seq S_DOUBLEArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_FLOATArray_Seq S_FLOATArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_BYTEArray_Seq S_BYTEArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_CHARArray_Seq S_CHARArray_Ret(); + [DllImport("MarshalArrayByValNative")] + static extern C_LPSTRArray_Seq S_LPSTRArray_Ret(); + + [DllImport("MarshalArrayByValNative")] + static extern C_StructArray_Seq S_StructArray_Ret(); + + //for RunTest6 + //get struct on C++ side as explicit class + [DllImport("MarshalArrayByValNative", EntryPoint = "S_INTArray_Ret")] + static extern C_INTArray_Exp S_INTArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_UINTArray_Ret")] + static extern C_UINTArray_Exp S_UINTArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_SHORTArray_Ret")] + static extern C_SHORTArray_Exp S_SHORTArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_WORDArray_Ret")] + static extern C_WORDArray_Exp S_WORDArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_LONG64Array_Ret")] + static extern C_LONG64Array_Exp S_LONG64Array_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_ULONG64Array_Ret")] + static extern C_ULONG64Array_Exp S_ULONG64Array_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_DOUBLEArray_Ret")] + static extern C_DOUBLEArray_Exp S_DOUBLEArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_FLOATArray_Ret")] + static extern C_FLOATArray_Exp S_FLOATArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_BYTEArray_Ret")] + static extern C_BYTEArray_Exp S_BYTEArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_CHARArray_Ret")] + static extern C_CHARArray_Exp S_CHARArray_Ret2(); + [DllImport("MarshalArrayByValNative", EntryPoint = "S_LPSTRArray_Ret")] + static extern C_LPSTRArray_Exp S_LPSTRArray_Ret2(); + + [DllImport("MarshalArrayByValNative", EntryPoint = "S_StructArray_Ret")] + static extern C_StructArray_Exp S_StructArray_Ret2(); + + internal const int ARRAY_SIZE = 100; + + static T[] InitArray(int size) + { + T[] array = new T[size]; + + for (int i = 0; i < array.Length; i++) + array[i] = (T)Convert.ChangeType(i, typeof(T)); + + return array; + } + + static TestStruct[] InitStructArray(int size) + { + TestStruct[] array = new TestStruct[size]; + + for (int i = 0; i < array.Length; i++) + { + array[i].x = i; + array[i].d = i; + array[i].l = i; + array[i].str = i.ToString(); + } + + return array; + } + + static bool[] InitBoolArray(int size) + { + bool[] array = new bool[size]; + + for (int i = 0; i < array.Length; i++) + { + if (i % 2 == 0) + array[i] = true; + else + array[i] = false; + } + + return array; + } + + static IntPtr[] InitIntPtrArray(int size) + { + IntPtr[] array = new IntPtr[size]; + + for (int i = 0; i < array.Length; i++) + array[i] = new IntPtr(i); + + return array; + } + + static bool Equals(T[] arr1, T[] arr2) + { + if (arr1 == null && arr2 == null) + return true; + else if (arr1 == null && arr2 != null) + return false; + else if (arr1 != null && arr2 == null) + return false; + else if (arr1.Length != arr2.Length) + return false; + + for (int i = 0; i < arr2.Length; ++i) + { + if (!Object.Equals(arr1[i], arr2[i])) + { + Console.WriteLine("Array marshaling error, when type is {0}", typeof(T)); + Console.WriteLine("Expected: {0}, Actual: {1}", arr1[i], arr2[i]); + return false; + } + } + + return true; + } + + static bool TestStructEquals(TestStruct[] tsArr1, TestStruct[] tsArr2) + { + if (tsArr1 == null && tsArr2 == null) + return true; + else if (tsArr1 == null && tsArr2 != null) + return false; + else if (tsArr1 != null && tsArr2 == null) + return false; + else if (tsArr1.Length != tsArr2.Length) + return false; + + bool result = true; + for (int i = 0; i < tsArr2.Length; i++) + { + result = (tsArr1[i].x == tsArr2[i].x && + tsArr1[i].d == tsArr2[i].d && + tsArr1[i].l == tsArr2[i].l && + tsArr1[i].str == tsArr2[i].str) && result; + } + + return result; + } + + + + static bool RunTest1(string report) + { + Console.WriteLine(report); + + S_INTArray_Seq s1 = new S_INTArray_Seq(); + s1.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeIntArraySeqStructByVal(s1, s1.arr.Length), "TakeIntArraySeqStructByVal"); + + S_UINTArray_Seq s2 = new S_UINTArray_Seq(); + s2.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeUIntArraySeqStructByVal(s2, s2.arr.Length), "TakeUIntArraySeqStructByVal"); + + S_SHORTArray_Seq s3 = new S_SHORTArray_Seq(); + s3.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeShortArraySeqStructByVal(s3, s3.arr.Length), "TakeShortArraySeqStructByVal"); + + S_WORDArray_Seq s4 = new S_WORDArray_Seq(); + s4.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeWordArraySeqStructByVal(s4, s4.arr.Length), "TakeWordArraySeqStructByVal"); + + S_LONG64Array_Seq s5 = new S_LONG64Array_Seq(); + s5.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLong64ArraySeqStructByVal(s5, s5.arr.Length), "TakeLong64ArraySeqStructByVal"); + + S_ULONG64Array_Seq s6 = new S_ULONG64Array_Seq(); + s6.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeULong64ArraySeqStructByVal(s6, s6.arr.Length), "TakeULong64ArraySeqStructByVal"); + + S_DOUBLEArray_Seq s7 = new S_DOUBLEArray_Seq(); + s7.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeDoubleArraySeqStructByVal(s7, s7.arr.Length), "TakeDoubleArraySeqStructByVal"); + + S_FLOATArray_Seq s8 = new S_FLOATArray_Seq(); + s8.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeFloatArraySeqStructByVal(s8, s8.arr.Length), "TakeFloatArraySeqStructByVal"); + + S_BYTEArray_Seq s9 = new S_BYTEArray_Seq(); + s9.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeByteArraySeqStructByVal(s9, s9.arr.Length), "TakeByteArraySeqStructByVal"); + + S_CHARArray_Seq s10 = new S_CHARArray_Seq(); + s10.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeCharArraySeqStructByVal(s10, s10.arr.Length), "TakeCharArraySeqStructByVal"); + + S_INTPTRArray_Seq s11 = new S_INTPTRArray_Seq(); + s11.arr = InitIntPtrArray(ARRAY_SIZE); + TestHelper.Assert(TakeIntPtrArraySeqStructByVal(s11, s11.arr.Length), "TakeIntPtrArraySeqStructByVal"); + +#if NONWINDOWS_BUG + S_StructArray_Seq s14 = new S_StructArray_Seq(); + s14.arr = InitStructArray(ARRAY_SIZE); + TestHelper.Assert(TakeStructArraySeqStructByVal(s14, s14.arr.Length),"TakeStructArraySeqStructByVal"); +#endif + return true; + } + + static bool RunTest2(string report) + { + + C_INTArray_Seq c1 = new C_INTArray_Seq(); + c1.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeIntArraySeqClassByVal(c1, c1.arr.Length)); + + C_UINTArray_Seq c2 = new C_UINTArray_Seq(); + c2.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeUIntArraySeqClassByVal(c2, c2.arr.Length)); + + C_SHORTArray_Seq c3 = new C_SHORTArray_Seq(); + c3.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeShortArraySeqClassByVal(c3, c3.arr.Length)); + + C_WORDArray_Seq c4 = new C_WORDArray_Seq(); + c4.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeWordArraySeqClassByVal(c4, c4.arr.Length)); + + C_LONG64Array_Seq c5 = new C_LONG64Array_Seq(); + c5.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLong64ArraySeqClassByVal(c5, c5.arr.Length)); + + C_ULONG64Array_Seq c6 = new C_ULONG64Array_Seq(); + c6.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeULong64ArraySeqClassByVal(c6, c6.arr.Length)); + + C_DOUBLEArray_Seq c7 = new C_DOUBLEArray_Seq(); + c7.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeDoubleArraySeqClassByVal(c7, c7.arr.Length)); + + C_FLOATArray_Seq c8 = new C_FLOATArray_Seq(); + c8.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeFloatArraySeqClassByVal(c8, c8.arr.Length)); + + C_BYTEArray_Seq c9 = new C_BYTEArray_Seq(); + c9.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeByteArraySeqClassByVal(c9, c9.arr.Length)); + + C_CHARArray_Seq c10 = new C_CHARArray_Seq(); + c10.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeCharArraySeqClassByVal(c10, c10.arr.Length)); + + C_LPSTRArray_Seq c11 = new C_LPSTRArray_Seq(); + c11.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLPSTRArraySeqClassByVal(c11, c11.arr.Length)); + + C_LPCSTRArray_Seq c12 = new C_LPCSTRArray_Seq(); + c12.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLPCSTRArraySeqClassByVal(c12, c12.arr.Length)); + +#if NONWINDOWS_BUG + C_StructArray_Seq c14 = new C_StructArray_Seq(); + c14.arr = InitStructArray(ARRAY_SIZE); + TestHelper.Assert(TakeStructArraySeqClassByVal(c14, c14.arr.Length)); +#endif + return true; + } + + + static bool RunTest3(string report) + { + Console.WriteLine(report); + + S_INTArray_Exp s1 = new S_INTArray_Exp(); + s1.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeIntArrayExpStructByVal(s1, s1.arr.Length), "TakeIntArrayExpStructByVal"); + + S_UINTArray_Exp s2 = new S_UINTArray_Exp(); + s2.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeUIntArrayExpStructByVal(s2, s2.arr.Length), "TakeUIntArrayExpStructByVal"); + + S_SHORTArray_Exp s3 = new S_SHORTArray_Exp(); + s3.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeShortArrayExpStructByVal(s3, s3.arr.Length), "TakeShortArrayExpStructByVal"); + + S_WORDArray_Exp s4 = new S_WORDArray_Exp(); + s4.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeWordArrayExpStructByVal(s4, s4.arr.Length), "TakeWordArrayExpStructByVal"); + + S_LONG64Array_Exp s5 = new S_LONG64Array_Exp(); + s5.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLong64ArrayExpStructByVal(s5, s5.arr.Length), "TakeLong64ArrayExpStructByVal"); + + S_ULONG64Array_Exp s6 = new S_ULONG64Array_Exp(); + s6.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeULong64ArrayExpStructByVal(s6, s6.arr.Length), "TakeULong64ArrayExpStructByVal"); + + S_DOUBLEArray_Exp s7 = new S_DOUBLEArray_Exp(); + s7.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeDoubleArrayExpStructByVal(s7, s7.arr.Length), "TakeDoubleArrayExpStructByVal"); + + S_FLOATArray_Exp s8 = new S_FLOATArray_Exp(); + s8.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeFloatArrayExpStructByVal(s8, s8.arr.Length), "TakeFloatArrayExpStructByVal"); + + S_BYTEArray_Exp s9 = new S_BYTEArray_Exp(); + s9.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeByteArrayExpStructByVal(s9, s9.arr.Length), "TakeByteArrayExpStructByVal"); + + S_CHARArray_Exp s10 = new S_CHARArray_Exp(); + s10.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeCharArrayExpStructByVal(s10, s10.arr.Length), "TakeCharArrayExpStructByVal"); + + S_LPSTRArray_Exp s11 = new S_LPSTRArray_Exp(); + s11.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLPSTRArrayExpStructByVal(s11, s11.arr.Length)); + + S_LPCSTRArray_Exp s12 = new S_LPCSTRArray_Exp(); + s12.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLPCSTRArrayExpStructByVal(s12, s12.arr.Length)); + +#if NONWINDOWS_BUG + S_StructArray_Exp s14 = new S_StructArray_Exp(); + s14.arr = InitStructArray(ARRAY_SIZE); + TestHelper.Assert(TakeStructArrayExpStructByVal(s14, s14.arr.Length)); +#endif + + return true; + } + + + static bool RunTest4(string report) + { + Console.WriteLine(report); + + C_INTArray_Exp c1 = new C_INTArray_Exp(); + c1.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeIntArrayExpClassByVal(c1, c1.arr.Length)); + + C_UINTArray_Exp c2 = new C_UINTArray_Exp(); + c2.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeUIntArrayExpClassByVal(c2, c2.arr.Length)); + + C_SHORTArray_Exp c3 = new C_SHORTArray_Exp(); + c3.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeShortArrayExpClassByVal(c3, c3.arr.Length)); + + C_WORDArray_Exp c4 = new C_WORDArray_Exp(); + c4.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeWordArrayExpClassByVal(c4, c4.arr.Length)); + + C_LONG64Array_Exp c5 = new C_LONG64Array_Exp(); + c5.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLong64ArrayExpClassByVal(c5, c5.arr.Length)); + + C_ULONG64Array_Exp c6 = new C_ULONG64Array_Exp(); + c6.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeULong64ArrayExpClassByVal(c6, c6.arr.Length)); + + C_DOUBLEArray_Exp c7 = new C_DOUBLEArray_Exp(); + c7.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeDoubleArrayExpClassByVal(c7, c7.arr.Length)); + + C_FLOATArray_Exp c8 = new C_FLOATArray_Exp(); + c8.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeFloatArrayExpClassByVal(c8, c8.arr.Length)); + + C_BYTEArray_Exp c9 = new C_BYTEArray_Exp(); + c9.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeByteArrayExpClassByVal(c9, c9.arr.Length)); + + C_CHARArray_Exp c10 = new C_CHARArray_Exp(); + c10.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeCharArrayExpClassByVal(c10, c10.arr.Length)); + + C_LPSTRArray_Exp c11 = new C_LPSTRArray_Exp(); + c11.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLPSTRArrayExpClassByVal(c11, c11.arr.Length)); + + C_LPCSTRArray_Exp c12 = new C_LPCSTRArray_Exp(); + c12.arr = InitArray(ARRAY_SIZE); + TestHelper.Assert(TakeLPCSTRArrayExpClassByVal(c12, c12.arr.Length)); + +#if NONWINDOWS_BUG + C_StructArray_Exp c14 = new C_StructArray_Exp(); + c14.arr = InitStructArray(ARRAY_SIZE); + TestHelper.Assert(TakeStructArrayExpClassByVal(c14, c14.arr.Length)); +#endif + return true; + } + + static bool RunTest5(string report) + { + + C_INTArray_Seq retval1 = S_INTArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval1.arr)); + + C_UINTArray_Seq retval2 = S_UINTArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval2.arr)); + + C_SHORTArray_Seq retval3 = S_SHORTArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval3.arr)); + + C_WORDArray_Seq retval4 = S_WORDArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval4.arr)); + + C_LONG64Array_Seq retval5 = S_LONG64Array_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval5.arr)); + + C_ULONG64Array_Seq retval6 = S_ULONG64Array_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval6.arr)); + + C_DOUBLEArray_Seq retval7 = S_DOUBLEArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval7.arr)); + + C_FLOATArray_Seq retval8 = S_FLOATArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval8.arr)); + + C_BYTEArray_Seq retval9 = S_BYTEArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval9.arr)); + + C_CHARArray_Seq retval10 = S_CHARArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval10.arr)); + + C_LPSTRArray_Seq retval11 = S_LPSTRArray_Ret(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval11.arr)); + +#if NONWINDOWS_BUG + + C_StructArray_Seq retval13 = S_StructArray_Ret(); + TestHelper.Assert(TestStructEquals(InitStructArray(ARRAY_SIZE), retval13.arr)); +#endif + return true; + } + + static bool RunTest6(string report) + { + + C_INTArray_Exp retval1 = S_INTArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval1.arr)); + + C_UINTArray_Exp retval2 = S_UINTArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval2.arr)); + + C_SHORTArray_Exp retval3 = S_SHORTArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval3.arr)); + + C_WORDArray_Exp retval4 = S_WORDArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval4.arr)); + + C_LONG64Array_Exp retval5 = S_LONG64Array_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval5.arr)); + + C_ULONG64Array_Exp retval6 = S_ULONG64Array_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval6.arr)); + + C_DOUBLEArray_Exp retval7 = S_DOUBLEArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval7.arr)); + + C_FLOATArray_Exp retval8 = S_FLOATArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval8.arr)); + + C_BYTEArray_Exp retval9 = S_BYTEArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval9.arr)); + + C_CHARArray_Exp retval10 = S_CHARArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval10.arr)); + + C_LPSTRArray_Exp retval11 = S_LPSTRArray_Ret2(); + TestHelper.Assert(Equals(InitArray(ARRAY_SIZE), retval11.arr)); + +#if NONWINDOWS_BUG + C_StructArray_Exp retval13 = S_StructArray_Ret2(); + TestHelper.Assert(TestStructEquals(InitStructArray(ARRAY_SIZE), retval13.arr)); +#endif + return true; + } + + static int Main(string[] args) + { + RunTest1("RunTest1 : Marshal array as field as ByValArray in sequential struct as parameter."); + RunTest2("RunTest2 : Marshal array as field as ByValArray in sequential class as parameter."); + RunTest3("RunTest3 : Marshal array as field as ByValArray in explicit struct as parameter."); + RunTest4("RunTest4 : Marshal array as field as ByValArray in explicit class as parameter."); + RunTest5("RunTest5 : Marshal array as field as ByValArray in sequential class as return type."); + RunTest6("RunTest6 : Marshal array as field as ByValArray in explicit class as return type."); + return 100; + } +} diff --git a/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.csproj b/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.csproj new file mode 100644 index 0000000000..8584c0d1f0 --- /dev/null +++ b/tests/src/Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest.csproj @@ -0,0 +1,45 @@ + + + + + Debug + AnyCPU + MarshalArrayByValTest + 2.0 + {F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0} + Exe + Properties + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + $(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages + ..\..\ + + 7a9bfb7d + $(DefineConstants);STATIC + + + + + + + + + False + + + + + + + + + + + + {c8c0dc74-fac4-45b1-81fe-70c4808366e0} + CoreCLRTestLibrary + + + + + -- cgit v1.2.3