public void TypeTest2()
{
var t = typeof(string);
var mt = t.AsMetaType();
Assert.AreEqual(mt.RuntimeType, t);
Assert.AreEqual(mt.Token, t.MetadataToken);
Assert.AreEqual(mt.Attributes, t.Attributes);
Assert.True(mt.HasComponentSize);
Assert.True(mt.IsString);
Assert.True(mt.IsStringOrArray);
Assert.AreEqual(mt.ComponentSize, sizeof(char));
TestUtil.AssertAll(!mt.IsInteger,
!mt.IsUnmanaged,
!mt.IsNumeric,
!mt.IsReal,
!mt.IsAnyPointer,
!mt.IsArray);
var mti = typeof(int).AsMetaType();
TestUtil.AssertAll(mti.IsInteger,
!mti.IsReal,
mti.IsNumeric);
var mtf = typeof(float).AsMetaType();
TestUtil.AssertAll(!mtf.IsInteger,
mtf.IsReal,
mtf.IsNumeric);
var rg1 = new int[1];
var mtrg1 = rg1.GetType().AsMetaType();
Assert.AreEqual(rg1.Rank, mtrg1.ArrayRank);
Assert.True(mtrg1.HasComponentSize);
Assert.AreEqual(mtrg1.ComponentSize, sizeof(int));
Assert.AreEqual(rg1.GetType().GetElementType(), mtrg1.ElementTypeHandle.RuntimeType);
var rg2 = new int[1, 1];
var mtrg2 = rg2.GetType().AsMetaType();
Assert.AreEqual(rg2.Rank, mtrg2.ArrayRank);
Assert.AreEqual(rg2.GetType().GetElementType(), mtrg2.ElementTypeHandle.RuntimeType);
unsafe
{
fixed(int *i = rg1)
{
Assert.AreEqual((ulong)i, Mem.AddressOfHeap(rg1, OffsetOptions.ArrayData).ToUInt64());
}
}
}
public unsafe void GCTest()
{
var s = "bar";
var ptr = Mem.AddressOfHeap(s).ToPointer();
Assert.True(GCHeap.IsHeapPointer(ptr));
var p = new Point();
Assert.False(GCHeap.IsHeapPointer(&p));
Assert.True(GCHeap.IsHeapPointer(s));
}
public void ArrayTest()
{
int[] rg = { 1, 2, 3 };
var ptr = Mem.AddressOfHeap(rg, OffsetOptions.ArrayData);
unsafe
{
fixed(int *p = rg)
{
Assert.AreEqual((ulong)p, ptr.ToUInt64());
}
}
ptr[0] = 100;
Assert.True(rg.SequenceEqual(new[] { 100, 2, 3 }));
}
public void PinTest(object s)
{
//var g = GCHandle.Alloc(s, GCHandleType.Pinned);
var p = Mem.AddressOfHeap(s);
Mem.Pin(s);
Assert.False(AddPressure(p, s));
Mem.Unpin(s);
// Assert.True(AddPressure(p, s));
Mem.InvokeWhilePinned(s, (o) =>
{
Assert.False(AddPressure(p, o));
});
}
public void StringTest()
{
string s = "foo";
var pointer = Mem.AddressOfHeap(s, OffsetOptions.StringData);
unsafe
{
fixed(char *p = s)
{
Assert.AreEqual((ulong)p, pointer.ToUInt64());
}
}
var p2 = pointer.Cast <char>();
p2[0] = 'g';
Assert.AreEqual(s, "goo");
}
private static bool AddPressure(Pointer <byte> p, object s)
{
for (int i = 0; i < 1000; i++)
{
//GC.AddMemoryPressure(100000);
var r = new object[1000];
for (int j = 0; j < r.Length; j++)
{
r[j] = new Random().Next();
}
GC.Collect();
if (p != Mem.AddressOfHeap(s))
{
return(true);
}
}
return(false);
}
public void Test1()
{
int i = 256;
var ptr1 = Mem.AddressOf(ref i);
Assert.AreEqual(ptr1.Value, i);
Assert.AreEqual(ptr1.Reference, i);
var rg = new int[] { 1, 2, 3 };
Pointer <int> ptr2 = Mem.AddressOfHeap(rg, OffsetOptions.ArrayData);
fixed(int *p1 = rg)
{
int *cpy = p1;
for (int j = 0; j < rg.Length; j++)
{
Assert.True(ptr2.Address == Marshal.UnsafeAddrOfPinnedArrayElement(rg, j));
Assert.True(cpy++ == ptr2++);
}
}
}
public void Test5()
{
Span <int> s = stackalloc int[4] {
1, 2, 3, 4
};
Pointer <int> p = s;
Assert.AreEqual(s[0], p[0]);
p++;
Assert.AreEqual(s[1], p.Value);
var rg2 = new string[] { "foo", "bar" };
var rg = new[] { 1, 2, 3, 4 };
var p2 = Mem.AddressOfHeap(rg, OffsetOptions.ArrayData);
var asMemory = rg.AsMemory();
var pin = asMemory.Pin();
Assert.True(pin.Pointer == p2.ToPointer());
var p3 = Mem.AddressOfHeap(rg2, OffsetOptions.ArrayData).Cast <string>();
Assert.True(p3.Value == rg2[0]);
}
public static bool IsHeapPointer <T>(T t, bool smallHeapOnly = false) where T : class => IsHeapPointer(Mem.AddressOfHeap(t), smallHeapOnly);
public unsafe void AddressTest()
{
/*
* String
*/
var s = "foo";
IntPtr strFixed;
fixed(char *c = s)
{
strFixed = (IntPtr)c;
}
IntPtr strPin;
fixed(char *c = &s.GetPinnableReference())
{
strPin = (IntPtr)c;
}
var pin = s.AsMemory().Pin();
var strPinHandle = (IntPtr)pin.Pointer;
var strMem = Mem.AddressOfHeap(s, OffsetOptions.StringData).Address;
Assert.AreEqual(strFixed, strMem);
Assert.AreEqual(strPin, strMem);
Assert.AreEqual(strPinHandle, strMem);
/*
* Array
*/
IntPtr arrayFixed;
var rg = new[] { 1, 2, 3 };
fixed(int *c = rg)
{
arrayFixed = (IntPtr)c;
}
var arrayPin = rg.AsMemory().Pin();
var arrayPinHandle = (IntPtr)arrayPin.Pointer;
var arrayMem = Mem.AddressOfHeap(rg, OffsetOptions.ArrayData).Address;
Assert.AreEqual(arrayFixed, arrayMem);
Assert.AreEqual(arrayPinHandle, arrayMem);
/*
* Object
*/
object obj = new();
IntPtr objFixed;
fixed(byte *p = &Mem.GetPinningHelper(obj).Data)
{
objFixed = (IntPtr)p;
}
var objMem = Mem.AddressOfHeap(obj, OffsetOptions.Fields).Address;
Assert.AreEqual(objFixed, objMem);
}
