136 lines
3.8 KiB
C#
136 lines
3.8 KiB
C#
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using WhiteMagic;
|
|
|
|
namespace WhiteMagicTest;
|
|
|
|
/// <summary>
|
|
/// Tests for <see cref="MarshalCache{T}"/>: blittable size, marshal-required flag,
|
|
/// and computed-once behavior.
|
|
/// </summary>
|
|
public class MarshalCacheTests
|
|
{
|
|
[Fact]
|
|
public void Size_for_int_is_4()
|
|
{
|
|
Assert.Equal(4, MarshalCache<int>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_byte_is_1()
|
|
{
|
|
Assert.Equal(1, MarshalCache<byte>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_IntPtr_matches_native_pointer_size()
|
|
{
|
|
Assert.Equal(IntPtr.Size, MarshalCache<IntPtr>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_bool_is_1()
|
|
{
|
|
Assert.Equal(1, MarshalCache<bool>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_enum_matches_underlying_type()
|
|
{
|
|
Assert.Equal(4, MarshalCache<DayOfWeek>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_blittable_struct_is_accurate()
|
|
{
|
|
Assert.Equal(8, MarshalCache<BlittableStruct>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_struct_with_bool_is_managed_layout_width()
|
|
{
|
|
// Regression for the Marshal.SizeOf / Unsafe.SizeOf disagreement on a struct
|
|
// whose only field is `bool`: Marshal reports 4 bytes (Win32 BOOL default marshaling),
|
|
// but the blittable path (MemoryMarshal.Read<T>) actually lays out a bool as 1 byte.
|
|
// MarshalCache.Size must match what the reader actually touches.
|
|
Assert.Equal(Unsafe.SizeOf<SingleBoolStruct>(), MarshalCache<SingleBoolStruct>.Size);
|
|
Assert.Equal(1, MarshalCache<SingleBoolStruct>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void Size_for_struct_with_bools_in_sequence_matches_managed_layout()
|
|
{
|
|
// Sequential struct { bool, bool } — managed width is 2, Marshal width is 8 (two BOOLs).
|
|
// The blittable path uses 1 byte per bool, so Size must equal the managed width.
|
|
Assert.Equal(Unsafe.SizeOf<SequentialBoolStruct>(), MarshalCache<SequentialBoolStruct>.Size);
|
|
Assert.Equal(2, MarshalCache<SequentialBoolStruct>.Size);
|
|
}
|
|
|
|
[Fact]
|
|
public void TypeRequiresMarshal_is_false_for_blittable_types()
|
|
{
|
|
Assert.False(MarshalCache<int>.TypeRequiresMarshal);
|
|
Assert.False(MarshalCache<byte>.TypeRequiresMarshal);
|
|
Assert.False(MarshalCache<IntPtr>.TypeRequiresMarshal);
|
|
Assert.False(MarshalCache<IntPtr>.TypeRequiresMarshal);
|
|
}
|
|
|
|
[Fact]
|
|
public void TypeRequiresMarshal_is_true_for_types_with_MarshalAs_field()
|
|
{
|
|
Assert.True(MarshalCache<MarshalAsStruct>.TypeRequiresMarshal);
|
|
}
|
|
|
|
[Fact]
|
|
public void TypeRequiresMarshal_is_true_for_reference_containing_types()
|
|
{
|
|
Assert.True(MarshalCache<string>.TypeRequiresMarshal);
|
|
Assert.True(MarshalCache<ClassWithInt>.TypeRequiresMarshal);
|
|
}
|
|
|
|
[Fact]
|
|
public void Properties_are_computed_once_and_cached()
|
|
{
|
|
int size1 = MarshalCache<int>.Size;
|
|
bool marshal1 = MarshalCache<int>.TypeRequiresMarshal;
|
|
|
|
int size2 = MarshalCache<int>.Size;
|
|
bool marshal2 = MarshalCache<int>.TypeRequiresMarshal;
|
|
|
|
Assert.Equal(size1, size2);
|
|
Assert.Equal(marshal1, marshal2);
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct BlittableStruct
|
|
{
|
|
public int X;
|
|
public int Y;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct MarshalAsStruct
|
|
{
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
|
|
public byte[] Data;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct SingleBoolStruct
|
|
{
|
|
public bool Flag;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
private struct SequentialBoolStruct
|
|
{
|
|
public bool A;
|
|
public bool B;
|
|
}
|
|
|
|
private class ClassWithInt
|
|
{
|
|
public int Value = 0;
|
|
}
|
|
}
|