public void WhenMemoryIsConsumed <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image0 = provider.GetImage())
{
var targetBuffer = new TPixel[image0.Width * image0.Height];
image0.GetPixelSpan().CopyTo(targetBuffer);
var managerOfExternalMemory = new TestMemoryManager <TPixel>(targetBuffer);
Memory <TPixel> externalMemory = managerOfExternalMemory.Memory;
using (var image1 = Image.WrapMemory(externalMemory, image0.Width, image0.Height))
{
Memory <TPixel> internalMemory = image1.GetPixelMemory();
Assert.Equal(targetBuffer.Length, internalMemory.Length);
Assert.True(Unsafe.AreSame(ref targetBuffer[0], ref internalMemory.Span[0]));
image0.ComparePixelBufferTo(internalMemory.Span);
}
// Make sure externalMemory works after destruction:
image0.ComparePixelBufferTo(externalMemory.Span);
}
}
public void Wrap()
{
int[] data0 = { 1, 2, 3, 4 };
int[] data1 = { 5, 6, 7, 8 };
int[] data2 = { 9, 10 };
using var mgr0 = new TestMemoryManager <int>(data0);
using var mgr1 = new TestMemoryManager <int>(data1);
using var group = MemoryGroup <int> .Wrap(mgr0.Memory, mgr1.Memory, data2);
Assert.Equal(3, group.Count);
Assert.Equal(4, group.BufferLength);
Assert.Equal(10, group.TotalLength);
Assert.True(group[0].Span.SequenceEqual(data0));
Assert.True(group[1].Span.SequenceEqual(data1));
Assert.True(group[2].Span.SequenceEqual(data2));
int cnt = 0;
int[][] allData = { data0, data1, data2 };
foreach (Memory <int> memory in group)
{
Assert.True(memory.Span.SequenceEqual(allData[cnt]));
cnt++;
}
}
public void WhenMemoryObserver_ShouldNotDisposeAnything()
{
var mmg = new TestMemoryManager <int>(new int[10]);
var bmg = new MemorySource <int>(mmg.Memory);
bmg.Dispose();
Assert.False(mmg.IsDisposed);
}
public void WhenOwnershipIsTransferred_ShouldDisposeMemoryOwner(bool isInternalMemorySource)
{
var mmg = new TestMemoryManager <int>(new int[10]);
var bmg = new MemorySource <int>(mmg, isInternalMemorySource);
bmg.Dispose();
Assert.True(mmg.IsDisposed);
}
public void InitializeAsObserver_MemoryOwner_IsNull()
{
var data = new Rgba32[21];
var mmg = new TestMemoryManager <Rgba32>(data);
var a = new MemorySource <Rgba32>(mmg.Memory);
Assert.Null(a.MemoryOwner);
Assert.Equal(mmg.Memory, a.Memory);
Assert.False(a.HasSwappableContents);
}
public void InitializeAsOwner(bool isInternalMemorySource)
{
var data = new Rgba32[21];
var mmg = new TestMemoryManager <Rgba32>(data);
var a = new MemorySource <Rgba32>(mmg, isInternalMemorySource);
Assert.Equal(mmg, a.MemoryOwner);
Assert.Equal(mmg.Memory, a.Memory);
Assert.Equal(isInternalMemorySource, a.HasSwappableContents);
}
public void Resize_ThrowsForWrappedMemoryImage <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : struct, IPixel <TPixel>
{
using (Image <TPixel> image0 = provider.GetImage())
{
var mmg = TestMemoryManager <TPixel> .CreateAsCopyOf(image0.GetPixelSpan());
using (var image1 = Image.WrapMemory(mmg.Memory, image0.Width, image0.Height))
{
Assert.ThrowsAny <Exception>(
() => { image1.Mutate(x => x.Resize(image0.Width / 2, image0.Height / 2, true)); });
}
}
}
public void Wrap()
{
int[] data0 = { 1, 2, 3, 4 };
int[] data1 = { 5, 6, 7, 8 };
int[] data2 = { 9, 10 };
using var mgr0 = new TestMemoryManager <int>(data0);
using var mgr1 = new TestMemoryManager <int>(data1);
using var group = MemoryGroup <int> .Wrap(mgr0.Memory, mgr1.Memory, data2);
Assert.Equal(3, group.Count);
Assert.Equal(4, group.BufferLength);
Assert.Equal(10, group.TotalLength);
Assert.True(group[0].Span.SequenceEqual(data0));
Assert.True(group[1].Span.SequenceEqual(data1));
Assert.True(group[2].Span.SequenceEqual(data2));
}
public void WhenDestIsNotMemoryOwner_DifferentSize_Throws(bool sourceIsOwner)
{
var data = new Rgba32[21];
var color = new Rgba32(1, 2, 3, 4);
using var destOwner = new TestMemoryManager <Rgba32>(data);
using var dest = new Buffer2D <Rgba32>(MemoryGroup <Rgba32> .Wrap(destOwner.Memory), 21, 1);
using Buffer2D <Rgba32> source = this.MemoryAllocator.Allocate2D <Rgba32>(22, 1);
source.FastMemoryGroup[0].Span[10] = color;
// Act:
Assert.ThrowsAny <InvalidOperationException>(() => Buffer2D <Rgba32> .SwapOrCopyContent(dest, source));
Assert.Equal(color, source.MemoryGroup[0].Span[10]);
Assert.NotEqual(color, dest.MemoryGroup[0].Span[10]);
}
public void WhenDestIsNotAllocated_SameSize_ShouldCopy(bool sourceIsAllocated)
{
var data = new Rgba32[21];
var color = new Rgba32(1, 2, 3, 4);
using var destOwner = new TestMemoryManager <Rgba32>(data);
using var dest = new Buffer2D <Rgba32>(MemoryGroup <Rgba32> .Wrap(destOwner.Memory), 21, 1);
using Buffer2D <Rgba32> source = this.MemoryAllocator.Allocate2D <Rgba32>(21, 1);
source.FastMemoryGroup[0].Span[10] = color;
// Act:
bool swap = Buffer2D <Rgba32> .SwapOrCopyContent(dest, source);
// Assert:
Assert.False(swap);
Assert.Equal(color, dest.MemoryGroup[0].Span[10]);
Assert.NotEqual(source.FastMemoryGroup[0], dest.FastMemoryGroup[0]);
}
public void ConsumedMemory_PixelDataIsCorrect <TPixel>(TestImageProvider <TPixel> provider)
where TPixel : unmanaged, IPixel <TPixel>
{
using Image <TPixel> image0 = provider.GetImage();
var targetBuffer = new TPixel[image0.Width * image0.Height];
image0.GetPixelSpan().CopyTo(targetBuffer);
var managerOfExternalMemory = new TestMemoryManager <TPixel>(targetBuffer);
Memory <TPixel> externalMemory = managerOfExternalMemory.Memory;
using (var image1 = Image.WrapMemory(externalMemory, image0.Width, image0.Height))
{
VerifyMemoryGroupDataMatchesTestPattern(provider, image1.GetPixelMemoryGroup(), image1.Size());
}
// Make sure externalMemory works after destruction:
VerifyMemoryGroupDataMatchesTestPattern(provider, image0.GetPixelMemoryGroup(), image0.Size());
}
public void WhenDestIsNotMemoryOwner_DifferentSize_Throws(bool sourceIsOwner)
{
var data = new Rgba32[21];
var color = new Rgba32(1, 2, 3, 4);
var destOwner = new TestMemoryManager <Rgba32>(data);
var dest = new MemorySource <Rgba32>(destOwner.Memory);
IMemoryOwner <Rgba32> sourceOwner = this.MemoryAllocator.Allocate <Rgba32>(22);
MemorySource <Rgba32> source = sourceIsOwner
? new MemorySource <Rgba32>(sourceOwner, true)
: new MemorySource <Rgba32>(sourceOwner.Memory);
sourceOwner.Memory.Span[10] = color;
// Act:
Assert.ThrowsAny <InvalidOperationException>(() => MemorySource <Rgba32> .SwapOrCopyContent(ref dest, ref source));
Assert.Equal(color, source.Memory.Span[10]);
Assert.NotEqual(color, dest.Memory.Span[10]);
}
public void WhenDestIsNotMemoryOwner_SameSize_ShouldCopy(bool sourceIsOwner, bool isInternalMemorySource)
{
var data = new Rgba32[21];
var color = new Rgba32(1, 2, 3, 4);
var destOwner = new TestMemoryManager <Rgba32>(data);
var dest = new MemorySource <Rgba32>(destOwner.Memory);
IMemoryOwner <Rgba32> sourceOwner = this.MemoryAllocator.Allocate <Rgba32>(21);
MemorySource <Rgba32> source = sourceIsOwner
? new MemorySource <Rgba32>(sourceOwner, isInternalMemorySource)
: new MemorySource <Rgba32>(sourceOwner.Memory);
sourceOwner.Memory.Span[10] = color;
// Act:
MemorySource <Rgba32> .SwapOrCopyContent(ref dest, ref source);
// Assert:
Assert.Equal(color, dest.Memory.Span[10]);
Assert.NotEqual(sourceOwner, dest.MemoryOwner);
Assert.NotEqual(destOwner, source.MemoryOwner);
}
