Add PInvoke/Structures tests

Fix compile warnings

Fix compile warnings

Fix compile warnings

Remove duplicate tests. Move ReversePinvoke tests under StructMarshalling.

Clean up some compile errors.

More string cleanup.

More string fixes

Clean up consts and typedefs.

Fix typo.

Change TP_slen return type to match xplatform.h

Fix printf specifiers.

Don't define wcslen in xplatform if it's been macro redefined (to platformdefines.h's TP_slen)

Fix build breaks.

Remove extension from DllImport so it will correctly resolve xplat.

Fix printf specifiers again...

Fix Windows x86 calling convention mismatch.

Fix HRESULT size off-Windows

20 files changed, 9173 insertions, 6 deletions

diff --git a/tests/src/Common/Platform/platformdefines.cpp b/tests/src/Common/Platform/platformdefines.cpp
index 826e741e06..34cd360cfa 100644
--- a/tests/src/Common/Platform/platformdefines.cpp
+++ b/tests/src/Common/Platform/platformdefines.cpp
@@ -77,9 +77,9 @@ error_t TP_scat_s(LPWSTR strDestination, size_t sizeInWords, LPCWSTR strSource)
     return TP_scpy_s(strEnd, sizeInWords - ((strEnd - strDestination) / sizeof(WCHAR)), strSource);
 }
 
-int TP_slen(LPWSTR str)
+size_t TP_slen(LPCWSTR str)
 {
-    int len;
+    size_t len;
 
     if (NULL == str) return 0;
 
@@ -113,7 +113,7 @@ int TP_scmp_s(LPCSTR str1, LPCSTR str2)
     return (*str1 > *str2) ? 1 : -1;
 }
 
-int TP_wcmp_s(LPWSTR str1, LPWSTR str2)
+int TP_wcmp_s(LPCWSTR str1, LPCWSTR str2)
 {
     // < 0 str1 less than str2
     // 0  str1 identical to str2
diff --git a/tests/src/Common/Platform/platformdefines.h b/tests/src/Common/Platform/platformdefines.h
index aa96483124..64b9c8069f 100644
--- a/tests/src/Common/Platform/platformdefines.h
+++ b/tests/src/Common/Platform/platformdefines.h
@@ -36,7 +36,7 @@ typedef int BOOL;
 typedef WCHAR *LPWSTR, *PWSTR;
 typedef const WCHAR *LPCWSTR, *PCWSTR;
 
-typedef long HRESULT;
+typedef int HRESULT;
 #define LONGLONG long long
 #define ULONGLONG unsigned LONGLONG
 typedef unsigned long ULONG, *PULONG;
@@ -125,9 +125,9 @@ typedef ULONG_PTR DWORD_PTR;
 //
 error_t TP_scpy_s(LPWSTR strDestination, size_t sizeInWords, LPCWSTR strSource);
 error_t TP_scat_s(LPWSTR strDestination, size_t sizeInWords, LPCWSTR strSource);
-int TP_slen(LPWSTR str);
+size_t TP_slen(LPCWSTR str);
 int TP_scmp_s(LPCSTR str1, LPCSTR str2);
-int TP_wcmp_s(LPWSTR str1, LPWSTR str2);
+int TP_wcmp_s(LPCWSTR str1, LPCWSTR str2);
 error_t TP_getenv_s(size_t* pReturnValue, LPWSTR buffer, size_t sizeInWords, LPCWSTR varname);
 error_t TP_putenv_s(LPTSTR name, LPTSTR value);
 void TP_ZeroMemory(LPVOID buffer, size_t sizeInBytes);
diff --git a/tests/src/Interop/CMakeLists.txt b/tests/src/Interop/CMakeLists.txt
index 0a512c2315..4fe5cef71c 100644
--- a/tests/src/Interop/CMakeLists.txt
+++ b/tests/src/Interop/CMakeLists.txt
@@ -25,6 +25,8 @@ add_subdirectory(PrimitiveMarshalling/EnumMarshalling)
 add_subdirectory(FuncPtrAsDelegateParam)
 add_subdirectory(SimpleStruct)
 add_subdirectory(StructMarshalling/PInvoke)
+add_subdirectory(StructMarshalling/ReversePInvoke/MarshalExpStruct)
+add_subdirectory(StructMarshalling/ReversePInvoke/MarshalSeqStruct)
 add_subdirectory(BestFitMapping)
 add_subdirectory(RefInt)
 add_subdirectory(RefCharArray)
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs b/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs
new file mode 100644
index 0000000000..eadfab6a18
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs
@@ -0,0 +1,1252 @@
+// 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;
+using System.IO;
+using System.Text;
+using System.Globalization;
+using System.Collections;
+using System.IO.IsolatedStorage;
+using System.Security.Policy;
+
+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
+
+}
+
+public static class TestFramework
+{
+    public static void LogInformation(string str)
+    {
+        Logging.WriteLine(str);
+    }
+    public static void LogError(string id, string msg)
+    {
+        Logging.WriteLine("ERROR!!!-" + id + ": " + msg);
+    }
+    public static void BeginScenario(string name)
+    {
+        Logging.WriteLine("Beginning scenario: " + name);
+    }
+}
+
+public static class Logging
+{
+    static TextWriter stdout = Console.Out;
+
+#if (!WIN_8_P)
+    static TextWriter loggingFile = null;
+#endif    
+
+    public static void SetConsole(string fileName)
+    {
+#if (!WIN_8_P)        
+        FileStream fs = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
+        loggingFile = new StreamWriter(fs, Encoding.Unicode);
+        Console.SetOut(loggingFile);
+#endif
+    }
+
+    public static void ResetConsole()
+    {
+#if (!WIN_8_P)
+        loggingFile.Close();
+#endif
+        Console.SetOut(stdout);
+    }
+
+    public static void WriteLine()
+    {
+        Console.WriteLine();
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(bool value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(char value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(char[] buffer)
+    {
+        Console.WriteLine(buffer);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(char[] buffer, int index, int count)
+    {
+        Console.WriteLine(new string(buffer, index, count));
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(decimal value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(double value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(float value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(int value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(uint value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(long value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(ulong value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(Object value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(String value)
+    {
+        Console.WriteLine(value);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(String format, Object arg0)
+    {
+        Console.WriteLine(format, arg0);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(String format, Object arg0, Object arg1)
+    {
+        Console.WriteLine(format, arg0, arg1);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(String format, Object arg0, Object arg1, Object arg2)
+    {
+        Console.WriteLine(format, arg0, arg1, arg2);
+        Console.Out.Flush();
+    }
+
+    public static void WriteLine(String format, params Object[] arg)
+    {
+        Console.WriteLine(format, arg);
+        Console.Out.Flush();
+    }
+
+    public static void Write(String format, Object arg0)
+    {
+        Console.Write(format, arg0);
+        Console.Out.Flush();
+    }
+
+    public static void Write(String format, Object arg0, Object arg1)
+    {
+        Console.Write(format, arg0, arg1);
+        Console.Out.Flush();
+    }
+
+    public static void Write(String format, Object arg0, Object arg1, Object arg2)
+    {
+        Console.Write(format, arg0, arg1, arg2);
+        Console.Out.Flush();
+    }
+
+    public static void Write(String format, params Object[] arg)
+    {
+        Console.Write(format, arg);
+        Console.Out.Flush();
+    }
+
+    public static void Write(bool value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(char value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(char[] buffer)
+    {
+        Console.Write(buffer);
+        Console.Out.Flush();
+    }
+
+#if (!WIN_8_P)
+    public static void Write(char[] buffer, int index, int count)
+    {
+        Console.Write(buffer, index, count);
+        Console.Out.Flush();
+    }
+#endif
+
+    public static void Write(double value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(decimal value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(float value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(int value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(uint value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(long value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(ulong value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(Object value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+    public static void Write(String value)
+    {
+        Console.Write(value);
+        Console.Out.Flush();
+    }
+
+}
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/CMakeLists.txt b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/CMakeLists.txt
new file mode 100644
index 0000000000..7278b94877
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/CMakeLists.txt
@@ -0,0 +1,13 @@
+
+cmake_minimum_required (VERSION 2.6) 
+project (ReversePInvokeNative) 
+include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") 
+include_directories(${INC_PLATFORM_DIR}) 
+set(SOURCES 
+    ExpStructAsParamNative.cpp 
+) 
+# add the executable 
+add_library (ReversePInvokeNative SHARED ${SOURCES})
+target_link_libraries(ReversePInvokeNative ${LINK_LIBRARIES_ADDITIONAL})  
+# add the install targets 
+install (TARGETS ReversePInvokeNative DESTINATION bin) 
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/DelegatePInvoke/DelegatePInvokeTest.cs b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/DelegatePInvoke/DelegatePInvokeTest.cs
new file mode 100644
index 0000000000..a76dd892fc
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/DelegatePInvoke/DelegatePInvokeTest.cs
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/DelegatePInvoke/DelegatePInvokeTest.csproj b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/DelegatePInvoke/DelegatePInvokeTest.csproj
new file mode 100644
index 0000000000..5bece63f96
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/DelegatePInvoke/DelegatePInvokeTest.csproj
@@ -0,0 +1,40 @@
+<?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>DelegatePInvokeTest</AssemblyName>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\..\..\..\</SolutionDir>
+    <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <!-- Test unsupported outside of windows -->
+    <TestUnsupportedOutsideWindows>true</TestUnsupportedOutsideWindows>
+    <DisableProjectBuild Condition="'$(TargetsUnix)' == 'true'">true</DisableProjectBuild>
+  </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="DelegatePInvokeTest.cs" />
+    <Compile Include="..\..\Helper.cs" />
+    <Compile Include="..\..\Struct.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CMakeLists.txt" />
+  </ItemGroup>
+  <Import Project="../../../../Interop.settings.targets" />
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
+</Project>
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ExpStructAsParamNative.cpp b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ExpStructAsParamNative.cpp
new file mode 100644
index 0000000000..ad1d0c83a5
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ExpStructAsParamNative.cpp
@@ -0,0 +1,1606 @@
+// 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 "ExpStructAsParamNative.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <xplatform.h>
+
+const char* NativeStr = "Native";
+const size_t size=strlen(NativeStr);
+
+#define PRINT_ERR_INFO() \
+    printf("\t%s : unexpected error \n",__FUNCTION__)
+
+//----------method called byref----------//
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefINNER2_Cdecl(INNER2* inner)
+{
+    if(!IsCorrectINNER2(inner))
+    {
+        PRINT_ERR_INFO();
+        PrintINNER2(inner,"inner");
+        return FALSE;
+    }
+    ChangeINNER2(inner);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefINNER2_Stdcall(INNER2* inner)
+{
+    if(!IsCorrectINNER2(inner))
+    {
+        PRINT_ERR_INFO();
+        PrintINNER2(inner,"inner");
+        return FALSE;
+    }
+    ChangeINNER2(inner);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefInnerExplicit_Cdecl(InnerExplicit* inner)
+{
+    if(inner->f1 != 1 || memcmp(inner->f3, "some string",11*sizeof(char)) != 0)
+    {
+        PRINT_ERR_INFO();
+        PrintInnerExplicit(inner,"inner");
+        return FALSE;
+    }
+    ChangeInnerExplicit(inner);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefInnerExplicit_Stdcall(InnerExplicit* inner)
+{
+    if(inner->f1 != 1 || memcmp(inner->f3, "some string",11*sizeof(char)) != 0)
+    {
+        PRINT_ERR_INFO();
+        PrintInnerExplicit(inner,"inner");
+        return FALSE;
+    }
+    ChangeInnerExplicit(inner);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Cdecl(InnerArrayExplicit* outer2)
+{
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        if(outer2->arr[i].f1 != 1)
+        {
+            PRINT_ERR_INFO();
+            return FALSE;
+        }
+    }
+    if(memcmp(outer2->f4,"some string2",12) != 0)
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+    for(int i =0;i<NumArrElements;i++)
+    {
+        outer2->arr[i].f1 = 77;
+    }
+    const char* temp = "change string2";
+    size_t len = strlen(temp);
+    LPCSTR str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    strcpy_s((char*)str,len+1,temp);
+    outer2->f4 = str;
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Stdcall(InnerArrayExplicit* outer2)
+{
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        if(outer2->arr[i].f1 != 1)
+        {
+            PRINT_ERR_INFO();
+            return FALSE;
+        }
+    }
+    if(memcmp(outer2->f4,"some string2",12) != 0)
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+    for(int i =0;i<NumArrElements;i++)
+    {
+        outer2->arr[i].f1 = 77;
+    }
+    const char* temp = "change string2";
+    size_t len = strlen(temp);
+    LPCSTR str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    strcpy_s((char*)str,len+1,temp);
+    outer2->f4 = str;
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefOUTER3_Cdecl(OUTER3* outer3)
+{
+    if(!IsCorrectOUTER3(outer3))
+    {
+        PRINT_ERR_INFO();
+        PrintOUTER3(outer3,"OUTER3");
+        return FALSE;
+    }
+    ChangeOUTER3(outer3);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefOUTER3_Stdcall(OUTER3* outer3)
+{
+    if(!IsCorrectOUTER3(outer3))
+    {
+        PRINT_ERR_INFO();
+        PrintOUTER3(outer3,"OUTER3");
+        return FALSE;
+    }
+    ChangeOUTER3(outer3);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefU_Cdecl(U* str1)
+{
+    if(!IsCorrectU(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintU(str1, "str1");
+        return FALSE;
+    }
+    ChangeU(str1);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefU_Stdcall(U* str1)
+{
+    if(!IsCorrectU(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintU(str1, "str1");
+        return FALSE;
+    }
+    ChangeU(str1);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Cdecl(ByteStructPack2Explicit* str1)
+{
+    if(!IsCorrectByteStructPack2Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintByteStructPack2Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeByteStructPack2Explicit(str1);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Stdcall(ByteStructPack2Explicit* str1)
+{
+    if(!IsCorrectByteStructPack2Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintByteStructPack2Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeByteStructPack2Explicit(str1);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Cdecl(ShortStructPack4Explicit* str1)
+{
+    if(!IsCorrectShortStructPack4Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintShortStructPack4Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeShortStructPack4Explicit(str1);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Stdcall(ShortStructPack4Explicit* str1)
+{
+    if(!IsCorrectShortStructPack4Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintShortStructPack4Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeShortStructPack4Explicit(str1);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Cdecl(IntStructPack8Explicit* str1)
+{
+    if(!IsCorrectIntStructPack8Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintIntStructPack8Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeIntStructPack8Explicit(str1);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Stdcall(IntStructPack8Explicit* str1)
+{
+    if(!IsCorrectIntStructPack8Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintIntStructPack8Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeIntStructPack8Explicit(str1);
+    return TRUE;
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Cdecl(LongStructPack16Explicit* str1)
+{
+    if(!IsCorrectLongStructPack16Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintLongStructPack16Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeLongStructPack16Explicit(str1);
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Stdcall(LongStructPack16Explicit* str1)
+{
+    if(!IsCorrectLongStructPack16Explicit(str1))
+    {
+        PRINT_ERR_INFO();
+        PrintLongStructPack16Explicit(str1, "str1");
+        return FALSE;
+    }
+    ChangeLongStructPack16Explicit(str1);
+    return TRUE;
+}
+/////
+//---------------------------- ----------//
+
+
+//----------method called byval----------//
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValINNER2_Cdecl(INNER2 str1)
+{
+    return MarshalStructAsParam_AsExpByRefINNER2_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValINNER2_Stdcall(INNER2 str1)
+{
+    return MarshalStructAsParam_AsExpByRefINNER2_Stdcall(&str1);
+}
+/////
+
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValInnerExplicit_Cdecl(InnerExplicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefInnerExplicit_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValInnerExplicit_Stdcall(InnerExplicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefInnerExplicit_Stdcall(&str1);
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValInnerArrayExplicit_Cdecl(InnerArrayExplicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValInnerArrayExplicit_Stdcall(InnerArrayExplicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Stdcall(&str1);
+}
+/////
+
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValOUTER3_Cdecl(OUTER3 str1)
+{
+    return MarshalStructAsParam_AsExpByRefOUTER3_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValOUTER3_Stdcall(OUTER3 str1)
+{
+    return MarshalStructAsParam_AsExpByRefOUTER3_Stdcall( &str1);
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValU_Cdecl(U str1)
+{
+    return MarshalStructAsParam_AsExpByRefU_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValU_Stdcall(U str1)
+{
+    return MarshalStructAsParam_AsExpByRefU_Stdcall(&str1);
+}
+/////
+
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValByteStructPack2Explicit_Cdecl(ByteStructPack2Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValByteStructPack2Explicit_Stdcall(ByteStructPack2Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Stdcall(&str1);
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValShortStructPack4Explicit_Cdecl(ShortStructPack4Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValShortStructPack4Explicit_Stdcall(ShortStructPack4Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Stdcall(&str1);
+}
+/////
+
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValIntStructPack8Explicit_Cdecl(IntStructPack8Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValIntStructPack8Explicit_Stdcall(IntStructPack8Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Stdcall(&str1);
+}
+
+/////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructAsParam_AsExpByValLongStructPack16Explicit_Cdecl(LongStructPack16Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Cdecl(&str1);
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructAsParam_AsExpByValLongStructPack16Explicit_Stdcall(LongStructPack16Explicit str1)
+{
+    return MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Stdcall(&str1);
+}
+/////
+//---------------------------- ----------//
+
+
+//----------Delegate Pinvoke. PassByRef----------//
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_INNER2)(INNER2* inner);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_INNER2 _cdecl Get_MarshalStructAsParam_AsExpByRefINNER2_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefINNER2_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_INNER2)(INNER2* inner);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_INNER2 __stdcall Get_MarshalStructAsParam_AsExpByRefINNER2_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefINNER2_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_InnerExplicit)(InnerExplicit* ie);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_InnerExplicit _cdecl Get_MarshalStructAsParam_AsExpByRefInnerExplicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefInnerExplicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_InnerExplicit)(InnerExplicit* ie);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_InnerExplicit __stdcall Get_MarshalStructAsParam_AsExpByRefInnerExplicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefInnerExplicit_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_InnerArrayExplicit)(InnerArrayExplicit* iae);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_InnerArrayExplicit _cdecl Get_MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_InnerArrayExplicit)(InnerArrayExplicit* iae);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_InnerArrayExplicit __stdcall Get_MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefInnerArrayExplicit_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_OUTER3)(OUTER3* outer);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_OUTER3 _cdecl Get_MarshalStructAsParam_AsExpByRefOUTER3_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefOUTER3_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_OUTER3)(OUTER3* outer);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_OUTER3 __stdcall Get_MarshalStructAsParam_AsExpByRefOUTER3_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefOUTER3_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_U)(U* inner);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_U _cdecl Get_MarshalStructAsParam_AsExpByRefU_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefU_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_U)(U* inner);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_U __stdcall Get_MarshalStructAsParam_AsExpByRefU_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefU_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit* bspe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_ByteStructPack2Explicit _cdecl Get_MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit* bspe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_ByteStructPack2Explicit __stdcall Get_MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefByteStructPack2Explicit_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit* sspe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_ShortStructPack4Explicit _cdecl Get_MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit* sspe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_ShortStructPack4Explicit __stdcall Get_MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefShortStructPack4Explicit_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_IntStructPack8Explicit)(IntStructPack8Explicit* ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_IntStructPack8Explicit _cdecl Get_MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_IntStructPack8Explicit)(IntStructPack8Explicit* ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_IntStructPack8Explicit __stdcall Get_MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefIntStructPack8Explicit_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByRefCdeclCaller_LongStructPack16Explicit)(LongStructPack16Explicit* ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefCdeclCaller_LongStructPack16Explicit _cdecl Get_MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByRefStdcallCaller_LongStructPack16Explicit)(LongStructPack16Explicit* ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByRefStdcallCaller_LongStructPack16Explicit __stdcall Get_MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByRefLongStructPack16Explicit_Stdcall;
+}
+/////
+//---------------------------- ----------//
+
+
+//----------Delegate Pinvoke. PassByVal----------//
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_INNER2)(INNER2 inner);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_INNER2 _cdecl Get_MarshalStructAsParam_AsExpByValINNER2_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValINNER2_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_INNER2)(INNER2 inner);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_INNER2 __stdcall Get_MarshalStructAsParam_AsExpByValINNER2_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValINNER2_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_InnerExplicit)(InnerExplicit ie);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_InnerExplicit _cdecl Get_MarshalStructAsParam_AsExpByValInnerExplicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValInnerExplicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_InnerExplicit)(InnerExplicit ie);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_InnerExplicit __stdcall Get_MarshalStructAsParam_AsExpByValInnerExplicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValInnerExplicit_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_InnerArrayExplicit)(InnerArrayExplicit iae);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_InnerArrayExplicit _cdecl Get_MarshalStructAsParam_AsExpByValInnerArrayExplicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValInnerArrayExplicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_InnerArrayExplicit)(InnerArrayExplicit iae);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_InnerArrayExplicit __stdcall Get_MarshalStructAsParam_AsExpByValInnerArrayExplicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValInnerArrayExplicit_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_OUTER3)(OUTER3 outer);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_OUTER3 _cdecl Get_MarshalStructAsParam_AsExpByValOUTER3_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValOUTER3_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_OUTER3)(OUTER3 outer);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_OUTER3 __stdcall Get_MarshalStructAsParam_AsExpByValOUTER3_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValOUTER3_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_U)(U inner);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_U _cdecl Get_MarshalStructAsParam_AsExpByValU_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValU_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_U)(U inner);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_U __stdcall Get_MarshalStructAsParam_AsExpByValU_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValU_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit bspe);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_ByteStructPack2Explicit _cdecl Get_MarshalStructAsParam_AsExpByValByteStructPack2Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValByteStructPack2Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit bspe);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_ByteStructPack2Explicit __stdcall Get_MarshalStructAsParam_AsExpByValByteStructPack2Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValByteStructPack2Explicit_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit sspe);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_ShortStructPack4Explicit _cdecl Get_MarshalStructAsParam_AsExpByValShortStructPack4Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValShortStructPack4Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit sspe);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_ShortStructPack4Explicit __stdcall Get_MarshalStructAsParam_AsExpByValShortStructPack4Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValShortStructPack4Explicit_Stdcall;
+}
+/////
+
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_IntStructPack8Explicit)(IntStructPack8Explicit ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_IntStructPack8Explicit _cdecl Get_MarshalStructAsParam_AsExpByValIntStructPack8Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValIntStructPack8Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_IntStructPack8Explicit)(IntStructPack8Explicit ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_IntStructPack8Explicit __stdcall Get_MarshalStructAsParam_AsExpByValIntStructPack8Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValIntStructPack8Explicit_Stdcall;
+}
+
+/////
+typedef BOOL(_cdecl *DelegatePinvokeByValCdeclCaller_LongStructPack16Explicit)(LongStructPack16Explicit ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByValCdeclCaller_LongStructPack16Explicit _cdecl Get_MarshalStructAsParam_AsExpByValLongStructPack16Explicit_Cdecl_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValLongStructPack16Explicit_Cdecl;
+}
+
+typedef BOOL(__stdcall *DelegatePinvokeByValStdcallCaller_LongStructPack16Explicit)(LongStructPack16Explicit ispe);
+extern "C" DLL_EXPORT DelegatePinvokeByValStdcallCaller_LongStructPack16Explicit __stdcall Get_MarshalStructAsParam_AsExpByValLongStructPack16Explicit_Stdcall_FuncPtr()
+{
+    return MarshalStructAsParam_AsExpByValLongStructPack16Explicit_Stdcall;
+}
+/////
+//---------------------------- ----------//
+
+
+//----------Reverse Pinvoke. PassByRef----------//
+/////
+typedef BOOL (_cdecl *ByRefCdeclCaller_INNER2)(INNER2* inner2);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_INNER2(ByRefCdeclCaller_INNER2 caller)
+{
+    //init
+    INNER2 inner2;
+    inner2.f1 = 77;
+    inner2.f2 = 77.0;
+
+    char* pstr = GetNativeString();
+    inner2.f3 = pstr;
+
+    if(!caller(&inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if(!IsCorrectINNER2(&inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    //TP_CoreClrFree((void*)inner2.f3);
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_INNER2)(INNER2* inner2);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_INNER2(ByRefStdcallCaller_INNER2 caller)
+{
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+
+    //init
+    INNER2 inner2;
+    inner2.f1 = 77;
+    inner2.f2 = 77.0;
+
+    char* pstr = (char*)CoreClrAlloc(lsize + 1);
+    memset(pstr,0,lsize+1);
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+
+    inner2.f3 = pstr;
+
+    if(!caller(&inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if(!IsCorrectINNER2(&inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    //TP_CoreClrFree((void*)inner2.f3);
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByRefCdeclCaller_InnerExplicit)(InnerExplicit* inner2);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_InnerExplicit(ByRefCdeclCaller_InnerExplicit caller)
+{
+
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+
+    //init
+    InnerExplicit ie;
+    ie.f1 = 77;
+
+    char* pstr = (char*)CoreClrAlloc(lsize + 1);
+    memset(pstr,0,lsize+1);
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+    ie.f3 = pstr;
+
+    if(!caller(&ie))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( ie.f1 != 1 || 0 != strcmp((char*)ie.f3, "some string") )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_InnerExplicit)(InnerExplicit* inner2);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_InnerExplicit(ByRefStdcallCaller_InnerExplicit caller)
+{
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+
+    //init
+    InnerExplicit ie;
+    ie.f1 = 77;
+
+    char* pstr = (char*)CoreClrAlloc(lsize + 1);
+    memset(pstr,0,lsize+1);
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+    ie.f3 = pstr;
+
+    if(!caller(&ie))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( ie.f1 != 1 || 0 != strcmp((char*)ie.f3, "some string") )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByRefCdeclCaller_InnerArrayExplicit)(InnerArrayExplicit* iae);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_InnerArrayExplicit(ByRefCdeclCaller_InnerArrayExplicit caller)
+{
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+
+    //init
+    InnerArrayExplicit iae;
+    LPSTR str = NULL;
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        iae.arr[i].f1 = 77;
+        str = (LPSTR)CoreClrAlloc( lsize+1 );
+        memset(str,0,lsize+1);
+        strncpy_s((char*)str,lsize+1,lNativeStr,lsize);
+
+        iae.arr[i].f3 = str;
+        str = NULL;
+    }
+
+    str = (LPSTR)CoreClrAlloc( lsize+1 );
+    memset(str,0,lsize+1);
+    strncpy_s((char*)str,lsize+1,lNativeStr,lsize);
+    iae.f4 = str;
+
+    if(!caller(&iae))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        if( iae.arr[i].f1 != 1 || 0 != strcmp((char*)iae.arr[i].f3, "some string"))
+        {
+            PRINT_ERR_INFO();
+            return FALSE;
+        }
+    }
+    if( 0 != strcmp((char*)iae.f4, "some string") )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_InnerArrayExplicit)(InnerArrayExplicit* iae);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_InnerArrayExplicit(ByRefStdcallCaller_InnerArrayExplicit caller)
+{
+    //init
+    InnerArrayExplicit iae;
+    LPSTR str = NULL;
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        iae.arr[i].f1 = 77;
+        str = GetNativeString();
+        iae.arr[i].f3 = str;
+        str = NULL;
+    }
+
+    str = GetNativeString();
+    iae.f4 = str;
+
+    if(!caller(&iae))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        if( iae.arr[i].f1 != 1 || 0 != strcmp((char*)iae.arr[i].f3, "some string"))
+        {
+            PRINT_ERR_INFO();
+            return FALSE;
+        }
+    }
+    if( 0 != strcmp((char*)iae.f4, "some string") )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByRefCdeclCaller_OUTER3)(OUTER3* outer3);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_OUTER3(ByRefCdeclCaller_OUTER3 caller)
+{
+    //init
+    OUTER3 outer3;
+    LPSTR str = NULL;
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        outer3.arr[i].f1 = 77;
+        outer3.arr[i].f2 = 77.0;
+        str = GetNativeString();
+        outer3.arr[i].f3 = (LPCSTR)str;
+        str = NULL;
+    }
+
+    str = GetNativeString();
+    outer3.f4 = (LPCSTR)str;
+
+    if(!caller(&outer3))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectOUTER3( &outer3 ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_OUTER3)(OUTER3* outer3);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_OUTER3(ByRefStdcallCaller_OUTER3 caller)
+{
+
+    //init
+    OUTER3 outer3;
+    LPSTR str = NULL;
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        outer3.arr[i].f1 = 77;
+        outer3.arr[i].f2 = 77.0;
+        str = GetNativeString();
+        outer3.arr[i].f3 = (LPCSTR)str;
+        str = NULL;
+    }
+
+    str = GetNativeString();
+    outer3.f4 = (LPCSTR)str;
+
+    if(!caller(&outer3))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectOUTER3( &outer3 ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByRefCdeclCaller_U)(U* u);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_U(ByRefCdeclCaller_U caller)
+{
+    U u;
+    u.d = 1.23;
+
+    if(!caller(&u))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectU( &u ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_U)(U* u);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_U(ByRefStdcallCaller_U caller)
+{
+    U u;
+    u.d = 1.23;
+
+    if(!caller(&u))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectU( &u ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByRefCdeclCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit* bspe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_ByteStructPack2Explicit(ByRefCdeclCaller_ByteStructPack2Explicit caller)
+{
+    ByteStructPack2Explicit bspe;
+    bspe.b1 = 64;
+    bspe.b2 = 64;
+
+    if(!caller(&bspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectByteStructPack2Explicit( &bspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit* bspe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_ByteStructPack2Explicit(ByRefStdcallCaller_ByteStructPack2Explicit caller)
+{
+    ByteStructPack2Explicit bspe;
+    bspe.b1 = 64;
+    bspe.b2 = 64;
+
+    if(!caller(&bspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectByteStructPack2Explicit( &bspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByRefCdeclCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit* sspe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_ShortStructPack4Explicit(ByRefCdeclCaller_ShortStructPack4Explicit caller) 
+{
+    ShortStructPack4Explicit sspe;
+    sspe.s1 = 64;
+    sspe.s2 = 64;
+
+    if(!caller(&sspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectShortStructPack4Explicit( &sspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit* sspe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_ShortStructPack4Explicit(ByRefStdcallCaller_ShortStructPack4Explicit caller) 
+{
+    ShortStructPack4Explicit sspe;
+    sspe.s1 = 64;
+    sspe.s2 = 64;
+
+    if(!caller(&sspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectShortStructPack4Explicit( &sspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByRefCdeclCaller_IntStructPack8Explicit)(IntStructPack8Explicit* ispe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_IntStructPack8Explicit(ByRefCdeclCaller_IntStructPack8Explicit caller) 
+{
+    IntStructPack8Explicit ispe;
+    ispe.i1 = 64;
+    ispe.i2 = 64;
+
+    if(!caller(&ispe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectIntStructPack8Explicit( &ispe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_IntStructPack8Explicit)(IntStructPack8Explicit* ispe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_IntStructPack8Explicit(ByRefStdcallCaller_IntStructPack8Explicit caller) 
+{
+    IntStructPack8Explicit ispe;
+    ispe.i1 = 64;
+    ispe.i2 = 64;
+
+    if(!caller(&ispe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectIntStructPack8Explicit( &ispe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByRefCdeclCaller_LongStructPack16Explicit)(LongStructPack16Explicit* lspe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByRefStruct_Cdecl_LongStructPack16Explicit(ByRefCdeclCaller_LongStructPack16Explicit caller) 
+{
+    LongStructPack16Explicit lspe;
+    lspe.l1 = 64;
+    lspe.l2 = 64;
+
+    if(!caller(&lspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectLongStructPack16Explicit( &lspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByRefStdcallCaller_LongStructPack16Explicit)(LongStructPack16Explicit* lspe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByRefStruct_Stdcall_LongStructPack16Explicit(ByRefStdcallCaller_LongStructPack16Explicit caller) 
+{
+    LongStructPack16Explicit lspe;
+    lspe.l1 = 64;
+    lspe.l2 = 64;
+
+    if(!caller(&lspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectLongStructPack16Explicit( &lspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+//---------------------------- ----------//
+
+
+//----------Reverse Pinvoke. PassByVal---------//
+/////
+typedef BOOL (_cdecl *ByValCdeclCaller_INNER2)(INNER2 inner2);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_INNER2(ByValCdeclCaller_INNER2 caller)
+{
+    //init
+    INNER2 inner2;
+    inner2.f1 = 1;
+    inner2.f2 = 1.0;
+
+    char* pstr = GetSomeString();
+    inner2.f3 = pstr;
+
+    if(!caller(inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if(!IsCorrectINNER2(&inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_INNER2)(INNER2 inner2);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_INNER2(ByValStdcallCaller_INNER2 caller)
+{
+    //init
+    INNER2 inner2;
+    inner2.f1 = 1;
+    inner2.f2 = 1.0;
+
+    char* pstr = GetSomeString();
+    inner2.f3 = pstr;
+
+    if(!caller(inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if(!IsCorrectINNER2(&inner2))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByValCdeclCaller_InnerExplicit)(InnerExplicit inner2);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_InnerExplicit(ByValCdeclCaller_InnerExplicit caller)
+{
+    //init
+    InnerExplicit ie;
+    ie.f1 = 1;
+
+    char* pstr = GetNativeString();
+    ie.f3 = pstr;
+
+    if(!caller(ie))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( ie.f1 != 1 || 0 != strcmp((char*)ie.f3, (char*)NativeStr) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_InnerExplicit)(InnerExplicit inner2);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_InnerExplicit(ByValStdcallCaller_InnerExplicit caller)
+{
+    //init
+    InnerExplicit ie;
+    ie.f1 = 1;
+
+    char* pstr = GetNativeString();
+    ie.f3 = pstr;
+
+    if(!caller(ie))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( ie.f1 != 1 || 0 != strcmp((char*)ie.f3, (char*)NativeStr) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByValCdeclCaller_InnerArrayExplicit)(InnerArrayExplicit iae);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_InnerArrayExplicit(ByValCdeclCaller_InnerArrayExplicit caller)
+{
+    //init
+    InnerArrayExplicit iae;
+    LPSTR str = NULL;
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        iae.arr[i].f1 = 1;
+        str = GetSomeString();
+        iae.arr[i].f3 = str;
+        str = NULL;
+    }
+
+    str = GetSomeString();
+    iae.f4 = str;
+
+    if(!caller(iae))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        if( iae.arr[i].f1 != 1 || 0 != strcmp((char*)iae.arr[i].f3, "some string"))
+        {
+            PRINT_ERR_INFO();
+            return FALSE;
+        }
+    }
+    if( 0 != strcmp((char*)iae.f4, "some string") )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_InnerArrayExplicit)(InnerArrayExplicit iae);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_InnerArrayExplicit(ByValStdcallCaller_InnerArrayExplicit caller)
+{
+    //init
+    InnerArrayExplicit iae;
+    LPSTR str = NULL;
+
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        iae.arr[i].f1 = 1;
+
+        str = GetSomeString();
+        iae.arr[i].f3 = str;
+        str = NULL;
+    }
+
+    str = GetSomeString();
+    iae.f4 = str;
+
+    if(!caller(iae))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        if( iae.arr[i].f1 != 1 || 0 != strcmp((char*)iae.arr[i].f3, "some string"))
+        {
+            PRINT_ERR_INFO();
+            return FALSE;
+        }
+    }
+    if( 0 != strcmp((char*)iae.f4, "some string") )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByValCdeclCaller_OUTER3)(OUTER3 outer3);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_OUTER3(ByValCdeclCaller_OUTER3 caller)
+{
+    //init
+    OUTER3 outer3;
+    LPSTR str = NULL;
+
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        outer3.arr[i].f1 = 1;
+        outer3.arr[i].f2 = 1.0;
+        str = GetSomeString();
+        outer3.arr[i].f3 = (LPCSTR)str;
+        str = NULL;
+    }
+
+    str = GetSomeString();
+    outer3.f4 = (LPCSTR)str;
+
+    if(!caller(outer3))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectOUTER3( &outer3 ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_OUTER3)(OUTER3 outer3);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_OUTER3(ByValStdcallCaller_OUTER3 caller)
+{
+    //init
+    OUTER3 outer3;
+    LPSTR str = NULL;
+    for( size_t i = 0; i < NumArrElements; i++ )
+    {
+        outer3.arr[i].f1 = 1;
+        outer3.arr[i].f2 = 1.0;
+        str = GetSomeString();
+        outer3.arr[i].f3 = (LPCSTR)str;
+        str = NULL;
+    }
+
+    str = GetSomeString();
+    outer3.f4 = (LPCSTR)str;
+
+    if(!caller(outer3))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectOUTER3( &outer3 ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByValCdeclCaller_U)(U u);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_U(ByValCdeclCaller_U caller)
+{
+    U u;
+    u.d = 3.2;
+
+    if(!caller(u))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectU( &u ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_U)(U u);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_U(ByValStdcallCaller_U caller)
+{
+    U u;
+    u.d = 3.2;
+
+    if(!caller(u))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectU( &u ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByValCdeclCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit bspe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_ByteStructPack2Explicit(ByValCdeclCaller_ByteStructPack2Explicit caller)
+{
+    ByteStructPack2Explicit bspe;
+    bspe.b1 = 32;
+    bspe.b2 = 32;
+
+    if(!caller(bspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectByteStructPack2Explicit( &bspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_ByteStructPack2Explicit)(ByteStructPack2Explicit bspe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_ByteStructPack2Explicit(ByValStdcallCaller_ByteStructPack2Explicit caller)
+{
+    ByteStructPack2Explicit bspe;
+    bspe.b1 = 32;
+    bspe.b2 = 32;
+
+    if(!caller(bspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectByteStructPack2Explicit( &bspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByValCdeclCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit sspe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_ShortStructPack4Explicit(ByValCdeclCaller_ShortStructPack4Explicit caller) 
+{
+    ShortStructPack4Explicit sspe;
+    sspe.s1 = 32;
+    sspe.s2 = 32;
+
+    if(!caller(sspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectShortStructPack4Explicit( &sspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_ShortStructPack4Explicit)(ShortStructPack4Explicit sspe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_ShortStructPack4Explicit(ByValStdcallCaller_ShortStructPack4Explicit caller) 
+{
+    ShortStructPack4Explicit sspe;
+    sspe.s1 = 32;
+    sspe.s2 = 32;
+
+    if(!caller(sspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectShortStructPack4Explicit( &sspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+
+typedef BOOL (_cdecl *ByValCdeclCaller_IntStructPack8Explicit)(IntStructPack8Explicit ispe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_IntStructPack8Explicit(ByValCdeclCaller_IntStructPack8Explicit caller) 
+{
+    IntStructPack8Explicit ispe;
+    ispe.i1 = 32;
+    ispe.i2 = 32;
+
+    if(!caller(ispe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectIntStructPack8Explicit( &ispe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_IntStructPack8Explicit)(IntStructPack8Explicit ispe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_IntStructPack8Explicit(ByValStdcallCaller_IntStructPack8Explicit caller) 
+{
+    IntStructPack8Explicit ispe;
+    ispe.i1 = 32;
+    ispe.i2 = 32;
+
+    if(!caller(ispe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectIntStructPack8Explicit( &ispe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/////
+typedef BOOL (_cdecl *ByValCdeclCaller_LongStructPack16Explicit)(LongStructPack16Explicit lspe);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalByValStruct_Cdecl_LongStructPack16Explicit(ByValCdeclCaller_LongStructPack16Explicit caller) 
+{
+    LongStructPack16Explicit lspe;
+    lspe.l1 = 32;
+    lspe.l2 = 32;
+
+    if(!caller(lspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectLongStructPack16Explicit( &lspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ByValStdcallCaller_LongStructPack16Explicit)(LongStructPack16Explicit lspe);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalByValStruct_Stdcall_LongStructPack16Explicit(ByValStdcallCaller_LongStructPack16Explicit caller) 
+{
+    LongStructPack16Explicit lspe;
+    lspe.l1 = 32;
+    lspe.l2 = 32;
+
+    if(!caller(lspe))
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    if( !IsCorrectLongStructPack16Explicit( &lspe ) )
+    {
+        PRINT_ERR_INFO();
+        return FALSE;
+    }
+
+    return TRUE;
+}
+/////
+//---------------------------- ----------//
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ExpStructAsParamNative.h b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ExpStructAsParamNative.h
new file mode 100644
index 0000000000..cde3b524d0
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ExpStructAsParamNative.h
@@ -0,0 +1,919 @@
+// 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <xplatform.h>
+#include "platformdefines.h"
+
+const int NumArrElements = 2;
+struct InnerSequential
+{
+    int f1;
+    float f2;
+    LPCSTR f3;
+};
+
+void PrintInnerSequential(InnerSequential* p, const char* 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;
+
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strncpy_s((char*)temp,size,lpstr,size-1);
+        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;
+    if(strcmp((char*)p->f3,"some string") != 0 )
+        return false;
+
+    return true;
+}
+
+struct INNER2 // size = 12 bytes
+{
+    INT f1;
+    FLOAT f2;
+    LPCSTR f3;
+};
+
+void ChangeINNER2(INNER2* p)
+{
+    p->f1 = 77;
+    p->f2 = 77.0;
+    const char* temp = "changed string";
+    size_t len = strlen(temp);
+    LPCSTR str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    memset((LPVOID)str,0,len+1);
+    strncpy_s((char*)str,len+1,temp,len);
+    p->f3 = str;
+}
+
+void PrintINNER2(INNER2* p, const char* 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;
+#else
+    union
+    {
+        INT f1;
+        FLOAT f2;
+    };
+    INT _unused0;
+    LPCSTR f3;
+#endif 
+};
+
+
+void PrintInnerExplicit(InnerExplicit* p, const char* 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;
+
+    const char* temp = "changed string";
+    size_t len = strlen(temp);
+    LPCSTR str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    memset((LPVOID)str,0,len+1);
+    strncpy_s((char*)str,len+1,temp,len);
+    p->f3 = str;
+}
+
+struct InnerArraySequential
+{
+    InnerSequential arr[NumArrElements];
+};
+
+void PrintInnerArraySequential(InnerArraySequential* p, const char* 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].f2 = %s\n", name, i, (p->arr)[i].f3);
+    }
+}
+
+void ChangeInnerArraySequential(InnerArraySequential* p)
+{
+    const char* 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)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strncpy_s((char*)temp,strlen(lpstr)+1,lpstr,strlen(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 _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
+
+void PrintOUTER3(OUTER3* p, const char* 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)
+{
+    const char* 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)CoreClrAlloc( sizeof(char)*(len+1) );
+        memset((LPVOID)str,0,len+1);
+        strncpy_s((char*)str,len+1,temp,len);
+        (p->arr)[i].f3 = str;
+    }
+
+    str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    memset((LPVOID)str,0,len+1);
+    strncpy_s((char*)str,len+1,temp,len);
+    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, const char* name)
+{
+    printf("\t%s.f1 = %s\n", name, p->f1);
+    printf("\t%s.f2 = %c\n", name, p->f2);
+}
+
+void ChangeCharSetAnsiSequential(CharSetAnsiSequential* p)
+{
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);	
+    if(temp != NULL)
+    {
+        memset(temp,0,size);
+        strncpy_s((char*)temp,size,strSource,size-1);
+        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, const char* name)
+{
+#ifdef _WIN32
+	wprintf(L"\t%S.first = %s\n", name, p->f1);
+	wprintf(L"\t%S.last = %c\n", name, p->f2);
+#else
+	wprintf(L"\t%s.first = %s\n", name, p->f1);
+	wprintf(L"\t%s.last = %c\n", name, p->f2);
+#endif
+}
+
+void ChangeCharSetUnicodeSequential(CharSetUnicodeSequential* p)
+{
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len =TP_slen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        memset((LPWSTR)temp,0,len+1);
+        wcsncpy_s((WCHAR*)temp, len, strSource, len);
+        p->f1 = temp;
+        p->f2 = L'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+}
+
+bool IsCorrectCharSetUnicodeSequential(CharSetUnicodeSequential* p)
+{
+    WCHAR* expected= const_cast<WCHAR*>(W("some string"));
+    WCHAR* actual = const_cast<WCHAR*>(p->f1);
+    if(0 != TP_wcmp_s(actual, 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, const char* 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 = %lld\n", name, str->i64);
+    printf("\t%s.ui64 = %llu\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 != INT_MIN || 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, const char* 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;
+
+    const char* strSource = "change string";
+    size_t len =strlen(strSource)+1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        memset((LPVOID)temp,0,len);
+        strncpy_s((char*)temp,len,strSource,len-1);
+        p->str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        p->vals[i-1] = i;
+    }
+}
+
+bool IsCorrectS3(S3* p)
+{
+    int iflag = 0;
+    if(!p->flag || strcmp((char*)p->str,"some string") != 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, const char* 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;
+    const char* strSource = "change string";	
+    size_t len =strlen(strSource)+1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        memset((LPVOID)temp,0,len);
+        strncpy_s((char*)temp,len,strSource,len-1);
+        str->s4.name = temp;
+    }
+    str->s4.age = 64;
+    str->ef = eInstance;
+}
+
+bool IsCorrectS5(S5* str)
+{
+    Enum1 eInstance = e1;
+    if(str->s4.age != 32 || strcmp((char*)str->s4.name,"some string") != 0)
+        return false;
+    if(str->ef != eInstance)
+    {
+        return false;
+    }
+    return true;
+}
+
+struct StringStructSequentialAnsi // size = 8 bytes
+{
+    LPCSTR first;
+    LPCSTR last;
+};
+
+void PrintStringStructSequentialAnsi(StringStructSequentialAnsi* str, const char* 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*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(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, const char* name)
+{
+#ifdef _WIN32
+	wprintf(L"\t%S.first = %s\n", name, str->first);
+	wprintf(L"\t%S.last = %s\n", name, str->last);
+#else
+	wprintf(L"\t%s.first = %s\n", name, str->first);
+	wprintf(L"\t%s.last = %s\n", name, str->last);
+#endif
+}
+
+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*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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;
+    HRESULT i32;
+    HRESULT ui32;
+    WORD jobNum;
+    CHAR mySByte;
+};
+
+void PrintS8(S8* str, const char* 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, (int)(str->i32));
+    printf("\t%s.ui32 = %u\n", name, (unsigned int)(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)
+{
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,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
+{
+    HRESULT 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, const char* 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, const char* name)
+{
+    printf("\t%s.i32 = %d\n", name, str->i32);
+    printf("\t%s.ui32 = %u\n", name, str->ui32);
+    printf("\t%s.iPtr = %zu\n", name,  (size_t)(str->iPtr));
+    printf("\t%s.uiPtr = %zu\n", name,  (size_t)(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 = %lld\n", name, str->l);
+    printf("\t%s.ul = %llu\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, const char* 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, const char* 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, const char* 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, const char* name)
+{
+    printf("\t%s.l1 = %lld", name, str->l1);
+    printf("\t%s.l2 = %lld", 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;
+}
+
+LPSTR GetNativeString()
+{
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+    LPSTR str = NULL;
+
+    str = (LPSTR)CoreClrAlloc( lsize+1 );
+    memset(str,0,lsize+1);
+    strcpy_s((char*)str,lsize+1,lNativeStr);
+
+    return str;
+}
+
+LPSTR GetSomeString()
+{
+    const char* lNativeStr = "some string";
+    const size_t lsize = strlen(lNativeStr);
+    LPSTR str = NULL;
+
+    str = (LPSTR)CoreClrAlloc( lsize+1 );
+    memset(str,0,lsize+1);
+    strcpy_s((char*)str,lsize+1,lNativeStr);
+
+    return str;
+}
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ReversePInvokeManaged/ReversePInvokeTest.cs b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ReversePInvokeManaged/ReversePInvokeTest.cs
new file mode 100644
index 0000000000..674bbb2f6f
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ReversePInvokeManaged/ReversePInvokeTest.cs
@@ -0,0 +1,807 @@
+// 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.Text;
+using System.Security;
+using System.Runtime.InteropServices;
+using TestLibrary;
+
+public class Test
+{
+    const int iNative = 11;//the value passed from Native side to Managed side
+    const int iManaged = 10;//The value passed from Managed side to Native sid
+
+    enum StructID
+    {
+        INNER2Id,
+        InnerExplicitId,
+        InnerArrayExplicitId,
+        OUTER3Id,
+        UId,
+        ByteStructPack2ExplicitId,
+        ShortStructPack4ExplicitId,
+        IntStructPack8ExplicitId,
+        LongStructPack16ExplicitId
+    }
+
+    #region Methods implementation
+
+    #region ReversePinvoke, ByRef, Cdel  
+    
+    //ReversePinvoke,Cdel
+    // 1.1
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_INNER2([In, Out]ref INNER2 inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_INNER2(ByRefCdeclcaller_INNER2 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_INNER2_Cdecl(ref INNER2 inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        INNER2 sourceINNER2 = Helper.NewINNER2(77, 77.0F, "Native");
+        Assert.IsTrue(Helper.ValidateINNER2(sourceINNER2, inner2, "TestMethod_DoCallBack_MarshalStructByRef_INNER2_Cdecl"));
+        //changed the value
+        inner2.f1 = 1;
+        inner2.f2 = 1.0F;
+        inner2.f3 = "some string";
+        return true;
+    }
+
+    // 1.2
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_InnerExplicit([In, Out]ref InnerExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_InnerExplicit(ByRefCdeclcaller_InnerExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_InnerExplicit_Cdecl(ref InnerExplicit inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        InnerExplicit source_ie = new InnerExplicit();
+        source_ie.f1 = 77;
+        source_ie.f3 = "Native";
+        Assert.IsTrue(Helper.ValidateInnerExplicit(source_ie, inner2, "TestMethod_DoCallBack_MarshalStructByRef_InnerExplicit_Cdecl"));
+        //changed the value
+        inner2.f1 = 1;
+        inner2.f3 = "some string";
+        return true;
+    }
+
+    // 1.3
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_InnerArrayExplicit([In, Out]ref InnerArrayExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_InnerArrayExplicit(ByRefCdeclcaller_InnerArrayExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_InnerArrayExplicit_Cdecl(ref InnerArrayExplicit iae)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        InnerArrayExplicit source_iae = Helper.NewInnerArrayExplicit(77, 77.0F, "Native", "Native");
+        Assert.IsTrue(Helper.ValidateInnerArrayExplicit(source_iae, iae, "TestMethod_DoCallBack_MarshalStructByRef_InnerArrayExplicit_Cdecl"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            iae.arr[i].f1 = 1;
+            iae.arr[i].f3 = "some string";
+        }
+        iae.f4 = "some string";
+        return true;
+    }
+
+    // 1.4
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_OUTER3([In, Out]ref OUTER3 outer3);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_OUTER3(ByRefCdeclcaller_OUTER3 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_OUTER3_Cdecl(ref OUTER3 outer3)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        OUTER3 sourceOUTER3 = Helper.NewOUTER3(77, 77.0F, "Native", "Native");
+        Assert.IsTrue(Helper.ValidateOUTER3(sourceOUTER3, outer3, "TestMethod_DoCallBack_MarshalStructByRef_OUTER3_Cdecl"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            outer3.arr[i].f1 = 1;
+            outer3.arr[i].f2 = 1.0F;
+            outer3.arr[i].f3 = "some string";
+        }
+        outer3.f4 = "some string";
+        return true;
+    }
+
+    // 1.5
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_U([In, Out]ref U u);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_U(ByRefCdeclcaller_U caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_U_Cdecl(ref U u)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        U changeU = 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, 1.23);
+        Assert.IsTrue(Helper.ValidateU(changeU, u, "TestMethod_DoCallBack_MarshalStructByRef_U_Cdecl"));
+        //changed the value
+        u.d = 3.2;
+        return true;
+    }
+
+    // 1.6
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_ByteStructPack2Explicit([In, Out]ref ByteStructPack2Explicit bspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_ByteStructPack2Explicit(ByRefCdeclcaller_ByteStructPack2Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_ByteStructPack2Explicit_Cdecl(ref ByteStructPack2Explicit bspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateByteStructPack2Explicit(change_bspe, bspe, "TestMethod_DoCallBack_MarshalStructByRef_ByteStructPack2Explicit_Cdecl"));
+        //changed the value
+        bspe.b1 = 32;
+        bspe.b2 = 32;
+        return true;
+    }
+
+    // 1.7
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_ShortStructPack4Explicit([In, Out]ref ShortStructPack4Explicit sspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_ShortStructPack4Explicit(ByRefCdeclcaller_ShortStructPack4Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_ShortStructPack4Explicit_Cdecl(ref ShortStructPack4Explicit sspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateShortStructPack4Explicit(change_sspe, sspe, "TestMethod_DoCallBack_MarshalStructByRef_ShortStructPack4Explicit_Cdecl"));
+        //changed the value
+        sspe.s1 = 32;
+        sspe.s2 = 32;
+        return true;
+    }
+
+    // 1.8
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_IntStructPack8Explicit([In, Out]ref IntStructPack8Explicit ispe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_IntStructPack8Explicit(ByRefCdeclcaller_IntStructPack8Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_IntStructPack8Explicit_Cdecl(ref IntStructPack8Explicit ispe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateIntStructPack8Explicit(change_ispe, ispe, "TestMethod_DoCallBack_MarshalStructByRef_IntStructPack8Explicit_Cdecl"));
+        //changed the value
+        ispe.i1 = 32;
+        ispe.i2 = 32;
+        return true;
+    }
+
+    // 1.9
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByRefCdeclcaller_LongStructPack16Explicit([In, Out]ref LongStructPack16Explicit lspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Cdecl_LongStructPack16Explicit(ByRefCdeclcaller_LongStructPack16Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_LongStructPack16Explicit_Cdecl(ref LongStructPack16Explicit lspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        LongStructPack16Explicit change_lspe = Helper.NewLongStructPack16Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateLongStructPack16Explicit(change_lspe, lspe, "TestMethod_DoCallBack_MarshalStructByRef_LongStructPack16Explicit_Cdecl"));
+        //changed the value
+        lspe.l1 = 32;
+        lspe.l2 = 32;
+        return true;
+    }
+
+    #endregion
+    
+    #region ReversePinvoke, ByRef, Stdcall
+
+    //ReversePinvoke,Stdcall
+    // 2.1
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_INNER2([In, Out]ref INNER2 inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_INNER2(ByRefStdcallcaller_INNER2 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_INNER2_Stdcall(ref INNER2 inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        INNER2 sourceINNER2 = Helper.NewINNER2(77, 77.0F, "Native");
+        Assert.IsTrue(Helper.ValidateINNER2(sourceINNER2, inner2, "TestMethod_DoCallBack_MarshalStructByRef_INNER2_Stdcall"));
+        //changed the value
+        inner2.f1 = 1;
+        inner2.f2 = 1.0F;
+        inner2.f3 = "some string";
+        return true;
+    }
+
+    // 2.2
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_InnerExplicit([In, Out]ref InnerExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_InnerExplicit(ByRefStdcallcaller_InnerExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_InnerExplicit_Stdcall(ref InnerExplicit inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        InnerExplicit source_ie = new InnerExplicit();
+        source_ie.f1 = 77;
+        source_ie.f3 = "Native";
+        Assert.IsTrue(Helper.ValidateInnerExplicit(inner2,source_ie, "TestMethod_DoCallBack_MarshalStructByRef_InnerExplicit_Stdcall"));
+        //changed the value
+        inner2.f1 = 1;
+        inner2.f3 = "some string";
+        return true;
+    }
+
+    // 2.3
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_InnerArrayExplicit([In, Out]ref InnerArrayExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_InnerArrayExplicit(ByRefStdcallcaller_InnerArrayExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_InnerArrayExplicit_Stdcall(ref InnerArrayExplicit iae)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        InnerArrayExplicit source_iae = Helper.NewInnerArrayExplicit(77, 77.0F, "Native", "Native");
+        Assert.IsTrue(Helper.ValidateInnerArrayExplicit(source_iae, iae, "TestMethod_DoCallBack_MarshalStructByRef_InnerArrayExplicit_Stdcall"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            iae.arr[i].f1 = 1;
+            iae.arr[i].f3 = "some string";
+        }
+        iae.f4 = "some string";
+        return true;
+    }
+
+    // 2.4
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_OUTER3([In, Out]ref OUTER3 outer3);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_OUTER3(ByRefStdcallcaller_OUTER3 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_OUTER3_Stdcall(ref OUTER3 outer3)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        OUTER3 sourceOUTER3 = Helper.NewOUTER3(77, 77.0F, "Native", "Native");
+        Assert.IsTrue(Helper.ValidateOUTER3(sourceOUTER3, outer3, "TestMethod_DoCallBack_MarshalStructByRef_OUTER3_Stdcall"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            outer3.arr[i].f1 = 1;
+            outer3.arr[i].f2 = 1.0F;
+            outer3.arr[i].f3 = "some string";
+        }
+        outer3.f4 = "some string";
+        return true;
+    }
+
+    // 2.5
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_U([In, Out]ref U u);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_U(ByRefStdcallcaller_U caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_U_Stdcall(ref U u)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        U changeU = 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, 1.23);
+        Assert.IsTrue(Helper.ValidateU(changeU, u, "TestMethod_DoCallBack_MarshalStructByRef_U_Stdcall"));
+        //changed the value
+        u.d = 3.2;
+        return true;
+    }
+
+    // 2.6
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_ByteStructPack2Explicit([In, Out]ref ByteStructPack2Explicit bspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_ByteStructPack2Explicit(ByRefStdcallcaller_ByteStructPack2Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_ByteStructPack2Explicit_Stdcall(ref ByteStructPack2Explicit bspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateByteStructPack2Explicit(change_bspe, bspe, "TestMethod_DoCallBack_MarshalStructByRef_ByteStructPack2Explicit_Stdcall"));
+        //changed the value
+        bspe.b1 = 32;
+        bspe.b2 = 32;
+        return true;
+    }
+
+    // 2.7
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_ShortStructPack4Explicit([In, Out]ref ShortStructPack4Explicit sspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_ShortStructPack4Explicit(ByRefStdcallcaller_ShortStructPack4Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_ShortStructPack4Explicit_Stdcall(ref ShortStructPack4Explicit sspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateShortStructPack4Explicit(change_sspe, sspe, "TestMethod_DoCallBack_MarshalStructByRef_ShortStructPack4Explicit_Stdcall"));
+        //changed the value
+        sspe.s1 = 32;
+        sspe.s2 = 32;
+        return true;
+    }
+
+    // 2.8
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_IntStructPack8Explicit([In, Out]ref IntStructPack8Explicit ispe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_IntStructPack8Explicit(ByRefStdcallcaller_IntStructPack8Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_IntStructPack8Explicit_Stdcall(ref IntStructPack8Explicit ispe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateIntStructPack8Explicit(change_ispe, ispe, "TestMethod_DoCallBack_MarshalStructByRef_IntStructPack8Explicit_Stdcall"));
+        //changed the value
+        ispe.i1 = 32;
+        ispe.i2 = 32;
+        return true;
+    }
+
+    // 2.9
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByRefStdcallcaller_LongStructPack16Explicit([In, Out]ref LongStructPack16Explicit lspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByRefStruct_Stdcall_LongStructPack16Explicit(ByRefStdcallcaller_LongStructPack16Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByRef_LongStructPack16Explicit_Stdcall(ref LongStructPack16Explicit lspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Stdcall");
+        LongStructPack16Explicit change_lspe = Helper.NewLongStructPack16Explicit(64, 64);
+        Assert.IsTrue(Helper.ValidateLongStructPack16Explicit(change_lspe, lspe, "TestMethod_DoCallBack_MarshalStructByRef_LongStructPack16Explicit_Stdcall"));
+        //changed the value
+        lspe.l1 = 32;
+        lspe.l2 = 32;
+        return true;
+    }
+
+    #endregion
+    
+    #region ReversePinvoke, ByVal, Cdel
+
+    // 3.1
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_INNER2([In, Out] INNER2 inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_INNER2(ByValCdeclcaller_INNER2 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_INNER2_Cdecl( INNER2 inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Ref,Cdecl");
+        INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string");
+        Assert.IsTrue(Helper.ValidateINNER2(sourceINNER2, inner2, "TestMethod_DoCallBack_MarshalStructByVal_INNER2_Cdecl"));
+        //changed the value
+        inner2.f1 = 77;
+        inner2.f2 = 77.0F;
+        inner2.f3 = "changed string";
+        return true;
+    }
+
+    // 3.2
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_InnerExplicit([In, Out] InnerExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_InnerExplicit(ByValCdeclcaller_InnerExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_InnerExplicit_Cdecl( InnerExplicit inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        InnerExplicit source_ie = new InnerExplicit();
+        source_ie.f1 = 1;
+        source_ie.f3 = "Native";
+        Assert.IsTrue(Helper.ValidateInnerExplicit(source_ie, inner2, "TestMethod_DoCallBack_MarshalStructByVal_InnerExplicit_Cdecl"));
+        //changed the value
+        inner2.f1 = 1;
+        inner2.f3 = "changed string";
+        return true;
+    }
+
+    // 3.3
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_InnerArrayExplicit([In, Out] InnerArrayExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_InnerArrayExplicit(ByValCdeclcaller_InnerArrayExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_InnerArrayExplicit_Cdecl( InnerArrayExplicit iae)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        InnerArrayExplicit source_iae = Helper.NewInnerArrayExplicit(1, 1.0F, "some string", "some string");
+        Assert.IsTrue(Helper.ValidateInnerArrayExplicit(source_iae, iae, "TestMethod_DoCallBack_MarshalStructByVal_InnerArrayExplicit_Cdecl"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            iae.arr[i].f1 = 1;
+            iae.arr[i].f3 = "changed string";
+        }
+        iae.f4 = "changed string";
+        return true;
+    }
+
+    // 3.4
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_OUTER3([In, Out] OUTER3 outer3);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_OUTER3(ByValCdeclcaller_OUTER3 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_OUTER3_Cdecl( OUTER3 outer3)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string");
+        Assert.IsTrue(Helper.ValidateOUTER3(sourceOUTER3, outer3, "TestMethod_DoCallBack_MarshalStructByVal_OUTER3_Cdecl"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            outer3.arr[i].f1 = 1;
+            outer3.arr[i].f2 = 1.0F;
+            outer3.arr[i].f3 = "changed string";
+        }
+        outer3.f4 = "changed string";
+        return true;
+    }
+
+    // 3.5
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_U([In, Out] U u);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_U(ByValCdeclcaller_U caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_U_Cdecl( U u)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        U changeU = 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);
+        Assert.IsTrue(Helper.ValidateU(changeU, u, "TestMethod_DoCallBack_MarshalStructByVal_U_Cdecl"));
+        //changed the value
+        u.d = 1.23;
+        return true;
+    }
+
+    // 3.6
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_ByteStructPack2Explicit([In, Out] ByteStructPack2Explicit bspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_ByteStructPack2Explicit(ByValCdeclcaller_ByteStructPack2Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_ByteStructPack2Explicit_Cdecl( ByteStructPack2Explicit bspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateByteStructPack2Explicit(change_bspe, bspe, "TestMethod_DoCallBack_MarshalStructByVal_ByteStructPack2Explicit_Cdecl"));
+        //changed the value
+        bspe.b1 = 64;
+        bspe.b2 = 64;
+        return true;
+    }
+
+    // 3.7
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_ShortStructPack4Explicit([In, Out] ShortStructPack4Explicit sspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_ShortStructPack4Explicit(ByValCdeclcaller_ShortStructPack4Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_ShortStructPack4Explicit_Cdecl( ShortStructPack4Explicit sspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateShortStructPack4Explicit(change_sspe, sspe, "TestMethod_DoCallBack_MarshalStructByVal_ShortStructPack4Explicit_Cdecl"));
+        //changed the value
+        sspe.s1 = 64;
+        sspe.s2 = 64;
+        return true;
+    }
+
+    // 3.8
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_IntStructPack8Explicit([In, Out] IntStructPack8Explicit ispe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_IntStructPack8Explicit(ByValCdeclcaller_IntStructPack8Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_IntStructPack8Explicit_Cdecl( IntStructPack8Explicit ispe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateIntStructPack8Explicit(change_ispe, ispe, "TestMethod_DoCallBack_MarshalStructByVal_IntStructPack8Explicit_Cdecl"));
+        //changed the value
+        ispe.i1 = 64;
+        ispe.i2 = 64;
+        return true;
+    }
+
+    // 3.9
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ByValCdeclcaller_LongStructPack16Explicit([In, Out] LongStructPack16Explicit lspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalByValStruct_Cdecl_LongStructPack16Explicit(ByValCdeclcaller_LongStructPack16Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_LongStructPack16Explicit_Cdecl( LongStructPack16Explicit lspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        LongStructPack16Explicit change_lspe = Helper.NewLongStructPack16Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateLongStructPack16Explicit(change_lspe, lspe, "TestMethod_DoCallBack_MarshalStructByVal_LongStructPack16Explicit_Cdecl"));
+        //changed the value
+        lspe.l1 = 64;
+        lspe.l2 = 64;
+        return true;
+    }
+
+    #endregion
+    
+    #region ReversePinvoke, ByVal, Stdcall
+   
+    // 4.1
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_INNER2([In, Out] INNER2 inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_INNER2(ByValStdcallcaller_INNER2 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_INNER2_Stdcall(INNER2 inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        INNER2 sourceINNER2 = Helper.NewINNER2(1, 1.0F, "some string");
+        Assert.IsTrue(Helper.ValidateINNER2(sourceINNER2, inner2, "TestMethod_DoCallBack_MarshalStructByVal_INNER2_Stdcall"));
+        //changed the value
+        inner2.f1 = 77;
+        inner2.f2 = 77.0F;
+        inner2.f3 = "changed string";
+        return true;
+    }
+    
+    // 4.2
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_InnerExplicit([In, Out] InnerExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_InnerExplicit(ByValStdcallcaller_InnerExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_InnerExplicit_Stdcall(InnerExplicit inner2)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        InnerExplicit source_ie = new InnerExplicit();
+        source_ie.f1 = 1;
+        source_ie.f3 = "Native";
+        Assert.IsTrue(Helper.ValidateInnerExplicit(source_ie, inner2, "TestMethod_DoCallBack_MarshalStructByVal_InnerExplicit_Stdcall"));
+        //changed the value
+        inner2.f1 = 1;
+        inner2.f3 = "changed string";
+        return true;
+    }
+   
+    // 4.3
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_InnerArrayExplicit([In, Out] InnerArrayExplicit inner2);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_InnerArrayExplicit(ByValStdcallcaller_InnerArrayExplicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_InnerArrayExplicit_Stdcall(InnerArrayExplicit iae)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        InnerArrayExplicit source_iae = Helper.NewInnerArrayExplicit(1, 1.0F, "some string", "some string");
+        Assert.IsTrue(Helper.ValidateInnerArrayExplicit(source_iae, iae, "TestMethod_DoCallBack_MarshalStructByVal_InnerArrayExplicit_Stdcall"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            iae.arr[i].f1 = 1;
+            iae.arr[i].f3 = "changed string";
+        }
+        iae.f4 = "changed string";
+        return true;
+    }
+ 
+    // 4.4
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_OUTER3([In, Out] OUTER3 outer3);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_OUTER3(ByValStdcallcaller_OUTER3 caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_OUTER3_Stdcall(OUTER3 outer3)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        OUTER3 sourceOUTER3 = Helper.NewOUTER3(1, 1.0F, "some string", "some string");
+        Assert.IsTrue(Helper.ValidateOUTER3(sourceOUTER3, outer3, "TestMethod_DoCallBack_MarshalStructByVal_OUTER3_Stdcall"));
+        //changed the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            outer3.arr[i].f1 = 1;
+            outer3.arr[i].f2 = 1.0F;
+            outer3.arr[i].f3 = "changed string";
+        }
+        outer3.f4 = "changed string";
+        return true;
+    }
+
+    // 4.5
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_U([In, Out] U u);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_U(ByValStdcallcaller_U caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_U_Stdcall(U u)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        U changeU = 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);
+        Assert.IsTrue(Helper.ValidateU(changeU, u, "TestMethod_DoCallBack_MarshalStructByVal_U_Stdcall"));
+        //changed the value
+        u.d = 1.23;
+        return true;
+    }
+   
+    // 4.6
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_ByteStructPack2Explicit([In, Out] ByteStructPack2Explicit bspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_ByteStructPack2Explicit(ByValStdcallcaller_ByteStructPack2Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_ByteStructPack2Explicit_Stdcall(ByteStructPack2Explicit bspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        ByteStructPack2Explicit change_bspe = Helper.NewByteStructPack2Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateByteStructPack2Explicit(change_bspe, bspe, "TestMethod_DoCallBack_MarshalStructByVal_ByteStructPack2Explicit_Stdcall"));
+        //changed the value
+        bspe.b1 = 64;
+        bspe.b2 = 64;
+        return true;
+    }
+
+    // 4.7
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_ShortStructPack4Explicit([In, Out] ShortStructPack4Explicit sspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_ShortStructPack4Explicit(ByValStdcallcaller_ShortStructPack4Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_ShortStructPack4Explicit_Stdcall(ShortStructPack4Explicit sspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        ShortStructPack4Explicit change_sspe = Helper.NewShortStructPack4Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateShortStructPack4Explicit(change_sspe, sspe, "TestMethod_DoCallBack_MarshalStructByVal_ShortStructPack4Explicit_Stdcall"));
+        //changed the value
+        sspe.s1 = 64;
+        sspe.s2 = 64;
+        return true;
+    }
+
+    // 4.8
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_IntStructPack8Explicit([In, Out] IntStructPack8Explicit ispe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_IntStructPack8Explicit(ByValStdcallcaller_IntStructPack8Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_IntStructPack8Explicit_Stdcall(IntStructPack8Explicit ispe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        IntStructPack8Explicit change_ispe = Helper.NewIntStructPack8Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateIntStructPack8Explicit(change_ispe, ispe, "TestMethod_DoCallBack_MarshalStructByVal_IntStructPack8Explicit_Stdcall"));
+        //changed the value
+        ispe.i1 = 64;
+        ispe.i2 = 64;
+        return true;
+    }
+
+    // 4.9
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ByValStdcallcaller_LongStructPack16Explicit([In, Out] LongStructPack16Explicit lspe);
+
+    [DllImport("ReversePInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalByValStruct_Stdcall_LongStructPack16Explicit(ByValStdcallcaller_LongStructPack16Explicit caller);
+
+    public static bool TestMethod_DoCallBack_MarshalStructByVal_LongStructPack16Explicit_Stdcall(LongStructPack16Explicit lspe)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Stdcall");
+        LongStructPack16Explicit change_lspe = Helper.NewLongStructPack16Explicit(32, 32);
+        Assert.IsTrue(Helper.ValidateLongStructPack16Explicit(change_lspe, lspe, "TestMethod_DoCallBack_MarshalStructByVal_LongStructPack16Explicit_Stdcall"));
+        //changed the value
+        lspe.l1 = 64;
+        lspe.l2 = 64;
+        return true;
+    }
+
+    #endregion
+    
+    #endregion
+
+    static int Main()
+    {
+        try{
+
+            #region calling method
+
+            ////Reverse Pinvoke,ByRef,cdecl
+            DoCallBack_MarshalByRefStruct_Cdecl_INNER2(new ByRefCdeclcaller_INNER2(TestMethod_DoCallBack_MarshalStructByRef_INNER2_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_InnerExplicit(new ByRefCdeclcaller_InnerExplicit(TestMethod_DoCallBack_MarshalStructByRef_InnerExplicit_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_InnerArrayExplicit(new ByRefCdeclcaller_InnerArrayExplicit(TestMethod_DoCallBack_MarshalStructByRef_InnerArrayExplicit_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_OUTER3(new ByRefCdeclcaller_OUTER3(TestMethod_DoCallBack_MarshalStructByRef_OUTER3_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_U(new ByRefCdeclcaller_U(TestMethod_DoCallBack_MarshalStructByRef_U_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_ByteStructPack2Explicit(new ByRefCdeclcaller_ByteStructPack2Explicit(TestMethod_DoCallBack_MarshalStructByRef_ByteStructPack2Explicit_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_ShortStructPack4Explicit(new ByRefCdeclcaller_ShortStructPack4Explicit(TestMethod_DoCallBack_MarshalStructByRef_ShortStructPack4Explicit_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_IntStructPack8Explicit(new ByRefCdeclcaller_IntStructPack8Explicit(TestMethod_DoCallBack_MarshalStructByRef_IntStructPack8Explicit_Cdecl));
+            DoCallBack_MarshalByRefStruct_Cdecl_LongStructPack16Explicit(new ByRefCdeclcaller_LongStructPack16Explicit(TestMethod_DoCallBack_MarshalStructByRef_LongStructPack16Explicit_Cdecl));
+            
+            ////Reverse Pinvoke,ByRef,StdCall
+            DoCallBack_MarshalByRefStruct_Stdcall_INNER2(new ByRefStdcallcaller_INNER2(TestMethod_DoCallBack_MarshalStructByRef_INNER2_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_InnerExplicit(new ByRefStdcallcaller_InnerExplicit(TestMethod_DoCallBack_MarshalStructByRef_InnerExplicit_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_InnerArrayExplicit(new ByRefStdcallcaller_InnerArrayExplicit(TestMethod_DoCallBack_MarshalStructByRef_InnerArrayExplicit_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_OUTER3(new ByRefStdcallcaller_OUTER3(TestMethod_DoCallBack_MarshalStructByRef_OUTER3_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_U(new ByRefStdcallcaller_U(TestMethod_DoCallBack_MarshalStructByRef_U_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_ByteStructPack2Explicit(new ByRefStdcallcaller_ByteStructPack2Explicit(TestMethod_DoCallBack_MarshalStructByRef_ByteStructPack2Explicit_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_ShortStructPack4Explicit(new ByRefStdcallcaller_ShortStructPack4Explicit(TestMethod_DoCallBack_MarshalStructByRef_ShortStructPack4Explicit_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_IntStructPack8Explicit(new ByRefStdcallcaller_IntStructPack8Explicit(TestMethod_DoCallBack_MarshalStructByRef_IntStructPack8Explicit_Stdcall));
+            DoCallBack_MarshalByRefStruct_Stdcall_LongStructPack16Explicit(new ByRefStdcallcaller_LongStructPack16Explicit(TestMethod_DoCallBack_MarshalStructByRef_LongStructPack16Explicit_Stdcall));
+
+            ////Reverse Pinvoke,ByVal,cdecl
+            DoCallBack_MarshalByValStruct_Cdecl_INNER2(new ByValCdeclcaller_INNER2(TestMethod_DoCallBack_MarshalStructByVal_INNER2_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_InnerExplicit(new ByValCdeclcaller_InnerExplicit(TestMethod_DoCallBack_MarshalStructByVal_InnerExplicit_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_InnerArrayExplicit(new ByValCdeclcaller_InnerArrayExplicit(TestMethod_DoCallBack_MarshalStructByVal_InnerArrayExplicit_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_OUTER3(new ByValCdeclcaller_OUTER3(TestMethod_DoCallBack_MarshalStructByVal_OUTER3_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_U(new ByValCdeclcaller_U(TestMethod_DoCallBack_MarshalStructByVal_U_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_ByteStructPack2Explicit(new ByValCdeclcaller_ByteStructPack2Explicit(TestMethod_DoCallBack_MarshalStructByVal_ByteStructPack2Explicit_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_ShortStructPack4Explicit(new ByValCdeclcaller_ShortStructPack4Explicit(TestMethod_DoCallBack_MarshalStructByVal_ShortStructPack4Explicit_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_IntStructPack8Explicit(new ByValCdeclcaller_IntStructPack8Explicit(TestMethod_DoCallBack_MarshalStructByVal_IntStructPack8Explicit_Cdecl));
+            DoCallBack_MarshalByValStruct_Cdecl_LongStructPack16Explicit(new ByValCdeclcaller_LongStructPack16Explicit(TestMethod_DoCallBack_MarshalStructByVal_LongStructPack16Explicit_Cdecl));
+
+            ////Reverse Pinvoke,ByVal,stdcall
+            DoCallBack_MarshalByValStruct_Stdcall_INNER2(new ByValStdcallcaller_INNER2(TestMethod_DoCallBack_MarshalStructByVal_INNER2_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_InnerExplicit(new ByValStdcallcaller_InnerExplicit(TestMethod_DoCallBack_MarshalStructByVal_InnerExplicit_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_InnerArrayExplicit(new ByValStdcallcaller_InnerArrayExplicit(TestMethod_DoCallBack_MarshalStructByVal_InnerArrayExplicit_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_OUTER3(new ByValStdcallcaller_OUTER3(TestMethod_DoCallBack_MarshalStructByVal_OUTER3_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_U(new ByValStdcallcaller_U(TestMethod_DoCallBack_MarshalStructByVal_U_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_ByteStructPack2Explicit(new ByValStdcallcaller_ByteStructPack2Explicit(TestMethod_DoCallBack_MarshalStructByVal_ByteStructPack2Explicit_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_ShortStructPack4Explicit(new ByValStdcallcaller_ShortStructPack4Explicit(TestMethod_DoCallBack_MarshalStructByVal_ShortStructPack4Explicit_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_IntStructPack8Explicit(new ByValStdcallcaller_IntStructPack8Explicit(TestMethod_DoCallBack_MarshalStructByVal_IntStructPack8Explicit_Stdcall));
+            DoCallBack_MarshalByValStruct_Stdcall_LongStructPack16Explicit(new ByValStdcallcaller_LongStructPack16Explicit(TestMethod_DoCallBack_MarshalStructByVal_LongStructPack16Explicit_Stdcall));
+        
+            #endregion
+
+            return 100;
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine($"Test Failure: {e}");
+            return 101;
+        }
+    }
+}
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ReversePInvokeManaged/ReversePInvokeTest.csproj b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ReversePInvokeManaged/ReversePInvokeTest.csproj
new file mode 100644
index 0000000000..ea6ff85431
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalExpStruct/ReversePInvokeManaged/ReversePInvokeTest.csproj
@@ -0,0 +1,40 @@
+<?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>ReversePInvokeTest</AssemblyName>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\..\..\..\</SolutionDir>
+    <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <!-- Test unsupported outside of windows -->
+    <TestUnsupportedOutsideWindows>true</TestUnsupportedOutsideWindows>
+    <DisableProjectBuild Condition="'$(TargetsUnix)' == 'true'">true</DisableProjectBuild>
+  </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="ReversePInvokeTest.cs" />
+    <Compile Include="..\..\Helper.cs" />
+    <Compile Include="..\..\Struct.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CMakeLists.txt" />
+  </ItemGroup>
+  <Import Project="../../../../Interop.settings.targets" />
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
+</Project>
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/CMakeLists.txt b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/CMakeLists.txt
new file mode 100644
index 0000000000..0b3aef3904
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required (VERSION 2.6) 
+project (SeqPInvokeNative) 
+include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") 
+include_directories(${INC_PLATFORM_DIR}) 
+set(SOURCES 
+    SeqStructDelRevPInvokeNative.cpp 
+) 
+add_library (SeqPInvokeNative SHARED ${SOURCES}) 
+target_link_libraries(SeqPInvokeNative ${LINK_LIBRARIES_ADDITIONAL}) 
+# add the install targets 
+install (TARGETS SeqPInvokeNative DESTINATION bin) 
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest.cs b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest.cs
new file mode 100644
index 0000000000..ad63deebdd
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest.cs
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest.csproj b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest.csproj
new file mode 100644
index 0000000000..b579275ec2
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/DelegatePInvoke/DelegatePInvokeTest.csproj
@@ -0,0 +1,37 @@
+<?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>DelegatePInvokeTest</AssemblyName>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\..\..\..\</SolutionDir>
+    <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </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="DelegatePInvokeTest.cs" />
+    <Compile Include="..\..\Helper.cs" />
+    <Compile Include="..\..\Struct.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CMakeLists.txt" />
+  </ItemGroup>
+  <Import Project="../../../../Interop.settings.targets" />
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
+</Project>
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs
new file mode 100644
index 0000000000..a6e789c30f
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj
new file mode 100644
index 0000000000..5b3703f4e8
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj
@@ -0,0 +1,37 @@
+<?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>ReversePInvokeTest</AssemblyName>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{F1E66554-8C8E-4141-85CF-D0CD6A0CD0B0}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\..\..\..\..\</SolutionDir>
+    <DefineConstants>$(DefineConstants);STATIC</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </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="ReversePInvokeTest.cs" />
+    <Compile Include="..\..\Helper.cs" />
+    <Compile Include="..\..\Struct.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CMakeLists.txt" />
+  </ItemGroup>
+  <Import Project="../../../../Interop.settings.targets" />
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
+</Project>
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp
new file mode 100644
index 0000000000..08f069c707
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp
@@ -0,0 +1,3241 @@
+// 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>
+#include "platformdefines.h"
+#include "SeqStructDelRevPInvokeNative.h"
+
+const char* NativeStr = "Native";
+//const size_t size = strlen(NativeStr);
+
+struct ScriptParamType
+{
+    int idata;
+    int useless; //Use this as pedding, since in the Manage code,the union starts at offset 8
+    union unionType
+    {
+        bool bdata;
+        double ddata;
+        int * ptrdata;
+    }udata;
+};
+
+struct ComplexStruct
+{
+    INT i;
+    CHAR b;
+    LPCSTR str;
+    //use this(padding), since in the Mac, it use 4bytes as struct pack(In windows, it is 8 bytes). 
+    //if i dont add this. In Mac, it will try to replace the value of (pedding) with idata's value
+    LPVOID padding;//padding
+    ScriptParamType type;
+};
+
+
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructComplexStructByRef_Cdecl(ComplexStruct * pcs)
+{                       
+    //Check the Input    
+    if((321 != pcs->i)||(!pcs->b)||(0 != strcmp(pcs->str,"Managed"))||(123 != pcs->type.idata)||(0x120000 != (int)(LONG64)(pcs->type.udata.ptrdata)))
+    {
+
+        printf("The parameter for MarshalRefStruct_Cdecl is wrong\n");
+        printf("ComplexStruct:%d:%d,%s,%d,%d\n",pcs->i,pcs->b,pcs->str,pcs->type.idata,(int)(LONG64)(pcs->type.udata.ptrdata));
+        return FALSE;
+    }
+    CoreClrFree((LPVOID)pcs->str);
+
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+    char * pstr = (char*)CoreClrAlloc((lsize + 1) * sizeof(char));
+    memset(pstr,0,lsize+1);
+
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+
+    //Change the value
+    pcs->i = 9999;
+    pcs->b = false;
+    pcs->str = pstr;
+    pcs->type.idata = -1;
+    pcs->type.udata.ddata = 3.14159;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructComplexStructByRef_StdCall(ComplexStruct * pcs)
+{
+    //Check the input
+    if((321 != pcs->i)||(!pcs->b)||(0 != strcmp(pcs->str,"Managed"))||(123 != pcs->type.idata)||(0x120000 != (int)(LONG64)(pcs->type.udata.ptrdata)))
+    {
+        printf("The parameter for MarshalRefStruct_StdCall is wrong\n");
+        return FALSE;
+    }
+    CoreClrFree((LPVOID)pcs->str);
+
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+    char * pstr = (char*)CoreClrAlloc(lsize + 1);
+    memset(pstr,0,lsize+1);
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+
+    //Change the value
+    pcs->i = 9999;
+    pcs->b = false;
+    pcs->str = pstr;
+    pcs->type.idata = -1;
+    pcs->type.udata.ddata = 3.14159;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *ComplexStructByRefCdeclCaller)(ComplexStruct* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructComplexStructByRef_Cdecl(ComplexStructByRefCdeclCaller caller)
+{
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+
+    //Init
+    char * pstr = (char*)CoreClrAlloc(lsize + 1);
+    memset(pstr,0,lsize+1);
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+
+    ComplexStruct cs;
+    cs.i = 9999;
+    cs.b = false;
+    cs.str = pstr;
+    cs.type.idata = -1;
+    cs.type.udata.ddata = 3.14159;
+
+    if(!caller(&cs))
+    {
+        printf("DoCallBack_MarshalByRefStruct_Cdecl:The Caller return wrong value!\n");
+        return FALSE;
+    }
+
+    if((321 != cs.i)||(!cs.b)||(0 != strcmp(cs.str,"Managed"))||(123 != cs.type.idata)||(0x120000 != (int)(LONG64)(cs.type.udata.ptrdata)))
+    {
+        printf("The parameter for DoCallBack_MarshalRefStruct_Cdecl is wrong\n");
+        return FALSE;
+    }
+    CoreClrFree((LPVOID)cs.str);
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ComplexStructByRefStdCallCaller)(ComplexStruct* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructComplexStructByRef_StdCall(ComplexStructByRefStdCallCaller caller)
+{
+    const char* lNativeStr = "Native";
+    const size_t lsize = strlen(lNativeStr);
+
+    //init
+    char * pstr = (char*)CoreClrAlloc(lsize + 1);
+    memset(pstr,0,lsize+1);
+    strncpy_s(pstr,lsize+1,lNativeStr,lsize);
+
+    ComplexStruct cs;
+    cs.i = 9999;
+    cs.b = false;
+    cs.str = pstr;
+    cs.type.idata = -1;
+    cs.type.udata.ddata = 3.14159;
+
+    if(!caller(&cs))
+    {
+        printf("DoCallBack_MarshalByRefStruct_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    if((321 != cs.i)||(!cs.b)||(0 != strcmp(cs.str,"Managed"))||(123 != cs.type.idata)||(0x120000 != (int)(LONG64)(cs.type.udata.ptrdata)))
+    {
+        printf("The parameter for DoCallBack_MarshalRefStruct_StdCall is wrong\n");
+        return FALSE;
+    }
+    CoreClrFree((LPVOID)cs.str);
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *ComplexStructDelegatePInvokeByRefCdeclCaller)(ComplexStruct* pcs);
+extern "C" DLL_EXPORT ComplexStructDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructComplexStructByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructComplexStructByRef_Cdecl;
+}
+
+typedef BOOL (__stdcall *ComplexStructDelegatePInvokeByRefStdCallCaller)(ComplexStruct* pcs);
+extern "C" DLL_EXPORT ComplexStructDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructComplexStructByRef_StdCall_FuncPtr()
+{
+    return MarshalStructComplexStructByRef_StdCall;
+}
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructComplexStructByVal_Cdecl(ComplexStruct cs)
+{
+    //Check the Input    
+    if((321 != cs.i)||(!cs.b)||(0 != strcmp(cs.str,"Managed"))||(123 != cs.type.idata)||(0x120000 != (int)(LONG64)(cs.type.udata.ptrdata)))
+    {
+
+        printf("The parameter for MarshalStructComplexStructByVal_Cdecl is wrong\n");
+        printf("ComplexStruct:%d:%d,%s,%d,%d\n",cs.i,cs.b,cs.str,cs.type.idata,(int)(LONG64)(cs.type.udata.ptrdata));
+        return FALSE;
+    }
+
+    cs.i = 9999;
+    cs.b = false;
+    cs.str = "Native";
+    cs.type.idata = -1;
+    cs.type.udata.ddata = 3.14159;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructComplexStructByVal_StdCall(ComplexStruct cs)
+{
+    //Check the input
+    if((321 != cs.i)||(!cs.b)||(0 != strcmp(cs.str,"Managed"))||(123 != cs.type.idata)||(0x120000 != (int)(LONG64)(cs.type.udata.ptrdata)))
+    {
+        printf("The parameter for MarshalStructComplexStructByVal_StdCall is wrong\n");
+        return FALSE;
+    }
+
+    cs.i = 9999;
+    cs.b = false;
+    cs.str = "Native";
+    cs.type.idata = -1;
+    cs.type.udata.ddata = 3.14159;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *ComplexStructByValCdeclCaller)(ComplexStruct cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructComplexStructByVal_Cdecl(ComplexStructByValCdeclCaller caller)
+{
+    //Init
+    ComplexStruct cs;
+    cs.i = 9999;
+    cs.b = false;
+    cs.str = "Native";
+    cs.type.idata = -1;
+    cs.type.udata.ddata = 3.14159;
+
+    if(!caller(cs))
+    {
+        printf("DoCallBack_MarshalStructComplexStructByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if((9999 != cs.i)||(cs.b)||(0 != strcmp(cs.str,NativeStr))||(-1 != cs.type.idata)||(3.14159 != cs.type.udata.ddata))
+    {
+        printf("The parameter for DoCallBack_MarshalByValStruct_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *ComplexStructByValStdCallCaller)(ComplexStruct cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructComplexStructByVal_StdCall(ComplexStructByValStdCallCaller caller)
+{
+    ComplexStruct cs;
+    cs.i = 9999;
+    cs.b = false;
+    cs.str = "Native";
+    cs.type.idata = -1;
+    cs.type.udata.ddata = 3.14159;
+
+    if(!caller(cs))
+    {
+        printf("The parameter for DoCallBack_MarshalStructComplexStructByVal_StdCall is wrong\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if((9999 != cs.i)||(cs.b)||(0 != strcmp(cs.str,NativeStr))||(-1 != cs.type.idata)||(3.14159 != cs.type.udata.ddata))
+    {
+        printf("DoCallBack_MarshalStructComplexStructByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *ComplexStructDelegatePInvokeByValCdeclCaller)(ComplexStruct cs);
+extern "C" DLL_EXPORT ComplexStructDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructComplexStructByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructComplexStructByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *ComplexStructDelegatePInvokeByValStdCallCaller)(ComplexStruct cs);
+extern "C" DLL_EXPORT ComplexStructDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructComplexStructByVal_StdCall_FuncPtr()
+{
+    return MarshalStructComplexStructByVal_StdCall;
+}
+
+///////////////////////////////////////////Methods for InnerSequential struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructInnerSequentialByRef_Cdecl(InnerSequential* argstr)
+{
+    if(!IsCorrectInnerSequential(argstr))
+    {
+        printf("\tMarshalStructInnerSequentialByRef_Cdecl: InnerSequential param not as expected\n");
+        PrintInnerSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeInnerSequential(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructInnerSequentialByRef_StdCall(InnerSequential* argstr)
+{
+    if(!IsCorrectInnerSequential(argstr))
+    {
+        printf("\tMarshalStructInnerSequentialByRef_StdCall: InnerSequential param not as expected\n");
+        PrintInnerSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeInnerSequential(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *InnerSequentialByRefCdeclCaller)(InnerSequential* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructInnerSequentialByRef_Cdecl(InnerSequentialByRefCdeclCaller caller)
+{
+    //Init
+    InnerSequential argstr;
+    argstr.f1 = 77;
+    argstr.f2 = 77.0;
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.f3 = temp;
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerSequentialByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectInnerSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructInnerSequentialByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *InnerSequentialByRefStdCallCaller)(InnerSequential* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructInnerSequentialByRef_StdCall(InnerSequentialByRefStdCallCaller caller)
+{
+    //Init
+    InnerSequential argstr;
+    argstr.f1 = 77;
+    argstr.f2 = 77.0;
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.f3 = temp;
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerSequentialByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectInnerSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructInnerSequentialByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *InnerSequentialDelegatePInvokeByRefCdeclCaller)(InnerSequential* pcs);
+extern "C" DLL_EXPORT InnerSequentialDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructInnerSequentialByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructInnerSequentialByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *InnerSequentialDelegatePInvokeByRefStdCallCaller)(InnerSequential* pcs);
+extern "C" DLL_EXPORT InnerSequentialDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructInnerSequentialByRef_StdCall_FuncPtr()
+{
+    return MarshalStructInnerSequentialByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructInnerSequentialByVal_Cdecl(InnerSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectInnerSequential(&argstr))
+    {
+        printf("\tMarshalStructInnerSequentialByVal_Cdecl: InnerSequential param not as expected\n");
+        PrintInnerSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.f1 = 77;
+    argstr.f2 = 77.0;
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.f3 = temp;
+    }
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructInnerSequentialByVal_StdCall(InnerSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectInnerSequential(&argstr))
+    {
+        printf("\tMarshalStructInnerSequentialByVal_StdCall: InnerSequential param not as expected\n");
+        PrintInnerSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.f1 = 77;
+    argstr.f2 = 77.0;
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.f3 = temp;
+    }
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *InnerSequentialByValCdeclCaller)(InnerSequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructInnerSequentialByVal_Cdecl(InnerSequentialByValCdeclCaller caller)
+{
+    //Init
+    InnerSequential argstr{};
+    argstr.f1 = 77;
+    argstr.f2 = 77.0;
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.f3 = temp;
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.f1 != 77 || argstr.f2 != 77.0 || strcmp((char*)argstr.f3, "changed string") != 0)
+    {
+        printf("The parameter for DoCallBack_MarshalStructInnerSequentialByVal_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *InnerSequentialByValStdCallCaller)(InnerSequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructInnerSequentialByVal_StdCall(InnerSequentialByValStdCallCaller caller)
+{
+    //Init
+    InnerSequential argstr{};
+    argstr.f1 = 77;
+    argstr.f2 = 77.0;
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.f3 = temp;
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerSequentialByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.f1 != 77 || argstr.f2 != 77.0 || strcmp((char*)argstr.f3, "changed string") != 0)
+    {
+        printf("The parameter for DoCallBack_MarshalStructInnerSequentialByVal_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *InnerSequentialDelegatePInvokeByValCdeclCaller)(InnerSequential cs);
+extern "C" DLL_EXPORT InnerSequentialDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructInnerSequentialByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructInnerSequentialByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *InnerSequentialDelegatePInvokeByValStdCallCaller)(InnerSequential cs);
+extern "C" DLL_EXPORT InnerSequentialDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructInnerSequentialByVal_StdCall_FuncPtr()
+{
+    return MarshalStructInnerSequentialByVal_StdCall;
+}
+
+
+///////////////////////////////////////////Methods for InnerArraySequential struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructInnerArraySequentialByRef_Cdecl(InnerArraySequential* argstr)
+{
+    if(!IsCorrectInnerArraySequential(argstr))
+    {
+        printf("\tMarshalStructInnerArraySequentialByRef_Cdecl: InnerArraySequential param not as expected\n");
+        PrintInnerArraySequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeInnerArraySequential(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructInnerArraySequentialByRef_StdCall(InnerArraySequential* argstr)
+{
+    if(!IsCorrectInnerArraySequential(argstr))
+    {
+        printf("\tMarshalStructInnerArraySequentialByRef_StdCall: InnerArraySequential param not as expected\n");
+        PrintInnerArraySequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeInnerArraySequential(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *InnerArraySequentialByRefCdeclCaller)(InnerArraySequential* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructInnerArraySequentialByRef_Cdecl(InnerArraySequentialByRefCdeclCaller caller)
+{
+    //Init
+    InnerArraySequential argstr;
+
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        argstr.arr[i].f1 = 77;
+        argstr.arr[i].f2 = 77.0;
+        const char* lpstr = "changed string";
+        size_t size = sizeof(char) * (strlen(lpstr) + 1);
+        LPSTR temp = (LPSTR)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,lpstr);
+            argstr.arr[i].f3 = temp;
+        }
+        else
+        {
+            printf("Memory Allocated Failed!");
+        }
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerArraySequentialByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectInnerArraySequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructInnerArraySequentialByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *InnerArraySequentialByRefStdCallCaller)(InnerArraySequential* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructInnerArraySequentialByRef_StdCall(InnerArraySequentialByRefStdCallCaller caller)
+{
+    //Init
+    InnerArraySequential argstr;
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        argstr.arr[i].f1 = 77;
+        argstr.arr[i].f2 = 77.0;
+        const char* lpstr = "changed string";
+        size_t size = sizeof(char) * (strlen(lpstr) + 1);
+        LPSTR temp = (LPSTR)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,lpstr);
+            argstr.arr[i].f3 = temp;
+        }
+        else
+        {
+            printf("Memory Allocated Failed!");
+        }
+    }
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerArraySequentialByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectInnerArraySequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructInnerArraySequentialByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *InnerArraySequentialDelegatePInvokeByRefCdeclCaller)(InnerArraySequential* pcs);
+extern "C" DLL_EXPORT InnerArraySequentialDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructInnerArraySequentialByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructInnerArraySequentialByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *InnerArraySequentialDelegatePInvokeByRefStdCallCaller)(InnerArraySequential* pcs);
+extern "C" DLL_EXPORT InnerArraySequentialDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructInnerArraySequentialByRef_StdCall_FuncPtr()
+{
+    return MarshalStructInnerArraySequentialByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructInnerArraySequentialByVal_Cdecl(InnerArraySequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectInnerArraySequential(&argstr))
+    {
+        printf("\tMarshalStructInnerArraySequentialByVal_Cdecl: InnerArraySequential param not as expected\n");
+        PrintInnerArraySequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        argstr.arr[i].f1 = 77;
+        argstr.arr[i].f2 = 77.0;
+        const char* lpstr = "changed string";
+        size_t size = sizeof(char) * (strlen(lpstr) + 1);
+        LPSTR temp = (LPSTR)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,lpstr);
+            argstr.arr[i].f3 = temp;
+        }
+        else
+        {
+            printf("Memory Allocated Failed!");
+        }
+    }
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructInnerArraySequentialByVal_StdCall(InnerArraySequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectInnerArraySequential(&argstr))
+    {
+        printf("\tMarshalStructInnerArraySequentialByVal_StdCall: InnerArraySequential param not as expected\n");
+        PrintInnerArraySequential(&argstr,"argstr");
+        return FALSE;
+    }
+    for(int i = 0; i<NumArrElements;i++)
+    {
+        argstr.arr[i].f1 = 77;
+        argstr.arr[i].f2 = 77.0;
+        const char* lpstr = "changed string";
+        size_t size = sizeof(char) * (strlen(lpstr) + 1);
+        LPSTR temp = (LPSTR)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,lpstr);
+            argstr.arr[i].f3 = temp;
+        }
+        else
+        {
+            printf("Memory Allocated Failed!");
+        }
+    }
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *InnerArraySequentialByValCdeclCaller)(InnerArraySequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructInnerArraySequentialByVal_Cdecl(InnerArraySequentialByValCdeclCaller caller)
+{
+    //Init
+    InnerArraySequential argstr;
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        argstr.arr[i].f1 = 77;
+        argstr.arr[i].f2 = 77.0;
+        const char* lpstr = "changed string";
+        size_t size = sizeof(char) * (strlen(lpstr) + 1);
+        LPSTR temp = (LPSTR)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,lpstr);
+            argstr.arr[i].f3 = temp;
+        }
+        else
+        {
+            printf("Memory Allocated Failed!");
+        }
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerArraySequentialByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    for(int i =0;i<NumArrElements;i++)
+    {
+        if(argstr.arr[i].f1 != 77 || argstr.arr[i].f2 != 77.0 || strcmp((char*)argstr.arr[i].f3, "changed string") != 0)
+        {
+            printf("The parameter for DoCallBack_MarshalStructInnerArraySequentialByVal_Cdecl is wrong\n");
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *InnerArraySequentialByValStdCallCaller)(InnerArraySequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructInnerArraySequentialByVal_StdCall(InnerArraySequentialByValStdCallCaller caller)
+{
+    //Init
+    InnerArraySequential argstr;
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        argstr.arr[i].f1 = 77;
+        argstr.arr[i].f2 = 77.0;
+        const char* lpstr = "changed string";
+        size_t size = sizeof(char) * (strlen(lpstr) + 1);
+        LPSTR temp = (LPSTR)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,lpstr);
+            argstr.arr[i].f3 = temp;
+        }
+        else
+        {
+            printf("Memory Allocated Failed!");
+        }
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructInnerArraySequentialByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    for(int i = 0;i<NumArrElements;i++)
+    {
+        if(argstr.arr[i].f1 != 77 || argstr.arr[i].f2 != 77.0 || strcmp((char*)argstr.arr[i].f3, "changed string") != 0)
+        {
+            printf("The parameter for DoCallBack_MarshalStructInnerArraySequentialByVal_StdCall is wrong\n");
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *InnerArraySequentialDelegatePInvokeByValCdeclCaller)(InnerArraySequential cs);
+extern "C" DLL_EXPORT InnerArraySequentialDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructInnerArraySequentialByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructInnerArraySequentialByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *InnerArraySequentialDelegatePInvokeByValStdCallCaller)(InnerArraySequential cs);
+extern "C" DLL_EXPORT InnerArraySequentialDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructInnerArraySequentialByVal_StdCall_FuncPtr()
+{
+    return MarshalStructInnerArraySequentialByVal_StdCall;
+}
+
+///////////////////////////////////////////Methods for CharSetAnsiSequential struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructCharSetAnsiSequentialByRef_Cdecl(CharSetAnsiSequential* argstr)
+{
+    if(!IsCorrectCharSetAnsiSequential(argstr))
+    {
+        printf("\tMarshalStructCharSetAnsiSequentialByRef_Cdecl: CharSetAnsiSequential param not as expected\n");
+        PrintCharSetAnsiSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeCharSetAnsiSequential(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructCharSetAnsiSequentialByRef_StdCall(CharSetAnsiSequential* argstr)
+{
+    if(!IsCorrectCharSetAnsiSequential(argstr))
+    {
+        printf("\tMarshalStructCharSetAnsiSequentialByRef_StdCall: CharSetAnsiSequential param not as expected\n");
+        PrintCharSetAnsiSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeCharSetAnsiSequential(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *CharSetAnsiSequentialByRefCdeclCaller)(CharSetAnsiSequential* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructCharSetAnsiSequentialByRef_Cdecl(CharSetAnsiSequentialByRefCdeclCaller caller)
+{
+    //Init
+    CharSetAnsiSequential argstr;
+
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetAnsiSequentialByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectCharSetAnsiSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetAnsiSequentialByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *CharSetAnsiSequentialByRefStdCallCaller)(CharSetAnsiSequential* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructCharSetAnsiSequentialByRef_StdCall(CharSetAnsiSequentialByRefStdCallCaller caller)
+{
+    //Init
+    CharSetAnsiSequential argstr;
+
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetAnsiSequentialByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectCharSetAnsiSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetAnsiSequentialByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *CharSetAnsiSequentialDelegatePInvokeByRefCdeclCaller)(CharSetAnsiSequential* pcs);
+extern "C" DLL_EXPORT CharSetAnsiSequentialDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructCharSetAnsiSequentialByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructCharSetAnsiSequentialByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *CharSetAnsiSequentialDelegatePInvokeByRefStdCallCaller)(CharSetAnsiSequential* pcs);
+extern "C" DLL_EXPORT CharSetAnsiSequentialDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructCharSetAnsiSequentialByRef_StdCall_FuncPtr()
+{
+    return MarshalStructCharSetAnsiSequentialByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructCharSetAnsiSequentialByVal_Cdecl(CharSetAnsiSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectCharSetAnsiSequential(&argstr))
+    {
+        printf("\tMarshalStructCharSetAnsiSequentialByVal_Cdecl: CharSetAnsiSequential param not as expected\n");
+        PrintCharSetAnsiSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructCharSetAnsiSequentialByVal_StdCall(CharSetAnsiSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectCharSetAnsiSequential(&argstr))
+    {
+        printf("\tMarshalStructCharSetAnsiSequentialByVal_StdCall: CharSetAnsiSequential param not as expected\n");
+        PrintCharSetAnsiSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *CharSetAnsiSequentialByValCdeclCaller)(CharSetAnsiSequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructCharSetAnsiSequentialByVal_Cdecl(CharSetAnsiSequentialByValCdeclCaller caller)
+{
+    //Init
+    CharSetAnsiSequential argstr{};
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetAnsiSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(strcmp((char*)argstr.f1,"change string") != 0 || argstr.f2 != 'n')
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetAnsiSequentialByVal_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *CharSetAnsiSequentialByValStdCallCaller)(CharSetAnsiSequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructCharSetAnsiSequentialByVal_StdCall(CharSetAnsiSequentialByValStdCallCaller caller)
+{
+    //Init
+    CharSetAnsiSequential argstr{};
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetAnsiSequentialByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(strcmp((char*)argstr.f1,"change string") != 0 || argstr.f2 != 'n')
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetAnsiSequentialByVal_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *CharSetAnsiSequentialDelegatePInvokeByValCdeclCaller)(CharSetAnsiSequential cs);
+extern "C" DLL_EXPORT CharSetAnsiSequentialDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructCharSetAnsiSequentialByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructCharSetAnsiSequentialByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *CharSetAnsiSequentialDelegatePInvokeByValStdCallCaller)(CharSetAnsiSequential cs);
+extern "C" DLL_EXPORT CharSetAnsiSequentialDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructCharSetAnsiSequentialByVal_StdCall_FuncPtr()
+{
+    return MarshalStructCharSetAnsiSequentialByVal_StdCall;
+}
+
+
+///////////////////////////////////////////Methods for CharSetUnicodeSequential struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructCharSetUnicodeSequentialByRef_Cdecl(CharSetUnicodeSequential* argstr)
+{
+    if(!IsCorrectCharSetUnicodeSequential(argstr))
+    {
+        printf("\tMarshalStructCharSetUnicodeSequentialByRef_Cdecl: CharSetUnicodeSequential param not as expected\n");
+        PrintCharSetUnicodeSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeCharSetUnicodeSequential(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructCharSetUnicodeSequentialByRef_StdCall(CharSetUnicodeSequential* argstr)
+{
+    if(!IsCorrectCharSetUnicodeSequential(argstr))
+    {
+        printf("\tMarshalStructCharSetUnicodeSequentialByRef_StdCall: CharSetUnicodeSequential param not as expected\n");
+        PrintCharSetUnicodeSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeCharSetUnicodeSequential(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *CharSetUnicodeSequentialByRefCdeclCaller)(CharSetUnicodeSequential* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_Cdecl(CharSetUnicodeSequentialByRefCdeclCaller caller)
+{
+    //Init
+    CharSetUnicodeSequential argstr;
+
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len = wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        //wcscpy((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource);
+        wcscpy_s((WCHAR*)temp,len+1,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectCharSetUnicodeSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *CharSetUnicodeSequentialByRefStdCallCaller)(CharSetUnicodeSequential* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_StdCall(CharSetUnicodeSequentialByRefStdCallCaller caller)
+{
+    //Init
+    CharSetUnicodeSequential argstr;
+
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len = wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        //wcscpy((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource);
+        wcscpy_s((WCHAR*)temp,len+1,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectCharSetUnicodeSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *CharSetUnicodeSequentialDelegatePInvokeByRefCdeclCaller)(CharSetUnicodeSequential* pcs);
+extern "C" DLL_EXPORT CharSetUnicodeSequentialDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructCharSetUnicodeSequentialByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructCharSetUnicodeSequentialByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *CharSetUnicodeSequentialDelegatePInvokeByRefStdCallCaller)(CharSetUnicodeSequential* pcs);
+extern "C" DLL_EXPORT CharSetUnicodeSequentialDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructCharSetUnicodeSequentialByRef_StdCall_FuncPtr()
+{
+    return MarshalStructCharSetUnicodeSequentialByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructCharSetUnicodeSequentialByVal_Cdecl(CharSetUnicodeSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectCharSetUnicodeSequential(&argstr))
+    {
+        printf("\tMarshalStructCharSetUnicodeSequentialByVal_Cdecl: CharSetUnicodeSequential param not as expected\n");
+        PrintCharSetUnicodeSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len = wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        //wcscpy((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource);
+        wcscpy_s((WCHAR*)temp,len+1,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructCharSetUnicodeSequentialByVal_StdCall(CharSetUnicodeSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectCharSetUnicodeSequential(&argstr))
+    {
+        printf("\tMarshalStructCharSetUnicodeSequentialByVal_StdCall: CharSetUnicodeSequential param not as expected\n");
+        PrintCharSetUnicodeSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len = wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        //wcscpy((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource);
+        wcscpy_s((WCHAR*)temp,len+1,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *CharSetUnicodeSequentialByValCdeclCaller)(CharSetUnicodeSequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_Cdecl(CharSetUnicodeSequentialByValCdeclCaller caller)
+{
+    //Init
+    CharSetUnicodeSequential argstr{};
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len =wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        //wcscpy((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource);
+        wcscpy_s((WCHAR*)temp,len+1,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(0 != wcscmp(const_cast<WCHAR*>(argstr.f1), const_cast<WCHAR*>(W("change string"))) || argstr.f2 != L'n')
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *CharSetUnicodeSequentialByValStdCallCaller)(CharSetUnicodeSequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_StdCall(CharSetUnicodeSequentialByValStdCallCaller caller)
+{
+    //Init
+    CharSetUnicodeSequential argstr{};
+    WCHAR* strSource = (WCHAR*)(W("change string"));
+    size_t len =wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        //wcscpy((WCHAR*)temp, (len+1)*sizeof(WCHAR), strSource);
+        wcscpy_s((WCHAR*)temp,len+1,strSource);
+        argstr.f1 = temp;
+        argstr.f2 = 'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(0 != wcscmp(const_cast<WCHAR*>(argstr.f1), const_cast<WCHAR*>(W("change string"))) || argstr.f2 != L'n')
+    {
+        printf("The parameter for DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *CharSetUnicodeSequentialDelegatePInvokeByValCdeclCaller)(CharSetUnicodeSequential cs);
+extern "C" DLL_EXPORT CharSetUnicodeSequentialDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructCharSetUnicodeSequentialByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructCharSetUnicodeSequentialByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *CharSetUnicodeSequentialDelegatePInvokeByValStdCallCaller)(CharSetUnicodeSequential cs);
+extern "C" DLL_EXPORT CharSetUnicodeSequentialDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructCharSetUnicodeSequentialByVal_StdCall_FuncPtr()
+{
+    return MarshalStructCharSetUnicodeSequentialByVal_StdCall;
+}
+
+
+///////////////////////////////////////////Methods for NumberSequential struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructNumberSequentialByRef_Cdecl(NumberSequential* argstr)
+{
+    if(!IsCorrectNumberSequential(argstr))
+    {
+        printf("\tMarshalStructNumberSequentialByRef_Cdecl: NumberSequential param not as expected\n");
+        PrintNumberSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeNumberSequential(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructNumberSequentialByRef_StdCall(NumberSequential* argstr)
+{
+    if(!IsCorrectNumberSequential(argstr))
+    {
+        printf("\tMarshalStructNumberSequentialByRef_StdCall: NumberSequential param not as expected\n");
+        PrintNumberSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeNumberSequential(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *NumberSequentialByRefCdeclCaller)(NumberSequential* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructNumberSequentialByRef_Cdecl(NumberSequentialByRefCdeclCaller caller)
+{
+    //Init
+    NumberSequential argstr;
+
+    argstr.i32 = 0;
+    argstr.ui32 = 32;
+    argstr.s1 = 0;
+    argstr.us1 = 16;
+    argstr.b = 0;
+    argstr.sb = 8;
+    argstr.i16 = 0;
+    argstr.ui16 = 16;
+    argstr.i64 = 0;
+    argstr.ui64 = 64;
+    argstr.sgl = 64.0;
+    argstr.d = 6.4;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructNumberSequentialByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectNumberSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructNumberSequentialByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *NumberSequentialByRefStdCallCaller)(NumberSequential* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructNumberSequentialByRef_StdCall(NumberSequentialByRefStdCallCaller caller)
+{
+    //Init
+    NumberSequential argstr;
+
+    argstr.i32 = 0;
+    argstr.ui32 = 32;
+    argstr.s1 = 0;
+    argstr.us1 = 16;
+    argstr.b = 0;
+    argstr.sb = 8;
+    argstr.i16 = 0;
+    argstr.ui16 = 16;
+    argstr.i64 = 0;
+    argstr.ui64 = 64;
+    argstr.sgl = 64.0;
+    argstr.d = 6.4;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructNumberSequentialByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectNumberSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructNumberSequentialByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *NumberSequentialDelegatePInvokeByRefCdeclCaller)(NumberSequential* pcs);
+extern "C" DLL_EXPORT NumberSequentialDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructNumberSequentialByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructNumberSequentialByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *NumberSequentialDelegatePInvokeByRefStdCallCaller)(NumberSequential* pcs);
+extern "C" DLL_EXPORT NumberSequentialDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructNumberSequentialByRef_StdCall_FuncPtr()
+{
+    return MarshalStructNumberSequentialByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructNumberSequentialByVal_Cdecl(NumberSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectNumberSequential(&argstr))
+    {
+        printf("\tMarshalStructNumberSequentialByVal_Cdecl: NumberSequential param not as expected\n");
+        PrintNumberSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.i32 = 0;
+    argstr.ui32 = 32;
+    argstr.s1 = 0;
+    argstr.us1 = 16;
+    argstr.b = 0;
+    argstr.sb = 8;
+    argstr.i16 = 0;
+    argstr.ui16 = 16;
+    argstr.i64 = 0;
+    argstr.ui64 = 64;
+    argstr.sgl = 64.0;
+    argstr.d = 6.4;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructNumberSequentialByVal_StdCall(NumberSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectNumberSequential(&argstr))
+    {
+        printf("\tMarshalStructNumberSequentialByVal_StdCall: NumberSequential param not as expected\n");
+        PrintNumberSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.i32 = 0;
+    argstr.ui32 = 32;
+    argstr.s1 = 0;
+    argstr.us1 = 16;
+    argstr.b = 0;
+    argstr.sb = 8;
+    argstr.i16 = 0;
+    argstr.ui16 = 16;
+    argstr.i64 = 0;
+    argstr.ui64 = 64;
+    argstr.sgl = 64.0;
+    argstr.d = 6.4;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *NumberSequentialByValCdeclCaller)(NumberSequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructNumberSequentialByVal_Cdecl(NumberSequentialByValCdeclCaller caller)
+{
+    //Init
+    NumberSequential argstr;
+
+    argstr.i32 = 0;
+    argstr.ui32 = 32;
+    argstr.s1 = 0;
+    argstr.us1 = 16;
+    argstr.b = 0;
+    argstr.sb = 8;
+    argstr.i16 = 0;
+    argstr.ui16 = 16;
+    argstr.i64 = 0;
+    argstr.ui64 = 64;
+    argstr.sgl = 64.0;
+    argstr.d = 6.4;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructNumberSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i32 != 0 || argstr.ui32 != 32 || argstr.s1 != 0 || argstr.us1 != 16 || argstr.b != 0 ||
+        argstr.sb != 8 || argstr.i16 != 0 || argstr.ui16 != 16 || argstr.i64 != 0 || argstr.ui64 != 64 ||
+        argstr.sgl != 64.0 || argstr.d != 6.4)
+    {
+        printf("The parameter for DoCallBack_MarshalStructNumberSequentialByVal_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *NumberSequentialByValStdCallCaller)(NumberSequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructNumberSequentialByVal_StdCall(NumberSequentialByValStdCallCaller caller)
+{
+    //Init
+    NumberSequential argstr;
+
+    argstr.i32 = 0;
+    argstr.ui32 = 32;
+    argstr.s1 = 0;
+    argstr.us1 = 16;
+    argstr.b = 0;
+    argstr.sb = 8;
+    argstr.i16 = 0;
+    argstr.ui16 = 16;
+    argstr.i64 = 0;
+    argstr.ui64 = 64;
+    argstr.sgl = 64.0;
+    argstr.d = 6.4;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructNumberSequentialByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i32 != 0 || argstr.ui32 != 32 || argstr.s1 != 0 || argstr.us1 != 16 || argstr.b != 0 ||
+        argstr.sb != 8 || argstr.i16 != 0 || argstr.ui16 != 16 || argstr.i64 != 0 || argstr.ui64 != 64 ||
+        argstr.sgl != 64.0 || argstr.d != 6.4)
+    {
+        printf("The parameter for DoCallBack_MarshalStructNumberSequentialByVal_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *NumberSequentialDelegatePInvokeByValCdeclCaller)(NumberSequential cs);
+extern "C" DLL_EXPORT NumberSequentialDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructNumberSequentialByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructNumberSequentialByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *NumberSequentialDelegatePInvokeByValStdCallCaller)(NumberSequential cs);
+extern "C" DLL_EXPORT NumberSequentialDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructNumberSequentialByVal_StdCall_FuncPtr()
+{
+    return MarshalStructNumberSequentialByVal_StdCall;
+}
+
+
+///////////////////////////////////////////Methods for S3 struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS3ByRef_Cdecl(S3* argstr)
+{
+    if(!IsCorrectS3(argstr))
+    {
+        printf("\tMarshalStructS3ByRef_Cdecl: S3 param not as expected\n");
+        PrintS3(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeS3(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS3ByRef_StdCall(S3* argstr)
+{
+    if(!IsCorrectS3(argstr))
+    {
+        printf("\tMarshalStructS3ByRef_StdCall: S3 param not as expected\n");
+        PrintS3(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeS3(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *S3ByRefCdeclCaller)(S3* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS3ByRef_Cdecl(S3ByRefCdeclCaller caller)
+{
+    //Init
+    S3 argstr;
+
+    argstr.flag = false;
+    const char* strSource = "change string";
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        argstr.vals[i-1] = i;
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS3ByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectS3(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructS3ByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S3ByRefStdCallCaller)(S3* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS3ByRef_StdCall(S3ByRefStdCallCaller caller)
+{
+    //Init
+    S3 argstr;
+
+    argstr.flag = false;
+    const char* strSource = "change string";
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        argstr.vals[i-1] = i;
+    }
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS3ByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectS3(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructS3ByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *S3DelegatePInvokeByRefCdeclCaller)(S3* pcs);
+extern "C" DLL_EXPORT S3DelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructS3ByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructS3ByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *S3DelegatePInvokeByRefStdCallCaller)(S3* pcs);
+extern "C" DLL_EXPORT S3DelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructS3ByRef_StdCall_FuncPtr()
+{
+    return MarshalStructS3ByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS3ByVal_Cdecl(S3 argstr)
+{
+    //Check the Input    
+    if(!IsCorrectS3(&argstr))
+    {
+        printf("\tMarshalStructS3ByVal_Cdecl: S3 param not as expected\n");
+        PrintS3(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.flag = false;
+    const char* strSource = "change string";
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        argstr.vals[i-1] = i;
+    }
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS3ByVal_StdCall(S3 argstr)
+{
+    //Check the Input    
+    if(!IsCorrectS3(&argstr))
+    {
+        printf("\tMarshalStructS3ByVal_StdCall: S3 param not as expected\n");
+        PrintS3(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.flag = false;
+    const char* strSource = "change string";
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        argstr.vals[i-1] = i;
+    }
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *S3ByValCdeclCaller)(S3 cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS3ByVal_Cdecl(S3ByValCdeclCaller caller)
+{
+    //Init
+    S3 argstr;
+
+    argstr.flag = false;
+    const char* strSource = "change string";
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        argstr.vals[i-1] = i;
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS3ByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    int iflag = 0;
+    if(argstr.flag || strcmp((char*)argstr.str,"change string") != 0)
+        return false;
+    for (int i = 1; i < 257; i++)
+    {
+        if (argstr.vals[i-1] != i)
+        {
+            printf("\tThe Index of %i is not expected",i);
+            iflag++;
+        }
+    }
+    if (iflag != 0)
+    {
+        return false;
+    }
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S3ByValStdCallCaller)(S3 cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS3ByVal_StdCall(S3ByValStdCallCaller caller)
+{
+    //Init
+    S3 argstr;
+
+    argstr.flag = false;
+    const char* strSource = "change string";
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        argstr.vals[i-1] = i;
+    }
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS3ByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    int iflag = 0;
+    if(argstr.flag || strcmp((char*)argstr.str,"change string") != 0)
+        return false;
+    for (int i = 1; i < 257; i++)
+    {
+        if (argstr.vals[i-1] != i)
+        {
+            printf("\tThe Index of %i is not expected",i);
+            iflag++;
+        }
+    }
+    if (iflag != 0)
+    {
+        return false;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *S3DelegatePInvokeByValCdeclCaller)(S3 cs);
+extern "C" DLL_EXPORT S3DelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructS3ByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructS3ByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *S3DelegatePInvokeByValStdCallCaller)(S3 cs);
+extern "C" DLL_EXPORT S3DelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructS3ByVal_StdCall_FuncPtr()
+{
+    return MarshalStructS3ByVal_StdCall;
+}
+
+
+
+///////////////////////////////////////////Methods for S5 struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS5ByRef_Cdecl(S5* argstr)
+{
+    if(!IsCorrectS5(argstr))
+    {
+        printf("\tMarshalStructS5ByRef_Cdecl: S5 param not as expected\n");
+        PrintS5(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeS5(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS5ByRef_StdCall(S5* argstr)
+{
+    if(!IsCorrectS5(argstr))
+    {
+        printf("\tMarshalStructS5ByRef_StdCall: S5 param not as expected\n");
+        PrintS5(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeS5(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *S5ByRefCdeclCaller)(S5* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS5ByRef_Cdecl(S5ByRefCdeclCaller caller)
+{
+    //Init
+    S5 argstr;
+
+    Enum1 eInstance = e2;
+    const char* strSource = "change string";    
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.s4.name = temp;
+    }
+    argstr.s4.age = 64;
+    argstr.ef = eInstance;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS5ByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectS5(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructS5ByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S5ByRefStdCallCaller)(S5* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS5ByRef_StdCall(S5ByRefStdCallCaller caller)
+{
+    //Init
+    S5 argstr;
+
+    Enum1 eInstance = e2;
+    const char* strSource = "change string";    
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.s4.name = temp;
+    }
+    argstr.s4.age = 64;
+    argstr.ef = eInstance;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS5ByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectS5(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructS5ByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *S5DelegatePInvokeByRefCdeclCaller)(S5* pcs);
+extern "C" DLL_EXPORT S5DelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructS5ByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructS5ByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *S5DelegatePInvokeByRefStdCallCaller)(S5* pcs);
+extern "C" DLL_EXPORT S5DelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructS5ByRef_StdCall_FuncPtr()
+{
+    return MarshalStructS5ByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS5ByVal_Cdecl(S5 argstr)
+{
+    //Check the Input    
+    if(!IsCorrectS5(&argstr))
+    {
+        printf("\tMarshalStructS5ByVal_Cdecl: S5 param not as expected\n");
+        PrintS5(&argstr,"argstr");
+        return FALSE;
+    }
+
+    Enum1 eInstance = e2;
+    const char* strSource = "change string";    
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.s4.name = temp;
+    }
+    argstr.s4.age = 64;
+    argstr.ef = eInstance;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS5ByVal_StdCall(S5 argstr)
+{
+    //Check the Input    
+    if(!IsCorrectS5(&argstr))
+    {
+        printf("\tMarshalStructS5ByVal_StdCall: S5 param not as expected\n");
+        PrintS5(&argstr,"argstr");
+        return FALSE;
+    }
+
+    Enum1 eInstance = e2;
+    const char* strSource = "change string";    
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.s4.name = temp;
+    }
+    argstr.s4.age = 64;
+    argstr.ef = eInstance;
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *S5ByValCdeclCaller)(S5 cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS5ByVal_Cdecl(S5ByValCdeclCaller caller)
+{
+    //Init
+    S5 argstr{};
+
+    Enum1 eInstance = e2;
+    const char* strSource = "change string";    
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.s4.name = temp;
+    }
+    argstr.s4.age = 64;
+    argstr.ef = eInstance;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS5ByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.s4.age != 64 || strcmp((char*)argstr.s4.name,"change string") != 0)
+        return false;
+    if(argstr.ef != eInstance)
+    {
+        return false;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S5ByValStdCallCaller)(S5 cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS5ByVal_StdCall(S5ByValStdCallCaller caller)
+{
+    //Init
+    S5 argstr{};
+
+    Enum1 eInstance = e2;
+    const char* strSource = "change string";    
+    size_t len =strlen(strSource) + 1;
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*len);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,len,strSource);
+        argstr.s4.name = temp;
+    }
+    argstr.s4.age = 64;
+    argstr.ef = eInstance;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS5ByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.s4.age != 64 || strcmp((char*)argstr.s4.name,"change string") != 0)
+        return false;
+    if(argstr.ef != eInstance)
+    {
+        return false;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *S5DelegatePInvokeByValCdeclCaller)(S5 cs);
+extern "C" DLL_EXPORT S5DelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructS5ByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructS5ByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *S5DelegatePInvokeByValStdCallCaller)(S5 cs);
+extern "C" DLL_EXPORT S5DelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructS5ByVal_StdCall_FuncPtr()
+{
+    return MarshalStructS5ByVal_StdCall;
+}
+
+
+///////////////////////////////////////////Methods for StringStructSequentialAnsi struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructStringStructSequentialAnsiByRef_Cdecl(StringStructSequentialAnsi* argstr)
+{
+    if(!IsCorrectStringStructSequentialAnsi(argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialAnsiByRef_Cdecl: StringStructSequentialAnsi param not as expected\n");
+        PrintStringStructSequentialAnsi(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeStringStructSequentialAnsi(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructStringStructSequentialAnsiByRef_StdCall(StringStructSequentialAnsi* argstr)
+{
+    if(!IsCorrectStringStructSequentialAnsi(argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialAnsiByRef_StdCall: StringStructSequentialAnsi param not as expected\n");
+        PrintStringStructSequentialAnsi(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeStringStructSequentialAnsi(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *StringStructSequentialAnsiByRefCdeclCaller)(StringStructSequentialAnsi* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructStringStructSequentialAnsiByRef_Cdecl(StringStructSequentialAnsiByRefCdeclCaller caller)
+{
+    //Init
+    StringStructSequentialAnsi argstr;
+
+    char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
+    for (int i = 0; i < 512; ++i)
+    {
+        newFirst[i] = 'b';
+        newLast[i] = 'a';
+    }
+    newFirst[512] = '\0';
+    newLast[512] = '\0';
+    argstr.first = newFirst;    
+    argstr.last = newLast;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialAnsiByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectStringStructSequentialAnsi(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructStringStructSequentialAnsiByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *StringStructSequentialAnsiByRefStdCallCaller)(StringStructSequentialAnsi* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructStringStructSequentialAnsiByRef_StdCall(StringStructSequentialAnsiByRefStdCallCaller caller)
+{
+    //Init
+    StringStructSequentialAnsi argstr;
+
+    char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
+    for (int i = 0; i < 512; ++i)
+    {
+        newFirst[i] = 'b';
+        newLast[i] = 'a';
+    }
+    newFirst[512] = '\0';
+    newLast[512] = '\0';
+    argstr.first = newFirst;    
+    argstr.last = newLast;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialAnsiByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectStringStructSequentialAnsi(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructStringStructSequentialAnsiByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *StringStructSequentialAnsiDelegatePInvokeByRefCdeclCaller)(StringStructSequentialAnsi* pcs);
+extern "C" DLL_EXPORT StringStructSequentialAnsiDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructStringStructSequentialAnsiByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructStringStructSequentialAnsiByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *StringStructSequentialAnsiDelegatePInvokeByRefStdCallCaller)(StringStructSequentialAnsi* pcs);
+extern "C" DLL_EXPORT StringStructSequentialAnsiDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructStringStructSequentialAnsiByRef_StdCall_FuncPtr()
+{
+    return MarshalStructStringStructSequentialAnsiByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructStringStructSequentialAnsiByVal_Cdecl(StringStructSequentialAnsi argstr)
+{
+    //Check the Input    
+    if(!IsCorrectStringStructSequentialAnsi(&argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialAnsiByVal_Cdecl: StringStructSequentialAnsi param not as expected\n");
+        PrintStringStructSequentialAnsi(&argstr,"argstr");
+        return FALSE;
+    }
+
+    char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
+    for (int i = 0; i < 512; ++i)
+    {
+        newFirst[i] = 'b';
+        newLast[i] = 'a';
+    }
+    newFirst[512] = '\0';
+    newLast[512] = '\0';
+    argstr.first = newFirst;    
+    argstr.last = newLast;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructStringStructSequentialAnsiByVal_StdCall(StringStructSequentialAnsi argstr)
+{
+    //Check the Input    
+    if(!IsCorrectStringStructSequentialAnsi(&argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialAnsiByVal_StdCall: StringStructSequentialAnsi param not as expected\n");
+        PrintStringStructSequentialAnsi(&argstr,"argstr");
+        return FALSE;
+    }
+
+    char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
+    for (int i = 0; i < 512; ++i)
+    {
+        newFirst[i] = 'b';
+        newLast[i] = 'a';
+    }
+    newFirst[512] = '\0';
+    newLast[512] = '\0';
+    argstr.first = newFirst;    
+    argstr.last = newLast;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *StringStructSequentialAnsiByValCdeclCaller)(StringStructSequentialAnsi cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructStringStructSequentialAnsiByVal_Cdecl(StringStructSequentialAnsiByValCdeclCaller caller)
+{
+    //Init
+    StringStructSequentialAnsi argstr;
+    char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
+    for (int i = 0; i < 512; ++i)
+    {
+        newFirst[i] = 'b';
+        newLast[i] = 'a';
+    }
+    newFirst[512] = '\0';
+    newLast[512] = '\0';
+    argstr.first = newFirst;    
+    argstr.last = newLast;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialAnsiByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(memcmp(argstr.first,newFirst,512)!= 0)
+        return false;
+    if(memcmp(argstr.last,newLast,512)!= 0)
+        return false;
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *StringStructSequentialAnsiByValStdCallCaller)(StringStructSequentialAnsi cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructStringStructSequentialAnsiByVal_StdCall(StringStructSequentialAnsiByValStdCallCaller caller)
+{
+    //Init
+    StringStructSequentialAnsi argstr;
+    char* newFirst = (char*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(sizeof(char)*513);
+    for (int i = 0; i < 512; ++i)
+    {
+        newFirst[i] = 'b';
+        newLast[i] = 'a';
+    }
+    newFirst[512] = '\0';
+    newLast[512] = '\0';
+    argstr.first = newFirst;    
+    argstr.last = newLast;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialAnsiByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(memcmp(argstr.first,newFirst,512)!= 0)
+        return false;
+    if(memcmp(argstr.last,newLast,512)!= 0)
+        return false;
+
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *StringStructSequentialAnsiDelegatePInvokeByValCdeclCaller)(StringStructSequentialAnsi cs);
+extern "C" DLL_EXPORT StringStructSequentialAnsiDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructStringStructSequentialAnsiByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructStringStructSequentialAnsiByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *StringStructSequentialAnsiDelegatePInvokeByValStdCallCaller)(StringStructSequentialAnsi cs);
+extern "C" DLL_EXPORT StringStructSequentialAnsiDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructStringStructSequentialAnsiByVal_StdCall_FuncPtr()
+{
+    return MarshalStructStringStructSequentialAnsiByVal_StdCall;
+}
+
+
+
+
+///////////////////////////////////////////Methods for StringStructSequentialUnicode struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructStringStructSequentialUnicodeByRef_Cdecl(StringStructSequentialUnicode* argstr)
+{
+    if(!IsCorrectStringStructSequentialUnicode(argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialUnicodeByRef_Cdecl: StringStructSequentialUnicode param not as expected\n");
+        PrintStringStructSequentialUnicode(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeStringStructSequentialUnicode(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructStringStructSequentialUnicodeByRef_StdCall(StringStructSequentialUnicode* argstr)
+{
+    if(!IsCorrectStringStructSequentialUnicode(argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialUnicodeByRef_StdCall: StringStructSequentialUnicode param not as expected\n");
+        PrintStringStructSequentialUnicode(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeStringStructSequentialUnicode(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *StringStructSequentialUnicodeByRefCdeclCaller)(StringStructSequentialUnicode* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_Cdecl(StringStructSequentialUnicodeByRefCdeclCaller caller)
+{
+    //Init
+    StringStructSequentialUnicode argstr;
+
+    WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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';
+    argstr.first = (const WCHAR*)newFirst;
+    argstr.last = (const WCHAR*)newLast;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectStringStructSequentialUnicode(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *StringStructSequentialUnicodeByRefStdCallCaller)(StringStructSequentialUnicode* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_StdCall(StringStructSequentialUnicodeByRefStdCallCaller caller)
+{
+    //Init
+    StringStructSequentialUnicode argstr;
+
+    WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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';
+    argstr.first = (const WCHAR*)newFirst;
+    argstr.last = (const WCHAR*)newLast;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectStringStructSequentialUnicode(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *StringStructSequentialUnicodeDelegatePInvokeByRefCdeclCaller)(StringStructSequentialUnicode* pcs);
+extern "C" DLL_EXPORT StringStructSequentialUnicodeDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructStringStructSequentialUnicodeByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructStringStructSequentialUnicodeByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *StringStructSequentialUnicodeDelegatePInvokeByRefStdCallCaller)(StringStructSequentialUnicode* pcs);
+extern "C" DLL_EXPORT StringStructSequentialUnicodeDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructStringStructSequentialUnicodeByRef_StdCall_FuncPtr()
+{
+    return MarshalStructStringStructSequentialUnicodeByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructStringStructSequentialUnicodeByVal_Cdecl(StringStructSequentialUnicode argstr)
+{
+    //Check the Input    
+    if(!IsCorrectStringStructSequentialUnicode(&argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialUnicodeByVal_Cdecl: StringStructSequentialUnicode param not as expected\n");
+        PrintStringStructSequentialUnicode(&argstr,"argstr");
+        return FALSE;
+    }
+
+    WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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';
+    argstr.first = (const WCHAR*)newFirst;
+    argstr.last = (const WCHAR*)newLast;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructStringStructSequentialUnicodeByVal_StdCall(StringStructSequentialUnicode argstr)
+{
+    //Check the Input    
+    if(!IsCorrectStringStructSequentialUnicode(&argstr))
+    {
+        printf("\tMarshalStructStringStructSequentialUnicodeByVal_StdCall: StringStructSequentialUnicode param not as expected\n");
+        PrintStringStructSequentialUnicode(&argstr,"argstr");
+        return FALSE;
+    }
+
+    WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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';
+    argstr.first = (const WCHAR*)newFirst;
+    argstr.last = (const WCHAR*)newLast;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *StringStructSequentialUnicodeByValCdeclCaller)(StringStructSequentialUnicode cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_Cdecl(StringStructSequentialUnicodeByValCdeclCaller caller)
+{
+    //Init
+    StringStructSequentialUnicode argstr;
+
+    WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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';
+    argstr.first = (const WCHAR*)newFirst;
+    argstr.last = (const WCHAR*)newLast;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(memcmp(argstr.first,newFirst,256*sizeof(WCHAR)) != 0)
+        return false;
+    if(memcmp(argstr.last,newLast,256*sizeof(WCHAR)) != 0)
+        return false;
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *StringStructSequentialUnicodeByValStdCallCaller)(StringStructSequentialUnicode cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_StdCall(StringStructSequentialUnicodeByValStdCallCaller caller)
+{
+    //Init
+    StringStructSequentialUnicode argstr;
+
+    WCHAR* newFirst = (WCHAR*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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';
+    argstr.first = (const WCHAR*)newFirst;
+    argstr.last = (const WCHAR*)newLast;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(memcmp(argstr.first,newFirst,256*sizeof(WCHAR)) != 0)
+        return false;
+    if(memcmp(argstr.last,newLast,256*sizeof(WCHAR)) != 0)
+        return false;
+
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *StringStructSequentialUnicodeDelegatePInvokeByValCdeclCaller)(StringStructSequentialUnicode cs);
+extern "C" DLL_EXPORT StringStructSequentialUnicodeDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructStringStructSequentialUnicodeByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructStringStructSequentialUnicodeByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *StringStructSequentialUnicodeDelegatePInvokeByValStdCallCaller)(StringStructSequentialUnicode cs);
+extern "C" DLL_EXPORT StringStructSequentialUnicodeDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructStringStructSequentialUnicodeByVal_StdCall_FuncPtr()
+{
+    return MarshalStructStringStructSequentialUnicodeByVal_StdCall;
+}
+
+
+
+
+///////////////////////////////////////////Methods for S8 struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS8ByRef_Cdecl(S8* argstr)
+{
+    if(!IsCorrectS8(argstr))
+    {
+        printf("\tMarshalStructS8ByRef_Cdecl: S8 param not as expected\n");
+        PrintS8(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeS8(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS8ByRef_StdCall(S8* argstr)
+{
+    if(!IsCorrectS8(argstr))
+    {
+        printf("\tMarshalStructS8ByRef_StdCall: S8 param not as expected\n");
+        PrintS8(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeS8(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *S8ByRefCdeclCaller)(S8* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS8ByRef_Cdecl(S8ByRefCdeclCaller caller)
+{
+    //Init
+    S8 argstr;
+
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.name = temp;
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    argstr.gender = false;
+    argstr.jobNum = 1;
+    argstr.i32 = 256;
+    argstr.ui32 = 256;
+    argstr.mySByte = 64;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS8ByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectS8(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructS8ByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S8ByRefStdCallCaller)(S8* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS8ByRef_StdCall(S8ByRefStdCallCaller caller)
+{
+    //Init
+    S8 argstr;
+
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.name = temp;
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    argstr.gender = false;
+    argstr.jobNum = 1;
+    argstr.i32 = 256;
+    argstr.ui32 = 256;
+    argstr.mySByte = 64;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS8ByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectS8(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructS8ByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *S8DelegatePInvokeByRefCdeclCaller)(S8* pcs);
+extern "C" DLL_EXPORT S8DelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructS8ByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructS8ByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *S8DelegatePInvokeByRefStdCallCaller)(S8* pcs);
+extern "C" DLL_EXPORT S8DelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructS8ByRef_StdCall_FuncPtr()
+{
+    return MarshalStructS8ByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS8ByVal_Cdecl(S8 argstr)
+{
+    //Check the Input    
+    if(!IsCorrectS8(&argstr))
+    {
+        printf("\tMarshalStructS8ByVal_Cdecl: S8 param not as expected\n");
+        PrintS8(&argstr,"argstr");
+        return FALSE;
+    }
+
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.name = temp;
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    argstr.gender = false;
+    argstr.jobNum = 1;
+    argstr.i32 = 256;
+    argstr.ui32 = 256;
+    argstr.mySByte = 64;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS8ByVal_StdCall(S8 argstr)
+{
+    //Check the Input    
+    if(!IsCorrectS8(&argstr))
+    {
+        printf("\tMarshalStructS8ByVal_StdCall: S8 param not as expected\n");
+        PrintS8(&argstr,"argstr");
+        return FALSE;
+    }
+
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.name = temp;
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    argstr.gender = false;
+    argstr.jobNum = 1;
+    argstr.i32 = 256;
+    argstr.ui32 = 256;
+    argstr.mySByte = 64;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *S8ByValCdeclCaller)(S8 cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS8ByVal_Cdecl(S8ByValCdeclCaller caller)
+{
+    //Init
+    S8 argstr{};
+
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.name = temp;
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    argstr.gender = false;
+    argstr.jobNum = 1;
+    argstr.i32 = 256;
+    argstr.ui32 = 256;
+    argstr.mySByte = 64;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS8ByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(memcmp( argstr.name,"world", strlen("world")*sizeof(char)+1 )!= 0)
+        return false;
+    if(argstr.gender)
+        return false;
+    if(argstr.jobNum != 1)
+        return false;
+    if(argstr.i32!= 256 || argstr.ui32 != 256)
+        return false;
+    if(argstr.mySByte != 64)
+        return false;
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S8ByValStdCallCaller)(S8 cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS8ByVal_StdCall(S8ByValStdCallCaller caller)
+{
+    //Init
+    S8 argstr{};
+
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,lpstr);
+        argstr.name = temp;
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+    argstr.gender = false;
+    argstr.jobNum = 1;
+    argstr.i32 = 256;
+    argstr.ui32 = 256;
+    argstr.mySByte = 64;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS8ByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(memcmp( argstr.name,"world", strlen("world")*sizeof(char)+1 )!= 0)
+        return false;
+    if(argstr.gender)
+        return false;
+    if(argstr.jobNum != 1)
+        return false;
+    if(argstr.i32!= 256 || argstr.ui32 != 256)
+        return false;
+    if(argstr.mySByte != 64)
+        return false;
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *S8DelegatePInvokeByValCdeclCaller)(S8 cs);
+extern "C" DLL_EXPORT S8DelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructS8ByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructS8ByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *S8DelegatePInvokeByValStdCallCaller)(S8 cs);
+extern "C" DLL_EXPORT S8DelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructS8ByVal_StdCall_FuncPtr()
+{
+    return MarshalStructS8ByVal_StdCall;
+}
+
+
+
+///////////////////////////////////////////Methods for S9 struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT void NtestMethod(S9 str1)
+{
+    printf("\tAction of the delegate");
+}
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS9ByRef_Cdecl(S9* argstr)
+{
+    if(argstr->i32 != 128 ||
+        argstr->myDelegate1 == NULL)
+    {
+        printf("\tMarshalStructS9ByRef_Cdecl: S9 param not as expected\n");
+        return FALSE;
+    }
+    argstr->i32 = 256;
+    argstr->myDelegate1 = NULL;
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS9ByRef_StdCall(S9* argstr)
+{
+    if(argstr->i32 != 128 ||
+        argstr->myDelegate1 == NULL)
+    {
+        printf("\tMarshalStructS9ByRef_StdCall: S9 param not as expected\n");
+        return FALSE;
+    }
+    argstr->i32 = 256;
+    argstr->myDelegate1 = NULL;
+    return TRUE;
+}
+typedef BOOL (_cdecl *S9ByRefCdeclCaller)(S9* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS9ByRef_Cdecl(S9ByRefCdeclCaller caller)
+{
+    //Init
+    S9 argstr;
+
+    argstr.i32 = 256;
+    argstr.myDelegate1 = NULL;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS9ByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(argstr.i32 != 128 ||
+        argstr.myDelegate1 == NULL)
+    {
+        printf("The parameter for DoCallBack_MarshalStructS9ByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S9ByRefStdCallCaller)(S9* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS9ByRef_StdCall(S9ByRefStdCallCaller caller)
+{
+    //Init
+    S9 argstr;
+
+    argstr.i32 = 256;
+    argstr.myDelegate1 = NULL;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS9ByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(argstr.i32 != 128 ||
+        argstr.myDelegate1 == NULL)
+    {
+        printf("The parameter for DoCallBack_MarshalStructS9ByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *S9DelegatePInvokeByRefCdeclCaller)(S9* pcs);
+extern "C" DLL_EXPORT S9DelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructS9ByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructS9ByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *S9DelegatePInvokeByRefStdCallCaller)(S9* pcs);
+extern "C" DLL_EXPORT S9DelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructS9ByRef_StdCall_FuncPtr()
+{
+    return MarshalStructS9ByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS9ByVal_Cdecl(S9 argstr)
+{
+    //Check the Input    
+    if(argstr.i32 != 128 ||
+        argstr.myDelegate1 == NULL)
+    {
+        printf("\tMarshalStructS9ByVal_Cdecl: S9 param not as expected\n");
+        return FALSE;
+    }
+    argstr.i32 = 256;
+    argstr.myDelegate1 = NULL;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS9ByVal_StdCall(S9 argstr)
+{
+    //Check the Input    
+    if(argstr.i32 != 128 ||
+        argstr.myDelegate1 == NULL)
+    {
+        printf("\tMarshalStructS9ByVal_StdCall: S9 param not as expected\n");
+        return FALSE;
+    }
+
+    argstr.i32 = 256;
+    argstr.myDelegate1 = NULL;
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *S9ByValCdeclCaller)(S9 cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS9ByVal_Cdecl(S9ByValCdeclCaller caller)
+{
+    //Init
+    S9 argstr;
+
+    argstr.i32 = 256;
+    argstr.myDelegate1 = NULL;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS9ByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i32 != 256 || argstr.myDelegate1 != NULL)
+        return false;
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S9ByValStdCallCaller)(S9 cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS9ByVal_StdCall(S9ByValStdCallCaller caller)
+{
+    //Init
+    S9 argstr;
+
+    argstr.i32 = 256;
+    argstr.myDelegate1 = NULL;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS9ByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i32 != 256 || argstr.myDelegate1 != NULL)
+        return false;
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *S9DelegatePInvokeByValCdeclCaller)(S9 cs);
+extern "C" DLL_EXPORT S9DelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructS9ByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructS9ByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *S9DelegatePInvokeByValStdCallCaller)(S9 cs);
+extern "C" DLL_EXPORT S9DelegatePInvokeByValStdCallCaller _cdecl Get_MarshalStructS9ByVal_StdCall_FuncPtr()
+{
+    return MarshalStructS9ByVal_StdCall;
+}
+
+///////////////////////////////////////////Methods for IncludeOuterIntergerStructSequential struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl(IncludeOuterIntergerStructSequential* argstr)
+{
+    if(!IsCorrectIncludeOuterIntergerStructSequential(argstr))
+    {
+        printf("\tMarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl: IncludeOuterIntergerStructSequential param not as expected\n");
+        PrintIncludeOuterIntergerStructSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeIncludeOuterIntergerStructSequential(argstr);
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall(IncludeOuterIntergerStructSequential* argstr)
+{
+    if(!IsCorrectIncludeOuterIntergerStructSequential(argstr))
+    {
+        printf("\tMarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall: IncludeOuterIntergerStructSequential param not as expected\n");
+        PrintIncludeOuterIntergerStructSequential(argstr,"argstr");
+        return FALSE;
+    }
+    ChangeIncludeOuterIntergerStructSequential(argstr);
+    return TRUE;
+}
+typedef BOOL (_cdecl *IncludeOuterIntergerStructSequentialByRefCdeclCaller)(IncludeOuterIntergerStructSequential* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl(IncludeOuterIntergerStructSequentialByRefCdeclCaller caller)
+{
+    //Init
+    IncludeOuterIntergerStructSequential argstr;
+
+    argstr.s.s_int.i = 64;
+    argstr.s.i = 64;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectIncludeOuterIntergerStructSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *IncludeOuterIntergerStructSequentialByRefStdCallCaller)(IncludeOuterIntergerStructSequential* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall(IncludeOuterIntergerStructSequentialByRefStdCallCaller caller)
+{
+    //Init
+    IncludeOuterIntergerStructSequential argstr;
+
+    argstr.s.s_int.i = 64;
+    argstr.s.i = 64;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(!IsCorrectIncludeOuterIntergerStructSequential(&argstr))
+    {
+        printf("The parameter for DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *IncludeOuterIntergerStructSequentialDelegatePInvokeByRefCdeclCaller)(IncludeOuterIntergerStructSequential* pcs);
+extern "C" DLL_EXPORT IncludeOuterIntergerStructSequentialDelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *IncludeOuterIntergerStructSequentialDelegatePInvokeByRefStdCallCaller)(IncludeOuterIntergerStructSequential* pcs);
+extern "C" DLL_EXPORT IncludeOuterIntergerStructSequentialDelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall_FuncPtr()
+{
+    return MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl(IncludeOuterIntergerStructSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectIncludeOuterIntergerStructSequential(&argstr))
+    {
+        printf("\tMarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl: IncludeOuterIntergerStructSequential param not as expected\n");
+        PrintIncludeOuterIntergerStructSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.s.s_int.i = 64;
+    argstr.s.i = 64;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall(IncludeOuterIntergerStructSequential argstr)
+{
+    //Check the Input    
+    if(!IsCorrectIncludeOuterIntergerStructSequential(&argstr))
+    {
+        printf("\tMarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall: IncludeOuterIntergerStructSequential param not as expected\n");
+        PrintIncludeOuterIntergerStructSequential(&argstr,"argstr");
+        return FALSE;
+    }
+
+    argstr.s.s_int.i = 64;
+    argstr.s.i = 64;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *IncludeOuterIntergerStructSequentialByValCdeclCaller)(IncludeOuterIntergerStructSequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl(IncludeOuterIntergerStructSequentialByValCdeclCaller caller)
+{
+    //Init
+    IncludeOuterIntergerStructSequential argstr;
+
+    argstr.s.s_int.i = 64;
+    argstr.s.i = 64;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.s.s_int.i != 64)
+        return false;
+    if(argstr.s.i != 64)
+        return false;
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *IncludeOuterIntergerStructSequentialByValStdCallCaller)(IncludeOuterIntergerStructSequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall(IncludeOuterIntergerStructSequentialByValStdCallCaller caller)
+{
+    //Init
+    IncludeOuterIntergerStructSequential argstr;
+
+    argstr.s.s_int.i = 64;
+    argstr.s.i = 64;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.s.s_int.i != 64)
+        return false;
+    if(argstr.s.i != 64)
+        return false;
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *IncludeOuterIntergerStructSequentialDelegatePInvokeByValCdeclCaller)(IncludeOuterIntergerStructSequential cs);
+extern "C" DLL_EXPORT IncludeOuterIntergerStructSequentialDelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *IncludeOuterIntergerStructSequentialDelegatePInvokeByValStdCallCaller)(IncludeOuterIntergerStructSequential cs);
+extern "C" DLL_EXPORT IncludeOuterIntergerStructSequentialDelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall_FuncPtr()
+{
+    return MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall;
+}
+
+///////////////////////////////////////////Methods for S11 struct////////////////////////////////////////////////////
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS11ByRef_Cdecl(S11* argstr)
+{
+    if(argstr->i32 != (LPINT)(32) || argstr->i != 32)
+    {
+        printf("\tMarshalStructS11ByRef_Cdecl: S11 param not as expected\n");
+        return FALSE;
+    }
+    argstr->i32 = (LPINT)(64);
+    argstr->i = 64;
+    return TRUE;
+}
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS11ByRef_StdCall(S11* argstr)
+{
+    if(argstr->i32 != (LPINT)(32) || argstr->i != 32)
+    {
+        printf("\tMarshalStructS11ByRef_StdCall: S11 param not as expected\n");
+        return FALSE;
+    }
+    argstr->i32 = (LPINT)(64);
+    argstr->i = 64;
+    return TRUE;
+}
+typedef BOOL (_cdecl *S11ByRefCdeclCaller)(S11* pcs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS11ByRef_Cdecl(S11ByRefCdeclCaller caller)
+{
+    //Init
+    S11 argstr;
+
+    argstr.i32 = (LPINT)(64);
+    argstr.i = 64;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS11ByRef_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(argstr.i32 != (LPINT)32 || argstr.i != 32)
+    {
+        printf("The parameter for DoCallBack_MarshalStructS11ByRef_Cdecl is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S11ByRefStdCallCaller)(S11* pcs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS11ByRef_StdCall(S11ByRefStdCallCaller caller)
+{
+    //Init
+    S11 argstr;
+
+    argstr.i32 = (LPINT)(64);
+    argstr.i = 64;
+
+    if(!caller(&argstr))
+    {
+        printf("DoCallBack_MarshalStructS11ByRef_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+    //Verify the value unchanged
+    if(argstr.i32 != (LPINT)(32) || argstr.i != 32)
+    {
+        printf("The parameter for DoCallBack_MarshalStructS11ByRef_StdCall is wrong\n");
+        return FALSE;
+    }
+    return TRUE;
+}
+//Delegate PInvoke,passbyref
+typedef BOOL (_cdecl *S11DelegatePInvokeByRefCdeclCaller)(S11* pcs);
+extern "C" DLL_EXPORT S11DelegatePInvokeByRefCdeclCaller _cdecl Get_MarshalStructS11ByRef_Cdecl_FuncPtr()
+{
+    return MarshalStructS11ByRef_Cdecl;            
+}
+
+typedef BOOL (__stdcall *S11DelegatePInvokeByRefStdCallCaller)(S11* pcs);
+extern "C" DLL_EXPORT S11DelegatePInvokeByRefStdCallCaller __stdcall Get_MarshalStructS11ByRef_StdCall_FuncPtr()
+{
+    return MarshalStructS11ByRef_StdCall;
+}
+
+
+//Passby value
+extern "C" DLL_EXPORT BOOL _cdecl MarshalStructS11ByVal_Cdecl(S11 argstr)
+{
+    //Check the Input    
+    if(argstr.i32 != (LPINT)(32) || argstr.i != 32)
+    {
+        printf("\tMarshalStructS11ByVal_Cdecl: S11 param not as expected\n");
+        return FALSE;
+    }
+
+    argstr.i32 = (LPINT)(64);
+    argstr.i = 64;
+
+    return TRUE;
+}
+
+extern "C" DLL_EXPORT BOOL __stdcall MarshalStructS11ByVal_StdCall(S11 argstr)
+{
+    //Check the Input    
+    if(argstr.i32 != (LPINT)(32) || argstr.i != 32)
+    {
+        printf("\tMarshalStructS11ByVal_StdCall: S11 param not as expected\n");
+        return FALSE;
+    }
+
+    argstr.i32 = (LPINT)(64);
+    argstr.i = 64;
+
+    return TRUE;
+}
+
+typedef BOOL (_cdecl *S11ByValCdeclCaller)(S11 cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructS11ByVal_Cdecl(S11ByValCdeclCaller caller)
+{
+    //Init
+    S11 argstr;
+
+    argstr.i32 = (LPINT)(64);
+    argstr.i = 64;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS11ByVal_Cdecl:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i32 != (LPINT)(64) || argstr.i != 64)
+        return false;
+
+    return TRUE;
+}
+
+typedef BOOL (__stdcall *S11ByValStdCallCaller)(S11 cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructS11ByVal_StdCall(S11ByValStdCallCaller caller)
+{
+    //Init
+    S11 argstr;
+
+    argstr.i32 = (LPINT)(64);
+    argstr.i = 64;
+
+    if(!caller(argstr))
+    {
+        printf("DoCallBack_MarshalStructS11ByVal_StdCall:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i32 != (LPINT)(64) || argstr.i != 64)
+        return false;
+    return TRUE;
+}
+//Delegate PInvoke,passbyval
+typedef BOOL (_cdecl *S11DelegatePInvokeByValCdeclCaller)(S11 cs);
+extern "C" DLL_EXPORT S11DelegatePInvokeByValCdeclCaller _cdecl Get_MarshalStructS11ByVal_Cdecl_FuncPtr()
+{
+    return MarshalStructS11ByVal_Cdecl;
+}
+
+typedef BOOL (__stdcall *S11DelegatePInvokeByValStdCallCaller)(S11 cs);
+extern "C" DLL_EXPORT S11DelegatePInvokeByValStdCallCaller __stdcall Get_MarshalStructS11ByVal_StdCall_FuncPtr()
+{
+    return MarshalStructS11ByVal_StdCall;
+}
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h
new file mode 100644
index 0000000000..6022d5aeab
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h
@@ -0,0 +1,881 @@
+// 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <xplatform.h>
+ 
+const int NumArrElements = 2;
+struct InnerSequential
+{
+    int f1;
+    float f2;
+    LPCSTR f3;
+};
+
+void PrintInnerSequential(InnerSequential* p, const char* 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;
+
+    const char* lpstr = "changed string";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,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;
+    if( strcmp((char*)p->f3,"some string") != 0 )
+        return false;
+    return true;
+}
+
+struct INNER2 // size = 12 bytes
+{
+    INT f1;
+    FLOAT f2;
+    LPCSTR f3;
+};
+
+void ChangeINNER2(INNER2* p)
+{
+    p->f1 = 77;
+    p->f2 = 77.0;
+    const char*  temp = "changed string";
+    size_t len = strlen(temp);
+    LPCSTR str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    strcpy_s((char*)str,len+1,temp);
+    p->f3 = str;
+}
+
+void PrintINNER2(INNER2* p, const char* 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;
+#else
+    union
+    {
+        INT f1;
+        FLOAT f2;
+    };
+    INT _unused0;
+    LPCSTR f3;
+#endif 
+};
+
+void PrintInnerExplicit(InnerExplicit* p, const char* 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;
+
+    const char*  temp = "changed string";
+    size_t len = strlen(temp);
+    LPCSTR str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    strcpy_s((char*)str,len+1,temp);
+    p->f3 = str;
+}
+
+struct InnerArraySequential
+{
+    InnerSequential arr[NumArrElements];
+};
+
+void PrintInnerArraySequential(InnerArraySequential* p, const char* 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].f2 = %s\n", name, i, (p->arr)[i].f3);
+    }
+}
+
+void ChangeInnerArraySequential(InnerArraySequential* p)
+{
+    const char* 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)CoreClrAlloc( size );
+        memset(temp, 0, size);
+        if(temp)
+        {
+            strcpy_s((char*)temp,size,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;
+}
+
+#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
+#else
+struct OUTER3 // size = 28 bytes
+{
+    struct InnerSequential arr[2];
+    LPCSTR f4;
+};
+#endif
+
+void PrintOUTER3(OUTER3* p, const char* 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)
+{
+    const char*  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)CoreClrAlloc( sizeof(char)*(len+1) );
+        strcpy_s((char*)str,len+1,temp);
+        (p->arr)[i].f3 = str;
+    }
+
+    str = (LPCSTR)CoreClrAlloc( sizeof(char)*(len+1) );
+    strcpy_s((char*)str,len+1,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, const char* name)
+{
+    printf("\t%s.f1 = %s\n", name, p->f1);
+    printf("\t%s.f2 = %c\n", name, p->f2);
+}
+
+void ChangeCharSetAnsiSequential(CharSetAnsiSequential* p)
+{
+    const char* strSource = "change string";
+    size_t size = strlen(strSource) + 1;
+    LPSTR temp = (LPSTR)CoreClrAlloc(size);
+    if(temp != NULL)
+    {
+        strcpy_s((char*)temp,size,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, const char* name)
+{
+#ifdef _WIN32
+	wprintf(L"\t%S.first = %s\n", name, p->f1);
+	wprintf(L"\t%S.last = %c\n", name, p->f2);
+#else
+	wprintf(L"\t%s.first = %s\n", name, p->f1);
+	wprintf(L"\t%s.last = %c\n", name, p->f2);
+#endif
+}
+
+void ChangeCharSetUnicodeSequential(CharSetUnicodeSequential* p)
+{
+    LPCWSTR strSource = W("change string");
+    size_t len = wcslen(strSource);
+    LPCWSTR temp = (LPCWSTR)CoreClrAlloc(sizeof(WCHAR)*(len+1));
+    if(temp != NULL)
+    {
+        wcscpy_s((WCHAR*)temp, (len+1), strSource);
+        p->f1 = temp;
+        p->f2 = L'n';
+    }
+    else
+    {
+        printf("Memory Allocated Failed!");
+    }
+}
+
+bool IsCorrectCharSetUnicodeSequential(CharSetUnicodeSequential* p)
+{
+    LPCWSTR expected= W("some string");
+    LPCWSTR actual = p->f1;
+    if(0 != wcscmp(actual, 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, const char* 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 = %lld\n", name, str->i64);
+    printf("\t%s.ui64 = %llu\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 != INT_MIN || 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, const char* 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;
+
+    const char* strSource = "change string";
+    size_t len = strlen(strSource);
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*(len+1));	
+    if(temp != NULL)
+    {
+        memset((LPVOID)temp,0,len+1);
+        strncpy_s((char*)temp,len+1,strSource,len);
+        p->str = temp;
+    }
+    for(int i = 1;i<257;i++)
+    {
+        p->vals[i-1] = i;
+    }
+}
+
+bool IsCorrectS3(S3* p)
+{
+    int iflag = 0;
+    if(!p->flag || strcmp((char*)p->str,"some string") != 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, const char* 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;
+    const char* strSource = "change string";	
+    size_t len = strlen(strSource);
+    LPCSTR temp = (LPCSTR)CoreClrAlloc(sizeof(char)*(len+1));
+    if(temp != NULL)
+    {
+        memset((LPVOID)temp,0,len+1);
+        strncpy_s((char*)temp,len+1,strSource,len);
+        str->s4.name = temp;
+    }
+    str->s4.age = 64;
+    str->ef = eInstance;
+}
+
+bool IsCorrectS5(S5* str)
+{
+    Enum1 eInstance = e1;
+    if(str->s4.age != 32 || strcmp((char*)str->s4.name,"some string") != 0)
+        return false;
+    if(str->ef != eInstance)
+    {
+        return false;
+    }
+    return true;
+}
+
+struct StringStructSequentialAnsi // size = 8 bytes
+{
+    LPCSTR first;
+    LPCSTR last;
+};
+
+void PrintStringStructSequentialAnsi(StringStructSequentialAnsi* str, const char* 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*)CoreClrAlloc(sizeof(char)*513);
+    char* newLast = (char*)CoreClrAlloc(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, const char* name)
+{
+#ifdef _WIN32
+	wprintf(L"\t%S.first = %s\n", name, str->first);
+	wprintf(L"\t%S.last = %s\n", name, str->last);
+#else
+	wprintf(L"\t%s.first = %s\n", name, str->first);
+	wprintf(L"\t%s.last = %s\n", name, str->last);
+#endif
+}
+
+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*)CoreClrAlloc(sizeof(WCHAR)*257);
+    WCHAR* newLast = (WCHAR*)CoreClrAlloc(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;
+    HRESULT i32;
+    HRESULT ui32;
+    WORD jobNum;
+    CHAR mySByte;
+};
+
+void PrintS8(S8* str, const char* 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, (int)(str->i32));
+    printf("\t%s.ui32 = %u\n", name, (unsigned int)(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)
+{
+    const char* lpstr = "world";
+    size_t size = sizeof(char) * (strlen(lpstr) + 1);
+    LPSTR temp = (LPSTR)CoreClrAlloc( size );
+    memset(temp, 0, size);
+    if(temp)
+    {
+        strcpy_s((char*)temp,size,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 IntergerStructSequential // size = 4 bytes
+{
+    INT i;
+};
+
+struct S9;
+typedef void (*TestDelegate1)(struct S9 myStruct);
+
+struct S9 // size = 8 bytes
+{
+    HRESULT i32;
+    TestDelegate1 myDelegate1;
+};
+
+struct OuterIntergerStructSequential // size = 8 bytes
+{
+    INT i;
+    struct IntergerStructSequential s_int;
+};
+
+struct IncludeOuterIntergerStructSequential // size = 8 bytes
+{
+    struct OuterIntergerStructSequential s;
+};
+
+void PrintIncludeOuterIntergerStructSequential(IncludeOuterIntergerStructSequential* str, const char* 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 IsCorrectIncludeOuterIntergerStructSequential(IncludeOuterIntergerStructSequential* str)
+{
+    if(str->s.s_int.i != 32)
+        return false;
+    if(str->s.i != 32)
+        return false;
+    return true;
+}
+
+void ChangeIncludeOuterIntergerStructSequential(IncludeOuterIntergerStructSequential* 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, const char* name)
+{
+    printf("\t%s.i32 = %d\n", name, str->i32);
+    printf("\t%s.ui32 = %u\n", name, str->ui32);
+    printf("\t%s.iPtr = %zu\n", name, (size_t)(str->iPtr));
+    printf("\t%s.uiPtr = %zu\n", name, (size_t)(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 = %lld\n", name, str->l);
+    printf("\t%s.ul = %llu\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, const char* 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, const char* 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, const char* 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, const char* name)
+{
+    printf("\t%s.l1 = %lld", name, str->l1);
+    printf("\t%s.l2 = %lld", 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;
+}
diff --git a/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs b/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs
new file mode 100644
index 0000000000..07edd32cbf
--- /dev/null
+++ b/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs
@@ -0,0 +1,279 @@
+// 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;
+
+public class Common
+{
+    public const int NumArrElements = 2;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct InnerSequential
+{
+    public int f1;
+    public float f2;
+    public String f3;
+}
+
+[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;
+    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)] //In ProjectN, MarshalAsError isnt supported in V1
+    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;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct ComplexStruct
+{
+    public int i;
+    [MarshalAs(UnmanagedType.I1)]
+    public bool b;
+    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;
+}
diff --git a/tests/src/Interop/common/xplatform.h b/tests/src/Interop/common/xplatform.h
index 94a693e384..158961ff19 100644
--- a/tests/src/Interop/common/xplatform.h
+++ b/tests/src/Interop/common/xplatform.h
@@ -142,12 +142,14 @@ size_t strcpy_s(char *dest, size_t n, char const *src)
     return snprintf(dest, n, "%s", src);
 }
 
+#ifndef wcslen
 size_t wcslen(const WCHAR *str)
 {
     size_t len = 0;
     while ('\0' != *(str + len)) len++;
     return len;
 }
+#endif
 
 int wcsncpy_s(LPWSTR strDestination, size_t size1, LPCWSTR strSource, size_t size2)
 {