From 2c571d0ea8a25125bea40faa0f1db1e52758c58c Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Fri, 7 Feb 2020 15:51:27 -0800
Subject: [PATCH 1/5] Add tests for marshalling Vector2/3/4 - Anticipated work
 on Windows Amd64 calling conventions may affect this, so this needs testing

---
 src/coreclr/tests/src/Interop/CMakeLists.txt  |   1 +
 .../PInvoke/Vector2_3_4/CMakeLists.txt        |   8 +
 .../PInvoke/Vector2_3_4/Vector2_3_4.cs        | 169 ++++++++++++++++
 .../PInvoke/Vector2_3_4/Vector2_3_4.csproj    |  12 ++
 .../Vector2_3_4/Vector2_3_4TestNative.cpp     | 182 ++++++++++++++++++
 .../Vector2_3_4/Vector2_3_4TestNative.cs      |  84 ++++++++
 6 files changed, 456 insertions(+)
 create mode 100644 src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/CMakeLists.txt
 create mode 100644 src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
 create mode 100644 src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.csproj
 create mode 100644 src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp
 create mode 100644 src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs

diff --git a/src/coreclr/tests/src/Interop/CMakeLists.txt b/src/coreclr/tests/src/Interop/CMakeLists.txt
index 9de657750644bd..afd1e257436e2a 100644
--- a/src/coreclr/tests/src/Interop/CMakeLists.txt
+++ b/src/coreclr/tests/src/Interop/CMakeLists.txt
@@ -34,6 +34,7 @@ add_subdirectory(PInvoke/CriticalHandles)
 add_subdirectory(PInvoke/Generics)
 add_subdirectory(PInvoke/AsAny)
 add_subdirectory(PInvoke/SafeHandles)
+add_subdirectory(PInvoke/Vector2_3_4)
 add_subdirectory(NativeCallable)
 add_subdirectory(PrimitiveMarshalling/Bool)
 add_subdirectory(PrimitiveMarshalling/UIntPtr)
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/CMakeLists.txt b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/CMakeLists.txt
new file mode 100644
index 00000000000000..ae38c05536d682
--- /dev/null
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/CMakeLists.txt
@@ -0,0 +1,8 @@
+ 
+include ("${CLR_INTEROP_TEST_ROOT}/Interop.cmake") 
+set(SOURCES 
+    Vector2_3_4TestNative.cpp 
+)
+add_library (Vector2_3_4TestNative SHARED ${SOURCES}) 
+target_link_libraries(Vector2_3_4TestNative ${LINK_LIBRARIES_ADDITIONAL})
+install (TARGETS Vector2_3_4TestNative DESTINATION bin) 
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
new file mode 100644
index 00000000000000..b44080e6c06609
--- /dev/null
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
@@ -0,0 +1,169 @@
+// 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.Numerics;
+using System.Runtime.InteropServices;
+using TestLibrary;
+
+public class Vector2_3_4Test
+{
+    private const int StartingIntValue = 42;
+    private const int NewIntValue = 18;
+
+    public static int Main()
+    {
+        try
+        {
+            RunVector2Tests();
+            RunVector3Tests();
+            RunVector4Tests();
+        }
+        catch (System.Exception ex)
+        {
+            Console.WriteLine(ex.ToString());
+            return 101;
+        }
+        return 100;
+    }
+
+    private static void RunVector2Tests()
+    {
+        float X = StartingIntValue;
+        float Y = StartingIntValue + 1;
+        float Z = StartingIntValue + 232;
+        float W = StartingIntValue + 93719;
+
+        float XNew = 71;
+        float YNew = 999;
+        float ZNew = 1203;
+        float WNew = 4;
+
+        Vector2 startingVector = new Vector2(X, Y);
+        Vector2 newVector = new Vector2(XNew, YNew);
+
+        Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateVector2FromFloats(X, Y));
+
+        Assert.IsTrue(Vector2_3_4TestNative.Vector2EqualToFloats(startingVector, X, Y));
+
+        Vecto2 localVector = startingVector;
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeVector2(ref localVector, X, Y, XNew, YNew));
+        Assert.AreEqual(newVector, localDecimal);
+
+        Vector2_3_4TestNative.GetVector2ForFloats(X, Y, out var vec);
+        Assert.AreEqual(startingVector, vec);
+        
+        Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateWrappedVector2FromFloats(X, Y).vec);
+
+        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector2EqualToInt(new Vector2_3_4TestNative.Vector2Wrapper { vec = startingVector }, X, Y));
+
+        var localVectorWrapper = new Vector2_3_4TestNative.Vector2Wrapper { vec = startingVector };
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeWrappedVector2(ref localVectorWrapper, X, Y, XNew, YNew));
+        Assert.AreEqual(newVector, localVectorWrapper.vec);
+
+        Assert.AreEqual(newVector, Vector2_3_4TestNative.PassThroughVector2ToCallback(startingVector, vectorParam => 
+        {
+            Assert.AreEqual(startingVector, vectorParam)
+            return newVector;
+        }));
+    }
+    
+    private static void RunVector3Tests()
+    {
+        float X = StartingIntValue;
+        float Y = StartingIntValue + 1;
+        float Z = StartingIntValue + 232;
+        float W = StartingIntValue + 93719;
+
+        float XNew = 71;
+        float YNew = 999;
+        float ZNew = 1203;
+        float WNew = 4;
+
+        Vector3 startingVector = new Vector3(X, Y, Z);
+        Vector3 newVector = new Vector3(XNew, YNew, ZNew);
+
+        Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateVector3FromFloats(X, Y, Z));
+
+        Assert.IsTrue(Vector2_3_4TestNative.Vector3EqualToFloats(startingVector, X, Y, Z));
+
+        Vecto2 localVector = startingVector;
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeVector3(ref localVector, X, Y, Z, XNew, YNew, ZNew));
+        Assert.AreEqual(newVector, localDecimal);
+
+        Vector2_3_4TestNative.GetVector3ForFloats(X, Y, Z, out var vec);
+        Assert.AreEqual(startingVector, vec);
+        
+        Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateWrappedVector3FromFloats(X, Y, Z).vec);
+
+        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector3EqualToInt(new Vector2_3_4TestNative.Vector3Wrapper { vec = startingVector }, X, Y, Z));
+
+        var localVectorWrapper = new Vector2_3_4TestNative.Vector3Wrapper { vec = startingVector };
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeWrappedVector3(ref localVectorWrapper, X, Y, Z, XNew, YNew, ZNew));
+        Assert.AreEqual(newVector, localVectorWrapper.vec);
+
+        Assert.AreEqual(newVector, Vector2_3_4TestNative.PassThroughVector3ToCallback(startingVector, vectorParam => 
+        {
+            Assert.AreEqual(startingVector, vectorParam)
+            return newVector;
+        }));
+    }
+
+    private static void RunVector4Tests()
+    {
+        float X = StartingIntValue;
+        float Y = StartingIntValue + 1;
+        float Z = StartingIntValue + 232;
+        float W = StartingIntValue + 93719;
+
+        float XNew = 71;
+        float YNew = 999;
+        float ZNew = 1203;
+        float WNew = 4;
+
+        Vector4 startingVector = new Vector4(X, Y, Z, W);
+        Vector4 newVector = new Vector4(XNew, YNew, ZNew, WNew);
+
+        Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateVector4FromFloats(X, Y, Z, W));
+
+        Assert.IsTrue(Vector2_3_4TestNative.Vector4EqualToFloats(startingVector, X, Y, Z, W));
+
+        Vecto2 localVector = startingVector;
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeVector4(ref localVector, X, Y, Z, W, XNew, YNew, ZNew, WNew));
+        Assert.AreEqual(newVector, localDecimal);
+
+        Vector2_3_4TestNative.GetVector4ForFloats(X, Y, Z, W, out var vec);
+        Assert.AreEqual(startingVector, vec);
+        
+        Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateWrappedVector4FromFloats(X, Y, Z, W).vec);
+
+        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector4EqualToInt(new Vector2_3_4TestNative.Vector4Wrapper { vec = startingVector }, X, Y, Z, W));
+
+        var localVectorWrapper = new Vector2_3_4TestNative.Vector4Wrapper { vec = startingVector };
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeWrappedVector4(ref localVectorWrapper, X, Y, Z, W, XNew, YNew, ZNew, WNew));
+        Assert.AreEqual(newVector, localVectorWrapper.vec);
+
+        Assert.AreEqual(newVector, Vector2_3_4TestNative.PassThroughVector4ToCallback(startingVector, vectorParam => 
+        {
+            Assert.AreEqual(startingVector, vectorParam)
+            return newVector;
+        }));
+    }
+
+    private static void RunLPVector2_3_4Tests()
+    {
+        Assert.AreEqual((decimal)StartingIntValue, Vector2_3_4TestNative.CreateLPDecimalFromInt(StartingIntValue));
+
+        Assert.IsTrue(Vector2_3_4TestNative.LPDecimalEqualToInt((decimal)StartingIntValue, StartingIntValue));
+
+        decimal localDecimal = (decimal)StartingIntValue;
+        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeLPDecimal(ref localDecimal, StartingIntValue, NewIntValue));
+        Assert.AreEqual((decimal)NewIntValue, localDecimal);
+
+        Vector2_3_4TestNative.GetLPDecimalForInt(NewIntValue, out var dec);
+        Assert.AreEqual((decimal)NewIntValue, dec);
+
+        Vector2_3_4TestNative.PassThroughLPDecimalToCallback((decimal)NewIntValue, d => Assert.AreEqual((decimal)NewIntValue, d));
+    }
+}
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.csproj b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.csproj
new file mode 100644
index 00000000000000..c6b2767243b338
--- /dev/null
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <Import Project="$([MSBuild]::GetPathOfFileAbove(Interop.settings.targets))" />
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="*.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="CMakeLists.txt" />
+  </ItemGroup>
+</Project>
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp
new file mode 100644
index 00000000000000..add7bb54ce059b
--- /dev/null
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp
@@ -0,0 +1,182 @@
+// 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 <new>
+
+struct Vector2
+{
+    float x;
+    float y;
+};
+
+struct Vector3
+{
+    float x;
+    float y;
+    float z;
+};
+
+struct Vector4
+{
+    float x;
+    float y;
+    float z;
+    float w;
+};
+
+namespace
+{
+    BOOL operator==(Vector2 lhs, Vector2 rhs)
+    {
+        return lhs.x == rhs.x && lhs.y == rhs.y ? TRUE : FALSE;
+    }
+    BOOL operator==(Vector3 lhs, Vector3 rhs)
+    {
+        return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z ? TRUE : FALSE;
+    }
+    BOOL operator==(Vector4 lhs, Vector4 rhs)
+    {
+        return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z && lhs.w == rhs.w ? TRUE : FALSE;
+    }
+}
+
+extern "C" DLL_EXPORT Vector4 STDMETHODCALLTYPE CreateVector4FromFloatsCreateVector4FromFloats(float x, float y, float z, float w)
+{
+    Vector4 result;
+    result.x = x;
+    result.y = y;
+    result.z = z;
+    result.w = w;
+    return result;
+}
+
+extern "C" DLL_EXPORT Vector3 STDMETHODCALLTYPE CreateVector3FromFloatsCreateVector4FromFloats(float x, float y, float z)
+{
+    Vector3 result;
+    result.x = x;
+    result.y = y;
+    result.z = z;
+    return result;
+}
+
+extern "C" DLL_EXPORT Vector2 STDMETHODCALLTYPE CreateVector2FromFloatsCreateVector4FromFloats(float x, float y)
+{
+    Vector2 result;
+    result.x = x;
+    result.y = y;
+    return result;
+}
+
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE Vector4EqualToFloats(Vector4 vec, float x, float y, float z, float w)
+{
+    Vector4 vecFromFloats;
+    vecFromFloats.x = x;
+    vecFromFloats.y = y;
+    vecFromFloats.z = z;
+    vecFromFloats.w = w;
+    return vec == vecFromFloats;
+}
+
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE Vector3EqualToFloats(Vector3 vec, float x, float y, float z)
+{
+    Vector3 vecFromFloats;
+    vecFromFloats.x = x;
+    vecFromFloats.y = y;
+    vecFromFloats.z = z;
+    return vec == vecFromFloats;
+}
+
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE Vector2EqualToFloats(Vector2 vec, float x, float y)
+{
+    Vector2 vecFromFloats;
+    vecFromFloats.x = x;
+    vecFromFloats.y = y;
+    return vec == vecFromFloats;
+}
+
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE ValidateAndChangeVector4(Vector4* vec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW)
+{
+    Vector4 vecExpected;
+    vecExpected.x = expectedX;
+    vecExpected.y = expectedY;
+    vecExpected.z = expectedZ;
+    vecExpected.w = expectedW;
+
+    BOOL result = *vec == vecExpected;
+    vec->x = newX;
+    vec->y = newY;
+    vec->z = newZ;
+    vec->w = newW;
+    return result;
+}
+
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE ValidateAndChangeVector3(Vector3* vec, float expectedX, float expectedY, float expectedZ, float newX, float newY, float newZ)
+{
+    Vector3 vecExpected;
+    vecExpected.x = expectedX;
+    vecExpected.y = expectedY;
+    vecExpected.z = expectedZ;
+
+    BOOL result = *vec == vecExpected;
+    vec->x = newX;
+    vec->y = newY;
+    vec->z = newZ;
+    return result;
+}
+
+extern "C" DLL_EXPORT BOOL STDMETHODCALLTYPE ValidateAndChangeVector2(Vector2* vec, float expectedX, float expectedY, float newX, float newY)
+{
+    Vector2 vecExpected;
+    vecExpected.x = expectedX;
+    vecExpected.y = expectedY;
+
+    BOOL result = *vec == vecExpected;
+    vec->x = newX;
+    vec->y = newY;
+    return result;
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector4ForFloats(float x, float y, float z, float w, Vector4* vec)
+{
+    vec->x = x;
+    vec->y = y;
+    vec->z = z;
+    vec->w = w;
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector3ForFloats(float x, float y, float z, float w, Vector3* vec)
+{
+    vec->x = x;
+    vec->y = y;
+    vec->z = z;
+}
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector2ForFloats(float x, float y, float z, float w, Vector2* vec)
+{
+    vec->x = x;
+    vec->y = y;
+}
+
+
+using Vector4Callback = Vector4(STDMETHODCALLTYPE*)(Vector4);
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE PassThroughVector4ToCallback(Vector4 vec, Vector4Callback cb)
+{
+    return cb(vec);
+}
+
+using Vector3Callback = Vector3(STDMETHODCALLTYPE*)(Vector3);
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE PassThroughVector3ToCallback(Vector3 vec, Vector3Callback cb)
+{
+    return cb(vec);
+}
+
+using Vector2Callback = Vector2(STDMETHODCALLTYPE*)(Vector2);
+
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE PassThroughVector2ToCallback(Vector2 vec, Vector2Callback cb)
+{
+    return cb(vec);
+}
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs
new file mode 100644
index 00000000000000..3733d41a3a356b
--- /dev/null
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs
@@ -0,0 +1,84 @@
+// 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.Runtime.InteropServices;
+
+#pragma warning disable 0618
+static class Vector2_3_4TestNative
+{
+    public struct Vector2Wrapper
+    {
+        public Vector2 vec;
+    };
+
+    public struct Vector3Wrapper
+    {
+        public Vector3 vec;
+    };
+
+    public struct Vector4Wrapper
+    {
+        public Vector4 vec;
+    };
+
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern Vector2 CreateVector2FromFloats(float x, float y);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern Vector3 CreateVector3FromFloats(float x, float y, float z);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern Vector4 CreateVector4FromFloats(float x, float y, float z, float w);
+
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "CreateVector2FromFloats")]
+    public static extern Vector2Wrapper CreateWrappedVector2FromFloats(float x, float b);
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "CreateVector3FromFloats")]
+    public static extern Vector3Wrapper CreateWrappedVector3FromFloats(float x, float y, float z);
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "CreateVector4FromFloats")]
+    public static extern Vector4Wrapper CreateWrappedVector4FromFloats(float x, float y, float z, float w);
+
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern bool Vector2EqualToFloats(Vector2 vec, float x, float y);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern bool Vector3EqualToFloats(Vector3 vec, float x, float y, float z);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern bool Vector4EqualToFloats(Vector4 vec, float x, float y, float z, float w);
+
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern bool ValidateAndChangeVector2(ref Vector2 dec, float expectedX, float expectedY, float newX, float newY);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern bool ValidateAndChangeVector3(ref Vector3 dec, float expectedX, float expectedY, float expectedZ, float newX, float newY, float newZ);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern bool ValidateAndChangeVector4(ref Vector4 dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
+
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern void GetVector2ForFloats(float x, float y, out Vector2 dec);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern void GetVector3ForFloats(float x, float y, float z, out Vector3 dec);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern void GetVector4ForFloats(float x, float y, float z, float w, out Vector4 dec);
+
+    [DllImport(nameof(Vector2_3_4TestNative, EntryPoint = "Vector2EqualToFloats"))]
+    public static extern bool WrappedVector2EqualToFloats(Vector2Wrapper vec, float x, float y);
+    [DllImport(nameof(Vector2_3_4TestNative, EntryPoint = "Vector3EqualToFloats"))]
+    public static extern bool WrappedVector3EqualToFloats(Vector3Wrapper vec, float x, float y, float z);
+    [DllImport(nameof(Vector2_3_4TestNative, EntryPoint = "Vector4EqualToFloats"))]
+    public static extern bool WrappedVector4EqualToFloats(Vector4Wrapper vec, float x, float y, float z, float w);
+
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "ValidateAndChangeVector2")]
+    public static extern bool ValidateAndChangeWrappedVector2(ref Vector2Wrapper dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "ValidateAndChangeVector3")]
+    public static extern bool ValidateAndChangeWrappedVector3(ref Vector3Wrapper dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "ValidateAndChangeVector4")]
+    public static extern bool ValidateAndChangeWrappedVector4(ref Vector4Wrapper dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
+
+    public delegate Vector2 Vector2Callback(Vector2 dec);
+    public delegate Vector3 Vector3Callback(Vector3 dec);
+    public delegate Vector4 Vector4Callback(Vector4 dec);
+
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern Vector2 PassThroughVector2ToCallback(Vector2 startingVector, Vector2Callback callback);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern Vector3 PassThroughVector3ToCallback(Vector3 startingVector, Vector3Callback callback);
+    [DllImport(nameof(Vector2_3_4TestNative))]
+    public static extern Vector4 PassThroughVector4ToCallback(Vector4 startingVector, Vector4Callback callback);
+}

From 0692421674620cdd7ab9cf105fa2937671bec319 Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Fri, 7 Feb 2020 15:52:30 -0800
Subject: [PATCH 2/5] Remove copy paste issue

---
 .../Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs   | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
index b44080e6c06609..27fb3168400033 100644
--- a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
@@ -150,20 +150,4 @@ private static void RunVector4Tests()
             return newVector;
         }));
     }
-
-    private static void RunLPVector2_3_4Tests()
-    {
-        Assert.AreEqual((decimal)StartingIntValue, Vector2_3_4TestNative.CreateLPDecimalFromInt(StartingIntValue));
-
-        Assert.IsTrue(Vector2_3_4TestNative.LPDecimalEqualToInt((decimal)StartingIntValue, StartingIntValue));
-
-        decimal localDecimal = (decimal)StartingIntValue;
-        Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeLPDecimal(ref localDecimal, StartingIntValue, NewIntValue));
-        Assert.AreEqual((decimal)NewIntValue, localDecimal);
-
-        Vector2_3_4TestNative.GetLPDecimalForInt(NewIntValue, out var dec);
-        Assert.AreEqual((decimal)NewIntValue, dec);
-
-        Vector2_3_4TestNative.PassThroughLPDecimalToCallback((decimal)NewIntValue, d => Assert.AreEqual((decimal)NewIntValue, d));
-    }
 }

From 7256d4b572fa3ea37b98e67c8047c0d7511104df Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Mon, 10 Feb 2020 10:46:19 -0800
Subject: [PATCH 3/5] Fix test bugs

---
 .../PInvoke/Vector2_3_4/Vector2_3_4.cs        | 24 +++++++++----------
 .../Vector2_3_4/Vector2_3_4TestNative.cpp     | 16 ++++++-------
 .../Vector2_3_4/Vector2_3_4TestNative.cs      | 11 +++++----
 3 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
index 27fb3168400033..ab724068b60c4d 100644
--- a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4.cs
@@ -47,16 +47,16 @@ private static void RunVector2Tests()
 
         Assert.IsTrue(Vector2_3_4TestNative.Vector2EqualToFloats(startingVector, X, Y));
 
-        Vecto2 localVector = startingVector;
+        Vector2 localVector = startingVector;
         Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeVector2(ref localVector, X, Y, XNew, YNew));
-        Assert.AreEqual(newVector, localDecimal);
+        Assert.AreEqual(newVector, localVector);
 
         Vector2_3_4TestNative.GetVector2ForFloats(X, Y, out var vec);
         Assert.AreEqual(startingVector, vec);
         
         Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateWrappedVector2FromFloats(X, Y).vec);
 
-        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector2EqualToInt(new Vector2_3_4TestNative.Vector2Wrapper { vec = startingVector }, X, Y));
+        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector2EqualToFloats(new Vector2_3_4TestNative.Vector2Wrapper { vec = startingVector }, X, Y));
 
         var localVectorWrapper = new Vector2_3_4TestNative.Vector2Wrapper { vec = startingVector };
         Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeWrappedVector2(ref localVectorWrapper, X, Y, XNew, YNew));
@@ -64,7 +64,7 @@ private static void RunVector2Tests()
 
         Assert.AreEqual(newVector, Vector2_3_4TestNative.PassThroughVector2ToCallback(startingVector, vectorParam => 
         {
-            Assert.AreEqual(startingVector, vectorParam)
+            Assert.AreEqual(startingVector, vectorParam);
             return newVector;
         }));
     }
@@ -88,16 +88,16 @@ private static void RunVector3Tests()
 
         Assert.IsTrue(Vector2_3_4TestNative.Vector3EqualToFloats(startingVector, X, Y, Z));
 
-        Vecto2 localVector = startingVector;
+        Vector3 localVector = startingVector;
         Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeVector3(ref localVector, X, Y, Z, XNew, YNew, ZNew));
-        Assert.AreEqual(newVector, localDecimal);
+        Assert.AreEqual(newVector, localVector);
 
         Vector2_3_4TestNative.GetVector3ForFloats(X, Y, Z, out var vec);
         Assert.AreEqual(startingVector, vec);
         
         Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateWrappedVector3FromFloats(X, Y, Z).vec);
 
-        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector3EqualToInt(new Vector2_3_4TestNative.Vector3Wrapper { vec = startingVector }, X, Y, Z));
+        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector3EqualToFloats(new Vector2_3_4TestNative.Vector3Wrapper { vec = startingVector }, X, Y, Z));
 
         var localVectorWrapper = new Vector2_3_4TestNative.Vector3Wrapper { vec = startingVector };
         Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeWrappedVector3(ref localVectorWrapper, X, Y, Z, XNew, YNew, ZNew));
@@ -105,7 +105,7 @@ private static void RunVector3Tests()
 
         Assert.AreEqual(newVector, Vector2_3_4TestNative.PassThroughVector3ToCallback(startingVector, vectorParam => 
         {
-            Assert.AreEqual(startingVector, vectorParam)
+            Assert.AreEqual(startingVector, vectorParam);
             return newVector;
         }));
     }
@@ -129,16 +129,16 @@ private static void RunVector4Tests()
 
         Assert.IsTrue(Vector2_3_4TestNative.Vector4EqualToFloats(startingVector, X, Y, Z, W));
 
-        Vecto2 localVector = startingVector;
+        Vector4 localVector = startingVector;
         Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeVector4(ref localVector, X, Y, Z, W, XNew, YNew, ZNew, WNew));
-        Assert.AreEqual(newVector, localDecimal);
+        Assert.AreEqual(newVector, localVector);
 
         Vector2_3_4TestNative.GetVector4ForFloats(X, Y, Z, W, out var vec);
         Assert.AreEqual(startingVector, vec);
         
         Assert.AreEqual(startingVector, Vector2_3_4TestNative.CreateWrappedVector4FromFloats(X, Y, Z, W).vec);
 
-        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector4EqualToInt(new Vector2_3_4TestNative.Vector4Wrapper { vec = startingVector }, X, Y, Z, W));
+        Assert.IsTrue(Vector2_3_4TestNative.WrappedVector4EqualToFloats(new Vector2_3_4TestNative.Vector4Wrapper { vec = startingVector }, X, Y, Z, W));
 
         var localVectorWrapper = new Vector2_3_4TestNative.Vector4Wrapper { vec = startingVector };
         Assert.IsTrue(Vector2_3_4TestNative.ValidateAndChangeWrappedVector4(ref localVectorWrapper, X, Y, Z, W, XNew, YNew, ZNew, WNew));
@@ -146,7 +146,7 @@ private static void RunVector4Tests()
 
         Assert.AreEqual(newVector, Vector2_3_4TestNative.PassThroughVector4ToCallback(startingVector, vectorParam => 
         {
-            Assert.AreEqual(startingVector, vectorParam)
+            Assert.AreEqual(startingVector, vectorParam);
             return newVector;
         }));
     }
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp
index add7bb54ce059b..d16165fe60249e 100644
--- a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cpp
@@ -42,7 +42,7 @@ namespace
     }
 }
 
-extern "C" DLL_EXPORT Vector4 STDMETHODCALLTYPE CreateVector4FromFloatsCreateVector4FromFloats(float x, float y, float z, float w)
+extern "C" DLL_EXPORT Vector4 STDMETHODCALLTYPE CreateVector4FromFloats(float x, float y, float z, float w)
 {
     Vector4 result;
     result.x = x;
@@ -52,7 +52,7 @@ extern "C" DLL_EXPORT Vector4 STDMETHODCALLTYPE CreateVector4FromFloatsCreateVec
     return result;
 }
 
-extern "C" DLL_EXPORT Vector3 STDMETHODCALLTYPE CreateVector3FromFloatsCreateVector4FromFloats(float x, float y, float z)
+extern "C" DLL_EXPORT Vector3 STDMETHODCALLTYPE CreateVector3FromFloats(float x, float y, float z)
 {
     Vector3 result;
     result.x = x;
@@ -61,7 +61,7 @@ extern "C" DLL_EXPORT Vector3 STDMETHODCALLTYPE CreateVector3FromFloatsCreateVec
     return result;
 }
 
-extern "C" DLL_EXPORT Vector2 STDMETHODCALLTYPE CreateVector2FromFloatsCreateVector4FromFloats(float x, float y)
+extern "C" DLL_EXPORT Vector2 STDMETHODCALLTYPE CreateVector2FromFloats(float x, float y)
 {
     Vector2 result;
     result.x = x;
@@ -146,14 +146,14 @@ extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector4ForFloats(float x, float
     vec->w = w;
 }
 
-extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector3ForFloats(float x, float y, float z, float w, Vector3* vec)
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector3ForFloats(float x, float y, float z, Vector3* vec)
 {
     vec->x = x;
     vec->y = y;
     vec->z = z;
 }
 
-extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector2ForFloats(float x, float y, float z, float w, Vector2* vec)
+extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector2ForFloats(float x, float y, Vector2* vec)
 {
     vec->x = x;
     vec->y = y;
@@ -162,21 +162,21 @@ extern "C" DLL_EXPORT void STDMETHODCALLTYPE GetVector2ForFloats(float x, float
 
 using Vector4Callback = Vector4(STDMETHODCALLTYPE*)(Vector4);
 
-extern "C" DLL_EXPORT void STDMETHODCALLTYPE PassThroughVector4ToCallback(Vector4 vec, Vector4Callback cb)
+extern "C" DLL_EXPORT Vector4 STDMETHODCALLTYPE PassThroughVector4ToCallback(Vector4 vec, Vector4Callback cb)
 {
     return cb(vec);
 }
 
 using Vector3Callback = Vector3(STDMETHODCALLTYPE*)(Vector3);
 
-extern "C" DLL_EXPORT void STDMETHODCALLTYPE PassThroughVector3ToCallback(Vector3 vec, Vector3Callback cb)
+extern "C" DLL_EXPORT Vector3 STDMETHODCALLTYPE PassThroughVector3ToCallback(Vector3 vec, Vector3Callback cb)
 {
     return cb(vec);
 }
 
 using Vector2Callback = Vector2(STDMETHODCALLTYPE*)(Vector2);
 
-extern "C" DLL_EXPORT void STDMETHODCALLTYPE PassThroughVector2ToCallback(Vector2 vec, Vector2Callback cb)
+extern "C" DLL_EXPORT Vector2 STDMETHODCALLTYPE PassThroughVector2ToCallback(Vector2 vec, Vector2Callback cb)
 {
     return cb(vec);
 }
diff --git a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs
index 3733d41a3a356b..2bf5267153019f 100644
--- a/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs
+++ b/src/coreclr/tests/src/Interop/PInvoke/Vector2_3_4/Vector2_3_4TestNative.cs
@@ -2,6 +2,7 @@
 // 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.Numerics;
 using System.Runtime.InteropServices;
 
 #pragma warning disable 0618
@@ -57,17 +58,17 @@ public struct Vector4Wrapper
     [DllImport(nameof(Vector2_3_4TestNative))]
     public static extern void GetVector4ForFloats(float x, float y, float z, float w, out Vector4 dec);
 
-    [DllImport(nameof(Vector2_3_4TestNative, EntryPoint = "Vector2EqualToFloats"))]
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "Vector2EqualToFloats")]
     public static extern bool WrappedVector2EqualToFloats(Vector2Wrapper vec, float x, float y);
-    [DllImport(nameof(Vector2_3_4TestNative, EntryPoint = "Vector3EqualToFloats"))]
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "Vector3EqualToFloats")]
     public static extern bool WrappedVector3EqualToFloats(Vector3Wrapper vec, float x, float y, float z);
-    [DllImport(nameof(Vector2_3_4TestNative, EntryPoint = "Vector4EqualToFloats"))]
+    [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "Vector4EqualToFloats")]
     public static extern bool WrappedVector4EqualToFloats(Vector4Wrapper vec, float x, float y, float z, float w);
 
     [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "ValidateAndChangeVector2")]
-    public static extern bool ValidateAndChangeWrappedVector2(ref Vector2Wrapper dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
+    public static extern bool ValidateAndChangeWrappedVector2(ref Vector2Wrapper dec, float expectedX, float expectedY, float newX, float newY);
     [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "ValidateAndChangeVector3")]
-    public static extern bool ValidateAndChangeWrappedVector3(ref Vector3Wrapper dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
+    public static extern bool ValidateAndChangeWrappedVector3(ref Vector3Wrapper dec, float expectedX, float expectedY, float expectedZ, float newX, float newY, float newZ);
     [DllImport(nameof(Vector2_3_4TestNative), EntryPoint = "ValidateAndChangeVector4")]
     public static extern bool ValidateAndChangeWrappedVector4(ref Vector4Wrapper dec, float expectedX, float expectedY, float expectedZ, float expectedW, float newX, float newY, float newZ, float newW);
 

From d11e26f93603b48ac7a052f03dcc0ea33ef23e1b Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Wed, 12 Feb 2020 16:03:36 -0800
Subject: [PATCH 4/5] Updates to add return struct marshalling tests/fixes -
 Adjust some reverse p/invoke struct marshalling tests to add coverage for
 returning structures   - Coverage includes a 3 byte, 4 byte struct, 8 byte
 struct, and a large struct   - Note: There is a code in mlinfo.cpp which
 explicitly makes support for returning 3, 5, 6, and 7 on X86 follow the wrong
 calling convention by rounding the size to a 4 byte boundary. I've left this
 unfortunate detail in place. - Fix issues noted in returning structures from
 reverse p/invokes

---
 src/coreclr/src/vm/dllimport.cpp              |   4 +-
 .../ReversePInvoke/Helper.cs                  |  66 +++++++++
 .../ReversePInvoke/ReversePInvokeTest.cs      | Bin 182602 -> 194376 bytes
 .../SeqStructDelRevPInvokeNative.cpp          | 137 +++++++++++++++++-
 .../SeqStructDelRevPInvokeNative.h            |  38 +++++
 .../ReversePInvoke/Struct.cs                  |   8 +
 6 files changed, 243 insertions(+), 10 deletions(-)

diff --git a/src/coreclr/src/vm/dllimport.cpp b/src/coreclr/src/vm/dllimport.cpp
index c17f4a0ca2d796..4792aa9fc7551c 100644
--- a/src/coreclr/src/vm/dllimport.cpp
+++ b/src/coreclr/src/vm/dllimport.cpp
@@ -3983,10 +3983,10 @@ static void CreateNDirectStubWorker(StubState*         pss,
         // For functions with value type class, managed and unmanaged calling convention differ
         fMarshalReturnValueFirst = HasRetBuffArgUnmanagedFixup(&msig);
 #elif defined(TARGET_ARM)
-        fMarshalReturnValueFirst = HasRetBuffArg(&msig);
+        fMarshalReturnValueFirst = (isInstanceMethod && isReturnTypeValueType) && HasRetBuffArg(&msig);
 #else
         // On Windows-X86, the native signature might need a return buffer when the managed doesn't (specifically when the native signature is a member function).
-        fMarshalReturnValueFirst = HasRetBuffArg(&msig) || (isInstanceMethod && isReturnTypeValueType);
+        fMarshalReturnValueFirst = (!SF_IsReverseStub(dwStubFlags) && HasRetBuffArg(&msig)) || (isInstanceMethod && isReturnTypeValueType);
 #endif // UNIX_X86_ABI
 #elif defined(TARGET_AMD64) || defined (TARGET_ARM64)
         fMarshalReturnValueFirst = isInstanceMethod && isReturnTypeValueType;
diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs
index effd483f535e71..4f2f709d702fcd 100644
--- a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs
+++ b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Helper.cs
@@ -994,6 +994,72 @@ public static bool ValidateLongStructPack16Explicit(LongStructPack16Explicit str
 
     #endregion
 
+    #region methods for ByteStruct3Byte struct
+    public static ByteStruct3Byte NewByteStruct3Byte(byte b1, byte b2, byte b3)
+    {
+        ByteStruct3Byte u1 = new ByteStruct3Byte();
+        u1.b1 = b1;
+        u1.b2 = b2;
+        u1.b3 = b3;
+
+        return u1;
+    }
+    public static void PrintByteStruct3Byte(ByteStruct3Byte str1, string name)
+    {
+        Console.WriteLine("\t{0}.b1 = {1}", name, str1.b1);
+        Console.WriteLine("\t{0}.b2 = {1}", name, str1.b2);
+        Console.WriteLine("\t{0}.b3 = {1}", name, str1.b3);
+    }
+    public static bool ValidateByteStruct3Byte(ByteStruct3Byte str1, ByteStruct3Byte str2, string methodName)
+    {
+        if (str1.b1 != str2.b1 || str1.b2 != str2.b2)
+        {
+            Console.WriteLine("\tFAILED! " + methodName + "did not receive result as expected.");
+            Console.WriteLine("\tThe Actual is...");
+            PrintByteStruct3Byte(str1, str1.ToString());
+            Console.WriteLine("\tThe Expected is...");
+            PrintByteStruct3Byte(str2, str2.ToString());
+            return false;
+        }
+        else
+        {
+            Console.WriteLine("\tPASSED!");
+            return true;
+        }
+    }
+    #endregion
+
+    #region methods for IntergerStructSequential struct
+    public static IntergerStructSequential NewIntergerStructSequential(int i1)
+    {
+        IntergerStructSequential u1 = new IntergerStructSequential();
+        u1.i = i1;
+
+        return u1;
+    }
+    public static void PrintIntergerStructSequential(IntergerStructSequential str1, string name)
+    {
+        Console.WriteLine("\t{0}.i = {1}", name, str1.i);
+    }
+    public static bool ValidateIntergerStructSequential(IntergerStructSequential str1, IntergerStructSequential str2, string methodName)
+    {
+        if (str1.i != str2.i)
+        {
+            Console.WriteLine("\tFAILED! " + methodName + "did not receive result as expected.");
+            Console.WriteLine("\tThe Actual is...");
+            PrintIntergerStructSequential(str1, str1.ToString());
+            Console.WriteLine("\tThe Expected is...");
+            PrintIntergerStructSequential(str2, str2.ToString());
+            return false;
+        }
+        else
+        {
+            Console.WriteLine("\tPASSED!");
+            return true;
+        }
+    }
+    #endregion
+
 }
 
 public static class TestFramework
diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs
index a6e789c30ffacaffcbd3402493f201d186f59880..1e1774b8964983727258f04b79623b34ce3754f5 100644
GIT binary patch
delta 3877
zcmeHKUrbw77(eGY7#65C4CrVF7aX-9YuXNBE*XPK(D{cyb(>qp#-CCKhS3d*I<t++
z5|eE@DF^v98Cziq(TUnwVy7k>Odl4XATfI+-J35?+yja3LBDfo303SZPbSmc+@5>S
z_kF+f{kwcWei%x<eJ?d|Z$00al(lIWIYB(cMP9+*9@0mgxNaqpUH*1vHjL<5X>eQ0
zopHYBasf}iw3%1(WbhtldS2hUfp>q}C<Tjl6AzE=;>!IE!TQOI$*C=fcZBo`T$s5+
zLs4^3uCjtvO#?N0o_kZ_3pIhD;%AIEUwA86d42yQE3tyU(@qNW!>oian9_Ltq{64o
z8sSe?Xz(N2A!XZx#+$l%m>Q)ogvv%Kqw<k2+Ka(k!Ky=nOH`Az5><LAl>qe}5O|*%
z!9Pkrj5Yjff@a0oNpC{lN%~DCZ{DE=T_eqbs~L18FK%Lq!ms7zJDZ}3UOoN9tRh!P
zD<=3Dmal{;<RE#Oh@|(D4qUrP6+W3c)nt_K!6FMS3*x!)>LNwt5L&pg;2vCCBfAP(
zh!$|7ZZGNOV*{D|be1uGlR#B~?d^{rZWDQyv>~Vyk6v3)DlTFm=|qF+{LRonOZejj
zo1pb1H5uZ#19xpSV|^rXe8y<7#Zg9|&BP|tTT1M5eTG=U7p6~ge|kxknyFLPq8mR1
z7io&AR@8xOE(2J<U={I`%;)xQNnZ)p2J|^vlo_qR1+i^d$sKr?bDuUlMq-ahZ2b7Q
z8)GC}qY|(==*IMz^21y^E#!lbX_MqBFz28Kc>W^Qjie;d-^Z20hp4|*s&jWL<Hh)`
z5c{dBbT$9gaA2vMxxJwH;cMoW2eyB?nYk~|0C%oXZLry`p)h-f<>agWHRjmUc`91m
zSNBBlMqvsC|8<s?04C0XL@>GT%#ScWMC~wemX<D$U@@cgFfoK%vnNWWf}C=u5n3xo
zF`wPJ4)#sZDekQ_!{TLHA(SnUJ4}s`{4v6r-lOk|Ckr2R>7e@qS_18#&_)mlFnfx=
z3E^AR^7mP}?2DY|as3F?7=;hvHJ>jC0L<T_)|JOE5da*y>)@TU)CvpdSqf4CoqUTX
zMsk5Jx~!p(rmcD?oEsYanVuU4<rk_p+8Q3vL;U-Gt1PBknV?0(P9>)4&S2&I%N#`&
za&8ODPGCI1*zdFj{GYLN;62DRq0a}{{o*wRD82wyZ)AW8Y03b5l+CJ;i3Yf{fVn~#
zV09|@Yt#A_@+#>h-AF3j<PGF13fWJ#kuqEb_Yv<ccz2;x%wEB3Jh&tDg_YP@(r+Sl
zq?Wuy4n(w%pxlYi9*HBkkrVCu&|WYi1*x%MT2Hs(QigXqzO+Ud^wJ?w4&8@D%!N|%
z>p_4XJXQdB&?RBxk_Wslb%aY!-0zXvf`NA-riD{uW`8GXM}0G14n*ljStmJ)R=e@J
zUD_N)2gR-k)k5kK!;NT?z##?f!RHQ?3XU(3qkiQ}s_;*8OC&u-{do9EycCk3paZ)x
z%sS+=^%#V3Eb63r)m_V9>R1#dba<k;xV78_(?NDD?htHv3Ym%ZHq*kOo^6N2wafwD
s8Kw_i_?nGB`hUax*BZuqgLx8fm}L0LL3Mok4?X@1mlk^MI~Gp*6Jm9u`Tzg`

delta 360
zcmY+8ze@sf7>9YksFjLINjUW5l<OBk92E{X)DZ>|4HD7h&?F8a;t)-7LxefR=_|do
z$YGEfryX2z(BybHIYmRs4bc)v^%rzPLoM&}KA(rj>iOCwpWYiVqJ!KO3YA5)SC{bo
zK8f72fYRMATD2(Jkvyv7ydgI_Zfs3iC{}pvY{dS6Tf|L35Sw+*p>>D!GR*Qhqf>o%
zQML&oY}a@rTRZ{c9+`+*ea10xDA>2gO^bU)B^V%Y0XCh07^Sa4b_!NVEkO!D*TQ67
zLj1R5&YUd6H=~3Ehr}tMpnjy$ei61EqxgSI@&g;gR>Wg=Yw+wcl<5rgrE!uQ%#U`)
zkHW0W%r{|AqT?=vNH~CX^JSP7%4V|0P8Z0z1xoZFV9HNS^P+s_xyZo?^+YyDYKrZU
d^ufZW_QtA1{U_-P1W6r*FzWMuGyTPE_YZ*?m)!sW

diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp
index dcd124a97b9dd1..c6898329fbd177 100644
--- a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp
+++ b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.cpp
@@ -1399,7 +1399,7 @@ extern "C" DLL_EXPORT BOOL __stdcall MarshalStructNumberSequentialByVal_StdCall(
     return TRUE;
 }
 
-typedef BOOL (_cdecl *NumberSequentialByValCdeclCaller)(NumberSequential cs);
+typedef NumberSequential (_cdecl *NumberSequentialByValCdeclCaller)(NumberSequential cs);
 extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructNumberSequentialByVal_Cdecl(NumberSequentialByValCdeclCaller caller)
 {
     //Init
@@ -1418,9 +1418,12 @@ extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructNumberSequentialByVal_
     argstr.sgl = 64.0;
     argstr.d = 6.4;
 
-    if(!caller(argstr))
+    NumberSequential retstr = caller(argstr);
+
+    if (!IsCorrectNumberSequential(&retstr))
     {
         printf("DoCallBack_MarshalStructNumberSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        PrintNumberSequential(&retstr, "retstr");
         return FALSE;
     }
 
@@ -1435,7 +1438,7 @@ extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructNumberSequentialByVal_
     return TRUE;
 }
 
-typedef BOOL (__stdcall *NumberSequentialByValStdCallCaller)(NumberSequential cs);
+typedef NumberSequential (__stdcall *NumberSequentialByValStdCallCaller)(NumberSequential cs);
 extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructNumberSequentialByVal_StdCall(NumberSequentialByValStdCallCaller caller)
 {
     //Init
@@ -1454,9 +1457,12 @@ extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructNumberSequentialByV
     argstr.sgl = 64.0;
     argstr.d = 6.4;
 
-    if(!caller(argstr))
+    NumberSequential retstr = caller(argstr);
+
+    if (!IsCorrectNumberSequential(&retstr))
     {
         printf("DoCallBack_MarshalStructNumberSequentialByVal_StdCall:The Caller returns wrong value\n");
+        PrintNumberSequential(&retstr, "retstr");
         return FALSE;
     }
 
@@ -3013,7 +3019,7 @@ extern "C" DLL_EXPORT BOOL __stdcall MarshalStructIncludeOuterIntergerStructSequ
     return TRUE;
 }
 
-typedef BOOL (_cdecl *IncludeOuterIntergerStructSequentialByValCdeclCaller)(IncludeOuterIntergerStructSequential cs);
+typedef IncludeOuterIntergerStructSequential (_cdecl *IncludeOuterIntergerStructSequentialByValCdeclCaller)(IncludeOuterIntergerStructSequential cs);
 extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl(IncludeOuterIntergerStructSequentialByValCdeclCaller caller)
 {
     //Init
@@ -3022,9 +3028,12 @@ extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructIncludeOuterIntergerSt
     argstr.s.s_int.i = 64;
     argstr.s.i = 64;
 
-    if(!caller(argstr))
+    IncludeOuterIntergerStructSequential retstr = caller(argstr);
+
+    if (!IsCorrectIncludeOuterIntergerStructSequential(&retstr))
     {
         printf("DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        PrintIncludeOuterIntergerStructSequential(&retstr, "retstr");
         return FALSE;
     }
 
@@ -3037,7 +3046,7 @@ extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructIncludeOuterIntergerSt
     return TRUE;
 }
 
-typedef BOOL (__stdcall *IncludeOuterIntergerStructSequentialByValStdCallCaller)(IncludeOuterIntergerStructSequential cs);
+typedef IncludeOuterIntergerStructSequential (__stdcall *IncludeOuterIntergerStructSequentialByValStdCallCaller)(IncludeOuterIntergerStructSequential cs);
 extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall(IncludeOuterIntergerStructSequentialByValStdCallCaller caller)
 {
     //Init
@@ -3046,9 +3055,12 @@ extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructIncludeOuterInterge
     argstr.s.s_int.i = 64;
     argstr.s.i = 64;
 
-    if(!caller(argstr))
+    IncludeOuterIntergerStructSequential retstr = caller(argstr);
+
+    if (!IsCorrectIncludeOuterIntergerStructSequential(&retstr))
     {
         printf("DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall:The Caller returns wrong value\n");
+        PrintIncludeOuterIntergerStructSequential(&retstr, "retstr");
         return FALSE;
     }
 
@@ -3239,3 +3251,112 @@ extern "C" DLL_EXPORT S11DelegatePInvokeByValStdCallCaller __stdcall Get_Marshal
 {
     return MarshalStructS11ByVal_StdCall;
 }
+
+
+typedef ByteStruct3Byte (__stdcall *ByteStruct3ByteByValStdCallCaller)(ByteStruct3Byte cs, BOOL *pBool);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte(ByteStruct3ByteByValStdCallCaller caller)
+{
+    //Init
+    ByteStruct3Byte argstr;
+
+    argstr.b1 = 1;
+    argstr.b2 = 42;
+    argstr.b3 = 90;
+
+    BOOL result;
+    ByteStruct3Byte retstruct = caller(argstr, &result);
+
+    if(!IsCorrectByteStruct3Byte(&retstruct))
+    {
+        printf("DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    if(!result)
+    {
+        printf("DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte:The Caller failed\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.b1 != 1 || argstr.b2 != 42 || argstr.b3 != 90)
+        return false;
+    return TRUE;
+}
+
+typedef ByteStruct3Byte (_cdecl *ByteStruct3ByteByValCdeclCaller)(ByteStruct3Byte cs, BOOL *pBool);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructByVal_Cdecl_ByteStruct3Byte(ByteStruct3ByteByValCdeclCaller caller)
+{
+    //Init
+    ByteStruct3Byte argstr;
+
+    argstr.b1 = 1;
+    argstr.b2 = 42;
+    argstr.b3 = 90;
+
+    BOOL result;
+    ByteStruct3Byte retstruct = caller(argstr, &result);
+
+    if(!IsCorrectByteStruct3Byte(&retstruct))
+    {
+        printf("DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte:The Caller returns wrong value\n");
+        return FALSE;
+    }
+
+    if(!result)
+    {
+        printf("DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte:The Caller failed\n");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.b1 != 1 || argstr.b2 != 42 || argstr.b3 != 90)
+        return false;
+    return TRUE;
+}
+
+typedef IntergerStructSequential (_cdecl *IntergerStructSequentialByValCdeclCaller)(IntergerStructSequential cs);
+extern "C" DLL_EXPORT BOOL _cdecl DoCallBack_MarshalStructIntergerStructSequentialByVal_Cdecl(IntergerStructSequentialByValCdeclCaller caller)
+{
+    //Init
+    IntergerStructSequential argstr;
+
+    argstr.i = 64;
+
+    IntergerStructSequential retstr = caller(argstr);
+
+    if (!IsCorrectIntergerStructSequential(&retstr))
+    {
+        printf("DoCallBack_MarshalStructIntergerStructSequentialByVal_Cdecl:The Caller returns wrong value\n");
+        PrintIntergerStructSequential(&retstr, "retstr");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i != 64)
+        return false;
+    return TRUE;
+}
+
+typedef IntergerStructSequential (__stdcall *IntergerStructSequentialByValStdCallCaller)(IntergerStructSequential cs);
+extern "C" DLL_EXPORT BOOL __stdcall DoCallBack_MarshalStructIntergerStructSequentialByVal_StdCall(IntergerStructSequentialByValStdCallCaller caller)
+{
+    //Init
+    IntergerStructSequential argstr;
+
+    argstr.i = 64;
+
+    IntergerStructSequential retstr = caller(argstr);
+
+    if (!IsCorrectIntergerStructSequential(&retstr))
+    {
+        printf("DoCallBack_MarshalStructIntergerStructSequentialByVal_StdCall:The Caller returns wrong value\n");
+        PrintIntergerStructSequential(&retstr, "retstr");
+        return FALSE;
+    }
+
+    //Verify the value unchanged
+    if(argstr.i != 64)
+        return false;
+    return TRUE;
+}
\ No newline at end of file
diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h
index b497b6133bebaa..50e8abd813ca74 100644
--- a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h
+++ b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/SeqStructDelRevPInvokeNative.h
@@ -672,6 +672,18 @@ struct IntergerStructSequential // size = 4 bytes
     INT i;
 };
 
+void PrintIntergerStructSequential(IntergerStructSequential* str, const char* name)
+{
+    printf("\t%s.i = %d\n", name, str->i);
+}
+
+bool IsCorrectIntergerStructSequential(IntergerStructSequential* str)
+{
+    if(str->i != 32)
+        return false;
+    return true;
+}
+
 struct S9;
 typedef void (*TestDelegate1)(struct S9 myStruct);
 
@@ -879,3 +891,29 @@ bool IsCorrectLongStructPack16Explicit(LongStructPack16Explicit* p)
         return false;
     return true;
 }
+
+struct ByteStruct3Byte
+{
+    BYTE b1;
+    BYTE b2;
+    BYTE b3;
+};
+void PrintByteStruct3Byte(ByteStruct3Byte* str, char const * name)
+{
+	printf("\t%s.b1 = %d", name, str->b1);
+	printf("\t%s.b2 = %d", name, str->b2);
+	printf("\t%s.b3 = %d", name, str->b3);
+}
+
+void ChangeByteStruct3Byte(ByteStruct3Byte* p)
+{
+	p->b1 = 1;
+	p->b2 = 42;
+	p->b2 = 90;
+}
+bool IsCorrectByteStruct3Byte(ByteStruct3Byte* p)
+{
+    if(p->b1 != 7 || p->b2 != 12 || p->b3 != 18)
+        return false;
+    return true;
+}
diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs
index 07edd32cbf9ef5..207530c1273768 100644
--- a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs
+++ b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/Struct.cs
@@ -189,6 +189,14 @@ public unsafe struct S11
     public int i;
 }
 
+[StructLayout(LayoutKind.Sequential)]
+public struct ByteStruct3Byte
+{
+    public byte b1;
+    public byte b2;
+    public byte b3;
+}
+
 [StructLayout(LayoutKind.Explicit)]
 public struct U
 {

From 3c9e028051124eda2e01c3974990f7499719f732 Mon Sep 17 00:00:00 2001
From: David Wrighton <davidwr@microsoft.com>
Date: Thu, 13 Feb 2020 11:33:00 -0800
Subject: [PATCH 5/5] Rewrite ReversePInvokeTest.cs to utf8

---
 .../ReversePInvoke/ReversePInvokeTest.cs      |  Bin 194376 -> 0 bytes
 .../ReversePInvoke/ReversePInvokeTest.csproj  |    2 +-
 .../ReversePInvoke/ReversePInvokeTest_.cs     | 1858 +++++++++++++++++
 3 files changed, 1859 insertions(+), 1 deletion(-)
 delete mode 100644 src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs
 create mode 100644 src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest_.cs

diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.cs
deleted file mode 100644
index 1e1774b8964983727258f04b79623b34ce3754f5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 194376
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
E0n?4yT>t<8

diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj
index a1db4da663a41c..e2666a9337d158 100644
--- a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj
+++ b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest.csproj
@@ -4,7 +4,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="ReversePInvokeTest.cs" />
+    <Compile Include="ReversePInvokeTest_.cs" />
     <Compile Include="..\..\Helper.cs" />
     <Compile Include="..\..\Struct.cs" />
   </ItemGroup>
diff --git a/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest_.cs b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest_.cs
new file mode 100644
index 00000000000000..2ee6ba354e9bf7
--- /dev/null
+++ b/src/coreclr/tests/src/Interop/StructMarshalling/ReversePInvoke/MarshalSeqStruct/ReversePInvoke/ReversePInvokeTest_.cs
@@ -0,0 +1,1858 @@
+// 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 MarshalStructTest
+{
+    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 side
+
+    private static string strOne;
+    private static string strTwo;
+
+    enum StructID
+    {
+        InnerSequentialId,
+        InnerArraySequentialId,
+        CharSetAnsiSequentialId,
+        CharSetUnicodeSequentialId,
+        NumberSequentialId,
+        S3Id,
+        S5Id,
+        StringStructSequentialAnsiId,
+        StringStructSequentialUnicodeId,
+        S8Id,
+        S9Id,
+        IncludeOuterIntergerStructSequentialId,
+        S11Id,
+        ComplexStructId,
+        ByteStruct3Byte
+    }
+
+
+    private static void testMethod(S9 s9)
+    {
+        Console.WriteLine("The first field of s9 is:", s9.i32);
+    }
+
+    #region Methods for the struct InnerSequential declaration
+
+    #region PassByRef
+
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool InnerSequentialByRefCdeclcaller([In, Out]ref InnerSequential argStr);
+    private static bool TestMethodForStructInnerSequential_ReversePInvokeByRef_Cdecl(ref InnerSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerSequential(argstr, change_is, "TestMethodForStructInnerSequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.f1 = 1;
+        argstr.f2 = 1.0F;
+        argstr.f3 = "some string";
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool InnerSequentialByRefStdCallcaller([In, Out]ref InnerSequential argStr);
+    private static bool TestMethodForStructInnerSequential_ReversePInvokeByRef_StdCall(ref InnerSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerSequential(argstr, change_is, "TestMethodForStructInnerSequential_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.f1 = 1;
+        argstr.f2 = 1.0F;
+        argstr.f3 = "some string";
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructInnerSequentialByRef_Cdecl(InnerSequentialByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructInnerSequentialByRef_StdCall(InnerSequentialByRefStdCallcaller caller);
+
+    #endregion
+
+    #region PassByValue
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool InnerSequentialByValCdeclcaller([In, Out] InnerSequential argStr);
+    private static bool TestMethodForStructInnerSequential_ReversePInvokeByVal_Cdecl(InnerSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerSequential(argstr, change_is, "TestMethodForStructInnerSequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.f1 = 1;
+        argstr.f2 = 1.0F;
+        argstr.f3 = "some string";
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool InnerSequentialByValStdCallcaller([In, Out] InnerSequential argStr);
+    private static bool TestMethodForStructInnerSequential_ReversePInvokeByVal_StdCall(InnerSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        InnerSequential change_is = Helper.NewInnerSequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerSequential(argstr, change_is, "TestMethodForStructInnerSequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.f1 = 1;
+        argstr.f2 = 1.0F;
+        argstr.f3 = "some string";
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructInnerSequentialByVal_Cdecl(InnerSequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructInnerSequentialByVal_StdCall(InnerSequentialByValStdCallcaller caller);
+
+    #endregion
+
+    #endregion
+
+    #region Methods for the struct InnerArraySequential declaration
+
+    #region PassByRef
+
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool InnerArraySequentialByRefCdeclcaller([In, Out]ref InnerArraySequential argStr);
+    private static bool TestMethodForStructInnerArraySequential_ReversePInvokeByRef_Cdecl(ref InnerArraySequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        InnerArraySequential change_is = Helper.NewInnerArraySequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerArraySequential(argstr, change_is, "TestMethodForStructInnerArraySequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            argstr.arr[i].f1 = 1;
+            argstr.arr[i].f2 = 1.0F;
+            argstr.arr[i].f3 = "some string";
+        }
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool InnerArraySequentialByRefStdCallcaller([In, Out]ref InnerArraySequential argStr);
+    private static bool TestMethodForStructInnerArraySequential_ReversePInvokeByRef_StdCall(ref InnerArraySequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        InnerArraySequential change_is = Helper.NewInnerArraySequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerArraySequential(argstr, change_is, "TestMethodForStructInnerArraySequential_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            argstr.arr[i].f1 = 1;
+            argstr.arr[i].f2 = 1.0F;
+            argstr.arr[i].f3 = "some string";
+        }
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructInnerArraySequentialByRef_Cdecl(InnerArraySequentialByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructInnerArraySequentialByRef_StdCall(InnerArraySequentialByRefStdCallcaller caller);
+
+    #endregion
+
+    #region PassByValue
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool InnerArraySequentialByValCdeclcaller([In, Out] InnerArraySequential argStr);
+    private static bool TestMethodForStructInnerArraySequential_ReversePInvokeByVal_Cdecl(InnerArraySequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        InnerArraySequential change_is = Helper.NewInnerArraySequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerArraySequential(argstr, change_is, "TestMethodForStructInnerArraySequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            argstr.arr[i].f1 = 1;
+            argstr.arr[i].f2 = 1.0F;
+            argstr.arr[i].f3 = "some string";
+        }
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool InnerArraySequentialByValStdCallcaller([In, Out] InnerArraySequential argStr);
+    private static bool TestMethodForStructInnerArraySequential_ReversePInvokeByVal_StdCall(InnerArraySequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        InnerArraySequential change_is = Helper.NewInnerArraySequential(77, 77.0F, "changed string");
+        //Check the input
+        Assert.IsTrue(Helper.ValidateInnerArraySequential(argstr, change_is, "TestMethodForStructInnerArraySequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        for (int i = 0; i < Common.NumArrElements; i++)
+        {
+            argstr.arr[i].f1 = 1;
+            argstr.arr[i].f2 = 1.0F;
+            argstr.arr[i].f3 = "some string";
+        }
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructInnerArraySequentialByVal_Cdecl(InnerArraySequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructInnerArraySequentialByVal_StdCall(InnerArraySequentialByValStdCallcaller caller);
+
+    #endregion
+
+    #endregion
+
+    #region Methods for the struct CharSetAnsiSequential declaration
+
+    #region PassByRef
+
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool CharSetAnsiSequentialByRefCdeclcaller([In, Out]ref CharSetAnsiSequential argStr);
+    private static bool TestMethodForStructCharSetAnsiSequential_ReversePInvokeByRef_Cdecl(ref CharSetAnsiSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        CharSetAnsiSequential change_is = Helper.NewCharSetAnsiSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetAnsiSequential(argstr, change_is, "TestMethodForStructCharSetAnsiSequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool CharSetAnsiSequentialByRefStdCallcaller([In, Out]ref CharSetAnsiSequential argStr);
+    private static bool TestMethodForStructCharSetAnsiSequential_ReversePInvokeByRef_StdCall(ref CharSetAnsiSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        CharSetAnsiSequential change_is = Helper.NewCharSetAnsiSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetAnsiSequential(argstr, change_is, "TestMethodForStructCharSetAnsiSequential_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructCharSetAnsiSequentialByRef_Cdecl(CharSetAnsiSequentialByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructCharSetAnsiSequentialByRef_StdCall(CharSetAnsiSequentialByRefStdCallcaller caller);
+
+    #endregion
+
+    #region PassByValue
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool CharSetAnsiSequentialByValCdeclcaller([In, Out] CharSetAnsiSequential argStr);
+    private static bool TestMethodForStructCharSetAnsiSequential_ReversePInvokeByVal_Cdecl(CharSetAnsiSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        CharSetAnsiSequential change_is = Helper.NewCharSetAnsiSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetAnsiSequential(argstr, change_is, "TestMethodForStructCharSetAnsiSequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool CharSetAnsiSequentialByValStdCallcaller([In, Out] CharSetAnsiSequential argStr);
+    private static bool TestMethodForStructCharSetAnsiSequential_ReversePInvokeByVal_StdCall(CharSetAnsiSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        CharSetAnsiSequential change_is = Helper.NewCharSetAnsiSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetAnsiSequential(argstr, change_is, "TestMethodForStructCharSetAnsiSequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructCharSetAnsiSequentialByVal_Cdecl(CharSetAnsiSequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructCharSetAnsiSequentialByVal_StdCall(CharSetAnsiSequentialByValStdCallcaller caller);
+
+    #endregion
+
+    #endregion
+
+    #region Methods for the struct CharSetUnicodeSequential declaration
+
+    #region PassByRef
+
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool CharSetUnicodeSequentialByRefCdeclcaller([In, Out]ref CharSetUnicodeSequential argStr);
+    private static bool TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByRef_Cdecl(ref CharSetUnicodeSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        CharSetUnicodeSequential change_is = Helper.NewCharSetUnicodeSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetUnicodeSequential(argstr, change_is, "TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool CharSetUnicodeSequentialByRefStdCallcaller([In, Out]ref CharSetUnicodeSequential argStr);
+    private static bool TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByRef_StdCall(ref CharSetUnicodeSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        CharSetUnicodeSequential change_is = Helper.NewCharSetUnicodeSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetUnicodeSequential(argstr, change_is, "TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_Cdecl(CharSetUnicodeSequentialByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_StdCall(CharSetUnicodeSequentialByRefStdCallcaller caller);
+
+    #endregion
+
+    #region PassByValue
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool CharSetUnicodeSequentialByValCdeclcaller([In, Out] CharSetUnicodeSequential argStr);
+    private static bool TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByVal_Cdecl(CharSetUnicodeSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        CharSetUnicodeSequential change_is = Helper.NewCharSetUnicodeSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetUnicodeSequential(argstr, change_is, "TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool CharSetUnicodeSequentialByValStdCallcaller([In, Out] CharSetUnicodeSequential argStr);
+    private static bool TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByVal_StdCall(CharSetUnicodeSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        CharSetUnicodeSequential change_is = Helper.NewCharSetUnicodeSequential("change string", 'n');
+        //Check the input
+        Assert.IsTrue(Helper.ValidateCharSetUnicodeSequential(argstr, change_is, "TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.f1 = "some string";
+        argstr.f2 = 'c';
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_Cdecl(CharSetUnicodeSequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_StdCall(CharSetUnicodeSequentialByValStdCallcaller caller);
+
+    #endregion
+
+    #endregion
+
+    #region Methods for the struct NumberSequential declaration
+
+    #region PassByRef
+
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool NumberSequentialByRefCdeclcaller([In, Out]ref NumberSequential argStr);
+    private static bool TestMethodForStructNumberSequential_ReversePInvokeByRef_Cdecl(ref NumberSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        NumberSequential change_is = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateNumberSequential(argstr, change_is, "TestMethodForStructNumberSequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.i32 = Int32.MinValue;
+        argstr.ui32 = UInt32.MaxValue;
+        argstr.s1 = short.MinValue;
+        argstr.us1 = ushort.MaxValue;
+        argstr.b = byte.MinValue;
+        argstr.sb = sbyte.MaxValue;
+        argstr.i16 = Int16.MinValue;
+        argstr.ui16 = UInt16.MaxValue;
+        argstr.i64 = -1234567890;
+        argstr.ui64 = 1234567890;
+        argstr.sgl = 32.0F;
+        argstr.d = 3.2;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool NumberSequentialByRefStdCallcaller([In, Out]ref NumberSequential argStr);
+    private static bool TestMethodForStructNumberSequential_ReversePInvokeByRef_StdCall(ref NumberSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        NumberSequential change_is = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateNumberSequential(argstr, change_is, "TestMethodForStructNumberSequential_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.i32 = Int32.MinValue;
+        argstr.ui32 = UInt32.MaxValue;
+        argstr.s1 = short.MinValue;
+        argstr.us1 = ushort.MaxValue;
+        argstr.b = byte.MinValue;
+        argstr.sb = sbyte.MaxValue;
+        argstr.i16 = Int16.MinValue;
+        argstr.ui16 = UInt16.MaxValue;
+        argstr.i64 = -1234567890;
+        argstr.ui64 = 1234567890;
+        argstr.sgl = 32.0F;
+        argstr.d = 3.2;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructNumberSequentialByRef_Cdecl(NumberSequentialByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructNumberSequentialByRef_StdCall(NumberSequentialByRefStdCallcaller caller);
+
+    #endregion
+
+    #region PassByValue
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate NumberSequential NumberSequentialByValCdeclcaller([In, Out] NumberSequential argStr);
+    private static NumberSequential TestMethodForStructNumberSequential_ReversePInvokeByVal_Cdecl(NumberSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        NumberSequential change_is = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateNumberSequential(argstr, change_is, "TestMethodForStructNumberSequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.i32 = Int32.MinValue;
+        argstr.ui32 = UInt32.MaxValue;
+        argstr.s1 = short.MinValue;
+        argstr.us1 = ushort.MaxValue;
+        argstr.b = byte.MinValue;
+        argstr.sb = sbyte.MaxValue;
+        argstr.i16 = Int16.MinValue;
+        argstr.ui16 = UInt16.MaxValue;
+        argstr.i64 = -1234567890;
+        argstr.ui64 = 1234567890;
+        argstr.sgl = 32.0F;
+        argstr.d = 3.2;
+        return argstr;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate NumberSequential NumberSequentialByValStdCallcaller([In, Out] NumberSequential argStr);
+    private static NumberSequential TestMethodForStructNumberSequential_ReversePInvokeByVal_StdCall(NumberSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        NumberSequential change_is = Helper.NewNumberSequential(0, 32, 0, 16, 0, 8, 0, 16, 0, 64, 64.0F, 6.4);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateNumberSequential(argstr, change_is, "TestMethodForStructNumberSequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.i32 = Int32.MinValue;
+        argstr.ui32 = UInt32.MaxValue;
+        argstr.s1 = short.MinValue;
+        argstr.us1 = ushort.MaxValue;
+        argstr.b = byte.MinValue;
+        argstr.sb = sbyte.MaxValue;
+        argstr.i16 = Int16.MinValue;
+        argstr.ui16 = UInt16.MaxValue;
+        argstr.i64 = -1234567890;
+        argstr.ui64 = 1234567890;
+        argstr.sgl = 32.0F;
+        argstr.d = 3.2;
+        return argstr;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructNumberSequentialByVal_Cdecl(NumberSequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructNumberSequentialByVal_StdCall(NumberSequentialByValStdCallcaller caller);
+
+    #endregion
+
+    #endregion
+
+    #region Methods for the struct S3 declaration
+
+    #region PassByRef
+
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S3ByRefCdeclcaller([In, Out]ref S3 argStr);
+    private static bool TestMethodForStructS3_ReversePInvokeByRef_Cdecl(ref S3 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        int[] iarr = new int[256];
+        int[] icarr = new int[256];
+        Helper.InitialArray(iarr, icarr);
+        S3 changeS3 = Helper.NewS3(false, "change string", icarr);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS3(argstr, changeS3, "TestMethodForStructS3_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.flag = true;
+        argstr.str = "some string";
+        argstr.vals = iarr;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S3ByRefStdCallcaller([In, Out]ref S3 argStr);
+    private static bool TestMethodForStructS3_ReversePInvokeByRef_StdCall(ref S3 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        int[] iarr = new int[256];
+        int[] icarr = new int[256];
+        Helper.InitialArray(iarr, icarr);
+        S3 changeS3 = Helper.NewS3(false, "change string", icarr);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS3(argstr, changeS3, "TestMethodForStructS3_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.flag = true;
+        argstr.str = "some string";
+        argstr.vals = iarr;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS3ByRef_Cdecl(S3ByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS3ByRef_StdCall(S3ByRefStdCallcaller caller);
+
+    #endregion
+
+    #region PassByValue
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S3ByValCdeclcaller([In, Out] S3 argStr);
+    private static bool TestMethodForStructS3_ReversePInvokeByVal_Cdecl(S3 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        int[] iarr = new int[256];
+        int[] icarr = new int[256];
+        Helper.InitialArray(iarr, icarr);
+        S3 changeS3 = Helper.NewS3(false, "change string", icarr);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS3(argstr, changeS3, "TestMethodForStructS3_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.flag = true;
+        argstr.str = "some string";
+        argstr.vals = iarr;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S3ByValStdCallcaller([In, Out] S3 argStr);
+    private static bool TestMethodForStructS3_ReversePInvokeByVal_StdCall(S3 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        int[] iarr = new int[256];
+        int[] icarr = new int[256];
+        Helper.InitialArray(iarr, icarr);
+        S3 changeS3 = Helper.NewS3(false, "change string", icarr);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS3(argstr, changeS3, "TestMethodForStructS3_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.flag = true;
+        argstr.str = "some string";
+        argstr.vals = iarr;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS3ByVal_Cdecl(S3ByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS3ByVal_StdCall(S3ByValStdCallcaller caller);
+
+    #endregion
+
+    #endregion
+
+    #region Methods for the struct S5 declaration
+  
+    #region PassByRef
+  
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S5ByRefCdeclcaller([In, Out]ref S5 argStr);
+    private static bool TestMethodForStructS5_ReversePInvokeByRef_Cdecl(ref S5 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        Enum1 enums = Enum1.e1;
+        Enum1 enumch = Enum1.e2;
+        S4 s4 = new S4();
+        s4.age = 32;
+        s4.name = "some string";
+        S5 changeS5 = Helper.NewS5(64, "change string", enumch);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS5(argstr, changeS5, "TestMethodForStructS5_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.s4 = s4;
+        argstr.ef = enums;
+        return true;
+    }
+   
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S5ByRefStdCallcaller([In, Out]ref S5 argStr);
+    private static bool TestMethodForStructS5_ReversePInvokeByRef_StdCall(ref S5 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        Enum1 enums = Enum1.e1;
+        Enum1 enumch = Enum1.e2;
+        S4 s4 = new S4();
+        s4.age = 32;
+        s4.name = "some string";
+        S5 changeS5 = Helper.NewS5(64, "change string", enumch);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS5(argstr, changeS5, "TestMethodForStructS5_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.s4 = s4;
+        argstr.ef = enums;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS5ByRef_Cdecl(S5ByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS5ByRef_StdCall(S5ByRefStdCallcaller caller);
+  
+    #endregion
+    
+    #region PassByValue
+   
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S5ByValCdeclcaller([In, Out] S5 argStr);
+    private static bool TestMethodForStructS5_ReversePInvokeByVal_Cdecl(S5 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        Enum1 enums = Enum1.e1;
+        Enum1 enumch = Enum1.e2;
+        S4 s4 = new S4();
+        s4.age = 32;
+        s4.name = "some string";
+        S5 changeS5 = Helper.NewS5(64, "change string", enumch);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS5(argstr, changeS5, "TestMethodForStructS5_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.s4 = s4;
+        argstr.ef = enums;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S5ByValStdCallcaller([In, Out] S5 argStr);
+    private static bool TestMethodForStructS5_ReversePInvokeByVal_StdCall(S5 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        Enum1 enums = Enum1.e1;
+        Enum1 enumch = Enum1.e2;
+        S4 s4 = new S4();
+        s4.age = 32;
+        s4.name = "some string";
+        S5 changeS5 = Helper.NewS5(64, "change string", enumch);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS5(argstr, changeS5, "TestMethodForStructS5_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.s4 = s4;
+        argstr.ef = enums;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS5ByVal_Cdecl(S5ByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS5ByVal_StdCall(S5ByValStdCallcaller caller);
+  
+    #endregion
+  
+    #endregion
+
+    #region Methods for the struct StringStructSequentialAnsi declaration
+   
+    #region PassByRef
+   
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool StringStructSequentialAnsiByRefCdeclcaller([In, Out]ref StringStructSequentialAnsi argStr);
+    private static bool TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByRef_Cdecl(ref StringStructSequentialAnsi argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        strOne = new String('a', 512);
+        strTwo = new String('b', 512);
+        StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialAnsi(argstr, change_sssa, "TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+   
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool StringStructSequentialAnsiByRefStdCallcaller([In, Out]ref StringStructSequentialAnsi argStr);
+    private static bool TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByRef_StdCall(ref StringStructSequentialAnsi argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        strOne = new String('a', 512);
+        strTwo = new String('b', 512);
+        StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialAnsi(argstr, change_sssa, "TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialAnsiByRef_Cdecl(StringStructSequentialAnsiByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialAnsiByRef_StdCall(StringStructSequentialAnsiByRefStdCallcaller caller);
+    
+    #endregion
+   
+    #region PassByValue
+    
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool StringStructSequentialAnsiByValCdeclcaller([In, Out] StringStructSequentialAnsi argStr);
+    private static bool TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByVal_Cdecl(StringStructSequentialAnsi argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        strOne = new String('a', 512);
+        strTwo = new String('b', 512);
+        StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialAnsi(argstr, change_sssa, "TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool StringStructSequentialAnsiByValStdCallcaller([In, Out] StringStructSequentialAnsi argStr);
+    private static bool TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByVal_StdCall(StringStructSequentialAnsi argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        strOne = new String('a', 512);
+        strTwo = new String('b', 512);
+        StringStructSequentialAnsi change_sssa = Helper.NewStringStructSequentialAnsi(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialAnsi(argstr, change_sssa, "TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialAnsiByVal_Cdecl(StringStructSequentialAnsiByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialAnsiByVal_StdCall(StringStructSequentialAnsiByValStdCallcaller caller);
+   
+    #endregion
+   
+    #endregion
+
+    #region Methods for the struct StringStructSequentialUnicode declaration
+   
+    #region PassByRef
+   
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool StringStructSequentialUnicodeByRefCdeclcaller([In, Out]ref StringStructSequentialUnicode argStr);
+    private static bool TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByRef_Cdecl(ref StringStructSequentialUnicode argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        strOne = new String('a', 256);
+        strTwo = new String('b', 256);
+        StringStructSequentialUnicode change_sssa = Helper.NewStringStructSequentialUnicode(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialUnicode(argstr, change_sssa, "TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+   
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool StringStructSequentialUnicodeByRefStdCallcaller([In, Out]ref StringStructSequentialUnicode argStr);
+    private static bool TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByRef_StdCall(ref StringStructSequentialUnicode argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        strOne = new String('a', 256);
+        strTwo = new String('b', 256);
+        StringStructSequentialUnicode change_sssa = Helper.NewStringStructSequentialUnicode(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialUnicode(argstr, change_sssa, "TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_Cdecl(StringStructSequentialUnicodeByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_StdCall(StringStructSequentialUnicodeByRefStdCallcaller caller);
+   
+    #endregion
+      
+    #region PassByValue
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool StringStructSequentialUnicodeByValCdeclcaller([In, Out] StringStructSequentialUnicode argStr);
+    private static bool TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByVal_Cdecl(StringStructSequentialUnicode argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        strOne = new String('a', 256);
+        strTwo = new String('b', 256);
+        StringStructSequentialUnicode change_sssa = Helper.NewStringStructSequentialUnicode(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialUnicode(argstr, change_sssa, "TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool StringStructSequentialUnicodeByValStdCallcaller([In, Out] StringStructSequentialUnicode argStr);
+    private static bool TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByVal_StdCall(StringStructSequentialUnicode argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        strOne = new String('a', 256);
+        strTwo = new String('b', 256);
+        StringStructSequentialUnicode change_sssa = Helper.NewStringStructSequentialUnicode(strTwo, strOne);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateStringStructSequentialUnicode(argstr, change_sssa, "TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.first = strOne;
+        argstr.last = strTwo;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_Cdecl(StringStructSequentialUnicodeByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_StdCall(StringStructSequentialUnicodeByValStdCallcaller caller);
+   
+    #endregion
+   
+    #endregion
+
+    #region Methods for the struct S8 declaration
+  
+    #region PassByRef
+   
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S8ByRefCdeclcaller([In, Out]ref S8 argStr);
+    private static bool TestMethodForStructS8_ReversePInvokeByRef_Cdecl(ref S8 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS8(argstr, changeS8, "TestMethodForStructS8_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.name = "hello";
+        argstr.gender = true;
+        argstr.jobNum = 10;
+        argstr.i32 = 128;
+        argstr.ui32 = 128;
+        argstr.mySByte = 32;
+        return true;
+    }
+  
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S8ByRefStdCallcaller([In, Out]ref S8 argStr);
+    private static bool TestMethodForStructS8_ReversePInvokeByRef_StdCall(ref S8 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS8(argstr, changeS8, "TestMethodForStructS8_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.name = "hello";
+        argstr.gender = true;
+        argstr.jobNum = 10;
+        argstr.i32 = 128;
+        argstr.ui32 = 128;
+        argstr.mySByte = 32;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS8ByRef_Cdecl(S8ByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS8ByRef_StdCall(S8ByRefStdCallcaller caller);
+  
+    #endregion
+  
+    #region PassByValue
+   
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S8ByValCdeclcaller([In, Out] S8 argStr);
+    private static bool TestMethodForStructS8_ReversePInvokeByVal_Cdecl(S8 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS8(argstr, changeS8, "TestMethodForStructS8_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.name = "hello";
+        argstr.gender = true;
+        argstr.jobNum = 10;
+        argstr.i32 = 128;
+        argstr.ui32 = 128;
+        argstr.mySByte = 32;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S8ByValStdCallcaller([In, Out] S8 argStr);
+    private static bool TestMethodForStructS8_ReversePInvokeByVal_StdCall(S8 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        S8 changeS8 = Helper.NewS8("world", false, 1, 256, 256, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS8(argstr, changeS8, "TestMethodForStructS8_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.name = "hello";
+        argstr.gender = true;
+        argstr.jobNum = 10;
+        argstr.i32 = 128;
+        argstr.ui32 = 128;
+        argstr.mySByte = 32;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS8ByVal_Cdecl(S8ByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS8ByVal_StdCall(S8ByValStdCallcaller caller);
+   
+    #endregion
+  
+    #endregion
+
+    #region Methods for the struct S9 declaration
+  
+    #region PassByRef
+    
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S9ByRefCdeclcaller([In, Out]ref S9 argStr);
+    private static bool TestMethodForStructS9_ReversePInvokeByRef_Cdecl(ref S9 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        S9 changeS9 = Helper.NewS9(256, null);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS9(argstr, changeS9, "TestMethodForStructS9_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.i32 = 128;
+        argstr.myDelegate1 = new TestDelegate1(testMethod);
+        return true;
+    }
+   
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S9ByRefStdCallcaller([In, Out]ref S9 argStr);
+    private static bool TestMethodForStructS9_ReversePInvokeByRef_StdCall(ref S9 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        S9 changeS9 = Helper.NewS9(256, null);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS9(argstr, changeS9, "TestMethodForStructS9_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.i32 = 128;
+        argstr.myDelegate1 = new TestDelegate1(testMethod);
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS9ByRef_Cdecl(S9ByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS9ByRef_StdCall(S9ByRefStdCallcaller caller);
+  
+    #endregion
+ 
+    #region PassByValue
+    
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S9ByValCdeclcaller([In, Out] S9 argStr);
+    private static bool TestMethodForStructS9_ReversePInvokeByVal_Cdecl(S9 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        S9 changeS9 = Helper.NewS9(256, null);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS9(argstr, changeS9, "TestMethodForStructS9_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.i32 = 128;
+        argstr.myDelegate1 = new TestDelegate1(testMethod);
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S9ByValStdCallcaller([In, Out] S9 argStr);
+    private static bool TestMethodForStructS9_ReversePInvokeByVal_StdCall(S9 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        S9 changeS9 = Helper.NewS9(256, null);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS9(argstr, changeS9, "TestMethodForStructS9_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.i32 = 128;
+        argstr.myDelegate1 = new TestDelegate1(testMethod);
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS9ByVal_Cdecl(S9ByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS9ByVal_StdCall(S9ByValStdCallcaller caller);
+   
+    #endregion
+   
+    #endregion
+
+    #region Methods for the struct IncludeOuterIntergerStructSequential declaration
+   
+    #region PassByRef
+   
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool IncludeOuterIntergerStructSequentialByRefCdeclcaller([In, Out]ref IncludeOuterIntergerStructSequential argStr);
+    private static bool TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByRef_Cdecl(ref IncludeOuterIntergerStructSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateIncludeOuterIntergerStructSequential(argstr, 
+            changeIncludeOuterIntergerStructSequential, "TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.s.s_int.i = 32;
+        argstr.s.i = 32;
+        return true;
+    }
+  
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool IncludeOuterIntergerStructSequentialByRefStdCallcaller([In, Out]ref IncludeOuterIntergerStructSequential argStr);
+    private static bool TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByRef_StdCall(ref IncludeOuterIntergerStructSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateIncludeOuterIntergerStructSequential(argstr, 
+            changeIncludeOuterIntergerStructSequential, "TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.s.s_int.i = 32;
+        argstr.s.i = 32;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl(IncludeOuterIntergerStructSequentialByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall(IncludeOuterIntergerStructSequentialByRefStdCallcaller caller);
+   
+    #endregion
+   
+    #region PassByValue
+    
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IncludeOuterIntergerStructSequential IncludeOuterIntergerStructSequentialByValCdeclcaller([In, Out] IncludeOuterIntergerStructSequential argStr);
+    private static IncludeOuterIntergerStructSequential TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByVal_Cdecl(IncludeOuterIntergerStructSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateIncludeOuterIntergerStructSequential(argstr, 
+            changeIncludeOuterIntergerStructSequential, "TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.s.s_int.i = 32;
+        argstr.s.i = 32;
+        return argstr;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate IncludeOuterIntergerStructSequential IncludeOuterIntergerStructSequentialByValStdCallcaller([In, Out] IncludeOuterIntergerStructSequential argStr);
+    private static IncludeOuterIntergerStructSequential TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByVal_StdCall(IncludeOuterIntergerStructSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        IncludeOuterIntergerStructSequential changeIncludeOuterIntergerStructSequential = Helper.NewIncludeOuterIntergerStructSequential(64, 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateIncludeOuterIntergerStructSequential(argstr, 
+            changeIncludeOuterIntergerStructSequential, "TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.s.s_int.i = 32;
+        argstr.s.i = 32;
+        return argstr;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl(IncludeOuterIntergerStructSequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall(IncludeOuterIntergerStructSequentialByValStdCallcaller caller);
+   
+    #endregion
+   
+    #endregion
+
+    #region Methods for the struct S11 declaration
+  
+    #region PassByRef
+   
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S11ByRefCdeclcaller([In, Out]ref S11 argStr);
+    unsafe private static bool TestMethodForStructS11_ReversePInvokeByRef_Cdecl(ref S11 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+        S11 changeS11 = Helper.NewS11((int*)(64), 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS11(argstr, changeS11, "TestMethodForStructS11_ReversePInvokeByRef_Cdecl"));
+        //Chanage the value
+        argstr.i32 = (int*)(32);
+        argstr.i = 32;
+        return true;
+    }
+   
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S11ByRefStdCallcaller([In, Out]ref S11 argStr);
+    unsafe private static bool TestMethodForStructS11_ReversePInvokeByRef_StdCall(ref S11 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        S11 changeS11 = Helper.NewS11((int*)(64), 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS11(argstr, changeS11, "TestMethodForStructS11_ReversePInvokeByRef_StdCall"));
+        //Chanage the value
+        argstr.i32 = (int*)(32);
+        argstr.i = 32;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS11ByRef_Cdecl(S11ByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS11ByRef_StdCall(S11ByRefStdCallcaller caller);
+  
+    #endregion
+  
+    #region PassByValue
+   
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool S11ByValCdeclcaller([In, Out] S11 argStr);
+    unsafe private static bool TestMethodForStructS11_ReversePInvokeByVal_Cdecl(S11 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        S11 changeS11 = Helper.NewS11((int*)(64), 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS11(argstr, changeS11, "TestMethodForStructS11_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.i32 = (int*)(32);
+        argstr.i = 32;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool S11ByValStdCallcaller([In, Out] S11 argStr);
+    unsafe private static bool TestMethodForStructS11_ReversePInvokeByVal_StdCall(S11 argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        S11 changeS11 = Helper.NewS11((int*)(64), 64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateS11(argstr, changeS11, "TestMethodForStructS11_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.i32 = (int*)(32);
+        argstr.i = 32;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructS11ByVal_Cdecl(S11ByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructS11ByVal_StdCall(S11ByValStdCallcaller caller);
+  
+    #endregion
+  
+    #endregion
+
+    #region Methods for the struct ComplexStruct declaration
+   
+    #region PassByRef
+   
+    //For Reverse Pinvoke ByRef
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ComplexStructByRefCdeclcaller([In, Out]ref ComplexStruct argStr);
+    private static bool TestMethodForStructComplexStruct_ReversePInvokeByRef_Cdecl(ref ComplexStruct cs)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,Cdecl");
+            //Check the input
+            Assert.AreEqual(9999, cs.i);
+            Assert.IsFalse(cs.b);
+            Assert.AreEqual("Native", cs.str);
+            Assert.AreEqual(-1, cs.type.idata);
+            Assert.AreEqual(3.14159, cs.type.ddata);
+            //Chanage the value
+            cs.i = 321;
+            cs.b = true;
+            cs.str = "Managed";
+            cs.type.idata = 123;
+            cs.type.ptrdata = (IntPtr)0x120000;
+            return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ComplexStructByRefStdCallcaller([In, Out]ref ComplexStruct argStr);
+    private static bool TestMethodForStructComplexStruct_ReversePInvokeByRef_StdCall(ref ComplexStruct cs)
+    {
+        Console.WriteLine("ReversePinvoke,By Ref,StdCall");
+        //Check the input
+        Assert.AreEqual(9999, cs.i);
+        Assert.IsFalse(cs.b);
+        Assert.AreEqual("Native", cs.str);
+        Assert.AreEqual(-1, cs.type.idata);
+        Assert.AreEqual(3.14159, cs.type.ddata);
+        //Chanage the value
+        cs.i = 321;
+        cs.b = true;
+        cs.str = "Managed";
+        cs.type.idata = 123;
+        cs.type.ptrdata = (IntPtr)0x120000;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructComplexStructByRef_Cdecl(ComplexStructByRefCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructComplexStructByRef_StdCall(ComplexStructByRefStdCallcaller caller);
+   
+    #endregion
+   
+    #region PassByValue
+   
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate bool ComplexStructByValCdeclcaller([In, Out] ComplexStruct argStr);
+    private static bool TestMethodForStructComplexStruct_ReversePInvokeByVal_Cdecl(ComplexStruct cs)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        //Check the input
+        Assert.AreEqual(9999, cs.i);
+        Assert.IsFalse(cs.b);
+        Assert.AreEqual("Native", cs.str);
+        Assert.AreEqual(-1, cs.type.idata);
+        Assert.AreEqual(3.14159, cs.type.ddata);
+        //Try to Chanage the value
+        cs.i = 321;
+        cs.b = true;
+        cs.str = "Managed";
+        cs.type.idata = 123;
+        cs.type.ptrdata = (IntPtr)0x120000;
+        return true;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate bool ComplexStructByValStdCallcaller([In, Out] ComplexStruct argStr);
+    private static bool TestMethodForStructComplexStruct_ReversePInvokeByVal_StdCall(ComplexStruct cs)
+    {
+        Console.WriteLine("Reverse Pinvoke,By Value,StdCall");
+        //Check the input
+        Assert.AreEqual(9999, cs.i);
+        Assert.IsFalse(cs.b);
+        Assert.AreEqual("Native", cs.str);
+        Assert.AreEqual(-1, cs.type.idata);
+        Assert.AreEqual(3.14159, cs.type.ddata);
+        //Try to Chanage the value
+        cs.i = 321;
+        cs.b = true;
+        cs.str = "Managed";
+        cs.type.idata = 123;
+        cs.type.ptrdata = (IntPtr)0x120000;
+        return true;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructComplexStructByVal_Cdecl(ComplexStructByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructComplexStructByVal_StdCall(ComplexStructByValStdCallcaller caller);
+   
+    #endregion
+
+    #endregion
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate ByteStruct3Byte ByValCdeclcaller_ByteStruct3Byte(ByteStruct3Byte bspe, [MarshalAs(UnmanagedType.Bool)] out bool success);
+
+    public static ByteStruct3Byte TestMethod_DoCallBack_MarshalStructByVal_ByteStruct3Byte_Cdecl(ByteStruct3Byte bspe, out bool success)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,Cdecl");
+        ByteStruct3Byte change_bspe = Helper.NewByteStruct3Byte(1, 42, 90);
+        Assert.IsTrue(Helper.ValidateByteStruct3Byte(change_bspe, bspe, "TestMethod_DoCallBack_MarshalStructByVal_ByteStruct3Byte_Cdecl"));
+        //changed the value
+        bspe.b1 = 7;
+        bspe.b2 = 12;
+        bspe.b3 = 18;
+        success = true;
+        return bspe;
+    }
+    
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate ByteStruct3Byte ByValStdCallcaller_ByteStruct3Byte(ByteStruct3Byte bspe, [MarshalAs(UnmanagedType.Bool)] out bool success);
+
+    public static ByteStruct3Byte TestMethod_DoCallBack_MarshalStructByVal_ByteStruct3Byte_StdCall(ByteStruct3Byte bspe, out bool success)
+    {
+        Console.WriteLine("Reverse,Pinvoke,By Val,StdCall");
+        ByteStruct3Byte change_bspe = Helper.NewByteStruct3Byte(1, 42, 90);
+        Assert.IsTrue(Helper.ValidateByteStruct3Byte(change_bspe, bspe, "TestMethod_DoCallBack_MarshalStructByVal_ByteStruct3Byte_StdCall"));
+        //changed the value
+        bspe.b1 = 7;
+        bspe.b2 = 12;
+        bspe.b3 = 18;
+        success = true;
+        return bspe;
+    }
+
+
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte(ByValStdCallcaller_ByteStruct3Byte caller);
+
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructByVal_Cdecl_ByteStruct3Byte(ByValCdeclcaller_ByteStruct3Byte caller);
+
+    //For Reverse Pinvoke ByVal
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+    public delegate IntergerStructSequential IntergerStructSequentialByValCdeclcaller([In, Out] IntergerStructSequential argStr);
+    private static IntergerStructSequential TestMethodForStructIntergerStructSequential_ReversePInvokeByVal_Cdecl(IntergerStructSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,Cdecl");
+        IntergerStructSequential changeIntergerStructSequential = Helper.NewIntergerStructSequential(64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateIntergerStructSequential(argstr, 
+            changeIntergerStructSequential, "TestMethodForStructIntergerStructSequential_ReversePInvokeByVal_Cdecl"));
+        //Chanage the value
+        argstr.i = 32;
+        return argstr;
+    }
+
+    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+    public delegate IntergerStructSequential IntergerStructSequentialByValStdCallcaller([In, Out] IntergerStructSequential argStr);
+    private static IntergerStructSequential TestMethodForStructIntergerStructSequential_ReversePInvokeByVal_StdCall(IntergerStructSequential argstr)
+    {
+        Console.WriteLine("ReversePinvoke,By Value,StdCall");
+        IntergerStructSequential changeIntergerStructSequential = Helper.NewIntergerStructSequential(64);
+        //Check the input
+        Assert.IsTrue(Helper.ValidateIntergerStructSequential(argstr, 
+            changeIntergerStructSequential, "TestMethodForStructIntergerStructSequential_ReversePInvokeByVal_StdCall"));
+        //Chanage the value
+        argstr.i = 32;
+        return argstr;
+    }
+
+    //Reverse Pinvoke,cdecl
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.Cdecl)]
+    public static extern bool DoCallBack_MarshalStructIntergerStructSequentialByVal_Cdecl(IntergerStructSequentialByValCdeclcaller caller);
+    //Reverse Pinvoke,stdcall
+    [DllImport("SeqPInvokeNative", CallingConvention = CallingConvention.StdCall)]
+    public static extern bool DoCallBack_MarshalStructIntergerStructSequentialByVal_StdCall(IntergerStructSequentialByValStdCallcaller caller);
+
+    #region Methods implementation
+   
+    //Reverse P/Invoke By Ref
+    private static void TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID structid)
+    {
+        switch (structid)
+        {
+            case StructID.ComplexStructId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructComplexStructByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructComplexStructByRef_Cdecl(new ComplexStructByRefCdeclcaller(TestMethodForStructComplexStruct_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.InnerSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerSequentialByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerSequentialByRef_Cdecl(new InnerSequentialByRefCdeclcaller(TestMethodForStructInnerSequential_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.InnerArraySequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerArraySequentialByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerArraySequentialByRef_Cdecl(
+                    new InnerArraySequentialByRefCdeclcaller(TestMethodForStructInnerArraySequential_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.CharSetAnsiSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetAnsiSequentialByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetAnsiSequentialByRef_Cdecl(
+                    new CharSetAnsiSequentialByRefCdeclcaller(TestMethodForStructCharSetAnsiSequential_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.CharSetUnicodeSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetUnicodeSequentialByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_Cdecl(
+                    new CharSetUnicodeSequentialByRefCdeclcaller(TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.NumberSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructNumberSequentialByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructNumberSequentialByRef_Cdecl(new NumberSequentialByRefCdeclcaller(TestMethodForStructNumberSequential_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.S3Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS3ByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS3ByRef_Cdecl(new S3ByRefCdeclcaller(TestMethodForStructS3_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.S5Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS5ByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS5ByRef_Cdecl(new S5ByRefCdeclcaller(TestMethodForStructS5_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.StringStructSequentialAnsiId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialAnsiByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialAnsiByRef_Cdecl(
+                    new StringStructSequentialAnsiByRefCdeclcaller(TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.StringStructSequentialUnicodeId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialUnicodeByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_Cdecl(
+                    new StringStructSequentialUnicodeByRefCdeclcaller(TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.S8Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS8ByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS8ByRef_Cdecl(new S8ByRefCdeclcaller(TestMethodForStructS8_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.S9Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS9ByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS9ByRef_Cdecl(new S9ByRefCdeclcaller(TestMethodForStructS9_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.IncludeOuterIntergerStructSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_Cdecl(
+                    new IncludeOuterIntergerStructSequentialByRefCdeclcaller(TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByRef_Cdecl)));
+                break;
+            case StructID.S11Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS11ByRef_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS11ByRef_Cdecl(new S11ByRefCdeclcaller(TestMethodForStructS11_ReversePInvokeByRef_Cdecl)));
+                break;
+            default:
+                Assert.Fail("DoCallBack_MarshalStructByRef_Cdecl:The structid (Managed Side) is wrong");
+                break;
+        }
+    }
+
+    private static void TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID structid)
+    {
+        switch (structid)
+        {
+            case StructID.ComplexStructId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructComplexStructByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructComplexStructByRef_StdCall(new ComplexStructByRefStdCallcaller(TestMethodForStructComplexStruct_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.InnerSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerSequentialByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerSequentialByRef_StdCall(new InnerSequentialByRefStdCallcaller(TestMethodForStructInnerSequential_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.InnerArraySequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerArraySequentialByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerArraySequentialByRef_StdCall(
+                    new InnerArraySequentialByRefStdCallcaller(TestMethodForStructInnerArraySequential_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.CharSetAnsiSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetAnsiSequentialByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetAnsiSequentialByRef_StdCall(
+                    new CharSetAnsiSequentialByRefStdCallcaller(TestMethodForStructCharSetAnsiSequential_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.CharSetUnicodeSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetUnicodeSequentialByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetUnicodeSequentialByRef_StdCall(
+                    new CharSetUnicodeSequentialByRefStdCallcaller(TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.NumberSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructNumberSequentialByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructNumberSequentialByRef_StdCall(new NumberSequentialByRefStdCallcaller(TestMethodForStructNumberSequential_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.S3Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS3ByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS3ByRef_StdCall(new S3ByRefStdCallcaller(TestMethodForStructS3_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.S5Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS5ByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS5ByRef_StdCall(new S5ByRefStdCallcaller(TestMethodForStructS5_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.StringStructSequentialAnsiId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialAnsiByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialAnsiByRef_StdCall(
+                    new StringStructSequentialAnsiByRefStdCallcaller(TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.StringStructSequentialUnicodeId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialUnicodeByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialUnicodeByRef_StdCall(
+                    new StringStructSequentialUnicodeByRefStdCallcaller(TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.S8Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS8ByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS8ByRef_StdCall(new S8ByRefStdCallcaller(TestMethodForStructS8_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.S9Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS9ByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS9ByRef_StdCall(new S9ByRefStdCallcaller(TestMethodForStructS9_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.IncludeOuterIntergerStructSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByRef_StdCall(
+                    new IncludeOuterIntergerStructSequentialByRefStdCallcaller(TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByRef_StdCall)));
+                break;
+            case StructID.S11Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS11ByRef_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS11ByRef_StdCall(new S11ByRefStdCallcaller(TestMethodForStructS11_ReversePInvokeByRef_StdCall)));
+                break;
+            default:
+                Assert.Fail("DoCallBack_MarshalStructByRef_StdCall:The structid (Managed Side) is wrong");
+                break;
+        }
+    }
+
+    private static void Run_TestMethod_DoCallBack_MarshalStructByRef_Cdecl()
+    {
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.ComplexStructId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.InnerSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.InnerArraySequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.CharSetAnsiSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.CharSetUnicodeSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.NumberSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.S3Id);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.S5Id);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.StringStructSequentialAnsiId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.StringStructSequentialUnicodeId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.S8Id);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.S9Id);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.IncludeOuterIntergerStructSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_Cdecl(StructID.S11Id);
+    }
+
+    private static void Run_TestMethod_DoCallBack_MarshalStructByRef_StdCall()
+    {
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.ComplexStructId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.InnerSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.InnerArraySequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.CharSetAnsiSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.CharSetUnicodeSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.NumberSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.S3Id);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.S5Id);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.StringStructSequentialAnsiId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.StringStructSequentialUnicodeId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.S8Id);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.S9Id);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.IncludeOuterIntergerStructSequentialId);
+        TestMethod_DoCallBack_MarshalStructByRef_StdCall(StructID.S11Id);
+    }
+
+    //Reverse P/Invoke By Value
+    private static void TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID structid)
+    {
+        switch (structid)
+        {
+            case StructID.ComplexStructId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructComplexeStructByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructComplexStructByVal_Cdecl(new ComplexStructByValCdeclcaller(TestMethodForStructComplexStruct_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.InnerSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerSequentialByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerSequentialByVal_Cdecl(new InnerSequentialByValCdeclcaller(TestMethodForStructInnerSequential_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.InnerArraySequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerArraySequentialByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerArraySequentialByVal_Cdecl(
+                    new InnerArraySequentialByValCdeclcaller(TestMethodForStructInnerArraySequential_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.CharSetAnsiSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetAnsiSequentialByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetAnsiSequentialByVal_Cdecl
+                    (new CharSetAnsiSequentialByValCdeclcaller(TestMethodForStructCharSetAnsiSequential_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.CharSetUnicodeSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetUnicodeSequentialByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_Cdecl(
+                    new CharSetUnicodeSequentialByValCdeclcaller(TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.NumberSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructNumberSequentialByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructNumberSequentialByVal_Cdecl(new NumberSequentialByValCdeclcaller(TestMethodForStructNumberSequential_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.S3Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS3ByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS3ByVal_Cdecl(new S3ByValCdeclcaller(TestMethodForStructS3_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.S5Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS5ByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS5ByVal_Cdecl(new S5ByValCdeclcaller(TestMethodForStructS5_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.StringStructSequentialAnsiId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialAnsiByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialAnsiByVal_Cdecl(
+                    new StringStructSequentialAnsiByValCdeclcaller(TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.StringStructSequentialUnicodeId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialUnicodeByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_Cdecl(
+                    new StringStructSequentialUnicodeByValCdeclcaller(TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.S8Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS8ByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS8ByVal_Cdecl(new S8ByValCdeclcaller(TestMethodForStructS8_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.S9Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS9ByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS9ByVal_Cdecl(new S9ByValCdeclcaller(TestMethodForStructS9_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.IncludeOuterIntergerStructSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_Cdecl(
+                    new IncludeOuterIntergerStructSequentialByValCdeclcaller(TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.S11Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS11ByVal_Cdecl...");
+                Assert.IsTrue(DoCallBack_MarshalStructS11ByVal_Cdecl(new S11ByValCdeclcaller(TestMethodForStructS11_ReversePInvokeByVal_Cdecl)));
+                break;
+            case StructID.ByteStruct3Byte:
+                Console.WriteLine("Calling DoCallBack_MarshalStructByVal_Cdecl_ByteStruct3Byte...");
+                Assert.IsTrue(DoCallBack_MarshalStructByVal_Cdecl_ByteStruct3Byte(
+                    new ByValCdeclcaller_ByteStruct3Byte(TestMethod_DoCallBack_MarshalStructByVal_ByteStruct3Byte_Cdecl)));
+                break;
+            default:
+                Assert.Fail("DoCallBack_MarshalStructByVal_Cdecl:The structid (Managed Side) is wrong");
+                break;
+        }
+    }
+
+    private static void TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID structid)
+    {
+        switch (structid)
+        {
+            case StructID.ComplexStructId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructComplexStructByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructComplexStructByVal_StdCall(new ComplexStructByValStdCallcaller(TestMethodForStructComplexStruct_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.InnerSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerSequentialByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerSequentialByVal_StdCall(new InnerSequentialByValStdCallcaller(TestMethodForStructInnerSequential_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.InnerArraySequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructInnerArraySequentialByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructInnerArraySequentialByVal_StdCall(
+                    new InnerArraySequentialByValStdCallcaller(TestMethodForStructInnerArraySequential_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.CharSetAnsiSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetAnsiSequentialByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetAnsiSequentialByVal_StdCall(
+                    new CharSetAnsiSequentialByValStdCallcaller(TestMethodForStructCharSetAnsiSequential_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.CharSetUnicodeSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructCharSetUnicodeSequentialByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructCharSetUnicodeSequentialByVal_StdCall(
+                    new CharSetUnicodeSequentialByValStdCallcaller(TestMethodForStructCharSetUnicodeSequential_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.NumberSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructNumberSequentialByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructNumberSequentialByVal_StdCall(new NumberSequentialByValStdCallcaller(TestMethodForStructNumberSequential_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.S3Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS3ByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS3ByVal_StdCall(new S3ByValStdCallcaller(TestMethodForStructS3_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.S5Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS5ByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS5ByVal_StdCall(new S5ByValStdCallcaller(TestMethodForStructS5_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.StringStructSequentialAnsiId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialAnsiByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialAnsiByVal_StdCall(
+                    new StringStructSequentialAnsiByValStdCallcaller(TestMethodForStructStringStructSequentialAnsi_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.StringStructSequentialUnicodeId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructStringStructSequentialUnicodeByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructStringStructSequentialUnicodeByVal_StdCall(
+                    new StringStructSequentialUnicodeByValStdCallcaller(TestMethodForStructStringStructSequentialUnicode_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.S8Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS8ByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS8ByVal_StdCall(new S8ByValStdCallcaller(TestMethodForStructS8_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.S9Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS9ByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS9ByVal_StdCall(new S9ByValStdCallcaller(TestMethodForStructS9_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.IncludeOuterIntergerStructSequentialId:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructIncludeOuterIntergerStructSequentialByVal_StdCall(
+                    new IncludeOuterIntergerStructSequentialByValStdCallcaller(TestMethodForStructIncludeOuterIntergerStructSequential_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.S11Id:
+                Console.WriteLine("Calling ReversePInvoke_MarshalStructS11ByVal_StdCall...");
+                Assert.IsTrue(DoCallBack_MarshalStructS11ByVal_StdCall(new S11ByValStdCallcaller(TestMethodForStructS11_ReversePInvokeByVal_StdCall)));
+                break;
+            case StructID.ByteStruct3Byte:
+                Console.WriteLine("Calling DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte...");
+                Assert.IsTrue(DoCallBack_MarshalStructByVal_StdCall_ByteStruct3Byte(
+                    new ByValStdCallcaller_ByteStruct3Byte(TestMethod_DoCallBack_MarshalStructByVal_ByteStruct3Byte_StdCall)));
+                break;
+            default:
+                Assert.Fail("DoCallBack_MarshalStructByVal_StdCall:The structid (Managed Side) is wrong");
+                break;
+        }
+    }
+
+    private static void Run_TestMethod_DoCallBack_MarshalStructByVal_Cdecl()
+    {
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.ComplexStructId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.InnerSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.InnerArraySequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.CharSetAnsiSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.CharSetUnicodeSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.NumberSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.S3Id);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.S5Id);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.StringStructSequentialAnsiId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.StringStructSequentialUnicodeId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.S8Id);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.S9Id);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.IncludeOuterIntergerStructSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.S11Id);
+        // Windows X86 has a long standing X86_ONLY logic that causes 3, 5,6,7 byte structure returns to behave incorrectly.
+        if ((RuntimeInformation.ProcessArchitecture != Architecture.X86) || !RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            TestMethod_DoCallBack_MarshalStructByVal_Cdecl(StructID.ByteStruct3Byte);
+        }
+    }
+
+    private static void Run_TestMethod_DoCallBack_MarshalStructByVal_StdCall()
+    {
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.ComplexStructId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.InnerSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.InnerArraySequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.CharSetAnsiSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.CharSetUnicodeSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.NumberSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.S3Id);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.S5Id);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.StringStructSequentialAnsiId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.StringStructSequentialUnicodeId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.S8Id);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.S9Id);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.IncludeOuterIntergerStructSequentialId);
+        TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.S11Id);
+        // Windows X86 has a long standing X86_ONLY logic that causes 3, 5,6,7 byte structure returns to behave incorrectly.
+        if ((RuntimeInformation.ProcessArchitecture != Architecture.X86) || !RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            TestMethod_DoCallBack_MarshalStructByVal_StdCall(StructID.ByteStruct3Byte);
+        }
+    }
+  
+    #endregion
+
+    static int Main()
+    {
+        try{
+            
+        //Reverse Pinvoke,ByRef,cdecl
+        Console.WriteLine("Run the methods for marshaling struct Reverse P/Invoke ByRef");
+        Run_TestMethod_DoCallBack_MarshalStructByRef_Cdecl();
+        Run_TestMethod_DoCallBack_MarshalStructByRef_StdCall();
+
+        //Reverse PInvoke,ByValue,Cdcel
+        Console.WriteLine("Run the methods for marshaling struct Reverse P/Invoke ByVal");
+        Run_TestMethod_DoCallBack_MarshalStructByVal_Cdecl();
+        Run_TestMethod_DoCallBack_MarshalStructByVal_StdCall();
+
+            return 100;
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine($"Test Failure: {e}");
+            return 101;
+        }
+    }
+}
\ No newline at end of file