Imported Upstream version 1.1.0upstream/1.1.0

8 files changed, 2303 insertions, 0 deletions

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