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); }