/// <inheritdoc/>
        protected override Size2D MeasureOverride(Size2D availableSize)
        {
            var sizeLeft   = 0.0;
            var sizeTop    = 0.0;
            var sizeRight  = 0.0;
            var sizeBottom = 0.0;

            foreach (var child in Children)
            {
                var availableSizeForChild = new Size2D(
                    availableSize.Width - (sizeLeft + sizeRight),
                    availableSize.Height - (sizeTop + sizeBottom));

                child.Measure(availableSizeForChild);

                switch (GetDock(child))
                {
                    case Dock.Left:
                        sizeLeft += child.DesiredSize.Width;
                        break;
                    case Dock.Top:
                        sizeTop += child.DesiredSize.Height;
                        break;
                    case Dock.Right:
                        sizeRight += child.DesiredSize.Width;
                        break;
                    case Dock.Bottom:
                        sizeBottom += child.DesiredSize.Height;
                        break;
                }
            }

            return new Size2D(sizeLeft + sizeRight, sizeTop + sizeBottom);
        }

        public void Size2DEqualityTests()
        {
            Size2D s1 = new Size2D();
            Size2D s2 = Size2D.Empty;
            Size2D s3 = Size2D.Zero;
            Size2D s4 = new Size2D(0, 0);
            Size2D s5 = new Size2D(9, 10);

            Assert.Equal(s1, s2);
            Assert.NotEqual(s1, s3);
            Assert.Equal(s3, s4);
            Assert.NotEqual(s1, s5);
            Assert.NotEqual(s3, s5);

            IVectorD v1 = s1;
            IVectorD v2 = s2;
            IVectorD v3 = s3;
            IVectorD v4 = s4;
            IVectorD v5 = s5;

            Assert.Equal(v1, v2);
            Assert.NotEqual(v1, v3);
            Assert.Equal(v3, v4);
            Assert.NotEqual(v1, v5);
            Assert.NotEqual(v3, v5);

            Assert.Equal(v5, s5);
        }

        public void Size2D_IsConstructedProperly()
        {
            var result = new Size2D(123.45, 456.78);

            TheResultingValue(result)
                .ShouldBe(123.45, 456.78);
        }

        /// <inheritdoc/>
        protected override Size2D MeasureOverride(Size2D availableSize)
        {
            var contentWidth  = 0.0;
            var contentHeight = 0.0;

            if (Orientation == Orientation.Vertical)
            {
                foreach (var child in Children)
                {
                    child.Measure(new Size2D(availableSize.Width, Double.PositiveInfinity));

                    contentWidth  = Math.Max(contentWidth, child.DesiredSize.Width);
                    contentHeight = contentHeight + child.DesiredSize.Height;
                }
            }
            else
            {
                foreach (var child in Children)
                {
                    child.Measure(new Size2D(Double.PositiveInfinity, availableSize.Height));

                    contentWidth  = contentWidth + child.DesiredSize.Width;
                    contentHeight = Math.Max(contentHeight, child.DesiredSize.Height);
                }
            }

            return new Size2D(contentWidth, contentHeight);
        }

		/// <summary>
		/// Test whether label collides.
		/// </summary>
		/// <param name="newLabel"></param>
		/// <returns>true if label collided with another (more important or earlier) label</returns>
		public Boolean SimpleCollisionTest(Label2D newLabel)
		{
			if (labelList.Contains(newLabel))
			{
				return false;
			}

			Size2D newSize = TextRenderer.MeasureString(newLabel.Text, newLabel.Font);
			newSize = new Size2D(newSize.Width + 2 * newLabel.CollisionBuffer.Width, newSize.Height + 2 * newLabel.CollisionBuffer.Height);
			Rectangle2D newRect = new Rectangle2D(new Point2D(newLabel.Location.X - newLabel.CollisionBuffer.Width, newLabel.Location.Y - newLabel.CollisionBuffer.Height), newSize);

			foreach (Label2D label in labelList)
			{
				Size2D size = TextRenderer.MeasureString(label.Text, label.Font);
				size = new Size2D(size.Width + 2*label.CollisionBuffer.Width, size.Height + 2*label.CollisionBuffer.Height);
				Rectangle2D rect =
					new Rectangle2D(
						new Point2D(label.Location.X - newLabel.CollisionBuffer.Width, label.Location.Y - label.CollisionBuffer.Height),
						size);

				if (newRect.Intersects(rect))
				{
					return true;
				}
			}

			labelList.Add(newLabel);

			return false;
		}

        public VirtualButton(Size2D<int> CustomHitbox, bool Animate = false)
        {
            this.CustomHitbox = CustomHitbox;
            this.Animate = Animate;

            PressedAnimation = "Pressed";
            ReleasedAnimation = "Released";
        }

        public void Size2D_EqualsObject()
        {
            var size1 = new Size2D(123.45, 456.78);
            var size2 = new Size2D(123.45, 456.78);

            TheResultingValue(size1.Equals((Object)size2)).ShouldBe(true);
            TheResultingValue(size1.Equals("This is a test")).ShouldBe(false);
        }

        public void Size2D_Area_IsCalculatedCorrectly()
        {
            var size1 = new Size2D(123.45, 456.78);
            TheResultingValue(size1.Area).ShouldBe(123.45 * 456.78);

            var size2 = new Size2D(222.22, 55555.55);
            TheResultingValue(size2.Area).ShouldBe(222.22 * 55555.55);
        }

 /// <inheritdoc/>
 protected override Size2D ArrangeOverride(Size2D finalSize, ArrangeOptions options)
 {
     if (child != null)
     {
         child.Arrange(new RectangleD(Point2D.Zero, finalSize), options);
     }
     return finalSize;
 }

 public SpriteOscillator(Size2D<int> MinSize, Size2D<int> MaxSize, float Frequency, Size2D<int>? IdleSize = null, bool Oscillate = true)
 {
     this.MinSize = MinSize;
     this.MaxSize = MaxSize;
     this.IdleSize = IdleSize;
     this.Frequency = Frequency;
     this.Oscillate = Oscillate;
 }

        public StyleFont(StyleFontFamily family, Size2D emSize, StyleFontStyle style)
        {
            if (family == null) throw new ArgumentNullException("family");

            _fontFamily = family;
            _size = emSize;
            _style = style;
        }

 /// <inheritdoc/>
 protected override Size2D MeasureOverride(Size2D availableSize)
 {
     if (Track != null)
     {
         Track.InvalidateMeasure();
     }
     return base.MeasureOverride(availableSize);
 }

 /// <inheritdoc/>
 protected override Size2D MeasureOverride(Size2D availableSize)
 {
     if (child != null)
     {
         child.Measure(availableSize);
         return child.DesiredSize;
     }
     return Size2D.Zero;
 }

 /// <inheritdoc/>
 protected override Size2D ArrangeOverride(Size2D finalSize, ArrangeOptions options)
 {
     var arrangedSize = base.ArrangeOverride(finalSize, options);
     if (VisualTreeHelper.GetParent(adornerLayer) == this)
     {
         adornerLayer.Arrange(new RectangleD(Point2D.Zero, finalSize));
     }
     return arrangedSize;
 }

 /// <inheritdoc/>
 protected override Size2D MeasureOverride(Size2D availableSize)
 {
     var desiredSize = base.MeasureOverride(availableSize);
     if (VisualTreeHelper.GetParent(adornerLayer) == this)
     {
         adornerLayer.Measure(availableSize);
     }
     return desiredSize;
 }

        public LabelStyle(StyleFont font,
						  StyleBrush foreground,
						  StyleBrush background,
						  Point2D offset,
						  Size2D collisionBuffer,
						  HorizontalAlignment horizontalAlignment,
						  VerticalAlignment verticalAlignment)
            : base(font, foreground, background, offset, collisionBuffer, horizontalAlignment, verticalAlignment)
        {}

        public static Size2D GetRotatedSize(Size2D size, double angleOfRotation)
        {
            double cosOfAngleOfRotation = Math.Cos(angleOfRotation);
            double sinOfAngleOfRotation = Math.Sin(angleOfRotation);
            double rotatedWidth = Math.Abs(cosOfAngleOfRotation) * size.Width + Math.Abs(sinOfAngleOfRotation) * size.Height;
            double rotatedHeight = Math.Abs(sinOfAngleOfRotation) * size.Width + Math.Abs(cosOfAngleOfRotation) * size.Height;

            return new Size2D(rotatedWidth, rotatedHeight);
        }

        public void Size2D_OpInequality()
        {
            var size1 = new Size2D(123.45, 456.78);
            var size2 = new Size2D(123.45, 456.78);
            var size3 = new Size2D(123.45, 555.55);
            var size4 = new Size2D(222.22, 456.78);

            TheResultingValue(size1 != size2).ShouldBe(false);
            TheResultingValue(size1 != size3).ShouldBe(true);
            TheResultingValue(size1 != size4).ShouldBe(true);
        }

        /// <inheritdoc/>
        protected override Size2D MeasureOverride(Size2D availableSize)
        {
            foreach (var child in Children)
                child.Measure(availableSize);

            var contentSize = (Orientation == Orientation.Vertical) ? 
                MeasureVertically(availableSize) :
                MeasureHorizontally(availableSize);

            return contentSize;
        }

        public void Size2D_EqualsSize2D()
        {
            var size1 = new Size2D(123.45, 456.78);
            var size2 = new Size2D(123.45, 456.78);
            var size3 = new Size2D(123.45, 555.55);
            var size4 = new Size2D(222.22, 456.78);

            TheResultingValue(size1.Equals(size2)).ShouldBe(true);
            TheResultingValue(size1.Equals(size3)).ShouldBe(false);
            TheResultingValue(size1.Equals(size4)).ShouldBe(false);
        }