diff options
Diffstat (limited to 'tests')
30 files changed, 8250 insertions, 2 deletions
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 813d97342c..b8faa5e787 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -64,4 +64,3 @@ MACRO(ADDSUBDIR_REC curdir) ENDMACRO() ADDSUBDIR_REC(${CMAKE_CURRENT_SOURCE_DIR}) - diff --git a/tests/src/Interop/CMakeLists.txt b/tests/src/Interop/CMakeLists.txt index c1c37d598b..af51c5e665 100644 --- a/tests/src/Interop/CMakeLists.txt +++ b/tests/src/Interop/CMakeLists.txt @@ -5,6 +5,10 @@ add_subdirectory(PrimitiveMarshalling/Bool) add_subdirectory(PrimitiveMarshalling/UIntPtr) add_subdirectory(ArrayMarshalling/BoolArray) add_subdirectory(ArrayMarshalling/ByValArray) +add_subdirectory(PrimitiveMarshalling/EnumMarshalling) +add_subdirectory(FuncPtrAsDelegateParam) +add_subdirectory(SimpleStruct) +add_subdirectory(StructMarshalling/PInvoke) add_subdirectory(BestFitMapping) add_subdirectory(RefInt) add_subdirectory(RefCharArray) diff --git a/tests/src/Interop/FuncPtrAsDelegateParam/CMakeLists.txt b/tests/src/Interop/FuncPtrAsDelegateParam/CMakeLists.txt new file mode 100644 index 0000000000..3fa62f1b84 --- /dev/null +++ b/tests/src/Interop/FuncPtrAsDelegateParam/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required (VERSION 2.6) +project (FuncPtrAsDelegateParamNative) +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES FuncPtrAsDelegateParamNative.cpp ) + +# add the executable +add_library (FuncPtrAsDelegateParamNative SHARED ${SOURCES}) + +# add the install targets +install (TARGETS FuncPtrAsDelegateParamNative DESTINATION bin)
\ No newline at end of file diff --git a/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParam.csproj b/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParam.csproj new file mode 100644 index 0000000000..f5c95fa8e1 --- /dev/null +++ b/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParam.csproj @@ -0,0 +1,49 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>FuncPtrAsDelegateParam</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid> + <OutputType>exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + <DefineConstants>$(DefineConstants);STATIC</DefineConstants> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'"> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'"> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Compile Include="*.cs" /> + <Compile Include="..\common\Assertion.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="project.json" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj"> + <Project>{c8c0dc74-fac4-45b1-81fe-70c4808366e0}</Project> + <Name>CoreCLRTestLibrary</Name> + </ProjectReference> + <ProjectReference Include="CMakeLists.txt"> + </ProjectReference> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> +</Project>
\ No newline at end of file diff --git a/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParamManaged.cs b/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParamManaged.cs Binary files differnew file mode 100644 index 0000000000..324f9a22a8 --- /dev/null +++ b/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParamManaged.cs diff --git a/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParamNative.cpp b/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParamNative.cpp new file mode 100644 index 0000000000..9c9d36dbef --- /dev/null +++ b/tests/src/Interop/FuncPtrAsDelegateParam/FuncPtrAsDelegateParamNative.cpp @@ -0,0 +1,28 @@ +#include "platformdefines.cpp" +#include <stdio.h> +#include <stdlib.h> +#include <xplatform.h> + +//Value Pass N-->M M--->N +//STDcall 200 9999 +//Cdecl -1 678 + + +int WINAPI CdeTest() +{ + return -1; +} + +typedef int (WINAPI *pFunc)(); +typedef int (WINAPI *Cdeclcaller)(pFunc); +extern "C" DLL_EXPORT BOOL WINAPI DoCallBack_Cdecl(Cdeclcaller caller) +{ + printf("DoCallBack_Cdecl\n"); + + if(678 != caller(CdeTest)) + { + printf("Error:The Return value from caller is wrong!\n"); + return FALSE; + } + return TRUE; +}
\ No newline at end of file diff --git a/tests/src/Interop/FuncPtrAsDelegateParam/project.json b/tests/src/Interop/FuncPtrAsDelegateParam/project.json new file mode 100644 index 0000000000..d0bba5fe35 --- /dev/null +++ b/tests/src/Interop/FuncPtrAsDelegateParam/project.json @@ -0,0 +1,35 @@ +{ + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1-rc2-23816", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.1-rc2-23816", + "System.Collections.Specialized": "4.0.1-rc2-23816", + "System.ComponentModel": "4.0.1-rc2-23816", + "System.Console": "4.0.0-rc2-23816", + "System.Diagnostics.Process": "4.1.0-rc2-23816", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Linq": "4.0.1-rc2-23816", + "System.Linq.Queryable": "4.0.1-rc2-23816", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.1.0-rc2-23816", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.1.0-rc2-23816", + "System.Runtime.Loader": "4.0.0-rc2-23816", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Thread": "4.0.0-rc2-23816", + "System.Xml.ReaderWriter": "4.0.11-rc2-23816", + "System.Xml.XDocument": "4.0.11-rc2-23816", + "System.Xml.XmlDocument": "4.0.1-rc2-23816", + "System.Xml.XmlSerializer": "4.0.11-rc2-23816" + }, + "frameworks": { + "dnxcore50": {} + } +}
\ No newline at end of file diff --git a/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/CMakeLists.txt b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/CMakeLists.txt new file mode 100644 index 0000000000..42eaff6394 --- /dev/null +++ b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/CMakeLists.txt @@ -0,0 +1,9 @@ +cmake_minimum_required (VERSION 2.6) +project (MarshalEnumNative) +set(SOURCES MarshalEnumNative.cpp ) + +# add the executable +add_library (MarshalEnumNative SHARED ${SOURCES}) + +# add the install targets +install (TARGETS MarshalEnumNative DESTINATION bin)
\ No newline at end of file diff --git a/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/EnumTest.csproj b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/EnumTest.csproj new file mode 100644 index 0000000000..8ee089f064 --- /dev/null +++ b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/EnumTest.csproj @@ -0,0 +1,49 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>EnumTest</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid> + <OutputType>exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + <DefineConstants>$(DefineConstants);STATIC</DefineConstants> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'"> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'"> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Compile Include="*.cs" /> + <Compile Include="..\..\common\Assertion.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="project.json" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj"> + <Project>{c8c0dc74-fac4-45b1-81fe-70c4808366e0}</Project> + <Name>CoreCLRTestLibrary</Name> + </ProjectReference> + <ProjectReference Include="CMakeLists.txt"> + </ProjectReference> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> +</Project>
\ No newline at end of file diff --git a/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/MarshalEnumManaged.cs b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/MarshalEnumManaged.cs new file mode 100644 index 0000000000..23c497aa2f --- /dev/null +++ b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/MarshalEnumManaged.cs @@ -0,0 +1,69 @@ +using System; +using System.Collections.Generic; +using System.Text; +using TestLibrary; +using System.Runtime.InteropServices; + +namespace EnumRoundtrip +{ + class MarshalEnumManaged + { + [Flags] + public enum DialogResult + { + None = 0x01, + OK = 0x02, + Cancel = 0x03 + } + + #region pinvoke declarations + //cdecl + + [DllImport("MarshalEnumNative", CallingConvention = CallingConvention.Cdecl)] + public static extern int CdeclEnum(DialogResult r, ref bool result); + + [DllImport("MarshalEnumNative", EntryPoint = "GetFptr")] + [return: MarshalAs(UnmanagedType.FunctionPtr)] + public static extern CdeclEnumDelegate GetFptrCdeclEnum(); + + + #endregion + + #region delegate pinvoke + //cdecl + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate int CdeclEnumDelegate(DialogResult r, ref bool result); + + #endregion + [System.Security.SecuritySafeCritical] + static int Main(string[] args) + { + bool result = true; + int r = 0; + + TestFramework.BeginScenario("\n\nTest #1 (Roundtrip of enum)."); + + TestFramework.LogInformation("Direct p/invoke cdecl calling convention"); + //direct pinvoke - cdecl + r = CdeclEnum(DialogResult.None | DialogResult.OK, ref result); + if ((!result) || (r != 3)) + { + TestFramework.LogError("02", "Main : Returned value of enum doesn't match with the value passed in to pinvoke call"); + return 101; + } + + TestFramework.LogInformation("Delegate p/invoke cdecl calling convention"); + //delegate pincoke - cdecl + CdeclEnumDelegate cdecdel = GetFptrCdeclEnum(); + r = cdecdel(DialogResult.None | DialogResult.OK, ref result); + if ((!result) || (r != 3)) + { + TestFramework.LogError("04", "Main : Returned value of enum doesn't match with the value passed in to pinvoke call"); + return 101; + } + + Console.WriteLine("PASS"); + return 100; + } + } +} diff --git a/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/MarshalEnumNative.cpp b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/MarshalEnumNative.cpp new file mode 100644 index 0000000000..c1e37ca4bf --- /dev/null +++ b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/MarshalEnumNative.cpp @@ -0,0 +1,23 @@ +#include <xplatform.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +typedef void *voidPtr; + +extern "C" DLL_EXPORT long WINAPI CdeclEnum(int r,BOOL *result) +{ + if(r != 3) + { + printf("\nThe enum value is different from expected one\n"); + *(result)= FALSE; + return 0; + } + return r; +} + + +extern "C" DLL_EXPORT voidPtr WINAPI GetFptr(int i) +{ + return (voidPtr) &CdeclEnum; +} diff --git a/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/project.json b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/project.json new file mode 100644 index 0000000000..d0bba5fe35 --- /dev/null +++ b/tests/src/Interop/PrimitiveMarshalling/EnumMarshalling/project.json @@ -0,0 +1,35 @@ +{ + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1-rc2-23816", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.1-rc2-23816", + "System.Collections.Specialized": "4.0.1-rc2-23816", + "System.ComponentModel": "4.0.1-rc2-23816", + "System.Console": "4.0.0-rc2-23816", + "System.Diagnostics.Process": "4.1.0-rc2-23816", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Linq": "4.0.1-rc2-23816", + "System.Linq.Queryable": "4.0.1-rc2-23816", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.1.0-rc2-23816", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.1.0-rc2-23816", + "System.Runtime.Loader": "4.0.0-rc2-23816", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Thread": "4.0.0-rc2-23816", + "System.Xml.ReaderWriter": "4.0.11-rc2-23816", + "System.Xml.XDocument": "4.0.11-rc2-23816", + "System.Xml.XmlDocument": "4.0.1-rc2-23816", + "System.Xml.XmlSerializer": "4.0.11-rc2-23816" + }, + "frameworks": { + "dnxcore50": {} + } +}
\ No newline at end of file diff --git a/tests/src/Interop/SimpleStruct/CMakeLists.txt b/tests/src/Interop/SimpleStruct/CMakeLists.txt new file mode 100644 index 0000000000..4f990270df --- /dev/null +++ b/tests/src/Interop/SimpleStruct/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required (VERSION 2.6) +project (SimpleStructNative) +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES SimpleStructNative.cpp ) + +# add the executable +add_library (SimpleStructNative SHARED ${SOURCES}) + +# add the install targets +install (TARGETS SimpleStructNative DESTINATION bin)
\ No newline at end of file diff --git a/tests/src/Interop/SimpleStruct/SimpleStruct.csproj b/tests/src/Interop/SimpleStruct/SimpleStruct.csproj new file mode 100644 index 0000000000..f564b645c4 --- /dev/null +++ b/tests/src/Interop/SimpleStruct/SimpleStruct.csproj @@ -0,0 +1,49 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>SimpleStruct</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid> + <OutputType>exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + <DefineConstants>$(DefineConstants);STATIC</DefineConstants> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'"> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'"> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Compile Include="*.cs" /> + <Compile Include="..\common\Assertion.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="project.json" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj"> + <Project>{c8c0dc74-fac4-45b1-81fe-70c4808366e0}</Project> + <Name>CoreCLRTestLibrary</Name> + </ProjectReference> + <ProjectReference Include="CMakeLists.txt"> + </ProjectReference> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> +</Project>
\ No newline at end of file diff --git a/tests/src/Interop/SimpleStruct/SimpleStructManaged.cs b/tests/src/Interop/SimpleStruct/SimpleStructManaged.cs new file mode 100644 index 0000000000..c815015a39 --- /dev/null +++ b/tests/src/Interop/SimpleStruct/SimpleStructManaged.cs @@ -0,0 +1,490 @@ +using System; +using System.Security; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; +using TestLibrary; + +namespace PInvokeTests +{ + #region structure def + + [SecuritySafeCritical] + [StructLayout(LayoutKind.Sequential)] + public struct Sstr + { + public int a; + public bool b; + public string str; + + public Sstr(int _a, bool _b, string _str) + { + a = _a; + b = _b; + str = String.Concat(_str, ""); + } + } + + //Using this structure for pass by value scenario + //because we don't support returning a structure + //containing a non-blittable type like string. + + [SecuritySafeCritical] + [StructLayout(LayoutKind.Sequential)] + public struct Sstr_simple + { + public int a; + public bool b; + public double c; + + public Sstr_simple(int _a, bool _b, double _c) + { + a = _a; + b = _b; + c = _c; + } + } + + [SecuritySafeCritical] + [StructLayout(LayoutKind.Explicit)] + public struct ExplStruct + { + [FieldOffset(0)] + public DialogResult type; + + [FieldOffset(8)] + public int i; + + [FieldOffset(8)] + public bool b; + + [FieldOffset(8)] + public double c; + + public ExplStruct(DialogResult t, int num) + { + type = t; + b = false; + c = num; + i = num; + } + public ExplStruct(DialogResult t, double dnum) + { + type = t; + b = false; + i = 0; + c = dnum; + } + public ExplStruct(DialogResult t, bool bnum) + { + type = t; + i = 0; + c = 0; + b = bnum; + } + } + + public enum DialogResult + { + None = 0, + OK = 1, + Cancel = 2 + } + #endregion + + class StructureTests + { + #region direct Pinvoke declarartions + + #region cdecl + //Simple struct - sequential layout by ref + [DllImport("SimpleStructNative", CallingConvention = CallingConvention.Cdecl)] + private static extern bool CdeclSimpleStructByRef(ref Sstr p); + + [DllImport("SimpleStructNative", EntryPoint = "GetFptr")] + [return: MarshalAs(UnmanagedType.FunctionPtr)] + public static extern CdeclSimpleStructByRefDelegate GetFptrCdeclSimpleStructByRef(int i); + + //Simple struct - sequential layout by value + [DllImport("SimpleStructNative", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr CdeclSimpleStruct(Sstr_simple p, ref bool retval); + + [DllImport("SimpleStructNative", EntryPoint = "GetFptr")] + [return: MarshalAs(UnmanagedType.FunctionPtr)] + public static extern CdeclSimpleStructDelegate GetFptrCdeclSimpleStruct(int i); + + //Simple struct - explicit layout by value + [DllImport("SimpleStructNative", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr CdeclSimpleExplStruct(ExplStruct p, ref bool retval); + + [DllImport("SimpleStructNative", EntryPoint = "GetFptr")] + [return: MarshalAs(UnmanagedType.FunctionPtr)] + public static extern CdeclSimpleExplStructDelegate GetFptrCdeclSimpleExplStruct(int i); + + //Simple struct - explicit layout by ref + [DllImport("SimpleStructNative", EntryPoint = "GetFptr")] + [return: MarshalAs(UnmanagedType.FunctionPtr)] + public static extern CdeclSimpleExplStructByRefDelegate GetFptrCdeclSimpleExplStructByRef(int i); + + [DllImport("SimpleStructNative", CallingConvention = CallingConvention.Cdecl)] + private static extern bool CdeclSimpleExplStructByRef(ref ExplStruct p); + + #endregion + + #endregion + + #region delegate pinvoke + //Simple struct - sequential layout by value + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate IntPtr CdeclSimpleStructDelegate(Sstr_simple p, ref bool retval); + + //Simple struct - explicit layout by value + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate IntPtr CdeclSimpleExplStructDelegate(ExplStruct p, ref bool retval); + + //Simple struct - sequential layout by ref + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate bool CdeclSimpleStructByRefDelegate(ref Sstr p); + + //Simple struct - explicit layout by ref + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public delegate bool CdeclSimpleExplStructByRefDelegate(ref ExplStruct p); + + #endregion + + #region reverse pinvoke + + #endregion + + #region public methods related to pinvoke declrarations + //Simple struct - sequential layout by ref + [System.Security.SecuritySafeCritical] + public static bool DoCdeclSimpleStructByRef(ref Sstr p) + { + return CdeclSimpleStructByRef(ref p); + } + + //Simple struct - explicit by ref + [System.Security.SecuritySafeCritical] + public static bool DoCdeclSimpleExplStructByRef(ref ExplStruct p) + { + return CdeclSimpleExplStructByRef(ref p); + } + + //Simple struct - sequential layout by value + [System.Security.SecuritySafeCritical] + public static Sstr_simple DoCdeclSimpleStruct(Sstr_simple p, ref bool retval) + { + IntPtr st = CdeclSimpleStruct(p, ref retval); + Sstr_simple simple = (Sstr_simple)Marshal.PtrToStructure(st, typeof(Sstr_simple)); + return simple; + } + + //Simple Struct - Explicit layout by value + [System.Security.SecuritySafeCritical] + public static ExplStruct DoCdeclSimpleExplStruct(ExplStruct p, ref bool retval) + { + IntPtr st = CdeclSimpleExplStruct(p, ref retval); + ExplStruct simple = (ExplStruct)Marshal.PtrToStructure(st, typeof(ExplStruct)); + return simple; + } + + #endregion + + #region test methods + //Simple sequential struct by reference testcase + [System.Security.SecuritySafeCritical] + public static bool PosTest1() + { + string s = "before"; + string changedValue = "after"; + bool retval = true; + Sstr p = new Sstr(0, false, s); + + TestFramework.BeginScenario("Test #1 (Roundtrip of a simple structre by reference. Verify that values updated on unmanaged side reflect on managed side)"); + + //Direct pinvoke + + //cdecl calling convention. + try + { + TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention"); + retval = DoCdeclSimpleStructByRef(ref p); + + if ((p.a != 100) || (!p.b) || (!p.str.Equals(changedValue))) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->a=" + 100 + "\nSimpleStruct->b=TRUE\n" + "SimpleStruct->str=after\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->a=" + p.a + "\nSimpleStruct->b=" + p.b + "\nSimpleStruct->str=" + p.str + "\n"); + TestFramework.LogError("03", "PInvokeTests->PosTest1 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("04", "Unexpected exception: " + e.ToString()); + retval = false; + } + + //Delegate pinvoke + + //cdecl + try + { + TestFramework.LogInformation(" Case 4: Delegate p/invoke - cdecl calling convention"); + CdeclSimpleStructByRefDelegate std = GetFptrCdeclSimpleStructByRef(14); + + retval = std(ref p); + + if ((p.a != 100) || (!p.b) || (!p.str.Equals(changedValue))) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->a=" + 100 + "\nSimpleStruct->b=TRUE\n" + "SimpleStruct->str=after\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->a=" + p.a + "\nSimpleStruct->b=" + p.b + "\nSimpleStruct->str=" + p.str + "\n"); + TestFramework.LogError("01", "PInvokeTests->PosTest1 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("02", "Unexpected exception: " + e.ToString()); + retval = false; + } + + + return retval; + } + + //Simple Sequential struct by value + [System.Security.SecuritySafeCritical] + public static bool PosTest2() + { + string s = "Before"; + bool retval = true; + double d = 3.142; + Sstr p = new Sstr(100, false, s); + + TestFramework.BeginScenario("\n\nTest #2 (Roundtrip of a simple structre by value. Verify that values updated on unmanaged side reflect on managed side)"); + //direct pinvoke + + // //cdecl calling convention + try + { + TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention"); + Sstr_simple simple = new Sstr_simple(100, false, d); + simple = DoCdeclSimpleStruct(simple, ref retval); + + if (retval == false) + { + TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side."); + return false; + } + if ((simple.a != 101) || (!simple.b) || (simple.c != 10.11)) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->a=101\nSimpleStruct->b=TRUE\nSimpleStruct->c=10.11\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->a=" + simple.a + "\nSimpleStruct->b=" + simple.b + "\nSimpleStruct->c=" + simple.c + "\n"); + TestFramework.LogError("02", "PInvokeTests->PosTest2 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + + TestFramework.LogError("03", "Unexpected exception: " + e.ToString()); + retval = false; + } + + // //delegate pinvoke + + // //cdecl calling convention + try + { + TestFramework.LogInformation(" Case 4: Delegate p/invoke cdecl calling convention"); + Sstr_simple simple = new Sstr_simple(100, false, d); + CdeclSimpleStructDelegate std = GetFptrCdeclSimpleStruct(16); + + IntPtr st = std(simple, ref retval); + simple = (Sstr_simple)Marshal.PtrToStructure(st, typeof(Sstr_simple)); + + + if (retval == false) + { + TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side."); + return false; + } + if ((simple.a != 101) || (!simple.b) || (simple.c != 10.11)) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->a=101\nSimpleStruct->b=TRUE\nSimpleStruct->c=10.11\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->a=" + simple.a + "\nSimpleStruct->b=" + simple.b + "\nSimpleStruct->c=" + simple.c + "\n"); + TestFramework.LogError("02", "PInvokeTests->PosTest2 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("03", "Unexpected exception: " + e.ToString()); + retval = false; + } + return retval; + } + + //Simple struct explicit layout by reference. + [System.Security.SecuritySafeCritical] + public static bool PosTest3() + { + ExplStruct p; + bool retval = false; + + TestFramework.BeginScenario("\n\nTest #3 (Roundtrip of a simple structre (explicit layout) by reference. Verify that values updated on unmanaged side reflect on managed side)"); + //direct pinvoke + + //cdecl + try + { + p = new ExplStruct(DialogResult.None, 10); + TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention"); + retval = DoCdeclSimpleExplStructByRef(ref p); + + if (retval == false) + { + TestFramework.LogError("01", "PInvokeTests->PosTest3 : Unexpected error occured on unmanaged side"); + return false; + } + if ((p.type != DialogResult.OK) || (!p.b)) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->type=1\nSimpleStruct->b=TRUE\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->type=" + p.type + "\nSimpleStruct->b=" + p.b); + TestFramework.LogError("02", "PInvokeTests->PosTest3 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("03", "Unexpected exception: " + e.ToString()); + retval = false; + } + + //Delegate pinvoke --- cdecl + try + { + p = new ExplStruct(DialogResult.None, 10); + TestFramework.LogInformation(" Case 4: Delegate p/invoke cdecl calling convention"); + CdeclSimpleExplStructByRefDelegate std = GetFptrCdeclSimpleExplStructByRef(18); + + retval = std(ref p); + + if (retval == false) + { + TestFramework.LogError("01", "PInvokeTests->PosTest3 : Unexpected error occured on unmanaged side"); + return false; + } + if ((p.type != DialogResult.OK) || (!p.b)) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->type=1\nSimpleStruct->b=TRUE\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->type=" + p.type + "\nSimpleStruct->b=" + p.b); + TestFramework.LogError("02", "PInvokeTests->PosTest3 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("03", "Unexpected exception: " + e.ToString()); + retval = false; + } + + + return retval; + } + + //Simple struct explicit layout by value. + [System.Security.SecuritySafeCritical] + public static bool PosTest4() + { + ExplStruct p; + bool retval = false; + + TestFramework.BeginScenario("\n\nTest #4 (Roundtrip of a simple structre (Explicit layout) by value. Verify that values updated on unmanaged side reflect on managed side)"); + //direct pinvoke + + //cdecl + try + { + p = new ExplStruct(DialogResult.OK, false); + TestFramework.LogInformation(" Case 2: Direct p/invoke cdecl calling convention"); + p = DoCdeclSimpleExplStruct(p, ref retval); + if (retval == false) + { + TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side."); + return false; + } + if ((p.type != DialogResult.Cancel) || (p.c != 3.142)) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->a=2\nSimpleStruct->c=3.142\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->a=" + p.type + "\nSimpleStruct->c=" + p.c + "\n"); + TestFramework.LogError("02", "PInvokeTests->PosTest4 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("03", "Unexpected exception: " + e.ToString()); + retval = false; + } + + //delegate pinvoke + + //cdecl + try + { + p = new ExplStruct(DialogResult.OK, false); + TestFramework.LogInformation(" Case 4: Direct p/invoke cdecl calling convention"); + + CdeclSimpleExplStructDelegate std = GetFptrCdeclSimpleExplStruct(20); + + IntPtr st = std(p, ref retval); + p = (ExplStruct)Marshal.PtrToStructure(st, typeof(ExplStruct)); + + if (retval == false) + { + TestFramework.LogError("01", "PInvokeTests->PosTest2 : values of passed in structure not matched with expected once on unmanaged side."); + return false; + } + if ((p.type != DialogResult.Cancel) || (p.c != 3.142)) + { + Console.WriteLine("\nExpected values:\n SimpleStruct->a=2\nSimpleStruct->c=3.142\n"); + Console.WriteLine("\nActual values:\n SimpleStruct->a=" + p.type + "\nSimpleStruct->c=" + p.c + "\n"); + TestFramework.LogError("02", "PInvokeTests->PosTest4 : Returned values are different from expected values"); + retval = false; + } + } + catch (Exception e) + { + TestFramework.LogError("03", "Unexpected exception: " + e.ToString()); + retval = false; + } + return retval; + } + + #endregion + + public static int Main(string[] argv) + { + bool retVal = true; + + retVal = retVal && PosTest1(); + retVal = retVal && PosTest2(); + retVal = retVal && PosTest3(); + retVal = retVal && PosTest4(); + + if (!retVal) + Console.WriteLine("FAIL"); + else + Console.WriteLine("PASS"); + return (retVal ? 100 : 101); + } + + + } +} diff --git a/tests/src/Interop/SimpleStruct/SimpleStructNative.cpp b/tests/src/Interop/SimpleStruct/SimpleStructNative.cpp new file mode 100644 index 0000000000..24517b8f10 --- /dev/null +++ b/tests/src/Interop/SimpleStruct/SimpleStructNative.cpp @@ -0,0 +1,107 @@ +#include "platformdefines.h" + +#include <stdio.h> +#include <stdlib.h> +#include <xplatform.h> + +typedef void *voidPtr; + +typedef struct { int a; +bool b; +char* str;} Sstr; + +typedef struct { int a; +bool b; +double c;} Sstr_simple; + +typedef struct { + int a; + int extra; //padding needs to be added here as we have added 8 byte offset. + union + { + int i; + BOOL b; + double d; + }udata; +}ExplStruct; + +extern "C" +DLL_EXPORT BOOL WINAPI CdeclSimpleStructByRef(Sstr *p) +{ + p->a = 100; + p->b=1; + strncpy(p->str,"after",6); + return TRUE; +} + +extern "C" +DLL_EXPORT BOOL WINAPI CdeclSimpleExplStructByRef(ExplStruct *p) +{ + if((p->a != 0) || (p->udata.i != 10)) + { + printf("\np->a=%d, p->udata.i=%d\n",p->a,p->udata.i); + return FALSE; + } + p->a = 1; + p->udata.b = TRUE; + return TRUE; +} + +extern "C" +DLL_EXPORT Sstr_simple* WINAPI CdeclSimpleStruct(Sstr_simple p,BOOL *result) +{ + Sstr_simple *pSimpleStruct; + if((p.a !=100) || (p.b != FALSE) || (p.c != 3.142)) + { + *(result)= FALSE; + return NULL; + } + pSimpleStruct = (Sstr_simple*) TP_CoTaskMemAlloc(sizeof(Sstr_simple) * 1); + pSimpleStruct->a = 101; + pSimpleStruct->b = TRUE; + pSimpleStruct->c = 10.11; + *(result)= TRUE; + return pSimpleStruct; +} + +extern "C" +DLL_EXPORT ExplStruct* WINAPI CdeclSimpleExplStruct(ExplStruct p,BOOL *result) +{ + ExplStruct *pExplStruct; + if((p.a !=1) || (p.udata.b != FALSE)) + { + *(result)= FALSE; + return NULL; + } + pExplStruct = (ExplStruct*) TP_CoTaskMemAlloc(sizeof(ExplStruct) * 1); + pExplStruct->a = 2; + pExplStruct->udata.d = 3.142; + *(result)= TRUE; + return pExplStruct; +} + +extern "C" +DLL_EXPORT voidPtr WINAPI GetFptr(int i) +{ + switch(i) + { + + case 14: + return (voidPtr) &CdeclSimpleStructByRef; + break; + + case 16: + return (voidPtr) &CdeclSimpleStruct; + break; + + case 18: + return (voidPtr) &CdeclSimpleExplStructByRef; + break; + + case 20: + return (voidPtr) &CdeclSimpleExplStruct; + break; + + } + return (voidPtr) &CdeclSimpleStruct; +} diff --git a/tests/src/Interop/SimpleStruct/project.json b/tests/src/Interop/SimpleStruct/project.json new file mode 100644 index 0000000000..d0bba5fe35 --- /dev/null +++ b/tests/src/Interop/SimpleStruct/project.json @@ -0,0 +1,35 @@ +{ + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1-rc2-23816", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.1-rc2-23816", + "System.Collections.Specialized": "4.0.1-rc2-23816", + "System.ComponentModel": "4.0.1-rc2-23816", + "System.Console": "4.0.0-rc2-23816", + "System.Diagnostics.Process": "4.1.0-rc2-23816", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Linq": "4.0.1-rc2-23816", + "System.Linq.Queryable": "4.0.1-rc2-23816", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.1.0-rc2-23816", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.1.0-rc2-23816", + "System.Runtime.Loader": "4.0.0-rc2-23816", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Thread": "4.0.0-rc2-23816", + "System.Xml.ReaderWriter": "4.0.11-rc2-23816", + "System.Xml.XDocument": "4.0.11-rc2-23816", + "System.Xml.XmlDocument": "4.0.1-rc2-23816", + "System.Xml.XmlSerializer": "4.0.11-rc2-23816" + }, + "frameworks": { + "dnxcore50": {} + } +}
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/CMakeLists.txt b/tests/src/Interop/StructMarshalling/PInvoke/CMakeLists.txt new file mode 100644 index 0000000000..dc1e16f241 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required (VERSION 2.6) +project (MarshalStructAsParam) +include_directories(${INC_PLATFORM_DIR}) +set(SOURCES MarshalStructAsParamDLL.cpp) + +# add the executable +add_library (MarshalStructAsParam SHARED ${SOURCES}) + +# add the install targets +install (TARGETS MarshalStructAsParam DESTINATION bin)
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/Helper.cs b/tests/src/Interop/StructMarshalling/PInvoke/Helper.cs new file mode 100644 index 0000000000..9e8f7d7316 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/Helper.cs @@ -0,0 +1,905 @@ +using System; +using System.Runtime.InteropServices; + +public class Helper +{ + #region methods for InnerSequential struct + // Return new InnerSequential instance + public static InnerSequential NewInnerSequential(int f1, float f2, string f3) + { + InnerSequential inner_seq = new InnerSequential(); + inner_seq.f1 = f1; + inner_seq.f2 = f2; + inner_seq.f3 = f3; + return inner_seq; + } + // Prints InnerSequential + public static void PrintInnerSequential(InnerSequential inner_seq, string name) + { + Console.WriteLine("\t{0}.f1 = {1}", name, inner_seq.f1); + Console.WriteLine("\t{0}.f2 = {1}", name, inner_seq.f2); + Console.WriteLine("\t{0}.f3 = {1}", name, inner_seq.f3); + } + public static bool ValidateInnerSequential(InnerSequential s1, InnerSequential s2, string methodName) + { + if (s1.f1 != s2.f1 || s1.f2 != s2.f2 || s1.f3 != s2.f3) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintInnerSequential(s1, s1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintInnerSequential(s2, s2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + + #region methods for INNER2 struct + // Return new INNER2 instance + public static INNER2 NewINNER2(int f1, float f2, string f3) + { + INNER2 inner = new INNER2(); + inner.f1 = f1; + inner.f2 = f2; + inner.f3 = f3; + return inner; + } + // Prints INNER2 + public static void PrintINNER2(INNER2 inner, string name) + { + Console.WriteLine("\t{0}.f1 = {1}", name, inner.f1); + Console.WriteLine("\t{0}.f2 = {1}", name, inner.f2); + Console.WriteLine("\t{0}.f3 = {1}", name, inner.f3); + } + public static bool ValidateINNER2(INNER2 inner1, INNER2 inner2, string methodName) + { + if (inner1.f1 != inner2.f1 || inner1.f2 != inner2.f2 || inner1.f3 != inner2.f3) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintINNER2(inner1, inner1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintINNER2(inner2, inner2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + + #endregion + + #region methods for InnerExplicit struct + // Return new InnerExplicit instance + public static InnerExplicit NewInnerExplicit(int f1, float f2, string f3) + { + InnerExplicit inner = new InnerExplicit(); + inner.f1 = f1; + inner.f2 = f2; + inner.f3 = f3; + return inner; + } + // Prints InnerExplicit + public static void PrintInnerExplicit(InnerExplicit inner, string name) + { + Console.WriteLine("\t{0}.f1 = {1}", name, inner.f1); + Console.WriteLine("\t{0}.f2 = {1}", name, inner.f2); + Console.WriteLine("\t{0}.f3 = {1}", name, inner.f3); + } + public static bool ValidateInnerExplicit(InnerExplicit inner1, InnerExplicit inner2, string methodName) + { + if (inner1.f1 != inner2.f1 || inner1.f2 != inner2.f2 || inner1.f3 != inner2.f3) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintInnerExplicit(inner1, inner1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintInnerExplicit(inner2, inner2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + + #endregion + + #region methods for InnerArraySequential struct + // Returns new OUTER instance; the params are the fields of INNER; + // all the INNER elements have the same field values + public static InnerArraySequential NewInnerArraySequential(int f1, float f2, string f3) + { + InnerArraySequential outer = new InnerArraySequential(); + outer.arr = new InnerSequential[Common.NumArrElements]; + for (int i = 0; i < Common.NumArrElements; i++) + { + outer.arr[i].f1 = f1; + outer.arr[i].f2 = f2; + outer.arr[i].f3 = f3; + } + return outer; + } + // Prints InnerArraySequential + public static void PrintInnerArraySequential(InnerArraySequential outer, string name) + { + for (int i = 0; i < Common.NumArrElements; i++) + { + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", name, i, outer.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", name, i, outer.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", name, i, outer.arr[i].f3); + } + } + // Returns true if the two params have the same fields + public static bool ValidateInnerArraySequential(InnerArraySequential outer1, InnerArraySequential outer2, string methodName) + { + for (int i = 0; i < Common.NumArrElements; i++) + { + if (outer1.arr[i].f1 != outer2.arr[i].f1 || + outer1.arr[i].f2 != outer2.arr[i].f2 || + outer1.arr[i].f3 != outer2.arr[i].f3) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", outer1.ToString(), i, outer1.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", outer1.ToString(), i, outer1.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", outer1.ToString(), i, outer1.arr[i].f3); + Console.WriteLine("\tThe Expected is..."); + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", outer2.ToString(), i, outer2.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", outer2.ToString(), i, outer2.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", outer2.ToString(), i, outer2.arr[i].f3); + return false; + } + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for InnerArrayExplicit struct + // Returns new InnerArrayExplicit instance; the params are the fields of INNER; + // all the INNER elements have the same field values + public static InnerArrayExplicit NewInnerArrayExplicit(int f1, float f2, string f3, string f4) + { + InnerArrayExplicit outer = new InnerArrayExplicit(); + outer.arr = new InnerSequential[Common.NumArrElements]; + for (int i = 0; i < Common.NumArrElements; i++) + { + outer.arr[i].f1 = f1; + outer.arr[i].f2 = f2; + outer.arr[i].f3 = f3; + } + outer.f4 = f4; + return outer; + } + // Prints InnerArrayExplicit + public static void PrintInnerArrayExplicit(InnerArrayExplicit outer, string name) + { + for (int i = 0; i < Common.NumArrElements; i++) + { + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", name, i, outer.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", name, i, outer.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", name, i, outer.arr[i].f3); + } + Console.WriteLine("\t{0}.f4 = {1}", name, outer.f4); + } + // Returns true if the two params have the same fields + public static bool ValidateInnerArrayExplicit(InnerArrayExplicit outer1, InnerArrayExplicit InnerArrayExplicit, string methodName) + { + for (int i = 0; i < Common.NumArrElements; i++) + { + if (outer1.arr[i].f1 != InnerArrayExplicit.arr[i].f1) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual f1 field is..."); + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", outer1.ToString(), i, outer1.arr[i].f1); + Console.WriteLine("\tThe Expected f1 field is..."); + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", InnerArrayExplicit.ToString(), i, InnerArrayExplicit.arr[i].f1); + return false; + } + } + if (outer1.f4 != InnerArrayExplicit.f4) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual f4 field is..."); + Console.WriteLine("\t{0}.f4 = {1}", outer1.ToString(), outer1.f4); + Console.WriteLine("\tThe Expected f4 field is..."); + Console.WriteLine("\t{0}.f4 = {1}", InnerArrayExplicit.ToString(), InnerArrayExplicit.f4); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for OUTER3 struct + // Returns new OUTER3 instance; the params are the fields of INNER; + // all the INNER elements have the same field values + public static OUTER3 NewOUTER3(int f1, float f2, string f3, string f4) + { + OUTER3 outer = new OUTER3(); + outer.arr = new InnerSequential[Common.NumArrElements]; + for (int i = 0; i < Common.NumArrElements; i++) + { + outer.arr[i].f1 = f1; + outer.arr[i].f2 = f2; + outer.arr[i].f3 = f3; + } + outer.f4 = f4; + return outer; + } + // Prints OUTER3 + public static void PrintOUTER3(OUTER3 outer, string name) + { + for (int i = 0; i < Common.NumArrElements; i++) + { + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", name, i, outer.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", name, i, outer.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", name, i, outer.arr[i].f3); + } + Console.WriteLine("\t{0}.f4 = {1}", name, outer.f4); + } + // Returns true if the two params have the same fields + public static bool ValidateOUTER3(OUTER3 outer1, OUTER3 InnerArrayExplicit, string methodName) + { + for (int i = 0; i < Common.NumArrElements; i++) + { + if (outer1.arr[i].f1 != InnerArrayExplicit.arr[i].f1 || + outer1.arr[i].f2 != InnerArrayExplicit.arr[i].f2 || + outer1.arr[i].f3 != InnerArrayExplicit.arr[i].f3) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", outer1.ToString(), i, outer1.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", outer1.ToString(), i, outer1.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", outer1.ToString(), i, outer1.arr[i].f3); + Console.WriteLine("\tThe Expected is..."); + Console.WriteLine("\t{0}.arr[{1}].f1 = {2}", InnerArrayExplicit.ToString(), i, InnerArrayExplicit.arr[i].f1); + Console.WriteLine("\t{0}.arr[{1}].f2 = {2}", InnerArrayExplicit.ToString(), i, InnerArrayExplicit.arr[i].f2); + Console.WriteLine("\t{0}.arr[{1}].f3 = {2}", InnerArrayExplicit.ToString(), i, InnerArrayExplicit.arr[i].f3); + return false; + } + } + if (outer1.f4 != InnerArrayExplicit.f4) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual f4 field is..."); + Console.WriteLine("\t{0}.f4 = {1}", outer1.ToString(), outer1.f4); + Console.WriteLine("\tThe Expected f4 field is..."); + Console.WriteLine("\t{0}.f4 = {1}", InnerArrayExplicit.ToString(), InnerArrayExplicit.f4); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for CharSetAnsiSequential struct + //return CharSetAnsiSequential struct instance + public static CharSetAnsiSequential NewCharSetAnsiSequential(string f1, char f2) + { + CharSetAnsiSequential str1 = new CharSetAnsiSequential(); + str1.f1 = f1; + str1.f2 = f2; + return str1; + } + //print the struct CharSetAnsiSequential element + public static void PrintCharSetAnsiSequential(CharSetAnsiSequential str1, string name) + { + Console.WriteLine("\t{0}.f1 = {1}", name, str1.f1); + Console.WriteLine("\t{0}.f2 = {1}", name, str1.f2); + } + // Returns true if the two params have the same fields + public static bool ValidateCharSetAnsiSequential(CharSetAnsiSequential str1, CharSetAnsiSequential str2, string methodName) + { + if (str1.f1 != str2.f1 || str1.f2 != str2.f2) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintCharSetAnsiSequential(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintCharSetAnsiSequential(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + + #endregion + + #region methods for CharSetUnicodeSequential struct + //return the struct CharSetUnicodeSequential instance + public static CharSetUnicodeSequential NewCharSetUnicodeSequential(string f1, char f2) + { + CharSetUnicodeSequential str1 = new CharSetUnicodeSequential(); + str1.f1 = f1; + str1.f2 = f2; + return str1; + } + //print the struct CharSetUnicodeSequential element + public static void PrintCharSetUnicodeSequential(CharSetUnicodeSequential str1, string name) + { + Console.WriteLine("\t{0}.f1 = {1}", name, str1.f1); + Console.WriteLine("\t{0}.f2 = {1}", name, str1.f2); + } + // Returns true if the two params have the same fields + public static bool ValidateCharSetUnicodeSequential(CharSetUnicodeSequential str1, CharSetUnicodeSequential str2, string methodName) + { + if (str1.f1 != str2.f1 || str1.f2 != str2.f2) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintCharSetUnicodeSequential(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintCharSetUnicodeSequential(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for NumberSequential struct + public static NumberSequential NewNumberSequential(int i32, uint ui32, short s1, ushort us1, Byte b, SByte sb, + Int16 i16, UInt16 ui16, Int64 i64, UInt64 ui64, Single sgl, Double d) + { + NumberSequential str1 = new NumberSequential(); + str1.i32 = i32; + str1.ui32 = ui32; + str1.s1 = s1; + str1.us1 = us1; + str1.b = b; + str1.sb = sb; + str1.i16 = i16; + str1.ui16 = ui16; + str1.i64 = i64; + str1.ui64 = ui64; + str1.sgl = sgl; + str1.d = d; + return str1; + } + public static void PrintNumberSequential(NumberSequential str1, string name) + { + Console.WriteLine("\t{0}.i32 = {1}", name, str1.i32); + Console.WriteLine("\t{0}.ui32 = {1}", name, str1.ui32); + Console.WriteLine("\t{0}.s1 = {1}", name, str1.s1); + Console.WriteLine("\t{0}.us1 = {1}", name, str1.us1); + Console.WriteLine("\t{0}.b = {1}", name, str1.b); + Console.WriteLine("\t{0}.sb = {1}", name, str1.sb); + Console.WriteLine("\t{0}.i16 = {1}", name, str1.i16); + Console.WriteLine("\t{0}.ui16 = {1}", name, str1.ui16); + Console.WriteLine("\t{0}.i64 = {1}", name, str1.i64); + Console.WriteLine("\t{0}.ui64 = {1}", name, str1.ui64); + Console.WriteLine("\t{0}.sgl = {1}", name, str1.sgl); + Console.WriteLine("\t{0}.d = {1}", name, str1.d); + } + public static bool ValidateNumberSequential(NumberSequential str1, NumberSequential str2, string methodName) + { + if (str1.i32 != str2.i32 || str1.ui32 != str2.ui32 || str1.s1 != str2.s1 || + str1.us1 != str2.us1 || str1.b != str2.b || str1.sb != str2.sb || str1.i16 != str2.i16 || + str1.ui16 != str2.ui16 || str1.i64 != str2.i64 || str1.ui64 != str2.ui64 || + str1.sgl != str2.sgl || str1.d != str2.d) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintNumberSequential(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintNumberSequential(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for S3 struct + public static void InitialArray(int[] iarr, int[] icarr) + { + for (int i = 0; i < iarr.Length; i++) + { + iarr[i] = i; + } + + for (int i = 1; i < icarr.Length + 1; i++) + { + icarr[i - 1] = i; + } + } + + + public static S3 NewS3(bool flag, string str, int[] vals) + { + S3 str1 = new S3(); + str1.flag = flag; + str1.str = str; + str1.vals = vals; + return str1; + } + public static void PrintS3(S3 str1, string name) + { + Console.WriteLine("\t{0}.flag = {1}", name, str1.flag); + Console.WriteLine("\t{0}.flag = {1}", name, str1.str); + for (int i = 0; i < str1.vals.Length; i++) + { + Console.WriteLine("\t{0}.vals[{1}] = {2}", name, i, str1.vals[i]); + } + } + public static bool ValidateS3(S3 str1, S3 str2, string methodName) + { + int iflag = 0; + if (str1.flag != str2.flag || str1.str != str2.str) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual flag field is..."); + Console.WriteLine("\t{0}.flag = {1}", str1.ToString(), str1.flag); + Console.WriteLine("\t{0}.str = {1}", str1.ToString(), str1.str); + Console.WriteLine("\tThe Expected is..."); + Console.WriteLine("\t{0}.flag = {1}", str2.ToString(), str2.flag); + Console.WriteLine("\t{0}.str = {1}", str2.ToString(), str2.str); + return false; + } + for (int i = 0; i < 256; i++) + { + if (str1.vals[i] != str2.vals[i]) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual vals field is..."); + Console.WriteLine("\t{0}.vals[{1}] = {2}", str1.ToString(), i, str1.vals[i]); + Console.WriteLine("\tThe Expected vals field is..."); + Console.WriteLine("\t{0}.vals[{1}] = {2}", str2.ToString(), i, str2.vals[i]); + iflag++; + } + } + if (iflag != 0) + { + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for S5 struct + public static S5 NewS5(int age, string name,Enum1 ef) + { + S4 s4 = new S4(); + s4.age = age; + s4.name = name; + + S5 s5 = new S5(); + s5.s4 = s4; + s5.ef = ef; + + return s5; + } + public static void PrintS5(S5 str1, string name) + { + Console.WriteLine("\t{0}.s4.age = {1}", str1.s4.age); + Console.WriteLine("\t{0}.s4.name = {1}", str1.s4.name); + Console.WriteLine("\t{0}.ef = {1}", str1.ef.ToString()); + } + public static bool ValidateS5(S5 str1, S5 str2, string methodName) + { + if (str1.s4.age != str2.s4.age || str1.s4.name != str2.s4.name) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual s4 field is..."); + Console.WriteLine("\t{0}.s4.age = {1}", str1.ToString(), str1.s4.age); + Console.WriteLine("\t{0}.s4.name = {1}", str1.ToString(), str1.s4.name); + Console.WriteLine("\tThe Expected s4 field is..."); + Console.WriteLine("\t{0}.s4.age = {1}", str2.ToString(), str2.s4.age); + Console.WriteLine("\t{0}.s4.name = {1}", str2.ToString(), str2.s4.name); + return false; + } + if (str1.ef != str2.ef) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual ef field is..."); + Console.WriteLine("\t{0}.ef = {1}", str1.ToString(), str1.ef); + Console.WriteLine("\tThe Expected s4 field is..."); + Console.WriteLine("\t{0}.ef = {1}", str2.ToString(), str2.ef); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for StringStructSequentialAnsi struct + public static StringStructSequentialAnsi NewStringStructSequentialAnsi(string first, string last) + { + StringStructSequentialAnsi s6 = new StringStructSequentialAnsi(); + s6.first = first; + s6.last = last; + + return s6; + } + public static void PrintStringStructSequentialAnsi(StringStructSequentialAnsi str1, string name) + { + Console.WriteLine("\t{0}.first = {1}", name, str1.first); + Console.WriteLine("\t{0}.last = {1}", name, str1.last); + } + public static bool ValidateStringStructSequentialAnsi(StringStructSequentialAnsi str1, StringStructSequentialAnsi str2, string methodName) + { + if (str1.first != str2.first || str1.last != str2.last) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintStringStructSequentialAnsi(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintStringStructSequentialAnsi(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for StringStructSequentialUnicode struct + public static StringStructSequentialUnicode NewStringStructSequentialUnicode(string first, string last) + { + StringStructSequentialUnicode s7 = new StringStructSequentialUnicode(); + s7.first = first; + s7.last = last; + + return s7; + } + public static void PrintStringStructSequentialUnicode(StringStructSequentialUnicode str1, string name) + { + Console.WriteLine("\t{0}.first = {1}", name, str1.first); + Console.WriteLine("\t{0}.last = {1}", name, str1.last); + } + public static bool ValidateStringStructSequentialUnicode(StringStructSequentialUnicode str1, StringStructSequentialUnicode str2, string methodName) + { + if (str1.first != str2.first || str1.last != str2.last) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintStringStructSequentialUnicode(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintStringStructSequentialUnicode(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for S8 struct + public static S8 NewS8(string name, bool gender, UInt16 jobNum, int i32, uint ui32, sbyte mySByte) + { + S8 s8 = new S8(); + s8.name = name; + s8.gender = gender; + s8.i32 = i32; + s8.ui32 = ui32; + s8.jobNum = jobNum; + s8.mySByte = mySByte; + return s8; + } + public static void PrintS8(S8 str1, string name) + { + Console.WriteLine("\t{0}.name = {1}", name, str1.name); + Console.WriteLine("\t{0}.gender = {1}", name, str1.gender); + Console.WriteLine("\t{0}.jobNum = {1}", name, str1.jobNum); + Console.WriteLine("\t{0}.i32 = {1}", name, str1.i32); + Console.WriteLine("\t{0}.ui32 = {1}", name, str1.ui32); + Console.WriteLine("\t{0}.mySByte = {1}", name, str1.mySByte); + } + public static bool ValidateS8(S8 str1, S8 str2, string methodName) + { + if (str1.name != str2.name || str1.gender != str2.gender || + str1.jobNum != str2.jobNum || + str1.i32 != str2.i32 || str1.ui32 != str2.ui32 || str1.mySByte != str2.mySByte) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintS8(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintS8(str2, str2.ToString()); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + + } + + #endregion + + #region methods for S9 struct + public static S9 NewS9(int i32, TestDelegate1 testDel1) + { + S9 s9 = new S9(); + s9.i32 = i32; + s9.myDelegate1 = testDel1; + return s9; + } + public static bool ValidateS9(S9 str1, S9 str2, string methodName) + { + if (str1.i32 != str2.i32 || str1.myDelegate1 != str2.myDelegate1) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + Console.WriteLine("\t{0}.i32 = {1}", str1.ToString(), str1.i32); + Console.WriteLine("\t{0}.myDelegate1 = {1}", str1.ToString(), str1.myDelegate1); + Console.WriteLine("\tThe Expected is..."); + Console.WriteLine("\t{0}.i32 = {1}", str2.ToString(), str2.i32); + Console.WriteLine("\t{0}.myDelegate1 = {1}", str2.ToString(), str2.myDelegate1); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for IncludeOuterIntergerStructSequential struct + public static IncludeOuterIntergerStructSequential NewIncludeOuterIntergerStructSequential(int i321, int i322) + { + IncludeOuterIntergerStructSequential s10 = new IncludeOuterIntergerStructSequential(); + s10.s.s_int.i = i321; + s10.s.i = i322; + return s10; + } + public static void PrintIncludeOuterIntergerStructSequential(IncludeOuterIntergerStructSequential str1, string name) + { + Console.WriteLine("\t{0}.s.s_int.i = {1}", name, str1.s.s_int.i); + Console.WriteLine("\t{0}.s.i = {1}", name, str1.s.i); + } + public static bool ValidateIncludeOuterIntergerStructSequential(IncludeOuterIntergerStructSequential str1, IncludeOuterIntergerStructSequential str2, string methodName) + { + if (str1.s.s_int.i != str2.s.s_int.i || str1.s.i != str2.s.i) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintIncludeOuterIntergerStructSequential(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintIncludeOuterIntergerStructSequential(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for S11 struct + unsafe public static void PrintS11(S11 str1, string name) + { + Console.WriteLine("\t{0}.i32 = {1}", name, (int)(str1.i32)); + Console.WriteLine("\t{0}.i = {1}", name, str1.i); + } + unsafe public static S11 NewS11(int* i32, int i) + { + S11 s11 = new S11(); + s11.i32 = i32; + s11.i = i; + return s11; + } + unsafe public static bool ValidateS11(S11 str1, S11 str2, string methodName) + { + if (str1.i32 != str2.i32 || str1.i != str2.i) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintS11(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintS11(str2, str2.ToString()); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for U struct + public static U NewU(int i32, uint ui32, IntPtr iPtr, UIntPtr uiPtr, short s, ushort us, byte b, sbyte sb, long l, ulong ul, float f, double d) + { + U u = new U(); + u.i32 = i32; + u.ui32 = ui32; + u.iPtr = iPtr; + u.uiPtr = uiPtr; + u.s = s; + u.us = us; + u.b = b; + u.sb = sb; + u.l = l; + u.ul = ul; + u.f = f; + u.d = d; + + return u; + } + public static void PrintU(U str1, string name) + { + Console.WriteLine("\t{0}.i32 = {1}", name, str1.i32); + Console.WriteLine("\t{0}.ui32 = {1}", name, str1.ui32); + Console.WriteLine("\t{0}.iPtr = {1}", name, str1.iPtr); + Console.WriteLine("\t{0}.uiPtr = {1}", name, str1.uiPtr); + Console.WriteLine("\t{0}.s = {1}", name, str1.s); + Console.WriteLine("\t{0}.us = {1}", name, str1.us); + Console.WriteLine("\t{0}.b = {1}", name, str1.b); + Console.WriteLine("\t{0}.sb = {1}", name, str1.sb); + Console.WriteLine("\t{0}.l = {1}", name, str1.l); + Console.WriteLine("\t{0}.ul = {1}", name, str1.ul); + Console.WriteLine("\t{0}.f = {1}", name, str1.f); + Console.WriteLine("\t{0}.d = {1}", name, str1.d); + } + public static bool ValidateU(U str1, U str2, string methodName) + { + if (str1.i32 != str2.i32 || str1.ui32 != str2.ui32 || str1.iPtr != str2.iPtr || + str1.uiPtr != str2.uiPtr || str1.s != str2.s || str1.us != str2.us || + str1.b != str2.b || str1.sb != str2.sb || str1.l != str2.l || str1.ul != str2.ul || + str1.f != str2.f || str1.d != str2.d) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintU(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintU(str2, str2.ToString()); + return false; + } + Console.WriteLine("\tPASSED!"); + return true; + } + #endregion + + #region methods for ByteStructPack2Explicit struct + public static ByteStructPack2Explicit NewByteStructPack2Explicit(byte b1, byte b2) + { + ByteStructPack2Explicit u1 = new ByteStructPack2Explicit(); + u1.b1 = b1; + u1.b2 = b2; + + return u1; + } + public static void PrintByteStructPack2Explicit(ByteStructPack2Explicit str1, string name) + { + Console.WriteLine("\t{0}.b1 = {1}", name, str1.b1); + Console.WriteLine("\t{0}.b2 = {1}", name, str1.b2); + } + public static bool ValidateByteStructPack2Explicit(ByteStructPack2Explicit str1, ByteStructPack2Explicit str2, string methodName) + { + if (str1.b1 != str2.b1 || str1.b2 != str2.b2) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintByteStructPack2Explicit(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintByteStructPack2Explicit(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for ShortStructPack4Explicit struct + public static ShortStructPack4Explicit NewShortStructPack4Explicit(short s1, short s2) + { + ShortStructPack4Explicit u2 = new ShortStructPack4Explicit(); + u2.s1 = s1; + u2.s2 = s2; + + return u2; + } + public static void PrintShortStructPack4Explicit(ShortStructPack4Explicit str1, string name) + { + Console.WriteLine("\t{0}.s1 = {1}", name, str1.s1); + Console.WriteLine("\t{0}.s2 = {1}", name, str1.s2); + } + public static bool ValidateShortStructPack4Explicit(ShortStructPack4Explicit str1, ShortStructPack4Explicit str2, string methodName) + { + if (str1.s1 != str2.s1 || str1.s2 != str2.s2) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintShortStructPack4Explicit(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintShortStructPack4Explicit(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for IntStructPack8Explicit struct + public static IntStructPack8Explicit NewIntStructPack8Explicit(int i1, int i2) + { + IntStructPack8Explicit u3 = new IntStructPack8Explicit(); + u3.i1 = i1; + u3.i2 = i2; + + return u3; + } + public static void PrintIntStructPack8Explicit(IntStructPack8Explicit str1, string name) + { + Console.WriteLine("\t{0}.i1 = {1}", name, str1.i1); + Console.WriteLine("\t{0}.i2 = {1}", name, str1.i2); + } + public static bool ValidateIntStructPack8Explicit(IntStructPack8Explicit str1, IntStructPack8Explicit str2, string methodName) + { + if (str1.i1 != str2.i1 || str1.i2 != str2.i2) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintIntStructPack8Explicit(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintIntStructPack8Explicit(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + + #region methods for LongStructPack16Explicit struct + public static LongStructPack16Explicit NewLongStructPack16Explicit(long l1, long l2) + { + LongStructPack16Explicit u4 = new LongStructPack16Explicit(); + u4.l1 = l1; + u4.l2 = l2; + + return u4; + } + public static void PrintLongStructPack16Explicit(LongStructPack16Explicit str1, string name) + { + Console.WriteLine("\t{0}.l1 = {1}", name, str1.l1); + Console.WriteLine("\t{0}.l2 = {1}", name, str1.l2); + } + public static bool ValidateLongStructPack16Explicit(LongStructPack16Explicit str1, LongStructPack16Explicit str2, string methodName) + { + if (str1.l1 != str2.l1 || str1.l2 != str2.l2) + { + Console.WriteLine("\tFAILED! " + methodName + "did not recieve result as expected."); + Console.WriteLine("\tThe Actual is..."); + PrintLongStructPack16Explicit(str1, str1.ToString()); + Console.WriteLine("\tThe Expected is..."); + PrintLongStructPack16Explicit(str2, str2.ToString()); + return false; + } + else + { + Console.WriteLine("\tPASSED!"); + return true; + } + } + #endregion + +}
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp.cs b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp.cs new file mode 100644 index 0000000000..43492d7c49 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp.cs @@ -0,0 +1,1570 @@ +using System; +using System.Runtime.InteropServices; +using System.Security; + +public class Managed +{ + static int failures = 0; + enum StructID + { + INNER2Id, + InnerExplicitId, + InnerArrayExplicitId, + OUTER3Id, + UId, + ByteStructPack2ExplicitId, + ShortStructPack4ExplicitId, + IntStructPack8ExplicitId, + LongStructPack16ExplicitId + } + + [SecuritySafeCritical] + public static int Main() + { + RunMarshalStructAsParamAsExpByVal(); + RunMarshalStructAsParamAsExpByRef(); + RunMarshalStructAsParamAsExpByValIn(); + RunMarshalStructAsParamAsExpByRefIn(); + RunMarshalStructAsParamAsExpByValOut(); + RunMarshalStructAsParamAsExpByRefOut(); + RunMarshalStructAsParamAsExpByValInOut(); + RunMarshalStructAsParamAsExpByRefInOut(); + + if (failures > 0) + { + Console.WriteLine("\nTEST FAILED!"); + return 101; + } + else + { + Console.WriteLine("\nTEST PASSED!"); + return 100; + } + } + + #region Struct with Layout Explicit scenario1 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValINNER2(INNER2 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefINNER2(ref INNER2 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValINNER2")] + static extern bool MarshalStructAsParam_AsExpByValInINNER2([In] INNER2 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInINNER2([In] ref INNER2 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValINNER2")] + static extern bool MarshalStructAsParam_AsExpByValOutINNER2([Out] INNER2 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutINNER2(out INNER2 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValINNER2")] + static extern bool MarshalStructAsParam_AsExpByValInOutINNER2([In, Out] INNER2 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefINNER2")] + static extern bool MarshalStructAsParam_AsExpByRefInOutINNER2([In, Out] ref INNER2 str1); + #endregion + #region Struct with Layout Explicit scenario2 + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByValInnerExplicit(InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByRefInnerExplicit(ref InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByValInInnerExplicit([In] InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefInInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByRefInInnerExplicit([In] ref InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByValOutInnerExplicit([Out] InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefOutInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByRefOutInnerExplicit(out InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByValInOutInnerExplicit([In, Out] InnerExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefInnerExplicit")] + static extern bool MarshalStructAsParam_AsExpByRefInOutInnerExplicit([In, Out] ref InnerExplicit str1); + #endregion + #region Struct with Layout Explicit scenario3 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValInnerArrayExplicit(InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInnerArrayExplicit(ref InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerArrayExplicit")] + static extern bool MarshalStructAsParam_AsExpByValInInnerArrayExplicit([In] InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInInnerArrayExplicit([In] ref InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerArrayExplicit")] + static extern bool MarshalStructAsParam_AsExpByValOutInnerArrayExplicit([Out] InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit(out InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValInnerArrayExplicit")] + static extern bool MarshalStructAsParam_AsExpByValInOutInnerArrayExplicit([In, Out] InnerArrayExplicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefInnerArrayExplicit")] + static extern bool MarshalStructAsParam_AsExpByRefInOutInnerArrayExplicit([In, Out] ref InnerArrayExplicit str1); + #endregion + #region Struct with Layout Explicit scenario4 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValOUTER3(OUTER3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOUTER3(ref OUTER3 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValOUTER3")] + static extern bool MarshalStructAsParam_AsExpByValInOUTER3([In] OUTER3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInOUTER3([In] ref OUTER3 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValOUTER3")] + static extern bool MarshalStructAsParam_AsExpByValOutOUTER3([Out] OUTER3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutOUTER3(out OUTER3 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValOUTER3")] + static extern bool MarshalStructAsParam_AsExpByValInOutOUTER3([In, Out] OUTER3 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefOUTER3")] + static extern bool MarshalStructAsParam_AsExpByRefInOutOUTER3([In, Out] ref OUTER3 str1); + #endregion + #region Struct(U) with Layout Explicit scenario5 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValU(U str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefU(ref U str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValU")] + static extern bool MarshalStructAsParam_AsExpByValInU([In] U str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInU([In] ref U str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValU")] + static extern bool MarshalStructAsParam_AsExpByValOutU([Out] U str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutU(out U str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValU")] + static extern bool MarshalStructAsParam_AsExpByValInOutU([In, Out] U str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefU")] + static extern bool MarshalStructAsParam_AsExpByRefInOutU([In, Out] ref U str1); + #endregion + + #region Struct(ByteStructPack2Explicit) with Layout Explicit scenario6 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValByteStructPack2Explicit(ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefByteStructPack2Explicit(ref ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValByteStructPack2Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInByteStructPack2Explicit([In] ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit([In] ref ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValByteStructPack2Explicit")] + static extern bool MarshalStructAsParam_AsExpByValOutByteStructPack2Explicit([Out] ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit(out ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValByteStructPack2Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInOutByteStructPack2Explicit([In, Out] ByteStructPack2Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefByteStructPack2Explicit")] + static extern bool MarshalStructAsParam_AsExpByRefInOutByteStructPack2Explicit([In, Out] ref ByteStructPack2Explicit str1); + #endregion + #region Struct(ShortStructPack4Explicit) with Layout Explicit scenario7 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValShortStructPack4Explicit(ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefShortStructPack4Explicit(ref ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValShortStructPack4Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInShortStructPack4Explicit([In] ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit([In] ref ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValShortStructPack4Explicit")] + static extern bool MarshalStructAsParam_AsExpByValOutShortStructPack4Explicit([Out] ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit(out ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValShortStructPack4Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInOutShortStructPack4Explicit([In, Out] ShortStructPack4Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefShortStructPack4Explicit")] + static extern bool MarshalStructAsParam_AsExpByRefInOutShortStructPack4Explicit([In, Out] ref ShortStructPack4Explicit str1); + #endregion + #region Struct(IntStructPack8Explicit) with Layout Explicit scenario8 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValIntStructPack8Explicit(IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefIntStructPack8Explicit(ref IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValIntStructPack8Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInIntStructPack8Explicit([In] IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit([In] ref IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValIntStructPack8Explicit")] + static extern bool MarshalStructAsParam_AsExpByValOutIntStructPack8Explicit([Out] IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit(out IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValIntStructPack8Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInOutIntStructPack8Explicit([In, Out] IntStructPack8Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefIntStructPack8Explicit")] + static extern bool MarshalStructAsParam_AsExpByRefInOutIntStructPack8Explicit([In, Out] ref IntStructPack8Explicit str1); + #endregion + #region Struct(LongStructPack16Explicit) with Layout Explicit scenario9 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByValLongStructPack16Explicit(LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefLongStructPack16Explicit(ref LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValLongStructPack16Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInLongStructPack16Explicit([In] LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit([In] ref LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValLongStructPack16Explicit")] + static extern bool MarshalStructAsParam_AsExpByValOutLongStructPack16Explicit([Out] LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit(out LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByValLongStructPack16Explicit")] + static extern bool MarshalStructAsParam_AsExpByValInOutLongStructPack16Explicit([In, Out] LongStructPack16Explicit str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsExpByRefLongStructPack16Explicit")] + static extern bool MarshalStructAsParam_AsExpByRefInOutLongStructPack16Explicit([In, Out] ref LongStructPack16Explicit str1); + #endregion + + #region Marshal Explicit struct method + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByVal(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 cloneINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValINNER2..."); + if (!MarshalStructAsParam_AsExpByValINNER2(sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, cloneINNER2, "MarshalStructAsParam_AsExpByValINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit cloneInnerExplicit = new InnerExplicit(); + cloneInnerExplicit.f1 = 1; + cloneInnerExplicit.f3 = "some string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByValInnerExplicit(sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, cloneInnerExplicit, "MarshalStructAsParam_AsExpByValInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit cloneInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByValInnerArrayExplicit(sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, cloneInnerArrayExplicit, "MarshalStructAsParam_AsExpByValInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 cloneOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOUTER3..."); + if (!MarshalStructAsParam_AsExpByValOUTER3(sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, cloneOUTER3, "MarshalStructAsParam_AsExpByValOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U cloneU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValU..."); + if (!MarshalStructAsParam_AsExpByValU(sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, cloneU, "MarshalStructAsParam_AsExpByValU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit clone_bspe = Helper.NewByteStructPack2Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByValByteStructPack2Explicit(source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, clone_bspe, "MarshalStructAsParam_AsExpByValByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit clone_sspe = Helper.NewShortStructPack4Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByValShortStructPack4Explicit(source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, clone_sspe, "MarshalStructAsParam_AsExpByValShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit clone_ispe = Helper.NewIntStructPack8Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByValIntStructPack8Explicit(source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, clone_ispe, "MarshalStructAsParam_AsExpByValIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit cloneLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByValLongStructPack16Explicit(sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, cloneLongStructPack16Explicit, "MarshalStructAsParam_AsExpByValLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByRef(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 changeINNER2 = Helper.NewINNER2(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefINNER2..."); + if (!MarshalStructAsParam_AsExpByRefINNER2(ref sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, changeINNER2, "MarshalStructAsParam_AsExpByRefINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit changeInnerExplicit = new InnerExplicit(); + changeInnerExplicit.f1 = 77; + changeInnerExplicit.f3 = "changed string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByRefInnerExplicit(ref sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, changeInnerExplicit, "MarshalStructAsParam_AsExpByRefInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit changeInnerArrayExplicit = Helper.NewInnerArrayExplicit(77, 77.0F, "change string1", "change string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByRefInnerArrayExplicit(ref sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, changeInnerArrayExplicit, "MarshalStructAsParam_AsExpByRefInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 changeOUTER3 = Helper.NewOUTER3(77, 77.0F, "changed string", "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOUTER3..."); + if (!MarshalStructAsParam_AsExpByRefOUTER3(ref sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, changeOUTER3, "MarshalStructAsParam_AsExpByRefOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U changeU = Helper.NewU(Int32.MaxValue, UInt32.MinValue, new IntPtr(-64), new UIntPtr(64), short.MaxValue, ushort.MinValue, byte.MaxValue, sbyte.MinValue, long.MaxValue, ulong.MinValue, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefU..."); + if (!MarshalStructAsParam_AsExpByRefU(ref sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, changeU, "MarshalStructAsParam_AsExpByRefU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByRefByteStructPack2Explicit(ref source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, change_bspe, "MarshalStructAsParam_AsExpByRefByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByRefShortStructPack4Explicit(ref source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, change_sspe, "MarshalStructAsParam_AsExpByRefShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByRefIntStructPack8Explicit(ref source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, change_ispe, "MarshalStructAsParam_AsExpByRefIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit changeLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByRefLongStructPack16Explicit(ref sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, changeLongStructPack16Explicit, "MarshalStructAsParam_AsExpByRefLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByValIn(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 cloneINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInINNER2..."); + if (!MarshalStructAsParam_AsExpByValInINNER2(sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, cloneINNER2, "MarshalStructAsParam_AsExpByValInINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit cloneInnerExplicit = new InnerExplicit(); + cloneInnerExplicit.f1 = 1; + cloneInnerExplicit.f3 = "some string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByValInInnerExplicit(sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, cloneInnerExplicit, "MarshalStructAsParam_AsExpByValInInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit cloneInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByValInInnerArrayExplicit(sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, cloneInnerArrayExplicit, "MarshalStructAsParam_AsExpByValInInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 cloneOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOUTER3..."); + if (!MarshalStructAsParam_AsExpByValInOUTER3(sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, cloneOUTER3, "MarshalStructAsParam_AsExpByValInOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U cloneU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInU..."); + if (!MarshalStructAsParam_AsExpByValInU(sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, cloneU, "MarshalStructAsParam_AsExpByValInU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit clone_bspe = Helper.NewByteStructPack2Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByValInByteStructPack2Explicit(source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, clone_bspe, "MarshalStructAsParam_AsExpByValInByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit clone_sspe = Helper.NewShortStructPack4Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByValInShortStructPack4Explicit(source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, clone_sspe, "MarshalStructAsParam_AsExpByValInShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit clone_ispe = Helper.NewIntStructPack8Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByValInIntStructPack8Explicit(source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, clone_ispe, "MarshalStructAsParam_AsExpByValInIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit cloneLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByValInLongStructPack16Explicit(sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, cloneLongStructPack16Explicit, "MarshalStructAsParam_AsExpByValInLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByRefIn(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 changeINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInINNER2..."); + if (!MarshalStructAsParam_AsExpByRefInINNER2(ref sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, changeINNER2, "MarshalStructAsParam_AsExpByRefInINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit changeInnerExplicit = new InnerExplicit(); + changeInnerExplicit.f1 = 1; + changeInnerExplicit.f3 = "some string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByRefInInnerExplicit(ref sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, changeInnerExplicit, "MarshalStructAsParam_AsExpByRefInInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit changeInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByRefInInnerArrayExplicit(ref sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, changeInnerArrayExplicit, "MarshalStructAsParam_AsExpByRefInInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 changeOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOUTER3..."); + if (!MarshalStructAsParam_AsExpByRefInOUTER3(ref sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, changeOUTER3, "MarshalStructAsParam_AsExpByRefInOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U changeU = Helper.NewU(Int32.MaxValue, UInt32.MinValue, new IntPtr(-64), new UIntPtr(64), short.MaxValue, ushort.MinValue, byte.MaxValue, sbyte.MinValue, long.MaxValue, ulong.MinValue, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInU..."); + if (!MarshalStructAsParam_AsExpByRefInU(ref sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, changeU, "MarshalStructAsParam_AsExpByRefInU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit(ref source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, change_bspe, "MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit(ref source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, change_sspe, "MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit(ref source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, change_ispe, "MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit changeLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit(ref sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, changeLongStructPack16Explicit, "MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByValOut(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 cloneINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutINNER2..."); + if (!MarshalStructAsParam_AsExpByValOutINNER2(sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, cloneINNER2, "MarshalStructAsParam_AsExpByValOutINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit cloneInnerExplicit = new InnerExplicit(); + cloneInnerExplicit.f1 = 1; + cloneInnerExplicit.f3 = "some string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByValOutInnerExplicit(sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, cloneInnerExplicit, "MarshalStructAsParam_AsExpByValOutInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit cloneInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByValOutInnerArrayExplicit(sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, cloneInnerArrayExplicit, "MarshalStructAsParam_AsExpByValOutInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 cloneOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutOUTER3..."); + if (!MarshalStructAsParam_AsExpByValOutOUTER3(sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, cloneOUTER3, "MarshalStructAsParam_AsExpByValOutOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U cloneU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutU..."); + if (!MarshalStructAsParam_AsExpByValOutU(sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, cloneU, "MarshalStructAsParam_AsExpByValOutU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit clone_bspe = Helper.NewByteStructPack2Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByValOutByteStructPack2Explicit(source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, clone_bspe, "MarshalStructAsParam_AsExpByValOutByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit clone_sspe = Helper.NewShortStructPack4Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByValOutShortStructPack4Explicit(source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, clone_sspe, "MarshalStructAsParam_AsExpByValOutShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit clone_ispe = Helper.NewIntStructPack8Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByValOutIntStructPack8Explicit(source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, clone_ispe, "MarshalStructAsParam_AsExpByValOutIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit cloneLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValOutLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByValOutLongStructPack16Explicit(sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValOutLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, cloneLongStructPack16Explicit, "MarshalStructAsParam_AsExpByValOutLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByRefOut(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 changeINNER2 = Helper.NewINNER2(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutINNER2..."); + if (!MarshalStructAsParam_AsExpByRefOutINNER2(out sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, changeINNER2, "MarshalStructAsParam_AsExpByRefOutINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit changeInnerExplicit = new InnerExplicit(); + changeInnerExplicit.f1 = 77; + changeInnerExplicit.f3 = "changed string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByRefOutInnerExplicit(out sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, changeInnerExplicit, "MarshalStructAsParam_AsExpByRefOutInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit changeInnerArrayExplicit = Helper.NewInnerArrayExplicit(77, 77.0F, "change string1", "change string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit(out sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, changeInnerArrayExplicit, "MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 changeOUTER3 = Helper.NewOUTER3(77, 77.0F, "changed string", "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutOUTER3..."); + if (!MarshalStructAsParam_AsExpByRefOutOUTER3(out sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, changeOUTER3, "MarshalStructAsParam_AsExpByRefOutOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U changeU = Helper.NewU(Int32.MaxValue, UInt32.MinValue, new IntPtr(-64), new UIntPtr(64), short.MaxValue, ushort.MinValue, byte.MaxValue, sbyte.MinValue, long.MaxValue, ulong.MinValue, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutU..."); + if (!MarshalStructAsParam_AsExpByRefOutU(out sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, changeU, "MarshalStructAsParam_AsExpByRefOutU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit(out source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, change_bspe, "MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit(out source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, change_sspe, "MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit(out source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, change_ispe, "MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit changeLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit(out sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, changeLongStructPack16Explicit, "MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByValInOut(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 cloneINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutINNER2..."); + if (!MarshalStructAsParam_AsExpByValInOutINNER2(sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, cloneINNER2, "MarshalStructAsParam_AsExpByValInOutINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit cloneInnerExplicit = new InnerExplicit(); + cloneInnerExplicit.f1 = 1; + cloneInnerExplicit.f3 = "some string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByValInOutInnerExplicit(sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, cloneInnerExplicit, "MarshalStructAsParam_AsExpByValInOutInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit cloneInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByValInOutInnerArrayExplicit(sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, cloneInnerArrayExplicit, "MarshalStructAsParam_AsExpByValInOutInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 cloneOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutOUTER3..."); + if (!MarshalStructAsParam_AsExpByValInOutOUTER3(sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, cloneOUTER3, "MarshalStructAsParam_AsExpByValInOutOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U cloneU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutU..."); + if (!MarshalStructAsParam_AsExpByValInOutU(sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, cloneU, "MarshalStructAsParam_AsExpByValInOutU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit clone_bspe = Helper.NewByteStructPack2Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByValInOutByteStructPack2Explicit(source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, clone_bspe, "MarshalStructAsParam_AsExpByValInOutByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit clone_sspe = Helper.NewShortStructPack4Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByValInOutShortStructPack4Explicit(source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, clone_sspe, "MarshalStructAsParam_AsExpByValInOutShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit clone_ispe = Helper.NewIntStructPack8Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByValInOutIntStructPack8Explicit(source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, clone_ispe, "MarshalStructAsParam_AsExpByValInOutIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit cloneLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByValInOutLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByValInOutLongStructPack16Explicit(sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByValInOutLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, cloneLongStructPack16Explicit, "MarshalStructAsParam_AsExpByValInOutLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + private static void MarshalStructAsParam_AsExpByRefInOut(StructID id) + { + try + { + switch (id) + { + case StructID.INNER2Id: + INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string"); + INNER2 changeINNER2 = Helper.NewINNER2(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutINNER2..."); + if (!MarshalStructAsParam_AsExpByRefInOutINNER2(ref sourceINNER2)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutINNER2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateINNER2(sourceINNER2, changeINNER2, "MarshalStructAsParam_AsExpByRefInOutINNER2")) + { + failures++; + } + break; + case StructID.InnerExplicitId: + InnerExplicit sourceInnerExplicit = new InnerExplicit(); + sourceInnerExplicit.f1 = 1; + sourceInnerExplicit.f3 = "some string"; + InnerExplicit changeInnerExplicit = new InnerExplicit(); + changeInnerExplicit.f1 = 77; + changeInnerExplicit.f3 = "changed string"; + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutInnerExplicit..."); + if (!MarshalStructAsParam_AsExpByRefInOutInnerExplicit(ref sourceInnerExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutInnerExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerExplicit(sourceInnerExplicit, changeInnerExplicit, "MarshalStructAsParam_AsExpByRefInOutInnerExplicit")) + { + failures++; + } + break; + case StructID.InnerArrayExplicitId: + InnerArrayExplicit sourceInnerArrayExplicit = Helper.NewInnerArrayExplicit(1, 1.0F, "some string1", "some string2"); + InnerArrayExplicit changeInnerArrayExplicit = Helper.NewInnerArrayExplicit(77, 77.0F, "change string1", "change string2"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutInnerArrayExplicit..."); + if (!MarshalStructAsParam_AsExpByRefInOutInnerArrayExplicit(ref sourceInnerArrayExplicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutInnerArrayExplicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArrayExplicit(sourceInnerArrayExplicit, changeInnerArrayExplicit, "MarshalStructAsParam_AsExpByRefInOutInnerArrayExplicit")) + { + failures++; + } + break; + case StructID.OUTER3Id: + OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string"); + OUTER3 changeOUTER3 = Helper.NewOUTER3(77, 77.0F, "changed string", "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutOUTER3..."); + if (!MarshalStructAsParam_AsExpByRefInOutOUTER3(ref sourceOUTER3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutOUTER3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateOUTER3(sourceOUTER3, changeOUTER3, "MarshalStructAsParam_AsExpByRefInOutOUTER3")) + { + failures++; + } + break; + case StructID.UId: + U sourceU = Helper.NewU(Int32.MinValue, UInt32.MaxValue, new IntPtr(-32), new UIntPtr(32), short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, long.MinValue, ulong.MaxValue, 32.0F, 3.2); + U changeU = Helper.NewU(Int32.MaxValue, UInt32.MinValue, new IntPtr(-64), new UIntPtr(64), short.MaxValue, ushort.MinValue, byte.MaxValue, sbyte.MinValue, long.MaxValue, ulong.MinValue, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutU..."); + if (!MarshalStructAsParam_AsExpByRefInOutU(ref sourceU)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutU.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateU(sourceU, changeU, "MarshalStructAsParam_AsExpByRefInOutU")) + { + failures++; + } + break; + case StructID.ByteStructPack2ExplicitId: + ByteStructPack2Explicit source_bspe = Helper.NewByteStructPack2Explicit(32, 32); + ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutByteStructPack2Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInOutByteStructPack2Explicit(ref source_bspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutByteStructPack2Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateByteStructPack2Explicit(source_bspe, change_bspe, "MarshalStructAsParam_AsExpByRefInOutByteStructPack2Explicit")) + { + failures++; + } + break; + case StructID.ShortStructPack4ExplicitId: + ShortStructPack4Explicit source_sspe = Helper.NewShortStructPack4Explicit(32, 32); + ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutShortStructPack4Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInOutShortStructPack4Explicit(ref source_sspe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutShortStructPack4Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateShortStructPack4Explicit(source_sspe, change_sspe, "MarshalStructAsParam_AsExpByRefInOutShortStructPack4Explicit")) + { + failures++; + } + break; + case StructID.IntStructPack8ExplicitId: + IntStructPack8Explicit source_ispe = Helper.NewIntStructPack8Explicit(32, 32); + IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutIntStructPack8Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInOutIntStructPack8Explicit(ref source_ispe)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutIntStructPack8Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIntStructPack8Explicit(source_ispe, change_ispe, "MarshalStructAsParam_AsExpByRefInOutIntStructPack8Explicit")) + { + failures++; + } + break; + case StructID.LongStructPack16ExplicitId: + LongStructPack16Explicit sourceLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(32, 32); + LongStructPack16Explicit changeLongStructPack16Explicit = Helper.NewLongStructPack16Explicit(64, 64); + Console.WriteLine("\tCalling MarshalStructAsParam_AsExpByRefInOutLongStructPack16Explicit..."); + if (!MarshalStructAsParam_AsExpByRefInOutLongStructPack16Explicit(ref sourceLongStructPack16Explicit)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsExpByRefInOutLongStructPack16Explicit.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateLongStructPack16Explicit(sourceLongStructPack16Explicit, changeLongStructPack16Explicit, "MarshalStructAsParam_AsExpByRefInOutLongStructPack16Explicit")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + #endregion + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByVal() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByVal"); + MarshalStructAsParam_AsExpByVal(StructID.INNER2Id); + MarshalStructAsParam_AsExpByVal(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByVal(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByVal(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByVal(StructID.UId); + MarshalStructAsParam_AsExpByVal(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByVal(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByVal(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByVal(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByRef() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByRef"); + MarshalStructAsParam_AsExpByRef(StructID.INNER2Id); + MarshalStructAsParam_AsExpByRef(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByRef(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByRef(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByRef(StructID.UId); + MarshalStructAsParam_AsExpByRef(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByRef(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByRef(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByRef(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByValIn() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByValIn"); + MarshalStructAsParam_AsExpByValIn(StructID.INNER2Id); + MarshalStructAsParam_AsExpByValIn(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByValIn(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByValIn(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByValIn(StructID.UId); + MarshalStructAsParam_AsExpByValIn(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByValIn(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByValIn(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByValIn(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByRefIn() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByRefIn"); + MarshalStructAsParam_AsExpByRefIn(StructID.INNER2Id); + MarshalStructAsParam_AsExpByRefIn(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByRefIn(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByRefIn(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByRefIn(StructID.UId); + MarshalStructAsParam_AsExpByRefIn(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByRefIn(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByRefIn(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByRefIn(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByValOut() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByValOut"); + MarshalStructAsParam_AsExpByValOut(StructID.INNER2Id); + MarshalStructAsParam_AsExpByValOut(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByValOut(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByValOut(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByValOut(StructID.UId); + MarshalStructAsParam_AsExpByValOut(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByValOut(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByValOut(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByValOut(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByRefOut() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByRefOut"); + MarshalStructAsParam_AsExpByRefOut(StructID.INNER2Id); + MarshalStructAsParam_AsExpByRefOut(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByRefOut(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByRefOut(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByRefOut(StructID.UId); + MarshalStructAsParam_AsExpByRefOut(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByRefOut(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByRefOut(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByRefOut(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByValInOut() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByValInOut"); + MarshalStructAsParam_AsExpByValInOut(StructID.INNER2Id); + MarshalStructAsParam_AsExpByValInOut(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByValInOut(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByValInOut(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByValInOut(StructID.UId); + MarshalStructAsParam_AsExpByValInOut(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByValInOut(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByValInOut(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByValInOut(StructID.LongStructPack16ExplicitId); + } + + [SecuritySafeCritical] + private static void RunMarshalStructAsParamAsExpByRefInOut() + { + Console.WriteLine("\nVerify marshal Explicit layout struct as param as ByRefInOut"); + MarshalStructAsParam_AsExpByRefInOut(StructID.INNER2Id); + MarshalStructAsParam_AsExpByRefInOut(StructID.InnerExplicitId); + MarshalStructAsParam_AsExpByRefInOut(StructID.InnerArrayExplicitId); + MarshalStructAsParam_AsExpByRefInOut(StructID.OUTER3Id); + MarshalStructAsParam_AsExpByRefInOut(StructID.UId); + MarshalStructAsParam_AsExpByRefInOut(StructID.ByteStructPack2ExplicitId); + MarshalStructAsParam_AsExpByRefInOut(StructID.ShortStructPack4ExplicitId); + MarshalStructAsParam_AsExpByRefInOut(StructID.IntStructPack8ExplicitId); + MarshalStructAsParam_AsExpByRefInOut(StructID.LongStructPack16ExplicitId); + } +}
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp.csproj b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp.csproj new file mode 100644 index 0000000000..a7da67fb29 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp.csproj @@ -0,0 +1,50 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>MarshalStructAsLayoutExp</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid> + <OutputType>exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + <DefineConstants>$(DefineConstants);STATIC</DefineConstants> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'"> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'"> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Compile Include="MarshalStructAsLayoutExp.cs" /> + <Compile Include="Struct.cs" /> + <Compile Include="Helper.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="project.json" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj"> + <Project>{c8c0dc74-fac4-45b1-81fe-70c4808366e0}</Project> + <Name>CoreCLRTestLibrary</Name> + </ProjectReference> + <ProjectReference Include="CMakeLists.txt"> + </ProjectReference> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> +</Project>
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq.cs b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq.cs new file mode 100644 index 0000000000..7283d5fb00 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq.cs @@ -0,0 +1,2303 @@ +using System; +using System.Runtime.InteropServices; +using System.Security; + +public class Managed +{ + static int failures = 0; + private static string strOne; + private static string strTwo; + + enum StructID + { + InnerSequentialId, + InnerArraySequentialId, + CharSetAnsiSequentialId, + CharSetUnicodeSequentialId, + NumberSequentialId, + S3Id, + S5Id, + StringStructSequentialAnsiId, + StringStructSequentialUnicodeId, + S8Id, + S9Id, + IncludeOuterIntergerStructSequentialId, + S11Id + } + + private static void InitialArray(int[] iarr, int[] icarr) + { + for (int i = 0; i < iarr.Length; i++) + { + iarr[i] = i; + } + + for (int i = 1; i < icarr.Length + 1; i++) + { + icarr[i - 1] = i; + } + } + + [SecuritySafeCritical] + private static void testMethod(S9 s9) + { + Console.WriteLine("\tThe first field of s9 is:", s9.i32); + } + + [SecuritySafeCritical] + public static int Main() + { + RunMarshalSeqStructAsParamByVal(); + RunMarshalSeqStructAsParamByRef(); + RunMarshalSeqStructAsParamByValIn(); + RunMarshalSeqStructAsParamByRefIn(); + RunMarshalSeqStructAsParamByValOut(); + RunMarshalSeqStructAsParamByRefOut(); + RunMarshalSeqStructAsParamByValInOut(); + RunMarshalSeqStructAsParamByRefInOut(); + + if (failures > 0) + { + Console.WriteLine("\nTEST FAILED!"); + return 101; + } + else + { + Console.WriteLine("\nTEST PASSED!"); + return 100; + } + } + + #region Struct with Layout Sequential scenario1 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal(InnerSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef(ref InnerSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal")] + static extern bool MarshalStructAsParam_AsSeqByValIn([In] InnerSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn([In] ref InnerSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut([Out] InnerSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut(out InnerSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal")] + static extern bool MarshalStructAsParam_AsSeqByValInOut([In, Out] InnerSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut([In, Out] ref InnerSequential str1); + #endregion + #region Struct with Layout Sequential scenario2 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal2(InnerArraySequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef2(ref InnerArraySequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal2")] + static extern bool MarshalStructAsParam_AsSeqByValIn2([In] InnerArraySequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn2([In] ref InnerArraySequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut2([Out] InnerArraySequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut2(out InnerArraySequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal2")] + static extern bool MarshalStructAsParam_AsSeqByValInOut2([In, Out] InnerArraySequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef2")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut2([In, Out] ref InnerArraySequential str1); + #endregion + #region Struct with Layout Sequential scenario3 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal3(CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef3(ref CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal3")] + static extern bool MarshalStructAsParam_AsSeqByValIn3([In] CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn3([In] ref CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut3([Out] CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut3(out CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal3")] + static extern bool MarshalStructAsParam_AsSeqByValInOut3([In, Out] CharSetAnsiSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef3")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut3([In, Out] ref CharSetAnsiSequential str1); + #endregion + #region Struct with Layout Sequential scenario4 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal4(CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef4(ref CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal4")] + static extern bool MarshalStructAsParam_AsSeqByValIn4([In] CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn4([In] ref CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut4([Out] CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut4(out CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal4")] + static extern bool MarshalStructAsParam_AsSeqByValInOut4([In, Out] CharSetUnicodeSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef4")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut4([In, Out] ref CharSetUnicodeSequential str1); + #endregion + #region Struct with Layout Sequential scenario5 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal6(NumberSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef6(ref NumberSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal6")] + static extern bool MarshalStructAsParam_AsSeqByValIn6([In] NumberSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn6([In] ref NumberSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut6([Out] NumberSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut6(out NumberSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal6")] + static extern bool MarshalStructAsParam_AsSeqByValInOut6([In, Out] NumberSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef6")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut6([In, Out] ref NumberSequential str1); + #endregion + #region Struct with Layout Sequential scenario6 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal7(S3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef7(ref S3 str1); + [DllImport("MarshalStructAsParam",EntryPoint = "MarshalStructAsParam_AsSeqByVal7")] + static extern bool MarshalStructAsParam_AsSeqByValIn7([In] S3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn7([In] ref S3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut7(out S3 str1); + [DllImport("MarshalStructAsParam",EntryPoint = "MarshalStructAsParam_AsSeqByRef7")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut7([In,Out] ref S3 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut7([Out] S3 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal7")] + static extern bool MarshalStructAsParam_AsSeqByValInOut7([In, Out] S3 str1); + #endregion + #region Struct with Layout Sequential scenario7 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal8(S5 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef8(ref S5 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal8")] + static extern bool MarshalStructAsParam_AsSeqByValIn8([In] S5 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn8([In] ref S5 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal8")] + static extern bool MarshalStructAsParam_AsSeqByValOut8([Out] S5 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut8(out S5 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal8")] + static extern bool MarshalStructAsParam_AsSeqByValInOut8([In, Out] S5 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef8")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut8([In, Out] ref S5 str1); + #endregion + #region Struct with Layout Sequential scenario8 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal9(StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef9(ref StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal9")] + static extern bool MarshalStructAsParam_AsSeqByValIn9([In] StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn9([In] ref StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut9([Out] StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut9(out StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal9")] + static extern bool MarshalStructAsParam_AsSeqByValInOut9([In, Out] StringStructSequentialAnsi str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef9")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut9([In, Out] ref StringStructSequentialAnsi str1); + #endregion + #region Struct with Layout Sequential scenario9 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal10(StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef10(ref StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal10")] + static extern bool MarshalStructAsParam_AsSeqByValIn10([In] StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn10([In] ref StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut10([Out] StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut10(out StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal10")] + static extern bool MarshalStructAsParam_AsSeqByValInOut10([In, Out] StringStructSequentialUnicode str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef10")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut10([In, Out] ref StringStructSequentialUnicode str1); + #endregion + #region Struct with Layout Sequential scenario10 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal11(S8 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef11(ref S8 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal11")] + static extern bool MarshalStructAsParam_AsSeqByValIn11([In] S8 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn11([In] ref S8 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut11([Out] S8 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut11(out S8 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal11")] + static extern bool MarshalStructAsParam_AsSeqByValInOut11([In, Out] S8 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef11")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut11([In, Out] ref S8 str1); + #endregion + #region Struct with Layout Sequential scenario11 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal12(S9 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef12(ref S9 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal12")] + static extern bool MarshalStructAsParam_AsSeqByValIn12(S9 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef12")] + static extern bool MarshalStructAsParam_AsSeqByRefIn12([In] ref S9 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut12([Out] S9 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut12(out S9 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal12")] + static extern bool MarshalStructAsParam_AsSeqByValInOut12([In, Out] S9 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef12")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut12([In, Out] ref S9 str1); + #endregion + #region Struct with Layout Sequential scenario12 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal13(IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef13(ref IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal13")] + static extern bool MarshalStructAsParam_AsSeqByValIn13([In] IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn13([In] ref IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByValOut13([Out] IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut13(out IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal13")] + static extern bool MarshalStructAsParam_AsSeqByValInOut13([In, Out] IncludeOuterIntergerStructSequential str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef13")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut13([In, Out] ref IncludeOuterIntergerStructSequential str1); + #endregion + #region Struct with Layout Sequential scenario13 + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByVal14(S11 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRef14(ref S11 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal14")] + static extern bool MarshalStructAsParam_AsSeqByValIn14([In] S11 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefIn14([In] ref S11 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByValOut14")] + static extern bool MarshalStructAsParam_AsSeqByValOut14([Out] S11 str1); + [DllImport("MarshalStructAsParam")] + static extern bool MarshalStructAsParam_AsSeqByRefOut14(out S11 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByVal14")] + static extern bool MarshalStructAsParam_AsSeqByValInOut14([In, Out] S11 str1); + [DllImport("MarshalStructAsParam", EntryPoint = "MarshalStructAsParam_AsSeqByRef14")] + static extern bool MarshalStructAsParam_AsSeqByRefInOut14([In, Out] ref S11 str1); + #endregion + + #region Marshal struct method in PInvoke + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByVal(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential clone_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal..."); + if (!MarshalStructAsParam_AsSeqByVal(source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, clone_is, "MarshalStructAsParam_AsSeqByVal")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential clone_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal2..."); + if (!MarshalStructAsParam_AsSeqByVal2(source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, clone_ias, "MarshalStructAsParam_AsSeqByVal2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential clone_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal3..."); + if (!MarshalStructAsParam_AsSeqByVal3(source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, clone_csas, "MarshalStructAsParam_AsSeqByVal3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential clone_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal4..."); + if (!MarshalStructAsParam_AsSeqByVal4(source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, clone_csus, "MarshalStructAsParam_AsSeqByVal4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential clone_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal6..."); + if (!MarshalStructAsParam_AsSeqByVal6(source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, clone_ns, "MarshalStructAsParam_AsSeqByVal6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 cloneS3 = Helper.NewS3(true, "some string", iarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal7..."); + if (!MarshalStructAsParam_AsSeqByVal7(sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, cloneS3, "MarshalStructAsParam_AsSeqByVal7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumcl = Enum1.e1; + + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 cloneS5 = Helper.NewS5(32, "some string", enumcl); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal8..."); + if (!MarshalStructAsParam_AsSeqByVal8(sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, cloneS5, "MarshalStructAsParam_AsSeqByVal8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi clone_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal9..."); + if (!MarshalStructAsParam_AsSeqByVal9(source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, clone_sssa, "MarshalStructAsParam_AsSeqByVal9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode clone_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal10..."); + if (!MarshalStructAsParam_AsSeqByVal10(source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, clone_sssu, "MarshalStructAsParam_AsSeqByVal10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 cloneS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal11..."); + if (!MarshalStructAsParam_AsSeqByVal11(sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, cloneS8, "MarshalStructAsParam_AsSeqByVal11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 cloneS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal12..."); + if (!MarshalStructAsParam_AsSeqByVal12(sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, cloneS9, "MarshalStructAsParam_AsSeqByVal12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential cloneIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal13..."); + if (!MarshalStructAsParam_AsSeqByVal13(sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, cloneIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByVal13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 cloneS11 = Helper.NewS11((int*)new Int64(), 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByVal14..."); + if (!MarshalStructAsParam_AsSeqByVal14(sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByVal14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, cloneS11, "MarshalStructAsParam_AsSeqByVal14")) + { + failures++; + } + break; + + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByRef(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef..."); + if (!MarshalStructAsParam_AsSeqByRef(ref source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, change_is, "MarshalStructAsParam_AsSeqByRef")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential change_ias = Helper.NewInnerArraySequential(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef2..."); + if (!MarshalStructAsParam_AsSeqByRef2(ref source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef2.Expected:True;Actual:False"); + } + if (!Helper.ValidateInnerArraySequential(source_ias, change_ias, "MarshalStructAsParam_AsSeqByRef2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential changeStr1 = Helper.NewCharSetAnsiSequential("change string", 'n'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef3..."); + if (!MarshalStructAsParam_AsSeqByRef3(ref source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, changeStr1, "MarshalStructAsParam_AsSeqByRef3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential change_csus = Helper.NewCharSetUnicodeSequential("change string", 'n'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef4..."); + if (!MarshalStructAsParam_AsSeqByRef4(ref source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, change_csus, "MarshalStructAsParam_AsSeqByRef4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential change_ns = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef6..."); + if (!MarshalStructAsParam_AsSeqByRef6(ref source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, change_ns, "MarshalStructAsParam_AsSeqByRef6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 changeS3 = Helper.NewS3(false, "change string", icarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef7..."); + if (!MarshalStructAsParam_AsSeqByRef7(ref sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, changeS3, "MarshalStructAsParam_AsSeqByRef7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumch = Enum1.e2; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 changeS5 = Helper.NewS5(64, "change string", enumch); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef8..."); + if (!MarshalStructAsParam_AsSeqByRef8(ref sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, changeS5, "MarshalStructAsParam_AsSeqByRef8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef9..."); + if (!MarshalStructAsParam_AsSeqByRef9(ref source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, change_sssa, "MarshalStructAsParam_AsSeqByRef9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode change_sssu = Helper.NewStringStructSequentialUnicode(strTwo, strOne); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef10..."); + if (!MarshalStructAsParam_AsSeqByRef10(ref source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, change_sssu, "MarshalStructAsParam_AsSeqByRef10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef11..."); + if (!MarshalStructAsParam_AsSeqByRef11(ref sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, changeS8, "MarshalStructAsParam_AsSeqByRef11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 changeS9 = Helper.NewS9(256, null); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef12..."); + if (!MarshalStructAsParam_AsSeqByRef12(ref sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, changeS9, "MarshalStructAsParam_AsSeqByRef12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef13..."); + if (!MarshalStructAsParam_AsSeqByRef13(ref sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, changeIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByRef13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 changeS11 = Helper.NewS11((int*)(32), 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRef14..."); + if (!MarshalStructAsParam_AsSeqByRef14(ref sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRef14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, changeS11, "MarshalStructAsParam_AsSeqByRef14")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByValIn(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential clone_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn..."); + if (!MarshalStructAsParam_AsSeqByValIn(source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, clone_is, "MarshalStructAsParam_AsSeqByValIn")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential clone_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn2..."); + if (!MarshalStructAsParam_AsSeqByValIn2(source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, clone_ias, "MarshalStructAsParam_AsSeqByValIn2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential clone_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn3..."); + if (!MarshalStructAsParam_AsSeqByValIn3(source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, clone_csas, "MarshalStructAsParam_AsSeqByValIn3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential clone_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn4..."); + if (!MarshalStructAsParam_AsSeqByValIn4(source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, clone_csus, "MarshalStructAsParam_AsSeqByValIn4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential clone_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn6..."); + if (!MarshalStructAsParam_AsSeqByValIn6(source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, clone_ns, "MarshalStructAsParam_AsSeqByValIn6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 cloneS3 = Helper.NewS3(true, "some string", iarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn7..."); + if (!MarshalStructAsParam_AsSeqByValIn7(sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, cloneS3, "MarshalStructAsParam_AsSeqByValIn7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumcl = Enum1.e1; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 cloneS5 = Helper.NewS5(32, "some string", enumcl); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn8..."); + if (!MarshalStructAsParam_AsSeqByValIn8(sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, cloneS5, "MarshalStructAsParam_AsSeqByValIn8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi clone_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn9..."); + if (!MarshalStructAsParam_AsSeqByValIn9(source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, clone_sssa, "MarshalStructAsParam_AsSeqByValIn9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode clone_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn10..."); + if (!MarshalStructAsParam_AsSeqByValIn10(source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, clone_sssu, "MarshalStructAsParam_AsSeqByValIn10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 cloneS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn11..."); + if (!MarshalStructAsParam_AsSeqByValIn11(sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, cloneS8, "MarshalStructAsParam_AsSeqByValIn11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 cloneS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn12..."); + if (!MarshalStructAsParam_AsSeqByValIn12(sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, cloneS9, "MarshalStructAsParam_AsSeqByValIn12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential cloneIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn13..."); + if (!MarshalStructAsParam_AsSeqByValIn13(sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, cloneIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByValIn13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 cloneS11 = Helper.NewS11((int*)new Int64(), 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValIn14..."); + if (!MarshalStructAsParam_AsSeqByValIn14(sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValIn14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, cloneS11, "MarshalStructAsParam_AsSeqByValIn14")) + { + failures++; + } + break; + + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByRefIn(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential clone_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn..."); + if (!MarshalStructAsParam_AsSeqByRefIn(ref source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, clone_is, "MarshalStructAsParam_AsSeqByRefIn")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential clone_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn2..."); + if (!MarshalStructAsParam_AsSeqByRefIn2(ref source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, clone_ias, "MarshalStructAsParam_AsSeqByRefIn2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential clone_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn3..."); + if (!MarshalStructAsParam_AsSeqByRefIn3(ref source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, clone_csas, "MarshalStructAsParam_AsSeqByRefIn3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential clone_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn4..."); + if (!MarshalStructAsParam_AsSeqByRefIn4(ref source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, clone_csus, "MarshalStructAsParam_AsSeqByRefIn4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential change_ns = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn6..."); + if (!MarshalStructAsParam_AsSeqByRefIn6(ref source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, change_ns, "MarshalStructAsParam_AsSeqByRefIn6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 cloneS3 = Helper.NewS3(true, "some string", iarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn7..."); + if (!MarshalStructAsParam_AsSeqByRefIn7(ref sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, cloneS3, "MarshalStructAsParam_AsSeqByRefIn7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumcl = Enum1.e1; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 cloneS5 = Helper.NewS5(32, "some string", enumcl); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn8..."); + if (!MarshalStructAsParam_AsSeqByRefIn8(ref sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, cloneS5, "MarshalStructAsParam_AsSeqByRefIn8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi clone_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn9..."); + if (!MarshalStructAsParam_AsSeqByRefIn9(ref source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, clone_sssa, "MarshalStructAsParam_AsSeqByRefIn9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode clone_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn10..."); + if (!MarshalStructAsParam_AsSeqByRefIn10(ref source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, clone_sssu, "MarshalStructAsParam_AsSeqByRefIn10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 cloneS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn11..."); + if (!MarshalStructAsParam_AsSeqByRefIn11(ref sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, cloneS8, "MarshalStructAsParam_AsSeqByRefIn11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 cloneS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn12..."); + if (!MarshalStructAsParam_AsSeqByRefIn12(ref sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, cloneS9, "MarshalStructAsParam_AsSeqByRefIn12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn13..."); + if (!MarshalStructAsParam_AsSeqByRefIn13(ref sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, changeIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByRefIn13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 changeS11 = Helper.NewS11((int*)(32), 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefIn14..."); + if (!MarshalStructAsParam_AsSeqByRefIn14(ref sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefIn14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, changeS11, "MarshalStructAsParam_AsSeqByRefIn14")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByValOut(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential clone_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut..."); + if (!MarshalStructAsParam_AsSeqByValOut(source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, clone_is, "MarshalStructAsParam_AsSeqByValOut")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential clone_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut2..."); + if (!MarshalStructAsParam_AsSeqByValOut2(source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, clone_ias, "MarshalStructAsParam_AsSeqByValOut2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential clone_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut3..."); + if (!MarshalStructAsParam_AsSeqByValOut3(source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, clone_csas, "MarshalStructAsParam_AsSeqByValOut3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential clone_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut4..."); + if (!MarshalStructAsParam_AsSeqByValOut4(source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, clone_csus, "MarshalStructAsParam_AsSeqByValOut4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential clone_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut6..."); + if (!MarshalStructAsParam_AsSeqByValOut6(source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, clone_ns, "MarshalStructAsParam_AsSeqByValOut6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 cloneS3 = Helper.NewS3(true, "some string", iarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut7..."); + if (!MarshalStructAsParam_AsSeqByValOut7(sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, cloneS3, "MarshalStructAsParam_AsSeqByValOut7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumcl = Enum1.e1; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 cloneS5 = Helper.NewS5(32, "some string", enumcl); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut8..."); + if (!MarshalStructAsParam_AsSeqByValOut8(sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, cloneS5, "MarshalStructAsParam_AsSeqByValOut8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi clone_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut9..."); + if (!MarshalStructAsParam_AsSeqByValOut9(source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, clone_sssa, "MarshalStructAsParam_AsSeqByValOut9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode clone_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut10..."); + if (!MarshalStructAsParam_AsSeqByValOut10(source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, clone_sssu, "MarshalStructAsParam_AsSeqByValOut10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 cloneS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut11..."); + if (!MarshalStructAsParam_AsSeqByValOut11(sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, cloneS8, "MarshalStructAsParam_AsSeqByValOut11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 cloneS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut12..."); + if (!MarshalStructAsParam_AsSeqByValOut12(sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, cloneS9, "MarshalStructAsParam_AsSeqByValOut12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential cloneIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut13..."); + if (!MarshalStructAsParam_AsSeqByValOut13(sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, cloneIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByValOut13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)32, 32); + S11 cloneS11 = Helper.NewS11((int*)32, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValOut14..."); + if (!MarshalStructAsParam_AsSeqByValOut14(sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValOut14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, cloneS11, "MarshalStructAsParam_AsSeqByValOut14")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByRefOut(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut..."); + if (!MarshalStructAsParam_AsSeqByRefOut(out source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, change_is, "MarshalStructAsParam_AsSeqByRefOut")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential change_ias = Helper.NewInnerArraySequential(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut2..."); + if (!MarshalStructAsParam_AsSeqByRefOut2(out source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, change_ias, "MarshalStructAsParam_AsSeqByRefOut2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential changeStr1 = Helper.NewCharSetAnsiSequential("change string", 'n'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut3..."); + if (!MarshalStructAsParam_AsSeqByRefOut3(out source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, changeStr1, "MarshalStructAsParam_AsSeqByRefOut3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential change_csus = Helper.NewCharSetUnicodeSequential("change string", 'n'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut4..."); + if (!MarshalStructAsParam_AsSeqByRefOut4(out source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, change_csus, "MarshalStructAsParam_AsSeqByRefOut4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential change_ns = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut6..."); + if (!MarshalStructAsParam_AsSeqByRefOut6(out source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, change_ns, "MarshalStructAsParam_AsSeqByRefOut6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 changeS3 = Helper.NewS3(false, "change string", icarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut7..."); + if (!MarshalStructAsParam_AsSeqByRefOut7(out sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, changeS3, "MarshalStructAsParam_AsSeqByRefOut7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumch = Enum1.e2; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 changeS5 = Helper.NewS5(64, "change string", enumch); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut8..."); + if (!MarshalStructAsParam_AsSeqByRefOut8(out sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, changeS5, "MarshalStructAsParam_AsSeqByRefOut8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut9..."); + if (!MarshalStructAsParam_AsSeqByRefOut9(out source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, change_sssa, "MarshalStructAsParam_AsSeqByRefOut9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode change_sssu = Helper.NewStringStructSequentialUnicode(strTwo, strOne); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut10..."); + if (!MarshalStructAsParam_AsSeqByRefOut10(out source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, change_sssu, "MarshalStructAsParam_AsSeqByRefOut10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut11..."); + if (!MarshalStructAsParam_AsSeqByRefOut11(out sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, changeS8, "MarshalStructAsParam_AsSeqByRefOut11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut12..."); + if (!MarshalStructAsParam_AsSeqByRefOut12(out sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut12.Expected:True;Actual:False"); + failures++; + } + else if (sourceS9.i32 != 256 || sourceS9.myDelegate1 == null) + { + Console.WriteLine("\tFAILED! Native to Managed failed in MarshalStructAsParam_AsSeqByRefOut12."); + failures++; + } + else + { + Console.WriteLine("\tPASSED!"); + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut13..."); + if (!MarshalStructAsParam_AsSeqByRefOut13(out sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, changeIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByRefOut13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 changeS11 = Helper.NewS11((int*)(32), 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefOut14..."); + if (!MarshalStructAsParam_AsSeqByRefOut14(out sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefOut14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, changeS11, "MarshalStructAsParam_AsSeqByRefOut14")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByValInOut(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential clone_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut..."); + if (!MarshalStructAsParam_AsSeqByValInOut(source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, clone_is, "MarshalStructAsParam_AsSeqByValInOut")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential clone_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut2..."); + if (!MarshalStructAsParam_AsSeqByValInOut2(source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, clone_ias, "MarshalStructAsParam_AsSeqByValInOut2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential clone_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut3..."); + if (!MarshalStructAsParam_AsSeqByValInOut3(source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, clone_csas, "MarshalStructAsParam_AsSeqByValInOut3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential clone_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut4..."); + if (!MarshalStructAsParam_AsSeqByValInOut4(source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, clone_csus, "MarshalStructAsParam_AsSeqByValInOut4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential clone_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut6..."); + if (!MarshalStructAsParam_AsSeqByValInOut6(source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, clone_ns, "MarshalStructAsParam_AsSeqByValInOut6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 cloneS3 = Helper.NewS3(true, "some string", iarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut7..."); + if (!MarshalStructAsParam_AsSeqByValInOut7(sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, cloneS3, "MarshalStructAsParam_AsSeqByValInOut7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumcl = Enum1.e1; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 cloneS5 = Helper.NewS5(32, "some string", enumcl); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut8..."); + if (!MarshalStructAsParam_AsSeqByValInOut8(sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, cloneS5, "MarshalStructAsParam_AsSeqByValInOut8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi clone_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut9..."); + if (!MarshalStructAsParam_AsSeqByValInOut9(source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, clone_sssa, "MarshalStructAsParam_AsSeqByValInOut9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode clone_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut10..."); + if (!MarshalStructAsParam_AsSeqByValInOut10(source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, clone_sssu, "MarshalStructAsParam_AsSeqByValInOut10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 cloneS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut11..."); + if (!MarshalStructAsParam_AsSeqByValInOut11(sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, cloneS8, "MarshalStructAsParam_AsSeqByValInOut11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 cloneS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut12..."); + if (!MarshalStructAsParam_AsSeqByValInOut12(sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, cloneS9, "MarshalStructAsParam_AsSeqByValInOut12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential cloneIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut13..."); + if (!MarshalStructAsParam_AsSeqByValInOut13(sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, cloneIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByValInOut13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 cloneS11 = Helper.NewS11((int*)new Int64(), 32); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByValInOut14..."); + if (!MarshalStructAsParam_AsSeqByValInOut14(sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByValInOut14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, cloneS11, "MarshalStructAsParam_AsSeqByValInOut14")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + + } + + [SecuritySafeCritical] + unsafe private static void MarshalStructAsParam_AsSeqByRefInOut(StructID id) + { + try + { + switch (id) + { + case StructID.InnerSequentialId: + InnerSequential source_is = Helper.NewInnerSequential(1, 1.0F, "some string"); + InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut..."); + if (!MarshalStructAsParam_AsSeqByRefInOut(ref source_is)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerSequential(source_is, change_is, "MarshalStructAsParam_AsSeqByRefInOut")) + { + failures++; + } + break; + case StructID.InnerArraySequentialId: + InnerArraySequential source_ias = Helper.NewInnerArraySequential(1, 1.0F, "some string"); + InnerArraySequential change_ias = Helper.NewInnerArraySequential(77, 77.0F, "changed string"); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut2..."); + if (!MarshalStructAsParam_AsSeqByRefInOut2(ref source_ias)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut2.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateInnerArraySequential(source_ias, change_ias, "MarshalStructAsParam_AsSeqByRefInOut2")) + { + failures++; + } + break; + case StructID.CharSetAnsiSequentialId: + CharSetAnsiSequential source_csas = Helper.NewCharSetAnsiSequential("some string", 'c'); + CharSetAnsiSequential changeStr1 = Helper.NewCharSetAnsiSequential("change string", 'n'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut3..."); + if (!MarshalStructAsParam_AsSeqByRefInOut3(ref source_csas)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut3.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetAnsiSequential(source_csas, changeStr1, "MarshalStructAsParam_AsSeqByRefInOut3")) + { + failures++; + } + break; + case StructID.CharSetUnicodeSequentialId: + CharSetUnicodeSequential source_csus = Helper.NewCharSetUnicodeSequential("some string", 'c'); + CharSetUnicodeSequential change_csus = Helper.NewCharSetUnicodeSequential("change string", 'n'); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut4..."); + if (!MarshalStructAsParam_AsSeqByRefInOut4(ref source_csus)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut4.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateCharSetUnicodeSequential(source_csus, change_csus, "MarshalStructAsParam_AsSeqByRefInOut4")) + { + failures++; + } + break; + case StructID.NumberSequentialId: + NumberSequential source_ns = Helper.NewNumberSequential(Int32.MinValue, UInt32.MaxValue, short.MinValue, ushort.MaxValue, byte.MinValue, sbyte.MaxValue, Int16.MinValue, UInt16.MaxValue, -1234567890, 1234567890, 32.0F, 3.2); + NumberSequential change_ns = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut6..."); + if (!MarshalStructAsParam_AsSeqByRefInOut6(ref source_ns)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut6.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateNumberSequential(source_ns, change_ns, "MarshalStructAsParam_AsSeqByRefInOut6")) + { + failures++; + } + break; + case StructID.S3Id: + int[] iarr = new int[256]; + int[] icarr = new int[256]; + InitialArray(iarr, icarr); + + S3 sourceS3 = Helper.NewS3(true, "some string", iarr); + S3 changeS3 = Helper.NewS3(false, "change string", icarr); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut7..."); + if (!MarshalStructAsParam_AsSeqByRefInOut7(ref sourceS3)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut7.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS3(sourceS3, changeS3, "MarshalStructAsParam_AsSeqByRefInOut7")) + { + failures++; + } + break; + case StructID.S5Id: + Enum1 enums = Enum1.e1; + Enum1 enumch = Enum1.e2; + S5 sourceS5 = Helper.NewS5(32, "some string", enums); + S5 changeS5 = Helper.NewS5(64, "change string", enumch); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut8..."); + if (!MarshalStructAsParam_AsSeqByRefInOut8(ref sourceS5)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut8.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS5(sourceS5, changeS5, "MarshalStructAsParam_AsSeqByRefInOut8")) + { + failures++; + } + break; + case StructID.StringStructSequentialAnsiId: + strOne = new String('a', 512); + strTwo = new String('b', 512); + StringStructSequentialAnsi source_sssa = Helper.NewStringStructSequentialAnsi(strOne, strTwo); + StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut9..."); + if (!MarshalStructAsParam_AsSeqByRefInOut9(ref source_sssa)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut9.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialAnsi(source_sssa, change_sssa, "MarshalStructAsParam_AsSeqByRefInOut9")) + { + failures++; + } + break; + case StructID.StringStructSequentialUnicodeId: + strOne = new String('a', 256); + strTwo = new String('b', 256); + StringStructSequentialUnicode source_sssu = Helper.NewStringStructSequentialUnicode(strOne, strTwo); + StringStructSequentialUnicode change_sssu = Helper.NewStringStructSequentialUnicode(strTwo, strOne); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut10..."); + if (!MarshalStructAsParam_AsSeqByRefInOut10(ref source_sssu)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut10.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateStringStructSequentialUnicode(source_sssu, change_sssu, "MarshalStructAsParam_AsSeqByRefInOut10")) + { + failures++; + } + break; + case StructID.S8Id: + S8 sourceS8 = Helper.NewS8("hello", true, 10, 128, 128, 32); + S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut11..."); + if (!MarshalStructAsParam_AsSeqByRefInOut11(ref sourceS8)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut11.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS8(sourceS8, changeS8, "MarshalStructAsParam_AsSeqByRefInOut11")) + { + failures++; + } + break; + case StructID.S9Id: + S9 sourceS9 = Helper.NewS9(128, new TestDelegate1(testMethod)); + S9 changeS9 = Helper.NewS9(256, null); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut12..."); + if (!MarshalStructAsParam_AsSeqByRefInOut12(ref sourceS9)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut12.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS9(sourceS9, changeS9, "MarshalStructAsParam_AsSeqByRefInOut12")) + { + failures++; + } + break; + case StructID.IncludeOuterIntergerStructSequentialId: + IncludeOuterIntergerStructSequential sourceIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(32, 32); + IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut13..."); + if (!MarshalStructAsParam_AsSeqByRefInOut13(ref sourceIncludeOuterIntergerStructSequential)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut13.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateIncludeOuterIntergerStructSequential(sourceIncludeOuterIntergerStructSequential, changeIncludeOuterIntergerStructSequential, "MarshalStructAsParam_AsSeqByRefInOut13")) + { + failures++; + } + break; + case StructID.S11Id: + S11 sourceS11 = Helper.NewS11((int*)new Int32(), 32); + S11 changeS11 = Helper.NewS11((int*)(32), 64); + + Console.WriteLine("\tCalling MarshalStructAsParam_AsSeqByRefInOut14..."); + if (!MarshalStructAsParam_AsSeqByRefInOut14(ref sourceS11)) + { + Console.WriteLine("\tFAILED! Managed to Native failed in MarshalStructAsParam_AsSeqByRefInOut14.Expected:True;Actual:False"); + failures++; + } + if (!Helper.ValidateS11(sourceS11, changeS11, "MarshalStructAsParam_AsSeqByRefInOut14")) + { + failures++; + } + break; + default: + Console.WriteLine("\tThere is not the struct id"); + failures++; + break; + } + } + catch (Exception e) + { + Console.WriteLine("Unexpected Exception:" + e.ToString()); + failures++; + } + } + #endregion + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByVal() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByVal"); +#if _BUG_MARSHALSTRUCTSEQ + //MarshalStructAsParam_AsSeqByVal(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByVal(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByVal(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByVal(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByVal(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + //MarshalStructAsParam_AsSeqByVal(StructID.S3Id); + //MarshalStructAsParam_AsSeqByVal(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByVal(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByVal(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByVal(StructID.S8Id); + MarshalStructAsParam_AsSeqByVal(StructID.S9Id); + MarshalStructAsParam_AsSeqByVal(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByVal(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByRef() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByRef"); +#if _BUG_MARSHALSTRUCTSEQ + //MarshalStructAsParam_AsSeqByRef(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByRef(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByRef(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByRef(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByRef(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + //MarshalStructAsParam_AsSeqByRef(StructID.S3Id); + //MarshalStructAsParam_AsSeqByRef(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByRef(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByRef(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByRef(StructID.S8Id); + MarshalStructAsParam_AsSeqByRef(StructID.S9Id); + MarshalStructAsParam_AsSeqByRef(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByRef(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByValIn() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByValIn"); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByValIn(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByValIn(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByValIn(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByValIn(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByValIn(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByValIn(StructID.S3Id); + MarshalStructAsParam_AsSeqByValIn(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByValIn(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByValIn(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByValIn(StructID.S8Id); + MarshalStructAsParam_AsSeqByValIn(StructID.S9Id); + MarshalStructAsParam_AsSeqByValIn(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByValIn(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByRefIn() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByRefIn"); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByRefIn(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByRefIn(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByRefIn(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByRefIn(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByRefIn(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByRefIn(StructID.S3Id); + MarshalStructAsParam_AsSeqByRefIn(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByRefIn(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByRefIn(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByRefIn(StructID.S8Id); + MarshalStructAsParam_AsSeqByRefIn(StructID.S9Id); + MarshalStructAsParam_AsSeqByRefIn(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByRefIn(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByValOut() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByValOut"); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByValOut(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByValOut(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByValOut(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByValOut(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByValOut(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByValOut(StructID.S3Id); + MarshalStructAsParam_AsSeqByValOut(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByValOut(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByValOut(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByValOut(StructID.S8Id); + MarshalStructAsParam_AsSeqByValOut(StructID.S9Id); + MarshalStructAsParam_AsSeqByValOut(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByValOut(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByRefOut() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByRefOut"); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByRefOut(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByRefOut(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByRefOut(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByRefOut(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByRefOut(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByRefOut(StructID.S3Id); + MarshalStructAsParam_AsSeqByRefOut(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByRefOut(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByRefOut(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByRefOut(StructID.S8Id); + MarshalStructAsParam_AsSeqByRefOut(StructID.S9Id); + MarshalStructAsParam_AsSeqByRefOut(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByRefOut(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByValInOut() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByValInOut"); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByValInOut(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByValInOut(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByValInOut(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByValInOut(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByValInOut(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByValInOut(StructID.S3Id); + MarshalStructAsParam_AsSeqByValInOut(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByValInOut(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByValInOut(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByValInOut(StructID.S8Id); + MarshalStructAsParam_AsSeqByValInOut(StructID.S9Id); + MarshalStructAsParam_AsSeqByValInOut(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByValInOut(StructID.S11Id); + } + + [SecuritySafeCritical] + private static void RunMarshalSeqStructAsParamByRefInOut() + { + Console.WriteLine("\nVerify marshal sequential layout struct as param as ByRefInOut"); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByRefInOut(StructID.InnerSequentialId); +#endif + MarshalStructAsParam_AsSeqByRefInOut(StructID.InnerArraySequentialId); + MarshalStructAsParam_AsSeqByRefInOut(StructID.CharSetAnsiSequentialId); + MarshalStructAsParam_AsSeqByRefInOut(StructID.CharSetUnicodeSequentialId); + MarshalStructAsParam_AsSeqByRefInOut(StructID.NumberSequentialId); +#if _BUG_MARSHALSTRUCTSEQ + MarshalStructAsParam_AsSeqByRefInOut(StructID.S3Id); + MarshalStructAsParam_AsSeqByRefInOut(StructID.S5Id); +#endif + MarshalStructAsParam_AsSeqByRefInOut(StructID.StringStructSequentialAnsiId); + MarshalStructAsParam_AsSeqByRefInOut(StructID.StringStructSequentialUnicodeId); + MarshalStructAsParam_AsSeqByRefInOut(StructID.S8Id); + MarshalStructAsParam_AsSeqByRefInOut(StructID.S9Id); + MarshalStructAsParam_AsSeqByRefInOut(StructID.IncludeOuterIntergerStructSequentialId); + MarshalStructAsParam_AsSeqByRefInOut(StructID.S11Id); + } +} + + +
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq.csproj b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq.csproj new file mode 100644 index 0000000000..868a701603 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq.csproj @@ -0,0 +1,50 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" /> + <PropertyGroup> + <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> + <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform> + <AssemblyName>MarshalStructAsLayoutSeq</AssemblyName> + <SchemaVersion>2.0</SchemaVersion> + <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid> + <OutputType>exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <FileAlignment>512</FileAlignment> + <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids> + <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\11.0\UITestExtensionPackages</ReferencePath> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\</SolutionDir> + <AllowUnsafeBlocks>true</AllowUnsafeBlocks> + <NuGetPackageImportStamp>7a9bfb7d</NuGetPackageImportStamp> + <DefineConstants>$(DefineConstants);STATIC</DefineConstants> + </PropertyGroup> + <!-- Default configurations to help VS understand the configurations --> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'"> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'"> + </PropertyGroup> + <ItemGroup> + <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies"> + <Visible>False</Visible> + </CodeAnalysisDependentAssemblyPaths> + </ItemGroup> + <ItemGroup> + <Compile Include="MarshalStructAsLayoutSeq.cs" /> + <Compile Include="Struct.cs" /> + <Compile Include="Helper.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="project.json" /> + </ItemGroup> + <ItemGroup> + <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\..\..\Common\CoreCLRTestLibrary\CoreCLRTestLibrary.csproj"> + <Project>{c8c0dc74-fac4-45b1-81fe-70c4808366e0}</Project> + <Name>CoreCLRTestLibrary</Name> + </ProjectReference> + <ProjectReference Include="CMakeLists.txt"> + </ProjectReference> + </ItemGroup> + <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" /> +</Project>
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsParamDLL.cpp b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsParamDLL.cpp new file mode 100644 index 0000000000..fe9ceeaa40 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsParamDLL.cpp @@ -0,0 +1,1145 @@ +#include "MarshalStructAsParamDLL.h" + +/////////////////////////////////////////////////////////////////////////////////// +// EXPORTED METHODS +/////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal(InnerSequential inner) +{ + if(!IsCorrectInnerSequential(&inner)) + { + printf("\tMarshalStructAsParam_AsSeqByVal: InnerSequential param not as expected\n"); + PrintInnerSequential(&inner,"inner"); + return FALSE; + } + ChangeInnerSequential(&inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef(InnerSequential* inner) +{ + if(!IsCorrectInnerSequential(inner)) + { + printf("\tMarshalStructAsParam_AsSeqByRef: InnerSequential param not as expected\n"); + PrintInnerSequential(inner,"inner"); + return FALSE; + } + ChangeInnerSequential(inner); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn(InnerSequential* inner) +{ + if(!IsCorrectInnerSequential(inner)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn: InnerSequential param not as expected\n"); + PrintInnerSequential(inner,"inner"); + return FALSE; + } + ChangeInnerSequential(inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut(InnerSequential inner) +{ + if(!IsCorrectInnerSequential(&inner)) + { + printf("\tMarshalStructAsParam_AsSeqByValOut:NNER param not as expected\n"); + PrintInnerSequential(&inner,"inner"); + return FALSE; + } + ChangeInnerSequential(&inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut(InnerSequential* inner) +{ + ChangeInnerSequential(inner); + return TRUE; +} + +/////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal2(InnerArraySequential outer) +{ + if(!IsCorrectInnerArraySequential(&outer)) + { + printf("\tMarshalStructAsParam_AsSeqByVal2: InnerArraySequential param not as expected\n"); + PrintInnerArraySequential(&outer,"outer"); + return FALSE; + } + ChangeInnerArraySequential(&outer); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef2(InnerArraySequential* outer) +{ + if(!IsCorrectInnerArraySequential(outer)) + { + printf("\tMarshalStructAsParam_AsSeqByRef2: InnerArraySequential param not as expected\n"); + PrintInnerArraySequential(outer,"outer"); + return FALSE; + } + ChangeInnerArraySequential(outer); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn2(InnerArraySequential* outer) +{ + if(!IsCorrectInnerArraySequential(outer)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn2: InnerArraySequential param not as expected\n"); + PrintInnerArraySequential(outer,"inner"); + return FALSE; + } + ChangeInnerArraySequential(outer); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut2(InnerArraySequential outer) +{ + if(!IsCorrectInnerArraySequential(&outer)) + { + printf("\tMarshalStructAsParam_AsSeqByVal2:InnerArraySequential param not as expected\n"); + PrintInnerArraySequential(&outer,"outer"); + return FALSE; + } + for(int i = 0; i < NumArrElements; i++) + { + outer.arr[i].f1 = 77; + outer.arr[i].f2 = 77.0; + } + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut2(InnerArraySequential* outer) +{ + for(int i = 0;i<NumArrElements;i++) + { + if(outer->arr[i].f1 != 0 || outer->arr[i].f2 != 0.0) + { + printf("\tMarshalStructAsParam_AsSeqByRefOut2: InnerArraySequential param not as expected\n"); + return FALSE; + } + } + ChangeInnerArraySequential(outer); + return TRUE; +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal3(CharSetAnsiSequential str1) +{ + if(!IsCorrectCharSetAnsiSequential(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal3:strCharStr param not as expected\n"); + PrintCharSetAnsiSequential(&str1,"CharSetAnsiSequential"); + return FALSE; + } + ChangeCharSetAnsiSequential(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef3(CharSetAnsiSequential* str1) +{ + if(!IsCorrectCharSetAnsiSequential(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef3:strCharStr param not as expected\n"); + PrintCharSetAnsiSequential(str1,"CharSetAnsiSequential"); + return FALSE; + } + ChangeCharSetAnsiSequential(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn3(CharSetAnsiSequential* str1) +{ + if(!IsCorrectCharSetAnsiSequential(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn3:strCharStr param not as expected\n"); + PrintCharSetAnsiSequential(str1,"CharSetAnsiSequential"); + return FALSE; + } + ChangeCharSetAnsiSequential(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut3(CharSetAnsiSequential str1) +{ + if(!IsCorrectCharSetAnsiSequential(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal3:strCharStr param not as expected\n"); + PrintCharSetAnsiSequential(&str1,"CharSetAnsiSequential"); + return FALSE; + } + str1.f2 = 'n'; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut3(CharSetAnsiSequential* str1) +{ + char const* strSource = "change string"; + int len = strlen(strSource); + LPCSTR temp = (LPCSTR)TP_CoTaskMemAlloc((sizeof(char)*len)+1); + if(temp != NULL) + { + TP_CoTaskMemFree((void*)(str1->f1)); + strcpy((char*)temp,strSource); + str1->f1 = temp; + str1->f2 = 'n'; + return TRUE; + } + else + { + printf("Memory Allocated Failed !"); + return FALSE; + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal4(CharSetUnicodeSequential str1) +{ + if(!IsCorrectCharSetUnicodeSequential(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal4:CharSetUnicodeSequential param not as expected\n"); + PrintCharSetUnicodeSequential(&str1,"CharSetUnicodeSequential"); + return FALSE; + } + ChangeCharSetUnicodeSequential(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef4(CharSetUnicodeSequential* str1) +{ + if(!IsCorrectCharSetUnicodeSequential(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef4:strCharStr param not as expected\n"); + PrintCharSetUnicodeSequential(str1,"CharSetUnicodeSequential"); + return FALSE; + } + ChangeCharSetUnicodeSequential(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn4(CharSetUnicodeSequential* str1) +{ + if(!IsCorrectCharSetUnicodeSequential(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn4:strCharStr param not as expected\n"); + PrintCharSetUnicodeSequential(str1,"CharSetUnicodeSequential"); + return FALSE; + } + ChangeCharSetUnicodeSequential(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut4(CharSetUnicodeSequential str1) +{ + if(!IsCorrectCharSetUnicodeSequential(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal4:strCharStrOut2 param not as expected\n"); + PrintCharSetUnicodeSequential(&str1,"CharSetUnicodeSequential"); + return FALSE; + } + str1.f2 = L'n'; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut4(CharSetUnicodeSequential* str1) +{ + if(str1->f1 != 0 || str1->f2 != 0) + return false; + ChangeCharSetUnicodeSequential(str1); + return true; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal6(NumberSequential str1) +{ + if(!IsCorrectNumberSequential(&str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByVal6:NumberSequential param not as expected\n"); + PrintNumberSequential(&str1, "str1"); + return FALSE; + } + ChangeNumberSequential(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef6(NumberSequential* str1) +{ + if(!IsCorrectNumberSequential(str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByRef6:NumberSequential param not as expected\n"); + PrintNumberSequential(str1, "str1"); + return FALSE; + } + ChangeNumberSequential(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn6(NumberSequential* str1) +{ + if(!IsCorrectNumberSequential(str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByRefIn6:NumberSequential param not as expected\n"); + PrintNumberSequential(str1, "str1"); + return FALSE; + } + ChangeNumberSequential(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut6(NumberSequential str1) +{ + if(!IsCorrectNumberSequential(&str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByValOut6:NumberSequential param not as expected\n"); + PrintNumberSequential(&str1, "str1"); + return FALSE; + } + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut6(NumberSequential* str1) +{ + ChangeNumberSequential(str1); + return TRUE; +} + +//////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal7(S3 str1) +{ + if(!IsCorrectS3(&str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByVal7:S3 param not as expected\n"); + PrintS3(&str1, "str1"); + return FALSE; + } + ChangeS3(&str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef7(S3* str1) +{ + if(!IsCorrectS3(str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByRef7:S3 param not as expected\n"); + return FALSE; + } + ChangeS3(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn7(S3* str1) +{ + if(!IsCorrectS3(str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByRef7:S3 param not as expected\n"); + PrintS3(str1, "str1"); + return FALSE; + } + ChangeS3(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut7(S3 str1) +{ + if(!IsCorrectS3(&str1)) + { + printf("\tManaged to Native failed in MarshalStructAsParam_AsSeqByValOut7:S3 param not as expected\n"); + PrintS3(&str1, "str1"); + return FALSE; + } + str1.flag = false; + return TRUE; + +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut7(S3* str1) +{ + ChangeS3(str1); + return TRUE; +} +//////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal8(S5 str1) +{ + if(!IsCorrectS5(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal8:S5 param not as expected\n"); + PrintS5(&str1, "str1"); + return FALSE; + } + ChangeS5(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef8(S5* str1) +{ + if(!IsCorrectS5(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef8:S5 param not as expected\n"); + PrintS5(str1, "str1"); + return FALSE; + } + ChangeS5(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn8(S5* str1) +{ + if(!IsCorrectS5(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn8:S5 param not as expected\n"); + PrintS5(str1, "str1"); + return FALSE; + } + ChangeS5(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut8(S5* str1) +{ + ChangeS5(str1); + return TRUE; +} + + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal9(StringStructSequentialAnsi str1) +{ + if(!IsCorrectStringStructSequentialAnsi(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal9:StringStructSequentialAnsi param not as expected\n"); + PrintStringStructSequentialAnsi(&str1, "str1"); + return FALSE; + } + ChangeStringStructSequentialAnsi(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef9(StringStructSequentialAnsi* str1) +{ + if(!IsCorrectStringStructSequentialAnsi(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef9:StringStructSequentialAnsi param not as expected\n"); + PrintStringStructSequentialAnsi(str1, "str1"); + return FALSE; + } + ChangeStringStructSequentialAnsi(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn9(StringStructSequentialAnsi* str1) +{ + if(!IsCorrectStringStructSequentialAnsi(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn9:StringStructSequentialAnsi param not as expected\n"); + PrintStringStructSequentialAnsi(str1, "str1"); + return FALSE; + } + ChangeStringStructSequentialAnsi(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut9(StringStructSequentialAnsi str1) +{ + if(!IsCorrectStringStructSequentialAnsi(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal9:StringStructSequentialAnsi param not as expected\n"); + PrintStringStructSequentialAnsi(&str1, "str1"); + return FALSE; + } + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut9(StringStructSequentialAnsi* str1) +{ + ChangeStringStructSequentialAnsi(str1); + + return TRUE; +} + + +///////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal10(StringStructSequentialUnicode str1) +{ + if(!IsCorrectStringStructSequentialUnicode(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal10:StringStructSequentialUnicode param not as expected\n"); + PrintStringStructSequentialUnicode(&str1, "str1"); + return FALSE; + } + ChangeStringStructSequentialUnicode(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef10(StringStructSequentialUnicode* str1) +{ + if(!IsCorrectStringStructSequentialUnicode(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef10:StringStructSequentialUnicode param not as expected\n"); + PrintStringStructSequentialUnicode(str1, "str1"); + return FALSE; + } + ChangeStringStructSequentialUnicode(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn10(StringStructSequentialUnicode* str1) +{ + if(!IsCorrectStringStructSequentialUnicode(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn10:StringStructSequentialUnicode param not as expected\n"); + PrintStringStructSequentialUnicode(str1, "str1"); + return FALSE; + } + ChangeStringStructSequentialUnicode(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut10(StringStructSequentialUnicode str1) +{ + if(!IsCorrectStringStructSequentialUnicode(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByValOut10:StringStructSequentialUnicode param not as expected\n"); + PrintStringStructSequentialUnicode(&str1, "str1"); + return FALSE; + } + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut10(StringStructSequentialUnicode* str1) +{ + ChangeStringStructSequentialUnicode(str1); + + return TRUE; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal11(S8 str1) +{ + if(!IsCorrectS8(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal11:S8 param not as expected\n"); + PrintS8(&str1,"str1"); + return FALSE; + } + ChangeS8(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef11(S8* str1) +{ + if(!IsCorrectS8(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef11:S8 param not as expected\n"); + PrintS8(str1,"str1"); + return FALSE; + } + ChangeS8(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn11(S8* str1) +{ + if(!IsCorrectS8(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn11:S8 param not as expected\n"); + PrintS8(str1,"str1"); + return FALSE; + } + ChangeS8(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut11(S8 str1) +{ + if(!IsCorrectS8(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByValOut11:S8 param not as expected\n"); + PrintS8(&str1,"str1"); + return FALSE; + } + str1.i32 = 256; + str1.ui32 = 256; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut11(S8* str1) +{ + ChangeS8(str1); + + return TRUE; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" void NtestMethod(S9 str1) +{ + printf("\tAction of the delegate"); +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal12(S9 str1) +{ + if(str1.i32 != 128 || + str1.myDelegate1 == NULL) + { + return FALSE; + } + str1.i32 = 256; + str1.myDelegate1 = NULL; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef12(S9* str1) +{ + if(str1->i32 != 128 || + str1->myDelegate1 == NULL) + { + return FALSE; + } + else + { + str1->i32 = 256; + str1->myDelegate1 = NULL; + } + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn12(S9* str1) +{ + if(str1->i32 != 128 || + str1->myDelegate1 == NULL) + { + return FALSE; + } + else + { + str1->i32 = 256; + str1->myDelegate1 = NULL; + } + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut12(S9 str1) +{ + if(str1.i32 != 128 || + str1.myDelegate1 == NULL) + { + return FALSE; + } + str1.i32 = 256; + str1.myDelegate1 = NULL; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut12(S9* str1) +{ + str1->i32 = 256; + str1->myDelegate1 = NtestMethod; + return TRUE; +} + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal13(S10 str1) +{ + if(!IsCorrectS10(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByVal13:S10 param not as expected\n"); + PrintS10(&str1, "str1"); + return FALSE; + } + ChangeS10(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef13(S10* str1) +{ + if(!IsCorrectS10(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRef13:S10 param not as expected\n"); + PrintS10(str1, "str1"); + return FALSE; + } + ChangeS10(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn13(S10* str1) +{ + if(!IsCorrectS10(str1)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn13:S10 param not as expected\n"); + PrintS10(str1, "str1"); + return FALSE; + } + ChangeS10(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut13(S10 str1) +{ + if(!IsCorrectS10(&str1)) + { + printf("\tMarshalStructAsParam_AsSeqByValOut13:S10 param not as expected\n"); + PrintS10(&str1, "str1"); + return FALSE; + } + str1.s.i = 64; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut13(S10* str1) +{ + ChangeS10(str1); + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByVal14(S11 str1) +{ + if( str1.i32 != 0 || str1.i != 32 ) + return FALSE; + str1.i32 = (LPINT)(long)(str1.i); + str1.i = 64; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRef14(S11* str1) +{ + if(str1->i32 != 0 || str1->i != 32) + return FALSE; + else + { + str1->i32 = (LPINT)(long)(str1->i); + str1->i = 64; + return TRUE; + } +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefIn14(S11* str1) +{ + if(str1->i32 != 0 || str1->i != 32) + return FALSE; + else + { + str1->i32 = (LPINT)(long)(str1->i); + str1->i = 64; + return TRUE; + } +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByValOut14(S11 str1) +{ + if( str1.i32 != (LPINT)32 || str1.i != 32 ) + return FALSE; + str1.i = 64; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsSeqByRefOut14(S11* str1) +{ + str1->i32 = (LPINT)(long)(str1->i); + str1->i = 64; + return TRUE; +} +////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValINNER2(INNER2 inner) +{ + if(!IsCorrectINNER2(&inner)) + { + printf("\tMarshalStructAsParam_AsSeqByVal: INNER param not as expected\n"); + PrintINNER2(&inner,"inner"); + return FALSE; + } + ChangeINNER2(&inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefINNER2(INNER2* inner) +{ + if(!IsCorrectINNER2(inner)) + { + printf("\tMarshalStructAsParam_AsSeqByRef: INNER param not as expected\n"); + PrintINNER2(inner,"inner"); + return FALSE; + } + ChangeINNER2(inner); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInINNER2(INNER2* inner) +{ + if(!IsCorrectINNER2(inner)) + { + printf("\tMarshalStructAsParam_AsSeqByRefIn: INNER param not as expected\n"); + PrintINNER2(inner,"inner"); + return FALSE; + } + ChangeINNER2(inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValOutINNER2(INNER2 inner) +{ + if(!IsCorrectINNER2(&inner)) + { + printf("\tMarshalStructAsParam_AsSeqByValOut:NNER param not as expected\n"); + PrintINNER2(&inner,"inner"); + return FALSE; + } + ChangeINNER2(&inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutINNER2(INNER2* inner) +{ + //change struct + ChangeINNER2(inner); + return TRUE; +} +///////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValInnerExplicit(InnerExplicit inner) +{ + if((&inner)->f1 != 1 || memcmp((&inner)->f3, "some string",11*sizeof(char)) != 0) + { + printf("\tMarshalStructAsParam_AsExpByVal: INNER param not as expected\n"); + PrintInnerExplicit(&inner,"inner"); + return FALSE; + } + ChangeInnerExplicit(&inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInnerExplicit(InnerExplicit* inner) +{ + if(inner->f1 != 1 || memcmp(inner->f3, "some string",11*sizeof(char)) != 0) + { + printf("\tMarshalStructAsParam_AsExpByRef: INNER param not as expected\n"); + PrintInnerExplicit(inner,"inner"); + return FALSE; + } + ChangeInnerExplicit(inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInInnerExplicit(InnerExplicit* inner) +{ + if(inner->f1 != 1 || memcmp(inner->f3, "some string",11*sizeof(char)) != 0) + { + printf("\tMarshalStructAsParam_AsExpByRefIn: INNER param not as expected\n"); + PrintInnerExplicit(inner,"inner"); + return FALSE; + } + ChangeInnerExplicit(inner); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutInnerExplicit(InnerExplicit* inner) +{ + if(inner->f1 != 0 || inner->f2 != 0.0) + { + printf("\tMarshalStructAsParam_AsExpByRefOut: INNER param not as expected\n"); + return FALSE; + } + ChangeInnerExplicit(inner); + return TRUE; +} + + + +//////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValInnerArrayExplicit(InnerArrayExplicit outer2) +{ + for(int i = 0;i<NumArrElements;i++) + { + if((&outer2)->arr[i].f1 != 1) + { + printf("\tMarshalStructAsParam_AsExpByVal3:InnerArrayExplicit param not as expected\n"); + return FALSE; + } + } + if(memcmp((&outer2)->f4,"some string2",12) != 0) + { + printf("\tMarshalStructAsParam_AsExpByVal3:InnerArrayExplicit param f4 not as expected\n"); + return FALSE; + } + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInnerArrayExplicit(InnerArrayExplicit* outer2) +{ + for(int i = 0;i<NumArrElements;i++) + { + if(outer2->arr[i].f1 != 1) + { + printf("\tMarshalStructAsParam_AsExpByRef3:InnerArrayExplicit param not as expected\n"); + return FALSE; + } + } + if(memcmp(outer2->f4,"some string2",12) != 0) + { + printf("\tMarshalStructAsParam_AsExpByRef3:InnerArrayExplicit param f4 not as expected\n"); + return FALSE; + } + for(int i =0;i<NumArrElements;i++) + { + outer2->arr[i].f1 = 77; + } + char const * temp = "change string2"; + size_t len = strlen(temp); + LPCSTR str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + outer2->f4 = str; + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInInnerArrayExplicit(InnerArrayExplicit* outer2) +{ + for(int i = 0;i<NumArrElements;i++) + { + if(outer2->arr[i].f1 != 1) + { + printf("\tMarshalStructAsParam_AsExpByRefIn3:InnerArrayExplicit param not as expected\n"); + return FALSE; + } + } + if(memcmp(outer2->f4, "some string2",12*(sizeof(char))) != 0) + { + printf("\tMarshalStructAsParam_AsExpByRefIn3:InnerArrayExplicit param f4 not as expected\n"); + return FALSE; + } + for(int i =0;i<NumArrElements;i++) + { + outer2->arr[i].f1 = 77; + } + char const * temp = "change string2"; + size_t len = strlen(temp); + LPCSTR str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + outer2->f4 = str; + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutInnerArrayExplicit(InnerArrayExplicit* outer2) +{ + for(int i =0;i<NumArrElements;i++) + { + outer2->arr[i].f1 = 77; + } + char const * temp = "change string2"; + size_t len = strlen(temp); + LPCSTR str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + outer2->f4 = str; + return TRUE; +} + + +//////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValOUTER3(OUTER3 outer3) +{ + if(!IsCorrectOUTER3(&outer3)) + { + printf("\tMarshalStructAsParam_AsExoByVal4:OUTER3 param not as expected\n"); + PrintOUTER3(&outer3,"OUTER3"); + return FALSE; + } + ChangeOUTER3(&outer3); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOUTER3(OUTER3* outer3) +{ + if(!IsCorrectOUTER3(outer3)) + { + printf("\tMarshalStructAsParam_AsExoByRef4:OUTER3 param not as expected\n"); + PrintOUTER3(outer3,"OUTER3"); + return FALSE; + } + ChangeOUTER3(outer3); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInOUTER3(OUTER3* outer3) +{ + if(!IsCorrectOUTER3(outer3)) + { + printf("\tMarshalStructAsParam_AsExoByRefIn4:OUTER3 param not as expected\n"); + PrintOUTER3(outer3,"OUTER3"); + return FALSE; + } + ChangeOUTER3(outer3); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutOUTER3(OUTER3* outer3) +{ + ChangeOUTER3(outer3); + return TRUE; +} + +/////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValU(U str1) +{ + if(!IsCorrectU(&str1)) + { + printf("\tMarshalStructAsParam_AsExpByVal6:U param not as expected\n"); + PrintU(&str1, "str1"); + return FALSE; + } + ChangeU(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefU(U* str1) +{ + if(!IsCorrectU(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRef6:U param not as expected\n"); + PrintU(str1, "str1"); + return FALSE; + } + ChangeU(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInU(U* str1) +{ + if(!IsCorrectU(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRefIn6:U param not as expected\n"); + PrintU(str1, "str1"); + return FALSE; + } + ChangeU(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutU(U* str1) +{ + ChangeU(str1); + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValByteStructPack2Explicit(ByteStructPack2Explicit str1) +{ + if(!IsCorrectByteStructPack2Explicit(&str1)) + { + printf("\tMarshalStructAsParam_AsExpByVal7:ByteStructPack2Explicit param not as expected\n"); + PrintByteStructPack2Explicit(&str1, "str1"); + return FALSE; + } + ChangeByteStructPack2Explicit(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefByteStructPack2Explicit(ByteStructPack2Explicit* str1) +{ + if(!IsCorrectByteStructPack2Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRef7:ByteStructPack2Explicit param not as expected\n"); + PrintByteStructPack2Explicit(str1, "str1"); + return FALSE; + } + ChangeByteStructPack2Explicit(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInByteStructPack2Explicit(ByteStructPack2Explicit* str1) +{ + if(!IsCorrectByteStructPack2Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRefIn7:ByteStructPack2Explicit param not as expected\n"); + PrintByteStructPack2Explicit(str1, "str1"); + return FALSE; + } + ChangeByteStructPack2Explicit(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutByteStructPack2Explicit(ByteStructPack2Explicit* str1) +{ + ChangeByteStructPack2Explicit(str1); + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValShortStructPack4Explicit(ShortStructPack4Explicit str1) +{ + if(!IsCorrectShortStructPack4Explicit(&str1)) + { + printf("\tMarshalStructAsParam_AsExpByVal8:ShortStructPack4Explicit param not as expected\n"); + PrintShortStructPack4Explicit(&str1, "str1"); + return FALSE; + } + ChangeShortStructPack4Explicit(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefShortStructPack4Explicit(ShortStructPack4Explicit* str1) +{ + if(!IsCorrectShortStructPack4Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRef8:ShortStructPack4Explicit param not as expected\n"); + PrintShortStructPack4Explicit(str1, "str1"); + return FALSE; + } + ChangeShortStructPack4Explicit(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInShortStructPack4Explicit(ShortStructPack4Explicit* str1) +{ + if(!IsCorrectShortStructPack4Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRefIn8:ShortStructPack4Explicit param not as expected\n"); + PrintShortStructPack4Explicit(str1, "str1"); + return FALSE; + } + ChangeShortStructPack4Explicit(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutShortStructPack4Explicit(ShortStructPack4Explicit* str1) +{ + ChangeShortStructPack4Explicit(str1); + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValIntStructPack8Explicit(IntStructPack8Explicit str1) +{ + if(!IsCorrectIntStructPack8Explicit(&str1)) + { + printf("\tMarshalStructAsParam_AsExpByVal9:IntStructPack8Explicit param not as expected\n"); + PrintIntStructPack8Explicit(&str1, "str1"); + return FALSE; + } + ChangeIntStructPack8Explicit(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefIntStructPack8Explicit(IntStructPack8Explicit* str1) +{ + if(!IsCorrectIntStructPack8Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRef9:IntStructPack8Explicit param not as expected\n"); + PrintIntStructPack8Explicit(str1, "str1"); + return FALSE; + } + ChangeIntStructPack8Explicit(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInIntStructPack8Explicit(IntStructPack8Explicit* str1) +{ + if(!IsCorrectIntStructPack8Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRefIn9:IntStructPack8Explicit param not as expected\n"); + PrintIntStructPack8Explicit(str1, "str1"); + return FALSE; + } + ChangeIntStructPack8Explicit(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutIntStructPack8Explicit(IntStructPack8Explicit* str1) +{ + ChangeIntStructPack8Explicit(str1); + + return TRUE; +} + +////////////////////////////////////////////////////////////////////////////////////////////////////////// +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByValLongStructPack16Explicit(LongStructPack16Explicit str1) +{ + if(!IsCorrectLongStructPack16Explicit(&str1)) + { + printf("\tMarshalStructAsParam_AsExpByVal10:LongStructPack16Explicit param not as expected\n"); + PrintLongStructPack16Explicit(&str1, "str1"); + return FALSE; + } + ChangeLongStructPack16Explicit(&str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefLongStructPack16Explicit(LongStructPack16Explicit* str1) +{ + if(!IsCorrectLongStructPack16Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRef10:LongStructPack16Explicit param not as expected\n"); + PrintLongStructPack16Explicit(str1, "str1"); + return FALSE; + } + ChangeLongStructPack16Explicit(str1); + return TRUE; +} + +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefInLongStructPack16Explicit(LongStructPack16Explicit* str1) +{ + if(!IsCorrectLongStructPack16Explicit(str1)) + { + printf("\tMarshalStructAsParam_AsExpByRefIn10:LongStructPack16Explicit param not as expected\n"); + PrintLongStructPack16Explicit(str1, "str1"); + return FALSE; + } + ChangeLongStructPack16Explicit(str1); + return TRUE; +} +extern "C" DLL_EXPORT BOOL WINAPI MarshalStructAsParam_AsExpByRefOutLongStructPack16Explicit(LongStructPack16Explicit* str1) +{ + ChangeLongStructPack16Explicit(str1); + + return TRUE; +} + diff --git a/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsParamDLL.h b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsParamDLL.h new file mode 100644 index 0000000000..39af8a9c78 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/MarshalStructAsParamDLL.h @@ -0,0 +1,900 @@ +#include "platformdefines.cpp" +#include <xplatform.h> + +const int NumArrElements = 2; +struct InnerSequential +{ + int f1; + float f2; + LPCSTR f3; +}; +void PrintInnerSequential(InnerSequential* p, char const * name) +{ + printf("\t%s.f1 = %d\n", name, p->f1); + printf("\t%s.f2 = %f\n", name, p->f2); + printf("\t%s.f3 = %s\n", name, p->f3); +} + +void ChangeInnerSequential(InnerSequential* p) +{ + p->f1 = 77; + p->f2 = 77.0; + + char const * lpstr = "changed string"; + size_t size = sizeof(char) * (strlen(lpstr) + 1); + LPSTR temp = (LPSTR)TP_CoTaskMemAlloc( size ); + memset(temp, 0, size); + if(temp) + { + strcpy( (char*)temp, lpstr ); + p->f3 = temp; + } + else + { + printf("Memory Allocated Failed!"); + } +} + +bool IsCorrectInnerSequential(InnerSequential* p) +{ + if(p->f1 != 1) + return false; + if(p->f2 != 1.0) + return false; + + char const * lpstr = "some string"; + size_t size = sizeof(char) * (strlen(lpstr) + 1); + LPSTR temp = (LPSTR)TP_CoTaskMemAlloc( size ); + memset(temp, 0, size); + + if( strcmp((char*)p->f3, temp) != 0 ) + return false; + + return true; +} + +#ifndef WINDOWS +typedef int INT; +typedef unsigned int UINT; +typedef short SHORT; +typedef char CHAR; +typedef unsigned short WORD; +typedef short SHORT; +typedef float FLOAT; +typedef double DOUBLE; +#endif + +struct INNER2 // size = 12 bytes +{ + INT f1; + FLOAT f2; + LPCSTR f3; +}; +void ChangeINNER2(INNER2* p) +{ + p->f1 = 77; + p->f2 = 77.0; + char const * temp = "changed string"; + size_t len = strlen(temp); + LPCSTR str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + p->f3 = str; +} +void PrintINNER2(INNER2* p, char const * name) +{ + printf("\t%s.f1 = %d\n", name, p->f1); + printf("\t%s.f2 = %f\n", name, p->f2); + printf("\t%s.f3 = %s\n", name, p->f3); +} +bool IsCorrectINNER2(INNER2* p) +{ + if(p->f1 != 1) + return false; + if(p->f2 != 1.0) + return false; + if(memcmp(p->f3, "some string",11*sizeof(char)) != 0 ) + return false; + return true; +} + + +struct InnerExplicit +{ + #ifdef WINDOWS + union + { + INT f1; + FLOAT f2; + }; + CHAR _unused0[4]; + LPCSTR f3; + #endif + + #ifndef WINDOWS + union + { + INT f1; + FLOAT f2; + }; + INT _unused0; + LPCSTR f3; + #endif +}; + + +void PrintInnerExplicit(InnerExplicit* p, char const * name) +{ + printf("\t%s.f1 = %d\n", name, p->f1); + printf("\t%s.f2 = %f\n", name, p->f2); + printf("\t%s.f3 = %s\n", name, p->f3); +} + +void ChangeInnerExplicit(InnerExplicit* p) +{ + p->f1 = 77; + + char const * temp = "changed string"; + size_t len = strlen(temp); + LPCSTR str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + p->f3 = str; +} + +struct InnerArraySequential +{ + InnerSequential arr[NumArrElements]; +}; + +void PrintInnerArraySequential(InnerArraySequential* p, char const * name) +{ + for(int i = 0; i < NumArrElements; i++) + { + printf("\t%s.arr[%d].f1 = %d\n", name, i, (p->arr)[i].f1); + printf("\t%s.arr[%d].f2 = %f\n", name, i, (p->arr)[i].f2); + printf("\t%s.arr[%d].f3 = %s\n", name, i, (p->arr)[i].f3); + } +} + +void ChangeInnerArraySequential(InnerArraySequential* p) +{ + char const * lpstr = "changed string"; + LPSTR temp; + for(int i = 0; i < NumArrElements; i++) + { + (p->arr)[i].f1 = 77; + (p->arr)[i].f2 = 77.0; + + size_t size = sizeof(char) * (strlen(lpstr) + 1); + temp = (LPSTR)TP_CoTaskMemAlloc( size ); + memset(temp, 0, size); + if(temp) + { + strcpy( (char*)temp, lpstr ); + (p->arr)[i].f3 = temp; + } + else + { + printf("Memory Allocated Failed!"); + } + } +} + +bool IsCorrectInnerArraySequential(InnerArraySequential* p) +{ + for(int i = 0; i < NumArrElements; i++) + { + if( (p->arr)[i].f1 != 1 ) + return false; + if( (p->arr)[i].f2 != 1.0 ) + return false; + } + return true; +} + + +union InnerArrayExplicit // size = 32 bytes +{ + struct InnerSequential arr[2]; + struct + { + LONG64 _unused0; + LPCSTR f4; + }; + +}; + + +#ifdef WINDOWS + #ifdef _WIN64 + union OUTER3 // size = 32 bytes + { + struct InnerSequential arr[2]; + struct + { + CHAR _unused0[24]; + LPCSTR f4; + }; + }; + #else + struct OUTER3 // size = 28 bytes + { + struct InnerSequential arr[2]; + LPCSTR f4; + }; + #endif +#endif + +#ifndef WINDOWS + struct OUTER3 // size = 28 bytes + { + struct InnerSequential arr[2]; + LPCSTR f4; + }; +#endif + +void PrintOUTER3(OUTER3* p, char const * name) +{ + for(int i = 0; i < NumArrElements; i++) + { + printf("\t%s.arr[%d].f1 = %d\n", name, i, (p->arr)[i].f1); + printf("\t%s.arr[%d].f2 = %f\n", name, i, (p->arr)[i].f2); + printf("\t%s.arr[%d].f3 = %s\n", name, i, (p->arr)[i].f3); + } + printf("\t%s.f4 = %s\n",name,p->f4); +} +void ChangeOUTER3(OUTER3* p) +{ + char const * temp = "changed string"; + size_t len = strlen(temp); + LPCSTR str = NULL; + for(int i = 0; i < NumArrElements; i++) + { + (p->arr)[i].f1 = 77; + (p->arr)[i].f2 = 77.0; + + str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + (p->arr)[i].f3 = str; + } + + str = (LPCSTR)TP_CoTaskMemAlloc( sizeof(char)*(len+1) ); + strcpy((char*)str,temp); + p->f4 = str; +} +bool IsCorrectOUTER3(OUTER3* p) +{ + for(int i = 0; i < NumArrElements; i++) + { + if( (p->arr)[i].f1 != 1 ) + return false; + if( (p->arr)[i].f2 != 1.0 ) + return false; + if( memcmp((p->arr)[i].f3, "some string",11*sizeof(char)) != 0 ) + return false; + } + if(memcmp(p->f4,"some string",11*sizeof(char)) != 0) + { + return false; + } + return true; +} + +struct CharSetAnsiSequential +{ + LPCSTR f1; + char f2; +}; + +void PrintCharSetAnsiSequential(CharSetAnsiSequential* p, char const * name) +{ + printf("\t%s.f1 = %s\n", name, p->f1); + printf("\t%s.f2 = %c\n", name, p->f2); +} + +void ChangeCharSetAnsiSequential(CharSetAnsiSequential* p) +{ + char const * strSource = "change string"; + size_t size = strlen(strSource) + 1; + LPSTR temp = (LPSTR)TP_CoTaskMemAlloc(size); + if(temp != NULL) + { + strcpy((char*)temp,strSource); + p->f1 = temp; + p->f2 = 'n'; + } + else + { + printf("Memory Allocated Failed!"); + } +} + +bool IsCorrectCharSetAnsiSequential(CharSetAnsiSequential* p) +{ + if(strcmp((char*)p->f1, (char*)"some string") != 0 ) + return false; + if(p->f2 != 'c') + return false; + return true; +} + + +struct CharSetUnicodeSequential +{ + LPCWSTR f1; + WCHAR f2; +}; +void PrintCharSetUnicodeSequential(CharSetUnicodeSequential* p, char const * name) +{ + wprintf(L"\t%s.f1 = %S\n", name, p->f1); + printf("\t%s.f2 = %c\n", name, p->f2); +} + +void ChangeCharSetUnicodeSequential(CharSetUnicodeSequential* p) +{ +#ifdef _WIN32 + LPCWSTR strSource = L"change string"; +#else + LPCWSTR strSource = u"change string"; +#endif + int len = wcslen(strSource); + LPCWSTR temp = (LPCWSTR)TP_CoTaskMemAlloc(sizeof(WCHAR)*(len+1)); + if(temp != NULL) + { + wcscpy_s((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource); + p->f1 = temp; + p->f2 = L'n'; + } + else + { + printf("Memory Allocated Failed!"); + } +} + +bool IsCorrectCharSetUnicodeSequential(CharSetUnicodeSequential* p) +{ +#ifdef _WIN32 + LPCWSTR expected= L"some string"; +#else + LPCWSTR expected= u"some string"; +#endif + LPCWSTR actual = p->f1; + if(0 != TP_wcmp_s((WCHAR*)actual, (WCHAR*)expected)) + { + return false; + } + if(p->f2 != L'c') + { + return false; + } + return true; +} + + +struct NumberSequential // size = 64 bytes +{ + LONG64 i64; + ULONG64 ui64; + DOUBLE d; + INT i32; + UINT ui32; + SHORT s1; + WORD us1; + SHORT i16; + WORD ui16; + FLOAT sgl; + BYTE b; + CHAR sb; +}; +void PrintNumberSequential(NumberSequential* str, char const * name) +{ + printf("\t%s.i32 = %d\n", name, str->i32); + printf("\t%s.ui32 = %d\n", name, str->ui32); + printf("\t%s.s1 = %d\n", name, str->s1); + printf("\t%s.us1 = %u\n", name, str->us1); + printf("\t%s.b = %u\n", name, str->b); + printf("\t%s.sb = %d\n", name, str->sb); + printf("\t%s.i16 = %d\n", name, str->i16); + printf("\t%s.ui16 = %u\n", name, str->ui16); + printf("\t%s.i64 = %ld\n", name, str->i64); + printf("\t%s.ui64 = %lu\n", name, str->ui64); + printf("\t%s.sgl = %f\n", name, str->sgl); + printf("\t%s.d = %f\n",name, str->d); +} +void ChangeNumberSequential(NumberSequential* p) +{ + p->i32 = 0; + p->ui32 = 32; + p->s1 = 0; + p->us1 = 16; + p->b = 0; + p->sb = 8; + p->i16 = 0; + p->ui16 = 16; + p->i64 = 0; + p->ui64 = 64; + p->sgl = 64.0; + p->d = 6.4; +} + +bool IsCorrectNumberSequential(NumberSequential* p) +{ + if(p->i32 != -0x80000000 || p->ui32 != 0xffffffff || p->s1 != -0x8000 || p->us1 != 0xffff || p->b != 0 || + p->sb != 0x7f ||p->i16 != -0x8000 || p->ui16 != 0xffff || p->i64 != -1234567890 || + p->ui64 != 1234567890 || (p->sgl) != 32.0 || p->d != 3.2) + { + return false; + } + return true; +} + +struct S3 // size = 1032 bytes +{ + BOOL flag; + LPCSTR str; + INT vals[256]; +}; + +void PrintS3(S3* str, char const * name) +{ + printf("\t%s.flag = %d\n", name, str->flag); + printf("\t%s.str = %s\n", name, str->str); + for(int i = 0; i<256 ;i++) + { + printf("\t%s.vals[%d] = %d\n",name,i,str->vals[i]); + } +} + +void ChangeS3(S3* p) +{ + p->flag = false; + + char const * strSource = "change string"; + int len = strlen(strSource); + + LPCSTR temp = (LPCSTR)TP_CoTaskMemAlloc((sizeof(char)*len) + 1); + if(temp != NULL) + { + /*TP_CoTaskMemFree((void *)p->str);*/ + strcpy((char*)temp,strSource); + p->str = temp; + } + for(int i = 1;i<257;i++) + { + p->vals[i-1] = i; + } +} + +bool IsCorrectS3(S3* p) +{ + int iflag = 0; + + char const * lpstr = "some string"; + size_t size = sizeof(char) * (strlen(lpstr) + 1); + LPSTR temp = (LPSTR)TP_CoTaskMemAlloc( size ); + memset(temp, 0, size); + + if(!p->flag || strcmp((char*)p->str, temp) != 0) + return false; + for (int i = 0; i < 256; i++) + { + if (p->vals[i] != i) + { + printf("\tThe Index of %i is not expected",i); + iflag++; + } + } + if (iflag != 0) + { + return false; + } + return true; +} + +struct S4 // size = 8 bytes +{ + INT age; + LPCSTR name; +}; +enum Enum1 +{ + e1 = 1, + e2 = 3 +}; +struct S5 // size = 8 bytes +{ + struct S4 s4; + Enum1 ef; +}; + +void PrintS5(S5* str, char const * name) +{ + printf("\t%s.s4.age = %d", name, str->s4.age); + printf("\t%s.s4.name = %s", name, str->s4.name); + printf("\t%s.ef = %d", name, str->ef); +} +void ChangeS5(S5* str) +{ + Enum1 eInstance = e2; + char const * strSource = "change string"; + int len = strlen(strSource); + LPCSTR temp = (LPCSTR)TP_CoTaskMemAlloc(sizeof(char)*(len+1)); + if(temp != NULL) + { + strcpy((char*)temp,strSource); + str->s4.name = temp; + } + str->s4.age = 64; + str->ef = eInstance; +} +bool IsCorrectS5(S5* str) +{ + Enum1 eInstance = e1; + + char const * lpstr = "some string"; + size_t size = sizeof(char) * (strlen(lpstr) + 1); + LPSTR temp = (LPSTR)TP_CoTaskMemAlloc( size ); + memset(temp, 0, size); + + if(str->s4.age != 32 || strcmp((char*)str->s4.name, temp) != 0) + return false; + if(str->ef != eInstance) + { + return false; + } + return true; +} + +struct StringStructSequentialAnsi // size = 8 bytes +{ + LPCSTR first; + LPCSTR last; +}; + +void PrintStringStructSequentialAnsi(StringStructSequentialAnsi* str, char const * name) +{ + printf("\t%s.first = %s\n", name, str->first); + printf("\t%s.last = %s\n", name, str->last); +} + +bool IsCorrectStringStructSequentialAnsi(StringStructSequentialAnsi* str) +{ + char strOne[512]; + char strTwo[512]; + for(int i = 0;i<512;i++) + { + strOne[i] = 'a'; + strTwo[i] = 'b'; + } + + if(memcmp(str->first,strOne,512)!= 0) + return false; + + if(memcmp(str->last,strTwo,512)!= 0) + return false; + + return true; +} + +void ChangeStringStructSequentialAnsi(StringStructSequentialAnsi* str) +{ + char* newFirst = (char*)TP_CoTaskMemAlloc(sizeof(char)*513); + char* newLast = (char*)TP_CoTaskMemAlloc(sizeof(char)*513); + for (int i = 0; i < 512; ++i) + { + newFirst[i] = 'b'; + newLast[i] = 'a'; + } + newFirst[512] = '\0'; + newLast[512] = '\0'; + + str->first = newFirst; + str->last = newLast; +} + +struct StringStructSequentialUnicode // size = 8 bytes +{ + LPCWSTR first; + LPCWSTR last; +}; + +void PrintStringStructSequentialUnicode(StringStructSequentialUnicode* str, char const * name) +{ + wprintf(L"\t%s.first = %s\n", name, str->first); + wprintf(L"\t%s.last = %s\n", name, str->last); +} + +bool IsCorrectStringStructSequentialUnicode(StringStructSequentialUnicode* str) +{ + WCHAR strOne[256+1]; + WCHAR strTwo[256+1]; + + for(int i = 0;i<256;++i) + { + strOne[i] = L'a'; + strTwo[i] = L'b'; + } + strOne[256] = L'\0'; + strTwo[256] = L'\0'; + + if(memcmp(str->first,strOne,256*sizeof(WCHAR)) != 0) + return false; + if(memcmp(str->last,strTwo,256*sizeof(WCHAR)) != 0) + return false; + return true; +} + +void ChangeStringStructSequentialUnicode(StringStructSequentialUnicode* str) +{ + WCHAR* newFirst = (WCHAR*)TP_CoTaskMemAlloc(sizeof(WCHAR)*257); + WCHAR* newLast = (WCHAR*)TP_CoTaskMemAlloc(sizeof(WCHAR)*257); + for (int i = 0; i < 256; ++i) + { + newFirst[i] = L'b'; + newLast[i] = L'a'; + } + newFirst[256] = L'\0'; + newLast[256] = L'\0'; + str->first = (const WCHAR*)newFirst; + str->last = (const WCHAR*)newLast; +} + + +struct S8 // size = 32 bytes +{ + LPCSTR name; + BOOL gender; + INT i32; + UINT ui32; + WORD jobNum; + CHAR mySByte; +}; +void PrintS8(S8* str, char const * name) +{ + printf("\t%s.name = %s\n",name, str->name); + printf("\t%s.gender = %d\n", name, str->gender); + printf("\t%s.jobNum = %d\n",name, str->jobNum); + printf("\t%s.i32 = %d\n", name, str->i32); + printf("\t%s.ui32 = %u\n", name, str->ui32); + printf("\t%s.mySByte = %c\n", name, str->mySByte); +} +bool IsCorrectS8(S8* str) +{ + if(memcmp( str->name,"hello", strlen("hello")*sizeof(char)+1 )!= 0) + return false; + if(!str->gender) + return false; + if(str->jobNum != 10) + return false; + if(str->i32!= 128 || str->ui32 != 128) + return false; + if(str->mySByte != 32) + return false; + return true; +} + +void ChangeS8(S8* str) +{ + char const * lpstr = "world"; + size_t size = sizeof(char) * (strlen(lpstr) + 1); + LPSTR temp = (LPSTR)TP_CoTaskMemAlloc( size ); + memset(temp, 0, size); + if(temp) + { + strcpy( (char*)temp, lpstr ); + str->name = temp; + } + else + { + printf("Memory Allocated Failed!"); + } + str->gender = false; + str->jobNum = 1; + str->i32 = 256; + str->ui32 = 256; + str->mySByte = 64; +} +#pragma pack (8) +struct S_int // size = 4 bytes +{ + INT i; +}; + +struct S9; +typedef void (*TestDelegate1)(struct S9 myStruct); + +struct S9 // size = 8 bytes +{ + INT i32; + TestDelegate1 myDelegate1; +}; + +struct S101 // size = 8 bytes +{ + INT i; + struct S_int s_int; +}; + +struct S10 // size = 8 bytes +{ + struct S101 s; +}; +void PrintS10(S10* str, char const * name) +{ + printf("\t%s.s.s_int.i = %d\n", name, str->s.s_int.i); + printf("\t%s.s.i = %d\n", name, str->s.i); +} +bool IsCorrectS10(S10* str) +{ + if(str->s.s_int.i != 32) + return false; + if(str->s.i != 32) + return false; + return true; +} +void ChangeS10(S10* str) +{ + str->s.s_int.i = 64; + str->s.i = 64; +} + +#ifndef WINDOWS +typedef int* LPINT; +#endif + +struct S11 // size = 8 bytes +{ + LPINT i32; + INT i; +}; + +union U // size = 8 bytes +{ + INT i32; + UINT ui32; + LPVOID iPtr; + LPVOID uiPtr; + SHORT s; + WORD us; + BYTE b; + CHAR sb; + LONG64 l; + ULONG64 ul; + FLOAT f; + DOUBLE d; +}; + +void PrintU(U* str, char const * name) +{ + printf("\t%s.i32 = %d\n", name, str->i32); + printf("\t%s.ui32 = %u\n", name, str->ui32); + printf("\t%s.iPtr = %p\n", name, str->iPtr); + printf("\t%s.uiPtr = %p\n", name, str->uiPtr); + printf("\t%s.s = %d\n", name, str->s); + printf("\t%s.us = %u\n", name, str->us); + printf("\t%s.b = %u\n", name, str->b); + printf("\t%s.sb = %d\n", name, str->sb); + printf("\t%s.l = %ld\n", name, str->l); + printf("\t%s.ul = %lu\n", name, str->ul); + printf("\t%s.f = %f\n", name, str->f); + printf("\t%s.d = %f\n", name, str->d); +} + +void ChangeU(U* p) +{ + p->i32 = 2147483647; + p->ui32 = 0; + p->iPtr = (LPVOID)(-64); + p->uiPtr = (LPVOID)(64); + p->s = 32767; + p->us = 0; + p->b = 255; + p->sb = -128; + p->l = -1234567890; + p->ul = 0; + p->f = 64.0; + p->d = 6.4; +} + +bool IsCorrectU(U* p) +{ + if(p->d != 3.2) + { + return false; + } + return true; +} + +struct ByteStructPack2Explicit // size = 2 bytes +{ + BYTE b1; + BYTE b2; +}; +void PrintByteStructPack2Explicit(ByteStructPack2Explicit* str, char const * name) +{ + printf("\t%s.b1 = %d", name, str->b1); + printf("\t%s.b2 = %d", name, str->b2); +} + +void ChangeByteStructPack2Explicit(ByteStructPack2Explicit* p) +{ + p->b1 = 64; + p->b2 = 64; +} +bool IsCorrectByteStructPack2Explicit(ByteStructPack2Explicit* p) +{ + if(p->b1 != 32 || p->b2 != 32) + return false; + return true; +} + + + +struct ShortStructPack4Explicit // size = 4 bytes +{ + SHORT s1; + SHORT s2; +}; + +void PrintShortStructPack4Explicit(ShortStructPack4Explicit* str, char const * name) +{ + printf("\t%s.s1 = %d", name, str->s1); + printf("\t%s.s2 = %d", name, str->s2); +} +void ChangeShortStructPack4Explicit(ShortStructPack4Explicit* p) +{ + p->s1 = 64; + p->s2 = 64; +} +bool IsCorrectShortStructPack4Explicit(ShortStructPack4Explicit* p) +{ + if(p->s1 != 32 || p->s2 != 32) + return false; + return true; +} + + +struct IntStructPack8Explicit // size = 8 bytes +{ + INT i1; + INT i2; +}; + +void PrintIntStructPack8Explicit(IntStructPack8Explicit* str, char const * name) +{ + printf("\t%s.i1 = %d", name, str->i1); + printf("\t%s.i2 = %d", name, str->i2); +} +void ChangeIntStructPack8Explicit(IntStructPack8Explicit* p) +{ + p->i1 = 64; + p->i2 = 64; +} +bool IsCorrectIntStructPack8Explicit(IntStructPack8Explicit* p) +{ + if(p->i1 != 32 || p->i2 != 32) + return false; + return true; +} + +struct LongStructPack16Explicit // size = 16 bytes +{ + LONG64 l1; + LONG64 l2; +}; + +void PrintLongStructPack16Explicit(LongStructPack16Explicit* str, char const * name) +{ + printf("\t%s.l1 = %ld", name, str->l1); + printf("\t%s.l2 = %ld", name, str->l2); +} +void ChangeLongStructPack16Explicit(LongStructPack16Explicit* p) +{ + p->l1 = 64; + p->l2 = 64; +} +bool IsCorrectLongStructPack16Explicit(LongStructPack16Explicit* p) +{ + if(p->l1 != 32 || p->l2 != 32) + return false; + return true; +}
\ No newline at end of file diff --git a/tests/src/Interop/StructMarshalling/PInvoke/Struct.cs b/tests/src/Interop/StructMarshalling/PInvoke/Struct.cs new file mode 100644 index 0000000000..282699bf14 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/Struct.cs @@ -0,0 +1,272 @@ +using System; +using System.Runtime.InteropServices; + +public class Common +{ + public const int NumArrElements = 2; +} +//////////////////////////////struct definition/////////////////////////// +[StructLayout(LayoutKind.Sequential)] +public struct InnerSequential +{ + public int f1; + public float f2; + public String f3; +} + +[StructLayout(LayoutKind.Sequential)] +public struct ComplexStruct +{ + public int i; + [MarshalAs(UnmanagedType.I1)] + public bool b; + [MarshalAs(UnmanagedType.LPStr)] + public string str; + public IntPtr pedding; + public ScriptParamType type; +} + +[StructLayout(LayoutKind.Explicit)] +public struct ScriptParamType +{ + [FieldOffset(0)] + public int idata; + [FieldOffset(8)] + public bool bdata; + [FieldOffset(8)] + public double ddata; + [FieldOffset(8)] + public IntPtr ptrdata; +} + +[StructLayout(LayoutKind.Explicit)] +public struct INNER2 +{ + [FieldOffset(0)] + public int f1; + [FieldOffset(4)] + public float f2; + [FieldOffset(8)] + public String f3; +} + +[StructLayout(LayoutKind.Explicit)] +public struct InnerExplicit +{ + [FieldOffset(0)] + public int f1; + [FieldOffset(0)] + public float f2; + [FieldOffset(8)] + public String f3; +} + +[StructLayout(LayoutKind.Sequential)]//struct containing one field of array type +public struct InnerArraySequential +{ + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Common.NumArrElements)] + public InnerSequential[] arr; +} + +[StructLayout(LayoutKind.Explicit, Pack = 8)] +public struct InnerArrayExplicit +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Common.NumArrElements)] + public InnerSequential[] arr; + + [FieldOffset(8)] + public string f4; +} + +[StructLayout(LayoutKind.Explicit)] +public struct OUTER3 +{ + [FieldOffset(0)] + [MarshalAs(UnmanagedType.ByValArray, SizeConst = Common.NumArrElements)] + public InnerSequential[] arr; + + [FieldOffset(24)] + public string f4; +} + +[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] +public struct CharSetAnsiSequential +{ + public string f1; + public char f2; +} + +[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] +public struct CharSetUnicodeSequential +{ + public string f1; + public char f2; +} + +[StructLayout(LayoutKind.Sequential)] +public struct NumberSequential +{ + public Int64 i64; + public UInt64 ui64; + public Double d; + public int i32; + public uint ui32; + public short s1; + public ushort us1; + public Int16 i16; + public UInt16 ui16; + public Single sgl; + public Byte b; + public SByte sb; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S3 +{ + public bool flag; + [MarshalAs(UnmanagedType.LPStr)] + public string str; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] + public int[] vals; +} + +[StructLayout(LayoutKind.Sequential)] +public struct S4 +{ + public int age; + public string name; +} + +public enum Enum1 { e1 = 1, e2 = 3 }; +[StructLayout(LayoutKind.Sequential)] +public struct S5 +{ + public S4 s4; + public Enum1 ef; +} + +[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] +public struct StringStructSequentialAnsi +{ + public string first; + public string last; +} + +[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] +public struct StringStructSequentialUnicode +{ + public string first; + public string last; +} +[StructLayout(LayoutKind.Sequential)] +public struct S8 +{ + public string name; + public bool gender; + [MarshalAs(UnmanagedType.Error)] + public int i32; + [MarshalAs(UnmanagedType.Error)] + public uint ui32; + [MarshalAs(UnmanagedType.U2)] + public UInt16 jobNum; + [MarshalAs(UnmanagedType.I1)] + public sbyte mySByte; +} + +public struct S9 +{ + [MarshalAs(UnmanagedType.Error)] + public int i32; + public TestDelegate1 myDelegate1; +} + +public delegate void TestDelegate1(S9 myStruct); + +[StructLayout(LayoutKind.Sequential)] +public struct IntergerStructSequential +{ + public int i; +} +[StructLayout(LayoutKind.Sequential)] +public struct OuterIntergerStructSequential +{ + public int i; + public IntergerStructSequential s_int; +} +[StructLayout(LayoutKind.Sequential)] +public struct IncludeOuterIntergerStructSequential +{ + public OuterIntergerStructSequential s; +} +[StructLayout(LayoutKind.Sequential)] +public unsafe struct S11 +{ + public int* i32; + public int i; +} + +[StructLayout(LayoutKind.Explicit)] +public struct U +{ + [FieldOffset(0)] + public int i32; + [FieldOffset(0)] + public uint ui32; + [FieldOffset(0)] + public IntPtr iPtr; + [FieldOffset(0)] + public UIntPtr uiPtr; + [FieldOffset(0)] + public short s; + [FieldOffset(0)] + public ushort us; + [FieldOffset(0)] + public Byte b; + [FieldOffset(0)] + public SByte sb; + [FieldOffset(0)] + public long l; + [FieldOffset(0)] + public ulong ul; + [FieldOffset(0)] + public float f; + [FieldOffset(0)] + public Double d; +} + +[StructLayout(LayoutKind.Explicit, Size = 2)] +public struct ByteStructPack2Explicit +{ + [FieldOffset(0)] + public byte b1; + [FieldOffset(1)] + public byte b2; +} + +[StructLayout(LayoutKind.Explicit, Size = 4)] +public struct ShortStructPack4Explicit +{ + [FieldOffset(0)] + public short s1; + [FieldOffset(2)] + public short s2; +} + +[StructLayout(LayoutKind.Explicit, Size = 8)] +public struct IntStructPack8Explicit +{ + [FieldOffset(0)] + public int i1; + [FieldOffset(4)] + public int i2; +} + +[StructLayout(LayoutKind.Explicit, Size = 16)] +public struct LongStructPack16Explicit +{ + [FieldOffset(0)] + public long l1; + [FieldOffset(8)] + public long l2; +} diff --git a/tests/src/Interop/StructMarshalling/PInvoke/project.json b/tests/src/Interop/StructMarshalling/PInvoke/project.json new file mode 100644 index 0000000000..21a7fa4381 --- /dev/null +++ b/tests/src/Interop/StructMarshalling/PInvoke/project.json @@ -0,0 +1,35 @@ +{ + "dependencies": { + "Microsoft.NETCore.Platforms": "1.0.1-rc2-23816", + "System.Collections": "4.0.10", + "System.Collections.NonGeneric": "4.0.1-rc2-23816", + "System.Collections.Specialized": "4.0.1-rc2-23816", + "System.ComponentModel": "4.0.1-rc2-23816", + "System.Console": "4.0.0-rc2-23816", + "System.Diagnostics.Process": "4.1.0-rc2-23816", + "System.Globalization": "4.0.10", + "System.Globalization.Calendars": "4.0.0", + "System.IO": "4.0.10", + "System.IO.FileSystem": "4.0.0", + "System.IO.FileSystem.Primitives": "4.0.0", + "System.Linq": "4.0.1-rc2-23816", + "System.Linq.Queryable": "4.0.1-rc2-23816", + "System.Reflection": "4.0.10", + "System.Reflection.Primitives": "4.0.0", + "System.Runtime": "4.1.0-rc2-23816", + "System.Runtime.Extensions": "4.0.10", + "System.Runtime.Handles": "4.0.0", + "System.Runtime.InteropServices": "4.1.0-rc2-23816", + "System.Runtime.Loader": "4.0.0-rc2-23816", + "System.Text.Encoding": "4.0.10", + "System.Threading": "4.0.10", + "System.Threading.Thread": "4.0.0-rc2-23816", + "System.Xml.ReaderWriter": "4.0.11-rc2-23816", + "System.Xml.XDocument": "4.0.11-rc2-23816", + "System.Xml.XmlDocument": "4.0.1-rc2-23816", + "System.Xml.XmlSerializer": "4.0.11-rc2-23816" + }, + "frameworks": { + "dnxcore50": {} + } +}
\ No newline at end of file diff --git a/tests/src/Interop/common/xplatform.h b/tests/src/Interop/common/xplatform.h index 451209b430..0099cae14e 100644 --- a/tests/src/Interop/common/xplatform.h +++ b/tests/src/Interop/common/xplatform.h @@ -24,11 +24,11 @@ // include #ifdef _WIN32 #include <windows.h> - #include <wchar.h> #include <tchar.h> #else #include "types.h" #endif +#include <wchar.h> // dllexport diff --git a/tests/testsFailingOutsideWindows.txt b/tests/testsFailingOutsideWindows.txt index 716eddbfe9..f7b8b91575 100644 --- a/tests/testsFailingOutsideWindows.txt +++ b/tests/testsFailingOutsideWindows.txt @@ -168,6 +168,10 @@ JIT/Methodical/Boxing/xlang/_orelsin_cs_il/_orelsin_cs_il.sh JIT/Methodical/Boxing/xlang/_relsin_cs_il/_relsin_cs_il.sh JIT/Methodical/localloc/call/call01_small/call01_small.sh JIT/Regression/Dev11/External/dev11_145295/CSharpPart/CSharpPart.sh +Interop/SimpleStruct/SimpleStruct/SimpleStruct.sh +Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutExp/MarshalStructAsLayoutExp.sh +Interop/StructMarshalling/PInvoke/MarshalStructAsLayoutSeq/MarshalStructAsLayoutSeq.sh +Interop/ArrayMarshalling/ByValArray/MarshalArrayByValTest/MarshalArrayByValTest.sh Interop/StringMarshalling/LPTSTR/LPTSTRTest/LPTSTRTest.sh GC/LargeMemory/Allocation/finalizertest/finalizertest.sh GC/LargeMemory/API/gc/reregisterforfinalize/reregisterforfinalize.sh diff --git a/tests/x86_legacy_backend_issues.targets b/tests/x86_legacy_backend_issues.targets index c28f616751..5229bd40a9 100644 --- a/tests/x86_legacy_backend_issues.targets +++ b/tests/x86_legacy_backend_issues.targets @@ -439,6 +439,9 @@ <ExcludeList Include="$(XunitTestBinBase)\JIT\Regression\Dev11\External\dev11_239804\ShowLocallocAlignment\ShowLocallocAlignment.cmd"> <Issue>needs triage</Issue> </ExcludeList> + <ExcludeList Include="$(XunitTestBinBase)\Interop\StructMarshalling\PInvoke\MarshalStructAsLayoutSeq\MarshalStructAsLayoutSeq.cmd"> + <Issue>needs triage</Issue> + </ExcludeList> <ExcludeList Include="$(XunitTestBinBase)\Interop\BestFitMapping\BestFitMapping\BestFitMapping.cmd"> <Issue>3571</Issue> </ExcludeList> |