Merge branch 'master' into fail-animation

osu.Game.Tests/Visual/UserInterface/OsuGridTestScene.cs

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    /// <summary>
+    /// An abstract test case which exposes small cells arranged in a grid.
+    /// Useful for displaying multiple configurations of a tested component at a glance.
+    /// </summary>
+    public abstract class OsuGridTestScene : OsuTestScene
+    {
+        private readonly Drawable[,] cells;
+
+        /// <summary>
+        /// The amount of rows in the grid.
+        /// </summary>
+        protected readonly int Rows;
+
+        /// <summary>
+        /// The amount of columns in the grid.
+        /// </summary>
+        protected readonly int Cols;
+
+        /// <summary>
+        /// Constructs a grid test case with the given dimensions.
+        /// </summary>
+        protected OsuGridTestScene(int rows, int cols)
+        {
+            Rows = rows;
+            Cols = cols;
+
+            GridContainer testContainer;
+            Add(testContainer = new GridContainer { RelativeSizeAxes = Axes.Both });
+
+            cells = new Drawable[rows, cols];
+            for (int r = 0; r < rows; r++)
+            for (int c = 0; c < cols; c++)
+                cells[r, c] = new Container { RelativeSizeAxes = Axes.Both };
+
+            testContainer.Content = cells.ToJagged();
+        }
+
+        protected Container Cell(int index) => (Container)cells[index / Cols, index % Cols];
+        protected Container Cell(int row, int col) => (Container)cells[row, col];
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneCursors.cs

@@ -84,7 +84,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             testLocalCursor();
             testUserCursorOverride();
             testMultipleLocalCursors();
-            ReturnUserInput();
         }
 
         /// <summary>

osu.Game.Tests/Visual/UserInterface/TestSceneLoadingAnimation.cs

@@ -3,13 +3,12 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.UserInterface
 {
-    public class TestSceneLoadingAnimation : GridTestScene //todo: this should be an OsuTestScene
+    public class TestSceneLoadingAnimation : OsuGridTestScene
     {
         public TestSceneLoadingAnimation()
             : base(2, 2)

osu.Game.Tests/Visual/UserInterface/TestSceneOsuAnimatedButton.cs

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneOsuAnimatedButton : OsuGridTestScene
+    {
+        public TestSceneOsuAnimatedButton()
+            : base(3, 2)
+        {
+            Cell(0).Add(new BaseContainer("relative sized")
+            {
+                RelativeSizeAxes = Axes.Both,
+            });
+
+            Cell(1).Add(new BaseContainer("auto sized")
+            {
+                AutoSizeAxes = Axes.Both
+            });
+
+            Cell(2).Add(new BaseContainer("relative Y auto X")
+            {
+                RelativeSizeAxes = Axes.Y,
+                AutoSizeAxes = Axes.X
+            });
+
+            Cell(3).Add(new BaseContainer("relative X auto Y")
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y
+            });
+
+            Cell(4).Add(new BaseContainer("fixed")
+            {
+                Size = new Vector2(100),
+            });
+
+            Cell(5).Add(new BaseContainer("fixed")
+            {
+                Size = new Vector2(100, 50),
+            });
+
+            AddToggleStep("toggle enabled", toggle =>
+            {
+                for (int i = 0; i < 6; i++)
+                    ((BaseContainer)Cell(i).Child).Action = toggle ? () => { } : (Action)null;
+            });
+        }
+
+        public class BaseContainer : OsuAnimatedButton
+        {
+            public BaseContainer(string text)
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                Add(new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Text = text
+                });
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneOsuHoverContainer.cs

@@ -0,0 +1,194 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.Containers;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    [TestFixture]
+    public class TestSceneOsuHoverContainer : ManualInputManagerTestScene
+    {
+        private OsuHoverTestContainer hoverContainer;
+        private Box colourContainer;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Child = hoverContainer = new OsuHoverTestContainer
+            {
+                Enabled = { Value = true },
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(100),
+                Child = colourContainer = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                },
+            };
+
+            doMoveOut();
+        });
+
+        [Description("Checks IsHovered property value on a container when it is hovered/unhovered.")]
+        [TestCase(true, TestName = "Enabled_Check_IsHovered")]
+        [TestCase(false, TestName = "Disabled_Check_IsHovered")]
+        public void TestIsHoveredHasProperValue(bool isEnabled)
+        {
+            setContainerEnabledTo(isEnabled);
+
+            checkNotHovered();
+
+            moveToText();
+            checkHovered();
+
+            moveOut();
+            checkNotHovered();
+
+            moveToText();
+            checkHovered();
+
+            moveOut();
+            checkNotHovered();
+        }
+
+        [Test]
+        [Description("Checks colour fading on an enabled container when it is hovered/unhovered.")]
+        public void TestTransitionWhileEnabled()
+        {
+            enableContainer();
+
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            waitUntilColourIs(OsuHoverTestContainer.HOVER_COLOUR);
+
+            moveOut();
+            waitUntilColourIs(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            waitUntilColourIs(OsuHoverTestContainer.HOVER_COLOUR);
+
+            moveOut();
+            waitUntilColourIs(OsuHoverTestContainer.IDLE_COLOUR);
+        }
+
+        [Test]
+        [Description("Checks colour fading on a disabled container when it is hovered/unhovered.")]
+        public void TestNoTransitionWhileDisabled()
+        {
+            disableContainer();
+
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveOut();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveOut();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+        }
+
+        [Test]
+        [Description("Checks that when a disabled & hovered container gets enabled, colour fading happens")]
+        public void TestBecomesEnabledTransition()
+        {
+            disableContainer();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            enableContainer();
+            waitUntilColourIs(OsuHoverTestContainer.HOVER_COLOUR);
+        }
+
+        [Test]
+        [Description("Checks that when an enabled & hovered container gets disabled, colour fading happens")]
+        public void TestBecomesDisabledTransition()
+        {
+            enableContainer();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            waitUntilColourIs(OsuHoverTestContainer.HOVER_COLOUR);
+
+            disableContainer();
+            waitUntilColourIs(OsuHoverTestContainer.IDLE_COLOUR);
+        }
+
+        [Test]
+        [Description("Checks that when a hovered container gets enabled and disabled multiple times, colour fading happens")]
+        public void TestDisabledChangesMultipleTimes()
+        {
+            enableContainer();
+            checkColour(OsuHoverTestContainer.IDLE_COLOUR);
+
+            moveToText();
+            waitUntilColourIs(OsuHoverTestContainer.HOVER_COLOUR);
+
+            disableContainer();
+            waitUntilColourIs(OsuHoverTestContainer.IDLE_COLOUR);
+
+            enableContainer();
+            waitUntilColourIs(OsuHoverTestContainer.HOVER_COLOUR);
+
+            disableContainer();
+            waitUntilColourIs(OsuHoverTestContainer.IDLE_COLOUR);
+        }
+
+        private void enableContainer() => setContainerEnabledTo(true);
+
+        private void disableContainer() => setContainerEnabledTo(false);
+
+        private void setContainerEnabledTo(bool newValue)
+        {
+            string word = newValue ? "Enable" : "Disable";
+            AddStep($"{word} container", () => hoverContainer.Enabled.Value = newValue);
+        }
+
+        private void moveToText() => AddStep("Move mouse to text", () => InputManager.MoveMouseTo(hoverContainer));
+
+        private void moveOut() => AddStep("Move out", doMoveOut);
+
+        private void checkHovered() => AddAssert("Check hovered", () => hoverContainer.IsHovered);
+
+        private void checkNotHovered() => AddAssert("Check not hovered", () => !hoverContainer.IsHovered);
+
+        private void checkColour(ColourInfo expectedColour)
+            => AddAssert($"Check colour to be '{expectedColour}'", () => currentColour.Equals(expectedColour));
+
+        private void waitUntilColourIs(ColourInfo expectedColour)
+            => AddUntilStep($"Wait until hover colour is {expectedColour}", () => currentColour.Equals(expectedColour));
+
+        private ColourInfo currentColour => colourContainer.DrawColourInfo.Colour;
+
+        /// <summary>
+        ///     Moves the cursor to top left corner of the screen
+        /// </summary>
+        private void doMoveOut()
+            => InputManager.MoveMouseTo(new Vector2(InputManager.ScreenSpaceDrawQuad.TopLeft.X, InputManager.ScreenSpaceDrawQuad.TopLeft.Y));
+
+        private sealed class OsuHoverTestContainer : OsuHoverContainer
+        {
+            public static readonly Color4 HOVER_COLOUR = Color4.Red;
+            public static readonly Color4 IDLE_COLOUR = Color4.Green;
+
+            public OsuHoverTestContainer()
+            {
+                HoverColour = HOVER_COLOUR;
+                IdleColour = IDLE_COLOUR;
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/UserInterface/TestSceneUpdateableBeatmapBackgroundSprite.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             TestUpdateableBeatmapBackgroundSprite background = null;
 
             AddStep("load null beatmap", () => Child = background = new TestUpdateableBeatmapBackgroundSprite { RelativeSizeAxes = Axes.Both });
-            AddAssert("no content", () => !background.ContentLoaded);
+            AddUntilStep("content loaded", () => background.ContentLoaded);
         }
 
         [Test]