public void ColorToBytes()
{
Color[] colors = { new Color(0, 1, 2, 3), new Color(4, 5, 6, 7), new Color(8, 9, 10, 11), };
using (PinnedBuffer <Color> colorBuf = new PinnedBuffer <Color>(colors))
using (PinnedBuffer <byte> byteBuf = new PinnedBuffer <byte>(colors.Length * 4))
{
BufferPointer.Copy <Color>(colorBuf, byteBuf, colorBuf.Count);
byte[] a = byteBuf.Array;
for (int i = 0; i < byteBuf.Count; i++)
{
Assert.Equal((byte)i, a[i]);
}
}
}
public void GenericToOwnType(int count)
{
Foo[] source = Foo.CreateArray(count + 2);
Foo[] dest = new Foo[count + 5];
fixed(Foo *pSource = source)
fixed(Foo * pDest = dest)
{
BufferPointer <Foo> apSource = new BufferPointer <Foo>(source, pSource);
BufferPointer <Foo> apDest = new BufferPointer <Foo>(dest, pDest);
BufferPointer.Copy(apSource, apDest, count);
}
Assert.Equal(source[0], dest[0]);
Assert.Equal(source[count - 1], dest[count - 1]);
Assert.NotEqual(source[count], dest[count]);
}
public void BytesToGeneric(int count)
{
int destCount = count * sizeof(Foo);
byte[] source = new byte[destCount + sizeof(Foo) + 1];
Foo[] dest = Foo.CreateArray(count + 2);
fixed(byte *pSource = source)
fixed(Foo * pDest = dest)
{
BufferPointer <byte> apSource = new BufferPointer <byte>(source, pSource);
BufferPointer <Foo> apDest = new BufferPointer <Foo>(dest, pDest);
BufferPointer.Copy(apSource, apDest, count);
}
Assert.True(ElementsAreEqual(dest, source, 0));
Assert.True(ElementsAreEqual(dest, source, count - 1));
Assert.False(ElementsAreEqual(dest, source, count));
}
public void IntToBytes(int count)
{
int destCount = count * sizeof(int);
int[] source = CreateTestInts(count + 2);
byte[] dest = new byte[destCount + sizeof(int) + 1];
fixed(int *pSource = source)
fixed(byte *pDest = dest)
{
BufferPointer <int> apSource = new BufferPointer <int>(source, pSource);
BufferPointer <byte> apDest = new BufferPointer <byte>(dest, pDest);
BufferPointer.Copy(apSource, apDest, count);
}
AssertNotDefault(source, 1);
Assert.True(ElementsAreEqual(source, dest, 0));
Assert.True(ElementsAreEqual(source, dest, count - 1));
Assert.False(ElementsAreEqual(source, dest, count));
}
public void IntToInt(int count)
{
int[] source = CreateTestInts(count + 2);
int[] dest = new int[count + 5];
fixed(int *pSource = source)
fixed(int *pDest = dest)
{
BufferPointer <int> apSource = new BufferPointer <int>(source, pSource, 1);
BufferPointer <int> apDest = new BufferPointer <int>(dest, pDest, 1);
BufferPointer.Copy(apSource, apDest, count - 1);
}
AssertNotDefault(source, 1);
AssertNotDefault(dest, 1);
Assert.NotEqual(source[0], dest[0]);
Assert.Equal(source[1], dest[1]);
Assert.Equal(source[2], dest[2]);
Assert.Equal(source[count - 1], dest[count - 1]);
Assert.NotEqual(source[count], dest[count]);
}
public void GenericToOwnType_Aligned(int count)
{
AlignedFoo[] source = AlignedFoo.CreateArray(count + 2);
AlignedFoo[] dest = new AlignedFoo[count + 5];
fixed(AlignedFoo *pSource = source)
fixed(AlignedFoo * pDest = dest)
{
BufferPointer <AlignedFoo> apSource = new BufferPointer <AlignedFoo>(source, pSource, 1);
BufferPointer <AlignedFoo> apDest = new BufferPointer <AlignedFoo>(dest, pDest, 1);
BufferPointer.Copy(apSource, apDest, count - 1);
}
AssertNotDefault(source, 1);
AssertNotDefault(dest, 1);
Assert.NotEqual(source[0], dest[0]);
Assert.Equal(source[1], dest[1]);
Assert.Equal(source[2], dest[2]);
Assert.Equal(source[count - 1], dest[count - 1]);
Assert.NotEqual(source[count], dest[count]);
}
public void BytesToGeneric(int count)
{
int srcCount = count * sizeof(Foo);
byte[] source = CreateTestBytes(srcCount);
Foo[] dest = new Foo[count + 2];
fixed(byte *pSource = source)
fixed(Foo * pDest = dest)
{
BufferPointer <byte> apSource = new BufferPointer <byte>(source, pSource);
BufferPointer <Foo> apDest = new BufferPointer <Foo>(dest, pDest);
BufferPointer.Copy(apSource, apDest, count);
}
AssertNotDefault(source, sizeof(Foo) + 1);
AssertNotDefault(dest, 1);
Assert.True(ElementsAreEqual(dest, source, 0));
Assert.True(ElementsAreEqual(dest, source, 1));
Assert.True(ElementsAreEqual(dest, source, count - 1));
Assert.False(ElementsAreEqual(dest, source, count));
}
public void GenericToBytes_Aligned(int count)
{
int destCount = count * sizeof(Foo);
AlignedFoo[] source = AlignedFoo.CreateArray(count + 2);
byte[] dest = new byte[destCount + sizeof(AlignedFoo) * 2];
fixed(AlignedFoo *pSource = source)
fixed(byte *pDest = dest)
{
BufferPointer <AlignedFoo> apSource = new BufferPointer <AlignedFoo>(source, pSource, 1);
BufferPointer <byte> apDest = new BufferPointer <byte>(dest, pDest, sizeof(AlignedFoo));
BufferPointer.Copy(apSource, apDest, count - 1);
}
AssertNotDefault(source, 1);
Assert.False(ElementsAreEqual(source, dest, 0));
Assert.True(ElementsAreEqual(source, dest, 1));
Assert.True(ElementsAreEqual(source, dest, 2));
Assert.True(ElementsAreEqual(source, dest, count - 1));
Assert.False(ElementsAreEqual(source, dest, count));
}
