Merge branch 'master' into changelog-overlay

osu.Game.Tests/Visual/Background/TestCaseBackgroundScreenBeatmap.cs

@@ -0,0 +1,421 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Framework.Input.States;
+using osu.Framework.Platform;
+using osu.Framework.Screens;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Scoring;
+using osu.Game.Screens;
+using osu.Game.Screens.Backgrounds;
+using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.PlayerSettings;
+using osu.Game.Screens.Select;
+using osu.Game.Tests.Resources;
+using osu.Game.Users;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Background
+{
+    [TestFixture]
+    public class TestCaseBackgroundScreenBeatmap : ManualInputManagerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ScreenWithBeatmapBackground),
+            typeof(PlayerLoader),
+            typeof(Player),
+            typeof(UserDimContainer),
+            typeof(OsuScreen)
+        };
+
+        private DummySongSelect songSelect;
+        private TestPlayerLoader playerLoader;
+        private TestPlayer player;
+        private DatabaseContextFactory factory;
+        private BeatmapManager manager;
+        private RulesetStore rulesets;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            factory = new DatabaseContextFactory(LocalStorage);
+            factory.ResetDatabase();
+
+            using (var usage = factory.Get())
+                usage.Migrate();
+
+            factory.ResetDatabase();
+
+            using (var usage = factory.Get())
+                usage.Migrate();
+
+            Dependencies.Cache(rulesets = new RulesetStore(factory));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, factory, rulesets, null, null, host, Beatmap.Default));
+            Dependencies.Cache(new OsuConfigManager(LocalStorage));
+
+            manager.Import(TestResources.GetTestBeatmapForImport());
+
+            Beatmap.SetDefault();
+        }
+
+        [SetUp]
+        public virtual void SetUp() => Schedule(() =>
+        {
+            Child = new OsuScreenStack(songSelect = new DummySongSelect())
+            {
+                RelativeSizeAxes = Axes.Both
+            };
+        });
+
+        /// <summary>
+        /// Check if <see cref="PlayerLoader"/> properly triggers the visual settings preview when a user hovers over the visual settings panel.
+        /// </summary>
+        [Test]
+        public void PlayerLoaderSettingsHoverTest()
+        {
+            setupUserSettings();
+            AddStep("Start player loader", () => songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer { BlockLoad = true })));
+            AddUntilStep("Wait for Player Loader to load", () => playerLoader?.IsLoaded ?? false);
+            AddAssert("Background retained from song select", () => songSelect.IsBackgroundCurrent());
+            AddStep("Trigger background preview", () =>
+            {
+                InputManager.MoveMouseTo(playerLoader.ScreenPos);
+                InputManager.MoveMouseTo(playerLoader.VisualSettingsPos);
+            });
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+            AddStep("Stop background preview", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
+            waitForDim();
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && playerLoader.IsBlurCorrect());
+        }
+
+        /// <summary>
+        /// In the case of a user triggering the dim preview the instant player gets loaded, then moving the cursor off of the visual settings:
+        /// The OnHover of PlayerLoader will trigger, which could potentially cause visual settings to be unapplied unless checked for in PlayerLoader.
+        /// We need to check that in this scenario, the dim and blur is still properly applied after entering player.
+        /// </summary>
+        [Test]
+        public void PlayerLoaderTransitionTest()
+        {
+            performFullSetup();
+            AddStep("Trigger hover event", () => playerLoader.TriggerOnHover());
+            AddAssert("Background retained from song select", () => songSelect.IsBackgroundCurrent());
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+        }
+
+        /// <summary>
+        /// Make sure the background is fully invisible (Alpha == 0) when the background should be disabled by the storyboard.
+        /// </summary>
+        [Test]
+        public void StoryboardBackgroundVisibilityTest()
+        {
+            performFullSetup();
+            createFakeStoryboard();
+            AddStep("Storyboard Enabled", () =>
+            {
+                player.ReplacesBackground.Value = true;
+                player.StoryboardEnabled.Value = true;
+            });
+            waitForDim();
+            AddAssert("Background is invisible, storyboard is visible", () => songSelect.IsBackgroundInvisible() && player.IsStoryboardVisible());
+            AddStep("Storyboard Disabled", () =>
+            {
+                player.ReplacesBackground.Value = false;
+                player.StoryboardEnabled.Value = false;
+            });
+            waitForDim();
+            AddAssert("Background is visible, storyboard is invisible", () => songSelect.IsBackgroundVisible() && player.IsStoryboardInvisible());
+        }
+
+        /// <summary>
+        /// When exiting player, the screen that it suspends/exits to needs to have a fully visible (Alpha == 1) background.
+        /// </summary>
+        [Test]
+        public void StoryboardTransitionTest()
+        {
+            performFullSetup();
+            createFakeStoryboard();
+            AddStep("Exit to song select", () => player.Exit());
+            waitForDim();
+            AddAssert("Background is visible", () => songSelect.IsBackgroundVisible());
+        }
+
+        /// <summary>
+        /// Check if the <see cref="UserDimContainer"/> is properly accepting user-defined visual changes at all.
+        /// </summary>
+        [Test]
+        public void DisableUserDimTest()
+        {
+            performFullSetup();
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+            AddStep("EnableUserDim disabled", () => songSelect.DimEnabled.Value = false);
+            waitForDim();
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && songSelect.IsUserBlurDisabled());
+            AddStep("EnableUserDim enabled", () => songSelect.DimEnabled.Value = true);
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+        }
+
+        /// <summary>
+        /// Check if the visual settings container retains dim and blur when pausing
+        /// </summary>
+        [Test]
+        public void PauseTest()
+        {
+            performFullSetup(true);
+            AddStep("Pause", () => player.Pause());
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+            AddStep("Unpause", () => player.Resume());
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+        }
+
+        /// <summary>
+        /// Check if the visual settings container removes user dim when suspending <see cref="Player"/> for <see cref="SoloResults"/>
+        /// </summary>
+        [Test]
+        public void TransitionTest()
+        {
+            performFullSetup();
+            var results = new FadeAccessibleResults(new ScoreInfo { User = new User { Username = "osu!" } });
+            AddStep("Transition to Results", () => player.Push(results));
+            AddUntilStep("Wait for results is current", results.IsCurrentScreen);
+            waitForDim();
+            AddAssert("Screen is undimmed, original background retained", () =>
+                songSelect.IsBackgroundUndimmed() && songSelect.IsBackgroundCurrent() && results.IsBlurCorrect());
+        }
+
+        /// <summary>
+        /// Check if background gets undimmed and unblurred when leaving <see cref="Player"/>  for <see cref="PlaySongSelect"/>
+        /// </summary>
+        [Test]
+        public void TransitionOutTest()
+        {
+            performFullSetup();
+            AddStep("Exit to song select", () => player.Exit());
+            waitForDim();
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && songSelect.IsBlurCorrect());
+        }
+
+        /// <summary>
+        /// Check if hovering on the visual settings dialogue after resuming from player still previews the background dim.
+        /// </summary>
+        [Test]
+        public void ResumeFromPlayerTest()
+        {
+            performFullSetup();
+            AddStep("Move mouse to Visual Settings", () => InputManager.MoveMouseTo(playerLoader.VisualSettingsPos));
+            AddStep("Resume PlayerLoader", () => player.Restart());
+            waitForDim();
+            AddAssert("Screen is dimmed and blur applied", () => songSelect.IsBackgroundDimmed() && songSelect.IsUserBlurApplied());
+            AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
+            waitForDim();
+            AddAssert("Screen is undimmed and user blur removed", () => songSelect.IsBackgroundUndimmed() && playerLoader.IsBlurCorrect());
+        }
+
+        private void waitForDim() => AddWaitStep("Wait for dim", 5);
+
+        private void createFakeStoryboard() => AddStep("Create storyboard", () =>
+        {
+            player.StoryboardEnabled.Value = false;
+            player.ReplacesBackground.Value = false;
+            player.CurrentStoryboardContainer.Add(new SpriteText
+            {
+                Size = new Vector2(250, 50),
+                Alpha = 1,
+                Colour = Color4.Tomato,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Text = "THIS IS A STORYBOARD",
+            });
+        });
+
+        private void performFullSetup(bool allowPause = false)
+        {
+            setupUserSettings();
+
+            AddStep("Start player loader", () => songSelect.Push(playerLoader = new TestPlayerLoader(player = new TestPlayer(allowPause))));
+
+            AddUntilStep("Wait for Player Loader to load", () => playerLoader.IsLoaded);
+            AddStep("Move mouse to center of screen", () => InputManager.MoveMouseTo(playerLoader.ScreenPos));
+            AddUntilStep("Wait for player to load", () => player.IsLoaded);
+        }
+
+        private void setupUserSettings()
+        {
+            AddUntilStep("Song select has selection", () => songSelect.Carousel.SelectedBeatmap != null);
+            AddStep("Set default user settings", () =>
+            {
+                Mods.Value = Mods.Value.Concat(new[] { new OsuModNoFail() }).ToArray();
+                songSelect.DimLevel.Value = 0.7f;
+                songSelect.BlurLevel.Value = 0.4f;
+            });
+        }
+
+        private class DummySongSelect : PlaySongSelect
+        {
+            protected override BackgroundScreen CreateBackground()
+            {
+                FadeAccessibleBackground background = new FadeAccessibleBackground(Beatmap.Value);
+                DimEnabled.BindTo(background.EnableUserDim);
+                return background;
+            }
+
+            public readonly Bindable<bool> DimEnabled = new Bindable<bool>();
+            public readonly Bindable<double> DimLevel = new Bindable<double>();
+            public readonly Bindable<double> BlurLevel = new Bindable<double>();
+
+            public new BeatmapCarousel Carousel => base.Carousel;
+
+            [BackgroundDependencyLoader]
+            private void load(OsuConfigManager config)
+            {
+                config.BindWith(OsuSetting.DimLevel, DimLevel);
+                config.BindWith(OsuSetting.BlurLevel, BlurLevel);
+            }
+
+            public bool IsBackgroundDimmed() => ((FadeAccessibleBackground)Background).CurrentColour == OsuColour.Gray(1 - (float)DimLevel.Value);
+
+            public bool IsBackgroundUndimmed() => ((FadeAccessibleBackground)Background).CurrentColour == Color4.White;
+
+            public bool IsUserBlurApplied() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2((float)BlurLevel.Value * 25);
+
+            public bool IsUserBlurDisabled() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(0);
+
+            public bool IsBackgroundInvisible() => ((FadeAccessibleBackground)Background).CurrentAlpha == 0;
+
+            public bool IsBackgroundVisible() => ((FadeAccessibleBackground)Background).CurrentAlpha == 1;
+
+            public bool IsBlurCorrect() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(BACKGROUND_BLUR);
+
+            /// <summary>
+            /// Make sure every time a screen gets pushed, the background doesn't get replaced
+            /// </summary>
+            /// <returns>Whether or not the original background (The one created in DummySongSelect) is still the current background</returns>
+            public bool IsBackgroundCurrent() => ((FadeAccessibleBackground)Background).IsCurrentScreen();
+        }
+
+        private class FadeAccessibleResults : SoloResults
+        {
+            public FadeAccessibleResults(ScoreInfo score)
+                : base(score)
+            {
+            }
+
+            protected override BackgroundScreen CreateBackground() => new FadeAccessibleBackground(Beatmap.Value);
+
+            public bool IsBlurCorrect() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(BACKGROUND_BLUR);
+        }
+
+        private class TestPlayer : Visual.TestPlayer
+        {
+            protected override BackgroundScreen CreateBackground() => new FadeAccessibleBackground(Beatmap.Value);
+
+            protected override UserDimContainer CreateStoryboardContainer()
+            {
+                return new TestUserDimContainer(true)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 1,
+                    EnableUserDim = { Value = true }
+                };
+            }
+
+            public UserDimContainer CurrentStoryboardContainer => StoryboardContainer;
+
+            // Whether or not the player should be allowed to load.
+            public bool BlockLoad;
+
+            public Bindable<bool> StoryboardEnabled;
+            public readonly Bindable<bool> ReplacesBackground = new Bindable<bool>();
+            public readonly Bindable<bool> IsPaused = new Bindable<bool>();
+
+            public TestPlayer(bool allowPause = true)
+                : base(allowPause)
+            {
+            }
+
+            public bool IsStoryboardVisible() => ((TestUserDimContainer)CurrentStoryboardContainer).CurrentAlpha == 1;
+
+            public bool IsStoryboardInvisible() => ((TestUserDimContainer)CurrentStoryboardContainer).CurrentAlpha <= 1;
+
+            [BackgroundDependencyLoader]
+            private void load(OsuConfigManager config, CancellationToken token)
+            {
+                while (BlockLoad && !token.IsCancellationRequested)
+                    Thread.Sleep(1);
+
+                StoryboardEnabled = config.GetBindable<bool>(OsuSetting.ShowStoryboard);
+                ReplacesBackground.BindTo(Background.StoryboardReplacesBackground);
+                DrawableRuleset.IsPaused.BindTo(IsPaused);
+            }
+        }
+
+        private class TestPlayerLoader : PlayerLoader
+        {
+            public VisualSettings VisualSettingsPos => VisualSettings;
+            public BackgroundScreen ScreenPos => Background;
+
+            public TestPlayerLoader(Player player)
+                : base(() => player)
+            {
+            }
+
+            public void TriggerOnHover() => OnHover(new HoverEvent(new InputState()));
+
+            public bool IsBlurCorrect() => ((FadeAccessibleBackground)Background).CurrentBlur == new Vector2(BACKGROUND_BLUR);
+
+            protected override BackgroundScreen CreateBackground() => new FadeAccessibleBackground(Beatmap.Value);
+        }
+
+        private class FadeAccessibleBackground : BackgroundScreenBeatmap
+        {
+            protected override UserDimContainer CreateFadeContainer() => fadeContainer = new TestUserDimContainer { RelativeSizeAxes = Axes.Both };
+
+            public Color4 CurrentColour => fadeContainer.CurrentColour;
+
+            public float CurrentAlpha => fadeContainer.CurrentAlpha;
+
+            public Vector2 CurrentBlur => Background.BlurSigma;
+
+            private TestUserDimContainer fadeContainer;
+
+            public FadeAccessibleBackground(WorkingBeatmap beatmap)
+                : base(beatmap)
+            {
+            }
+        }
+
+        private class TestUserDimContainer : UserDimContainer
+        {
+            public Color4 CurrentColour => DimContainer.Colour;
+            public float CurrentAlpha => DimContainer.Alpha;
+
+            public TestUserDimContainer(bool isStoryboard = false)
+                : base(isStoryboard)
+            {
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Components/TestCaseIdleTracker.cs

@@ -0,0 +1,135 @@
+// 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.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Input;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Components
+{
+    [TestFixture]
+    public class TestCaseIdleTracker : ManualInputManagerTestCase
+    {
+        private readonly IdleTrackingBox box1;
+        private readonly IdleTrackingBox box2;
+        private readonly IdleTrackingBox box3;
+        private readonly IdleTrackingBox box4;
+
+        public TestCaseIdleTracker()
+        {
+            Children = new Drawable[]
+            {
+                box1 = new IdleTrackingBox(1000)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Red,
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopLeft,
+                },
+                box2 = new IdleTrackingBox(2000)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Green,
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                },
+                box3 = new IdleTrackingBox(3000)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Blue,
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                },
+                box4 = new IdleTrackingBox(4000)
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.Orange,
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                },
+            };
+        }
+
+        [Test]
+        public void TestNudge()
+        {
+            AddStep("move mouse to top left", () => InputManager.MoveMouseTo(box1.ScreenSpaceDrawQuad.Centre));
+
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
+
+            AddStep("nudge mouse", () => InputManager.MoveMouseTo(box1.ScreenSpaceDrawQuad.Centre + new Vector2(1)));
+
+            AddAssert("check not idle", () => !box1.IsIdle);
+            AddAssert("check idle", () => box2.IsIdle);
+            AddAssert("check idle", () => box3.IsIdle);
+            AddAssert("check idle", () => box4.IsIdle);
+        }
+
+        [Test]
+        public void TestMovement()
+        {
+            AddStep("move mouse", () => InputManager.MoveMouseTo(box2.ScreenSpaceDrawQuad.Centre));
+
+            AddAssert("check not idle", () => box1.IsIdle);
+            AddAssert("check not idle", () => !box2.IsIdle);
+            AddAssert("check idle", () => box3.IsIdle);
+            AddAssert("check idle", () => box4.IsIdle);
+
+            AddStep("move mouse", () => InputManager.MoveMouseTo(box3.ScreenSpaceDrawQuad.Centre));
+            AddStep("move mouse", () => InputManager.MoveMouseTo(box4.ScreenSpaceDrawQuad.Centre));
+
+            AddAssert("check not idle", () => box1.IsIdle);
+            AddAssert("check not idle", () => !box2.IsIdle);
+            AddAssert("check idle", () => !box3.IsIdle);
+            AddAssert("check idle", () => !box4.IsIdle);
+
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
+        }
+
+        [Test]
+        public void TestTimings()
+        {
+            AddStep("move mouse", () => InputManager.MoveMouseTo(ScreenSpaceDrawQuad.Centre));
+
+            AddAssert("check not idle", () => !box1.IsIdle && !box2.IsIdle && !box3.IsIdle && !box4.IsIdle);
+            AddUntilStep("Wait for idle", () => box1.IsIdle);
+            AddAssert("check not idle", () => !box2.IsIdle && !box3.IsIdle && !box4.IsIdle);
+            AddUntilStep("Wait for idle", () => box2.IsIdle);
+            AddAssert("check not idle", () => !box3.IsIdle && !box4.IsIdle);
+            AddUntilStep("Wait for idle", () => box3.IsIdle);
+
+            AddUntilStep("Wait for all idle", () => box1.IsIdle && box2.IsIdle && box3.IsIdle && box4.IsIdle);
+        }
+
+        private class IdleTrackingBox : CompositeDrawable
+        {
+            private readonly IdleTracker idleTracker;
+
+            public bool IsIdle => idleTracker.IsIdle.Value;
+
+            public IdleTrackingBox(double timeToIdle)
+            {
+                Box box;
+
+                Alpha = 0.6f;
+                Scale = new Vector2(0.6f);
+
+                InternalChildren = new Drawable[]
+                {
+                    idleTracker = new IdleTracker(timeToIdle),
+                    box = new Box
+                    {
+                        Colour = Color4.White,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                };
+
+                idleTracker.IsIdle.BindValueChanged(idle => box.Colour = idle.NewValue ? Color4.White : Color4.Black, true);
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Components/TestCasePollingComponent.cs

@@ -0,0 +1,147 @@
+// 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 System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Logging;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Online;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Components
+{
+    public class TestCasePollingComponent : OsuTestCase
+    {
+        private Container pollBox;
+        private TestPoller poller;
+
+        private const float safety_adjust = 1f;
+        private int count;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            count = 0;
+
+            Children = new Drawable[]
+            {
+                pollBox = new Container
+                {
+                    Alpha = 0,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Scale = new Vector2(0.4f),
+                            Colour = Color4.LimeGreen,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Text = "Poll!",
+                        }
+                    }
+                }
+            };
+        });
+
+        [Test]
+        [Ignore("polling is threaded, and it's very hard to hook into it correctly")]
+        public void TestInstantPolling()
+        {
+            createPoller(true);
+
+            AddStep("set poll interval to 1", () => poller.TimeBetweenPolls = TimePerAction * safety_adjust);
+            checkCount(1);
+            checkCount(2);
+            checkCount(3);
+
+            AddStep("set poll interval to 5", () => poller.TimeBetweenPolls = TimePerAction * safety_adjust * 5);
+            checkCount(4);
+            checkCount(4);
+            checkCount(4);
+
+            skip();
+
+            checkCount(5);
+            checkCount(5);
+
+            AddStep("set poll interval to 1", () => poller.TimeBetweenPolls = TimePerAction * safety_adjust);
+            checkCount(6);
+            checkCount(7);
+        }
+
+        [Test]
+        [Ignore("i have no idea how to fix the timing of this one")]
+        public void TestSlowPolling()
+        {
+            createPoller(false);
+
+            AddStep("set poll interval to 1", () => poller.TimeBetweenPolls = TimePerAction * safety_adjust * 5);
+            checkCount(0);
+            skip();
+            checkCount(0);
+            skip();
+            skip();
+            checkCount(0);
+            skip();
+            skip();
+            checkCount(0);
+        }
+
+        private void skip() => AddStep("skip", () =>
+        {
+            // could be 4 or 5 at this point due to timing discrepancies (safety_adjust @ 0.2 * 5 ~= 1)
+            // easiest to just ignore the value at this point and move on.
+        });
+
+        private void checkCount(int checkValue)
+        {
+            AddAssert($"count is {checkValue}", () =>
+            {
+                Logger.Log($"value is {count}");
+                return count == checkValue;
+            });
+        }
+
+        private void createPoller(bool instant) => AddStep("create poller", () =>
+        {
+            poller?.Expire();
+
+            Add(poller = instant ? new TestPoller() : new TestSlowPoller());
+            poller.OnPoll += () =>
+            {
+                pollBox.FadeOutFromOne(500);
+                count++;
+            };
+        });
+
+        protected override double TimePerAction => 500;
+
+        public class TestPoller : PollingComponent
+        {
+            public event Action OnPoll;
+
+            protected override Task Poll()
+            {
+                Schedule(() => OnPoll?.Invoke());
+                return base.Poll();
+            }
+        }
+
+        public class TestSlowPoller : TestPoller
+        {
+            protected override Task Poll() => Task.Delay((int)(TimeBetweenPolls / 2f / Clock.Rate)).ContinueWith(_ => base.Poll());
+        }
+    }
+}

osu.Game.Tests/Visual/Components/TestCasePreviewTrackManager.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Allocation;
@@ -8,7 +8,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Components
 {
     public class TestCasePreviewTrackManager : OsuTestCase, IPreviewTrackOwner
     {

osu.Game.Tests/Visual/Editor/TestCaseBeatDivisorControl.cs

@@ -1,14 +1,15 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Screens.Edit.Screens.Compose;
-using OpenTK;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     public class TestCaseBeatDivisorControl : OsuTestCase
     {

osu.Game.Tests/Visual/Editor/TestCaseEditorCompose.cs

@@ -1,26 +1,26 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Screens.Edit.Screens.Compose;
+using osu.Game.Screens.Edit.Compose;
 using osu.Game.Tests.Beatmaps;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorCompose : EditorClockTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(Compose) };
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(ComposeScreen) };
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            Beatmap.Value = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo);
-            Child = new Compose();
+            Beatmap.Value = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo, Clock);
+            Child = new ComposeScreen();
         }
     }
 }

osu.Game.Tests/Visual/Editor/TestCaseEditorComposeRadioButtons.cs

@@ -1,13 +1,13 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Graphics;
-using osu.Game.Screens.Edit.Screens.Compose.RadioButtons;
+using osu.Game.Screens.Edit.Components.RadioButtons;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorComposeRadioButtons : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorComposeTimeline.cs

@@ -1,22 +1,22 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
-using OpenTK;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
-using osu.Game.Screens.Edit.Screens.Compose.Timeline;
-using OpenTK.Graphics;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorComposeTimeline : EditorClockTestCase
@@ -85,7 +85,7 @@ namespace osu.Game.Tests.Visual
             }
 
             [BackgroundDependencyLoader]
-            private void load(IAdjustableClock adjustableClock, IBindableBeatmap beatmap)
+            private void load(IAdjustableClock adjustableClock, IBindable<WorkingBeatmap> beatmap)
             {
                 this.adjustableClock = adjustableClock;
                 this.beatmap.BindTo(beatmap);

osu.Game.Tests/Visual/Editor/TestCaseEditorMenuBar.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -8,9 +8,9 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Screens.Edit.Menus;
+using osu.Game.Screens.Edit.Components.Menus;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorMenuBar : OsuTestCase

osu.Game.Tests/Visual/Editor/TestCaseEditorSeekSnapping.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Allocation;
@@ -11,10 +11,10 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorSeekSnapping : EditorClockTestCase
@@ -33,7 +33,7 @@ namespace osu.Game.Tests.Visual
                 {
                     TimingPoints =
                     {
-                        new TimingControlPoint { Time = 0, BeatLength = 200},
+                        new TimingControlPoint { Time = 0, BeatLength = 200 },
                         new TimingControlPoint { Time = 100, BeatLength = 400 },
                         new TimingControlPoint { Time = 175, BeatLength = 800 },
                         new TimingControlPoint { Time = 350, BeatLength = 200 },
@@ -48,7 +48,7 @@ namespace osu.Game.Tests.Visual
                 }
             };
 
-            Beatmap.Value = new TestWorkingBeatmap(testBeatmap);
+            Beatmap.Value = new TestWorkingBeatmap(testBeatmap, Clock);
 
             Child = new TimingPointVisualiser(testBeatmap, 5000) { Clock = Clock };
         }

osu.Game.Tests/Visual/Editor/TestCaseEditorSummaryTimeline.cs

@@ -1,17 +1,17 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using OpenTK;
-using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Game.Tests.Beatmaps;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseEditorSummaryTimeline : EditorClockTestCase
@@ -21,7 +21,7 @@ namespace osu.Game.Tests.Visual
         [BackgroundDependencyLoader]
         private void load()
         {
-            Beatmap.Value = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo);
+            Beatmap.Value = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo, null);
 
             Add(new SummaryTimeline
             {

osu.Game.Tests/Visual/Editor/TestCaseHitObjectComposer.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -7,31 +7,41 @@ using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Timing;
-using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Screens.Edit.Screens.Compose.Layers;
+using osu.Game.Screens.Edit.Compose;
+using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Tests.Beatmaps;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
-    public class TestCaseHitObjectComposer : OsuTestCase
+    [Cached(Type = typeof(IPlacementHandler))]
+    public class TestCaseHitObjectComposer : OsuTestCase, IPlacementHandler
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(MaskSelection),
-            typeof(DragLayer),
+            typeof(SelectionHandler),
+            typeof(DragBox),
             typeof(HitObjectComposer),
             typeof(OsuHitObjectComposer),
-            typeof(HitObjectMaskLayer),
-            typeof(NotNullAttribute)
+            typeof(BlueprintContainer),
+            typeof(NotNullAttribute),
+            typeof(HitCirclePiece),
+            typeof(HitCircleSelectionBlueprint),
+            typeof(HitCirclePlacementBlueprint),
         };
 
+        private HitObjectComposer composer;
+
         [BackgroundDependencyLoader]
         private void load()
         {
@@ -44,14 +54,11 @@ namespace osu.Game.Tests.Visual
                     new Slider
                     {
                         Position = new Vector2(128, 256),
-                        ControlPoints = new[]
+                        Path = new SliderPath(PathType.Linear, new[]
                         {
                             Vector2.Zero,
                             new Vector2(216, 0),
-                        },
-                        Distance = 400,
-                        Velocity = 1,
-                        TickDistance = 100,
+                        }),
                         Scale = 0.5f,
                     }
                 },
@@ -61,7 +68,15 @@ namespace osu.Game.Tests.Visual
             Dependencies.CacheAs<IAdjustableClock>(clock);
             Dependencies.CacheAs<IFrameBasedClock>(clock);
 
-            Child = new OsuHitObjectComposer(new OsuRuleset());
+            Child = composer = new OsuHitObjectComposer(new OsuRuleset());
         }
+
+        public void BeginPlacement(HitObject hitObject)
+        {
+        }
+
+        public void EndPlacement(HitObject hitObject) => composer.Add(hitObject);
+
+        public void Delete(HitObject hitObject) => composer.Remove(hitObject);
     }
 }

osu.Game.Tests/Visual/Editor/TestCasePlaybackControl.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Allocation;
@@ -8,9 +8,9 @@ using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Tests.Beatmaps;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCasePlaybackControl : OsuTestCase
@@ -26,10 +26,10 @@ namespace osu.Game.Tests.Visual
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                Size = new Vector2(200,100)
+                Size = new Vector2(200, 100)
             };
 
-            Beatmap.Value = new TestWorkingBeatmap(new Beatmap());
+            Beatmap.Value = new TestWorkingBeatmap(new Beatmap(), Clock);
 
             Child = playback;
         }

osu.Game.Tests/Visual/Editor/TestCaseWaveContainer.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Allocation;
@@ -9,10 +9,10 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
     public class TestCaseWaveContainer : OsuTestCase
@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Visual
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        TextSize = 20,
+                        Font = OsuFont.GetFont(size: 20),
                         Text = @"Wave Container",
                     },
                 },

osu.Game.Tests/Visual/Editor/TestCaseWaveform.cs

@@ -0,0 +1,107 @@
+// 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.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Editor
+{
+    [TestFixture]
+    public class TestCaseWaveform : OsuTestCase
+    {
+        private WorkingBeatmap waveformBeatmap;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            waveformBeatmap = new WaveformTestBeatmap();
+        }
+
+        [TestCase(1f)]
+        [TestCase(1f / 2)]
+        [TestCase(1f / 4)]
+        [TestCase(1f / 8)]
+        [TestCase(1f / 16)]
+        [TestCase(0f)]
+        public void TestResolution(float resolution)
+        {
+            TestWaveformGraph graph = null;
+
+            AddStep("add graph", () =>
+            {
+                Child = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 100,
+                    Children = new Drawable[]
+                    {
+                        graph = new TestWaveformGraph
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Resolution = resolution,
+                            Waveform = waveformBeatmap.Waveform,
+                        },
+                        new Container
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            AutoSizeAxes = Axes.Both,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.Black,
+                                    Alpha = 0.75f
+                                },
+                                new OsuSpriteText
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Text = $"Resolution: {resolution:0.00}"
+                                }
+                            }
+                        }
+                    }
+                };
+            });
+
+            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+        }
+
+        [Test]
+        public void TestDefaultBeatmap()
+        {
+            TestWaveformGraph graph = null;
+
+            AddStep("add graph", () =>
+            {
+                Child = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = 100,
+                    Child = graph = new TestWaveformGraph
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Waveform = new DummyWorkingBeatmap().Waveform,
+                    },
+                };
+            });
+
+            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+        }
+
+        public class TestWaveformGraph : WaveformGraph
+        {
+            public new Waveform ResampledWaveform => base.ResampledWaveform;
+        }
+    }
+}

osu.Game.Tests/Visual/Editor/TestCaseZoomableScrollContainer.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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;
@@ -8,48 +8,60 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
+using osu.Framework.Testing;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Cursor;
-using osu.Game.Screens.Edit.Screens.Compose.Timeline;
-using OpenTK;
-using OpenTK.Graphics;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Editor
 {
     public class TestCaseZoomableScrollContainer : ManualInputManagerTestCase
     {
-        private readonly ZoomableScrollContainer scrollContainer;
-        private readonly Drawable innerBox;
+        private ZoomableScrollContainer scrollContainer;
+        private Drawable innerBox;
 
-        public TestCaseZoomableScrollContainer()
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            Children = new Drawable[]
+            AddStep("Add new scroll container", () =>
             {
-                new Container
+                Children = new Drawable[]
                 {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    RelativeSizeAxes = Axes.X,
-                    Height = 250,
-                    Width = 0.75f,
-                    Children = new Drawable[]
+                    new Container
                     {
-                        new Box
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.X,
+                        Height = 250,
+                        Width = 0.75f,
+                        Children = new Drawable[]
                         {
-                            RelativeSizeAxes = Axes.Both,
-                            Colour = OsuColour.Gray(30)
-                        },
-                        scrollContainer = new ZoomableScrollContainer { RelativeSizeAxes = Axes.Both }
-                    }
-                },
-                new MenuCursor()
-            };
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = OsuColour.Gray(30)
+                            },
+                            scrollContainer = new ZoomableScrollContainer { RelativeSizeAxes = Axes.Both }
+                        }
+                    },
+                    new MenuCursor()
+                };
 
-            scrollContainer.Add(innerBox = new Box
-            {
-                RelativeSizeAxes = Axes.Both,
-                Colour = ColourInfo.GradientHorizontal(new Color4(0.8f, 0.6f, 0.4f, 1f), new Color4(0.4f, 0.6f, 0.8f, 1f))
+                scrollContainer.Add(innerBox = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = ColourInfo.GradientHorizontal(new Color4(0.8f, 0.6f, 0.4f, 1f), new Color4(0.4f, 0.6f, 0.8f, 1f))
+                });
             });
+            AddUntilStep("Scroll container is loaded", () => scrollContainer.LoadState >= LoadState.Loaded);
+        }
+
+        [Test]
+        public void TestWidthInitialization()
+        {
+            AddAssert("Inner container width was initialized", () => innerBox.DrawWidth > 0);
         }
 
         [Test]

osu.Game.Tests/Visual/Gameplay/TestCaseAutoplay.cs

@@ -0,0 +1,38 @@
+// 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.ComponentModel;
+using System.Linq;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [Description("Player instantiated with an autoplay mod.")]
+    public class TestCaseAutoplay : AllPlayersTestCase
+    {
+        protected override Player CreatePlayer(Ruleset ruleset)
+        {
+            Mods.Value = Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() }).ToArray();
+            return new ScoreAccessiblePlayer();
+        }
+
+        protected override void AddCheckSteps()
+        {
+            AddUntilStep("score above zero", () => ((ScoreAccessiblePlayer)Player).ScoreProcessor.TotalScore.Value > 0);
+            AddUntilStep("key counter counted keys", () => ((ScoreAccessiblePlayer)Player).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0));
+        }
+
+        private class ScoreAccessiblePlayer : TestPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            public ScoreAccessiblePlayer()
+                : base(false, false)
+            {
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCaseBreakOverlay.cs

@@ -1,12 +1,12 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Game.Beatmaps.Timing;
 using System.Collections.Generic;
 using NUnit.Framework;
+using osu.Game.Beatmaps.Timing;
 using osu.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseBreakOverlay : OsuTestCase

osu.Game.Tests/Visual/Gameplay/TestCaseFrameStabilityContainer.cs

@@ -0,0 +1,174 @@
+// 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.Containers;
+using osu.Framework.Timing;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCaseFrameStabilityContainer : OsuTestCase
+    {
+        private readonly ManualClock manualClock;
+
+        private readonly Container mainContainer;
+
+        private ClockConsumingChild consumer;
+
+        public TestCaseFrameStabilityContainer()
+        {
+            Child = mainContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Clock = new FramedClock(manualClock = new ManualClock()),
+            };
+        }
+
+        [Test]
+        public void TestLargeJumps()
+        {
+            seekManualTo(0);
+            createStabilityContainer();
+            seekManualTo(100000);
+
+            confirmSeek(100000);
+            checkFrameCount(6000);
+
+            seekManualTo(0);
+
+            confirmSeek(0);
+            checkFrameCount(12000);
+        }
+
+        [Test]
+        public void TestSmallJumps()
+        {
+            seekManualTo(0);
+            createStabilityContainer();
+            seekManualTo(40);
+
+            confirmSeek(40);
+            checkFrameCount(3);
+
+            seekManualTo(0);
+
+            confirmSeek(0);
+            checkFrameCount(6);
+        }
+
+        [Test]
+        public void TestSingleFrameJump()
+        {
+            seekManualTo(0);
+            createStabilityContainer();
+            seekManualTo(8);
+            confirmSeek(8);
+            checkFrameCount(1);
+
+            seekManualTo(16);
+            confirmSeek(16);
+            checkFrameCount(2);
+        }
+
+        [Test]
+        public void TestInitialSeekWithGameplayStart()
+        {
+            seekManualTo(1000);
+            createStabilityContainer(30000);
+
+            confirmSeek(1000);
+            checkFrameCount(0);
+
+            seekManualTo(10000);
+            confirmSeek(10000);
+
+            checkFrameCount(1);
+
+            seekManualTo(130000);
+            confirmSeek(130000);
+
+            checkFrameCount(6002);
+        }
+
+        [Test]
+        public void TestInitialSeek()
+        {
+            seekManualTo(100000);
+            createStabilityContainer();
+
+            confirmSeek(100000);
+            checkFrameCount(0);
+        }
+
+        private const int max_frames_catchup = 50;
+
+        private void createStabilityContainer(double gameplayStartTime = double.MinValue) => AddStep("create container", () =>
+            mainContainer.Child = new FrameStabilityContainer(gameplayStartTime) { MaxCatchUpFrames = max_frames_catchup }
+                .WithChild(consumer = new ClockConsumingChild()));
+
+        private void seekManualTo(double time) => AddStep($"seek manual clock to {time}", () => manualClock.CurrentTime = time);
+
+        private void confirmSeek(double time) => AddUntilStep($"wait for seek to {time}", () => consumer.Clock.CurrentTime == time);
+
+        private void checkFrameCount(int frames) =>
+            AddAssert($"elapsed frames is {frames}", () => consumer.ElapsedFrames == frames);
+
+        public class ClockConsumingChild : CompositeDrawable
+        {
+            private readonly OsuSpriteText text;
+            private readonly OsuSpriteText text2;
+            private readonly OsuSpriteText text3;
+
+            public ClockConsumingChild()
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    new FillFlowContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Direction = FillDirection.Vertical,
+                        Children = new Drawable[]
+                        {
+                            text = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                            text2 = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                            text3 = new OsuSpriteText
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                            },
+                        }
+                    },
+                };
+            }
+
+            public int ElapsedFrames;
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (Clock.ElapsedFrameTime != 0)
+                    ElapsedFrames++;
+
+                text.Text = $"current time: {Clock.CurrentTime:F0}";
+                if (Clock.ElapsedFrameTime != 0)
+                    text2.Text = $"last elapsed frame time: {Clock.ElapsedFrameTime:F0}";
+                text3.Text = $"total frames: {ElapsedFrames:F0}";
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCaseGameplayMenuOverlay.cs

@@ -1,42 +1,52 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
-using OpenTK.Input;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
+using osu.Game.Input.Bindings;
 using osu.Game.Screens.Play;
-using OpenTK;
+using osuTK;
+using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("player pause/fail screens")]
     public class TestCaseGameplayMenuOverlay : ManualInputManagerTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseContainer) };
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseOverlay) };
 
         private FailOverlay failOverlay;
-        private PauseContainer.PauseOverlay pauseOverlay;
+        private PauseOverlay pauseOverlay;
+
+        private GlobalActionContainer globalActionContainer;
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(OsuGameBase game)
         {
-            Add(pauseOverlay = new PauseContainer.PauseOverlay
+            Child = globalActionContainer = new GlobalActionContainer(game)
             {
-                OnResume = () => Logger.Log(@"Resume"),
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
+                Children = new Drawable[]
+                {
+                    pauseOverlay = new PauseOverlay
+                    {
+                        OnResume = () => Logger.Log(@"Resume"),
+                        OnRetry = () => Logger.Log(@"Retry"),
+                        OnQuit = () => Logger.Log(@"Quit"),
+                    },
+                    failOverlay = new FailOverlay
 
-            Add(failOverlay = new FailOverlay
-            {
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
+                    {
+                        OnRetry = () => Logger.Log(@"Retry"),
+                        OnQuit = () => Logger.Log(@"Quit"),
+                    }
+                }
+            };
 
             var retryCount = 0;
 
@@ -76,13 +86,7 @@ namespace osu.Game.Tests.Visual
             AddStep("Hover first button", () => InputManager.MoveMouseTo(failOverlay.Buttons.First()));
             AddStep("Hide overlay", () => failOverlay.Hide());
 
-            AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected));
-        }
-
-        private void press(Key key)
-        {
-            InputManager.PressKey(key);
-            InputManager.ReleaseKey(key);
+            AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected.Value));
         }
 
         /// <summary>
@@ -92,7 +96,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => pauseOverlay.Show());
 
-            AddStep("Press enter", () => press(Key.Enter));
+            AddStep("Press select", () => press(GlobalAction.Select));
             AddAssert("Overlay still open", () => pauseOverlay.State == Visibility.Visible);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
@@ -106,7 +110,7 @@ namespace osu.Game.Tests.Visual
             AddStep("Show overlay", () => pauseOverlay.Show());
 
             AddStep("Up arrow", () => press(Key.Up));
-            AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected);
+            AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected.Value);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
         }
@@ -119,7 +123,7 @@ namespace osu.Game.Tests.Visual
             AddStep("Show overlay", () => pauseOverlay.Show());
 
             AddStep("Down arrow", () => press(Key.Down));
-            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected.Value);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
         }
@@ -132,11 +136,11 @@ namespace osu.Game.Tests.Visual
             AddStep("Show overlay", () => failOverlay.Show());
 
             AddStep("Up arrow", () => press(Key.Up));
-            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
             AddStep("Up arrow", () => press(Key.Up));
-            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
             AddStep("Up arrow", () => press(Key.Up));
-            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
 
             AddStep("Hide overlay", () => failOverlay.Hide());
         }
@@ -149,11 +153,11 @@ namespace osu.Game.Tests.Visual
             AddStep("Show overlay", () => failOverlay.Show());
 
             AddStep("Down arrow", () => press(Key.Down));
-            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
             AddStep("Down arrow", () => press(Key.Down));
-            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected.Value);
             AddStep("Down arrow", () => press(Key.Down));
-            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected.Value);
 
             AddStep("Hide overlay", () => failOverlay.Hide());
         }
@@ -169,8 +173,8 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Down arrow", () => press(Key.Down));
             AddStep("Hover second button", () => InputManager.MoveMouseTo(secondButton));
-            AddAssert("First button not selected", () => !pauseOverlay.Buttons.First().Selected);
-            AddAssert("Second button selected", () => secondButton.Selected);
+            AddAssert("First button not selected", () => !pauseOverlay.Buttons.First().Selected.Value);
+            AddAssert("Second button selected", () => secondButton.Selected.Value);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
         }
@@ -190,8 +194,8 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Hover second button", () => InputManager.MoveMouseTo(secondButton));
             AddStep("Up arrow", () => press(Key.Up));
-            AddAssert("Second button not selected", () => !secondButton.Selected);
-            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
+            AddAssert("Second button not selected", () => !secondButton.Selected.Value);
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected.Value);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
         }
@@ -208,7 +212,7 @@ namespace osu.Game.Tests.Visual
             AddStep("Hover second button", () => InputManager.MoveMouseTo(secondButton));
             AddStep("Unhover second button", () => InputManager.MoveMouseTo(Vector2.Zero));
             AddStep("Down arrow", () => press(Key.Down));
-            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected); // Initial state condition
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected.Value); // Initial state condition
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
         }
@@ -265,9 +269,22 @@ namespace osu.Game.Tests.Visual
                     pauseOverlay.OnRetry = lastAction;
                     lastAction = null;
                 }
+
                 return triggered;
             });
             AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
         }
+
+        private void press(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
+
+        private void press(GlobalAction action)
+        {
+            globalActionContainer.TriggerPressed(action);
+            globalActionContainer.TriggerReleased(action);
+        }
     }
 }

osu.Game.Tests/Visual/Gameplay/TestCaseHoldForMenuButton.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Linq;
 using NUnit.Framework;
@@ -7,39 +7,39 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Screens.Play.HUD;
-using OpenTK;
-using OpenTK.Input;
+using osuTK;
+using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [Description("'Hold to Quit' UI element")]
-    public class TestCaseQuitButton : ManualInputManagerTestCase
+    public class TestCaseHoldForMenuButton : ManualInputManagerTestCase
     {
         private bool exitAction;
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            QuitButton quitButton;
+            HoldForMenuButton holdForMenuButton;
 
-            Add(quitButton = new QuitButton
+            Add(holdForMenuButton = new HoldForMenuButton
             {
                 Origin = Anchor.BottomRight,
                 Anchor = Anchor.BottomRight,
                 Action = () => exitAction = true
             });
 
-            var text = quitButton.Children.OfType<SpriteText>().First();
+            var text = holdForMenuButton.Children.OfType<SpriteText>().First();
 
-            AddStep("Trigger text fade in", () => InputManager.MoveMouseTo(quitButton));
-            AddUntilStep(() => text.IsPresent && !exitAction, "Text visible");
+            AddStep("Trigger text fade in", () => InputManager.MoveMouseTo(holdForMenuButton));
+            AddUntilStep("Text visible", () => text.IsPresent && !exitAction);
             AddStep("Trigger text fade out", () => InputManager.MoveMouseTo(Vector2.One));
-            AddUntilStep(() => !text.IsPresent && !exitAction, "Text is not visible");
+            AddUntilStep("Text is not visible", () => !text.IsPresent && !exitAction);
 
             AddStep("Trigger exit action", () =>
             {
                 exitAction = false;
-                InputManager.MoveMouseTo(quitButton);
+                InputManager.MoveMouseTo(holdForMenuButton);
                 InputManager.PressButton(MouseButton.Left);
             });
 
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("action not triggered", () => !exitAction);
 
             AddStep("Trigger exit action", () => InputManager.PressButton(MouseButton.Left));
-            AddUntilStep(() => exitAction, $"{nameof(quitButton.Action)} was triggered");
+            AddUntilStep($"{nameof(holdForMenuButton.Action)} was triggered", () => exitAction);
         }
     }
 }

osu.Game.Tests/Visual/Gameplay/TestCaseKeyCounter.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -9,9 +9,9 @@ using osu.Framework.Graphics;
 using osu.Framework.MathUtils;
 using osu.Framework.Timing;
 using osu.Game.Screens.Play;
-using OpenTK.Input;
+using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseKeyCounter : ManualInputManagerTestCase
@@ -20,13 +20,13 @@ namespace osu.Game.Tests.Visual
         {
             typeof(KeyCounterKeyboard),
             typeof(KeyCounterMouse),
-            typeof(KeyCounterCollection)
+            typeof(KeyCounterDisplay)
         };
 
         public TestCaseKeyCounter()
         {
             KeyCounterKeyboard rewindTestKeyCounterKeyboard;
-            KeyCounterCollection kc = new KeyCounterCollection
+            KeyCounterDisplay kc = new KeyCounterDisplay
             {
                 Origin = Anchor.Centre,
                 Anchor = Anchor.Centre,
@@ -39,7 +39,6 @@ namespace osu.Game.Tests.Visual
                 },
             };
 
-
             AddStep("Add random", () =>
             {
                 Key key = (Key)((int)Key.A + RNG.Next(26));

osu.Game.Tests/Visual/Gameplay/TestCaseMedalOverlay.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -8,7 +8,7 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.MedalSplash;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseMedalOverlay : OsuTestCase

osu.Game.Tests/Visual/Gameplay/TestCasePause.cs

@@ -0,0 +1,217 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCasePause : PlayerTestCase
+    {
+        protected new PausePlayer Player => (PausePlayer)base.Player;
+
+        private readonly Container content;
+
+        protected override Container<Drawable> Content => content;
+
+        public TestCasePause()
+            : base(new OsuRuleset())
+        {
+            base.Content.Add(content = new MenuCursorContainer { RelativeSizeAxes = Axes.Both });
+        }
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("resume player", () => Player.GameplayClockContainer.Start());
+            confirmClockRunning(true);
+        }
+
+        [Test]
+        public void TestPauseResume()
+        {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+            pauseAndConfirm();
+            resumeAndConfirm();
+        }
+
+        [Test]
+        public void TestResumeWithResumeOverlay()
+        {
+            AddStep("move cursor to center", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for hitobjects", () => Player.ScoreProcessor.Health.Value < 1);
+
+            pauseAndConfirm();
+            resume();
+
+            confirmClockRunning(false);
+            confirmPauseOverlayShown(false);
+
+            AddStep("click to resume", () =>
+            {
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+
+            confirmClockRunning(true);
+        }
+
+        [Test]
+        public void TestResumeWithResumeOverlaySkipped()
+        {
+            AddStep("move cursor to button", () =>
+                InputManager.MoveMouseTo(Player.HUDOverlay.HoldToQuit.Children.OfType<HoldToConfirmContainer>().First().ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for hitobjects", () => Player.ScoreProcessor.Health.Value < 1);
+
+            pauseAndConfirm();
+            resumeAndConfirm();
+        }
+
+        [Test]
+        public void TestPauseTooSoon()
+        {
+            AddStep("move cursor outside", () => InputManager.MoveMouseTo(Player.ScreenSpaceDrawQuad.TopLeft - new Vector2(10)));
+
+            pauseAndConfirm();
+            resumeAndConfirm();
+
+            pause();
+
+            confirmClockRunning(true);
+            confirmPauseOverlayShown(false);
+        }
+
+        [Test]
+        public void TestExitTooSoon()
+        {
+            pauseAndConfirm();
+
+            resume();
+
+            AddStep("exit too soon", () => Player.Exit());
+
+            confirmClockRunning(true);
+            confirmPauseOverlayShown(false);
+
+            AddAssert("not exited", () => Player.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestPauseAfterFail()
+        {
+            AddUntilStep("wait for fail", () => Player.HasFailed);
+            AddAssert("fail overlay shown", () => Player.FailOverlayVisible);
+
+            confirmClockRunning(false);
+
+            pause();
+
+            confirmClockRunning(false);
+            confirmPauseOverlayShown(false);
+
+            AddAssert("fail overlay still shown", () => Player.FailOverlayVisible);
+
+            exitAndConfirm();
+        }
+
+        [Test]
+        public void TestExitFromGameplay()
+        {
+            AddStep("exit", () => Player.Exit());
+
+            confirmPaused();
+
+            exitAndConfirm();
+        }
+
+        [Test]
+        public void TestExitFromPause()
+        {
+            pauseAndConfirm();
+            exitAndConfirm();
+        }
+
+        private void pauseAndConfirm()
+        {
+            pause();
+            confirmPaused();
+        }
+
+        private void resumeAndConfirm()
+        {
+            resume();
+            confirmResumed();
+        }
+
+        private void exitAndConfirm()
+        {
+            AddUntilStep("player not exited", () => Player.IsCurrentScreen());
+            AddStep("exit", () => Player.Exit());
+            confirmExited();
+        }
+
+        private void confirmPaused()
+        {
+            confirmClockRunning(false);
+            AddAssert("player not exited", () => Player.IsCurrentScreen());
+            AddAssert("player not failed", () => !Player.HasFailed);
+            AddAssert("pause overlay shown", () => Player.PauseOverlayVisible);
+        }
+
+        private void confirmResumed()
+        {
+            confirmClockRunning(true);
+            confirmPauseOverlayShown(false);
+        }
+
+        private void confirmExited()
+        {
+            AddUntilStep("player exited", () => !Player.IsCurrentScreen());
+        }
+
+        private void pause() => AddStep("pause", () => Player.Pause());
+        private void resume() => AddStep("resume", () => Player.Resume());
+
+        private void confirmPauseOverlayShown(bool isShown) =>
+            AddAssert("pause overlay " + (isShown ? "shown" : "hidden"), () => Player.PauseOverlayVisible == isShown);
+
+        private void confirmClockRunning(bool isRunning) =>
+            AddAssert("clock " + (isRunning ? "running" : "stopped"), () => Player.GameplayClockContainer.GameplayClock.IsRunning == isRunning);
+
+        protected override bool AllowFail => true;
+
+        protected override Player CreatePlayer(Ruleset ruleset) => new PausePlayer();
+
+        protected class PausePlayer : TestPlayer
+        {
+            public new GameplayClockContainer GameplayClockContainer => base.GameplayClockContainer;
+
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            public bool FailOverlayVisible => FailOverlay.State == Visibility.Visible;
+
+            public bool PauseOverlayVisible => PauseOverlay.State == Visibility.Visible;
+
+            public override void OnEntering(IScreen last)
+            {
+                base.OnEntering(last);
+                GameplayClockContainer.Stop();
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCasePlayerLoader.cs

@@ -0,0 +1,132 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCasePlayerLoader : ManualInputManagerTestCase
+    {
+        private PlayerLoader loader;
+        private OsuScreenStack stack;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            InputManager.Child = stack = new OsuScreenStack { RelativeSizeAxes = Axes.Both };
+            Beatmap.Value = new TestWorkingBeatmap(new TestBeatmap(new OsuRuleset().RulesetInfo), Clock);
+        });
+
+        [Test]
+        public void TestLoadContinuation()
+        {
+            Player player = null;
+            SlowLoadPlayer slowPlayer = null;
+
+            AddStep("load dummy beatmap", () => stack.Push(loader = new PlayerLoader(() => player = new TestPlayer(false, false))));
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
+            AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+            AddStep("load slow dummy beatmap", () =>
+            {
+                stack.Push(loader = new PlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
+                Scheduler.AddDelayed(() => slowPlayer.AllowLoad.Set(), 5000);
+            });
+
+            AddUntilStep("wait for player to be current", () => slowPlayer.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestModReinstantiation()
+        {
+            TestPlayer player = null;
+            TestMod gameMod = null;
+            TestMod playerMod1 = null;
+            TestMod playerMod2 = null;
+
+            AddStep("load player", () =>
+            {
+                Mods.Value = new[] { gameMod = new TestMod() };
+                stack.Push(loader = new PlayerLoader(() => player = new TestPlayer()));
+            });
+
+            AddUntilStep("wait for loader to become current", () => loader.IsCurrentScreen());
+            AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+            AddStep("retrieve mods", () => playerMod1 = (TestMod)player.Mods.Value.Single());
+            AddAssert("game mods not applied", () => gameMod.Applied == false);
+            AddAssert("player mods applied", () => playerMod1.Applied);
+
+            AddStep("restart player", () =>
+            {
+                var lastPlayer = player;
+                player = null;
+                lastPlayer.Restart();
+            });
+
+            AddUntilStep("wait for player to be current", () => player.IsCurrentScreen());
+            AddStep("retrieve mods", () => playerMod2 = (TestMod)player.Mods.Value.Single());
+            AddAssert("game mods not applied", () => gameMod.Applied == false);
+            AddAssert("player has different mods", () => playerMod1 != playerMod2);
+            AddAssert("player mods applied", () => playerMod2.Applied);
+        }
+
+        private class TestMod : Mod, IApplicableToScoreProcessor
+        {
+            public override string Name => string.Empty;
+            public override string Acronym => string.Empty;
+            public override double ScoreMultiplier => 1;
+
+            public bool Applied { get; private set; }
+
+            public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
+            {
+                Applied = true;
+            }
+
+            public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
+        }
+
+        private class TestPlayer : Visual.TestPlayer
+        {
+            public new Bindable<IReadOnlyList<Mod>> Mods => base.Mods;
+
+            public TestPlayer(bool allowPause = true, bool showResults = true)
+                : base(allowPause, showResults)
+            {
+            }
+        }
+
+        protected class SlowLoadPlayer : Visual.TestPlayer
+        {
+            public readonly ManualResetEventSlim AllowLoad = new ManualResetEventSlim(false);
+
+            public SlowLoadPlayer(bool allowPause = true, bool showResults = true)
+                : base(allowPause, showResults)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                if (!AllowLoad.Wait(TimeSpan.FromSeconds(10)))
+                    throw new TimeoutException();
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCasePlayerReferenceLeaking.cs

@@ -0,0 +1,56 @@
+// 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.Lists;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCasePlayerReferenceLeaking : AllPlayersTestCase
+    {
+        private readonly WeakList<WorkingBeatmap> workingWeakReferences = new WeakList<WorkingBeatmap>();
+
+        private readonly WeakList<Player> playerWeakReferences = new WeakList<Player>();
+
+        protected override void AddCheckSteps()
+        {
+            AddUntilStep("no leaked beatmaps", () =>
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                int count = 0;
+
+                workingWeakReferences.ForEachAlive(_ => count++);
+                return count == 1;
+            });
+
+            AddUntilStep("no leaked players", () =>
+            {
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                int count = 0;
+
+                playerWeakReferences.ForEachAlive(_ => count++);
+                return count == 1;
+            });
+        }
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, IFrameBasedClock clock)
+        {
+            var working = base.CreateWorkingBeatmap(beatmap, clock);
+            workingWeakReferences.Add(working);
+            return working;
+        }
+
+        protected override Player CreatePlayer(Ruleset ruleset)
+        {
+            var player = base.CreatePlayer(ruleset);
+            playerWeakReferences.Add(player);
+            return player;
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCaseReplay.cs

@@ -0,0 +1,44 @@
+// 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 System.ComponentModel;
+using System.Linq;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [Description("Player instantiated with a replay.")]
+    public class TestCaseReplay : AllPlayersTestCase
+    {
+        protected override Player CreatePlayer(Ruleset ruleset)
+        {
+            var beatmap = Beatmap.Value.GetPlayableBeatmap(ruleset.RulesetInfo, Array.Empty<Mod>());
+
+            return new ScoreAccessibleReplayPlayer(ruleset.GetAutoplayMod().CreateReplayScore(beatmap));
+        }
+
+        protected override void AddCheckSteps()
+        {
+            AddUntilStep("score above zero", () => ((ScoreAccessibleReplayPlayer)Player).ScoreProcessor.TotalScore.Value > 0);
+            AddUntilStep("key counter counted keys", () => ((ScoreAccessibleReplayPlayer)Player).HUDOverlay.KeyCounter.Children.Any(kc => kc.CountPresses > 0));
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+            public new HUDOverlay HUDOverlay => base.HUDOverlay;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score)
+            {
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCaseReplaySettingsOverlay.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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;
@@ -7,7 +7,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Play.PlayerSettings;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseReplaySettingsOverlay : OsuTestCase

osu.Game.Tests/Visual/Gameplay/TestCaseResults.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -7,23 +7,26 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
+using osu.Game.Screens.Ranking.Pages;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
-    public class TestCaseResults : OsuTestCase
+    public class TestCaseResults : ScreenTestCase
     {
         private BeatmapManager beatmaps;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(Score),
+            typeof(ScoreInfo),
             typeof(Results),
             typeof(ResultsPage),
-            typeof(ResultsPageScore),
-            typeof(ResultsPageRanking)
+            typeof(ScoreResultsPage),
+            typeof(LocalLeaderboardPage)
         };
 
         [BackgroundDependencyLoader]
@@ -40,14 +43,14 @@ namespace osu.Game.Tests.Visual
             if (beatmapInfo != null)
                 Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmapInfo);
 
-            Add(new Results(new Score
+            LoadScreen(new SoloResults(new ScoreInfo
             {
                 TotalScore = 2845370,
                 Accuracy = 0.98,
                 MaxCombo = 123,
                 Rank = ScoreRank.A,
                 Date = DateTimeOffset.Now,
-                Statistics = new Dictionary<HitResult, dynamic>
+                Statistics = new Dictionary<HitResult, int>
                 {
                     { HitResult.Great, 50 },
                     { HitResult.Good, 20 },

osu.Game.Tests/Visual/Gameplay/TestCaseScoreCounter.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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;
@@ -7,9 +7,9 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Play.HUD;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseScoreCounter : OsuTestCase
@@ -74,7 +74,7 @@ namespace osu.Game.Tests.Visual
 
             AddStep(@"Hit! :D", delegate
             {
-                score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current > 0 ? comboCounter.Current - 1 : 0) / 25.0);
+                score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current.Value > 0 ? comboCounter.Current.Value - 1 : 0) / 25.0);
                 comboCounter.Increment();
                 numerator++;
                 denominator++;

osu.Game.Tests/Visual/Gameplay/TestCaseScrollingHitObjects.cs

@@ -1,27 +1,34 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
-using OpenTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Timing;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseScrollingHitObjects : OsuTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(Playfield) };
 
+        [Cached(typeof(IReadOnlyList<Mod>))]
+        private IReadOnlyList<Mod> mods { get; set; } = Array.Empty<Mod>();
+
+        private readonly ScrollingTestContainer[] scrollContainers = new ScrollingTestContainer[4];
         private readonly TestPlayfield[] playfields = new TestPlayfield[4];
 
         public TestCaseScrollingHitObjects()
@@ -33,18 +40,38 @@ namespace osu.Game.Tests.Visual
                 {
                     new Drawable[]
                     {
-                        playfields[0] = new TestPlayfield(ScrollingDirection.Up),
-                        playfields[1] = new TestPlayfield(ScrollingDirection.Down)
+                        scrollContainers[0] = new ScrollingTestContainer(ScrollingDirection.Up)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[0] = new TestPlayfield()
+                        },
+                        scrollContainers[1] = new ScrollingTestContainer(ScrollingDirection.Up)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[1] = new TestPlayfield()
+                        },
                     },
                     new Drawable[]
                     {
-                        playfields[2] = new TestPlayfield(ScrollingDirection.Left),
-                        playfields[3] = new TestPlayfield(ScrollingDirection.Right)
+                        scrollContainers[2] = new ScrollingTestContainer(ScrollingDirection.Up)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[2] = new TestPlayfield()
+                        },
+                        scrollContainers[3] = new ScrollingTestContainer(ScrollingDirection.Up)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Child = playfields[3] = new TestPlayfield()
+                        }
                     }
                 }
             });
 
-            AddSliderStep("Time range", 100, 10000, 5000, v => playfields.ForEach(p => p.VisibleTimeRange.Value = v));
+            AddStep("Constant scroll", () => setScrollAlgorithm(ScrollVisualisationMethod.Constant));
+            AddStep("Overlapping scroll", () => setScrollAlgorithm(ScrollVisualisationMethod.Overlapping));
+            AddStep("Sequential scroll", () => setScrollAlgorithm(ScrollVisualisationMethod.Sequential));
+
+            AddSliderStep("Time range", 100, 10000, 5000, v => scrollContainers.ForEach(c => c.TimeRange = v));
             AddStep("Add control point", () => addControlPoint(Time.Current + 5000));
         }
 
@@ -52,7 +79,7 @@ namespace osu.Game.Tests.Visual
         {
             base.LoadComplete();
 
-            playfields.ForEach(p => p.HitObjects.AddControlPoint(new MultiplierControlPoint(0)));
+            scrollContainers.ForEach(c => c.ControlPoints.Add(new MultiplierControlPoint(0)));
 
             for (int i = 0; i <= 5000; i += 1000)
                 addHitObject(Time.Current + i);
@@ -73,12 +100,15 @@ namespace osu.Game.Tests.Visual
 
         private void addControlPoint(double time)
         {
+            scrollContainers.ForEach(c =>
+            {
+                c.ControlPoints.Add(new MultiplierControlPoint(time) { DifficultyPoint = { SpeedMultiplier = 3 } });
+                c.ControlPoints.Add(new MultiplierControlPoint(time + 2000) { DifficultyPoint = { SpeedMultiplier = 2 } });
+                c.ControlPoints.Add(new MultiplierControlPoint(time + 3000) { DifficultyPoint = { SpeedMultiplier = 1 } });
+            });
+
             playfields.ForEach(p =>
             {
-                p.HitObjects.AddControlPoint(new MultiplierControlPoint(time) { DifficultyPoint = { SpeedMultiplier = 3 } });
-                p.HitObjects.AddControlPoint(new MultiplierControlPoint(time + 2000) { DifficultyPoint = { SpeedMultiplier = 2 } });
-                p.HitObjects.AddControlPoint(new MultiplierControlPoint(time + 3000) { DifficultyPoint = { SpeedMultiplier = 1 } });
-
                 TestDrawableControlPoint createDrawablePoint(double t)
                 {
                     var obj = new TestDrawableControlPoint(p.Direction, t);
@@ -99,27 +129,29 @@ namespace osu.Game.Tests.Visual
                 case ScrollingDirection.Up:
                     obj.Anchor = Anchor.TopCentre;
                     break;
+
                 case ScrollingDirection.Down:
                     obj.Anchor = Anchor.BottomCentre;
                     break;
+
                 case ScrollingDirection.Left:
                     obj.Anchor = Anchor.CentreLeft;
                     break;
+
                 case ScrollingDirection.Right:
                     obj.Anchor = Anchor.CentreRight;
                     break;
             }
         }
 
+        private void setScrollAlgorithm(ScrollVisualisationMethod algorithm) => scrollContainers.ForEach(c => c.ScrollAlgorithm = algorithm);
 
         private class TestPlayfield : ScrollingPlayfield
         {
-            public new readonly ScrollingDirection Direction;
+            public new ScrollingDirection Direction => base.Direction.Value;
 
-            public TestPlayfield(ScrollingDirection direction)
+            public TestPlayfield()
             {
-                Direction = direction;
-
                 Padding = new MarginPadding(2);
 
                 InternalChildren = new Drawable[]
@@ -146,12 +178,12 @@ namespace osu.Game.Tests.Visual
             {
                 Origin = Anchor.Centre;
 
-                InternalChild = new Box
+                AddInternal(new Box
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.Both
-                };
+                });
 
                 switch (direction)
                 {
@@ -160,6 +192,7 @@ namespace osu.Game.Tests.Visual
                         RelativeSizeAxes = Axes.X;
                         Height = 2;
                         break;
+
                     case ScrollingDirection.Left:
                     case ScrollingDirection.Right:
                         RelativeSizeAxes = Axes.Y;
@@ -181,7 +214,7 @@ namespace osu.Game.Tests.Visual
                 Origin = Anchor.Centre;
                 AutoSizeAxes = Axes.Both;
 
-                InternalChild = new Box { Size = new Vector2(75) };
+                AddInternal(new Box { Size = new Vector2(75) });
             }
 
             protected override void UpdateState(ArmedState state)

osu.Game.Tests/Visual/Gameplay/TestCaseSkinReloadable.cs

@@ -0,0 +1,145 @@
+// 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 NUnit.Framework;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Graphics;
+using osu.Game.Skinning;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestCaseSkinReloadable : OsuTestCase
+    {
+        [Test]
+        public void TestInitialLoad()
+        {
+            var secondarySource = new SecondarySource();
+            SkinConsumer consumer = null;
+
+            AddStep("setup layout", () =>
+            {
+                Child = new SkinSourceContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = new LocalSkinOverrideContainer(secondarySource)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"), source => true)
+                    }
+                };
+            });
+
+            AddAssert("consumer using override source", () => consumer.Drawable is SecondarySourceBox);
+            AddAssert("skinchanged only called once", () => consumer.SkinChangedCount == 1);
+        }
+
+        [Test]
+        public void TestOverride()
+        {
+            var secondarySource = new SecondarySource();
+
+            SkinConsumer consumer = null;
+            Container target = null;
+
+            AddStep("setup layout", () =>
+            {
+                Child = new SkinSourceContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Child = target = new LocalSkinOverrideContainer(secondarySource)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    }
+                };
+            });
+
+            AddStep("add permissive", () => target.Add(consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"), source => true)));
+            AddAssert("consumer using override source", () => consumer.Drawable is SecondarySourceBox);
+            AddAssert("skinchanged only called once", () => consumer.SkinChangedCount == 1);
+        }
+
+        private class NamedBox : Container
+        {
+            public NamedBox(string name)
+            {
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = Color4.Black,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new SpriteText
+                    {
+                        Font = OsuFont.Default.With(size: 40),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = name
+                    }
+                };
+            }
+        }
+
+        private class SkinConsumer : SkinnableDrawable
+        {
+            public new Drawable Drawable => base.Drawable;
+            public int SkinChangedCount { get; private set; }
+
+            public SkinConsumer(string name, Func<string, Drawable> defaultImplementation, Func<ISkinSource, bool> allowFallback = null, bool restrictSize = true)
+                : base(name, defaultImplementation, allowFallback, restrictSize)
+            {
+            }
+
+            protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+            {
+                base.SkinChanged(skin, allowFallback);
+                SkinChangedCount++;
+            }
+        }
+
+        private class BaseSourceBox : NamedBox
+        {
+            public BaseSourceBox()
+                : base("Base Source")
+            {
+            }
+        }
+
+        private class SecondarySourceBox : NamedBox
+        {
+            public SecondarySourceBox()
+                : base("Secondary Source")
+            {
+            }
+        }
+
+        private class SecondarySource : ISkin
+        {
+            public Drawable GetDrawableComponent(string componentName) => new SecondarySourceBox();
+
+            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+
+            public SampleChannel GetSample(string sampleName) => throw new NotImplementedException();
+
+            public TValue GetValue<TConfiguration, TValue>(Func<TConfiguration, TValue> query) where TConfiguration : SkinConfiguration => throw new NotImplementedException();
+        }
+
+        private class SkinSourceContainer : Container, ISkin
+        {
+            public Drawable GetDrawableComponent(string componentName) => new BaseSourceBox();
+
+            public Texture GetTexture(string componentName) => throw new NotImplementedException();
+
+            public SampleChannel GetSample(string sampleName) => throw new NotImplementedException();
+
+            public TValue GetValue<TConfiguration, TValue>(Func<TConfiguration, TValue> query) where TConfiguration : SkinConfiguration => throw new NotImplementedException();
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCaseSkipOverlay.cs

@@ -1,13 +1,13 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Game.Screens.Play;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
-    public class TestCaseSkipButton : OsuTestCase
+    public class TestCaseSkipOverlay : OsuTestCase
     {
         protected override void LoadComplete()
         {

osu.Game.Tests/Visual/Gameplay/TestCaseSongProgress.cs

@@ -0,0 +1,98 @@
+// 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.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.MathUtils;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [TestFixture]
+    public class TestCaseSongProgress : OsuTestCase
+    {
+        private readonly SongProgress progress;
+        private readonly TestSongProgressGraph graph;
+
+        private readonly StopwatchClock clock;
+
+        [Cached]
+        private readonly GameplayClock gameplayClock;
+
+        private readonly FramedClock framedClock;
+
+        public TestCaseSongProgress()
+        {
+            clock = new StopwatchClock(true);
+
+            gameplayClock = new GameplayClock(framedClock = new FramedClock(clock));
+
+            Add(progress = new SongProgress
+            {
+                RelativeSizeAxes = Axes.X,
+                Anchor = Anchor.BottomLeft,
+                Origin = Anchor.BottomLeft,
+            });
+
+            Add(graph = new TestSongProgressGraph
+            {
+                RelativeSizeAxes = Axes.X,
+                Height = 200,
+                Anchor = Anchor.TopLeft,
+                Origin = Anchor.TopLeft,
+            });
+
+            AddWaitStep("wait some", 5);
+            AddAssert("ensure not created", () => graph.CreationCount == 0);
+
+            AddStep("display values", displayNewValues);
+            AddWaitStep("wait some", 5);
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
+
+            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
+            AddWaitStep("wait some", 5);
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
+
+            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
+            AddWaitStep("wait some", 5);
+            AddUntilStep("wait for creation count", () => graph.CreationCount == 1);
+            AddRepeatStep("New Values", displayNewValues, 5);
+
+            AddWaitStep("wait some", 5);
+            AddAssert("ensure debounced", () => graph.CreationCount == 2);
+        }
+
+        private void displayNewValues()
+        {
+            List<HitObject> objects = new List<HitObject>();
+            for (double i = 0; i < 5000; i += RNG.NextDouble() * 10 + i / 1000)
+                objects.Add(new HitObject { StartTime = i });
+
+            progress.Objects = objects;
+            graph.Objects = objects;
+
+            progress.RequestSeek = pos => clock.Seek(pos);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            framedClock.ProcessFrame();
+        }
+
+        private class TestSongProgressGraph : SongProgressGraph
+        {
+            public int CreationCount { get; private set; }
+
+            protected override void RecreateGraph()
+            {
+                base.RecreateGraph();
+                CreationCount++;
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Gameplay/TestCaseStoryboard.cs

@@ -1,8 +1,9 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -10,9 +11,9 @@ using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Storyboards.Drawables;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Gameplay
 {
     [TestFixture]
     public class TestCaseStoryboard : OsuTestCase
@@ -49,7 +50,10 @@ namespace osu.Game.Tests.Visual
             });
 
             AddStep("Restart", restart);
-            AddToggleStep("Passing", passing => { if (storyboard != null) storyboard.Passing = passing; });
+            AddToggleStep("Passing", passing =>
+            {
+                if (storyboard != null) storyboard.Passing = passing;
+            });
         }
 
         [BackgroundDependencyLoader]
@@ -58,15 +62,15 @@ namespace osu.Game.Tests.Visual
             Beatmap.ValueChanged += beatmapChanged;
         }
 
-        private void beatmapChanged(WorkingBeatmap working)
-            => loadStoryboard(working);
+        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e)
+            => loadStoryboard(e.NewValue);
 
         private void restart()
         {
             var track = Beatmap.Value.Track;
 
             track.Reset();
-            loadStoryboard(Beatmap);
+            loadStoryboard(Beatmap.Value);
             track.Start();
         }
 
@@ -78,7 +82,7 @@ namespace osu.Game.Tests.Visual
             var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
             storyboardContainer.Clock = decoupledClock;
 
-            storyboard = working.Storyboard.CreateDrawable(Beatmap);
+            storyboard = working.Storyboard.CreateDrawable(Beatmap.Value);
             storyboard.Passing = false;
 
             storyboardContainer.Add(storyboard);

osu.Game.Tests/Visual/Menus/TestCaseDisclaimer.cs

@@ -0,0 +1,34 @@
+// 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.Allocation;
+using osu.Game.Online.API;
+using osu.Game.Screens.Menu;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public class TestCaseDisclaimer : ScreenTestCase
+    {
+        [Cached(typeof(IAPIProvider))]
+        private readonly DummyAPIAccess api = new DummyAPIAccess();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(api);
+
+            AddStep("load disclaimer", () => LoadScreen(new Disclaimer()));
+
+            AddStep("toggle support", () =>
+            {
+                api.LocalUser.Value = new User
+                {
+                    Username = api.LocalUser.Value.Username,
+                    Id = api.LocalUser.Value.Id,
+                    IsSupporter = !api.LocalUser.Value.IsSupporter,
+                };
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Menus/TestCaseIntroSequence.cs

@@ -1,17 +1,17 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
-using OpenTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Timing;
 using osu.Game.Screens.Menu;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Menus
 {
     [TestFixture]
     public class TestCaseIntroSequence : OsuTestCase

osu.Game.Tests/Visual/Menus/TestCaseLoaderAnimation.cs

@@ -0,0 +1,141 @@
+// 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.Threading;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Screens;
+using osu.Game.Screens;
+using osu.Game.Screens.Menu;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    [TestFixture]
+    public class TestCaseLoaderAnimation : ScreenTestCase
+    {
+        private TestLoader loader;
+
+        [Cached]
+        private OsuLogo logo;
+
+        public TestCaseLoaderAnimation()
+        {
+            Child = logo = new OsuLogo
+            {
+                Alpha = 0,
+                Depth = float.MinValue
+            };
+        }
+
+        [Test]
+        public void TestInstantLoad()
+        {
+            bool logoVisible = false;
+
+            AddStep("begin loading", () =>
+            {
+                loader = new TestLoader();
+                loader.AllowLoad.Set();
+
+                LoadScreen(loader);
+            });
+
+            AddUntilStep("loaded", () =>
+            {
+                logoVisible = loader.Logo?.Alpha > 0;
+                return loader.Logo != null && loader.ScreenLoaded;
+            });
+
+            AddAssert("logo was not visible", () => !logoVisible);
+        }
+
+        [Test]
+        public void TestShortLoad()
+        {
+            bool logoVisible = false;
+
+            AddStep("begin loading", () => LoadScreen(loader = new TestLoader()));
+            AddWaitStep("wait", 2);
+            AddStep("finish loading", () =>
+            {
+                logoVisible = loader.Logo?.Alpha > 0;
+                loader.AllowLoad.Set();
+            });
+
+            AddAssert("loaded", () => loader.Logo != null && loader.ScreenLoaded);
+            AddAssert("logo was visible", () => logoVisible);
+            AddUntilStep("logo gone", () => loader.Logo?.Alpha == 0);
+        }
+
+        [Test]
+        public void TestLongLoad()
+        {
+            bool logoVisible = false;
+
+            AddStep("begin loading", () => LoadScreen(loader = new TestLoader()));
+            AddWaitStep("wait", 10);
+            AddStep("finish loading", () =>
+            {
+                logoVisible = loader.Logo?.Alpha > 0;
+                loader.AllowLoad.Set();
+            });
+
+            AddAssert("loaded", () => loader.Logo != null && loader.ScreenLoaded);
+            AddAssert("logo was visible", () => logoVisible);
+            AddUntilStep("logo gone", () => loader.Logo?.Alpha == 0);
+        }
+
+        private class TestLoader : Loader
+        {
+            public readonly ManualResetEventSlim AllowLoad = new ManualResetEventSlim();
+
+            public OsuLogo Logo;
+            private TestScreen screen;
+
+            public bool ScreenLoaded => screen.IsCurrentScreen();
+
+            protected override void LogoArriving(OsuLogo logo, bool resuming)
+            {
+                Logo = logo;
+                base.LogoArriving(logo, resuming);
+            }
+
+            protected override OsuScreen CreateLoadableScreen() => screen = new TestScreen();
+            protected override ShaderPrecompiler CreateShaderPrecompiler() => new TestShaderPrecompiler(AllowLoad);
+
+            private class TestShaderPrecompiler : ShaderPrecompiler
+            {
+                private readonly ManualResetEventSlim allowLoad;
+
+                public TestShaderPrecompiler(ManualResetEventSlim allowLoad)
+                {
+                    this.allowLoad = allowLoad;
+                }
+
+                protected override bool AllLoaded => allowLoad.IsSet;
+            }
+
+            private class TestScreen : OsuScreen
+            {
+                public TestScreen()
+                {
+                    InternalChild = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.DarkSlateGray,
+                        Alpha = 0,
+                    };
+                }
+
+                protected override void LogoArriving(OsuLogo logo, bool resuming)
+                {
+                    base.LogoArriving(logo, resuming);
+                    InternalChild.FadeInFromZero(200);
+                }
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Menus/TestCaseToolbar.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -8,7 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Overlays.Toolbar;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Menus
 {
     [TestFixture]
     public class TestCaseToolbar : OsuTestCase
@@ -24,10 +24,13 @@ namespace osu.Game.Tests.Visual
         public TestCaseToolbar()
         {
             var toolbar = new Toolbar { State = Visibility.Visible };
+            ToolbarNotificationButton notificationButton = null;
 
-            Add(toolbar);
-
-            var notificationButton = toolbar.Children.OfType<FillFlowContainer>().Last().Children.OfType<ToolbarNotificationButton>().First();
+            AddStep("create toolbar", () =>
+            {
+                Add(toolbar);
+                notificationButton = toolbar.Children.OfType<FillFlowContainer>().Last().Children.OfType<ToolbarNotificationButton>().First();
+            });
 
             void setNotifications(int count) => AddStep($"set notification count to {count}", () => notificationButton.NotificationCount.Value = count);
 

osu.Game.Tests/Visual/Multiplayer/TestCaseLoungeRoomsContainer.cs

@@ -0,0 +1,102 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Screens.Multi;
+using osu.Game.Screens.Multi.Lounge.Components;
+using osu.Game.Users;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseLoungeRoomsContainer : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(RoomsContainer),
+            typeof(DrawableRoom)
+        };
+
+        [Cached(Type = typeof(IRoomManager))]
+        private TestRoomManager roomManager = new TestRoomManager();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RoomsContainer container;
+
+            Child = container = new RoomsContainer
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Width = 0.5f,
+                JoinRequested = joinRequested
+            };
+
+            AddStep("clear rooms", () => roomManager.Rooms.Clear());
+
+            AddStep("add rooms", () =>
+            {
+                for (int i = 0; i < 3; i++)
+                {
+                    roomManager.Rooms.Add(new Room
+                    {
+                        RoomID = { Value = i },
+                        Name = { Value = $"Room {i}" },
+                        Host = { Value = new User { Username = "Host" } },
+                        EndDate = { Value = DateTimeOffset.Now + TimeSpan.FromSeconds(10) }
+                    });
+                }
+            });
+
+            AddAssert("has 2 rooms", () => container.Rooms.Count == 3);
+            AddStep("remove first room", () => roomManager.Rooms.Remove(roomManager.Rooms.FirstOrDefault()));
+            AddAssert("has 2 rooms", () => container.Rooms.Count == 2);
+            AddAssert("first room removed", () => container.Rooms.All(r => r.Room.RoomID.Value != 0));
+
+            AddStep("select first room", () => container.Rooms.First().Action?.Invoke());
+            AddAssert("first room selected", () => Room == roomManager.Rooms.First());
+
+            AddStep("join first room", () => container.Rooms.First().Action?.Invoke());
+            AddAssert("first room joined", () => roomManager.Rooms.First().Status.Value is JoinedRoomStatus);
+        }
+
+        private void joinRequested(Room room) => room.Status.Value = new JoinedRoomStatus();
+
+        private class TestRoomManager : IRoomManager
+        {
+            public event Action RoomsUpdated
+            {
+                add { }
+                remove { }
+            }
+
+            public readonly BindableList<Room> Rooms = new BindableList<Room>();
+            IBindableList<Room> IRoomManager.Rooms => Rooms;
+
+            public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null) => Rooms.Add(room);
+
+            public void JoinRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)
+            {
+            }
+
+            public void PartRoom()
+            {
+            }
+        }
+
+        private class JoinedRoomStatus : RoomStatus
+        {
+            public override string Message => "Joined";
+
+            public override Color4 GetAppropriateColour(OsuColour colours) => colours.Yellow;
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchHeader.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 System;
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.GameTypes;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.Multi.Match.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchHeader : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Header)
+        };
+
+        public TestCaseMatchHeader()
+        {
+            Room.Playlist.Add(new PlaylistItem
+            {
+                Beatmap = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Title = "Title",
+                        Artist = "Artist",
+                        AuthorString = "Author",
+                    },
+                    Version = "Version",
+                    Ruleset = new OsuRuleset().RulesetInfo
+                },
+                RequiredMods =
+                {
+                    new OsuModDoubleTime(),
+                    new OsuModNoFail(),
+                    new OsuModRelax(),
+                }
+            });
+
+            Room.Type.Value = new GameTypeTimeshift();
+
+            Child = new Header();
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchHostInfo.cs

@@ -0,0 +1,35 @@
+// 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 System.Collections.Generic;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Screens.Multi.Match.Components;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchHostInfo : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(HostInfo)
+        };
+
+        private readonly Bindable<User> host = new Bindable<User>(new User { Username = "SomeHost" });
+
+        public TestCaseMatchHostInfo()
+        {
+            HostInfo hostInfo;
+
+            Child = hostInfo = new HostInfo
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
+
+            hostInfo.Host.BindTo(host);
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchInfo.cs

@@ -0,0 +1,78 @@
+// 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 System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.RoomStatuses;
+using osu.Game.Rulesets;
+using osu.Game.Screens.Multi.Match.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMatchInfo : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Info),
+            typeof(HeaderButton),
+            typeof(ReadyButton),
+            typeof(ViewBeatmapButton)
+        };
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            Add(new Info());
+
+            AddStep(@"set name", () => Room.Name.Value = @"Room Name?");
+            AddStep(@"set availability", () => Room.Availability.Value = RoomAvailability.FriendsOnly);
+            AddStep(@"set status", () => Room.Status.Value = new RoomStatusPlaying());
+            AddStep(@"set beatmap", () =>
+            {
+                Room.Playlist.Clear();
+                Room.Playlist.Add(new PlaylistItem
+                {
+                    Beatmap = new BeatmapInfo
+                    {
+                        StarDifficulty = 2.4,
+                        Ruleset = rulesets.GetRuleset(0),
+                        Metadata = new BeatmapMetadata
+                        {
+                            Title = @"My Song",
+                            Artist = @"VisualTests",
+                            AuthorString = @"osu!lazer",
+                        },
+                    }
+                });
+            });
+
+            AddStep(@"change name", () => Room.Name.Value = @"Room Name!");
+            AddStep(@"change availability", () => Room.Availability.Value = RoomAvailability.InviteOnly);
+            AddStep(@"change status", () => Room.Status.Value = new RoomStatusOpen());
+            AddStep(@"null beatmap", () => Room.Playlist.Clear());
+            AddStep(@"change beatmap", () =>
+            {
+                Room.Playlist.Clear();
+                Room.Playlist.Add(new PlaylistItem
+                {
+                    Beatmap = new BeatmapInfo
+                    {
+                        StarDifficulty = 4.2,
+                        Ruleset = rulesets.GetRuleset(3),
+                        Metadata = new BeatmapMetadata
+                        {
+                            Title = @"Your Song",
+                            Artist = @"Tester",
+                            AuthorString = @"Someone",
+                        },
+                    }
+                });
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchLeaderboard.cs

@@ -0,0 +1,69 @@
+// 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.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Online.API;
+using osu.Game.Screens.Multi.Match.Components;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchLeaderboard : MultiplayerTestCase
+    {
+        public TestCaseMatchLeaderboard()
+        {
+            Room.RoomID.Value = 3;
+
+            Add(new MatchLeaderboard
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Size = new Vector2(550f, 450f),
+                Scope = MatchLeaderboardScope.Overall,
+            });
+        }
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var req = new GetRoomScoresRequest();
+            req.Success += v => { };
+            req.Failure += _ => { };
+
+            api.Queue(req);
+        }
+
+        private class GetRoomScoresRequest : APIRequest<List<RoomScore>>
+        {
+            protected override string Target => "rooms/3/leaderboard";
+        }
+
+        private class RoomScore
+        {
+            [JsonProperty("user")]
+            public User User { get; set; }
+
+            [JsonProperty("accuracy")]
+            public double Accuracy { get; set; }
+
+            [JsonProperty("total_score")]
+            public int TotalScore { get; set; }
+
+            [JsonProperty("pp")]
+            public double PP { get; set; }
+
+            [JsonProperty("attempts")]
+            public int TotalAttempts { get; set; }
+
+            [JsonProperty("completed")]
+            public int CompletedAttempts { get; set; }
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchParticipants.cs

@@ -1,26 +1,22 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Game.Screens.Multi.Screens.Match;
+using osu.Game.Screens.Multi.Match.Components;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Multiplayer
 {
     [TestFixture]
-    public class TestCaseMatchParticipants : OsuTestCase
+    public class TestCaseMatchParticipants : MultiplayerTestCase
     {
         public TestCaseMatchParticipants()
         {
-            Participants participants;
-            Add(participants = new Participants
-            {
-                RelativeSizeAxes = Axes.Both,
-            });
+            Add(new Participants { RelativeSizeAxes = Axes.Both });
 
-            AddStep(@"set max to null", () => participants.Max = null);
-            AddStep(@"set users", () => participants.Users = new[]
+            AddStep(@"set max to null", () => Room.MaxParticipants.Value = null);
+            AddStep(@"set users", () => Room.Participants.Value = new[]
             {
                 new User
                 {
@@ -48,9 +44,9 @@ namespace osu.Game.Tests.Visual
                 },
             });
 
-            AddStep(@"set max", () => participants.Max = 10);
-            AddStep(@"clear users", () => participants.Users = new User[] { });
-            AddStep(@"set max to null", () => participants.Max = null);
+            AddStep(@"set max", () => Room.MaxParticipants.Value = 10);
+            AddStep(@"clear users", () => Room.Participants.Value = new User[] { });
+            AddStep(@"set max to null", () => Room.MaxParticipants.Value = null);
         }
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchResults.cs

@@ -0,0 +1,106 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Scoring;
+using osu.Game.Screens.Multi.Match.Components;
+using osu.Game.Screens.Multi.Ranking;
+using osu.Game.Screens.Multi.Ranking.Pages;
+using osu.Game.Screens.Multi.Ranking.Types;
+using osu.Game.Screens.Ranking;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchResults : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(MatchResults),
+            typeof(RoomLeaderboardPageInfo),
+            typeof(RoomLeaderboardPage)
+        };
+
+        [Resolved]
+        private BeatmapManager beatmaps { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var beatmapInfo = beatmaps.QueryBeatmap(b => b.RulesetID == 0);
+            if (beatmapInfo != null)
+                Beatmap.Value = beatmaps.GetWorkingBeatmap(beatmapInfo);
+
+            Room.RoomID.Value = 1;
+            Room.Name.Value = "an awesome room";
+
+            LoadScreen(new TestMatchResults(new ScoreInfo
+            {
+                User = new User { Id = 10 },
+            }));
+        }
+
+        private class TestMatchResults : MatchResults
+        {
+            public TestMatchResults(ScoreInfo score)
+                : base(score)
+            {
+            }
+
+            protected override IEnumerable<IResultPageInfo> CreateResultPages() => new[] { new TestRoomLeaderboardPageInfo(Score, Beatmap.Value) };
+        }
+
+        private class TestRoomLeaderboardPageInfo : RoomLeaderboardPageInfo
+        {
+            private readonly ScoreInfo score;
+            private readonly WorkingBeatmap beatmap;
+
+            public TestRoomLeaderboardPageInfo(ScoreInfo score, WorkingBeatmap beatmap)
+                : base(score, beatmap)
+            {
+                this.score = score;
+                this.beatmap = beatmap;
+            }
+
+            public override ResultsPage CreatePage() => new TestRoomLeaderboardPage(score, beatmap);
+        }
+
+        private class TestRoomLeaderboardPage : RoomLeaderboardPage
+        {
+            public TestRoomLeaderboardPage(ScoreInfo score, WorkingBeatmap beatmap)
+                : base(score, beatmap)
+            {
+            }
+
+            protected override MatchLeaderboard CreateLeaderboard() => new TestMatchLeaderboard();
+        }
+
+        private class TestMatchLeaderboard : RoomLeaderboardPage.ResultsMatchLeaderboard
+        {
+            protected override APIRequest FetchScores(Action<IEnumerable<APIRoomScoreInfo>> scoresCallback)
+            {
+                var scores = Enumerable.Range(0, 50).Select(createRoomScore).ToArray();
+
+                scoresCallback?.Invoke(scores);
+                ScoresLoaded?.Invoke(scores);
+
+                return null;
+            }
+
+            private APIRoomScoreInfo createRoomScore(int id) => new APIRoomScoreInfo
+            {
+                User = new User { Id = id, Username = $"User {id}" },
+                Accuracy = 0.98,
+                TotalScore = 987654,
+                TotalAttempts = 13,
+                CompletedBeatmaps = 5
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMatchSettingsOverlay.cs

@@ -0,0 +1,157 @@
+// 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 System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Screens.Multi;
+using osu.Game.Screens.Multi.Match.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchSettingsOverlay : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(MatchSettingsOverlay)
+        };
+
+        [Cached(Type = typeof(IRoomManager))]
+        private TestRoomManager roomManager = new TestRoomManager();
+
+        private TestRoomSettings settings;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Room = new Room();
+
+            settings = new TestRoomSettings
+            {
+                RelativeSizeAxes = Axes.Both,
+                State = Visibility.Visible
+            };
+
+            Child = settings;
+        });
+
+        [Test]
+        public void TestButtonEnabledOnlyWithNameAndBeatmap()
+        {
+            AddStep("clear name and beatmap", () =>
+            {
+                Room.Name.Value = "";
+                Room.Playlist.Clear();
+            });
+
+            AddAssert("button disabled", () => !settings.ApplyButton.Enabled.Value);
+
+            AddStep("set name", () => Room.Name.Value = "Room name");
+            AddAssert("button disabled", () => !settings.ApplyButton.Enabled.Value);
+
+            AddStep("set beatmap", () => Room.Playlist.Add(new PlaylistItem { Beatmap = new DummyWorkingBeatmap().BeatmapInfo }));
+            AddAssert("button enabled", () => settings.ApplyButton.Enabled.Value);
+
+            AddStep("clear name", () => Room.Name.Value = "");
+            AddAssert("button disabled", () => !settings.ApplyButton.Enabled.Value);
+        }
+
+        [Test]
+        public void TestCorrectSettingsApplied()
+        {
+            const string expected_name = "expected name";
+            TimeSpan expectedDuration = TimeSpan.FromMinutes(15);
+
+            Room createdRoom = null;
+
+            AddStep("setup", () =>
+            {
+                settings.NameField.Current.Value = expected_name;
+                settings.DurationField.Current.Value = expectedDuration;
+
+                roomManager.CreateRequested = r =>
+                {
+                    createdRoom = r;
+                    return true;
+                };
+            });
+
+            AddStep("create room", () => settings.ApplyButton.Action.Invoke());
+            AddAssert("has correct name", () => createdRoom.Name.Value == expected_name);
+            AddAssert("has correct duration", () => createdRoom.Duration.Value == expectedDuration);
+        }
+
+        [Test]
+        public void TestCreationFailureDisplaysError()
+        {
+            bool fail;
+
+            AddStep("setup", () =>
+            {
+                fail = true;
+                roomManager.CreateRequested = _ => !fail;
+            });
+            AddAssert("error not displayed", () => !settings.ErrorText.IsPresent);
+
+            AddStep("create room", () => settings.ApplyButton.Action.Invoke());
+            AddAssert("error displayed", () => settings.ErrorText.IsPresent);
+            AddAssert("error has correct text", () => settings.ErrorText.Text == TestRoomManager.FAILED_TEXT);
+
+            AddStep("create room no fail", () =>
+            {
+                fail = false;
+                settings.ApplyButton.Action.Invoke();
+            });
+
+            AddUntilStep("error not displayed", () => !settings.ErrorText.IsPresent);
+        }
+
+        private class TestRoomSettings : MatchSettingsOverlay
+        {
+            public TriangleButton ApplyButton => Settings.ApplyButton;
+
+            public OsuTextBox NameField => Settings.NameField;
+            public OsuDropdown<TimeSpan> DurationField => Settings.DurationField;
+
+            public OsuSpriteText ErrorText => Settings.ErrorText;
+        }
+
+        private class TestRoomManager : IRoomManager
+        {
+            public const string FAILED_TEXT = "failed";
+
+            public Func<Room, bool> CreateRequested;
+
+            public event Action RoomsUpdated
+            {
+                add { }
+                remove { }
+            }
+
+            public IBindableList<Room> Rooms { get; } = null;
+
+            public void CreateRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null)
+            {
+                if (CreateRequested == null)
+                    return;
+
+                if (!CreateRequested.Invoke(room))
+                    onError?.Invoke(FAILED_TEXT);
+                else
+                    onSuccess?.Invoke(room);
+            }
+
+            public void JoinRoom(Room room, Action<Room> onSuccess = null, Action<string> onError = null) => throw new NotImplementedException();
+
+            public void PartRoom() => throw new NotImplementedException();
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMultiHeader.cs

@@ -0,0 +1,44 @@
+// 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.Screens;
+using osu.Game.Screens;
+using osu.Game.Screens.Multi;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMultiHeader : OsuTestCase
+    {
+        public TestCaseMultiHeader()
+        {
+            int index = 0;
+
+            OsuScreenStack screenStack = new OsuScreenStack(new TestMultiplayerSubScreen(index)) { RelativeSizeAxes = Axes.Both };
+
+            Children = new Drawable[]
+            {
+                screenStack,
+                new Header(screenStack)
+            };
+
+            AddStep("push multi screen", () => screenStack.CurrentScreen.Push(new TestMultiplayerSubScreen(++index)));
+        }
+
+        private class TestMultiplayerSubScreen : OsuScreen, IMultiplayerSubScreen
+        {
+            private readonly int index;
+
+            public string ShortTitle => $"Screen {index}";
+
+            public TestMultiplayerSubScreen(int index)
+            {
+                this.index = index;
+            }
+
+            public override string ToString() => ShortTitle;
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseMultiScreen.cs

@@ -0,0 +1,29 @@
+// 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 System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Screens.Multi.Lounge;
+using osu.Game.Screens.Multi.Lounge.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMultiScreen : ScreenTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Screens.Multi.Multiplayer),
+            typeof(LoungeSubScreen),
+            typeof(FilterControl)
+        };
+
+        public TestCaseMultiScreen()
+        {
+            Screens.Multi.Multiplayer multi = new Screens.Multi.Multiplayer();
+
+            AddStep(@"show", () => LoadScreen(multi));
+        }
+    }
+}

osu.Game.Tests/Visual/Multiplayer/TestCaseRoomStatus.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 System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.RoomStatuses;
+using osu.Game.Screens.Multi.Lounge.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseRoomStatus : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(RoomStatusEnded),
+            typeof(RoomStatusOpen),
+            typeof(RoomStatusPlaying)
+        };
+
+        public TestCaseRoomStatus()
+        {
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Width = 0.5f,
+                Children = new Drawable[]
+                {
+                    new DrawableRoom(new Room
+                    {
+                        Name = { Value = "Room 1" },
+                        Status = { Value = new RoomStatusOpen() }
+                    }),
+                    new DrawableRoom(new Room
+                    {
+                        Name = { Value = "Room 2" },
+                        Status = { Value = new RoomStatusPlaying() }
+                    }),
+                    new DrawableRoom(new Room
+                    {
+                        Name = { Value = "Room 3" },
+                        Status = { Value = new RoomStatusEnded() }
+                    }),
+                }
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseAccountCreationOverlay.cs

@@ -0,0 +1,56 @@
+// 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 System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.API;
+using osu.Game.Overlays;
+using osu.Game.Overlays.AccountCreation;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseAccountCreationOverlay : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ErrorTextFlowContainer),
+            typeof(AccountCreationBackground),
+            typeof(ScreenEntry),
+            typeof(ScreenWarning),
+            typeof(ScreenWelcome),
+            typeof(AccountCreationScreen),
+        };
+
+        [Cached(typeof(IAPIProvider))]
+        private DummyAPIAccess api = new DummyAPIAccess();
+
+        public TestCaseAccountCreationOverlay()
+        {
+            Container userPanelArea;
+            AccountCreationOverlay accountCreation;
+
+            Children = new Drawable[]
+            {
+                api,
+                accountCreation = new AccountCreationOverlay(),
+                userPanelArea = new Container
+                {
+                    Padding = new MarginPadding(10),
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                },
+            };
+
+            api.Logout();
+            api.LocalUser.BindValueChanged(user => { userPanelArea.Child = new UserPanel(user.NewValue) { Width = 200 }; }, true);
+
+            AddStep("show", () => accountCreation.State = Visibility.Visible);
+            AddStep("logout", () => api.Logout());
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseBeatmapSetOverlay.cs

@@ -1,9 +1,6 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
-using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
@@ -13,8 +10,11 @@ using osu.Game.Overlays.BeatmapSet.Buttons;
 using osu.Game.Overlays.BeatmapSet.Scores;
 using osu.Game.Rulesets;
 using osu.Game.Users;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseBeatmapSetOverlay : OsuTestCase
@@ -24,8 +24,8 @@ namespace osu.Game.Tests.Visual
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(Header),
-            typeof(ClickableUsername),
-            typeof(DrawableScore),
+            typeof(ScoreTable),
+            typeof(ScoreTableRowBackground),
             typeof(DrawableTopScore),
             typeof(ScoresContainer),
             typeof(AuthorInfo),

osu.Game.Tests/Visual/Online/TestCaseChannelTabControl.cs

@@ -0,0 +1,120 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.MathUtils;
+using osu.Game.Online.Chat;
+using osu.Game.Overlays.Chat.Tabs;
+using osu.Game.Users;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseChannelTabControl : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ChannelTabControl),
+        };
+
+        private readonly ChannelTabControl channelTabControl;
+
+        public TestCaseChannelTabControl()
+        {
+            SpriteText currentText;
+            Add(new Container
+            {
+                RelativeSizeAxes = Axes.X,
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Children = new Drawable[]
+                {
+                    channelTabControl = new ChannelTabControl
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                        Height = 50
+                    },
+                    new Box
+                    {
+                        Colour = Color4.Black.Opacity(0.1f),
+                        RelativeSizeAxes = Axes.X,
+                        Height = 50,
+                        Depth = -1,
+                        Origin = Anchor.Centre,
+                        Anchor = Anchor.Centre,
+                    }
+                }
+            });
+
+            Add(new Container
+            {
+                Origin = Anchor.TopLeft,
+                Anchor = Anchor.TopLeft,
+                Children = new Drawable[]
+                {
+                    currentText = new SpriteText
+                    {
+                        Text = "Currently selected channel:"
+                    }
+                }
+            });
+
+            channelTabControl.OnRequestLeave += channel => channelTabControl.RemoveChannel(channel);
+            channelTabControl.Current.ValueChanged += channel => currentText.Text = "Currently selected channel: " + channel.NewValue.ToString();
+
+            AddStep("Add random private channel", addRandomPrivateChannel);
+            AddAssert("There is only one channels", () => channelTabControl.Items.Count() == 2);
+            AddRepeatStep("Add 3 random private channels", addRandomPrivateChannel, 3);
+            AddAssert("There are four channels", () => channelTabControl.Items.Count() == 5);
+            AddStep("Add random public channel", () => addChannel(RNG.Next().ToString()));
+
+            AddRepeatStep("Select a random channel", () => channelTabControl.Current.Value = channelTabControl.Items.ElementAt(RNG.Next(channelTabControl.Items.Count() - 1)), 20);
+
+            Channel channelBefore = channelTabControl.Items.First();
+            AddStep("set first channel", () => channelTabControl.Current.Value = channelBefore);
+
+            AddStep("select selector tab", () => channelTabControl.Current.Value = channelTabControl.Items.Last());
+            AddAssert("selector tab is active", () => channelTabControl.ChannelSelectorActive.Value);
+
+            AddAssert("check channel unchanged", () => channelBefore == channelTabControl.Current.Value);
+
+            AddStep("set second channel", () => channelTabControl.Current.Value = channelTabControl.Items.Skip(1).First());
+            AddAssert("selector tab is inactive", () => !channelTabControl.ChannelSelectorActive.Value);
+
+            AddUntilStep("remove all channels", () =>
+            {
+                var first = channelTabControl.Items.First();
+                if (first is ChannelSelectorTabItem.ChannelSelectorTabChannel)
+                    return true;
+
+                channelTabControl.RemoveChannel(first);
+                return false;
+            });
+
+            AddAssert("selector tab is active", () => channelTabControl.ChannelSelectorActive.Value);
+        }
+
+        private void addRandomPrivateChannel() =>
+            channelTabControl.AddChannel(new Channel(new User
+            {
+                Id = RNG.Next(1000, 10000000),
+                Username = "Test User " + RNG.Next(1000)
+            }));
+
+        private void addChannel(string name) =>
+            channelTabControl.AddChannel(new Channel
+            {
+                Type = ChannelType.Public,
+                Name = name
+            });
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseChatDisplay.cs

@@ -0,0 +1,45 @@
+// 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 System.Collections.Generic;
+using System.ComponentModel;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.Chat;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Chat;
+using osu.Game.Overlays.Chat.Tabs;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [Description("Testing chat api and overlay")]
+    public class TestCaseChatDisplay : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ChatOverlay),
+            typeof(ChatLine),
+            typeof(DrawableChannel),
+            typeof(ChannelSelectorTabItem),
+            typeof(ChannelTabControl),
+            typeof(ChannelTabItem),
+            typeof(PrivateChannelTabItem),
+            typeof(TabCloseButton)
+        };
+
+        [Cached]
+        private readonly ChannelManager channelManager = new ChannelManager();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Children = new Drawable[]
+            {
+                channelManager,
+                new ChatOverlay { State = Visibility.Visible }
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseChatLink.cs

@@ -1,28 +1,30 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 OpenTK.Graphics;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics;
-using osu.Game.Online.Chat;
-using osu.Game.Overlays.Chat;
-using osu.Game.Users;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Online.Chat;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Chat;
+using osu.Game.Users;
+using osuTK.Graphics;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseChatLink : OsuTestCase
     {
         private readonly TestChatLineContainer textContainer;
+        private readonly DialogOverlay dialogOverlay;
         private Color4 linkColour;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
@@ -37,6 +39,7 @@ namespace osu.Game.Tests.Visual
 
         public TestCaseChatLink()
         {
+            Add(dialogOverlay = new DialogOverlay { Depth = float.MinValue });
             Add(textContainer = new TestChatLineContainer
             {
                 Padding = new MarginPadding { Left = 20, Right = 20 },
@@ -50,14 +53,15 @@ namespace osu.Game.Tests.Visual
         private void load(OsuColour colours)
         {
             linkColour = colours.Blue;
-            Dependencies.Cache(new ChatOverlay
-            {
-                AvailableChannels =
-                {
-                    new Channel { Name = "#english" },
-                    new Channel { Name = "#japanese" }
-                }
-            });
+
+            var chatManager = new ChannelManager();
+            BindableList<Channel> availableChannels = (BindableList<Channel>)chatManager.AvailableChannels;
+            availableChannels.Add(new Channel { Name = "#english" });
+            availableChannels.Add(new Channel { Name = "#japanese" });
+            Dependencies.Cache(chatManager);
+
+            Dependencies.Cache(new ChatOverlay());
+            Dependencies.Cache(dialogOverlay);
 
             testLinksGeneral();
             testEcho();
@@ -92,7 +96,7 @@ namespace osu.Game.Tests.Visual
                 return true;
             }
 
-            bool isItalic() => newLine.ContentFlow.Where(d => d is OsuSpriteText).Cast<OsuSpriteText>().All(sprite => sprite.Font == "Exo2.0-MediumItalic");
+            bool isItalic() => newLine.ContentFlow.Where(d => d is OsuSpriteText).Cast<OsuSpriteText>().All(sprite => sprite.Font.Italics);
 
             bool isShowingLinks()
             {
@@ -155,7 +159,7 @@ namespace osu.Game.Tests.Visual
                     Scheduler.AddDelayed(() => newLine.Message = new DummyMessage(completeText ?? text), delay);
                 });
 
-                AddUntilStep(() => textContainer.All(line => line.Message is DummyMessage), $"wait for msg #{echoCounter}");
+                AddUntilStep($"wait for msg #{echoCounter}", () => textContainer.All(line => line.Message is DummyMessage));
             }
         }
 

osu.Game.Tests/Visual/Online/TestCaseDirect.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Collections.Generic;
 using NUnit.Framework;
@@ -8,7 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseDirect : OsuTestCase

osu.Game.Tests/Visual/Online/TestCaseDirectPanel.cs

@@ -0,0 +1,47 @@
+// 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 System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays.Direct;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseDirectPanel : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DirectGridPanel),
+            typeof(DirectListPanel),
+            typeof(IconPill)
+        };
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var beatmap = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo, null);
+            beatmap.BeatmapSetInfo.OnlineInfo.HasVideo = true;
+            beatmap.BeatmapSetInfo.OnlineInfo.HasStoryboard = true;
+
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.X,
+                AutoSizeAxes = Axes.Y,
+                Direction = FillDirection.Vertical,
+                Padding = new MarginPadding(20),
+                Spacing = new Vector2(0, 20),
+                Children = new Drawable[]
+                {
+                    new DirectGridPanel(beatmap.BeatmapSetInfo),
+                    new DirectListPanel(beatmap.BeatmapSetInfo)
+                }
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseExternalLinkButton.cs

@@ -1,12 +1,12 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using osu.Game.Graphics.UserInterface;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     public class TestCaseExternalLinkButton : OsuTestCase
     {

osu.Game.Tests/Visual/Online/TestCaseGraph.cs

@@ -1,13 +1,13 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Game.Graphics.UserInterface;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseGraph : OsuTestCase

osu.Game.Tests/Visual/Online/TestCaseHistoricalSection.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -12,7 +12,7 @@ using osu.Game.Overlays.Profile.Sections;
 using osu.Game.Overlays.Profile.Sections.Historical;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseHistoricalSection : OsuTestCase

osu.Game.Tests/Visual/Online/TestCaseRankGraph.cs

@@ -1,19 +1,19 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
+using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using OpenTK;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using System.Collections.Generic;
-using System;
-using NUnit.Framework;
 using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays.Profile.Header;
+using osu.Game.Overlays.Profile.Header.Components;
 using osu.Game.Users;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseRankGraph : OsuTestCase

osu.Game.Tests/Visual/Online/TestCaseScoresContainer.cs

@@ -0,0 +1,185 @@
+// 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 System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
+using osu.Game.Overlays.BeatmapSet.Scores;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseScoresContainer : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(DrawableTopScore),
+            typeof(TopScoreUserSection),
+            typeof(TopScoreStatisticsSection),
+            typeof(ScoreTable),
+            typeof(ScoreTableRowBackground),
+        };
+
+        private readonly Box background;
+
+        public TestCaseScoresContainer()
+        {
+            ScoresContainer scoresContainer;
+
+            Child = new Container
+            {
+                Anchor = Anchor.TopCentre,
+                Origin = Anchor.TopCentre,
+                AutoSizeAxes = Axes.Y,
+                RelativeSizeAxes = Axes.X,
+                Width = 0.8f,
+                Children = new Drawable[]
+                {
+                    background = new Box { RelativeSizeAxes = Axes.Both },
+                    scoresContainer = new ScoresContainer(),
+                }
+            };
+
+            var scores = new List<ScoreInfo>
+            {
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 6602580,
+                        Username = @"waaiiru",
+                        Country = new Country
+                        {
+                            FullName = @"Spain",
+                            FlagName = @"ES",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                        new OsuModHidden(),
+                        new OsuModFlashlight(),
+                        new OsuModHardRock(),
+                    },
+                    Rank = ScoreRank.XH,
+                    PP = 200,
+                    MaxCombo = 1234,
+                    TotalScore = 1234567890,
+                    Accuracy = 1,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 4608074,
+                        Username = @"Skycries",
+                        Country = new Country
+                        {
+                            FullName = @"Brazil",
+                            FlagName = @"BR",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                        new OsuModHidden(),
+                        new OsuModFlashlight(),
+                    },
+                    Rank = ScoreRank.S,
+                    PP = 190,
+                    MaxCombo = 1234,
+                    TotalScore = 1234789,
+                    Accuracy = 0.9997,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 1014222,
+                        Username = @"eLy",
+                        Country = new Country
+                        {
+                            FullName = @"Japan",
+                            FlagName = @"JP",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                        new OsuModHidden(),
+                    },
+                    Rank = ScoreRank.B,
+                    PP = 180,
+                    MaxCombo = 1234,
+                    TotalScore = 12345678,
+                    Accuracy = 0.9854,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 1541390,
+                        Username = @"Toukai",
+                        Country = new Country
+                        {
+                            FullName = @"Canada",
+                            FlagName = @"CA",
+                        },
+                    },
+                    Mods = new Mod[]
+                    {
+                        new OsuModDoubleTime(),
+                    },
+                    Rank = ScoreRank.C,
+                    PP = 170,
+                    MaxCombo = 1234,
+                    TotalScore = 1234567,
+                    Accuracy = 0.8765,
+                },
+                new ScoreInfo
+                {
+                    User = new User
+                    {
+                        Id = 7151382,
+                        Username = @"Mayuri Hana",
+                        Country = new Country
+                        {
+                            FullName = @"Thailand",
+                            FlagName = @"TH",
+                        },
+                    },
+                    Rank = ScoreRank.F,
+                    PP = 160,
+                    MaxCombo = 1234,
+                    TotalScore = 123456,
+                    Accuracy = 0.6543,
+                },
+            };
+
+            foreach (var s in scores)
+            {
+                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
+                s.Statistics.Add(HitResult.Miss, RNG.Next(2000));
+            }
+
+            scoresContainer.Scores = scores;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            background.Colour = colours.Gray2;
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseSocial.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -8,7 +8,7 @@ using osu.Game.Overlays;
 using osu.Game.Overlays.Social;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseSocial : OsuTestCase

osu.Game.Tests/Visual/Online/TestCaseStandAloneChatDisplay.cs

@@ -0,0 +1,104 @@
+// 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.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Online.Chat;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseStandAloneChatDisplay : OsuTestCase
+    {
+        private readonly Channel testChannel = new Channel();
+
+        private readonly User admin = new User
+        {
+            Username = "HappyStick",
+            Id = 2,
+            Colour = "f2ca34"
+        };
+
+        private readonly User redUser = new User
+        {
+            Username = "BanchoBot",
+            Id = 3,
+        };
+
+        private readonly User blueUser = new User
+        {
+            Username = "Zallius",
+            Id = 4,
+        };
+
+        [Cached]
+        private ChannelManager channelManager = new ChannelManager();
+
+        private readonly StandAloneChatDisplay chatDisplay;
+        private readonly StandAloneChatDisplay chatDisplay2;
+
+        public TestCaseStandAloneChatDisplay()
+        {
+            Add(channelManager);
+
+            Add(chatDisplay = new StandAloneChatDisplay
+            {
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.CentreLeft,
+                Margin = new MarginPadding(20),
+                Size = new Vector2(400, 80)
+            });
+
+            Add(chatDisplay2 = new StandAloneChatDisplay(true)
+            {
+                Anchor = Anchor.CentreRight,
+                Origin = Anchor.CentreRight,
+                Margin = new MarginPadding(20),
+                Size = new Vector2(400, 150)
+            });
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            channelManager.CurrentChannel.Value = testChannel;
+
+            chatDisplay.Channel.Value = testChannel;
+            chatDisplay2.Channel.Value = testChannel;
+
+            int sequence = 0;
+
+            AddStep("message from admin", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = admin,
+                Content = "I am a wang!"
+            }));
+
+            AddStep("message from team red", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = redUser,
+                Content = "I am team red."
+            }));
+
+            AddStep("message from team red", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = redUser,
+                Content = "I plan to win!"
+            }));
+
+            AddStep("message from team blue", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = blueUser,
+                Content = "Not on my watch. Prepare to eat saaaaaaaaaand. Lots and lots of saaaaaaand."
+            }));
+
+            AddStep("message from admin", () => testChannel.AddNewMessages(new Message(sequence++)
+            {
+                Sender = admin,
+                Content = "Okay okay, calm down guys. Let's do this!"
+            }));
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseUserPanel.cs

@@ -1,13 +1,13 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Containers;
 using osu.Game.Users;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseUserPanel : OsuTestCase
@@ -38,6 +38,7 @@ namespace osu.Game.Tests.Visual
                         Country = new Country { FlagName = @"AU" },
                         CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
                         IsSupporter = true,
+                        SupportLevel = 3,
                     }) { Width = 300 },
                 },
             });

osu.Game.Tests/Visual/Online/TestCaseUserProfile.cs

@@ -1,25 +1,28 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Profile;
-using osu.Game.Overlays.Profile.Header;
+using osu.Game.Overlays.Profile.Header.Components;
 using osu.Game.Users;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseUserProfile : OsuTestCase
     {
         private readonly TestUserProfileOverlay profile;
-        private APIAccess api;
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -27,7 +30,46 @@ namespace osu.Game.Tests.Visual
             typeof(UserProfileOverlay),
             typeof(RankGraph),
             typeof(LineGraph),
-            typeof(BadgeContainer)
+            typeof(SectionsContainer<>),
+            typeof(SupporterIcon)
+        };
+
+        public static readonly User TEST_USER = new User
+        {
+            Username = @"Somebody",
+            Id = 1,
+            Country = new Country { FullName = @"Alien" },
+            CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c1.jpg",
+            JoinDate = DateTimeOffset.Now.AddDays(-1),
+            LastVisit = DateTimeOffset.Now,
+            ProfileOrder = new[] { "me" },
+            Statistics = new UserStatistics
+            {
+                Ranks = new UserStatistics.UserRanks { Global = 2148, Country = 1 },
+                PP = 4567.89m,
+                Level = new UserStatistics.LevelInfo
+                {
+                    Current = 727,
+                    Progress = 69,
+                }
+            },
+            RankHistory = new User.RankHistoryData
+            {
+                Mode = @"osu",
+                Data = Enumerable.Range(2345, 45).Concat(Enumerable.Range(2109, 40)).ToArray()
+            },
+            Badges = new[]
+            {
+                new Badge
+                {
+                    AwardedAt = DateTimeOffset.FromUnixTimeSeconds(1505741569),
+                    Description = "Outstanding help by being a voluntary test subject.",
+                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg"
+                }
+            },
+            Title = "osu!volunteer",
+            Colour = "ff0000",
+            Achievements = new User.UserAchievement[0],
         };
 
         public TestCaseUserProfile()
@@ -35,47 +77,11 @@ namespace osu.Game.Tests.Visual
             Add(profile = new TestUserProfileOverlay());
         }
 
-        [BackgroundDependencyLoader]
-        private void load(APIAccess api)
-        {
-            this.api = api;
-        }
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            AddStep("Show offline dummy", () => profile.ShowUser(new User
-            {
-                Username = @"Somebody",
-                Id = 1,
-                Country = new Country { FullName = @"Alien" },
-                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c1.jpg",
-                JoinDate = DateTimeOffset.Now.AddDays(-1),
-                LastVisit = DateTimeOffset.Now,
-                ProfileOrder = new[] { "me" },
-                Statistics = new UserStatistics
-                {
-                    Ranks = new UserStatistics.UserRanks { Global = 2148, Country = 1 },
-                    PP = 4567.89m,
-                },
-                RankHistory = new User.RankHistoryData
-                {
-                    Mode = @"osu",
-                    Data = Enumerable.Range(2345, 45).Concat(Enumerable.Range(2109, 40)).ToArray()
-                },
-                Badges = new[]
-                {
-                    new Badge
-                    {
-                        AwardedAt = DateTimeOffset.FromUnixTimeSeconds(1505741569),
-                        Description = "Outstanding help by being a voluntary test subject.",
-                        ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg"
-                    }
-                }
-            }, false));
-
-            checkSupporterTag(false);
+            AddStep("Show offline dummy", () => profile.ShowUser(TEST_USER, false));
 
             AddStep("Show null dummy", () => profile.ShowUser(new User
             {
@@ -92,8 +98,6 @@ namespace osu.Game.Tests.Visual
                 CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg"
             }, api.IsLoggedIn));
 
-            checkSupporterTag(true);
-
             AddStep("Show flyte", () => profile.ShowUser(new User
             {
                 Username = @"flyte",
@@ -106,15 +110,6 @@ namespace osu.Game.Tests.Visual
             AddStep("Show without reload", profile.Show);
         }
 
-        private void checkSupporterTag(bool isSupporter)
-        {
-            AddUntilStep(() => profile.Header.User != null, "wait for load");
-            if (isSupporter)
-                AddAssert("is supporter", () => profile.Header.SupporterTag.Alpha == 1);
-            else
-                AddAssert("no supporter", () => profile.Header.SupporterTag.Alpha == 0);
-        }
-
         private class TestUserProfileOverlay : UserProfileOverlay
         {
             public new ProfileHeader Header => base.Header;

osu.Game.Tests/Visual/Online/TestCaseUserProfileHeader.cs

@@ -0,0 +1,81 @@
+// 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 System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Overlays.Profile;
+using osu.Game.Overlays.Profile.Header;
+using osu.Game.Overlays.Profile.Header.Components;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestCaseUserProfileHeader : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(ProfileHeader),
+            typeof(RankGraph),
+            typeof(LineGraph),
+            typeof(ProfileHeaderTabControl),
+            typeof(CentreHeaderContainer),
+            typeof(BottomHeaderContainer),
+            typeof(DetailHeaderContainer),
+            typeof(ProfileHeaderButton)
+        };
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        private readonly ProfileHeader header;
+
+        public TestCaseUserProfileHeader()
+        {
+            header = new ProfileHeader();
+            Add(header);
+
+            AddStep("Show offline dummy", () => header.User.Value = TestCaseUserProfile.TEST_USER);
+
+            AddStep("Show null dummy", () => header.User.Value = new User
+            {
+                Username = "Null"
+            });
+
+            addOnlineStep("Show ppy", new User
+            {
+                Username = @"peppy",
+                Id = 2,
+                IsSupporter = true,
+                Country = new Country { FullName = @"Australia", FlagName = @"AU" },
+                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c3.jpg"
+            });
+
+            addOnlineStep("Show flyte", new User
+            {
+                Username = @"flyte",
+                Id = 3103765,
+                Country = new Country { FullName = @"Japan", FlagName = @"JP" },
+                CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c6.jpg"
+            });
+        }
+
+        private void addOnlineStep(string name, User fallback)
+        {
+            AddStep(name, () =>
+            {
+                if (api.IsLoggedIn)
+                {
+                    var request = new GetUserRequest(fallback.Id);
+                    request.Success += user => header.User.Value = user;
+                    api.Queue(request);
+                }
+                else
+                    header.User.Value = fallback;
+            });
+        }
+    }
+}

osu.Game.Tests/Visual/Online/TestCaseUserProfileRecentSection.cs

@@ -1,20 +1,20 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Profile.Sections;
 using osu.Game.Overlays.Profile.Sections.Recent;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Game.Online.API.Requests.Responses;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseUserProfileRecentSection : OsuTestCase

osu.Game.Tests/Visual/Online/TestCaseUserRanks.cs

@@ -1,6 +1,9 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
+using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -8,11 +11,8 @@ using osu.Game.Graphics;
 using osu.Game.Overlays.Profile.Sections;
 using osu.Game.Overlays.Profile.Sections.Ranks;
 using osu.Game.Users;
-using System;
-using System.Collections.Generic;
-using NUnit.Framework;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Online
 {
     [TestFixture]
     public class TestCaseUserRanks : OsuTestCase

osu.Game.Tests/Visual/Settings/TestCaseKeyConfiguration.cs

@@ -1,10 +1,10 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Game.Overlays;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Settings
 {
     [TestFixture]
     public class TestCaseKeyConfiguration : OsuTestCase

osu.Game.Tests/Visual/Settings/TestCaseSettings.cs

@@ -1,12 +1,12 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Allocation;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Overlays;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.Settings
 {
     [TestFixture]
     public class TestCaseSettings : OsuTestCase

osu.Game.Tests/Visual/SongSelect/TestCaseBeatmapCarousel.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -17,7 +17,7 @@ using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.SongSelect
 {
     [TestFixture]
     public class TestCaseBeatmapCarousel : OsuTestCase
@@ -40,7 +40,6 @@ namespace osu.Game.Tests.Visual
             typeof(DrawableCarouselBeatmapSet),
         };
 
-
         private readonly Stack<BeatmapSetInfo> selectedSets = new Stack<BeatmapSetInfo>();
         private readonly HashSet<int> eagerSelectedIDs = new HashSet<int>();
 
@@ -88,7 +87,7 @@ namespace osu.Game.Tests.Visual
                 carousel.BeatmapSetsChanged = () => changed = true;
                 carousel.BeatmapSets = beatmapSets;
             });
-            AddUntilStep(() => changed, "Wait for load");
+            AddUntilStep("Wait for load", () => changed);
         }
 
         private void ensureRandomFetchSuccess() =>
@@ -148,9 +147,10 @@ namespace osu.Game.Tests.Visual
 
         private bool selectedBeatmapVisible()
         {
-            var currentlySelected = carousel.Items.FirstOrDefault(s => s.Item is CarouselBeatmap && s.Item.State == CarouselItemState.Selected);
+            var currentlySelected = carousel.Items.Find(s => s.Item is CarouselBeatmap && s.Item.State.Value == CarouselItemState.Selected);
             if (currentlySelected == null)
                 return true;
+
             return currentlySelected.Item.Visible;
         }
 
@@ -167,8 +167,7 @@ namespace osu.Game.Tests.Visual
                 carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false);
                 carousel.Filter(new FilterCriteria(), false);
                 eagerSelectedIDs.Add(carousel.SelectedBeatmapSet.ID);
-            }
-            );
+            });
         }
 
         /// <summary>
@@ -215,7 +214,7 @@ namespace osu.Game.Tests.Visual
             checkSelected(3, 2);
 
             AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
-            AddUntilStep(() => !carousel.PendingFilterTask, "Wait for debounce");
+            AddUntilStep("Wait for debounce", () => !carousel.PendingFilterTask);
             checkVisibleItemCount(diff: false, count: set_count);
             checkVisibleItemCount(diff: true, count: 3);
 
@@ -328,13 +327,13 @@ namespace osu.Game.Tests.Visual
             AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
             checkSelected(1);
 
-            AddUntilStep(() =>
+            AddUntilStep("Remove all", () =>
             {
                 if (!carousel.BeatmapSets.Any()) return true;
 
                 carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
                 return false;
-            }, "Remove all");
+            });
 
             checkNoSelection();
         }
@@ -509,6 +508,7 @@ namespace osu.Game.Tests.Visual
                 },
                 Beatmaps = new List<BeatmapInfo>(),
             };
+
             for (int b = 1; b < 101; b++)
             {
                 toReturn.Beatmaps.Add(new BeatmapInfo
@@ -523,6 +523,7 @@ namespace osu.Game.Tests.Visual
                     }
                 });
             }
+
             return toReturn;
         }
 

osu.Game.Tests/Visual/SongSelect/TestCaseBeatmapDetailArea.cs

@@ -0,0 +1,160 @@
+// 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 System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.SongSelect
+{
+    [TestFixture]
+    [System.ComponentModel.Description("PlaySongSelect leaderboard/details area")]
+    public class TestCaseBeatmapDetailArea : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BeatmapDetails) };
+
+        public TestCaseBeatmapDetailArea()
+        {
+            BeatmapDetailArea detailsArea;
+            Add(detailsArea = new BeatmapDetailArea
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(550f, 450f),
+            });
+
+            AddStep("all metrics", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+                {
+                    BeatmapInfo =
+                    {
+                        Version = "All Metrics",
+                        Metadata = new BeatmapMetadata
+                        {
+                            Source = "osu!lazer",
+                            Tags = "this beatmap has all the metrics",
+                        },
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            CircleSize = 7,
+                            DrainRate = 1,
+                            OverallDifficulty = 5.7f,
+                            ApproachRate = 3.5f,
+                        },
+                        StarDifficulty = 5.3f,
+                        Metrics = new BeatmapMetrics
+                        {
+                            Ratings = Enumerable.Range(0, 11),
+                            Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                            Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                        },
+                    }
+                }
+            );
+
+            AddStep("all except source", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "All Metrics",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Tags = "this beatmap has all the metrics",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 7,
+                        DrainRate = 1,
+                        OverallDifficulty = 5.7f,
+                        ApproachRate = 3.5f,
+                    },
+                    StarDifficulty = 5.3f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Ratings = Enumerable.Range(0, 11),
+                        Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                        Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                    },
+                }
+            });
+
+            AddStep("ratings", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "Only Ratings",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has ratings metrics but not retries or fails",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 6,
+                        DrainRate = 9,
+                        OverallDifficulty = 6,
+                        ApproachRate = 6,
+                    },
+                    StarDifficulty = 4.8f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Ratings = Enumerable.Range(0, 11),
+                    },
+                }
+            });
+
+            AddStep("fails+retries", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "Only Retries and Fails",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has retries and fails but no ratings",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 3.7f,
+                        DrainRate = 6,
+                        OverallDifficulty = 6,
+                        ApproachRate = 7,
+                    },
+                    StarDifficulty = 2.91f,
+                    Metrics = new BeatmapMetrics
+                    {
+                        Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                        Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                    },
+                }
+            });
+
+            AddStep("null metrics", () => detailsArea.Beatmap = new DummyWorkingBeatmap
+            {
+                BeatmapInfo =
+                {
+                    Version = "No Metrics",
+                    Metadata = new BeatmapMetadata
+                    {
+                        Source = "osu!lazer",
+                        Tags = "this beatmap has no metrics",
+                    },
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 5,
+                        DrainRate = 5,
+                        OverallDifficulty = 5.5f,
+                        ApproachRate = 6.5f,
+                    },
+                    StarDifficulty = 1.97f,
+                }
+            });
+
+            AddStep("null beatmap", () => detailsArea.Beatmap = null);
+        }
+    }
+}

osu.Game.Tests/Visual/SongSelect/TestCaseBeatmapDetails.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.ComponentModel;
 using System.Linq;
@@ -7,7 +7,7 @@ using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Select;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.SongSelect
 {
     [Description("PlaySongSelect beatmap details")]
     public class TestCaseBeatmapDetails : OsuTestCase
@@ -21,7 +21,7 @@ namespace osu.Game.Tests.Visual
                 Padding = new MarginPadding(150),
             });
 
-            AddStep("beatmap all metrics", () => details.Beatmap = new BeatmapInfo
+            AddStep("all metrics", () => details.Beatmap = new BeatmapInfo
             {
                 Version = "All Metrics",
                 Metadata = new BeatmapMetadata
@@ -45,7 +45,30 @@ namespace osu.Game.Tests.Visual
                 },
             });
 
-            AddStep("beatmap ratings", () => details.Beatmap = new BeatmapInfo
+            AddStep("all except source", () => details.Beatmap = new BeatmapInfo
+            {
+                Version = "All Metrics",
+                Metadata = new BeatmapMetadata
+                {
+                    Tags = "this beatmap has all the metrics",
+                },
+                BaseDifficulty = new BeatmapDifficulty
+                {
+                    CircleSize = 7,
+                    DrainRate = 1,
+                    OverallDifficulty = 5.7f,
+                    ApproachRate = 3.5f,
+                },
+                StarDifficulty = 5.3f,
+                Metrics = new BeatmapMetrics
+                {
+                    Ratings = Enumerable.Range(0, 11),
+                    Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                    Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                },
+            });
+
+            AddStep("ratings", () => details.Beatmap = new BeatmapInfo
             {
                 Version = "Only Ratings",
                 Metadata = new BeatmapMetadata
@@ -67,7 +90,7 @@ namespace osu.Game.Tests.Visual
                 },
             });
 
-            AddStep("beatmap fails retries", () => details.Beatmap = new BeatmapInfo
+            AddStep("fails retries", () => details.Beatmap = new BeatmapInfo
             {
                 Version = "Only Retries and Fails",
                 Metadata = new BeatmapMetadata
@@ -90,7 +113,7 @@ namespace osu.Game.Tests.Visual
                 },
             });
 
-            AddStep("beatmap no metrics", () => details.Beatmap = new BeatmapInfo
+            AddStep("no metrics", () => details.Beatmap = new BeatmapInfo
             {
                 Version = "No Metrics",
                 Metadata = new BeatmapMetadata

osu.Game.Tests/Visual/SongSelect/TestCaseBeatmapInfoWedge.cs

@@ -1,11 +1,10 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.Collections.Generic;
 using System.Linq;
 using JetBrains.Annotations;
 using NUnit.Framework;
-using OpenTK;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -20,8 +19,9 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Taiko;
 using osu.Game.Screens.Select;
 using osu.Game.Tests.Beatmaps;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.SongSelect
 {
     [TestFixture]
     public class TestCaseBeatmapInfoWedge : OsuTestCase
@@ -50,17 +50,17 @@ namespace osu.Game.Tests.Visual
             AddStep("show", () =>
             {
                 infoWedge.State = Visibility.Visible;
-                infoWedge.Beatmap = Beatmap;
+                infoWedge.Beatmap = Beatmap.Value;
             });
 
             // select part is redundant, but wait for load isn't
             selectBeatmap(Beatmap.Value.Beatmap);
 
-            AddWaitStep(3);
+            AddWaitStep("wait for select", 3);
 
             AddStep("hide", () => { infoWedge.State = Visibility.Hidden; });
 
-            AddWaitStep(3);
+            AddWaitStep("wait for hide", 3);
 
             AddStep("show", () => { infoWedge.State = Visibility.Visible; });
 
@@ -83,15 +83,19 @@ namespace osu.Game.Tests.Visual
                     case OsuRuleset _:
                         testInfoLabels(5);
                         break;
+
                     case TaikoRuleset _:
                         testInfoLabels(5);
                         break;
+
                     case CatchRuleset _:
                         testInfoLabels(5);
                         break;
+
                     case ManiaRuleset _:
                         testInfoLabels(4);
                         break;
+
                     default:
                         testInfoLabels(2);
                         break;
@@ -135,7 +139,7 @@ namespace osu.Game.Tests.Visual
                 infoWedge.Beatmap = Beatmap.Value = b == null ? Beatmap.Default : new TestWorkingBeatmap(b);
             });
 
-            AddUntilStep(() => infoWedge.Info != infoBefore, "wait for async load");
+            AddUntilStep("wait for async load", () => infoWedge.Info != infoBefore);
         }
 
         private IBeatmap createTestBeatmap(RulesetInfo ruleset)

osu.Game.Tests/Visual/SongSelect/TestCaseBeatmapOptionsOverlay.cs

@@ -1,13 +1,13 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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.ComponentModel;
-using osu.Game.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Screens.Select.Options;
-using OpenTK.Graphics;
-using OpenTK.Input;
+using osuTK.Graphics;
+using osuTK.Input;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.SongSelect
 {
     [Description("bottom beatmap details")]
     public class TestCaseBeatmapOptionsOverlay : OsuTestCase
@@ -16,10 +16,10 @@ namespace osu.Game.Tests.Visual
         {
             var overlay = new BeatmapOptionsOverlay();
 
-            overlay.AddButton(@"Remove", @"from unplayed", FontAwesome.fa_times_circle_o, Color4.Purple, null, Key.Number1);
-            overlay.AddButton(@"Clear", @"local scores", FontAwesome.fa_eraser, Color4.Purple, null, Key.Number2);
-            overlay.AddButton(@"Edit", @"Beatmap", FontAwesome.fa_pencil, Color4.Yellow, null, Key.Number3);
-            overlay.AddButton(@"Delete", @"Beatmap", FontAwesome.fa_trash, Color4.Pink, null, Key.Number4, float.MaxValue);
+            overlay.AddButton(@"Remove", @"from unplayed", FontAwesome.Regular.TimesCircle, Color4.Purple, null, Key.Number1);
+            overlay.AddButton(@"Clear", @"local scores", FontAwesome.Solid.Eraser, Color4.Purple, null, Key.Number2);
+            overlay.AddButton(@"Edit", @"Beatmap", FontAwesome.Solid.PencilAlt, Color4.Yellow, null, Key.Number3);
+            overlay.AddButton(@"Delete", @"Beatmap", FontAwesome.Solid.Trash, Color4.Pink, null, Key.Number4, float.MaxValue);
 
             Add(overlay);
 

osu.Game.Tests/Visual/SongSelect/TestCaseLeaderboard.cs

@@ -1,25 +1,27 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using System.ComponentModel;
+using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Leaderboards;
+using osu.Game.Rulesets;
+using osu.Game.Scoring;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
-using osu.Framework.Allocation;
-using OpenTK;
-using System.Linq;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
+using osuTK;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.SongSelect
 {
     [Description("PlaySongSelect leaderboard")]
     public class TestCaseLeaderboard : OsuTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
             typeof(Placeholder),
             typeof(MessagePlaceholder),
             typeof(RetrievalFailurePlaceholder),
@@ -36,7 +38,7 @@ namespace osu.Game.Tests.Visual
                 Origin = Anchor.Centre,
                 Anchor = Anchor.Centre,
                 Size = new Vector2(550f, 450f),
-                Scope = LeaderboardScope.Global,
+                Scope = BeatmapLeaderboardScope.Global,
             });
 
             AddStep(@"New Scores", newScores);
@@ -58,7 +60,7 @@ namespace osu.Game.Tests.Visual
         {
             var scores = new[]
             {
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.XH,
                     Accuracy = 1,
@@ -76,7 +78,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.X,
                     Accuracy = 1,
@@ -94,7 +96,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.SH,
                     Accuracy = 1,
@@ -112,7 +114,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.S,
                     Accuracy = 1,
@@ -130,7 +132,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.A,
                     Accuracy = 1,
@@ -148,7 +150,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.B,
                     Accuracy = 0.9826,
@@ -166,7 +168,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.C,
                     Accuracy = 0.9654,
@@ -184,7 +186,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.F,
                     Accuracy = 0.6025,
@@ -202,7 +204,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.F,
                     Accuracy = 0.5140,
@@ -220,7 +222,7 @@ namespace osu.Game.Tests.Visual
                         },
                     },
                 },
-                new Score
+                new ScoreInfo
                 {
                     Rank = ScoreRank.F,
                     Accuracy = 0.4222,
@@ -275,7 +277,7 @@ namespace osu.Game.Tests.Visual
             };
         }
 
-        private class FailableLeaderboard : Leaderboard
+        private class FailableLeaderboard : BeatmapLeaderboard
         {
             public void SetRetrievalState(PlaceholderState state)
             {

osu.Game.Tests/Visual/SongSelect/TestCasePlaySongSelect.cs

@@ -1,5 +1,5 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
@@ -8,9 +8,11 @@ using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Configuration;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.MathUtils;
+using osu.Framework.Platform;
+using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
@@ -21,10 +23,10 @@ using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
 
-namespace osu.Game.Tests.Visual
+namespace osu.Game.Tests.Visual.SongSelect
 {
     [TestFixture]
-    public class TestCasePlaySongSelect : OsuTestCase
+    public class TestCasePlaySongSelect : ScreenTestCase
     {
         private BeatmapManager manager;
 
@@ -33,13 +35,9 @@ namespace osu.Game.Tests.Visual
         private WorkingBeatmap defaultBeatmap;
         private DatabaseContextFactory factory;
 
-        [Cached]
-        [Cached(Type = typeof(IBindable<IEnumerable<Mod>>))]
-        private readonly Bindable<IEnumerable<Mod>> selectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
-
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(SongSelect),
+            typeof(Screens.Select.SongSelect),
             typeof(BeatmapCarousel),
 
             typeof(CarouselItem),
@@ -57,11 +55,19 @@ namespace osu.Game.Tests.Visual
 
         private class TestSongSelect : PlaySongSelect
         {
+            public Action StartRequested;
+
             public new Bindable<RulesetInfo> Ruleset => base.Ruleset;
 
             public WorkingBeatmap CurrentBeatmap => Beatmap.Value;
             public WorkingBeatmap CurrentBeatmapDetailsBeatmap => BeatmapDetails.Beatmap;
             public new BeatmapCarousel Carousel => base.Carousel;
+
+            protected override bool OnStart()
+            {
+                StartRequested?.Invoke();
+                return base.OnStart();
+            }
         }
 
         private TestSongSelect songSelect;
@@ -73,7 +79,7 @@ namespace osu.Game.Tests.Visual
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(GameHost host)
         {
             factory = new DatabaseContextFactory(LocalStorage);
             factory.ResetDatabase();
@@ -87,30 +93,25 @@ namespace osu.Game.Tests.Visual
                 usage.Migrate();
 
             Dependencies.Cache(rulesets = new RulesetStore(factory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, factory, rulesets, null, null)
-            {
-                DefaultBeatmap = defaultBeatmap = Beatmap.Default
-            });
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, factory, rulesets, null, null, host, defaultBeatmap = Beatmap.Default));
 
             Beatmap.SetDefault();
         }
 
         [SetUp]
-        public virtual void SetUp()
-        {
-            manager?.Delete(manager.GetAllUsableBeatmapSets());
-            Child = songSelect = new TestSongSelect();
-        }
+        public virtual void SetUp() =>
+            Schedule(() => { manager?.Delete(manager.GetAllUsableBeatmapSets()); });
 
         [Test]
         public void TestDummy()
         {
+            createSongSelect();
             AddAssert("dummy selected", () => songSelect.CurrentBeatmap == defaultBeatmap);
 
-            AddAssert("dummy shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
+            AddUntilStep("dummy shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap == defaultBeatmap);
 
             addManyTestMaps();
-            AddWaitStep(3);
+            AddWaitStep("wait for select", 3);
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
         }
@@ -118,8 +119,9 @@ namespace osu.Game.Tests.Visual
         [Test]
         public void TestSorting()
         {
+            createSongSelect();
             addManyTestMaps();
-            AddWaitStep(3);
+            AddWaitStep("wait for add", 3);
 
             AddAssert("random map selected", () => songSelect.CurrentBeatmap != defaultBeatmap);
 
@@ -133,29 +135,32 @@ namespace osu.Game.Tests.Visual
         [Ignore("needs fixing")]
         public void TestImportUnderDifferentRuleset()
         {
+            createSongSelect();
             changeRuleset(2);
             importForRuleset(0);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
+            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmap == null);
         }
 
         [Test]
         public void TestImportUnderCurrentRuleset()
         {
+            createSongSelect();
             changeRuleset(2);
             importForRuleset(2);
             importForRuleset(1);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap.RulesetID == 2, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.RulesetID == 2);
 
             changeRuleset(1);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap.RulesetID == 1, "has selection");
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.RulesetID == 1);
 
             changeRuleset(0);
-            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
+            AddUntilStep("no selection", () => songSelect.Carousel.SelectedBeatmap == null);
         }
 
         [Test]
         public void TestRulesetChangeResetsMods()
         {
+            createSongSelect();
             changeRuleset(0);
 
             changeMods(new OsuModHardRock());
@@ -166,20 +171,42 @@ namespace osu.Game.Tests.Visual
 
             AddStep("change ruleset", () =>
             {
-                songSelect.CurrentBeatmap.Mods.ValueChanged += onModChange;
+                Mods.ValueChanged += onModChange;
                 songSelect.Ruleset.ValueChanged += onRulesetChange;
 
                 Ruleset.Value = new TaikoRuleset().RulesetInfo;
 
-                songSelect.CurrentBeatmap.Mods.ValueChanged -= onModChange;
+                Mods.ValueChanged -= onModChange;
                 songSelect.Ruleset.ValueChanged -= onRulesetChange;
             });
 
             AddAssert("mods changed before ruleset", () => modChangeIndex < rulesetChangeIndex);
-            AddAssert("empty mods", () => !selectedMods.Value.Any());
+            AddAssert("empty mods", () => !Mods.Value.Any());
 
-            void onModChange(IEnumerable<Mod> mods) => modChangeIndex = actionIndex++;
-            void onRulesetChange(RulesetInfo ruleset) => rulesetChangeIndex = actionIndex--;
+            void onModChange(ValueChangedEvent<IReadOnlyList<Mod>> e) => modChangeIndex = actionIndex++;
+            void onRulesetChange(ValueChangedEvent<RulesetInfo> e) => rulesetChangeIndex = actionIndex--;
+        }
+
+        [Test]
+        public void TestStartAfterUnMatchingFilterDoesNotStart()
+        {
+            createSongSelect();
+            addManyTestMaps();
+            AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap != null);
+
+            bool startRequested = false;
+
+            AddStep("set filter and finalize", () =>
+            {
+                songSelect.StartRequested = () => startRequested = true;
+
+                songSelect.Carousel.Filter(new FilterCriteria { SearchText = "somestringthatshouldn'tbematchable" });
+                songSelect.FinaliseSelection();
+
+                songSelect.StartRequested = null;
+            });
+
+            AddAssert("start not requested", () => !startRequested);
         }
 
         private void importForRuleset(int id) => AddStep($"import test map for ruleset {id}", () => manager.Import(createTestBeatmapSet(getImportId(), rulesets.AvailableRulesets.Where(r => r.ID == id).ToArray())));
@@ -187,10 +214,16 @@ namespace osu.Game.Tests.Visual
         private static int importId;
         private int getImportId() => ++importId;
 
-        private void changeMods(params Mod[] mods) => AddStep($"change mods to {string.Join(", ", mods.Select(m => m.ShortenedName))}", () => selectedMods.Value = mods);
+        private void changeMods(params Mod[] mods) => AddStep($"change mods to {string.Join(", ", mods.Select(m => m.Acronym))}", () => Mods.Value = mods);
 
         private void changeRuleset(int id) => AddStep($"change ruleset to {id}", () => Ruleset.Value = rulesets.AvailableRulesets.First(r => r.ID == id));
 
+        private void createSongSelect()
+        {
+            AddStep("create song select", () => LoadScreen(songSelect = new TestSongSelect()));
+            AddUntilStep("wait for present", () => songSelect.IsCurrentScreen());
+        }
+
         private void addManyTestMaps()
         {
             AddStep("import test maps", () =>

osu.Game.Tests/Visual/TestCaseAllPlayers.cs

@@ -1,12 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseAllPlayers : TestCasePlayer
-    {
-    }
-}

osu.Game.Tests/Visual/TestCaseAutoplay.cs

@@ -1,33 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.ComponentModel;
-using System.Linq;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Screens.Play;
-
-namespace osu.Game.Tests.Visual
-{
-    [Description("Player instantiated with an autoplay mod.")]
-    public class TestCaseAutoplay : TestCasePlayer
-    {
-        protected override Player CreatePlayer(Ruleset ruleset)
-        {
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
-            return new ScoreAccessiblePlayer
-            {
-                AllowPause = false,
-                AllowLeadIn = false,
-                AllowResults = false,
-            };
-        }
-
-        protected override bool ContinueCondition(Player player) => base.ContinueCondition(player) &&  ((ScoreAccessiblePlayer)player).ScoreProcessor.TotalScore > 0;
-
-        private class ScoreAccessiblePlayer : Player
-        {
-            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseBadgeContainer.cs

@@ -1,62 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Game.Overlays.Profile.Header;
-using osu.Game.Users;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseBadgeContainer : OsuTestCase
-    {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(BadgeContainer) };
-
-        public TestCaseBadgeContainer()
-        {
-            BadgeContainer badgeContainer;
-
-            Child = badgeContainer = new BadgeContainer
-            {
-                RelativeSizeAxes = Axes.Both
-            };
-
-            AddStep("Show 1 badge", () => badgeContainer.ShowBadges(new[]
-            {
-                new Badge
-                {
-                    AwardedAt = DateTimeOffset.Now,
-                    Description = "Appreciates compasses",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/mg2018-1star.png",
-                }
-            }));
-
-            AddStep("Show 2 badges", () => badgeContainer.ShowBadges(new[]
-            {
-                new Badge
-                {
-                    AwardedAt = DateTimeOffset.Now,
-                    Description = "Contributed to osu!lazer testing",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.png",
-                },
-                new Badge
-                {
-                    AwardedAt = DateTimeOffset.Now,
-                    Description = "Appreciates compasses",
-                    ImageUrl = "https://assets.ppy.sh/profile-badges/mg2018-1star.png",
-                }
-            }));
-
-            AddStep("Show many badges", () => badgeContainer.ShowBadges(Enumerable.Range(1, 20).Select(i => new Badge
-            {
-                AwardedAt = DateTimeOffset.Now,
-                Description = $"Contributed to osu!lazer testing {i} times",
-                ImageUrl = "https://assets.ppy.sh/profile-badges/contributor.jpg",
-            }).ToArray()));
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseBeatmapDetailArea.cs

@@ -1,25 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Game.Screens.Select;
-using OpenTK;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    [System.ComponentModel.Description("PlaySongSelect leaderboard/details area")]
-    public class TestCaseBeatmapDetailArea : OsuTestCase
-    {
-        public TestCaseBeatmapDetailArea()
-        {
-            Add(new BeatmapDetailArea
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Size = new Vector2(550f, 450f),
-            });
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseBeatmapScoresContainer.cs

@@ -1,315 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.MathUtils;
-using osu.Game.Graphics;
-using osu.Game.Overlays.BeatmapSet.Scores;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Users;
-using System.Collections.Generic;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Online.API.Requests.Responses;
-using osu.Game.Rulesets.Osu;
-
-namespace osu.Game.Tests.Visual
-{
-    [System.ComponentModel.Description("in BeatmapOverlay")]
-    public class TestCaseBeatmapScoresContainer : OsuTestCase
-    {
-        private readonly IEnumerable<APIScore> scores;
-        private readonly IEnumerable<APIScore> anotherScores;
-        private readonly APIScore topScore;
-        private readonly Box background;
-
-        public TestCaseBeatmapScoresContainer()
-        {
-            Container container;
-            ScoresContainer scoresContainer;
-
-            Child = container = new Container
-            {
-                Anchor = Anchor.TopCentre,
-                Origin = Anchor.TopCentre,
-                AutoSizeAxes = Axes.Y,
-                RelativeSizeAxes = Axes.X,
-                Width = 0.8f,
-                Children = new Drawable[]
-                {
-                    background = new Box { RelativeSizeAxes = Axes.Both },
-                    scoresContainer = new ScoresContainer(),
-                }
-            };
-
-            AddStep("scores pack 1", () => scoresContainer.Scores = scores);
-            AddStep("scores pack 2", () => scoresContainer.Scores = anotherScores);
-            AddStep("only top score", () => scoresContainer.Scores = new[] { topScore });
-            AddStep("remove scores", () => scoresContainer.Scores = null);
-            AddStep("resize to big", () => container.ResizeWidthTo(1, 300));
-            AddStep("resize to normal", () => container.ResizeWidthTo(0.8f, 300));
-            AddStep("online scores", () => scoresContainer.Beatmap = new BeatmapInfo { OnlineBeatmapID = 75, Ruleset = new OsuRuleset().RulesetInfo });
-
-
-            scores = new[]
-            {
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 6602580,
-                        Username = @"waaiiru",
-                        Country = new Country
-                        {
-                            FullName = @"Spain",
-                            FlagName = @"ES",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                        new OsuModHardRock(),
-                    },
-                    Rank = ScoreRank.XH,
-                    TotalScore = 1234567890,
-                    Accuracy = 1,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 4608074,
-                        Username = @"Skycries",
-                        Country = new Country
-                        {
-                            FullName = @"Brazil",
-                            FlagName = @"BR",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                    },
-                    Rank = ScoreRank.S,
-                    TotalScore = 1234789,
-                    Accuracy = 0.9997,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 1014222,
-                        Username = @"eLy",
-                        Country = new Country
-                        {
-                            FullName = @"Japan",
-                            FlagName = @"JP",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                    },
-                    Rank = ScoreRank.B,
-                    TotalScore = 12345678,
-                    Accuracy = 0.9854,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 1541390,
-                        Username = @"Toukai",
-                        Country = new Country
-                        {
-                            FullName = @"Canada",
-                            FlagName = @"CA",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                    },
-                    Rank = ScoreRank.C,
-                    TotalScore = 1234567,
-                    Accuracy = 0.8765,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 7151382,
-                        Username = @"Mayuri Hana",
-                        Country = new Country
-                        {
-                            FullName = @"Thailand",
-                            FlagName = @"TH",
-                        },
-                    },
-                    Rank = ScoreRank.F,
-                    TotalScore = 123456,
-                    Accuracy = 0.6543,
-                },
-            };
-            foreach(var s in scores)
-            {
-                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
-            }
-
-            anotherScores = new[]
-            {
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 4608074,
-                        Username = @"Skycries",
-                        Country = new Country
-                        {
-                            FullName = @"Brazil",
-                            FlagName = @"BR",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                    },
-                    Rank = ScoreRank.S,
-                    TotalScore = 1234789,
-                    Accuracy = 0.9997,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 6602580,
-                        Username = @"waaiiru",
-                        Country = new Country
-                        {
-                            FullName = @"Spain",
-                            FlagName = @"ES",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                        new OsuModFlashlight(),
-                        new OsuModHardRock(),
-                    },
-                    Rank = ScoreRank.XH,
-                    TotalScore = 1234567890,
-                    Accuracy = 1,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 7151382,
-                        Username = @"Mayuri Hana",
-                        Country = new Country
-                        {
-                            FullName = @"Thailand",
-                            FlagName = @"TH",
-                        },
-                    },
-                    Rank = ScoreRank.F,
-                    TotalScore = 123456,
-                    Accuracy = 0.6543,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 1014222,
-                        Username = @"eLy",
-                        Country = new Country
-                        {
-                            FullName = @"Japan",
-                            FlagName = @"JP",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                        new OsuModHidden(),
-                    },
-                    Rank = ScoreRank.B,
-                    TotalScore = 12345678,
-                    Accuracy = 0.9854,
-                },
-                new APIScore
-                {
-                    User = new User
-                    {
-                        Id = 1541390,
-                        Username = @"Toukai",
-                        Country = new Country
-                        {
-                            FullName = @"Canada",
-                            FlagName = @"CA",
-                        },
-                    },
-                    Mods = new Mod[]
-                    {
-                        new OsuModDoubleTime(),
-                    },
-                    Rank = ScoreRank.C,
-                    TotalScore = 1234567,
-                    Accuracy = 0.8765,
-                },
-            };
-            foreach (var s in anotherScores)
-            {
-                s.Statistics.Add(HitResult.Great, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Good, RNG.Next(2000));
-                s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
-            }
-
-            topScore = new APIScore
-            {
-                User = new User
-                {
-                    Id = 2705430,
-                    Username = @"Mooha",
-                    Country = new Country
-                    {
-                        FullName = @"France",
-                        FlagName = @"FR",
-                    },
-                },
-                Mods = new Mod[]
-                {
-                    new OsuModDoubleTime(),
-                    new OsuModFlashlight(),
-                    new OsuModHardRock(),
-                },
-                Rank = ScoreRank.B,
-                TotalScore = 987654321,
-                Accuracy = 0.8487,
-            };
-            topScore.Statistics.Add(HitResult.Great, RNG.Next(2000));
-            topScore.Statistics.Add(HitResult.Good, RNG.Next(2000));
-            topScore.Statistics.Add(HitResult.Meh, RNG.Next(2000));
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            background.Colour = colours.Gray2;
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseCharLookup.cs

@@ -0,0 +1,16 @@
+// 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.Game.Graphics.Sprites;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseCharLookup : OsuTestCase
+    {
+        public TestCaseCharLookup()
+        {
+            AddStep("null", () => { });
+            AddStep("display acharacter", () => Add(new OsuSpriteText { Text = "振込申請" }));
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseChatDisplay.cs

@@ -1,21 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.ComponentModel;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Overlays;
-
-namespace osu.Game.Tests.Visual
-{
-    [Description("Testing chat api and overlay")]
-    public class TestCaseChatDisplay : OsuTestCase
-    {
-        public TestCaseChatDisplay()
-        {
-            Add(new ChatOverlay
-            {
-                State = Visibility.Visible
-            });
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseDisclaimer.cs

@@ -1,28 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Screens.Menu;
-using OpenTK.Graphics;
-
-namespace osu.Game.Tests.Visual
-{
-    public class TestCaseDisclaimer : OsuTestCase
-    {
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Children = new Drawable[]
-            {
-                new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Colour = Color4.Black,
-                },
-                new Disclaimer()
-            };
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseDrawableRoom.cs

@@ -1,135 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
-using osu.Game.Screens.Multi.Components;
-using osu.Game.Users;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseDrawableRoom : OsuTestCase
-    {
-        private RulesetStore rulesets;
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            DrawableRoom first;
-            Add(new FillFlowContainer
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                AutoSizeAxes = Axes.Y,
-                Width = 580f,
-                Direction = FillDirection.Vertical,
-                Children = new Drawable[]
-                {
-                    first = new DrawableRoom(new Room
-                    {
-                        Name = { Value = @"Great Room Right Here" },
-                        Host = { Value = new User { Username = @"Naeferith", Id = 9492835, Country = new Country { FlagName = @"FR" } } },
-                        Status = { Value = new RoomStatusOpen() },
-                        Type = { Value = new GameTypeTeamVersus() },
-                        Beatmap =
-                        {
-                            Value = new BeatmapInfo
-                            {
-                                StarDifficulty = 4.65,
-                                Ruleset = rulesets.GetRuleset(3),
-                                Metadata = new BeatmapMetadata
-                                {
-                                    Title = @"Critical Crystal",
-                                    Artist = @"Seiryu",
-                                },
-                                BeatmapSet = new BeatmapSetInfo
-                                {
-                                    OnlineInfo = new BeatmapSetOnlineInfo
-                                    {
-                                        Covers = new BeatmapSetOnlineCovers
-                                        {
-                                            Cover = @"https://assets.ppy.sh//beatmaps/376340/covers/cover.jpg?1456478455",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        Participants =
-                        {
-                            Value = new[]
-                            {
-                                new User { Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 1355 } } },
-                                new User { Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 8756 } } },
-                            },
-                        },
-                    }),
-                    new DrawableRoom(new Room
-                    {
-                        Name = { Value = @"Relax It's The Weekend" },
-                        Host = { Value = new User { Username = @"peppy", Id = 2, Country = new Country { FlagName = @"AU" } } },
-                        Status = { Value = new RoomStatusPlaying() },
-                        Type = { Value = new GameTypeTagTeam() },
-                        Beatmap =
-                        {
-                            Value = new BeatmapInfo
-                            {
-                                StarDifficulty = 1.96,
-                                Ruleset = rulesets.GetRuleset(0),
-                                Metadata = new BeatmapMetadata
-                                {
-                                    Title = @"Serendipity",
-                                    Artist = @"ZAQ",
-                                },
-                                BeatmapSet = new BeatmapSetInfo
-                                {
-                                    OnlineInfo = new BeatmapSetOnlineInfo
-                                    {
-                                        Covers = new BeatmapSetOnlineCovers
-                                        {
-                                            Cover = @"https://assets.ppy.sh//beatmaps/526839/covers/cover.jpg?1493815706",
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        Participants =
-                        {
-                            Value = new[]
-                            {
-                                new User { Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 578975 } } },
-                                new User { Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 24554 } } },
-                            },
-                        },
-                    }),
-                }
-            });
-
-            AddStep(@"select", () => first.State = SelectionState.Selected);
-            AddStep(@"change title", () => first.Room.Name.Value = @"I Changed Name");
-            AddStep(@"change host", () => first.Room.Host.Value = new User { Username = @"DrabWeb", Id = 6946022, Country = new Country { FlagName = @"CA" } });
-            AddStep(@"change status", () => first.Room.Status.Value = new RoomStatusPlaying());
-            AddStep(@"change type", () => first.Room.Type.Value = new GameTypeVersus());
-            AddStep(@"change beatmap", () => first.Room.Beatmap.Value = null);
-            AddStep(@"change participants", () => first.Room.Participants.Value = new[]
-            {
-                new User { Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 1254 } } },
-                new User { Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 123189 } } },
-            });
-            AddStep(@"deselect", () => first.State = SelectionState.NotSelected);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            this.rulesets = rulesets;
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseLoaderAnimation.cs

@@ -1,115 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Screens;
-using osu.Game.Screens.Menu;
-using OpenTK.Graphics;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseLoaderAnimation : OsuTestCase
-    {
-        private TestLoader loader;
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            // required to preload the logo in a headless run (so it doesn't delay the loading itself).
-            Add(new OsuLogo());
-
-            bool logoVisible = false;
-            AddStep("almost instant display", () => Child = loader = new TestLoader(250));
-            AddUntilStep(() =>
-            {
-                logoVisible = loader.Logo?.Alpha > 0;
-                return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
-            AddAssert("logo not visible", () => !logoVisible);
-
-            AddStep("short load", () => Child = loader = new TestLoader(800));
-            AddUntilStep(() =>
-            {
-                logoVisible = loader.Logo?.Alpha > 0;
-                return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
-            AddAssert("logo visible", () => logoVisible);
-            AddUntilStep(() => loader.Logo?.Alpha == 0, "logo gone");
-
-            AddStep("longer load", () => Child = loader = new TestLoader(1400));
-            AddUntilStep(() =>
-            {
-                logoVisible = loader.Logo?.Alpha > 0;
-                return loader.Logo != null && loader.ScreenLoaded;
-            }, "loaded");
-            AddAssert("logo visible", () => logoVisible);
-            AddUntilStep(() => loader.Logo?.Alpha == 0, "logo gone");
-        }
-
-        private class TestLoader : Loader
-        {
-            private readonly double delay;
-
-            public OsuLogo Logo;
-            private TestScreen screen;
-
-            public bool ScreenLoaded => screen.IsCurrentScreen;
-
-            public TestLoader(double delay)
-            {
-                this.delay = delay;
-            }
-
-            protected override void LogoArriving(OsuLogo logo, bool resuming)
-            {
-                Logo = logo;
-                base.LogoArriving(logo, resuming);
-            }
-
-            protected override OsuScreen CreateLoadableScreen() => screen = new TestScreen();
-            protected override ShaderPrecompiler CreateShaderPrecompiler() => new TestShaderPrecompiler(delay);
-
-            private class TestShaderPrecompiler : ShaderPrecompiler
-            {
-                private readonly double delay;
-                private double startTime;
-
-                public TestShaderPrecompiler(double delay)
-                {
-                    this.delay = delay;
-                }
-
-                protected override void LoadComplete()
-                {
-                    base.LoadComplete();
-                    startTime = Time.Current;
-                }
-
-                protected override bool AllLoaded => Time.Current > startTime + delay;
-            }
-
-            private class TestScreen : OsuScreen
-            {
-                public TestScreen()
-                {
-                    Child = new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.DarkSlateGray,
-                        Alpha = 0,
-                    };
-                }
-
-                protected override void LogoArriving(OsuLogo logo, bool resuming)
-                {
-                    base.LogoArriving(logo, resuming);
-                    Child.FadeInFromZero(200);
-                }
-            }
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseLounge.cs

@@ -1,216 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.Collections.Generic;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Game.Beatmaps;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
-using osu.Game.Screens;
-using osu.Game.Screens.Backgrounds;
-using osu.Game.Screens.Multi.Components;
-using osu.Game.Screens.Multi.Screens.Lounge;
-using osu.Game.Users;
-using OpenTK.Input;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseLounge : ManualInputManagerTestCase
-    {
-        private TestLounge lounge;
-
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            lounge = new TestLounge();
-
-            Room[] rooms =
-            {
-                new Room
-                {
-                    Name = { Value = @"Just Another Room" },
-                    Host = { Value = new User { Username = @"DrabWeb", Id = 6946022, Country = new Country { FlagName = @"CA" } } },
-                    Status = { Value = new RoomStatusPlaying() },
-                    Availability = { Value = RoomAvailability.Public },
-                    Type = { Value = new GameTypeTagTeam() },
-                    Beatmap =
-                    {
-                        Value = new BeatmapInfo
-                        {
-                            StarDifficulty = 5.65,
-                            Ruleset = rulesets.GetRuleset(0),
-                            Metadata = new BeatmapMetadata
-                            {
-                                Title = @"Sidetracked Day (Short Ver.)",
-                                Artist = @"VINXIS",
-                                AuthorString = @"Hobbes2",
-                            },
-                            BeatmapSet = new BeatmapSetInfo
-                            {
-                                OnlineInfo = new BeatmapSetOnlineInfo
-                                {
-                                    Covers = new BeatmapSetOnlineCovers
-                                    {
-                                        Cover = @"https://assets.ppy.sh/beatmaps/767600/covers/cover.jpg?1526243446",
-                                    },
-                                },
-                            },
-                        }
-                    },
-                    MaxParticipants = { Value = 10 },
-                    Participants =
-                    {
-                        Value = new[]
-                        {
-                            new User { Username = @"flyte", Id = 3103765, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 142 } } },
-                            new User { Username = @"Cookiezi", Id = 124493, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 546 } } },
-                            new User { Username = @"Angelsim", Id = 1777162, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 287 } } },
-                            new User { Username = @"Rafis", Id = 2558286, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 468 } } },
-                            new User { Username = @"hvick225", Id = 50265, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 325 } } },
-                            new User { Username = @"peppy", Id = 2, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 625 } } },
-                        }
-                    }
-                },
-                new Room
-                {
-                    Name = { Value = @"Not Just Any Room" },
-                    Host = { Value = new User { Username = @"Monstrata", Id = 2706438, Country = new Country { FlagName = @"CA" } } },
-                    Status = { Value = new RoomStatusOpen() },
-                    Availability = { Value = RoomAvailability.FriendsOnly },
-                    Type = { Value = new GameTypeTeamVersus() },
-                    Beatmap =
-                    {
-                        Value = new BeatmapInfo
-                        {
-                            StarDifficulty = 2.73,
-                            Ruleset = rulesets.GetRuleset(0),
-                            Metadata = new BeatmapMetadata
-                            {
-                                Title = @"lit(var)",
-                                Artist = @"kensuke ushio",
-                                AuthorString = @"Monstrata",
-                            },
-                            BeatmapSet = new BeatmapSetInfo
-                            {
-                                OnlineInfo = new BeatmapSetOnlineInfo
-                                {
-                                    Covers = new BeatmapSetOnlineCovers
-                                    {
-                                        Cover = @"https://assets.ppy.sh/beatmaps/623972/covers/cover.jpg?1521167183",
-                                    },
-                                },
-                            },
-                        }
-                    },
-                    Participants =
-                    {
-                        Value = new[]
-                        {
-                            new User { Username = @"Jeby", Id = 3136279, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 3497 } } },
-                            new User { Username = @"DualAkira", Id = 5220933, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 643 } } },
-                            new User { Username = @"Datenshi Yohane", Id = 7171857, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 10555 } } },
-                        }
-                    }
-                },
-                new Room
-                {
-                    Name = { Value = @"room THE FINAL" },
-                    Host = { Value = new User { Username = @"Delis", Id = 1603923, Country = new Country { FlagName = @"JP" } } },
-                    Status = { Value = new RoomStatusPlaying() },
-                    Availability = { Value = RoomAvailability.Public },
-                    Type = { Value = new GameTypeTagTeam() },
-                    Beatmap =
-                    {
-                        Value = new BeatmapInfo
-                        {
-                            StarDifficulty = 4.48,
-                            Ruleset = rulesets.GetRuleset(3),
-                            Metadata = new BeatmapMetadata
-                            {
-                                Title = @"ONIGIRI FREEWAY",
-                                Artist = @"OISHII",
-                                AuthorString = @"Mentholzzz",
-                            },
-                            BeatmapSet = new BeatmapSetInfo
-                            {
-                                OnlineInfo = new BeatmapSetOnlineInfo
-                                {
-                                    Covers = new BeatmapSetOnlineCovers
-                                    {
-                                        Cover = @"https://assets.ppy.sh/beatmaps/663098/covers/cover.jpg?1521898837",
-                                    },
-                                },
-                            },
-                        }
-                    },
-                    MaxParticipants = { Value = 30 },
-                    Participants =
-                    {
-                        Value = new[]
-                        {
-                            new User { Username = @"KizuA", Id = 6510442, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 5372 } } },
-                            new User { Username = @"Colored", Id = 827563, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 810 } } },
-                            new User { Username = @"Beryl", Id = 3817591, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 10096 } } },
-                        }
-                    }
-                },
-            };
-
-            AddStep(@"show", () => Add(lounge));
-            AddStep(@"set rooms", () => lounge.Rooms = rooms);
-            selectAssert(0);
-            AddStep(@"clear rooms", () => lounge.Rooms = new Room[] {});
-            AddAssert(@"no room selected", () => lounge.SelectedRoom == null);
-            AddStep(@"set rooms", () => lounge.Rooms = rooms);
-            selectAssert(1);
-            AddStep(@"open room 1", () => clickRoom(1));
-            AddUntilStep(() => lounge.ChildScreen?.IsCurrentScreen == true, "wait until room current");
-            AddStep(@"make lounge current", lounge.MakeCurrent);
-            filterAssert(@"THE FINAL", LoungeTab.Public, 1);
-            filterAssert(string.Empty, LoungeTab.Public, 2);
-            filterAssert(string.Empty, LoungeTab.Private, 1);
-            filterAssert(string.Empty, LoungeTab.Public, 2);
-            filterAssert(@"no matches", LoungeTab.Public, 0);
-            AddStep(@"clear rooms", () => lounge.Rooms = new Room[] {});
-            AddStep(@"set rooms", () => lounge.Rooms = rooms);
-            AddAssert(@"no matches after clear", () => !lounge.ChildRooms.Any());
-            filterAssert(string.Empty, LoungeTab.Public, 2);
-            AddStep(@"exit", lounge.Exit);
-        }
-
-        private void clickRoom(int n)
-        {
-            InputManager.MoveMouseTo(lounge.ChildRooms.ElementAt(n));
-            InputManager.Click(MouseButton.Left);
-        }
-
-        private void selectAssert(int n)
-        {
-            AddStep($@"select room {n}", () => clickRoom(n));
-            AddAssert($@"room {n} selected", () => lounge.SelectedRoom == lounge.ChildRooms.ElementAt(n).Room);
-        }
-
-        private void filterAssert(string filter, LoungeTab tab, int endCount)
-        {
-            AddStep($@"filter '{filter}', {tab}", () => lounge.SetFilter(filter, tab));
-            AddAssert(@"filtered correctly", () => lounge.ChildRooms.Count() == endCount);
-        }
-
-        private class TestLounge : Lounge
-        {
-            protected override BackgroundScreen CreateBackground() => new BackgroundScreenDefault();
-
-            public IEnumerable<DrawableRoom> ChildRooms => RoomsContainer.Children.Where(r => r.MatchingFilter);
-            public Room SelectedRoom => Inspector.Room;
-
-            public void SetFilter(string filter, LoungeTab tab)
-            {
-                Filter.Search.Current.Value = filter;
-                Filter.Tabs.Current.Value = tab;
-            }
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseMatch.cs

@@ -1,142 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Game.Beatmaps;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
-using osu.Game.Screens.Multi.Screens.Match;
-using osu.Game.Users;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseMatch : OsuTestCase
-    {
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            Room room = new Room
-            {
-                Name = { Value = @"One Awesome Room" },
-                Status = { Value = new RoomStatusOpen() },
-                Availability = { Value = RoomAvailability.Public },
-                Type = { Value = new GameTypeTeamVersus() },
-                Beatmap =
-                {
-                    Value = new BeatmapInfo
-                    {
-                        StarDifficulty = 5.02,
-                        Ruleset = rulesets.GetRuleset(1),
-                        Metadata = new BeatmapMetadata
-                        {
-                            Title = @"Paradigm Shift",
-                            Artist = @"Morimori Atsushi",
-                            AuthorString = @"eiri-",
-                        },
-                        BeatmapSet = new BeatmapSetInfo
-                        {
-                            OnlineInfo = new BeatmapSetOnlineInfo
-                            {
-                                Covers = new BeatmapSetOnlineCovers
-                                {
-                                    Cover = @"https://assets.ppy.sh/beatmaps/765055/covers/cover.jpg?1526955337",
-                                },
-                            },
-                        },
-                    },
-                },
-                MaxParticipants = { Value = 5 },
-                Participants =
-                {
-                    Value = new[]
-                    {
-                        new User
-                        {
-                            Username = @"eiri-",
-                            Id = 3388410,
-                            Country = new Country { FlagName = @"US" },
-                            CoverUrl = @"https://assets.ppy.sh/user-profile-covers/3388410/00a8486a247831e1cc4375db519f611ac970bda8bc0057d78b0f540ea38c3e58.jpeg",
-                            IsSupporter = true,
-                        },
-                        new User
-                        {
-                            Username = @"Nepuri",
-                            Id = 6637817,
-                            Country = new Country { FlagName = @"DE" },
-                            CoverUrl = @"https://assets.ppy.sh/user-profile-covers/6637817/9085fc60248b6b5327a72c1dcdecf2dbedba810ae0ab6bcf7224e46b1339632a.jpeg",
-                            IsSupporter = true,
-                        },
-                        new User
-                        {
-                            Username = @"goheegy",
-                            Id = 8057655,
-                            Country = new Country { FlagName = @"GB" },
-                            CoverUrl = @"https://assets.ppy.sh/user-profile-covers/8057655/21cec27c25a11dc197a4ec6a74253dbabb495949b0e0697113352f12007018c5.jpeg",
-                        },
-                        new User
-                        {
-                            Username = @"Alumetri",
-                            Id = 5371497,
-                            Country = new Country { FlagName = @"RU" },
-                            CoverUrl = @"https://assets.ppy.sh/user-profile-covers/5371497/e023b8c7fbe3613e64bd4856703517ea50fbed8a5805dc9acda9efe9897c67e2.jpeg",
-                        },
-                    }
-                },
-            };
-
-            Match match = new Match(room);
-
-            AddStep(@"show", () => Add(match));
-            AddStep(@"null beatmap", () => room.Beatmap.Value = null);
-            AddStep(@"change name", () => room.Name.Value = @"Two Awesome Rooms");
-            AddStep(@"change status", () => room.Status.Value = new RoomStatusPlaying());
-            AddStep(@"change availability", () => room.Availability.Value = RoomAvailability.FriendsOnly);
-            AddStep(@"change type", () => room.Type.Value = new GameTypeTag());
-            AddStep(@"change beatmap", () => room.Beatmap.Value = new BeatmapInfo
-            {
-                StarDifficulty = 4.33,
-                Ruleset = rulesets.GetRuleset(2),
-                Metadata = new BeatmapMetadata
-                {
-                    Title = @"Yasashisa no Riyuu",
-                    Artist = @"ChouCho",
-                    AuthorString = @"celerih",
-                },
-                BeatmapSet = new BeatmapSetInfo
-                {
-                    OnlineInfo = new BeatmapSetOnlineInfo
-                    {
-                        Covers = new BeatmapSetOnlineCovers
-                        {
-                            Cover = @"https://assets.ppy.sh/beatmaps/685391/covers/cover.jpg?1524597970",
-                        },
-                    },
-                },
-            });
-
-            AddStep(@"null max participants", () => room.MaxParticipants.Value = null);
-            AddStep(@"change participants", () => room.Participants.Value = new[]
-            {
-                new User
-                {
-                    Username = @"Spectator",
-                    Id = 702598,
-                    Country = new Country { FlagName = @"KR" },
-                    CoverUrl = @"https://assets.ppy.sh/user-profile-covers/702598/3bbf4cb8b8d2cf8b03145000a975ff27e191ab99b0920832e7dd67386280e288.jpeg",
-                    IsSupporter = true,
-                },
-                new User
-                {
-                    Username = @"celerih",
-                    Id = 4696296,
-                    Country = new Country { FlagName = @"CA" },
-                    CoverUrl = @"https://assets.ppy.sh/user-profile-covers/4696296/7f8500731d0ac66d5472569d146a7be07d9460273361913f22c038867baddaef.jpeg",
-                },
-            });
-
-            AddStep(@"exit", match.Exit);
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseMatchHeader.cs

@@ -1,43 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Game.Beatmaps;
-using osu.Game.Screens.Multi.Screens.Match;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseMatchHeader : OsuTestCase
-    {
-        public TestCaseMatchHeader()
-        {
-            Header header = new Header();
-            Add(header);
-
-            AddStep(@"set beatmap set", () => header.BeatmapSet = new BeatmapSetInfo
-            {
-                OnlineInfo = new BeatmapSetOnlineInfo
-                {
-                    Covers = new BeatmapSetOnlineCovers
-                    {
-                        Cover = @"https://assets.ppy.sh/beatmaps/760757/covers/cover.jpg?1526944540",
-                    },
-                },
-            });
-
-            AddStep(@"change beatmap set", () => header.BeatmapSet = new BeatmapSetInfo
-            {
-                OnlineInfo = new BeatmapSetOnlineInfo
-                {
-                    Covers = new BeatmapSetOnlineCovers
-                    {
-                        Cover = @"https://assets.ppy.sh/beatmaps/761883/covers/cover.jpg?1525557400",
-                    },
-                },
-            });
-
-            AddStep(@"null beatmap set", () => header.BeatmapSet = null);
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseMatchInfo.cs

@@ -1,57 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Game.Beatmaps;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
-using osu.Game.Screens.Multi.Screens.Match;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseMatchInfo : OsuTestCase
-    {
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            Info info = new Info();
-            Add(info);
-
-            AddStep(@"set name", () => info.Name = @"Room Name?");
-            AddStep(@"set availability", () => info.Availability = RoomAvailability.FriendsOnly);
-            AddStep(@"set status", () => info.Status = new RoomStatusPlaying());
-            AddStep(@"set beatmap", () => info.Beatmap = new BeatmapInfo
-            {
-                StarDifficulty = 2.4,
-                Ruleset = rulesets.GetRuleset(0),
-                Metadata = new BeatmapMetadata
-                {
-                    Title = @"My Song",
-                    Artist = @"VisualTests",
-                    AuthorString = @"osu!lazer",
-                },
-            });
-
-            AddStep(@"set type", () => info.Type = new GameTypeTagTeam());
-
-            AddStep(@"change name", () => info.Name = @"Room Name!");
-            AddStep(@"change availability", () => info.Availability = RoomAvailability.InviteOnly);
-            AddStep(@"change status", () => info.Status = new RoomStatusOpen());
-            AddStep(@"null beatmap", () => info.Beatmap = null);
-            AddStep(@"change type", () => info.Type = new GameTypeTeamVersus());
-            AddStep(@"change beatmap", () => info.Beatmap = new BeatmapInfo
-            {
-                StarDifficulty = 4.2,
-                Ruleset = rulesets.GetRuleset(3),
-                Metadata = new BeatmapMetadata
-                {
-                    Title = @"Your Song",
-                    Artist = @"Tester",
-                    AuthorString = @"Someone",
-                },
-            });
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseMultiHeader.cs

@@ -1,27 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Game.Screens.Multi;
-using osu.Game.Screens.Multi.Screens.Lounge;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseMultiHeader : OsuTestCase
-    {
-        public TestCaseMultiHeader()
-        {
-            Lounge lounge;
-            Children = new Drawable[]
-            {
-                lounge = new Lounge
-                {
-                    Padding = new MarginPadding { Top = Header.HEIGHT },
-                },
-                new Header(lounge),
-            };
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseMultiScreen.cs

@@ -1,21 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Game.Screens.Multi;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseMultiScreen : OsuTestCase
-    {
-        public TestCaseMultiScreen()
-        {
-            Multiplayer multi = new Multiplayer();
-
-            AddStep(@"show", () => Add(multi));
-            AddWaitStep(5);
-            AddStep(@"exit", multi.Exit);
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseOsuGame.cs

@@ -1,14 +1,15 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+// 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 System.Collections.Generic;
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Screens;
+using osu.Framework.Platform;
 using osu.Game.Screens.Menu;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual
 {
@@ -20,8 +21,12 @@ namespace osu.Game.Tests.Visual
             typeof(OsuLogo),
         };
 
-        public TestCaseOsuGame()
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
         {
+            OsuGame game = new OsuGame();
+            game.SetHost(host);
+
             Children = new Drawable[]
             {
                 new Box
@@ -29,7 +34,7 @@ namespace osu.Game.Tests.Visual
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.Black,
                 },
-                new Loader()
+                game
             };
         }
     }

osu.Game.Tests/Visual/TestCaseOsuScreenStack.cs

@@ -0,0 +1,82 @@
+// 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.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Screens;
+using osu.Game.Screens.Play;
+using osuTK.Graphics;
+
+namespace osu.Game.Tests.Visual
+{
+    [TestFixture]
+    public class TestCaseOsuScreenStack : OsuTestCase
+    {
+        private TestOsuScreenStack stack;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create new screen stack", () => { Child = stack = new TestOsuScreenStack { RelativeSizeAxes = Axes.Both }; });
+        }
+
+        [Test]
+        public void ParallaxAssignmentTest()
+        {
+            NoParallaxTestScreen noParallaxScreen = null;
+            TestScreen parallaxScreen = null;
+
+            AddStep("Push no parallax", () => stack.Push(noParallaxScreen = new NoParallaxTestScreen("NO PARALLAX")));
+            AddUntilStep("Wait for current", () => noParallaxScreen.IsLoaded);
+            AddAssert("Parallax is off", () => stack.ParallaxAmount == 0);
+
+            AddStep("Push parallax", () => noParallaxScreen.Push(parallaxScreen = new TestScreen("PARALLAX")));
+            AddUntilStep("Wait for current", () => parallaxScreen.IsLoaded);
+            AddAssert("Parallax is on", () => stack.ParallaxAmount > 0);
+
+            AddStep("Exit from new screen", () => { noParallaxScreen.MakeCurrent(); });
+            AddAssert("Parallax is off", () => stack.ParallaxAmount == 0);
+        }
+
+        private class TestScreen : ScreenWithBeatmapBackground
+        {
+            private readonly string screenText;
+
+            public TestScreen(string screenText)
+            {
+                this.screenText = screenText;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AddInternal(new SpriteText
+                {
+                    Text = screenText,
+                    Colour = Color4.White,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                });
+            }
+        }
+
+        private class NoParallaxTestScreen : TestScreen
+        {
+            public NoParallaxTestScreen(string screenText)
+                : base(screenText)
+            {
+            }
+
+            public override float BackgroundParallaxAmount => 0.0f;
+        }
+
+        private class TestOsuScreenStack : OsuScreenStack
+        {
+            public new float ParallaxAmount => base.ParallaxAmount;
+        }
+    }
+}

osu.Game.Tests/Visual/TestCasePlayerLoader.cs

@@ -1,61 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.Threading;
-using osu.Framework.Allocation;
-using osu.Game.Beatmaps;
-using osu.Game.Screens.Play;
-
-namespace osu.Game.Tests.Visual
-{
-    public class TestCasePlayerLoader : ManualInputManagerTestCase
-    {
-        private PlayerLoader loader;
-
-        [BackgroundDependencyLoader]
-        private void load(OsuGameBase game)
-        {
-            Beatmap.Value = new DummyWorkingBeatmap(game);
-
-            AddStep("load dummy beatmap", () => Add(loader = new PlayerLoader(new Player
-            {
-                AllowPause = false,
-                AllowLeadIn = false,
-                AllowResults = false,
-            })));
-
-            AddStep("mouse in centre", () => InputManager.MoveMouseTo(loader.ScreenSpaceDrawQuad.Centre));
-
-            AddUntilStep(() => !loader.IsCurrentScreen, "wait for no longer current");
-
-            AddStep("load slow dummy beatmap", () =>
-            {
-                SlowLoadPlayer slow;
-
-                Add(loader = new PlayerLoader(slow = new SlowLoadPlayer
-                {
-                    AllowPause = false,
-                    AllowLeadIn = false,
-                    AllowResults = false,
-                }));
-
-                Scheduler.AddDelayed(() => slow.Ready = true, 5000);
-            });
-
-            AddUntilStep(() => !loader.IsCurrentScreen, "wait for no longer current");
-        }
-
-        protected class SlowLoadPlayer : Player
-        {
-            public bool Ready;
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                while (!Ready)
-                    Thread.Sleep(1);
-            }
-        }
-    }
-
-}

osu.Game.Tests/Visual/TestCaseReplay.cs

@@ -1,31 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.ComponentModel;
-using System.Linq;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mods;
-using osu.Game.Screens.Play;
-
-namespace osu.Game.Tests.Visual
-{
-    [Description("Player instantiated with a replay.")]
-    public class TestCaseReplay : TestCasePlayer
-    {
-        protected override Player CreatePlayer(Ruleset ruleset)
-        {
-            // We create a dummy RulesetContainer just to get the replay - we don't want to use mods here
-            // to simulate setting a replay rather than having the replay already set for us
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Concat(new[] { ruleset.GetAutoplayMod() });
-            var dummyRulesetContainer = ruleset.CreateRulesetContainerWith(Beatmap.Value);
-
-            // We have the replay
-            var replay = dummyRulesetContainer.Replay;
-
-            // Reset the mods
-            Beatmap.Value.Mods.Value = Beatmap.Value.Mods.Value.Where(m => !(m is ModAutoplay));
-
-            return new ReplayPlayer(replay);
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseRoomInspector.cs

@@ -1,147 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Game.Beatmaps;
-using osu.Game.Online.Multiplayer;
-using osu.Game.Rulesets;
-using osu.Game.Screens.Multi.Components;
-using osu.Game.Users;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseRoomInspector : OsuTestCase
-    {
-        private RulesetStore rulesets;
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Room room = new Room
-            {
-                Name = { Value = @"My Awesome Room" },
-                Host = { Value = new User { Username = @"flyte", Id = 3103765, Country = new Country { FlagName = @"JP" } } },
-                Status = { Value = new RoomStatusOpen() },
-                Type = { Value = new GameTypeTeamVersus() },
-                Beatmap =
-                {
-                    Value = new BeatmapInfo
-                    {
-                        StarDifficulty = 3.7,
-                        Ruleset = rulesets.GetRuleset(3),
-                        Metadata = new BeatmapMetadata
-                        {
-                            Title = @"Platina",
-                            Artist = @"Maaya Sakamoto",
-                            AuthorString = @"uwutm8",
-                        },
-                        BeatmapSet = new BeatmapSetInfo
-                        {
-                            OnlineInfo = new BeatmapSetOnlineInfo
-                            {
-                                Covers = new BeatmapSetOnlineCovers
-                                {
-                                    Cover = @"https://assets.ppy.sh/beatmaps/560573/covers/cover.jpg?1492722343",
-                                },
-                            },
-                        },
-                    }
-                },
-                MaxParticipants = { Value = 200 },
-                Participants =
-                {
-                    Value = new[]
-                    {
-                        new User { Username = @"flyte", Id = 3103765, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 142 } } },
-                        new User { Username = @"Cookiezi", Id = 124493, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 546 } } },
-                        new User { Username = @"Angelsim", Id = 1777162, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 287 } } },
-                        new User { Username = @"Rafis", Id = 2558286, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 468 } } },
-                        new User { Username = @"hvick225", Id = 50265, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 325 } } },
-                        new User { Username = @"peppy", Id = 2, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 625 } } },
-                    }
-                }
-            };
-
-            RoomInspector inspector;
-            Add(inspector = new RoomInspector
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                RelativeSizeAxes = Axes.Both,
-                Width = 0.5f,
-            });
-
-            AddStep(@"set room", () => inspector.Room = room);
-            AddStep(@"null room", () => inspector.Room = null);
-            AddStep(@"set room", () => inspector.Room = room);
-            AddStep(@"change title", () => room.Name.Value = @"A Better Room Than The Above");
-            AddStep(@"change host", () => room.Host.Value = new User { Username = @"DrabWeb", Id = 6946022, Country = new Country { FlagName = @"CA" } });
-            AddStep(@"change status", () => room.Status.Value = new RoomStatusPlaying());
-            AddStep(@"change type", () => room.Type.Value = new GameTypeTag());
-            AddStep(@"change beatmap", () => room.Beatmap.Value = null);
-            AddStep(@"change max participants", () => room.MaxParticipants.Value = null);
-            AddStep(@"change participants", () => room.Participants.Value = new[]
-            {
-                new User { Username = @"filsdelama", Id = 2831793, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 854 } } },
-                new User { Username = @"_index", Id = 652457, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 150 } } }
-            });
-
-            AddStep(@"change room", () =>
-            {
-                Room newRoom = new Room
-                {
-                    Name = { Value = @"My New, Better Than Ever Room" },
-                    Host = { Value = new User { Username = @"Angelsim", Id = 1777162, Country = new Country { FlagName = @"KR" } } },
-                    Status = { Value = new RoomStatusOpen() },
-                    Type = { Value = new GameTypeTagTeam() },
-                    Beatmap =
-                    {
-                        Value = new BeatmapInfo
-                        {
-                            StarDifficulty = 7.07,
-                            Ruleset = rulesets.GetRuleset(0),
-                            Metadata = new BeatmapMetadata
-                            {
-                                Title = @"FREEDOM DIVE",
-                                Artist = @"xi",
-                                AuthorString = @"Nakagawa-Kanon",
-                            },
-                            BeatmapSet = new BeatmapSetInfo
-                            {
-                                OnlineInfo = new BeatmapSetOnlineInfo
-                                {
-                                    Covers = new BeatmapSetOnlineCovers
-                                    {
-                                        Cover = @"https://assets.ppy.sh/beatmaps/39804/covers/cover.jpg?1456506845",
-                                    },
-                                },
-                            },
-                        },
-                    },
-                    MaxParticipants = { Value = 10 },
-                    Participants =
-                    {
-                        Value = new[]
-                        {
-                            new User { Username = @"Angelsim", Id = 1777162, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 4 } } },
-                            new User { Username = @"HappyStick", Id = 256802, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 752 } } },
-                            new User { Username = @"-Konpaku-", Id = 2258797, Statistics = new UserStatistics { Ranks = new UserStatistics.UserRanks { Global = 571 } } }
-                        }
-                    }
-                };
-
-                inspector.Room = newRoom;
-            });
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            this.rulesets = rulesets;
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseSongProgress.cs

@@ -1,64 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.Collections.Generic;
-using NUnit.Framework;
-using osu.Framework.Graphics;
-using osu.Framework.MathUtils;
-using osu.Framework.Timing;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Screens.Play;
-
-namespace osu.Game.Tests.Visual
-{
-    [TestFixture]
-    public class TestCaseSongProgress : OsuTestCase
-    {
-        private readonly SongProgress progress;
-        private readonly SongProgressGraph graph;
-
-        private readonly StopwatchClock clock;
-
-        public TestCaseSongProgress()
-        {
-            clock = new StopwatchClock(true);
-
-            Add(progress = new SongProgress
-            {
-                RelativeSizeAxes = Axes.X,
-                AudioClock = new StopwatchClock(true),
-                Anchor = Anchor.BottomLeft,
-                Origin = Anchor.BottomLeft,
-            });
-
-            Add(graph = new SongProgressGraph
-            {
-                RelativeSizeAxes = Axes.X,
-                Height = 200,
-                Anchor = Anchor.TopLeft,
-                Origin = Anchor.TopLeft,
-            });
-
-            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
-            AddWaitStep(5);
-            AddStep("Toggle Bar", () => progress.AllowSeeking = !progress.AllowSeeking);
-            AddWaitStep(2);
-            AddRepeatStep("New Values", displayNewValues, 5);
-
-            displayNewValues();
-        }
-
-        private void displayNewValues()
-        {
-            List<HitObject> objects = new List<HitObject>();
-            for (double i = 0; i < 5000; i += RNG.NextDouble() * 10 + i / 1000)
-                objects.Add(new HitObject { StartTime = i });
-
-            progress.Objects = objects;
-            graph.Objects = objects;
-
-            progress.AudioClock = clock;
-            progress.OnSeek = pos => clock.Seek(pos);
-        }
-    }
-}