Merge branch 'master' into realm-key-binding-store

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs

@@ -169,6 +169,8 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             protected override Track GetBeatmapTrack() => throw new NotImplementedException();
 
+            protected override ISkin GetSkin() => throw new NotImplementedException();
+
             public override Stream GetStream(string storagePath) => throw new NotImplementedException();
         }
     }

osu.Game.Tests/Chat/MessageFormatterTests.cs

@@ -24,10 +24,10 @@ namespace osu.Game.Tests.Chat
         [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123#osu/456")]
         [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123#osu/456?whatever")]
         [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123/456")]
-        [TestCase(LinkAction.External, null, "https://dev.ppy.sh/beatmapsets/abc/def")]
+        [TestCase(LinkAction.External, "https://dev.ppy.sh/beatmapsets/abc/def", "https://dev.ppy.sh/beatmapsets/abc/def")]
         [TestCase(LinkAction.OpenBeatmapSet, "123", "https://dev.ppy.sh/beatmapsets/123")]
         [TestCase(LinkAction.OpenBeatmapSet, "123", "https://dev.ppy.sh/beatmapsets/123/whatever")]
-        [TestCase(LinkAction.External, null, "https://dev.ppy.sh/beatmapsets/abc")]
+        [TestCase(LinkAction.External, "https://dev.ppy.sh/beatmapsets/abc", "https://dev.ppy.sh/beatmapsets/abc")]
         public void TestBeatmapLinks(LinkAction expectedAction, string expectedArg, string link)
         {
             MessageFormatter.WebsiteRootUrl = "dev.ppy.sh";
@@ -489,5 +489,23 @@ namespace osu.Game.Tests.Chat
             Assert.AreEqual(result.Links[2].Url, "\uD83D\uDE00");
             Assert.AreEqual(result.Links[3].Url, "\uD83D\uDE20");
         }
+
+        [Test]
+        public void TestAbsoluteExternalLinks()
+        {
+            LinkDetails result = MessageFormatter.GetLinkDetails("https://google.com");
+
+            Assert.AreEqual(LinkAction.External, result.Action);
+            Assert.AreEqual("https://google.com", result.Argument);
+        }
+
+        [Test]
+        public void TestRelativeExternalLinks()
+        {
+            LinkDetails result = MessageFormatter.GetLinkDetails("/relative");
+
+            Assert.AreEqual(LinkAction.External, result.Action);
+            Assert.AreEqual("/relative", result.Argument);
+        }
     }
 }

osu.Game.Tests/Collections/IO/ImportCollectionsTest.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Tests.Collections.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    await osu.CollectionManager.Import(new MemoryStream());
+                    await importCollectionsFromStream(osu, new MemoryStream());
 
                     Assert.That(osu.CollectionManager.Collections.Count, Is.Zero);
                 }
@@ -43,7 +43,7 @@ namespace osu.Game.Tests.Collections.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
+                    await importCollectionsFromStream(osu, TestResources.OpenResource("Collections/collections.db"));
 
                     Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
 
@@ -69,7 +69,7 @@ namespace osu.Game.Tests.Collections.IO
                 {
                     var osu = LoadOsuIntoHost(host, true);
 
-                    await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
+                    await importCollectionsFromStream(osu, TestResources.OpenResource("Collections/collections.db"));
 
                     Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
 
@@ -110,7 +110,7 @@ namespace osu.Game.Tests.Collections.IO
 
                         ms.Seek(0, SeekOrigin.Begin);
 
-                        await osu.CollectionManager.Import(ms);
+                        await importCollectionsFromStream(osu, ms);
                     }
 
                     Assert.That(host.UpdateThread.Running, Is.True);
@@ -134,7 +134,7 @@ namespace osu.Game.Tests.Collections.IO
                 {
                     var osu = LoadOsuIntoHost(host, true);
 
-                    await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
+                    await importCollectionsFromStream(osu, TestResources.OpenResource("Collections/collections.db"));
 
                     // Move first beatmap from second collection into the first.
                     osu.CollectionManager.Collections[0].Beatmaps.Add(osu.CollectionManager.Collections[1].Beatmaps[0]);
@@ -169,5 +169,12 @@ namespace osu.Game.Tests.Collections.IO
                 }
             }
         }
+
+        private static async Task importCollectionsFromStream(TestOsuGameBase osu, Stream stream)
+        {
+            // intentionally spin this up on a separate task to avoid disposal deadlocks.
+            // see https://github.com/EventStore/EventStore/issues/1179
+            await Task.Run(() => osu.CollectionManager.Import(stream).Wait());
+        }
     }
 }

osu.Game.Tests/Gameplay/TestSceneDrawableHitObject.cs

@@ -3,6 +3,8 @@
 
 using NUnit.Framework;
 using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Tests.Visual;
@@ -70,15 +72,81 @@ namespace osu.Game.Tests.Gameplay
             AddAssert("Lifetime is changed", () => entry.LifetimeStart == double.MinValue && entry.LifetimeEnd == 1000);
         }
 
+        [Test]
+        public void TestLifetimeUpdatedOnDefaultApplied()
+        {
+            TestLifetimeEntry entry = null;
+            AddStep("Create entry", () => entry = new TestLifetimeEntry(new HitObject()) { LifetimeStart = 1 });
+            AddStep("ApplyDefaults", () => entry.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty()));
+            AddAssert("Lifetime is updated", () => entry.LifetimeStart == -TestLifetimeEntry.INITIAL_LIFETIME_OFFSET);
+
+            TestDrawableHitObject dho = null;
+            AddStep("Create DHO", () =>
+            {
+                dho = new TestDrawableHitObject(null);
+                dho.Apply(entry);
+                Child = dho;
+                dho.SetLifetimeStartOnApply = true;
+            });
+            AddStep("ApplyDefaults", () => entry.HitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty()));
+            AddAssert("Lifetime is correct", () => dho.LifetimeStart == TestDrawableHitObject.LIFETIME_ON_APPLY && entry.LifetimeStart == TestDrawableHitObject.LIFETIME_ON_APPLY);
+        }
+
+        [Test]
+        public void TestDrawableLifetimeUpdateOnEntryLifetimeChange()
+        {
+            TestDrawableHitObject dho = null;
+            TestLifetimeEntry entry = null;
+            AddStep("Create DHO", () =>
+            {
+                dho = new TestDrawableHitObject(null);
+                dho.Apply(entry = new TestLifetimeEntry(new HitObject()));
+                Child = dho;
+            });
+
+            AddStep("Set entry lifetime", () =>
+            {
+                entry.LifetimeStart = 777;
+                entry.LifetimeEnd = 888;
+            });
+            AddAssert("Drawable lifetime is updated", () => dho.LifetimeStart == 777 && dho.LifetimeEnd == 888);
+
+            AddStep("KeepAlive = true", () => entry.KeepAlive = true);
+            AddAssert("Drawable lifetime is updated", () => dho.LifetimeStart == double.MinValue && dho.LifetimeEnd == double.MaxValue);
+
+            AddStep("Modify start time", () => entry.HitObject.StartTime = 100);
+            AddAssert("Drawable lifetime is correct", () => dho.LifetimeStart == double.MinValue);
+
+            AddStep("Set LifetimeStart", () => dho.LifetimeStart = 666);
+            AddAssert("Lifetime change is blocked", () => dho.LifetimeStart == double.MinValue);
+
+            AddStep("Set LifetimeEnd", () => dho.LifetimeEnd = 999);
+            AddAssert("Lifetime change is blocked", () => dho.LifetimeEnd == double.MaxValue);
+
+            AddStep("KeepAlive = false", () => entry.KeepAlive = false);
+            AddAssert("Drawable lifetime is restored", () => dho.LifetimeStart == 666 && dho.LifetimeEnd == 999);
+        }
+
         private class TestDrawableHitObject : DrawableHitObject
         {
             public const double INITIAL_LIFETIME_OFFSET = 100;
+            public const double LIFETIME_ON_APPLY = 222;
             protected override double InitialLifetimeOffset => INITIAL_LIFETIME_OFFSET;
 
+            public bool SetLifetimeStartOnApply;
+
             public TestDrawableHitObject(HitObject hitObject)
                 : base(hitObject)
             {
             }
+
+            protected override void OnApply()
+            {
+                base.OnApply();
+
+                if (SetLifetimeStartOnApply)
+                    LifetimeStart = LIFETIME_ON_APPLY;
+            }
         }
 
         private class TestLifetimeEntry : HitObjectLifetimeEntry

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -123,6 +123,8 @@ namespace osu.Game.Tests.Gameplay
 
             public ISample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => null;
+
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup)
             {
                 switch (lookup)

osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Tests.Gameplay
     public class TestSceneHitObjectSamples : HitObjectSampleTest
     {
         protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
-        protected override IResourceStore<byte[]> Resources => TestResources.GetStore();
+        protected override IResourceStore<byte[]> RulesetResources => TestResources.GetStore();
 
         /// <summary>
         /// Tests that a hitobject which provides no custom sample set retrieves samples from the user skin.

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -219,6 +219,7 @@ namespace osu.Game.Tests.Gameplay
 
         public AudioManager AudioManager => Audio;
         public IResourceStore<byte[]> Files => null;
+        public new IResourceStore<byte[]> Resources => base.Resources;
         public IResourceStore<TextureUpload> CreateTextureLoaderStore(IResourceStore<byte[]> underlyingStore) => null;
 
         #endregion

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -217,7 +217,7 @@ namespace osu.Game.Tests.NonVisual
                 throw new NotImplementedException();
             }
 
-            protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods)
+            protected override Skill[] CreateSkills(IBeatmap beatmap, Mod[] mods, double clockRate)
             {
                 throw new NotImplementedException();
             }

osu.Game.Tests/NonVisual/Skinning/LegacySkinAnimationTest.cs

@@ -61,6 +61,7 @@ namespace osu.Game.Tests.NonVisual.Skinning
             public Drawable GetDrawableComponent(ISkinComponent component) => throw new NotSupportedException();
             public ISample GetSample(ISampleInfo sampleInfo) => throw new NotSupportedException();
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotSupportedException();
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => null;
         }
 
         private class TestAnimationTimeReference : IAnimationTimeReference

osu.Game.Tests/Online/TestSceneOnlinePlayBeatmapAvailabilityTracker.cs

@@ -12,6 +12,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.IO.Stores;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -44,7 +45,7 @@ namespace osu.Game.Tests.Online
         private void load(AudioManager audio, GameHost host)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, ContextFactory, rulesets, API, audio, host, Beatmap.Default));
+            Dependencies.CacheAs<BeatmapManager>(beatmaps = new TestBeatmapManager(LocalStorage, ContextFactory, rulesets, API, audio, Resources, host, Beatmap.Default));
         }
 
         [SetUp]
@@ -160,8 +161,8 @@ namespace osu.Game.Tests.Online
             protected override ArchiveDownloadRequest<BeatmapSetInfo> CreateDownloadRequest(BeatmapSetInfo set, bool minimiseDownloadSize)
                 => new TestDownloadRequest(set);
 
-            public TestBeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, GameHost host = null, WorkingBeatmap defaultBeatmap = null, bool performOnlineLookups = false)
-                : base(storage, contextFactory, rulesets, api, audioManager, host, defaultBeatmap, performOnlineLookups)
+            public TestBeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, [NotNull] AudioManager audioManager, IResourceStore<byte[]> resources, GameHost host = null, WorkingBeatmap defaultBeatmap = null, bool performOnlineLookups = false)
+                : base(storage, contextFactory, rulesets, api, audioManager, resources, host, defaultBeatmap, performOnlineLookups)
             {
             }
 

osu.Game.Tests/Skins/TestSceneSkinConfigurationLookup.cs

@@ -1,6 +1,7 @@
 // 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.IO;
 using System.Linq;
@@ -222,6 +223,8 @@ namespace osu.Game.Tests.Skins
             public ISample GetSample(ISampleInfo sampleInfo) => skin.GetSample(sampleInfo);
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => skin.GetConfig<TLookup, TValue>(lookup);
+
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => skin.FindProvider(lookupFunction);
         }
     }
 }

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

@@ -0,0 +1,133 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Backgrounds;
+using osu.Game.Online.API;
+using osu.Game.Screens;
+using osu.Game.Screens.Backgrounds;
+using osu.Game.Skinning;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Background
+{
+    [TestFixture]
+    public class TestSceneBackgroundScreenDefault : OsuTestScene
+    {
+        private BackgroundScreenStack stack;
+        private BackgroundScreenDefault screen;
+
+        private Graphics.Backgrounds.Background getCurrentBackground() => screen.ChildrenOfType<Graphics.Backgrounds.Background>().FirstOrDefault();
+
+        [Resolved]
+        private SkinManager skins { get; set; }
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create background stack", () => Child = stack = new BackgroundScreenStack());
+            AddStep("push default screen", () => stack.Push(screen = new BackgroundScreenDefault(false)));
+            AddUntilStep("wait for screen to load", () => screen.IsCurrentScreen());
+        }
+
+        [Test]
+        public void TestBackgroundTypeSwitch()
+        {
+            setSupporter(true);
+
+            setSourceMode(BackgroundSource.Beatmap);
+            AddUntilStep("is beatmap background", () => getCurrentBackground() is BeatmapBackground);
+
+            setSourceMode(BackgroundSource.BeatmapWithStoryboard);
+            AddUntilStep("is storyboard background", () => getCurrentBackground() is BeatmapBackgroundWithStoryboard);
+
+            setSourceMode(BackgroundSource.Skin);
+            AddUntilStep("is default background", () => getCurrentBackground().GetType() == typeof(Graphics.Backgrounds.Background));
+
+            setCustomSkin();
+            AddUntilStep("is skin background", () => getCurrentBackground() is SkinBackground);
+        }
+
+        [Test]
+        public void TestTogglingSupporterTogglesBeatmapBackground()
+        {
+            setSourceMode(BackgroundSource.Beatmap);
+
+            setSupporter(true);
+            AddUntilStep("is beatmap background", () => getCurrentBackground() is BeatmapBackground);
+
+            setSupporter(false);
+            AddUntilStep("is default background", () => !(getCurrentBackground() is BeatmapBackground));
+
+            setSupporter(true);
+            AddUntilStep("is beatmap background", () => getCurrentBackground() is BeatmapBackground);
+        }
+
+        [TestCase(BackgroundSource.Beatmap, typeof(BeatmapBackground))]
+        [TestCase(BackgroundSource.BeatmapWithStoryboard, typeof(BeatmapBackgroundWithStoryboard))]
+        [TestCase(BackgroundSource.Skin, typeof(SkinBackground))]
+        public void TestBackgroundDoesntReloadOnNoChange(BackgroundSource source, Type backgroundType)
+        {
+            Graphics.Backgrounds.Background last = null;
+
+            setSourceMode(source);
+            setSupporter(true);
+            if (source == BackgroundSource.Skin)
+                setCustomSkin();
+
+            AddUntilStep("wait for beatmap background to be loaded", () => (last = getCurrentBackground())?.GetType() == backgroundType);
+            AddAssert("next doesn't load new background", () => screen.Next() == false);
+
+            // doesn't really need to be checked but might as well.
+            AddWaitStep("wait a bit", 5);
+            AddUntilStep("ensure same background instance", () => last == getCurrentBackground());
+        }
+
+        [Test]
+        public void TestBackgroundCyclingOnDefaultSkin([Values] bool supporter)
+        {
+            Graphics.Backgrounds.Background last = null;
+
+            setSourceMode(BackgroundSource.Skin);
+            setSupporter(supporter);
+            setDefaultSkin();
+
+            AddUntilStep("wait for beatmap background to be loaded", () => (last = getCurrentBackground())?.GetType() == typeof(Graphics.Backgrounds.Background));
+            AddAssert("next cycles background", () => screen.Next());
+
+            // doesn't really need to be checked but might as well.
+            AddWaitStep("wait a bit", 5);
+            AddUntilStep("ensure different background instance", () => last != getCurrentBackground());
+        }
+
+        private void setSourceMode(BackgroundSource source) =>
+            AddStep($"set background mode to {source}", () => config.SetValue(OsuSetting.MenuBackgroundSource, source));
+
+        private void setSupporter(bool isSupporter) =>
+            AddStep($"set supporter {isSupporter}", () => ((DummyAPIAccess)API).LocalUser.Value = new User
+            {
+                IsSupporter = isSupporter,
+                Id = API.LocalUser.Value.Id + 1,
+            });
+
+        private void setCustomSkin()
+        {
+            // feign a skin switch. this doesn't do anything except force CurrentSkin to become a LegacySkin.
+            AddStep("set custom skin", () => skins.CurrentSkinInfo.Value = new SkinInfo { ID = 5 });
+        }
+
+        private void setDefaultSkin() => AddStep("set default skin", () => skins.CurrentSkinInfo.SetDefault());
+
+        [TearDownSteps]
+        public void TearDown() => setDefaultSkin();
+    }
+}

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

@@ -48,7 +48,7 @@ namespace osu.Game.Tests.Visual.Background
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
             Dependencies.Cache(new OsuConfigManager(LocalStorage));
 
             manager.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();

osu.Game.Tests/Visual/Collections/TestSceneManageCollectionsDialog.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual.Collections
         private void load(GameHost host)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, host, Beatmap.Default));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, Resources, host, Beatmap.Default));
 
             beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
 

osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs

@@ -24,13 +24,13 @@ namespace osu.Game.Tests.Visual.Editing
 
         protected override bool EditorComponentsReady => Editor.ChildrenOfType<SetupScreen>().SingleOrDefault()?.IsLoaded == true;
 
+        protected override bool IsolateSavingFromDatabase => false;
+
         [Resolved]
         private BeatmapManager beatmapManager { get; set; }
 
         public override void SetUpSteps()
         {
-            AddStep("set dummy", () => Beatmap.Value = new DummyWorkingBeatmap(Audio, null));
-
             base.SetUpSteps();
 
             // if we save a beatmap with a hash collision, things fall over.
@@ -38,6 +38,12 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("make new beatmap unique", () => EditorBeatmap.Metadata.Title = Guid.NewGuid().ToString());
         }
 
+        protected override void LoadEditor()
+        {
+            Beatmap.Value = new DummyWorkingBeatmap(Audio, null);
+            base.LoadEditor();
+        }
+
         [Test]
         public void TestCreateNewBeatmap()
         {

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

@@ -0,0 +1,33 @@
+// 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.Rulesets;
+using osu.Game.Rulesets.Osu;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public abstract class SkinnableHUDComponentTestScene : SkinnableTestScene
+    {
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            SetContents(skin =>
+            {
+                var implementation = skin != null
+                    ? CreateLegacyImplementation()
+                    : CreateDefaultImplementation();
+
+                implementation.Anchor = Anchor.Centre;
+                implementation.Origin = Anchor.Centre;
+                return implementation;
+            });
+        });
+
+        protected abstract Drawable CreateDefaultImplementation();
+        protected abstract Drawable CreateLegacyImplementation();
+    }
+}

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

@@ -18,12 +18,12 @@ namespace osu.Game.Tests.Visual.Gameplay
     [Description("Player instantiated with an autoplay mod.")]
     public class TestSceneAutoplay : TestSceneAllRulesetPlayers
     {
-        protected new TestPlayer Player => (TestPlayer)base.Player;
+        protected new TestReplayPlayer Player => (TestReplayPlayer)base.Player;
 
         protected override Player CreatePlayer(Ruleset ruleset)
         {
             SelectedMods.Value = new[] { ruleset.GetAutoplayMod() };
-            return new TestPlayer(false);
+            return new TestReplayPlayer(false);
         }
 
         protected override void AddCheckSteps()

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

@@ -0,0 +1,130 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Lists;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Extensions;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Skinning.Legacy;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneBeatmapSkinFallbacks : OsuPlayerTestScene
+    {
+        private ISkin currentBeatmapSkin;
+
+        [Resolved]
+        private SkinManager skinManager { get; set; }
+
+        [Cached]
+        private ScoreProcessor scoreProcessor = new ScoreProcessor();
+
+        [Cached(typeof(HealthProcessor))]
+        private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
+
+        protected override bool HasCustomSteps => true;
+
+        [Test]
+        public void TestEmptyLegacyBeatmapSkinFallsBack()
+        {
+            CreateSkinTest(SkinInfo.Default, () => new LegacyBeatmapSkin(new BeatmapInfo(), null, null));
+            AddAssert("hud from default skin", () => AssertComponentsFromExpectedSource(SkinnableTarget.MainHUDComponents, skinManager.CurrentSkin.Value));
+        }
+
+        protected void CreateSkinTest(SkinInfo gameCurrentSkin, Func<ISkin> getBeatmapSkin)
+        {
+            CreateTest(() =>
+            {
+                AddStep("setup skins", () =>
+                {
+                    skinManager.CurrentSkinInfo.Value = gameCurrentSkin;
+                    currentBeatmapSkin = getBeatmapSkin();
+                });
+            });
+        }
+
+        protected bool AssertComponentsFromExpectedSource(SkinnableTarget target, ISkin expectedSource)
+        {
+            var actualComponentsContainer = Player.ChildrenOfType<SkinnableTargetContainer>().First(s => s.Target == target)
+                                                  .ChildrenOfType<SkinnableTargetComponentsContainer>().SingleOrDefault();
+
+            if (actualComponentsContainer == null)
+                return false;
+
+            var actualInfo = actualComponentsContainer.CreateSkinnableInfo();
+
+            var expectedComponentsContainer = (SkinnableTargetComponentsContainer)expectedSource.GetDrawableComponent(new SkinnableTargetComponent(target));
+            if (expectedComponentsContainer == null)
+                return false;
+
+            var expectedComponentsAdjustmentContainer = new Container
+            {
+                Position = actualComponentsContainer.Parent.ToSpaceOfOtherDrawable(actualComponentsContainer.DrawPosition, Content),
+                Size = actualComponentsContainer.DrawSize,
+                Child = expectedComponentsContainer,
+            };
+
+            Add(expectedComponentsAdjustmentContainer);
+            expectedComponentsAdjustmentContainer.UpdateSubTree();
+            var expectedInfo = expectedComponentsContainer.CreateSkinnableInfo();
+            Remove(expectedComponentsAdjustmentContainer);
+
+            return almostEqual(actualInfo, expectedInfo);
+
+            static bool almostEqual(SkinnableInfo info, SkinnableInfo other) =>
+                other != null
+                && info.Type == other.Type
+                && info.Anchor == other.Anchor
+                && info.Origin == other.Origin
+                && Precision.AlmostEquals(info.Position, other.Position)
+                && Precision.AlmostEquals(info.Scale, other.Scale)
+                && Precision.AlmostEquals(info.Rotation, other.Rotation)
+                && info.Children.SequenceEqual(other.Children, new FuncEqualityComparer<SkinnableInfo>(almostEqual));
+        }
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+            => new CustomSkinWorkingBeatmap(beatmap, storyboard, Clock, Audio, currentBeatmapSkin);
+
+        protected override Ruleset CreatePlayerRuleset() => new TestOsuRuleset();
+
+        private class CustomSkinWorkingBeatmap : ClockBackedTestWorkingBeatmap
+        {
+            private readonly ISkin beatmapSkin;
+
+            public CustomSkinWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio, ISkin beatmapSkin)
+                : base(beatmap, storyboard, referenceClock, audio)
+            {
+                this.beatmapSkin = beatmapSkin;
+            }
+
+            protected override ISkin GetSkin() => beatmapSkin;
+        }
+
+        private class TestOsuRuleset : OsuRuleset
+        {
+            public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new TestOsuLegacySkinTransformer(source);
+
+            private class TestOsuLegacySkinTransformer : OsuLegacySkinTransformer
+            {
+                public TestOsuLegacySkinTransformer(ISkinSource source)
+                    : base(source)
+                {
+                }
+            }
+        }
+    }
+}

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

@@ -90,6 +90,20 @@ namespace osu.Game.Tests.Visual.Gameplay
             assertChildPosition(5);
         }
 
+        [TestCase("pooled")]
+        [TestCase("non-pooled")]
+        public void TestLifetimeRecomputedWhenTimeRangeChanges(string pooled)
+        {
+            var beatmap = createBeatmap(_ => pooled == "pooled" ? new TestPooledHitObject() : new TestHitObject());
+            beatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = time_range });
+            createTest(beatmap);
+
+            assertDead(3);
+
+            AddStep("increase time range", () => drawableRuleset.TimeRange.Value = 3 * time_range);
+            assertPosition(3, 1);
+        }
+
         [Test]
         public void TestRelativeBeatLengthScaleSingleTimingPoint()
         {

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

@@ -29,8 +29,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("allow skin lookup", () => storyboard.UseSkinSprites = false);
 
-            AddStep("create sprites", () => SetContents(
-                () => createSprite(lookup_name, Anchor.TopLeft, Vector2.Zero)));
+            AddStep("create sprites", () => SetContents(_ => createSprite(lookup_name, Anchor.TopLeft, Vector2.Zero)));
 
             assertSpritesFromSkin(false);
         }
@@ -42,8 +41,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("allow skin lookup", () => storyboard.UseSkinSprites = true);
 
-            AddStep("create sprites", () => SetContents(
-                () => createSprite(lookup_name, Anchor.Centre, Vector2.Zero)));
+            AddStep("create sprites", () => SetContents(_ => createSprite(lookup_name, Anchor.Centre, Vector2.Zero)));
 
             assertSpritesFromSkin(true);
         }

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

@@ -4,14 +4,15 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
 using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Rulesets.Catch.Scoring;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
@@ -29,15 +30,22 @@ namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestSceneHitErrorMeter : OsuTestScene
     {
-        [Cached]
-        private ScoreProcessor scoreProcessor = new ScoreProcessor();
+        [Cached(typeof(ScoreProcessor))]
+        private TestScoreProcessor scoreProcessor = new TestScoreProcessor();
 
         [Cached(typeof(DrawableRuleset))]
         private TestDrawableRuleset drawableRuleset = new TestDrawableRuleset();
 
-        public TestSceneHitErrorMeter()
+        [SetUpSteps]
+        public void SetUp()
         {
-            recreateDisplay(new OsuHitWindows(), 5);
+            AddStep("reset score processor", () => scoreProcessor.Reset());
+        }
+
+        [Test]
+        public void TestBasic()
+        {
+            AddStep("create display", () => recreateDisplay(new OsuHitWindows(), 5));
 
             AddRepeatStep("New random judgement", () => newJudgement(), 40);
 
@@ -45,12 +53,11 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddRepeatStep("New max positive", () => newJudgement(drawableRuleset.HitWindows.WindowFor(HitResult.Meh)), 20);
             AddStep("New fixed judgement (50ms)", () => newJudgement(50));
 
+            ScheduledDelegate del = null;
             AddStep("Judgement barrage", () =>
             {
                 int runCount = 0;
 
-                ScheduledDelegate del = null;
-
                 del = Scheduler.AddDelayed(() =>
                 {
                     newJudgement(runCount++ / 10f);
@@ -60,6 +67,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                         del?.Cancel();
                 }, 10, true);
             });
+            AddUntilStep("wait for barrage", () => del.Cancelled);
         }
 
         [Test]
@@ -84,10 +92,49 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         [Test]
-        public void TestCatch()
+        public void TestEmpty()
         {
-            AddStep("OD 1", () => recreateDisplay(new CatchHitWindows(), 1));
-            AddStep("OD 10", () => recreateDisplay(new CatchHitWindows(), 10));
+            AddStep("empty windows", () => recreateDisplay(HitWindows.Empty, 5));
+
+            AddStep("hit", () => newJudgement());
+            AddAssert("no bars added", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("circle added", () =>
+                this.ChildrenOfType<ColourHitErrorMeter>().All(
+                    meter => meter.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Count() == 1));
+
+            AddStep("miss", () => newJudgement(50, HitResult.Miss));
+            AddAssert("no bars added", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("circle added", () =>
+                this.ChildrenOfType<ColourHitErrorMeter>().All(
+                    meter => meter.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Count() == 2));
+        }
+
+        [Test]
+        public void TestBonus()
+        {
+            AddStep("OD 1", () => recreateDisplay(new OsuHitWindows(), 1));
+
+            AddStep("small bonus", () => newJudgement(result: HitResult.SmallBonus));
+            AddAssert("no bars added", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("no circle added", () => !this.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Any());
+
+            AddStep("large bonus", () => newJudgement(result: HitResult.LargeBonus));
+            AddAssert("no bars added", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("no circle added", () => !this.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Any());
+        }
+
+        [Test]
+        public void TestIgnore()
+        {
+            AddStep("OD 1", () => recreateDisplay(new OsuHitWindows(), 1));
+
+            AddStep("ignore hit", () => newJudgement(result: HitResult.IgnoreHit));
+            AddAssert("no bars added", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("no circle added", () => !this.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Any());
+
+            AddStep("ignore miss", () => newJudgement(result: HitResult.IgnoreMiss));
+            AddAssert("no bars added", () => !this.ChildrenOfType<BarHitErrorMeter.JudgementLine>().Any());
+            AddAssert("no circle added", () => !this.ChildrenOfType<ColourHitErrorMeter.HitErrorCircle>().Any());
         }
 
         private void recreateDisplay(HitWindows hitWindows, float overallDifficulty)
@@ -154,12 +201,12 @@ namespace osu.Game.Tests.Visual.Gameplay
             });
         }
 
-        private void newJudgement(double offset = 0)
+        private void newJudgement(double offset = 0, HitResult result = HitResult.Perfect)
         {
             scoreProcessor.ApplyResult(new JudgementResult(new HitCircle { HitWindows = drawableRuleset.HitWindows }, new Judgement())
             {
                 TimeOffset = offset == 0 ? RNG.Next(-150, 150) : offset,
-                Type = HitResult.Perfect,
+                Type = result,
             });
         }
 
@@ -177,6 +224,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             public override Container Overlays { get; }
             public override Container FrameStableComponents { get; }
             public override IFrameStableClock FrameStableClock { get; }
+            internal override bool FrameStablePlayback { get; set; }
             public override IReadOnlyList<Mod> Mods { get; }
 
             public override double GameplayStartTime { get; }
@@ -198,5 +246,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public override void CancelResume() => throw new NotImplementedException();
         }
+
+        private class TestScoreProcessor : ScoreProcessor
+        {
+            public void Reset() => base.Reset(false);
+        }
     }
 }

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

@@ -88,13 +88,18 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             beforeLoadAction?.Invoke();
 
+            prepareBeatmap();
+
+            LoadScreen(loader = new TestPlayerLoader(() => player = new TestPlayer(interactive, interactive)));
+        }
+
+        private void prepareBeatmap()
+        {
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
             Beatmap.Value.BeatmapInfo.EpilepsyWarning = epilepsyWarning;
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToTrack>())
                 mod.ApplyToTrack(Beatmap.Value.Track);
-
-            LoadScreen(loader = new TestPlayerLoader(() => player = new TestPlayer(interactive, interactive)));
         }
 
         [Test]
@@ -178,10 +183,13 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddStep("load slow dummy beatmap", () =>
             {
-                LoadScreen(loader = new TestPlayerLoader(() => slowPlayer = new SlowLoadPlayer(false, false)));
-                Scheduler.AddDelayed(() => slowPlayer.AllowLoad.Set(), 5000);
+                prepareBeatmap();
+                slowPlayer = new SlowLoadPlayer(false, false);
+                LoadScreen(loader = new TestPlayerLoader(() => slowPlayer));
             });
 
+            AddStep("schedule slow load", () => Scheduler.AddDelayed(() => slowPlayer.AllowLoad.Set(), 5000));
+
             AddUntilStep("wait for player to be current", () => slowPlayer.IsCurrentScreen());
         }
 

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

@@ -14,7 +14,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestToggleEditor()
         {
-            AddStep("show available components", () => SetContents(() => new SkinComponentToolbox(300)
+            AddStep("show available components", () => SetContents(_ => new SkinComponentToolbox(300)
             {
                 Anchor = Anchor.TopCentre,
                 Origin = Anchor.TopCentre,

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

@@ -27,7 +27,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create editor overlay", () =>
             {
-                SetContents(() =>
+                SetContents(_ =>
                 {
                     var ruleset = new OsuRuleset();
                     var mods = new[] { ruleset.GetAutoplayMod() };

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

@@ -3,26 +3,26 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Testing;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneSkinnableAccuracyCounter : SkinnableTestScene
+    public class TestSceneSkinnableAccuracyCounter : SkinnableHUDComponentTestScene
     {
-        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
-
         [Cached]
         private ScoreProcessor scoreProcessor = new ScoreProcessor();
 
+        protected override Drawable CreateDefaultImplementation() => new DefaultAccuracyCounter();
+        protected override Drawable CreateLegacyImplementation() => new LegacyAccuracyCounter();
+
         [SetUpSteps]
         public void SetUpSteps()
         {
             AddStep("Set initial accuracy", () => scoreProcessor.Accuracy.Value = 1);
-            AddStep("Create accuracy counters", () => SetContents(() => new SkinnableDrawable(new HUDSkinComponent(HUDSkinComponents.AccuracyCounter))));
         }
 
         [Test]

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

@@ -3,26 +3,19 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Testing;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Skinning;
+using osu.Game.Screens.Play.HUD;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneComboCounter : SkinnableTestScene
+    public class TestSceneSkinnableComboCounter : SkinnableHUDComponentTestScene
     {
-        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
-
         [Cached]
         private ScoreProcessor scoreProcessor = new ScoreProcessor();
 
-        [SetUpSteps]
-        public void SetUpSteps()
-        {
-            AddStep("Create combo counters", () => SetContents(() => new SkinnableDrawable(new HUDSkinComponent(HUDSkinComponents.ComboCounter))));
-        }
+        protected override Drawable CreateDefaultImplementation() => new DefaultComboCounter();
+        protected override Drawable CreateLegacyImplementation() => new LegacyComboCounter();
 
         [Test]
         public void TestComboCounterIncrementing()

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

@@ -42,9 +42,9 @@ namespace osu.Game.Tests.Visual.Gameplay
                         Spacing = new Vector2(10),
                         Children = new[]
                         {
-                            new ExposedSkinnableDrawable("default", _ => new DefaultBox(), _ => true),
-                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), _ => true),
-                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), _ => true, ConfineMode.NoScaling)
+                            new ExposedSkinnableDrawable("default", _ => new DefaultBox()),
+                            new ExposedSkinnableDrawable("available", _ => new DefaultBox()),
+                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), ConfineMode.NoScaling)
                         }
                     },
                 };
@@ -73,9 +73,9 @@ namespace osu.Game.Tests.Visual.Gameplay
                         Spacing = new Vector2(10),
                         Children = new[]
                         {
-                            new ExposedSkinnableDrawable("default", _ => new DefaultBox(), _ => true),
-                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), _ => true, ConfineMode.ScaleToFit),
-                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), _ => true, ConfineMode.NoScaling)
+                            new ExposedSkinnableDrawable("default", _ => new DefaultBox()),
+                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), ConfineMode.ScaleToFit),
+                            new ExposedSkinnableDrawable("available", _ => new DefaultBox(), ConfineMode.NoScaling)
                         }
                     },
                 };
@@ -100,7 +100,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                     Child = new SkinProvidingContainer(secondarySource)
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Child = consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"), source => true)
+                        Child = consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"))
                     }
                 };
             });
@@ -129,7 +129,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 };
             });
 
-            AddStep("add permissive", () => target.Add(consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"), source => true)));
+            AddStep("add permissive", () => target.Add(consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"))));
             AddAssert("consumer using override source", () => consumer.Drawable is SecondarySourceBox);
             AddAssert("skinchanged only called once", () => consumer.SkinChangedCount == 1);
         }
@@ -152,7 +152,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 };
             });
 
-            AddStep("add permissive", () => target.Add(consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"), source => true)));
+            AddStep("add permissive", () => target.Add(consumer = new SkinConsumer("test", name => new NamedBox("Default Implementation"))));
             AddAssert("consumer using override source", () => consumer.Drawable is SecondarySourceBox);
             AddStep("disable", () => target.Disable());
             AddAssert("consumer using base source", () => consumer.Drawable is BaseSourceBox);
@@ -180,9 +180,8 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             public new Drawable Drawable => base.Drawable;
 
-            public ExposedSkinnableDrawable(string name, Func<ISkinComponent, Drawable> defaultImplementation, Func<ISkinSource, bool> allowFallback = null,
-                                            ConfineMode confineMode = ConfineMode.ScaleToFit)
-                : base(new TestSkinComponent(name), defaultImplementation, allowFallback, confineMode)
+            public ExposedSkinnableDrawable(string name, Func<ISkinComponent, Drawable> defaultImplementation, ConfineMode confineMode = ConfineMode.ScaleToFit)
+                : base(new TestSkinComponent(name), defaultImplementation, confineMode)
             {
             }
         }
@@ -250,14 +249,14 @@ namespace osu.Game.Tests.Visual.Gameplay
             public new Drawable Drawable => base.Drawable;
             public int SkinChangedCount { get; private set; }
 
-            public SkinConsumer(string name, Func<ISkinComponent, Drawable> defaultImplementation, Func<ISkinSource, bool> allowFallback = null)
-                : base(new TestSkinComponent(name), defaultImplementation, allowFallback)
+            public SkinConsumer(string name, Func<ISkinComponent, Drawable> defaultImplementation)
+                : base(new TestSkinComponent(name), defaultImplementation)
             {
             }
 
-            protected override void SkinChanged(ISkinSource skin, bool allowFallback)
+            protected override void SkinChanged(ISkinSource skin)
             {
-                base.SkinChanged(skin, allowFallback);
+                base.SkinChanged(skin);
                 SkinChangedCount++;
             }
         }
@@ -301,6 +300,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             public ISample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
+
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => throw new NotImplementedException();
         }
 
         private class SecondarySource : ISkin
@@ -312,6 +313,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             public ISample GetSample(ISampleInfo sampleInfo) => throw new NotImplementedException();
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
+
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => throw new NotImplementedException();
         }
 
         [Cached(typeof(ISkinSource))]
@@ -325,6 +328,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => throw new NotImplementedException();
 
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => throw new NotImplementedException();
+
             public event Action SourceChanged
             {
                 add { }

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

@@ -77,7 +77,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create overlay", () =>
             {
-                SetContents(() =>
+                SetContents(_ =>
                 {
                     hudOverlay = new HUDOverlay(null, Array.Empty<Mod>());
 

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

@@ -3,28 +3,28 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Graphics;
 using osu.Framework.Testing;
-using osu.Game.Rulesets;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneSkinnableHealthDisplay : SkinnableTestScene
+    public class TestSceneSkinnableHealthDisplay : SkinnableHUDComponentTestScene
     {
-        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
-
         [Cached(typeof(HealthProcessor))]
         private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
 
+        protected override Drawable CreateDefaultImplementation() => new DefaultHealthDisplay();
+        protected override Drawable CreateLegacyImplementation() => new LegacyHealthDisplay();
+
         [SetUpSteps]
         public void SetUpSteps()
         {
-            AddStep("Create health displays", () => SetContents(() => new SkinnableDrawable(new HUDSkinComponent(HUDSkinComponents.HealthDisplay))));
             AddStep(@"Reset all", delegate
             {
                 healthProcessor.Health.Value = 1;

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

@@ -3,26 +3,20 @@
 
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Testing;
-using osu.Game.Rulesets;
-using osu.Game.Rulesets.Osu;
+using osu.Framework.Graphics;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Skinning;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneSkinnableScoreCounter : SkinnableTestScene
+    public class TestSceneSkinnableScoreCounter : SkinnableHUDComponentTestScene
     {
-        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
-
         [Cached]
         private ScoreProcessor scoreProcessor = new ScoreProcessor();
 
-        [SetUpSteps]
-        public void SetUpSteps()
-        {
-            AddStep("Create score counters", () => SetContents(() => new SkinnableDrawable(new HUDSkinComponent(HUDSkinComponents.ScoreCounter))));
-        }
+        protected override Drawable CreateDefaultImplementation() => new DefaultScoreCounter();
+        protected override Drawable CreateLegacyImplementation() => new LegacyScoreCounter();
 
         [Test]
         public void TestScoreCounterIncrementing()

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

@@ -29,14 +29,13 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("setup hierarchy", () =>
             {
-                Children = new Drawable[]
+                Child = skinSource = new TestSkinSourceContainer
                 {
-                    skinSource = new TestSkinSourceContainer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Child = skinnableSound = new PausableSkinnableSound(new SampleInfo("Gameplay/normal-sliderslide"))
-                    },
+                    RelativeSizeAxes = Axes.Both,
                 };
+
+                // has to be added after the hierarchy above else the `ISkinSource` dependency won't be cached.
+                skinSource.Add(skinnableSound = new PausableSkinnableSound(new SampleInfo("Gameplay/normal-sliderslide")));
             });
         }
 
@@ -147,6 +146,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => source?.GetTexture(componentName, wrapModeS, wrapModeT);
             public ISample GetSample(ISampleInfo sampleInfo) => source?.GetSample(sampleInfo);
             public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => source?.GetConfig<TLookup, TValue>(lookup);
+            public ISkin FindProvider(Func<ISkin, bool> lookupFunction) => source?.FindProvider(lookupFunction);
 
             public void TriggerSourceChanged()
             {

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

@@ -76,9 +76,9 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("screen hasn't changed", () => Stack.CurrentScreen is SoloSpectator);
 
             start();
-            sendFrames();
-
             waitForPlayer();
+
+            sendFrames();
             AddAssert("ensure frames arrived", () => replayHandler.HasFrames);
 
             AddUntilStep("wait for frame starvation", () => replayHandler.WaitingForFrame);
@@ -116,12 +116,11 @@ namespace osu.Game.Tests.Visual.Gameplay
             start();
 
             loadSpectatingScreen();
+            waitForPlayer();
 
             AddStep("advance frame count", () => nextFrame = 300);
             sendFrames();
 
-            waitForPlayer();
-
             AddUntilStep("playing from correct point in time", () => player.ChildrenOfType<DrawableRuleset>().First().FrameStableClock.CurrentTime > 30000);
         }
 
@@ -210,7 +209,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         private double currentFrameStableTime
             => player.ChildrenOfType<FrameStabilityContainer>().First().FrameStableClock.CurrentTime;
 
-        private void waitForPlayer() => AddUntilStep("wait for player", () => Stack.CurrentScreen is Player);
+        private void waitForPlayer() => AddUntilStep("wait for player", () => (Stack.CurrentScreen as Player)?.IsLoaded == true);
 
         private void start(int? beatmapId = null) => AddStep("start play", () => testSpectatorClient.StartPlay(streamingUser.Id, beatmapId ?? importedBeatmapId));
 

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

@@ -53,7 +53,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             CreateTest(null);
             AddUntilStep("completion set by processor", () => Player.ScoreProcessor.HasCompleted.Value);
             AddStep("skip outro", () => InputManager.Key(osuTK.Input.Key.Space));
-            AddAssert("score shown", () => Player.IsScoreShown);
+            AddUntilStep("wait for score shown", () => Player.IsScoreShown);
+            AddUntilStep("time less than storyboard duration", () => Player.GameplayClockContainer.GameplayClock.CurrentTime < currentStoryboardDuration);
         }
 
         [Test]

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

@@ -37,7 +37,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
 
             manager.Import(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet).Wait();
         }

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

@@ -43,7 +43,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
         }
 
         [SetUp]

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

@@ -73,8 +73,11 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 for (int i = 0; i < users; i++)
                     spectatorClient.StartPlay(i, Beatmap.Value.BeatmapInfo.OnlineBeatmapID ?? 0);
 
-                Client.CurrentMatchPlayingUserIds.Clear();
-                Client.CurrentMatchPlayingUserIds.AddRange(spectatorClient.PlayingUsers);
+                spectatorClient.Schedule(() =>
+                {
+                    Client.CurrentMatchPlayingUserIds.Clear();
+                    Client.CurrentMatchPlayingUserIds.AddRange(spectatorClient.PlayingUsers);
+                });
 
                 Children = new Drawable[]
                 {
@@ -91,6 +94,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
 
             AddUntilStep("wait for load", () => leaderboard.IsLoaded);
+            AddUntilStep("wait for user population", () => Client.CurrentMatchPlayingUserIds.Count > 0);
         }
 
         [Test]

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

@@ -42,7 +42,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
 
             beatmaps = new List<BeatmapInfo>();
 

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

@@ -40,7 +40,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
             beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
 
             importedSet = beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.All).First();

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

@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
             beatmaps.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
 
             Add(beatmapTracker = new OnlinePlayBeatmapAvailabilityTracker

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

@@ -141,14 +141,21 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
         private Room createRoom(Action<Room> initFunc = null)
         {
-            var room = new Room();
-
-            room.Name.Value = "test room";
-            room.Playlist.Add(new PlaylistItem
+            var room = new Room
             {
-                Beatmap = { Value = new TestBeatmap(Ruleset.Value).BeatmapInfo },
-                Ruleset = { Value = Ruleset.Value }
-            });
+                Name =
+                {
+                    Value = "test room"
+                },
+                Playlist =
+                {
+                    new PlaylistItem
+                    {
+                        Beatmap = { Value = new TestBeatmap(Ruleset.Value).BeatmapInfo },
+                        Ruleset = { Value = Ruleset.Value }
+                    }
+                }
+            };
 
             initFunc?.Invoke(room);
             return room;

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

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(beatmaps = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
 
             var beatmapTracker = new OnlinePlayBeatmapAvailabilityTracker { SelectedItem = { BindTarget = selectedItem } };
             base.Content.Add(beatmapTracker);

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

@@ -38,7 +38,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
 
             var beatmaps = new List<BeatmapInfo>();
 

osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs

@@ -9,15 +9,19 @@ using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.Multiplayer;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Toolbar;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.OnlinePlay.Components;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Options;
 using osu.Game.Tests.Beatmaps.IO;
+using osu.Game.Tests.Visual.Multiplayer;
 using osuTK;
 using osuTK.Input;
 
@@ -95,11 +99,12 @@ namespace osu.Game.Tests.Visual.Navigation
 
             AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
 
-            AddStep("set autoplay", () => Game.SelectedMods.Value = new[] { new OsuModAutoplay() });
+            AddStep("set mods", () => Game.SelectedMods.Value = new Mod[] { new OsuModNoFail(), new OsuModDoubleTime { SpeedChange = { Value = 2 } } });
 
             AddStep("press enter", () => InputManager.Key(Key.Enter));
             AddUntilStep("wait for player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
-            AddStep("seek to end", () => player.ChildrenOfType<GameplayClockContainer>().First().Seek(beatmap().Track.Length));
+            AddUntilStep("wait for track playing", () => beatmap().Track.IsRunning);
+            AddStep("seek to near end", () => player.ChildrenOfType<GameplayClockContainer>().First().Seek(beatmap().Beatmap.HitObjects[^1].StartTime - 1000));
             AddUntilStep("wait for pass", () => (results = Game.ScreenStack.CurrentScreen as ResultsScreen) != null && results.IsLoaded);
             AddStep("attempt to retry", () => results.ChildrenOfType<HotkeyRetryOverlay>().First().Action());
             AddUntilStep("wait for player", () => Game.ScreenStack.CurrentScreen != player && Game.ScreenStack.CurrentScreen is Player);
@@ -150,6 +155,14 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("wait for track", () => !Game.MusicController.CurrentTrack.IsDummyDevice && Game.MusicController.IsPlaying);
         }
 
+        [Test]
+        public void TestPushSongSelectAndPressBackButtonImmediately()
+        {
+            AddStep("push song select", () => Game.ScreenStack.Push(new TestPlaySongSelect()));
+            AddStep("press back button", () => Game.ChildrenOfType<BackButton>().First().Action());
+            AddWaitStep("wait two frames", 2);
+        }
+
         [Test]
         public void TestExitSongSelectWithClick()
         {
@@ -296,6 +309,18 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("Toolbar is hidden", () => Game.Toolbar.State.Value == Visibility.Hidden);
         }
 
+        [Test]
+        public void TestPushMatchSubScreenAndPressBackButtonImmediately()
+        {
+            TestMultiplayer multiplayer = null;
+
+            PushAndConfirm(() => multiplayer = new TestMultiplayer());
+
+            AddStep("open room", () => multiplayer.OpenNewRoom());
+            AddStep("press back button", () => Game.ChildrenOfType<BackButton>().First().Action());
+            AddWaitStep("wait two frames", 2);
+        }
+
         private void pushEscape() =>
             AddStep("Press escape", () => InputManager.Key(Key.Escape));
 
@@ -320,5 +345,18 @@ namespace osu.Game.Tests.Visual.Navigation
 
             protected override bool DisplayStableImportPrompt => false;
         }
+
+        private class TestMultiplayer : Screens.OnlinePlay.Multiplayer.Multiplayer
+        {
+            [Cached(typeof(MultiplayerClient))]
+            public readonly TestMultiplayerClient Client;
+
+            public TestMultiplayer()
+            {
+                Client = new TestMultiplayerClient((TestMultiplayerRoomManager)RoomManager);
+            }
+
+            protected override RoomManager CreateRoomManager() => new TestMultiplayerRoomManager();
+        }
     }
 }

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

@@ -9,6 +9,8 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
@@ -36,6 +38,10 @@ namespace osu.Game.Tests.Visual.Online
         private Channel previousChannel => joinedChannels.ElementAt(joinedChannels.ToList().IndexOf(currentChannel) - 1);
         private Channel channel1 => channels[0];
         private Channel channel2 => channels[1];
+        private Channel channel3 => channels[2];
+
+        [Resolved]
+        private GameHost host { get; set; }
 
         public TestSceneChatOverlay()
         {
@@ -44,7 +50,8 @@ namespace osu.Game.Tests.Visual.Online
                                  {
                                      Name = $"Channel no. {index}",
                                      Topic = index == 3 ? null : $"We talk about the number {index} here",
-                                     Type = index % 2 == 0 ? ChannelType.PM : ChannelType.Temporary
+                                     Type = index % 2 == 0 ? ChannelType.PM : ChannelType.Temporary,
+                                     Id = index
                                  })
                                  .ToList();
         }
@@ -228,6 +235,92 @@ namespace osu.Game.Tests.Visual.Online
             AddAssert("All channels closed", () => !channelManager.JoinedChannels.Any());
         }
 
+        [Test]
+        public void TestCloseTabShortcut()
+        {
+            AddStep("Join 2 channels", () =>
+            {
+                channelManager.JoinChannel(channel1);
+                channelManager.JoinChannel(channel2);
+            });
+
+            // Want to close channel 2
+            AddStep("Select channel 2", () => clickDrawable(chatOverlay.TabMap[channel2]));
+            AddStep("Close tab via shortcut", pressCloseDocumentKeys);
+
+            // Channel 2 should be closed
+            AddAssert("Channel 1 open", () => channelManager.JoinedChannels.Contains(channel1));
+            AddAssert("Channel 2 closed", () => !channelManager.JoinedChannels.Contains(channel2));
+
+            // Want to close channel 1
+            AddStep("Select channel 1", () => clickDrawable(chatOverlay.TabMap[channel1]));
+
+            AddStep("Close tab via shortcut", pressCloseDocumentKeys);
+            // Channel 1 and channel 2 should be closed
+            AddAssert("All channels closed", () => !channelManager.JoinedChannels.Any());
+        }
+
+        [Test]
+        public void TestNewTabShortcut()
+        {
+            AddStep("Join 2 channels", () =>
+            {
+                channelManager.JoinChannel(channel1);
+                channelManager.JoinChannel(channel2);
+            });
+
+            // Want to join another channel
+            AddStep("Press new tab shortcut", pressNewTabKeys);
+
+            // Selector should be visible
+            AddAssert("Selector is visible", () => chatOverlay.SelectionOverlayState == Visibility.Visible);
+        }
+
+        [Test]
+        public void TestRestoreTabShortcut()
+        {
+            AddStep("Join 3 channels", () =>
+            {
+                channelManager.JoinChannel(channel1);
+                channelManager.JoinChannel(channel2);
+                channelManager.JoinChannel(channel3);
+            });
+
+            // Should do nothing
+            AddStep("Restore tab via shortcut", pressRestoreTabKeys);
+            AddAssert("All channels still open", () => channelManager.JoinedChannels.Count == 3);
+
+            // Close channel 1
+            AddStep("Select channel 1", () => clickDrawable(chatOverlay.TabMap[channel1]));
+            AddStep("Click normal close button", () => clickDrawable(((TestChannelTabItem)chatOverlay.TabMap[channel1]).CloseButton.Child));
+            AddAssert("Channel 1 closed", () => !channelManager.JoinedChannels.Contains(channel1));
+            AddAssert("Other channels still open", () => channelManager.JoinedChannels.Count == 2);
+
+            // Reopen channel 1
+            AddStep("Restore tab via shortcut", pressRestoreTabKeys);
+            AddAssert("All channels now open", () => channelManager.JoinedChannels.Count == 3);
+            AddAssert("Current channel is channel 1", () => currentChannel == channel1);
+
+            // Close two channels
+            AddStep("Select channel 1", () => clickDrawable(chatOverlay.TabMap[channel1]));
+            AddStep("Close channel 1", () => clickDrawable(((TestChannelTabItem)chatOverlay.TabMap[channel1]).CloseButton.Child));
+            AddStep("Select channel 2", () => clickDrawable(chatOverlay.TabMap[channel2]));
+            AddStep("Close channel 2", () => clickDrawable(((TestPrivateChannelTabItem)chatOverlay.TabMap[channel2]).CloseButton.Child));
+            AddAssert("Only one channel open", () => channelManager.JoinedChannels.Count == 1);
+            AddAssert("Current channel is channel 3", () => currentChannel == channel3);
+
+            // Should first re-open channel 2
+            AddStep("Restore tab via shortcut", pressRestoreTabKeys);
+            AddAssert("Channel 1 still closed", () => !channelManager.JoinedChannels.Contains(channel1));
+            AddAssert("Channel 2 now open", () => channelManager.JoinedChannels.Contains(channel2));
+            AddAssert("Current channel is channel 2", () => currentChannel == channel2);
+
+            // Should then re-open channel 1
+            AddStep("Restore tab via shortcut", pressRestoreTabKeys);
+            AddAssert("All channels now open", () => channelManager.JoinedChannels.Count == 3);
+            AddAssert("Current channel is channel 1", () => currentChannel == channel1);
+        }
+
         private void pressChannelHotkey(int number)
         {
             var channelKey = Key.Number0 + number;
@@ -236,6 +329,23 @@ namespace osu.Game.Tests.Visual.Online
             InputManager.ReleaseKey(Key.AltLeft);
         }
 
+        private void pressCloseDocumentKeys() => pressKeysFor(PlatformActionType.DocumentClose);
+
+        private void pressNewTabKeys() => pressKeysFor(PlatformActionType.TabNew);
+
+        private void pressRestoreTabKeys() => pressKeysFor(PlatformActionType.TabRestore);
+
+        private void pressKeysFor(PlatformActionType type)
+        {
+            var binding = host.PlatformKeyBindings.First(b => ((PlatformAction)b.Action).ActionType == type);
+
+            foreach (var k in binding.KeyCombination.Keys)
+                InputManager.PressKey((Key)k);
+
+            foreach (var k in binding.KeyCombination.Keys)
+                InputManager.ReleaseKey((Key)k);
+        }
+
         private void clickDrawable(Drawable d)
         {
             InputManager.MoveMouseTo(d);

osu.Game.Tests/Visual/Online/TestSceneWikiHeader.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.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Wiki;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneWikiHeader : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Orange);
+
+        [Cached]
+        private readonly Bindable<APIWikiPage> wikiPageData = new Bindable<APIWikiPage>(new APIWikiPage
+        {
+            Title = "Main Page",
+            Path = "Main_Page",
+        });
+
+        private TestHeader header;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Child = header = new TestHeader
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                ShowIndexPage = dummyShowIndexPage,
+                ShowParentPage = dummyShowParentPage,
+            };
+            wikiPageData.BindTo(header.WikiPageData);
+        });
+
+        [Test]
+        public void TestWikiHeader()
+        {
+            AddAssert("Current is index", () => checkCurrent("index"));
+
+            AddStep("Change wiki page data", () => wikiPageData.Value = new APIWikiPage
+            {
+                Title = "Welcome",
+                Path = "Welcome"
+            });
+            AddAssert("Current is welcome", () => checkCurrent("Welcome"));
+            AddAssert("Check breadcrumb", checkBreadcrumb);
+
+            AddStep("Change current to index", () => header.Current.Value = "index");
+            AddAssert("Current is index", () => checkCurrent("index"));
+
+            AddStep("Change wiki page data", () => wikiPageData.Value = new APIWikiPage
+            {
+                Title = "Developers",
+                Path = "People/The_Team/Developers",
+                Subtitle = "The Team",
+            });
+            AddAssert("Current is 'Developers'", () => checkCurrent("Developers"));
+            AddAssert("Check breadcrumb", checkBreadcrumb);
+
+            AddStep("Change current to 'The Team'", () => header.Current.Value = "The Team");
+            AddAssert("Current is 'The Team'", () => checkCurrent("The Team"));
+            AddAssert("Check breadcrumb", checkBreadcrumb);
+        }
+
+        private bool checkCurrent(string expectedCurrent) => header.Current.Value == expectedCurrent;
+
+        private bool checkBreadcrumb()
+        {
+            var result = header.TabControlItems.Contains(wikiPageData.Value.Title);
+
+            if (wikiPageData.Value.Subtitle != null)
+                result = header.TabControlItems.Contains(wikiPageData.Value.Subtitle) && result;
+
+            return result;
+        }
+
+        private void dummyShowIndexPage() => wikiPageData.SetDefault();
+
+        private void dummyShowParentPage()
+        {
+            wikiPageData.Value = new APIWikiPage
+            {
+                Path = "People/The_Team",
+                Title = "The Team",
+                Subtitle = "People"
+            };
+        }
+
+        private class TestHeader : WikiHeader
+        {
+            public IReadOnlyList<string> TabControlItems => TabControl.Items;
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+// 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.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Wiki;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneWikiMainPage : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider overlayColour = new OverlayColourProvider(OverlayColourScheme.Orange);
+
+        public TestSceneWikiMainPage()
+        {
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    Colour = overlayColour.Background5,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new BasicScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(20),
+                    Child = new WikiMainPage
+                    {
+                        Markdown = main_page_markdown
+                    }
+                }
+            };
+        }
+
+        // From https://osu.ppy.sh/api/v2/wiki/en/Main_Page
+        private const string main_page_markdown =
+            "---\nlayout: main_page\n---\n\n<!-- Do not add any empty lines inside this div. -->\n\n<div class=\"wiki-main-page__blurb\">\nWelcome to the osu! wiki, a project containing a wide range of osu! related information.\n</div>\n\n<div class=\"wiki-main-page__panels\">\n<div class=\"wiki-main-page-panel wiki-main-page-panel--full\">\n\n# Getting started\n\n[Welcome](/wiki/Welcome) • [Installation](/wiki/Installation) • [Registration](/wiki/Registration) • [Help Centre](/wiki/Help_Centre) • [FAQ](/wiki/FAQ)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Game client\n\n[Interface](/wiki/Interface) • [Options](/wiki/Options) • [Visual settings](/wiki/Visual_Settings) • [Shortcut key reference](/wiki/Shortcut_key_reference) • [Configuration file](/wiki/osu!_Program_Files/User_Configuration_File) • [Program files](/wiki/osu!_Program_Files)\n\n[File formats](/wiki/osu!_File_Formats): [.osz](/wiki/osu!_File_Formats/Osz_(file_format)) • [.osk](/wiki/osu!_File_Formats/Osk_(file_format)) • [.osr](/wiki/osu!_File_Formats/Osr_(file_format)) • [.osu](/wiki/osu!_File_Formats/Osu_(file_format)) • [.osb](/wiki/osu!_File_Formats/Osb_(file_format)) • [.db](/wiki/osu!_File_Formats/Db_(file_format))\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Gameplay\n\n[Game modes](/wiki/Game_mode): [osu!](/wiki/Game_mode/osu!) • [osu!taiko](/wiki/Game_mode/osu!taiko) • [osu!catch](/wiki/Game_mode/osu!catch) • [osu!mania](/wiki/Game_mode/osu!mania)\n\n[Beatmap](/wiki/Beatmap) • [Hit object](/wiki/Hit_object) • [Mods](/wiki/Game_modifier) • [Score](/wiki/Score) • [Replay](/wiki/Replay) • [Multi](/wiki/Multi)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# [Beatmap editor](/wiki/Beatmap_Editor)\n\nSections: [Compose](/wiki/Beatmap_Editor/Compose) • [Design](/wiki/Beatmap_Editor/Design) • [Timing](/wiki/Beatmap_Editor/Timing) • [Song setup](/wiki/Beatmap_Editor/Song_Setup)\n\nComponents: [AiMod](/wiki/Beatmap_Editor/AiMod) • [Beat snap divisor](/wiki/Beatmap_Editor/Beat_Snap_Divisor) • [Distance snap](/wiki/Beatmap_Editor/Distance_Snap) • [Menu](/wiki/Beatmap_Editor/Menu) • [SB load](/wiki/Beatmap_Editor/SB_Load) • [Timelines](/wiki/Beatmap_Editor/Timelines)\n\n[Beatmapping](/wiki/Beatmapping) • [Difficulty](/wiki/Beatmap/Difficulty) • [Mapping techniques](/wiki/Mapping_Techniques) • [Storyboarding](/wiki/Storyboarding)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Beatmap submission and ranking\n\n[Submission](/wiki/Submission) • [Modding](/wiki/Modding) • [Ranking procedure](/wiki/Beatmap_ranking_procedure) • [Mappers' Guild](/wiki/Mappers_Guild) • [Project Loved](/wiki/Project_Loved)\n\n[Ranking criteria](/wiki/Ranking_Criteria): [osu!](/wiki/Ranking_Criteria/osu!) • [osu!taiko](/wiki/Ranking_Criteria/osu!taiko) • [osu!catch](/wiki/Ranking_Criteria/osu!catch) • [osu!mania](/wiki/Ranking_Criteria/osu!mania)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# Community\n\n[Tournaments](/wiki/Tournaments) • [Skinning](/wiki/Skinning) • [Projects](/wiki/Projects) • [Guides](/wiki/Guides) • [osu!dev Discord server](/wiki/osu!dev_Discord_server) • [How you can help](/wiki/How_You_Can_Help!) • [Glossary](/wiki/Glossary)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# People\n\n[The Team](/wiki/People/The_Team): [Developers](/wiki/People/The_Team/Developers) • [Global Moderation Team](/wiki/People/The_Team/Global_Moderation_Team) • [Support Team](/wiki/People/The_Team/Support_Team) • [Nomination Assessment Team](/wiki/People/The_Team/Nomination_Assessment_Team) • [Beatmap Nominators](/wiki/People/The_Team/Beatmap_Nominators) • [osu! Alumni](/wiki/People/The_Team/osu!_Alumni) • [Project Loved Team](/wiki/People/The_Team/Project_Loved_Team)\n\nOrganisations: [osu! UCI](/wiki/Organisations/osu!_UCI)\n\n[Community Contributors](/wiki/People/Community_Contributors) • [Users with unique titles](/wiki/People/Users_with_unique_titles)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# For developers\n\n[API](/wiki/osu!api) • [Bot account](/wiki/Bot_account) • [Brand identity guidelines](/wiki/Brand_identity_guidelines)\n\n</div>\n<div class=\"wiki-main-page-panel\">\n\n# About the wiki\n\n[Sitemap](/wiki/Sitemap) • [Contribution guide](/wiki/osu!_wiki_Contribution_Guide) • [Article styling criteria](/wiki/Article_Styling_Criteria) • [News styling criteria](/wiki/News_Styling_Criteria)\n\n</div>\n</div>\n";
+    }
+}

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

@@ -0,0 +1,175 @@
+// 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 Markdig.Syntax.Inlines;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Containers.Markdown;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics.Containers.Markdown;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Wiki.Markdown;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneWikiMarkdownContainer : OsuTestScene
+    {
+        private TestMarkdownContainer markdownContainer;
+
+        [Cached]
+        private readonly OverlayColourProvider overlayColour = new OverlayColourProvider(OverlayColourScheme.Orange);
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    Colour = overlayColour.Background5,
+                    RelativeSizeAxes = Axes.Both,
+                },
+                new BasicScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Padding = new MarginPadding(20),
+                    Child = markdownContainer = new TestMarkdownContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                    }
+                }
+            };
+        });
+
+        [Test]
+        public void TestLink()
+        {
+            AddStep("set current path", () => markdownContainer.CurrentPath = $"{API.WebsiteRootUrl}/wiki/Article_styling_criteria/");
+
+            AddStep("set '/wiki/Main_Page''", () => markdownContainer.Text = "[wiki main page](/wiki/Main_Page)");
+            AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/Main_Page");
+
+            AddStep("set '../FAQ''", () => markdownContainer.Text = "[FAQ](../FAQ)");
+            AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/FAQ");
+
+            AddStep("set './Writing''", () => markdownContainer.Text = "[wiki writing guidline](./Writing)");
+            AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/Article_styling_criteria/Writing");
+
+            AddStep("set 'Formatting''", () => markdownContainer.Text = "[wiki formatting guidline](Formatting)");
+            AddAssert("check url", () => markdownContainer.Link.Url == $"{API.WebsiteRootUrl}/wiki/Article_styling_criteria/Formatting");
+        }
+
+        [Test]
+        public void TestOutdatedNoticeBox()
+        {
+            AddStep("Add outdated yaml header", () =>
+            {
+                markdownContainer.Text = @"---
+outdated: true
+---";
+            });
+        }
+
+        [Test]
+        public void TestNeedsCleanupNoticeBox()
+        {
+            AddStep("Add needs cleanup yaml header", () =>
+            {
+                markdownContainer.Text = @"---
+needs_cleanup: true
+---";
+            });
+        }
+
+        [Test]
+        public void TestOnlyShowOutdatedNoticeBox()
+        {
+            AddStep("Add outdated and needs cleanup yaml", () =>
+            {
+                markdownContainer.Text = @"---
+outdated: true
+needs_cleanup: true
+---";
+            });
+        }
+
+        [Test]
+        public void TestAbsoluteImage()
+        {
+            AddStep("Add absolute image", () =>
+            {
+                markdownContainer.DocumentUrl = "https://dev.ppy.sh";
+                markdownContainer.Text = "![intro](/wiki/Interface/img/intro-screen.jpg)";
+            });
+        }
+
+        [Test]
+        public void TestRelativeImage()
+        {
+            AddStep("Add relative image", () =>
+            {
+                markdownContainer.DocumentUrl = "https://dev.ppy.sh";
+                markdownContainer.CurrentPath = $"{API.WebsiteRootUrl}/wiki/Interface/";
+                markdownContainer.Text = "![intro](img/intro-screen.jpg)";
+            });
+        }
+
+        [Test]
+        public void TestBlockImage()
+        {
+            AddStep("Add paragraph with block image", () =>
+            {
+                markdownContainer.DocumentUrl = "https://dev.ppy.sh";
+                markdownContainer.CurrentPath = $"{API.WebsiteRootUrl}/wiki/Interface/";
+                markdownContainer.Text = @"Line before image
+
+![play menu](img/play-menu.jpg ""Main Menu in osu!"")
+
+Line after image";
+            });
+        }
+
+        [Test]
+        public void TestInlineImage()
+        {
+            AddStep("Add inline image", () =>
+            {
+                markdownContainer.DocumentUrl = "https://dev.ppy.sh";
+                markdownContainer.Text = "![osu! mode icon](/wiki/shared/mode/osu.png) osu!";
+            });
+        }
+
+        private class TestMarkdownContainer : WikiMarkdownContainer
+        {
+            public LinkInline Link;
+
+            public new string DocumentUrl
+            {
+                set => base.DocumentUrl = value;
+            }
+
+            public override MarkdownTextFlowContainer CreateTextFlow() => new TestMarkdownTextFlowContainer
+            {
+                UrlAdded = link => Link = link,
+            };
+
+            private class TestMarkdownTextFlowContainer : OsuMarkdownTextFlowContainer
+            {
+                public Action<LinkInline> UrlAdded;
+
+                protected override void AddLinkText(string text, LinkInline linkInline)
+                {
+                    base.AddLinkText(text, linkInline);
+
+                    UrlAdded?.Invoke(linkInline);
+                }
+
+                protected override void AddImage(LinkInline linkInline) => AddDrawable(new WikiMarkdownImage(linkInline));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+// 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 Markdig.Parsers;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Graphics.Containers.Markdown;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Wiki;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneWikiSidebar : OsuTestScene
+    {
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Orange);
+
+        [Cached]
+        private readonly OverlayScrollContainer scrollContainer = new OverlayScrollContainer();
+
+        private WikiSidebar sidebar;
+
+        [SetUp]
+        public void SetUp() => Schedule(() => Child = sidebar = new WikiSidebar());
+
+        [Test]
+        public void TestNoContent()
+        {
+            AddStep("No Content", () => { });
+        }
+
+        [Test]
+        public void TestOnlyMainTitle()
+        {
+            AddStep("Add TOC", () =>
+            {
+                for (var i = 0; i < 10; i++)
+                    addTitle($"This is a very long title {i + 1}");
+            });
+        }
+
+        [Test]
+        public void TestWithSubtitle()
+        {
+            AddStep("Add TOC", () =>
+            {
+                for (var i = 0; i < 10; i++)
+                    addTitle($"This is a very long title {i + 1}", i % 4 != 0);
+            });
+        }
+
+        private void addTitle(string text, bool subtitle = false)
+        {
+            var headingBlock = new HeadingBlock(new HeadingBlockParser())
+            {
+                Inline = new ContainerInline().AppendChild(new LiteralInline(text)),
+                Level = subtitle ? 3 : 2,
+            };
+            var heading = new OsuMarkdownHeading(headingBlock);
+            sidebar.AddEntry(headingBlock, heading);
+        }
+    }
+}

osu.Game.Tests/Visual/Playlists/TestScenePlaylistsRoomSubScreen.cs

@@ -38,7 +38,7 @@ namespace osu.Game.Tests.Visual.Playlists
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, Beatmap.Default));
 
             manager.Import(new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo.BeatmapSet).Wait();
 

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

@@ -70,6 +70,7 @@ namespace osu.Game.Tests.Visual.Settings
             AddStep("click first row", () =>
             {
                 firstRow = panel.ChildrenOfType<KeyBindingRow>().First();
+
                 InputManager.MoveMouseTo(firstRow);
                 InputManager.Click(MouseButton.Left);
             });
@@ -138,6 +139,64 @@ namespace osu.Game.Tests.Visual.Settings
             }
         }
 
+        [Test]
+        public void TestSingleBindingResetButton()
+        {
+            KeyBindingRow settingsKeyBindingRow = null;
+
+            AddStep("click first row", () =>
+            {
+                settingsKeyBindingRow = panel.ChildrenOfType<KeyBindingRow>().First();
+
+                InputManager.MoveMouseTo(settingsKeyBindingRow);
+                InputManager.Click(MouseButton.Left);
+                InputManager.PressKey(Key.P);
+                InputManager.ReleaseKey(Key.P);
+            });
+
+            AddUntilStep("restore button shown", () => settingsKeyBindingRow.ChildrenOfType<RestoreDefaultValueButton<bool>>().First().Alpha > 0);
+
+            AddStep("click reset button for bindings", () =>
+            {
+                var resetButton = settingsKeyBindingRow.ChildrenOfType<RestoreDefaultValueButton<bool>>().First();
+
+                resetButton.Click();
+            });
+
+            AddUntilStep("restore button hidden", () => settingsKeyBindingRow.ChildrenOfType<RestoreDefaultValueButton<bool>>().First().Alpha == 0);
+
+            AddAssert("binding cleared", () => settingsKeyBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().ElementAt(0).KeyBinding.KeyCombination.Equals(settingsKeyBindingRow.Defaults.ElementAt(0)));
+        }
+
+        [Test]
+        public void TestResetAllBindingsButton()
+        {
+            KeyBindingRow settingsKeyBindingRow = null;
+
+            AddStep("click first row", () =>
+            {
+                settingsKeyBindingRow = panel.ChildrenOfType<KeyBindingRow>().First();
+
+                InputManager.MoveMouseTo(settingsKeyBindingRow);
+                InputManager.Click(MouseButton.Left);
+                InputManager.PressKey(Key.P);
+                InputManager.ReleaseKey(Key.P);
+            });
+
+            AddUntilStep("restore button shown", () => settingsKeyBindingRow.ChildrenOfType<RestoreDefaultValueButton<bool>>().First().Alpha > 0);
+
+            AddStep("click reset button for bindings", () =>
+            {
+                var resetButton = panel.ChildrenOfType<ResetButton>().First();
+
+                resetButton.Click();
+            });
+
+            AddUntilStep("restore button hidden", () => settingsKeyBindingRow.ChildrenOfType<RestoreDefaultValueButton<bool>>().First().Alpha == 0);
+
+            AddAssert("binding cleared", () => settingsKeyBindingRow.ChildrenOfType<KeyBindingRow.KeyButton>().ElementAt(0).KeyBinding.KeyCombination.Equals(settingsKeyBindingRow.Defaults.ElementAt(0)));
+        }
+
         [Test]
         public void TestClickRowSelectsFirstBinding()
         {

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

@@ -7,6 +7,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Testing;
 using osu.Game.Overlays.Settings;
+using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.Settings
 {
@@ -37,7 +38,7 @@ namespace osu.Game.Tests.Visual.Settings
 
         private class TestSettingsTextBox : SettingsTextBox
         {
-            public new Drawable RestoreDefaultValueButton => this.ChildrenOfType<RestoreDefaultValueButton>().Single();
+            public Drawable RestoreDefaultValueButton => this.ChildrenOfType<RestoreDefaultValueButton<string>>().Single();
         }
     }
-}
+}

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

@@ -786,9 +786,12 @@ namespace osu.Game.Tests.Visual.SongSelect
             }
         }
 
-        private void checkVisibleItemCount(bool diff, int count) =>
-            AddAssert($"{count} {(diff ? "diffs" : "sets")} visible", () =>
+        private void checkVisibleItemCount(bool diff, int count)
+        {
+            // until step required as we are querying against alive items, which are loaded asynchronously inside DrawableCarouselBeatmapSet.
+            AddUntilStep($"{count} {(diff ? "diffs" : "sets")} visible", () =>
                 carousel.Items.Count(s => (diff ? s.Item is CarouselBeatmap : s.Item is CarouselBeatmapSet) && s.Item.Visible) == count);
+        }
 
         private void checkNoSelection() => AddAssert("Selection is null", () => currentSelection == null);
 

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

@@ -36,7 +36,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private void load(GameHost host)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, host, Beatmap.Default));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, Resources, host, Beatmap.Default));
 
             beatmapManager.Import(TestResources.GetQuickTestBeatmapForImport()).Wait();
 

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

@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Visual.SongSelect
         private void load(GameHost host, AudioManager audio)
         {
             Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, defaultBeatmap = Beatmap.Default));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, Resources, host, defaultBeatmap = Beatmap.Default));
 
             Dependencies.Cache(music = new MusicController());
 
@@ -358,7 +358,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmap.Equals(target));
 
             // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo == target);
+            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.Equals(target));
         }
 
         [Test]
@@ -390,7 +390,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddUntilStep("has correct ruleset", () => Ruleset.Value.ID == 0);
 
             // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo == target);
+            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.Equals(target));
         }
 
         [Test]
@@ -781,7 +781,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.ID == 3);
 
-            AddAssert("Check first item in group selected", () => Beatmap.Value.BeatmapInfo == groupIcon.Items.First().Beatmap);
+            AddAssert("Check first item in group selected", () => Beatmap.Value.BeatmapInfo.Equals(groupIcon.Items.First().Beatmap));
         }
 
         [Test]

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

@@ -81,7 +81,7 @@ namespace osu.Game.Tests.Visual.UserInterface
             var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
             dependencies.Cache(rulesetStore = new RulesetStore(ContextFactory));
-            dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesetStore, null, dependencies.Get<AudioManager>(), dependencies.Get<GameHost>(), Beatmap.Default));
+            dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesetStore, null, dependencies.Get<AudioManager>(), Resources, dependencies.Get<GameHost>(), Beatmap.Default));
             dependencies.Cache(scoreManager = new ScoreManager(rulesetStore, () => beatmapManager, LocalStorage, null, ContextFactory));
 
             beatmap = beatmapManager.Import(new ImportTask(TestResources.GetQuickTestBeatmapForImport())).Result.Beatmaps[0];

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

@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Testing;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Dialog;
 
@@ -11,13 +13,20 @@ namespace osu.Game.Tests.Visual.UserInterface
     [TestFixture]
     public class TestSceneDialogOverlay : OsuTestScene
     {
-        public TestSceneDialogOverlay()
+        private DialogOverlay overlay;
+
+        [SetUpSteps]
+        public void SetUpSteps()
         {
-            DialogOverlay overlay;
+            AddStep("create dialog overlay", () => Child = overlay = new DialogOverlay());
+        }
 
-            Add(overlay = new DialogOverlay());
+        [Test]
+        public void TestBasic()
+        {
+            TestPopupDialog dialog = null;
 
-            AddStep("dialog #1", () => overlay.Push(new TestPopupDialog
+            AddStep("dialog #1", () => overlay.Push(dialog = new TestPopupDialog
             {
                 Icon = FontAwesome.Regular.TrashAlt,
                 HeaderText = @"Confirm deletion of",
@@ -37,7 +46,9 @@ namespace osu.Game.Tests.Visual.UserInterface
                 },
             }));
 
-            AddStep("dialog #2", () => overlay.Push(new TestPopupDialog
+            AddAssert("first dialog displayed", () => overlay.CurrentDialog == dialog);
+
+            AddStep("dialog #2", () => overlay.Push(dialog = new TestPopupDialog
             {
                 Icon = FontAwesome.Solid.Cog,
                 HeaderText = @"What do you want to do with",
@@ -70,6 +81,42 @@ namespace osu.Game.Tests.Visual.UserInterface
                     },
                 },
             }));
+
+            AddAssert("second dialog displayed", () => overlay.CurrentDialog == dialog);
+        }
+
+        [Test]
+        public void TestDismissBeforePush()
+        {
+            AddStep("dismissed dialog push", () =>
+            {
+                overlay.Push(new TestPopupDialog
+                {
+                    State = { Value = Visibility.Hidden }
+                });
+            });
+
+            AddAssert("no dialog pushed", () => overlay.CurrentDialog == null);
+        }
+
+        [Test]
+        public void TestDismissBeforePushViaButtonPress()
+        {
+            AddStep("dismissed dialog push", () =>
+            {
+                TestPopupDialog dialog;
+                overlay.Push(dialog = new TestPopupDialog
+                {
+                    Buttons = new PopupDialogButton[]
+                    {
+                        new PopupDialogOkButton { Text = @"OK" },
+                    },
+                });
+
+                dialog.PerformOkAction();
+            });
+
+            AddAssert("no dialog pushed", () => overlay.CurrentDialog == null);
         }
 
         private class TestPopupDialog : PopupDialog

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

@@ -86,6 +86,15 @@ _**italic with underscore, bold with asterisk**_";
             });
         }
 
+        [Test]
+        public void TestLinkWithTitle()
+        {
+            AddStep("Add Link with title", () =>
+            {
+                markdownContainer.Text = "[wikipedia](https://www.wikipedia.org \"The Free Encyclopedia\")";
+            });
+        }
+
         [Test]
         public void TestInlineCode()
         {

osu.Game.Tests/WaveformTestBeatmap.cs

@@ -11,6 +11,7 @@ using osu.Game.Beatmaps;
 using osu.Game.IO.Archives;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Skinning;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
 
@@ -52,6 +53,8 @@ namespace osu.Game.Tests
 
         protected override Waveform GetWaveform() => new Waveform(trackStore.GetStream(firstAudioFile));
 
+        protected override ISkin GetSkin() => null;
+
         public override Stream GetStream(string storagePath) => null;
 
         protected override Track GetBeatmapTrack() => trackStore.Get(firstAudioFile);

osu.Game.Tests/osu.Game.Tests.csproj

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
     <PackageReference Include="NUnit" Version="3.13.2" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />