//
using System;
+using System.Text;
using System.Runtime.InteropServices;
-public class Test {
+public class Tests {
[StructLayout (LayoutKind.Sequential)]
[MarshalAs (UnmanagedType.ByValArray, SizeConst=2)] public char[] a2;
}
+ [StructLayout (LayoutKind.Sequential, CharSet=CharSet.Ansi)]
+ public struct ByValTStrStruct {
+ [MarshalAs (UnmanagedType.ByValTStr, SizeConst=4)] public string s1;
+ public int i;
+ }
+
[StructLayout (LayoutKind.Sequential, CharSet=CharSet.Unicode)]
public struct ByValWStrStruct {
[MarshalAs (UnmanagedType.ByValTStr, SizeConst=4)] public string s1;
public int i;
}
+
+ [StructLayout (LayoutKind.Sequential, Pack=1)]
+ public struct PackStruct1 {
+ float f;
+ }
+
+ [StructLayout (LayoutKind.Sequential)]
+ public struct PackStruct2 {
+ byte b;
+ PackStruct1 s;
+ }
- public unsafe static int Main () {
+ public unsafe static int Main (String[] args) {
+ if (TestDriver.RunTests (typeof (Tests), args) != 0)
+ return 34;
+ return 0;
+ }
+
+ public static int test_0_structure_to_ptr () {
SimpleStruct ss = new SimpleStruct ();
int size = Marshal.SizeOf (typeof (SimpleStruct));
if (cp.a2 [1] != 'b')
return 30;
+ return 0;
+ }
+
+ [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode)]
+ public struct Struct1
+ {
+ [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
+ public string Field1;
+ [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
+ public string Field2;
+ [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
+ public string Field3;
+ }
+
+ public static int test_0_byvaltstr () {
+ ByValTStrStruct s = new ByValTStrStruct ();
+
+ IntPtr p2 = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (ByValTStrStruct)));
+ Marshal.StructureToPtr(s, p2, false);
+
+ /* Check that the ByValTStr is initialized correctly */
+ for (int i = 0; i < 4; ++i)
+ if (Marshal.ReadByte (p2, i) != 0)
+ return 31;
+
+ s.s1 = "ABCD";
+ s.i = 55;
+
+ Marshal.StructureToPtr(s, p2, false);
- /* ByValTStr with Unicode */
+ ByValTStrStruct s2 = (ByValTStrStruct)Marshal.PtrToStructure (p2, typeof (ByValTStrStruct));
+
+ /* The fourth char is lost because of null-termination */
+ if (s2.s1 != "ABC")
+ return 32;
+
+ if (s2.i != 55)
+ return 33;
+
+ // Check that decoding also respects the size, even when there is no null terminator
+ byte[] data = Encoding.ASCII.GetBytes ("ABCDXXXX");
+ int size = Marshal.SizeOf (typeof (ByValTStrStruct));
+ IntPtr buffer = Marshal.AllocHGlobal (size);
+ Marshal.Copy (data, 0, buffer, size);
+
+ s2 = (ByValTStrStruct)Marshal.PtrToStructure (buffer, typeof (ByValTStrStruct));
+ if (s2.s1 != "ABC")
+ return 34;
+
+ return 0;
+ }
+
+ public static int test_0_byvaltstr_unicode () {
ByValWStrStruct s = new ByValWStrStruct ();
IntPtr p2 = Marshal.AllocHGlobal (Marshal.SizeOf (typeof (ByValWStrStruct)));
if (s2.i != 55)
return 33;
+ return 0;
+ }
+ public static int test_0_byvaltstr_max_size () {
+ string buffer = "12345678123456789012345678901234";
+
+ IntPtr ptr = Marshal.StringToBSTR (buffer);
+
+ Struct1 data = (Struct1)Marshal.PtrToStructure (ptr, typeof (Struct1));
+ if (data.Field1 != "12345678")
+ return 1;
+ if (data.Field2 != "1234567890")
+ return 2;
+ if (data.Field3 != "12345678901234")
+ return 3;
return 0;
}
-}
+ // Check that the 'Pack' directive on a struct changes the min alignment of the struct as well (#12110)
+ public static int test_0_struct_pack () {
+ if (Marshal.OffsetOf (typeof (PackStruct2), "s") != new IntPtr (1))
+ return 1;
+ return 0;
+ }
+
+ public static int test_0_generic_ptr_to_struct () {
+ int size = Marshal.SizeOf (typeof (SimpleStruct2));
+ IntPtr p = Marshal.AllocHGlobal (size);
+
+ Marshal.WriteInt32 (p, 0, 1); //a
+ Marshal.WriteInt32 (p, 4, 2); //a
+
+ var s = Marshal.PtrToStructure<SimpleStruct2> (p);
+
+ if (s.a != 1)
+ return 1;
+ if (s.b != 2)
+ return 2;
+ return 0;
+ }
+}