public unsafe void Test_MemoryExtensions_FromMemoryManager_CastFromByte_Pin(int size, int preOffset, int postOffset)
{
// Just like the test above, but this type the initial memory wraps a memory manager
var data = new ArrayMemoryManager <byte>(size);
Memory <byte> memoryOfBytes = data.Memory.Slice(preOffset);
Memory <float> memoryOfFloats = memoryOfBytes.Cast <byte, float>().Slice(postOffset);
using var handle = memoryOfFloats.Pin();
void *p1 = handle.Pointer;
void *p2 = Unsafe.AsPointer(ref data.GetSpan()[preOffset + (postOffset * sizeof(float))]);
Assert.IsTrue(p1 == p2);
}
public void Test_MemoryExtensions_FromMemoryManager_CastToShort_WithSlice()
{
// Same as above but with different types
Memory <float> memoryOfFloats = new ArrayMemoryManager <float>(512).Memory.Slice(128, 128);
Memory <short> memoryOfShorts = memoryOfFloats.Cast <float, short>();
Assert.AreEqual(memoryOfShorts.Length, 128 * sizeof(float) / sizeof(short));
Span <float> spanOfFloats = memoryOfFloats.Span;
Span <short> spanOfShorts = memoryOfShorts.Span;
Assert.AreEqual(memoryOfShorts.Length, spanOfShorts.Length);
Assert.IsTrue(Unsafe.AreSame(
ref spanOfFloats[0],
ref Unsafe.As <short, float>(ref spanOfShorts[0])));
}
public void Test_MemoryExtensions_FromMemoryManager_CastToByte_WithSlice()
{
// Same as above, but with inverted types
Memory <float> memoryOfFloats = new ArrayMemoryManager <float>(512).Memory.Slice(128, 128);
Memory <byte> memoryOfBytes = memoryOfFloats.Cast <float, byte>();
Assert.AreEqual(memoryOfBytes.Length, 128 * sizeof(float));
Span <float> spanOfFloats = memoryOfFloats.Span;
Span <byte> spanOfBytes = memoryOfBytes.Span;
Assert.AreEqual(memoryOfBytes.Length, spanOfBytes.Length);
Assert.IsTrue(Unsafe.AreSame(
ref spanOfFloats[0],
ref Unsafe.As <byte, float>(ref spanOfBytes[0])));
}
public void Test_MemoryExtensions_FromMemoryManager_CastFromByte_WithSlice()
{
// Same as the ones with an array, but with an extra slice
Memory <byte> memoryOfBytes = new ArrayMemoryManager <byte>(512).Memory.Slice(128, 128);
Memory <float> memoryOfFloats = memoryOfBytes.Cast <byte, float>();
Assert.AreEqual(memoryOfFloats.Length, 128 / sizeof(float));
Span <byte> spanOfBytes = memoryOfBytes.Span;
Span <float> spanOfFloats = memoryOfFloats.Span;
Assert.AreEqual(memoryOfFloats.Length, spanOfFloats.Length);
Assert.IsTrue(Unsafe.AreSame(
ref spanOfBytes[0],
ref Unsafe.As <float, byte>(ref spanOfFloats[0])));
}
public void Test_MemoryExtensions_FromMemoryManager_CastFromByte()
{
// This test is just like the ones above, but this time we're casting a memory
// that wraps a custom memory manager and not an array. This is done to ensure
// the casting logic works correctly in all cases, as it'll use a different
// memory manager internally (a memory can wrap a string, an array or a manager).
Memory <byte> memoryOfBytes = new ArrayMemoryManager <byte>(128);
Memory <float> memoryOfFloats = memoryOfBytes.Cast <byte, float>();
Assert.AreEqual(memoryOfFloats.Length, 128 / sizeof(float));
Span <byte> spanOfBytes = memoryOfBytes.Span;
Span <float> spanOfFloats = memoryOfFloats.Span;
Assert.AreEqual(memoryOfFloats.Length, spanOfFloats.Length);
Assert.IsTrue(Unsafe.AreSame(
ref spanOfBytes[0],
ref Unsafe.As <float, byte>(ref spanOfFloats[0])));
}
public void Test_MemoryExtensions_FromMemoryManager_CastFromByteAndBack_WithSlice()
{
// Just like the one above, but with the slice
var data = new ArrayMemoryManager <byte>(512);
Memory <byte> memoryOfBytes = data.Memory.Slice(128, 128);
Memory <float> memoryOfFloats = memoryOfBytes.Cast <byte, float>();
Memory <byte> memoryBack = memoryOfFloats.Cast <float, byte>();
Assert.AreEqual(memoryOfBytes.Length, memoryBack.Length);
// Here we also need to validate that the offset was maintained
Assert.IsTrue(MemoryMarshal.TryGetMemoryManager <byte, ArrayMemoryManager <byte> >(memoryBack, out var manager, out var start, out var length));
Assert.AreSame(manager !, data);
Assert.AreEqual(start, 128);
Assert.AreEqual(length, 128);
Assert.IsTrue(memoryOfBytes.Equals(memoryBack));
Span <byte> span1 = memoryOfBytes.Span;
Span <byte> span2 = memoryBack.Span;
Assert.IsTrue(span1 == span2);
}
public void Test_MemoryExtensions_FromMemoryManager_CastFromByteAndBack()
{
// Equivalent to the one with an array, but with a memory manager
var data = new ArrayMemoryManager <byte>(128);
Memory <byte> memoryOfBytes = data;
Memory <float> memoryOfFloats = memoryOfBytes.Cast <byte, float>();
Memory <byte> memoryBack = memoryOfFloats.Cast <float, byte>();
Assert.AreEqual(memoryOfBytes.Length, memoryBack.Length);
// Here we expect to get back the original memory manager, due to the same optimization we
// checked for when using an array. We need to check they're the same, and the other parameters.
Assert.IsTrue(MemoryMarshal.TryGetMemoryManager <byte, ArrayMemoryManager <byte> >(memoryBack, out var manager, out var start, out var length));
Assert.AreSame(manager !, data);
Assert.AreEqual(start, 0);
Assert.AreEqual(length, 128);
Assert.IsTrue(memoryOfBytes.Equals(memoryBack));
Span <byte> span1 = memoryOfBytes.Span;
Span <byte> span2 = memoryBack.Span;
Assert.IsTrue(span1 == span2);
}
