public void Test_Memory2DT_Slice_2()
{
int[,] array =
{
{ 1, 2, 3 },
{ 4, 5, 6 }
};
Memory2D <int> memory2d = new Memory2D <int>(array);
// Mostly the same test as above, just with different parameters
Memory2D <int> slice1 = memory2d.Slice(0, 0, 2, 2);
Assert.AreEqual(slice1.Length, 4);
Assert.AreEqual(slice1.Height, 2);
Assert.AreEqual(slice1.Width, 2);
Assert.AreEqual(slice1.Span[0, 0], 1);
Assert.AreEqual(slice1.Span[1, 1], 5);
Memory2D <int> slice2 = slice1.Slice(1, 0, 1, 2);
Assert.AreEqual(slice2.Length, 2);
Assert.AreEqual(slice2.Height, 1);
Assert.AreEqual(slice2.Width, 2);
Assert.AreEqual(slice2.Span[0, 0], 4);
Assert.AreEqual(slice2.Span[0, 1], 5);
Memory2D <int> slice3 = slice2.Slice(0, 1, 1, 1);
Assert.AreEqual(slice3.Length, 1);
Assert.AreEqual(slice3.Height, 1);
Assert.AreEqual(slice3.Width, 1);
Assert.AreEqual(slice3.Span[0, 0], 5);
}
public void Test_Memory2DT_Slice_1()
{
int[,] array =
{
{ 1, 2, 3 },
{ 4, 5, 6 }
};
Memory2D <int> memory2d = new Memory2D <int>(array);
// Test a slice from a Memory2D<T> with valid parameters
Memory2D <int> slice1 = memory2d.Slice(1, 1, 1, 2);
Assert.AreEqual(slice1.Length, 2);
Assert.AreEqual(slice1.Height, 1);
Assert.AreEqual(slice1.Width, 2);
Assert.AreEqual(slice1.Span[0, 0], 5);
Assert.AreEqual(slice1.Span[0, 1], 6);
// Same above, but we test slicing a pre-sliced instance as well. This
// is done to verify that the internal offsets are properly tracked
// across multiple slicing operations, instead of just in the first.
Memory2D <int> slice2 = memory2d.Slice(0, 1, 2, 2);
Assert.AreEqual(slice2.Length, 4);
Assert.AreEqual(slice2.Height, 2);
Assert.AreEqual(slice2.Width, 2);
Assert.AreEqual(slice2.Span[0, 0], 2);
Assert.AreEqual(slice2.Span[1, 0], 5);
Assert.AreEqual(slice2.Span[1, 1], 6);
// A few invalid slicing operations, with out of range parameters
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(-1, 1, 1, 1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(1, -1, 1, 1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(1, 1, 1, -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(1, 1, -1, 1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(10, 1, 1, 1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(1, 12, 1, 12));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(1, 1, 55, 1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(0, 0, 2, 4));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(0, 0, 3, 3));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(0, 1, 2, 3));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => new Memory2D <int>(array).Slice(1, 0, 2, 3));
}
public void Test_ReadOnlyMemory2DT_Equals()
{
int[,] array =
{
{ 1, 2, 3 },
{ 4, 5, 6 }
};
ReadOnlyMemory2D <int> readOnlyMemory2D = new ReadOnlyMemory2D <int>(array);
Assert.IsFalse(readOnlyMemory2D.Equals(null));
Assert.IsFalse(readOnlyMemory2D.Equals(new ReadOnlyMemory2D <int>(array, 0, 1, 2, 2)));
Assert.IsTrue(readOnlyMemory2D.Equals(new ReadOnlyMemory2D <int>(array)));
Assert.IsTrue(readOnlyMemory2D.Equals(readOnlyMemory2D));
Memory2D <int> memory2d = array;
Assert.IsTrue(readOnlyMemory2D.Equals((object)memory2d));
Assert.IsFalse(readOnlyMemory2D.Equals((object)memory2d.Slice(0, 1, 2, 2)));
}
