using System;
using UnitTestSharp;
using Azimuth;
using Annulus;

namespace Glass.UnitTests
{
    public class RectDividerTests : TestFixture
    {
        [IgnoreTest]
        private static RectDivider TwoByThree()
        {
            var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(16, 7));
            return rect.NewGrid(2, 3, margin: new Vector(2, 1));
        }

        [IgnoreTest]
        private static Rect Cell(Scalar x, Scalar y, Scalar width, Scalar height)
        {
            return Rect.FromPositionAndSize(new Vector(x, y), new Vector(width, height));
        }

        [IgnoreTest]
        private static string ParameterNameThrownBy(System.Action action)
        {
            try
            {
                action();
            }
            catch (ArgumentOutOfRangeException exception)
            {
                return exception.ParamName;
            }

            return null;
        }

        public class CtorTests : TestFixture
        {
            private static readonly Rect Source =Rect.FromPositionAndSize(Vector.Zero, new Vector(6, 4));

            public void ExplicitCellSize_NegativeRows_ThrowsNamingRows()
            {
                CheckEqual("rows", ParameterNameThrownBy(
                    () => new RectDivider(Vector.Zero, new Vector(2, 2), rows: -1, columns: 3, margin: Vector.Zero)));
            }

            public void ExplicitCellSize_NegativeColumns_ThrowsNamingColumns()
            {
                CheckEqual("columns", ParameterNameThrownBy(
                    () => new RectDivider(Vector.Zero, new Vector(2, 2), rows: 2, columns: -1, margin: Vector.Zero)));
            }

            public void RowsAndColumns_NegativeRows_ThrowsNamingRows()
            {
                CheckEqual("rows", ParameterNameThrownBy(
                    () => new RectDivider(Source, rows: -1, columns: 3, margin: Vector.Zero)));
            }

            public void RowsAndColumns_NegativeColumns_ThrowsNamingColumns()
            {
                CheckEqual("columns", ParameterNameThrownBy(
                    () => new RectDivider(Source, rows: 2, columns: -1, margin: Vector.Zero)));
            }

            public void ExplicitCellSize_NegativeWidth_ThrowsNamingCellSize()
            {
                CheckEqual("cellSize", ParameterNameThrownBy(
                    () => new RectDivider(Vector.Zero, new Vector(-1, 2), rows: 2, columns: 3, margin: Vector.Zero)));
            }

            public void ExplicitCellSize_NegativeHeight_ThrowsNamingCellSize()
            {
                CheckEqual("cellSize", ParameterNameThrownBy(
                    () => new RectDivider(Vector.Zero, new Vector(2, -1), rows: 2, columns: 3, margin: Vector.Zero)));
            }

            public void RowsAndColumns_MarginTooWideForTheSource_ThrowsNamingMargin()
            {
                CheckEqual("margin", ParameterNameThrownBy(
                    () => new RectDivider(Source, rows: 2, columns: 3, margin: new Vector(10, 0))));
            }

            public void RowsAndColumns_MarginTooTallForTheSource_ThrowsNamingMargin()
            {
                CheckEqual("margin", ParameterNameThrownBy(
                    () => new RectDivider(Source, rows: 2, columns: 3, margin: new Vector(0, 10))));
            }

            public void RowsAndColumns_MarginExactlyUsingUpTheSource_LeavesZeroSizedCells()
            {
                var divider = new RectDivider(Source, rows: 2, columns: 3, margin: new Vector(3, 0));

                CheckEqual(0, divider[0, 0].Width);
            }

            public void RowsAndColumns_NoRows_IgnoresAMarginThatWouldNotFit()
            {
                var divider = new RectDivider(Source, rows: 0, columns: 3, margin: new Vector(100, 100));

                CheckEqual(0, divider.Count);
            }

            public void Horizontal_MarginTooLargeForTheSource_ThrowsNamingMargin()
            {
                CheckEqual("margin", ParameterNameThrownBy(
                    () => new RectDivider(Source, Orientation.Horizontal, count: 3, margin: 10)));
            }

            public void Vertical_MarginTooLargeForTheSource_ThrowsNamingMargin()
            {
                CheckEqual("margin", ParameterNameThrownBy(
                    () => new RectDivider(Source, Orientation.Vertical, count: 3, margin: 10)));
            }

            public void Horizontal_NegativeCount_ThrowsNamingCount()
            {
                CheckEqual("count", ParameterNameThrownBy(
                    () => new RectDivider(Source, Orientation.Horizontal, count: -1, margin: 0)));
            }

            public void Vertical_NegativeCount_ThrowsNamingCount()
            {
                CheckEqual("count", ParameterNameThrownBy(
                    () => new RectDivider(Source, Orientation.Vertical, count: -1, margin: 0)));
            }

            public void ExplicitCellSize_PlacesCellsFromTheOrigin()
            {
                var divider = new RectDivider(
                    new Vector(10, 20), new Vector(4, 3), rows: 2, columns: 3, margin: new Vector(2, 1));

                CheckEqual(Cell(10, 20, 4, 3), divider[0, 0]);
                CheckEqual(Cell(22, 24, 4, 3), divider[1, 2]);
            }

            public void ExplicitCellSize_KeepsTheGivenSizeExactly()
            {
                var divider = new RectDivider(
                    Vector.Zero, new Vector(0.1, 0.1), rows: 3, columns: 3, margin: new Vector(0.3, 0.3));

                CheckEqual(new Vector(0.1, 0.1), divider[2, 2].Size);
            }

            public void ExplicitCellSize_ReportsTheGivenCounts()
            {
                var divider = new RectDivider(Vector.Zero, new Vector(4, 3), rows: 2, columns: 3, margin: Vector.Zero);

                CheckEqual(2, divider.Rows);
                CheckEqual(3, divider.Columns);
                CheckEqual(6, divider.Count);
            }

            public void ExplicitCellSize_NoRows_HasNoCells()
            {
                var divider = new RectDivider(Vector.Zero, new Vector(4, 3), rows: 0, columns: 3, margin: Vector.Zero);

                CheckEqual(0, divider.Rows);
                CheckEqual(3, divider.Columns);
                CheckEqual(0, divider.Count);
            }

            public void RowsAndColumns_DividesTheSourceIntoEqualCells()
            {
                var source = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(16, 7));

                var divider = new RectDivider(source, rows: 2, columns: 3, margin: new Vector(2, 1));

                CheckEqual(Cell(10, 20, 4, 3), divider[0, 0]);
                CheckEqual(Cell(22, 24, 4, 3), divider[1, 2]);
            }

            public void RowsAndColumns_NoMargin_TilesTheSourceExactly()
            {
                var source = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(6, 4));

                var divider = new RectDivider(source, rows: 2, columns: 3, margin: Vector.Zero);

                CheckEqual(Cell(0, 0, 2, 2), divider[0, 0]);
                CheckEqual(Cell(4, 2, 2, 2), divider[1, 2]);
            }

            public void RowsAndColumns_ReportsTheGivenCounts()
            {
                var source = Rect.FromPositionAndSize(Vector.Zero, new Vector(6, 4));

                var divider = new RectDivider(source, rows: 2, columns: 3, margin: Vector.Zero);

                CheckEqual(2, divider.Rows);
                CheckEqual(3, divider.Columns);
                CheckEqual(6, divider.Count);
            }

            public void RowsAndColumns_NoRows_HasNoCells()
            {
                var source = Rect.FromPositionAndSize(Vector.Zero, new Vector(6, 4));

                var divider = new RectDivider(source, rows: 0, columns: 3, margin: Vector.Zero);

                CheckEqual(0, divider.Count);
            }

            public void RowsAndColumns_NoColumns_HasNoCells()
            {
                var source = Rect.FromPositionAndSize(Vector.Zero, new Vector(6, 4));

                var divider = new RectDivider(source, rows: 2, columns: 0, margin: Vector.Zero);

                CheckEqual(0, divider.Count);
            }

            public void Horizontal_MakesASingleRowOfTheCountInColumns()
            {
                var source = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                var divider = new RectDivider(source, Orientation.Horizontal, count: 3, margin: 0);

                CheckEqual(1, divider.Rows);
                CheckEqual(3, divider.Columns);
                CheckEqual(Cell(3, 4, 3, 6), divider[0, 0]);
                CheckEqual(Cell(9, 4, 3, 6), divider[0, 2]);
            }

            public void Horizontal_MarginSeparatesTheColumns()
            {
                var source = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(11, 6));

                var divider = new RectDivider(source, Orientation.Horizontal, count: 3, margin: 1);

                CheckEqual(Cell(4, 0, 3, 6), divider[0, 1]);
                CheckEqual(Cell(8, 0, 3, 6), divider[0, 2]);
            }

            public void Horizontal_NoColumns_HasNoCells()
            {
                var source = Rect.FromPositionAndSize(Vector.Zero, new Vector(9, 6));

                var divider = new RectDivider(source, Orientation.Horizontal, count: 0, margin: 0);

                CheckEqual(1, divider.Rows);
                CheckEqual(0, divider.Columns);
                CheckEqual(0, divider.Count);
            }

            public void Vertical_MakesASingleColumnOfTheCountInRows()
            {
                var source = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                var divider = new RectDivider(source, Orientation.Vertical, count: 3, margin: 0);

                CheckEqual(3, divider.Rows);
                CheckEqual(1, divider.Columns);
                CheckEqual(Cell(3, 4, 9, 2), divider[0, 0]);
                CheckEqual(Cell(3, 8, 9, 2), divider[2, 0]);
            }

            public void Vertical_MarginSeparatesTheRows()
            {
                var source = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(5, 11));

                var divider = new RectDivider(source, Orientation.Vertical, count: 3, margin: 1);

                CheckEqual(Cell(0, 4, 5, 3), divider[1, 0]);
                CheckEqual(Cell(0, 8, 5, 3), divider[2, 0]);
            }

            public void Vertical_NoRows_HasNoCells()
            {
                var source = Rect.FromPositionAndSize(Vector.Zero, new Vector(9, 6));

                var divider = new RectDivider(source, Orientation.Vertical, count: 0, margin: 0);

                CheckEqual(0, divider.Rows);
                CheckEqual(1, divider.Columns);
                CheckEqual(0, divider.Count);
            }
        }

        public class GetEnumeratorTests : TestFixture
        {
            public void ReenumeratingReturnsTheSamePiecesEachTime()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider divider = rect.NewCols(3);

                var firstPass = new Rect[3];
                int i = 0;
                foreach (Rect col in divider)
                {
                    firstPass[i++] = col;
                }

                var secondPass = new Rect[3];
                i = 0;
                foreach (Rect col in divider)
                {
                    secondPass[i++] = col;
                }

                CheckEqual(firstPass[0], secondPass[0]);
                CheckEqual(firstPass[1], secondPass[1]);
                CheckEqual(firstPass[2], secondPass[2]);
            }

            public void ManualAdvance_AdvancesThroughEachPieceInOrder()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(9, 3));
                RectDivider.Enumerator enumerator = rect.NewCols(3).GetEnumerator();

                CheckTrue(enumerator.MoveNext());
                CheckEqual(Rect.FromPositionAndSize(new Vector(0, 0), new Vector(3, 3)), enumerator.Current);

                CheckTrue(enumerator.MoveNext());
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 0), new Vector(3, 3)), enumerator.Current);

                CheckTrue(enumerator.MoveNext());
                CheckEqual(Rect.FromPositionAndSize(new Vector(6, 0), new Vector(3, 3)), enumerator.Current);
            }

            public void ManualAdvance_MoveNextKeepsReturningFalseOnceExhausted()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(9, 3));
                RectDivider.Enumerator enumerator = rect.NewCols(3).GetEnumerator();

                enumerator.MoveNext();
                enumerator.MoveNext();
                enumerator.MoveNext();

                CheckFalse(enumerator.MoveNext());
                CheckFalse(enumerator.MoveNext());
            }

            public void SingleItemSplit_YieldsTheWholeRectUnaffectedByMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                var pieces = new Rect[1];
                int i = 0;
                foreach (Rect col in rect.NewCols(1, margin: 10))
                {
                    pieces[i++] = col;
                }

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6)), pieces[0]);
            }

            public void Grid_VisitsCellsARowAtATimeLeftToRight()
            {
                RectDivider grid = TwoByThree();
                var visited = new Rect[6];
                int i = 0;

                foreach (Rect cell in grid)
                {
                    visited[i++] = cell;
                }

                CheckEqual(grid[0, 0], visited[0]);
                CheckEqual(grid[0, 1], visited[1]);
                CheckEqual(grid[0, 2], visited[2]);
                CheckEqual(grid[1, 0], visited[3]);
                CheckEqual(grid[1, 1], visited[4]);
                CheckEqual(grid[1, 2], visited[5]);
            }

            public void NoRows_VisitsNothing()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(16, 7));
                int count = 0;

                foreach (Rect _ in rect.NewGrid(0, 3))
                {
                    count++;
                }

                CheckEqual(0, count);
            }
        }

        public class Count : TestFixture
        {
            public void EqualsTheRequestedPieceCount()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider divider = rect.NewCols(3);

                CheckEqual(3, divider.Count);
            }

            public void Grid_IsRowsTimesColumns()
            {
                CheckEqual(6, TwoByThree().Count);
            }

            public void Grid_NoRows_IsZero()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(16, 7));

                CheckEqual(0, rect.NewGrid(0, 3).Count);
            }
        }

        public class Bounds : TestFixture
        {
            public void Grid_CoversTheCellsAndTheMarginsBetweenThem()
            {
                CheckEqual(Cell(10, 20, 16, 7), TwoByThree().Bounds);
            }

            public void ExplicitCellSize_RunsFromTheOrigin()
            {
                var divider = new RectDivider(
                    new Vector(5, 6), new Vector(4, 3), rows: 2, columns: 3, margin: new Vector(2, 1));

                CheckEqual(Cell(5, 6, 16, 7), divider.Bounds);
            }

            public void DividedIntoColumns_IsTheRectItWasDividedFrom()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                CheckEqual(Cell(3, 4, 9, 6), rect.NewCols(3).Bounds);
            }

            public void DividedIntoRows_IsTheRectItWasDividedFrom()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                CheckEqual(Cell(3, 4, 9, 6), rect.NewRows(3).Bounds);
            }

            public void SingleCell_IsThatCellWhateverTheMargin()
            {
                var divider = new RectDivider(
                    new Vector(5, 6), new Vector(4, 3), rows: 1, columns: 1, margin: new Vector(10, 10));

                CheckEqual(Cell(5, 6, 4, 3), divider.Bounds);
            }

            public void NoCells_IsNothingAtTheOrigin()
            {
                var divider = new RectDivider(
                    new Vector(5, 6), new Vector(4, 3), rows: 0, columns: 3, margin: new Vector(2, 1));

                CheckEqual(Cell(5, 6, 0, 0), divider.Bounds);
            }
        }

        public class Rows : TestFixture
        {
            public void Grid_IsTheRequestedRowCount()
            {
                CheckEqual(2, TwoByThree().Rows);
            }

            public void DividedIntoColumns_IsASingleRow()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                CheckEqual(1, rect.NewCols(3).Rows);
            }

            public void DividedIntoRows_IsTheRequestedCount()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                CheckEqual(3, rect.NewRows(3).Rows);
            }
        }

        public class Columns : TestFixture
        {
            public void Grid_IsTheRequestedColumnCount()
            {
                CheckEqual(3, TwoByThree().Columns);
            }

            public void DividedIntoRows_IsASingleColumn()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                CheckEqual(1, rect.NewRows(3).Columns);
            }

            public void DividedIntoColumns_IsTheRequestedCount()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                CheckEqual(3, rect.NewCols(3).Columns);
            }
        }

        public class IndexOperator : TestFixture
        {
            public void ReturnsThePieceAtThatIndex()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider divider = rect.NewCols(3);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(3, 6)), divider[0]);
                CheckEqual(Rect.FromPositionAndSize(new Vector(6, 4), new Vector(3, 6)), divider[1]);
                CheckEqual(Rect.FromPositionAndSize(new Vector(9, 4), new Vector(3, 6)), divider[2]);
            }

            public void MatchesWhatForeachYields()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(9, 3));
                RectDivider divider = rect.NewCols(3);

                var fromForeach = new Rect[3];
                int i = 0;
                foreach (Rect col in divider)
                {
                    fromForeach[i++] = col;
                }

                for (int index = 0; index < divider.Count; index++)
                {
                    CheckEqual(fromForeach[index], divider[index]);
                }
            }

            public void NegativeIndexThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider divider = rect.NewCols(3);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = divider[-1];
            }

            public void IndexEqualToCountThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider divider = rect.NewCols(3);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = divider[3];
            }

            public void Grid_NumbersCellsARowAtATime()
            {
                RectDivider grid = TwoByThree();

                CheckEqual(grid[0, 2], grid[2]);
                CheckEqual(grid[1, 0], grid[3]);
                CheckEqual(grid[1, 2], grid[5]);
            }
        }

        public class RowColumnIndexOperator : TestFixture
        {
            public void PlacesEachCellByRowThenColumn()
            {
                RectDivider grid = TwoByThree();

                CheckEqual(Cell(10, 20, 4, 3), grid[0, 0]);
                CheckEqual(Cell(16, 20, 4, 3), grid[0, 1]);
                CheckEqual(Cell(22, 20, 4, 3), grid[0, 2]);
                CheckEqual(Cell(10, 24, 4, 3), grid[1, 0]);
                CheckEqual(Cell(16, 24, 4, 3), grid[1, 1]);
                CheckEqual(Cell(22, 24, 4, 3), grid[1, 2]);
            }

            public void NoMargin_TilesTheRectExactly()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(6, 4));

                RectDivider grid = rect.NewGrid(2, 3);

                CheckEqual(Cell(0, 0, 2, 2), grid[0, 0]);
                CheckEqual(Cell(4, 2, 2, 2), grid[1, 2]);
            }

            public void OneByOne_IsTheWholeRectWhateverTheMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));

                RectDivider grid = rect.NewGrid(1, 1, margin: new Vector(10, 10));

                CheckEqual(Cell(3, 4, 9, 6), grid[0, 0]);
            }

            public void AlongOneAxis_MatchesTheSingleIndex()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider columns = rect.NewCols(3, margin: 0);
                rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                RectDivider rows = rect.NewRows(3, margin: 0);

                CheckEqual(columns[1], columns[0, 1]);
                CheckEqual(rows[1], rows[1, 0]);
            }

            public void RowPastTheEnd_Throws()
            {
                RectDivider grid = TwoByThree();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = grid[2, 0];
            }

            public void NegativeRow_Throws()
            {
                RectDivider grid = TwoByThree();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = grid[-1, 0];
            }

            public void ColumnPastTheEnd_Throws()
            {
                RectDivider grid = TwoByThree();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = grid[0, 3];
            }

            public void NegativeColumn_Throws()
            {
                RectDivider grid = TwoByThree();

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = grid[0, -1];
            }

            public void NoRows_HasNoCells()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(16, 7));
                RectDivider grid = rect.NewGrid(0, 3);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                Rect _ = grid[0, 0];
            }
        }
    }

    public class RectDividerOfTTests : TestFixture
    {
        public class GetEnumeratorTests : TestFixture
        {
            public void ReenumeratingReturnsTheSamePairsEachTime()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                var items = new[] { "a", "b", "c" };
                RectDivider<string> divider = rect.NewCols(items);

                var firstPass = new (Rect Rect, string Item)[3];
                int i = 0;
                foreach ((Rect col, string item) in divider)
                {
                    firstPass[i++] = (col, item);
                }

                var secondPass = new (Rect Rect, string Item)[3];
                i = 0;
                foreach ((Rect col, string item) in divider)
                {
                    secondPass[i++] = (col, item);
                }

                CheckEqual(firstPass[0], secondPass[0]);
                CheckEqual(firstPass[1], secondPass[1]);
                CheckEqual(firstPass[2], secondPass[2]);
            }

            public void ManualAdvance_CurrentPairsTheRectWithItsItem()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(9, 3));
                var items = new[] { "a", "b", "c" };
                RectDivider<string>.Enumerator enumerator = rect.NewCols(items).GetEnumerator();

                CheckTrue(enumerator.MoveNext());
                CheckEqual(Rect.FromPositionAndSize(new Vector(0, 0), new Vector(3, 3)), enumerator.Current.Rect);
                CheckEqual("a", enumerator.Current.Item);

                CheckTrue(enumerator.MoveNext());
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 0), new Vector(3, 3)), enumerator.Current.Rect);
                CheckEqual("b", enumerator.Current.Item);

                CheckTrue(enumerator.MoveNext());
                CheckEqual(Rect.FromPositionAndSize(new Vector(6, 0), new Vector(3, 3)), enumerator.Current.Rect);
                CheckEqual("c", enumerator.Current.Item);
            }

            public void ManualAdvance_MoveNextKeepsReturningFalseOnceExhausted()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(9, 3));
                var items = new[] { "a", "b", "c" };
                RectDivider<string>.Enumerator enumerator = rect.NewCols(items).GetEnumerator();

                enumerator.MoveNext();
                enumerator.MoveNext();
                enumerator.MoveNext();

                CheckFalse(enumerator.MoveNext());
                CheckFalse(enumerator.MoveNext());
            }

            public void SingleItemSplit_PairsTheWholeRectWithTheOnlyItem()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                var items = new[] { "only" };

                var pairs = new (Rect Rect, string Item)[1];
                int i = 0;
                foreach ((Rect col, string item) in rect.NewCols(items, margin: 10))
                {
                    pairs[i++] = (col, item);
                }

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6)), pairs[0].Rect);
                CheckEqual("only", pairs[0].Item);
            }
        }

        public class Count : TestFixture
        {
            public void EqualsTheItemsListCount()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                var items = new[] { "a", "b", "c" };
                RectDivider<string> divider = rect.NewCols(items);

                CheckEqual(3, divider.Count);
            }
        }

        public class IndexOperator : TestFixture
        {
            public void ReturnsThePieceAndItsItemAtThatIndex()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                var items = new[] { "a", "b", "c" };
                RectDivider<string> divider = rect.NewCols(items);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(3, 6)), divider[0].Rect);
                CheckEqual("a", divider[0].Item);
                CheckEqual(Rect.FromPositionAndSize(new Vector(6, 4), new Vector(3, 6)), divider[1].Rect);
                CheckEqual("b", divider[1].Item);
                CheckEqual(Rect.FromPositionAndSize(new Vector(9, 4), new Vector(3, 6)), divider[2].Rect);
                CheckEqual("c", divider[2].Item);
            }

            public void MatchesWhatForeachYields()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(9, 3));
                var items = new[] { "a", "b", "c" };
                RectDivider<string> divider = rect.NewCols(items);

                var fromForeach = new (Rect Rect, string Item)[3];
                int i = 0;
                foreach ((Rect col, string item) in divider)
                {
                    fromForeach[i++] = (col, item);
                }

                for (int index = 0; index < divider.Count; index++)
                {
                    CheckEqual(fromForeach[index], divider[index]);
                }
            }

            public void NegativeIndexThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                var items = new[] { "a", "b", "c" };
                RectDivider<string> divider = rect.NewCols(items);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                (Rect, string) _ = divider[-1];
            }

            public void IndexEqualToCountThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(9, 6));
                var items = new[] { "a", "b", "c" };
                RectDivider<string> divider = rect.NewCols(items);

                CheckThrow(typeof(ArgumentOutOfRangeException));
                (Rect, string) _ = divider[3];
            }
        }
    }
}