using System;
using UnitTestSharp;
using Azimuth;
using Annulus;
using static Glass.UnitTests.ButtonTests.MaterialTests;

namespace Glass.UnitTests
{
    public class RectTests : TestFixture
    {
        public class SplitHorizontally : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(25);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -5));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, -5), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void MarginIsTakenFromBottomHalf()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(25, margin: 10);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -5));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, 5), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void NegativeMarginCausesOverlap()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(25, margin: -10);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -5));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, -15), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void NegativeSplitHeightThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitHorizontally(-1);
            }

            public void TooLargeSplitHeightThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitHorizontally(81);
            }

            public void SplitHeight_0()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(0);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, -30));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void SplitHeight_Height()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect top, Rect bottom) = rect.SplitHorizontally(80);

                var expectedTop = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                var expectedBottom = Rect.FromTwoPoints(new Vector(-20, 50), new Vector(10, 50));
                CheckEqual(expectedTop, top);
                CheckEqual(expectedBottom, bottom);
            }

            public void MarginGreaterThanHeight()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitHorizontally(70, 11);
            }
        }

        public class SplitVertically : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(10);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-10, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void MarginIsTakenFromRightHalf()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(10, margin: 5);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-5, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void NegativeMarginCausesOverlap()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(10, margin: -5);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-15, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void NegativeSplitWidthThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitVertically(-1);
            }

            public void TooLargeSplitWidthThrows()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitVertically(31);
            }

            public void SplitWidth_0()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(0);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(-20, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void SplitWidth_Width()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                (Rect left, Rect right) = rect.SplitVertically(30);

                var expectedLeft = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                var expectedRight = Rect.FromTwoPoints(new Vector(10, -30), new Vector(10, 50));
                CheckEqual(expectedLeft, left);
                CheckEqual(expectedRight, right);
            }

            public void MarginGreaterThanHeight()
            {
                var rect = Rect.FromTwoPoints(new Vector(-20, -30), new Vector(10, 50));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.SplitVertically(20, 11);
            }
        }

        public class NewRow : TestFixture
        {
            public void TopJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(5);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 5)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 9), new Vector(5, 1)), rect);
            }

            public void BottomJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(5, VerticalJustification.Bottom);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 1)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 5), new Vector(5, 5)), row);
            }

            public void TopJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(4, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 4)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 9), new Vector(5, 1)), rect);
            }

            public void BottomJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewRow(4, VerticalJustification.Bottom, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 1)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 6), new Vector(5, 4)), row);
            }

            public void HeightLargerThanRectHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.NewRow(7);
            }

            public void SplittingNegativeWidthProducesTwoNegativeWidthRows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(100, 200), new Vector(-1, 40));
                var newRow = rect.NewRow(10);

                CheckEqual(Rect.FromPositionAndSize(new Vector(99, 200), new Vector(1, 10)), newRow);
                CheckEqual(Rect.FromPositionAndSize(new Vector(99, 210), new Vector(1, 30)), rect);
            }
        }

        public class NewCol : TestFixture
        {
            public void LeftJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(4);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(4, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(7, 4), new Vector(1, 6)), rect);
            }

            public void LeftJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(3, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(3, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(7, 4), new Vector(1, 6)), rect);
            }

            public void RightJustification()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(4, HorizontalJustification.Right);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(1, 6)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(4, 4), new Vector(4, 6)), row);
            }

            public void RightJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                var row = rect.NewCol(3, HorizontalJustification.Right, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(1, 6)), rect);
                CheckEqual(Rect.FromPositionAndSize(new Vector(5, 4), new Vector(3, 6)), row);
            }

            public void WidthGreaterThanWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckThrow(typeof(ArgumentOutOfRangeException));
                rect.NewCol(6);
            }

            public void SplittingNegativeHeightProducesTwoNegativeHeightCols()
            {
                var rect = Rect.FromPositionAndSize(new Vector(100, 200), new Vector(40, -1));
                var newRow = rect.NewCol(10);

                CheckEqual(Rect.FromPositionAndSize(new Vector(100, 199), new Vector(10, 1)), newRow);
                CheckEqual(Rect.FromPositionAndSize(new Vector(110, 199), new Vector(30, 1)), rect);
            }
        }

        public class TestMaterial : Material
        {
            private readonly Vector? _fixedSize;
            public TestMaterial(Vector? fixedSize) => _fixedSize = fixedSize;
            public override Vector CalculateLayoutSize(Vector maximumSize) => _fixedSize ?? maximumSize;
        }

        public class OversizedTestMaterial : Material
        {
            private readonly Vector _size;
            public OversizedTestMaterial(Vector size) => _size = size;
            public override Vector CalculateLayoutSize(Vector maximumSize) => _size;
        }

        public static Material FixedSizeMaterial(Scalar width, Scalar height)
        {
            return new TestMaterial(new Vector(width, height));
        }

        public static Material StretchyMaterial()
        {
            return new TestMaterial(null);
        }

        public class NewColMaterial : TestFixture
        {
            public void LeftJustificationFixedSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(4, 5));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(4, 5)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(7, 4), new Vector(6, 6)), rect);
            }

            public void RightJustificationFixedSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(4, 5), justification: HorizontalJustification.Right);

                CheckEqual(Rect.FromPositionAndSize(new Vector(9, 4), new Vector(4, 5)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(6, 6)), rect);
            }

            public void LeftJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(4, 5), margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(4, 5)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(8, 4), new Vector(5, 6)), rect);
            }

            public void StretchyMaterialUsesMaximumSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(StretchyMaterial());

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(13, 4), new Vector(0, 6)), rect);
            }

            public void MaximumWidthClampsAvailableWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(StretchyMaterial(), maximumWidth: 5);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(8, 4), new Vector(5, 6)), rect);
            }

            public void MaterialExceedingMaximumSizeThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                CheckThrow(typeof(InvalidOperationException));
                rect.NewCol(new OversizedTestMaterial(new Vector(11, 6)));
            }

            public void MaterialExceedingMaximumHeightThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                CheckThrow(typeof(InvalidOperationException));
                rect.NewCol(new OversizedTestMaterial(new Vector(5, 7)));
            }

            public void RightJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(4, 5), justification: HorizontalJustification.Right, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(9, 4), new Vector(4, 5)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6)), rect);
            }

            public void MaximumWidthSmallerThanMaterialWidthThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                CheckThrow(typeof(InvalidOperationException));
                rect.NewCol(FixedSizeMaterial(8, 5), maximumWidth: 4);
            }

            public void ZeroSizeMaterial()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(0, 0));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 0)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), rect);
            }

            public void MaximumWidthZero()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(StretchyMaterial(), maximumWidth: 0);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 6)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), rect);
            }

            public void ZeroWidthRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 6));
                var col = rect.NewCol(StretchyMaterial());

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 6)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 6)), rect);
            }

            public void ZeroHeightRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 0));
                var col = rect.NewCol(StretchyMaterial());

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 0)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(13, 4), new Vector(0, 0)), rect);
            }

            public void NegativeWidthRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(100, 200), new Vector(-1, 40));
                var col = rect.NewCol(FixedSizeMaterial(1, 10));

                CheckEqual(Rect.FromPositionAndSize(new Vector(99, 200), new Vector(1, 10)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(100, 200), new Vector(0, 40)), rect);
            }

            public void MaximumWidthLargerThanRectWidthIsClamped()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(StretchyMaterial(), maximumWidth: 20);

                // should behave as if maximumWidth was 10
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(13, 4), new Vector(0, 6)), rect);
            }

            public void MaterialReturnsExactlyMaximumSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(10, 6));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(13, 4), new Vector(0, 6)), rect);
            }

            public void ZeroWidthNonZeroHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(0, 5));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 5)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), rect);
            }

            public void NonZeroWidthZeroHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var col = rect.NewCol(FixedSizeMaterial(4, 0));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(4, 0)), col);
                CheckEqual(Rect.FromPositionAndSize(new Vector(7, 4), new Vector(6, 6)), rect);
            }
        }

        public class NewRowMaterial : TestFixture
        {
            public void TopJustificationFixedSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(8, 3));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(8, 3)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 7), new Vector(10, 3)), rect);
            }

            public void BottomJustificationFixedSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(8, 3), justification: VerticalJustification.Bottom);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 7), new Vector(8, 3)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 3)), rect);
            }

            public void TopJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(8, 3), margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(8, 3)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 8), new Vector(10, 2)), rect);
            }

            public void StretchyMaterialUsesMaximumSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(StretchyMaterial());

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 10), new Vector(10, 0)), rect);
            }

            public void MaximumHeightClampsAvailableHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(StretchyMaterial(), maximumHeight: 4);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 4)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 8), new Vector(10, 2)), rect);
            }

            public void MaterialExceedingMaximumSizeThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                CheckThrow(typeof(InvalidOperationException));
                rect.NewRow(new OversizedTestMaterial(new Vector(10, 7)));
            }

            public void MaterialExceedingMaximumWidthThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                CheckThrow(typeof(InvalidOperationException));
                rect.NewRow(new OversizedTestMaterial(new Vector(11, 3)));
            }

            public void BottomJustificationWithMargin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(8, 3), justification: VerticalJustification.Bottom, margin: 1);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 7), new Vector(8, 3)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 2)), rect);
            }

            public void MaximumHeightSmallerThanMaterialHeightThrows()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                CheckThrow(typeof(InvalidOperationException));
                rect.NewRow(FixedSizeMaterial(8, 5), maximumHeight: 3);
            }

            public void ZeroSizeMaterial()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(0, 0));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 0)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), rect);
            }

            public void MaximumHeightZero()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(StretchyMaterial(), maximumHeight: 0);

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 0)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), rect);
            }

            public void ZeroHeightRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 0));
                var row = rect.NewRow(StretchyMaterial());

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 0)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 0)), rect);
            }

            public void ZeroWidthRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 6));
                var row = rect.NewRow(StretchyMaterial());

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 10), new Vector(0, 0)), rect);
            }

            public void NegativeHeightRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(100, 200), new Vector(40, -1));
                var row = rect.NewRow(FixedSizeMaterial(10, 1));

                CheckEqual(Rect.FromPositionAndSize(new Vector(100, 199), new Vector(10, 1)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(100, 200), new Vector(40, 0)), rect);
            }

            public void MaximumHeightLargerThanRectHeightIsClamped()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(StretchyMaterial(), maximumHeight: 20);

                // should behave as if maximumHeight was 6
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 10), new Vector(10, 0)), rect);
            }

            public void MaterialReturnsExactlyMaximumSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(10, 6));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 10), new Vector(10, 0)), rect);
            }

            public void ZeroHeightNonZeroWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(8, 0));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(8, 0)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6)), rect);
            }

            public void NonZeroHeightZeroWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(10, 6));
                var row = rect.NewRow(FixedSizeMaterial(0, 3));

                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 4), new Vector(0, 3)), row);
                CheckEqual(Rect.FromPositionAndSize(new Vector(3, 7), new Vector(10, 3)), rect);
            }
        }
    }
}