Index2DArrayBounds2DIndex2DInvalidSectorSizeTestCases() { var list3x5 = new List2D <byte>(6, 10); list3x5.AddRows(3); list3x5.AddColumns(5); yield return(new TestCaseData( list3x5, new Index2D(0, 0), new Array2D <byte>(4, 5), new Bounds2D(4, 5), new Index2D(0, 0))); yield return(new TestCaseData( list3x5, new Index2D(0, 0), new Array2D <byte>(3, 6), new Bounds2D(3, 6), new Index2D(0, 0))); yield return(new TestCaseData( list3x5, new Index2D(0, 0), new Array2D <byte>(2, 5), new Bounds2D(3, 5), new Index2D(0, 0))); yield return(new TestCaseData( list3x5, new Index2D(0, 0), new Array2D <byte>(3, 4), new Bounds2D(3, 5), new Index2D(0, 0))); yield return(new TestCaseData( list3x5, new Index2D(1, 0), new Array2D <byte>(3, 5), new Bounds2D(3, 5), new Index2D(0, 0))); yield return(new TestCaseData( list3x5, new Index2D(0, 1), new Array2D <byte>(3, 5), new Bounds2D(3, 5), new Index2D(0, 0))); yield return(new TestCaseData( list3x5, new Index2D(0, 0), new Array2D <byte>(3, 5), new Bounds2D(3, 5), new Index2D(1, 0))); yield return(new TestCaseData( list3x5, new Index2D(0, 0), new Array2D <byte>(3, 5), new Bounds2D(3, 5), new Index2D(0, 1))); }
public static ItemRequestResult <Index2D> Test <T>(List2D <T> list, T item) => list.LastIndexOf(item);
public static void Index2DIntThrowsExceptionIfCountExceedsList2DCount <T>( List2D <T> list, Index2D startIndex, int count) => Assert.Throws <ArgumentOutOfRangeException>( () => list.LastIndexOf(default, startIndex, count));
/// <summary> /// Helper method for mesh generation /// </summary> /// <param name="dimensions"></param> private void GenerateMeshPartHelper(Dimensions2D dimensions) { // Create a 2D list that represents if a coordinate has been processed or not // Also create a queue that contains all possible voxels to process var processed = new List2D <bool>(dimensions); var processQueue = new Queue <Dimensions2D>(); for (int u = 0; u < dimensions.X; u++) { for (int v = 0; v < dimensions.Y; v++) { processed[u, v] = false; processQueue.Enqueue(new Dimensions2D(u, v)); } } // Process the entire queue while (processQueue.Count > 0) { // Find the first voxel that has not been processed and has a visible face var currentCoord = processQueue.Dequeue(); int startU = currentCoord.X; int startV = currentCoord.Y; if (processed[startU, startV] || (_voxelPlaneFaces[startU, startV] & _faceType) != _faceType) { processed[startU, startV] = true; continue; } // Find width // Stop when one of the following is found // - an empty voxel // - voxel that doesn't have a visible face // - voxel that doesn't match the starting voxel // - voxel that has already been processed int width = 0; for (int u = startU; u < dimensions.X; u++) { if (GetVoxel(u, startV).Empty || (_voxelPlaneFaces[u, startV] & _faceType) != _faceType || !GetVoxel(startU, startV).Equals(GetVoxel(u, startV)) || processed[u, startV]) { break; } processed[u, startV] = true; width++; } // Find height // Stop when one of the following is found // - an empty voxel // - voxel that doesn't have a visible face // - voxel that doesn't match the starting voxel // - voxel that has already been processed int height = 1; for (int v = startV + 1; v < dimensions.Y + 1; v++) { bool fullHeight = true; // The entire width will be looped over even if the height is not full.. // This is done so the previous full height can be marked as processed for (int u = startU; u < startU + width; u++) { if (v != dimensions.Y && (GetVoxel(u, v).Empty || (_voxelPlaneFaces[u, v] & _faceType) != _faceType || !GetVoxel(startU, startV).Equals(GetVoxel(u, v)) || processed[u, v])) { fullHeight = false; } processed[u, v - 1] = true; } if (!fullHeight) { break; } if (v != dimensions.Y) { height++; } } AddFace(startU, startV, width, height); } }
public static void TestFindAll <T, Index2DCollection, TPredicate>( List2D <T> list, TPredicate match, Index2DCollection expected) where Index2DCollection : ICollection <Index2D>, new() where TPredicate : struct, IPredicate <T> => CollectionAssert.AreEqual( expected, list.FindAllIndices <Index2DCollection, TPredicate>(match));
public static bool Test <T>(List2D <T> list, Predicate <T> match) => list.TrueForAll(match);
public static void GetColumnThrowExceptionIfIndexExceedsColumns <T>( List2D <T> list, int index) => Assert.Throws <ArgumentOutOfRangeException>(() => list.GetColumn(index));
public static ItemRequestResult <Index2D> Test <T>( List2D <T> list, Index2D startIndex, int count, Predicate <T> match) => list.FindIndex(startIndex, count, match);
public static void Index2DBounds2DThrowsExceptionIfSectorIsOutOfBounds <T>( List2D <T> list, Index2D startIndex, Bounds2D sector) => Assert.Throws <ArgumentOutOfRangeException>( () => list.FindIndex(startIndex, sector, o => true));
public static ItemRequestResult <Index2D> Test <T>( List2D <T> list, Predicate <T> match) => list.FindIndex(match);
public static void Index2DIntThrowsExceptionIfStartIndexIsOutOfBounds <T>( List2D <T> list, Index2D startIndex) => Assert.Throws <ArgumentOutOfRangeException>( () => list.FindIndex(startIndex, 0, o => true));
public static void ThrowsExceptionIfCountIsInvalid <T>( List2D <T> list, int startIndex, int count) => Assert.Throws <ArgumentOutOfRangeException>( () => list.RemoveColumns(startIndex, count));
private static IEnumerable <TestCaseData> ColumnsTestCases() { var list1 = List2D <int> .FromSystem2DArray( new int[, ] { { 2, 3, 5 }, { 4, 9, 1 }, { 8, 2, 3 } }); list1.IncreaseCapacity(list1.Boundaries); var list2 = List2D <int> .FromSystem2DArray( new int[, ] { { 2, 3, 5 }, { 4, 9, 1 }, { 8, 2, 3 } }); var list3 = List2D <string> .FromSystem2DArray( new string[, ] { { "2", "0", "3", "1" }, { "4", "2", "8", "7" } }); list3.IncreaseCapacity(list3.Boundaries); var list4 = List2D <int> .FromSystem2DArray( new int[, ] { { 1, 2 }, { 3, 4 } }); list4.IncreaseCapacity(list4.Boundaries); var list5 = List2D <int> .FromSystem2DArray( new int[, ] { { 1, 2 }, { 3, 4 } }); list5.IncreaseCapacity(list5.Boundaries); yield return(new TestCaseData( list1, 1, 1, List2D <int> .FromSystem2DArray( new int[, ] { { 2, 5 }, { 4, 1 }, { 8, 3 } }))); yield return(new TestCaseData( list2, 1, 1, List2D <int> .FromSystem2DArray( new int[, ] { { 2, 5 }, { 4, 1 }, { 8, 3 } }))); yield return(new TestCaseData( list3, 0, 2, List2D <string> .FromSystem2DArray( new string[, ] { { "3", "1" }, { "8", "7" } }))); yield return(new TestCaseData( list4, 0, 0, List2D <int> .FromSystem2DArray( new int[, ] { { 1, 2 }, { 3, 4 } }))); yield return(new TestCaseData(list5, 0, 2, new List2D <int>())); }
public static void ThrowsExceptionIfIndexIsOutOfBounds <T>( List2D <T> list, Index2D index) => Assert.Throws <IndexOutOfRangeException>( () => { ref readonly T value = ref list[index]; });
public static void ThrowsExceptionIfSizeIsInvalid <T>( List2D <T> list, int rows, int columns) => Assert.Throws <ArgumentOutOfRangeException>( () => list.IncreaseCapacity(rows, columns));
public static ItemRequestResult <Index2D> Test <T>( List2D <T> list, Index2D startIndex, Bounds2D sector, Predicate <T> match) => list.FindIndex(startIndex, sector, match);
public static void IsEmptyReturnsTrueWhenListIsCleared <T>(List2D <T> list) { list.Clear(); Assert.That(list.IsEmpty); }
public static void Index2DIntThrowsExceptionIfStartIndexIsOutOfBounds <T>(List2D <T> list, Index2D startIndex) => Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex( startIndex, 0, new AlwaysTruePredicate <T>()));
public static bool Test <T, TPredicate>(List2D <T> list, TPredicate match) where TPredicate : struct, IPredicate <T> => list.TrueForAll(match);
public static void Index2DIntThrowsExceptionIfCountExceedsList2DCount <T>(List2D <T> list, Index2D startIndex, int count) => Assert.Throws <ArgumentOutOfRangeException>(() => list.FindIndex( startIndex, count, new AlwaysTruePredicate <T>()));
public static void GetColumnTest <T>( List2D <T> list, int index, RefColumn <T, List2D <T> > expected) => CollectionAssert.AreEqual(expected, list.GetColumn(index));
public static ItemRequestResult <Index2D> Test <T, TPredicate>( List2D <T> list, Index2D startIndex, int count, TPredicate match) where TPredicate : struct, IPredicate <T> => list.FindIndex(startIndex, count, match);
public static void TestFindAll <T, TCollection>( List2D <T> list, Predicate <T> match, TCollection expected) where TCollection : ICollection <T>, new() => CollectionAssert.AreEqual(expected, list.FindAll <TCollection>(match));
public static void CountEqualsCollectionLength2 <T>( List2D <T> collection, RefRow <T, List2D <T> > row) => RefRowTests.CountEqualsCollectionLength2(collection, row);
public static ItemRequestResult <Index2D> Test <T>( List2D <T> list, T item) where T : IComparable <T> => list.LastIndexOfComparable(item);
public static ItemRequestResult <T> Test <T>(List2D <T> list, Predicate <T> match) => list.FindLast(match);
public static void Index2DIntThrowsExceptionIfStartIndexIsOutOfBounds <T>( List2D <T> list, Index2D startIndex) => Assert.Throws <ArgumentOutOfRangeException>( () => list.LastIndexOf(default, startIndex, 0));
public static ItemRequestResult <T> Test <T, TPredicate>( List2D <T> list, TPredicate match) where TPredicate : struct, IPredicate <T> => list.FindLast(match);
public static ItemRequestResult <Index2D> Test <T>( List2D <T> list, T item, Index2D startIndex, int count) => list.LastIndexOf(item, startIndex, count);
public static void Test <T>( List2D <T> src, Array2D <T> dest, Array2D <T> expected) { src.CopyTo(dest); CollectionAssert.AreEqual(expected, dest); }