using Azimuth;
using System;
using UnitTestSharp;
using static Annulus.Rect;

namespace Annulus.UnitTests
{
    public class RectTests : TestFixture
    {
        public void CornerTests()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));

            CheckEqual(new Vector(-3, -4), rect.TopLeft);
            CheckEqual(new Vector(5, -4), rect.TopRight);
            CheckEqual(new Vector(-3, 6), rect.BottomLeft);
            CheckEqual(new Vector(5, 6), rect.BottomRight);
            CheckEqual(new Vector(1, 1), rect.Center);
        }

        public void CornerTests_NegativeWidth()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(-5, 6));
            CheckEqual(new Vector(-5, -4), rect.TopLeft);
            CheckEqual(new Vector(-3, -4), rect.TopRight);
            CheckEqual(new Vector(-5, 6), rect.BottomLeft);
            CheckEqual(new Vector(-3, 6), rect.BottomRight);
            CheckEqual(new Vector(-4, 1), rect.Center);
        }

        public void CornerTests_NegativeHeight()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, -6));
            CheckEqual(new Vector(-3, -6), rect.TopLeft);
            CheckEqual(new Vector(5, -6), rect.TopRight);
            CheckEqual(new Vector(-3, -4), rect.BottomLeft);
            CheckEqual(new Vector(5, -4), rect.BottomRight);
            CheckEqual(new Vector(1, -5), rect.Center);
        }

        public void CornerTests_NegativeSize()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(-5, -6));
            CheckEqual(new Vector(-5, -6), rect.TopLeft);
            CheckEqual(new Vector(-3, -6), rect.TopRight);
            CheckEqual(new Vector(-5, -4), rect.BottomLeft);
            CheckEqual(new Vector(-3, -4), rect.BottomRight);
            CheckEqual(new Vector(-4, -5), rect.Center);
        }

        public void EdgeTests()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));

            CheckEqual(-3, rect.Left);
            CheckEqual(5, rect.Right);
            CheckEqual(6, rect.Bottom);
            CheckEqual(-4, rect.Top);
        }

        public void EdgeTests_NegativeWidth()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(-5, 6));
            CheckEqual(-5, rect.Left);
            CheckEqual(-3, rect.Right);
            CheckEqual(6, rect.Bottom);
            CheckEqual(-4, rect.Top);
        }

        public void EdgeTests_NegativeHeight()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, -6));
            CheckEqual(-3, rect.Left);
            CheckEqual(5, rect.Right);
            CheckEqual(-4, rect.Bottom);
            CheckEqual(-6, rect.Top);
        }

        public void EdgeTests_NegativeSize()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(-5, -6));
            CheckEqual(-5, rect.Left);
            CheckEqual(-3, rect.Right);
            CheckEqual(-4, rect.Bottom);
            CheckEqual(-6, rect.Top);
        }

        public void WidthHeight()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));

            CheckEqual(8, rect.Width);
            CheckEqual(10, rect.Height);
        }

        public void WidthHeight_NegativeWidth()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(-5, 6));
            CheckEqual(2, rect.Width);
            CheckEqual(10, rect.Height);
        }

        public void WidthHeight_NegativeHeight()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, -6));
            CheckEqual(8, rect.Width);
            CheckEqual(2, rect.Height);
        }

        public void WidthHeight_NegativeSize()
        {
            var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(-5, -6));
            CheckEqual(2, rect.Width);
            CheckEqual(2, rect.Height);
        }

        public void PositionAndSize()
        {
            var rect = Rect.FromPositionAndSize(new Vector(100, 50), new Vector(3, 4));

            CheckEqual(new Vector(100, 50), rect.Position);
            CheckEqual(new Vector(3, 4), rect.Size);
        }

        public void Zero()
        {
            CheckEqual(Rect.FromPositionAndSize(Vector.Zero, Vector.Zero), Rect.Zero);
        }

        public class FromPositionAndSizeTests : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckEqual(new Vector(3, 4), rect.Position);
                CheckEqual(new Vector(5, 6), rect.Size);
            }

            public void Zero()
            {
                var rect = Rect.FromPositionAndSize(Vector.Zero, Vector.Zero);
                CheckEqual(Vector.Zero, rect.Position);
                CheckEqual(Vector.Zero, rect.Size);
            }
        }

        public class FromTwoPointsTests : TestFixture
        {
            public void TopLeftAndBottomRight()
            {
                var rect = Rect.FromTwoPoints(new Vector(3, 4), new Vector(5, 6));
                CheckEqual(new Vector(3, 4), rect.TopLeft);
                CheckEqual(new Vector(5, 6), rect.BottomRight);
            }

            public void TopRightAndBottomLeft()
            {
                var rect = Rect.FromTwoPoints(new Vector(5, 4), new Vector(3, 6));
                CheckEqual(new Vector(3, 4), rect.TopLeft);
                CheckEqual(new Vector(5, 6), rect.BottomRight);
            }

            public void SamePoint()
            {
                var rect = Rect.FromTwoPoints(Vector.Zero, Vector.Zero);
                CheckEqual(new Rect(), rect);
            }
        }

        public class ContainsPoint : TestFixture
        {
            public void Inside()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(Vector.Zero));
            }

            public void OnLeftEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(-10, 0)));
            }

            public void OnRightEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(3, 0)));
            }

            public void OnTopEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(0, -5)));
            }

            public void OnBottomEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(0, 4)));
            }

            public void OnTopLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(-10, -5)));
            }

            public void OnTopRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(3, -5)));
            }

            public void OnBottomRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(3, 4)));
            }

            public void OnBottomLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                Check(rect.ContainsPoint(new Vector(-10, 4)));
            }

            public void OutsideTopLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(-11, -6)));
            }

            public void OutsideTopRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(4, -6)));
            }

            public void OutsideBottomRightCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(4, 5)));
            }

            public void OutsideBottomLeftCorner()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(-11, 5)));
            }

            public void OutsideLeftEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(-11, 0)));
            }

            public void OutsideRightEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(4, 0)));
            }

            public void OutsideTopEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(0, -6)));
            }

            public void OutsideBottomEdge()
            {
                var rect = Rect.FromTwoPoints(new Vector(-10, -5), new Vector(3, 4));
                CheckFalse(rect.ContainsPoint(new Vector(0, 5)));
            }
        }

        public class ToStringTests : TestFixture
        {
            public void Basic()
            {
                var rect = Rect.FromPositionAndSize(new Vector(3, 4), new Vector(5, 6));
                CheckEqual("<3 : 4>, <5 : 6>", rect.ToString());
            }
        }

        public class ToGraphicsAffineMatrixTests : TestFixture
        {
            public void TransformsCorners()
            {
                var rect = Rect.FromTwoPoints(new Vector(-3, -4), new Vector(5, 6));
                var matrix = rect.ToGraphicsAffineMatrix();
                CheckEqual(new Vector(-3, -6), matrix.TransformPoint(new Vector(-1, -1)));
                CheckEqual(new Vector(5, -6), matrix.TransformPoint(new Vector(1, -1)));
                CheckEqual(new Vector(-3, 4), matrix.TransformPoint(new Vector(-1, 1)));
                CheckEqual(new Vector(5, 4), matrix.TransformPoint(new Vector(1, 1)));
            }

            public void ToGraphicsAffineMatrix_NegativeWidth()
            {
                Rect rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(-30, 40));
                AffineMatrix matrix = rect.ToGraphicsAffineMatrix();
                AffineMatrix expected = new AffineMatrix(
                    angle: 0, position: new Vector(-5, -40), scale: new Vector(15, 20));
                CheckEqual(expected, matrix);
            }

            public void ToGraphicsAffineMatrix_NegativeHeight()
            {
                Rect rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, -40));
                AffineMatrix matrix = rect.ToGraphicsAffineMatrix();
                AffineMatrix expected = new AffineMatrix(
                    angle: 0, position: new Vector(25, 0), scale: new Vector(15, 20));
                CheckEqual(expected, matrix);
            }

            public void ToGraphicsAffineMatrix_NegativeWidthAndHeight()
            {
                Rect rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(-30, -40));
                AffineMatrix matrix = rect.ToGraphicsAffineMatrix();
                AffineMatrix expected = new AffineMatrix(
                    angle: 0, position: new Vector(-5, 0), scale: new Vector(15, 20));
                CheckEqual(expected, matrix);
            }
        }

        public class ErodeTests : TestFixture
        {
            public void ZeroBorderIsNoOp()
            {
                var rect = Rect.FromPositionAndSize(new Vector(5, 10), new Vector(20, 30));
                var eroded = rect.Erode(new BorderSize { Left = 0, Right = 0, Top = 0, Bottom = 0 });

                CheckEqual(rect, eroded);
            }

            public void BorderExactlyConsumesRect()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(10, 20));
                var eroded = rect.Erode(new BorderSize { Left = 5, Right = 5, Top = 10, Bottom = 10 });

                CheckEqual(new Vector(5, 10), eroded.Position);
                CheckEqual(new Vector(0, 0), eroded.Size);
            }

            public void LeftBorderOnlyAffectsPositionAndWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(22, 20));
                var eroded = rect.Erode(new BorderSize { Left = 5, Right = 0, Top = 0, Bottom = 0 });

                CheckEqual(new Vector(15, 20), eroded.Position);
                CheckEqual(new Vector(17, 20), eroded.Size);
            }

            public void RightBorderOnlyAffectsWidthNotPosition()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(20, 20));
                var eroded = rect.Erode(new BorderSize { Left = 0, Right = 5, Top = 0, Bottom = 0 });

                CheckEqual(new Vector(0, 0), eroded.Position);
                CheckEqual(new Vector(15, 20), eroded.Size);
            }

            public void TopBorderOnlyAffectsPositionAndHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(20, 20));
                var eroded = rect.Erode(new BorderSize { Left = 0, Right = 0, Top = 5, Bottom = 0 });

                CheckEqual(new Vector(10, 25), eroded.Position);
                CheckEqual(new Vector(20, 15), eroded.Size);
            }

            public void BottomBorderOnlyAffectsHeightNotPosition()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(20, 22));
                var eroded = rect.Erode(new BorderSize { Left = 0, Right = 0, Top = 0, Bottom = 5 });

                CheckEqual(new Vector(0, 0), eroded.Position);
                CheckEqual(new Vector(20, 17), eroded.Size);
            }

            public void OversizedBorderProducesNegativeSize()
            {
                var rect = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(10, 10));
                var eroded = rect.Erode(new BorderSize { Left = 6, Right = 6, Top = 0, Bottom = 0 });

                CheckEqual(new Vector(6, 0), eroded.Position);
                CheckEqual(new Vector(-2, 10), eroded.Size);
            }

            public void NonUniformBorderWithNonZeroOrigin()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, 40));
                var eroded = rect.Erode(new BorderSize { Left = 1, Right = 2, Top = 3, Bottom = 4 });

                CheckEqual(new Vector(11, 23), eroded.Position);
                CheckEqual(new Vector(27, 33), eroded.Size);
            }

            public void NegativeRight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, 40));
                var eroded = rect.Erode(new BorderSize { Left = 1, Right = -2, Top = 3, Bottom = 4 });

                CheckEqual(new Vector(11, 23), eroded.Position);
                CheckEqual(new Vector(31, 33), eroded.Size);
            }

            public void NegativeLeft()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, 40));
                var eroded = rect.Erode(new BorderSize { Left = -1, Right = 2, Top = 3, Bottom = 4 });

                CheckEqual(new Vector(9, 23), eroded.Position);
                CheckEqual(new Vector(29, 33), eroded.Size);
            }

            public void NegativeTop()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, 40));
                var eroded = rect.Erode(new BorderSize { Left = 1, Right = 2, Top = -3, Bottom = 4 });

                CheckEqual(new Vector(11, 17), eroded.Position);
                CheckEqual(new Vector(27, 39), eroded.Size);
            }

            public void NegativeBottom()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, 40));
                var eroded = rect.Erode(new BorderSize { Left = 1, Right = 2, Top = 3, Bottom = -4 });

                CheckEqual(new Vector(11, 23), eroded.Position);
                CheckEqual(new Vector(27, 41), eroded.Size);
            }

            public void NegativeRectWidth()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(-30, 40));
                var eroded = rect.Erode(new BorderSize { Left = 1, Right = 2, Top = 3, Bottom = 4 });

                CheckEqual(new Vector(8, 23), eroded.Position);
                CheckEqual(new Vector(-27, 33), eroded.Size);
            }

            public void NegativeRectHeight()
            {
                var rect = Rect.FromPositionAndSize(new Vector(10, 20), new Vector(30, -40));
                var eroded = rect.Erode(new BorderSize { Left = 1, Right = 2, Top = 3, Bottom = 4 });

                CheckEqual(new Vector(11, 16), eroded.Position);
                CheckEqual(new Vector(27, -33), eroded.Size);
            }
        }

        public class IntersectionTests : TestFixture
        {
            public void BasicOverlapMixedEdges()
            {
                var lhs = Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 10));
                var rhs = Rect.FromTwoPoints(new Vector(5, 5), new Vector(15, 15));
                var result = Rect.Intersection(lhs, rhs);

                CheckEqual(Rect.FromTwoPoints(new Vector(5, 5), new Vector(10, 10)), result);
            }

            public void ArgumentOrderSymmetry()
            {
                var lhs = Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 10));
                var rhs = Rect.FromTwoPoints(new Vector(5, 5), new Vector(15, 15));

                CheckEqual(Rect.Intersection(lhs, rhs), Rect.Intersection(rhs, lhs));
            }

            public void SeparatedHorizontallyReturnsNull()
            {
                var lhs = Rect.FromTwoPoints(new Vector(0, 0), new Vector(5, 10));
                var rhs = Rect.FromTwoPoints(new Vector(6, 0), new Vector(11, 10));
                var result = Rect.Intersection(lhs, rhs);

                CheckEqual(null, result);
            }

            public void SeparatedVerticallyReturnsNull()
            {
                var lhs = Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 5));
                var rhs = Rect.FromTwoPoints(new Vector(0, 6), new Vector(10, 11));
                var result = Rect.Intersection(lhs, rhs);

                CheckEqual(null, result);
            }

            public void TouchingEdgesHorizontallyReturnsNull()
            {
                var lhs = Rect.FromTwoPoints(new Vector(0, 0), new Vector(5, 10));
                var rhs = Rect.FromTwoPoints(new Vector(5, 0), new Vector(10, 10));
                var result = Rect.Intersection(lhs, rhs);

                CheckEqual(null, result);
            }

            public void TouchingEdgesVerticallyReturnsNull()
            {
                var lhs = Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 5));
                var rhs = Rect.FromTwoPoints(new Vector(0, 5), new Vector(10, 10));
                var result = Rect.Intersection(lhs, rhs);

                CheckEqual(null, result);
            }

            public void ContainedRectReturnsInnerRect()
            {
                var outer = Rect.FromTwoPoints(new Vector(0, 0), new Vector(20, 20));
                var inner = Rect.FromTwoPoints(new Vector(5, 5), new Vector(15, 15));
                var result = Rect.Intersection(outer, inner);

                CheckEqual(inner, result);
            }

            public void IdenticalRectsReturnSameRect()
            {
                var rect = Rect.FromTwoPoints(new Vector(3, 4), new Vector(10, 12));
                var result = Rect.Intersection(rect, rect);

                CheckEqual(rect, result);
            }

            public void OverlapWithNegativeCoordinates()
            {
                var lhs = Rect.FromTwoPoints(new Vector(-10, -10), new Vector(0, 0));
                var rhs = Rect.FromTwoPoints(new Vector(-5, -5), new Vector(5, 5));
                var result = Rect.Intersection(lhs, rhs);

                CheckEqual(Rect.FromTwoPoints(new Vector(-5, -5), new Vector(0, 0)), result);
            }

            public void NegativeWidthOverlap()
            {
                var lhs = Rect.FromPositionAndSize(new Vector(10, 0), new Vector(-15, 10));
                var rhs = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(15, 10));
                var result = Rect.Intersection(lhs, rhs);
                CheckEqual(Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 10)), result);
            }

            public void NegativeHeightOverlap()
            {
                var lhs = Rect.FromPositionAndSize(new Vector(0, 10), new Vector(10, -15));
                var rhs = Rect.FromPositionAndSize(new Vector(0, 0), new Vector(10, 15));
                var result = Rect.Intersection(lhs, rhs);
                CheckEqual(Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 10)), result);
            }

            public void NegativeSizeOverlap()
            {
                var lhs = Rect.FromPositionAndSize(new Vector(10, 10), new Vector(-15, -15));
                var rhs = Rect.FromPositionAndSize(new Vector(15, 15), new Vector(-15, -15));
                var result = Rect.Intersection(lhs, rhs);
                CheckEqual(Rect.FromTwoPoints(new Vector(0, 0), new Vector(10, 10)), result);
            }

            public void NegativeWidthSeparatedReturnsNull()
            {
                var lhs = Rect.FromPositionAndSize(new Vector(5, 0), new Vector(-5, 10));
                var rhs = Rect.FromPositionAndSize(new Vector(6, 0), new Vector(5, 10));
                var result = Rect.Intersection(lhs, rhs);
                CheckEqual(null, result);
            }

            public void NegativeHeightSeparatedReturnsNull()
            {
                var lhs = Rect.FromPositionAndSize(new Vector(0, 5), new Vector(10, -5));
                var rhs = Rect.FromPositionAndSize(new Vector(0, 6), new Vector(10, 5));
                var result = Rect.Intersection(lhs, rhs);
                CheckEqual(null, result);
            }

            public void NegativeWidthTouchingReturnsNull()
            {
                var lhs = Rect.FromPositionAndSize(new Vector(5, 0), new Vector(-5, 10));
                var rhs = Rect.FromPositionAndSize(new Vector(5, 0), new Vector(5, 10));
                var result = Rect.Intersection(lhs, rhs);
                CheckEqual(null, result);
            }

            public void NegativeSizeContainedReturnsInnerRect()
            {
                var outer = Rect.FromTwoPoints(new Vector(0, 0), new Vector(20, 20));
                var inner = Rect.FromPositionAndSize(new Vector(15, 15), new Vector(-10, -10));
                var result = Rect.Intersection(outer, inner);
                CheckEqual(Rect.FromTwoPoints(new Vector(5, 5), new Vector(15, 15)), result);
            }
        }

        public class BorderSizeTests : TestFixture
        {
            public void Construction()
            {
                var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };

                CheckEqual(1, border.Top);
                CheckEqual(2, border.Bottom);
                CheckEqual(3, border.Left);
                CheckEqual(4, border.Right);
            }

            public class SideMaskTests : TestFixture
            {
                public void CompoundFlags()
                {
                    CheckEqual(BorderSize.SideMask.Top | BorderSize.SideMask.Bottom, BorderSize.SideMask.TB);
                    CheckEqual(BorderSize.SideMask.Top | BorderSize.SideMask.Left, BorderSize.SideMask.TL);
                    CheckEqual(BorderSize.SideMask.Top | BorderSize.SideMask.Right, BorderSize.SideMask.TR);
                    CheckEqual(BorderSize.SideMask.Bottom | BorderSize.SideMask.Left, BorderSize.SideMask.BL);
                    CheckEqual(BorderSize.SideMask.Bottom | BorderSize.SideMask.Right, BorderSize.SideMask.BR);
                    CheckEqual(BorderSize.SideMask.Left | BorderSize.SideMask.Right, BorderSize.SideMask.LR);
                    CheckEqual(BorderSize.SideMask.Top | BorderSize.SideMask.Bottom | BorderSize.SideMask.Left,
                        BorderSize.SideMask.TBL);
                    CheckEqual(BorderSize.SideMask.Top | BorderSize.SideMask.Bottom | BorderSize.SideMask.Right,
                        BorderSize.SideMask.TBR);
                    CheckEqual(BorderSize.SideMask.Top | BorderSize.SideMask.Left | BorderSize.SideMask.Right,
                        BorderSize.SideMask.TLR);
                    CheckEqual(BorderSize.SideMask.Bottom | BorderSize.SideMask.Left | BorderSize.SideMask.Right,
                        BorderSize.SideMask.BLR);
                    CheckEqual(
                        BorderSize.SideMask.Top |
                        BorderSize.SideMask.Bottom |
                        BorderSize.SideMask.Left |
                        BorderSize.SideMask.Right,
                        BorderSize.SideMask.TBLR);
                    CheckEqual(BorderSize.SideMask.TBLR, BorderSize.SideMask.All);
                }
            }

            public class WithSidesTests : TestFixture
            {
                public void AllPassesAllSidesThrough()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.All);

                    CheckEqual(1, result.Top);
                    CheckEqual(2, result.Bottom);
                    CheckEqual(3, result.Left);
                    CheckEqual(4, result.Right);
                }

                public void NoneZerosAllSides()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.None);

                    CheckEqual(0, result.Top);
                    CheckEqual(0, result.Bottom);
                    CheckEqual(0, result.Left);
                    CheckEqual(0, result.Right);
                }

                public void TopOnlyPassesTopZerosOthers()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.Top);

                    CheckEqual(1, result.Top);
                    CheckEqual(0, result.Bottom);
                    CheckEqual(0, result.Left);
                    CheckEqual(0, result.Right);
                }

                public void BottomOnlyPassesBottomZerosOthers()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.Bottom);

                    CheckEqual(0, result.Top);
                    CheckEqual(2, result.Bottom);
                    CheckEqual(0, result.Left);
                    CheckEqual(0, result.Right);
                }

                public void LeftOnlyPassesLeftZerosOthers()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.Left);

                    CheckEqual(0, result.Top);
                    CheckEqual(0, result.Bottom);
                    CheckEqual(3, result.Left);
                    CheckEqual(0, result.Right);
                }

                public void RightOnlyPassesRightZerosOthers()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.Right);

                    CheckEqual(0, result.Top);
                    CheckEqual(0, result.Bottom);
                    CheckEqual(0, result.Left);
                    CheckEqual(4, result.Right);
                }

                public void TBLMaskPassesTopBottomLeftZerosRight()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var result = border.WithSides(BorderSize.SideMask.TBL);

                    CheckEqual(1, result.Top);
                    CheckEqual(2, result.Bottom);
                    CheckEqual(3, result.Left);
                    CheckEqual(0, result.Right);
                }

                public void OriginalIsUnmodifiedAfterWithSides()
                {
                    var border = new BorderSize { Top = 1, Bottom = 2, Left = 3, Right = 4 };
                    var _ = border.WithSides(BorderSize.SideMask.None);

                    CheckEqual(1, border.Top);
                    CheckEqual(2, border.Bottom);
                    CheckEqual(3, border.Left);
                    CheckEqual(4, border.Right);
                }
            }
        }
    }
}