Merge branch 'master' into hide-hud-during-break-time

osu.Game.Tests/Beatmaps/BeatmapDifficultyManagerTest.cs

@@ -0,0 +1,55 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+
+namespace osu.Game.Tests.Beatmaps
+{
+    [TestFixture]
+    public class BeatmapDifficultyManagerTest
+    {
+        [Test]
+        public void TestKeyEqualsWithDifferentModInstances()
+        {
+            var key1 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key2 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+
+            Assert.That(key1, Is.EqualTo(key2));
+        }
+
+        [Test]
+        public void TestKeyEqualsWithDifferentModOrder()
+        {
+            var key1 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key2 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHidden(), new OsuModHardRock() });
+
+            Assert.That(key1, Is.EqualTo(key2));
+        }
+
+        [TestCase(1.3, DifficultyRating.Easy)]
+        [TestCase(1.993, DifficultyRating.Easy)]
+        [TestCase(1.998, DifficultyRating.Normal)]
+        [TestCase(2.4, DifficultyRating.Normal)]
+        [TestCase(2.693, DifficultyRating.Normal)]
+        [TestCase(2.698, DifficultyRating.Hard)]
+        [TestCase(3.5, DifficultyRating.Hard)]
+        [TestCase(3.993, DifficultyRating.Hard)]
+        [TestCase(3.997, DifficultyRating.Insane)]
+        [TestCase(5.0, DifficultyRating.Insane)]
+        [TestCase(5.292, DifficultyRating.Insane)]
+        [TestCase(5.297, DifficultyRating.Expert)]
+        [TestCase(6.2, DifficultyRating.Expert)]
+        [TestCase(6.493, DifficultyRating.Expert)]
+        [TestCase(6.498, DifficultyRating.ExpertPlus)]
+        [TestCase(8.3, DifficultyRating.ExpertPlus)]
+        public void TestDifficultyRatingMapping(double starRating, DifficultyRating expectedBracket)
+        {
+            var actualBracket = BeatmapDifficultyManager.GetDifficultyRating(starRating);
+
+            Assert.AreEqual(expectedBracket, actualBracket);
+        }
+    }
+}

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

@@ -651,5 +651,63 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.IsInstanceOf<LegacyDifficultyCalculatorBeatmapDecoder>(decoder);
             }
         }
+
+        [Test]
+        public void TestMultiSegmentSliders()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+
+            using (var resStream = TestResources.OpenResource("multi-segment-slider.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var decoded = decoder.Decode(stream);
+
+                // Multi-segment
+                var first = ((IHasPath)decoded.HitObjects[0]).Path;
+
+                Assert.That(first.ControlPoints[0].Position.Value, Is.EqualTo(Vector2.Zero));
+                Assert.That(first.ControlPoints[0].Type.Value, Is.EqualTo(PathType.PerfectCurve));
+                Assert.That(first.ControlPoints[1].Position.Value, Is.EqualTo(new Vector2(161, -244)));
+                Assert.That(first.ControlPoints[1].Type.Value, Is.EqualTo(null));
+
+                Assert.That(first.ControlPoints[2].Position.Value, Is.EqualTo(new Vector2(376, -3)));
+                Assert.That(first.ControlPoints[2].Type.Value, Is.EqualTo(PathType.Bezier));
+                Assert.That(first.ControlPoints[3].Position.Value, Is.EqualTo(new Vector2(68, 15)));
+                Assert.That(first.ControlPoints[3].Type.Value, Is.EqualTo(null));
+                Assert.That(first.ControlPoints[4].Position.Value, Is.EqualTo(new Vector2(259, -132)));
+                Assert.That(first.ControlPoints[4].Type.Value, Is.EqualTo(null));
+                Assert.That(first.ControlPoints[5].Position.Value, Is.EqualTo(new Vector2(92, -107)));
+                Assert.That(first.ControlPoints[5].Type.Value, Is.EqualTo(null));
+
+                // Single-segment
+                var second = ((IHasPath)decoded.HitObjects[1]).Path;
+
+                Assert.That(second.ControlPoints[0].Position.Value, Is.EqualTo(Vector2.Zero));
+                Assert.That(second.ControlPoints[0].Type.Value, Is.EqualTo(PathType.PerfectCurve));
+                Assert.That(second.ControlPoints[1].Position.Value, Is.EqualTo(new Vector2(161, -244)));
+                Assert.That(second.ControlPoints[1].Type.Value, Is.EqualTo(null));
+                Assert.That(second.ControlPoints[2].Position.Value, Is.EqualTo(new Vector2(376, -3)));
+                Assert.That(second.ControlPoints[2].Type.Value, Is.EqualTo(null));
+
+                // Implicit multi-segment
+                var third = ((IHasPath)decoded.HitObjects[2]).Path;
+
+                Assert.That(third.ControlPoints[0].Position.Value, Is.EqualTo(Vector2.Zero));
+                Assert.That(third.ControlPoints[0].Type.Value, Is.EqualTo(PathType.Bezier));
+                Assert.That(third.ControlPoints[1].Position.Value, Is.EqualTo(new Vector2(0, 192)));
+                Assert.That(third.ControlPoints[1].Type.Value, Is.EqualTo(null));
+                Assert.That(third.ControlPoints[2].Position.Value, Is.EqualTo(new Vector2(224, 192)));
+                Assert.That(third.ControlPoints[2].Type.Value, Is.EqualTo(null));
+
+                Assert.That(third.ControlPoints[3].Position.Value, Is.EqualTo(new Vector2(224, 0)));
+                Assert.That(third.ControlPoints[3].Type.Value, Is.EqualTo(PathType.Bezier));
+                Assert.That(third.ControlPoints[4].Position.Value, Is.EqualTo(new Vector2(224, -192)));
+                Assert.That(third.ControlPoints[4].Type.Value, Is.EqualTo(null));
+                Assert.That(third.ControlPoints[5].Position.Value, Is.EqualTo(new Vector2(480, -192)));
+                Assert.That(third.ControlPoints[5].Type.Value, Is.EqualTo(null));
+                Assert.That(third.ControlPoints[6].Position.Value, Is.EqualTo(new Vector2(480, 0)));
+                Assert.That(third.ControlPoints[6].Type.Value, Is.EqualTo(null));
+            }
+        }
     }
 }

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

@@ -10,6 +10,7 @@ using System.Text;
 using NUnit.Framework;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Formats;
@@ -19,6 +20,7 @@ using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Taiko;
+using osu.Game.Skinning;
 using osu.Game.Tests.Resources;
 
 namespace osu.Game.Tests.Beatmaps.Formats
@@ -26,18 +28,33 @@ namespace osu.Game.Tests.Beatmaps.Formats
     [TestFixture]
     public class LegacyBeatmapEncoderTest
     {
-        private static IEnumerable<string> allBeatmaps => TestResources.GetStore().GetAvailableResources().Where(res => res.EndsWith(".osu"));
+        private static readonly DllResourceStore beatmaps_resource_store = TestResources.GetStore();
+
+        private static IEnumerable<string> allBeatmaps = beatmaps_resource_store.GetAvailableResources().Where(res => res.EndsWith(".osu", StringComparison.Ordinal));
 
         [TestCaseSource(nameof(allBeatmaps))]
         public void TestEncodeDecodeStability(string name)
         {
-            var decoded = decodeFromLegacy(TestResources.GetStore().GetStream(name));
-            var decodedAfterEncode = decodeFromLegacy(encodeToLegacy(decoded));
+            var decoded = decodeFromLegacy(beatmaps_resource_store.GetStream(name), name);
+            var decodedAfterEncode = decodeFromLegacy(encodeToLegacy(decoded), name);
 
-            sort(decoded);
-            sort(decodedAfterEncode);
+            sort(decoded.beatmap);
+            sort(decodedAfterEncode.beatmap);
 
-            Assert.That(decodedAfterEncode.Serialize(), Is.EqualTo(decoded.Serialize()));
+            Assert.That(decodedAfterEncode.beatmap.Serialize(), Is.EqualTo(decoded.beatmap.Serialize()));
+            Assert.IsTrue(areComboColoursEqual(decodedAfterEncode.beatmapSkin.Configuration, decoded.beatmapSkin.Configuration));
+        }
+
+        private bool areComboColoursEqual(IHasComboColours a, IHasComboColours b)
+        {
+            // equal to null, no need to SequenceEqual
+            if (a.ComboColours == null && b.ComboColours == null)
+                return true;
+
+            if (a.ComboColours == null || b.ComboColours == null)
+                return false;
+
+            return a.ComboColours.SequenceEqual(b.ComboColours);
         }
 
         private void sort(IBeatmap beatmap)
@@ -50,18 +67,31 @@ namespace osu.Game.Tests.Beatmaps.Formats
             }
         }
 
-        private IBeatmap decodeFromLegacy(Stream stream)
+        private (IBeatmap beatmap, TestLegacySkin beatmapSkin) decodeFromLegacy(Stream stream, string name)
         {
             using (var reader = new LineBufferedReader(stream))
-                return convert(new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(reader));
+            {
+                var beatmap = new LegacyBeatmapDecoder { ApplyOffsets = false }.Decode(reader);
+                var beatmapSkin = new TestLegacySkin(beatmaps_resource_store, name);
+                return (convert(beatmap), beatmapSkin);
+            }
         }
 
-        private Stream encodeToLegacy(IBeatmap beatmap)
+        private class TestLegacySkin : LegacySkin
         {
+            public TestLegacySkin(IResourceStore<byte[]> storage, string fileName)
+                : base(new SkinInfo { Name = "Test Skin", Creator = "Craftplacer" }, storage, null, fileName)
+            {
+            }
+        }
+
+        private Stream encodeToLegacy((IBeatmap beatmap, ISkin beatmapSkin) fullBeatmap)
+        {
+            var (beatmap, beatmapSkin) = fullBeatmap;
             var stream = new MemoryStream();
 
             using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))
-                new LegacyBeatmapEncoder(beatmap).Encode(writer);
+                new LegacyBeatmapEncoder(beatmap, beatmapSkin).Encode(writer);
 
             stream.Position = 0;
 
@@ -106,7 +136,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             protected override Texture GetBackground() => throw new NotImplementedException();
 
-            protected override Track GetTrack() => throw new NotImplementedException();
+            protected override Track GetBeatmapTrack() => throw new NotImplementedException();
         }
     }
 }

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

@@ -0,0 +1,70 @@
+// 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.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Mania;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko;
+using osu.Game.Scoring;
+using osu.Game.Scoring.Legacy;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Beatmaps.Formats
+{
+    [TestFixture]
+    public class LegacyScoreDecoderTest
+    {
+        [Test]
+        public void TestDecodeManiaReplay()
+        {
+            var decoder = new TestLegacyScoreDecoder();
+
+            using (var resourceStream = TestResources.OpenResource("Replays/mania-replay.osr"))
+            {
+                var score = decoder.Parse(resourceStream);
+
+                Assert.AreEqual(3, score.ScoreInfo.Ruleset.ID);
+
+                Assert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.Great]);
+                Assert.AreEqual(1, score.ScoreInfo.Statistics[HitResult.Good]);
+
+                Assert.AreEqual(829_931, score.ScoreInfo.TotalScore);
+                Assert.AreEqual(3, score.ScoreInfo.MaxCombo);
+                Assert.IsTrue(Precision.AlmostEquals(0.8889, score.ScoreInfo.Accuracy, 0.0001));
+                Assert.AreEqual(ScoreRank.B, score.ScoreInfo.Rank);
+
+                Assert.That(score.Replay.Frames, Is.Not.Empty);
+            }
+        }
+
+        private class TestLegacyScoreDecoder : LegacyScoreDecoder
+        {
+            private static readonly Dictionary<int, Ruleset> rulesets = new Ruleset[]
+            {
+                new OsuRuleset(),
+                new TaikoRuleset(),
+                new CatchRuleset(),
+                new ManiaRuleset()
+            }.ToDictionary(ruleset => ((ILegacyRuleset)ruleset).LegacyID);
+
+            protected override Ruleset GetRuleset(int rulesetId) => rulesets[rulesetId];
+
+            protected override WorkingBeatmap GetBeatmap(string md5Hash) => new TestWorkingBeatmap(new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    MD5Hash = md5Hash,
+                    Ruleset = new OsuRuleset().RulesetInfo,
+                    BaseDifficulty = new BeatmapDifficulty()
+                }
+            });
+        }
+    }
+}

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

@@ -11,6 +11,8 @@ using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.IO.Serialization;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Tests.Resources;
 using osuTK;
@@ -90,6 +92,38 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.AreEqual(2, difficulty.SliderTickRate);
         }
 
+        [Test]
+        public void TestDecodePostConverted()
+        {
+            var converted = new OsuBeatmapConverter(decodeAsJson(normal), new OsuRuleset()).Convert();
+
+            var processor = new OsuBeatmapProcessor(converted);
+
+            processor.PreProcess();
+            foreach (var o in converted.HitObjects)
+                o.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
+            processor.PostProcess();
+
+            var beatmap = converted.Serialize().Deserialize<Beatmap>();
+
+            var curveData = beatmap.HitObjects[0] as IHasPathWithRepeats;
+            var positionData = beatmap.HitObjects[0] as IHasPosition;
+
+            Assert.IsNotNull(positionData);
+            Assert.IsNotNull(curveData);
+            Assert.AreEqual(90, curveData.Path.Distance);
+            Assert.AreEqual(new Vector2(192, 168), positionData.Position);
+            Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
+            Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
+
+            positionData = beatmap.HitObjects[1] as IHasPosition;
+
+            Assert.IsNotNull(positionData);
+            Assert.AreEqual(new Vector2(304, 56), positionData.Position);
+            Assert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
+            Assert.IsTrue(beatmap.HitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
+        }
+
         [Test]
         public void TestDecodeHitObjects()
         {
@@ -100,6 +134,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             Assert.IsNotNull(positionData);
             Assert.IsNotNull(curveData);
+            Assert.AreEqual(90, curveData.Path.Distance);
             Assert.AreEqual(new Vector2(192, 168), positionData.Position);
             Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
             Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -15,8 +15,10 @@ using osu.Framework.Extensions;
 using osu.Framework.Logging;
 using osu.Game.Beatmaps;
 using osu.Game.IO;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Resources;
+using osu.Game.Users;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
 using SharpCompress.Common;
@@ -26,17 +28,17 @@ using FileInfo = System.IO.FileInfo;
 namespace osu.Game.Tests.Beatmaps.IO
 {
     [TestFixture]
-    public class ImportBeatmapTest
+    public class ImportBeatmapTest : ImportTest
     {
         [Test]
         public async Task TestImportWhenClosed()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportWhenClosed)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    await LoadOszIntoOsu(loadOsu(host));
+                    await LoadOszIntoOsu(LoadOsuIntoHost(host));
                 }
                 finally
                 {
@@ -49,11 +51,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenDelete()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportThenDelete)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -70,11 +72,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenImport()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportThenImport)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
                     var importedSecondTime = await LoadOszIntoOsu(osu);
@@ -96,11 +98,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportThenImportWithReZip()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportThenImportWithReZip)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -154,11 +156,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportThenImportWithChangedFile()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportThenImportWithChangedFile)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -205,11 +207,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportThenImportWithDifferentFilename()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportThenImportWithDifferentFilename)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -257,11 +259,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportCorruptThenImport()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportCorruptThenImport)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -299,7 +301,7 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestRollbackOnFailure()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestRollbackOnFailure)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
@@ -312,7 +314,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                             Interlocked.Increment(ref loggedExceptionCount);
                     };
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     // ReSharper disable once AccessToModifiedClosure
@@ -376,11 +378,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenDeleteThenImport()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportThenDeleteThenImport)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -404,11 +406,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportThenDeleteThenImportWithOnlineIDMismatch(bool set)
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"{nameof(TestImportThenDeleteThenImportWithOnlineIDMismatch)}-{set}"))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-{set}"))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var imported = await LoadOszIntoOsu(osu);
 
@@ -438,11 +440,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         public async Task TestImportWithDuplicateBeatmapIDs()
         {
             // unfortunately for the time being we need to reference osu.Framework.Desktop for a game host here.
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportWithDuplicateBeatmapIDs)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var metadata = new BeatmapMetadata
                     {
@@ -494,15 +496,15 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Ignore("Binding IPC on Appveyor isn't working (port in use). Need to figure out why")]
         public void TestImportOverIPC()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("host", true))
-            using (HeadlessGameHost client = new CleanRunHeadlessGameHost("client", true))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-host", true))
+            using (HeadlessGameHost client = new CleanRunHeadlessGameHost($"{nameof(ImportBeatmapTest)}-client", true))
             {
                 try
                 {
                     Assert.IsTrue(host.IsPrimaryInstance);
                     Assert.IsFalse(client.IsPrimaryInstance);
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -524,11 +526,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportWhenFileOpen()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportWhenFileOpen)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var temp = TestResources.GetTestBeatmapForImport();
                     using (File.OpenRead(temp))
                         await osu.Dependencies.Get<BeatmapManager>().Import(temp);
@@ -546,11 +548,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportWithDuplicateHashes()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportWithDuplicateHashes)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -588,11 +590,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportNestedStructure()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportNestedStructure)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -633,11 +635,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestImportWithIgnoredDirectoryInArchive()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestImportWithIgnoredDirectoryInArchive)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     var temp = TestResources.GetTestBeatmapForImport();
 
@@ -687,11 +689,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestUpdateBeatmapInfo()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestUpdateBeatmapInfo)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     var temp = TestResources.GetTestBeatmapForImport();
@@ -717,11 +719,11 @@ namespace osu.Game.Tests.Beatmaps.IO
         [Test]
         public async Task TestUpdateBeatmapFile()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(TestUpdateBeatmapFile)))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
                     var temp = TestResources.GetTestBeatmapForImport();
@@ -756,6 +758,63 @@ namespace osu.Game.Tests.Beatmaps.IO
             }
         }
 
+        [Test]
+        public void TestCreateNewEmptyBeatmap()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+                    var manager = osu.Dependencies.Get<BeatmapManager>();
+
+                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, User.SYSTEM_USER);
+
+                    manager.Save(working.BeatmapInfo, working.Beatmap);
+
+                    var retrievedSet = manager.GetAllUsableBeatmapSets()[0];
+
+                    // Check that the new file is referenced correctly by attempting a retrieval
+                    Beatmap updatedBeatmap = (Beatmap)manager.GetWorkingBeatmap(retrievedSet.Beatmaps[0]).Beatmap;
+                    Assert.That(updatedBeatmap.HitObjects.Count, Is.EqualTo(0));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public void TestCreateNewBeatmapWithObject()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportBeatmapTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+                    var manager = osu.Dependencies.Get<BeatmapManager>();
+
+                    var working = manager.CreateNew(new OsuRuleset().RulesetInfo, User.SYSTEM_USER);
+
+                    ((Beatmap)working.Beatmap).HitObjects.Add(new HitCircle { StartTime = 5000 });
+
+                    manager.Save(working.BeatmapInfo, working.Beatmap);
+
+                    var retrievedSet = manager.GetAllUsableBeatmapSets()[0];
+
+                    // Check that the new file is referenced correctly by attempting a retrieval
+                    Beatmap updatedBeatmap = (Beatmap)manager.GetWorkingBeatmap(retrievedSet.Beatmaps[0]).Beatmap;
+                    Assert.That(updatedBeatmap.HitObjects.Count, Is.EqualTo(1));
+                    Assert.That(updatedBeatmap.HitObjects[0].StartTime, Is.EqualTo(5000));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
         public static async Task<BeatmapSetInfo> LoadOszIntoOsu(OsuGameBase osu, string path = null, bool virtualTrack = false)
         {
             var temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
@@ -804,14 +863,6 @@ namespace osu.Game.Tests.Beatmaps.IO
             Assert.AreEqual(expected, osu.Dependencies.Get<FileStore>().QueryFiles(f => f.ReferenceCount == 1).Count());
         }
 
-        private OsuGameBase loadOsu(GameHost host)
-        {
-            var osu = new OsuGameBase();
-            Task.Run(() => host.Run(osu));
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-            return osu;
-        }
-
         private static void ensureLoaded(OsuGameBase osu, int timeout = 60000)
         {
             IEnumerable<BeatmapSetInfo> resultSets = null;

osu.Game.Tests/Beatmaps/TestSceneEditorBeatmap.cs

@@ -23,15 +23,19 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestHitObjectAddEvent()
         {
-            var editorBeatmap = new EditorBeatmap(new OsuBeatmap());
-
-            HitObject addedObject = null;
-            editorBeatmap.HitObjectAdded += h => addedObject = h;
-
             var hitCircle = new HitCircle();
 
-            editorBeatmap.Add(hitCircle);
-            Assert.That(addedObject, Is.EqualTo(hitCircle));
+            HitObject addedObject = null;
+            EditorBeatmap editorBeatmap = null;
+
+            AddStep("add beatmap", () =>
+            {
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+                editorBeatmap.HitObjectAdded += h => addedObject = h;
+            });
+
+            AddStep("add hitobject", () => editorBeatmap.Add(hitCircle));
+            AddAssert("received add event", () => addedObject == hitCircle);
         }
 
         /// <summary>
@@ -41,13 +45,15 @@ namespace osu.Game.Tests.Beatmaps
         public void HitObjectRemoveEvent()
         {
             var hitCircle = new HitCircle();
-            var editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
-
             HitObject removedObject = null;
-            editorBeatmap.HitObjectRemoved += h => removedObject = h;
-
-            editorBeatmap.Remove(hitCircle);
-            Assert.That(removedObject, Is.EqualTo(hitCircle));
+            EditorBeatmap editorBeatmap = null;
+            AddStep("add beatmap", () =>
+            {
+                Child = editorBeatmap = new EditorBeatmap(new OsuBeatmap { HitObjects = { hitCircle } });
+                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+            });
+            AddStep("remove hitobject", () => editorBeatmap.Remove(editorBeatmap.HitObjects.First()));
+            AddAssert("received remove event", () => removedObject == hitCircle);
         }
 
         /// <summary>
@@ -147,6 +153,7 @@ namespace osu.Game.Tests.Beatmaps
         public void TestResortWhenStartTimeChanged()
         {
             var hitCircle = new HitCircle { StartTime = 1000 };
+
             var editorBeatmap = new EditorBeatmap(new OsuBeatmap
             {
                 HitObjects =

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

@@ -0,0 +1,173 @@
+// 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.IO;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Platform;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Collections.IO
+{
+    [TestFixture]
+    public class ImportCollectionsTest : ImportTest
+    {
+        [Test]
+        public async Task TestImportEmptyDatabase()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    await osu.CollectionManager.Import(new MemoryStream());
+
+                    Assert.That(osu.CollectionManager.Collections.Count, Is.Zero);
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportWithNoBeatmaps()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
+
+                    Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
+
+                    Assert.That(osu.CollectionManager.Collections[0].Name.Value, Is.EqualTo("First"));
+                    Assert.That(osu.CollectionManager.Collections[0].Beatmaps.Count, Is.Zero);
+
+                    Assert.That(osu.CollectionManager.Collections[1].Name.Value, Is.EqualTo("Second"));
+                    Assert.That(osu.CollectionManager.Collections[1].Beatmaps.Count, Is.Zero);
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportWithBeatmaps()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host, true);
+
+                    await osu.CollectionManager.Import(TestResources.OpenResource("Collections/collections.db"));
+
+                    Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
+
+                    Assert.That(osu.CollectionManager.Collections[0].Name.Value, Is.EqualTo("First"));
+                    Assert.That(osu.CollectionManager.Collections[0].Beatmaps.Count, Is.EqualTo(1));
+
+                    Assert.That(osu.CollectionManager.Collections[1].Name.Value, Is.EqualTo("Second"));
+                    Assert.That(osu.CollectionManager.Collections[1].Beatmaps.Count, Is.EqualTo(12));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportMalformedDatabase()
+        {
+            bool exceptionThrown = false;
+            UnhandledExceptionEventHandler setException = (_, __) => exceptionThrown = true;
+
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    AppDomain.CurrentDomain.UnhandledException += setException;
+
+                    var osu = LoadOsuIntoHost(host, true);
+
+                    using (var ms = new MemoryStream())
+                    {
+                        using (var bw = new BinaryWriter(ms, Encoding.UTF8, true))
+                        {
+                            for (int i = 0; i < 10000; i++)
+                                bw.Write((byte)i);
+                        }
+
+                        ms.Seek(0, SeekOrigin.Begin);
+
+                        await osu.CollectionManager.Import(ms);
+                    }
+
+                    Assert.That(host.UpdateThread.Running, Is.True);
+                    Assert.That(exceptionThrown, Is.False);
+                    Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(0));
+                }
+                finally
+                {
+                    host.Exit();
+                    AppDomain.CurrentDomain.UnhandledException -= setException;
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestSaveAndReload()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host, true);
+
+                    await osu.CollectionManager.Import(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]);
+                    osu.CollectionManager.Collections[1].Beatmaps.RemoveAt(0);
+
+                    // Rename the second collecction.
+                    osu.CollectionManager.Collections[1].Name.Value = "Another";
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+
+            using (HeadlessGameHost host = new HeadlessGameHost("TestSaveAndReload"))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host, true);
+
+                    Assert.That(osu.CollectionManager.Collections.Count, Is.EqualTo(2));
+
+                    Assert.That(osu.CollectionManager.Collections[0].Name.Value, Is.EqualTo("First"));
+                    Assert.That(osu.CollectionManager.Collections[0].Beatmaps.Count, Is.EqualTo(2));
+
+                    Assert.That(osu.CollectionManager.Collections[1].Name.Value, Is.EqualTo("Another"));
+                    Assert.That(osu.CollectionManager.Collections[1].Beatmaps.Count, Is.EqualTo(11));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+    }
+}

osu.Game.Tests/Editing/EditorChangeHandlerTest.cs

@@ -2,7 +2,9 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
 
 namespace osu.Game.Tests.Editing
@@ -10,16 +12,27 @@ namespace osu.Game.Tests.Editing
     [TestFixture]
     public class EditorChangeHandlerTest
     {
+        private int stateChangedFired;
+
+        [SetUp]
+        public void SetUp()
+        {
+            stateChangedFired = 0;
+        }
+
         [Test]
         public void TestSaveRestoreState()
         {
-            var handler = new EditorChangeHandler(new EditorBeatmap(new Beatmap()));
+            var (handler, beatmap) = createChangeHandler();
 
             Assert.That(handler.CanUndo.Value, Is.False);
             Assert.That(handler.CanRedo.Value, Is.False);
 
+            addArbitraryChange(beatmap);
             handler.SaveState();
 
+            Assert.That(stateChangedFired, Is.EqualTo(1));
+
             Assert.That(handler.CanUndo.Value, Is.True);
             Assert.That(handler.CanRedo.Value, Is.False);
 
@@ -27,17 +40,57 @@ namespace osu.Game.Tests.Editing
 
             Assert.That(handler.CanUndo.Value, Is.False);
             Assert.That(handler.CanRedo.Value, Is.True);
+
+            Assert.That(stateChangedFired, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestSaveSameStateDoesNotSave()
+        {
+            var (handler, beatmap) = createChangeHandler();
+
+            Assert.That(handler.CanUndo.Value, Is.False);
+            Assert.That(handler.CanRedo.Value, Is.False);
+
+            addArbitraryChange(beatmap);
+            handler.SaveState();
+
+            Assert.That(handler.CanUndo.Value, Is.True);
+            Assert.That(handler.CanRedo.Value, Is.False);
+            Assert.That(stateChangedFired, Is.EqualTo(1));
+
+            string hash = handler.CurrentStateHash;
+
+            // save a save without making any changes
+            handler.SaveState();
+
+            Assert.That(hash, Is.EqualTo(handler.CurrentStateHash));
+            Assert.That(stateChangedFired, Is.EqualTo(1));
+
+            handler.RestoreState(-1);
+
+            Assert.That(hash, Is.Not.EqualTo(handler.CurrentStateHash));
+
+            // we should only be able to restore once even though we saved twice.
+            Assert.That(handler.CanUndo.Value, Is.False);
+            Assert.That(handler.CanRedo.Value, Is.True);
+            Assert.That(stateChangedFired, Is.EqualTo(2));
         }
 
         [Test]
         public void TestMaxStatesSaved()
         {
-            var handler = new EditorChangeHandler(new EditorBeatmap(new Beatmap()));
+            var (handler, beatmap) = createChangeHandler();
 
             Assert.That(handler.CanUndo.Value, Is.False);
 
             for (int i = 0; i < EditorChangeHandler.MAX_SAVED_STATES; i++)
+            {
+                Assert.That(stateChangedFired, Is.EqualTo(i));
+
+                addArbitraryChange(beatmap);
                 handler.SaveState();
+            }
 
             Assert.That(handler.CanUndo.Value, Is.True);
 
@@ -53,12 +106,15 @@ namespace osu.Game.Tests.Editing
         [Test]
         public void TestMaxStatesExceeded()
         {
-            var handler = new EditorChangeHandler(new EditorBeatmap(new Beatmap()));
+            var (handler, beatmap) = createChangeHandler();
 
             Assert.That(handler.CanUndo.Value, Is.False);
 
             for (int i = 0; i < EditorChangeHandler.MAX_SAVED_STATES * 2; i++)
+            {
+                addArbitraryChange(beatmap);
                 handler.SaveState();
+            }
 
             Assert.That(handler.CanUndo.Value, Is.True);
 
@@ -70,5 +126,20 @@ namespace osu.Game.Tests.Editing
 
             Assert.That(handler.CanUndo.Value, Is.False);
         }
+
+        private (EditorChangeHandler, EditorBeatmap) createChangeHandler()
+        {
+            var beatmap = new EditorBeatmap(new Beatmap());
+
+            var changeHandler = new EditorChangeHandler(beatmap);
+
+            changeHandler.OnStateChange += () => stateChangedFired++;
+            return (changeHandler, beatmap);
+        }
+
+        private void addArbitraryChange(EditorBeatmap beatmap)
+        {
+            beatmap.Add(new HitCircle { StartTime = RNG.Next(0, 100000) });
+        }
     }
 }

osu.Game.Tests/Editing/LegacyEditorBeatmapPatcherTest.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Tests.Editing
             {
                 HitObjects =
                 {
-                    new HitCircle { StartTime = 1000 }
+                    new HitCircle { StartTime = 1000, NewCombo = true }
                 }
             };
 
@@ -56,7 +56,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 1000 },
+                new HitCircle { StartTime = 1000, NewCombo = true },
                 new HitCircle { StartTime = 3000 },
             });
 
@@ -78,7 +78,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 1000 },
+                new HitCircle { StartTime = 1000, NewCombo = true },
                 new HitCircle { StartTime = 2000 },
                 new HitCircle { StartTime = 3000 },
             });
@@ -100,7 +100,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 1000 },
+                new HitCircle { StartTime = 1000, NewCombo = true },
                 new HitCircle { StartTime = 2000 },
                 new HitCircle { StartTime = 3000 },
             });
@@ -109,7 +109,7 @@ namespace osu.Game.Tests.Editing
             {
                 HitObjects =
                 {
-                    new HitCircle { StartTime = 500 },
+                    new HitCircle { StartTime = 500, NewCombo = true },
                     (OsuHitObject)current.HitObjects[1],
                     (OsuHitObject)current.HitObjects[2],
                 }
@@ -123,7 +123,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 1000 },
+                new HitCircle { StartTime = 1000, NewCombo = true },
                 new HitCircle { StartTime = 2000 },
                 new HitCircle { StartTime = 3000 },
             });
@@ -146,7 +146,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new OsuHitObject[]
             {
-                new HitCircle { StartTime = 1000 },
+                new HitCircle { StartTime = 1000, NewCombo = true },
                 new Slider
                 {
                     StartTime = 2000,
@@ -188,7 +188,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 1000 },
+                new HitCircle { StartTime = 1000, NewCombo = true },
                 new HitCircle { StartTime = 2000 },
                 new HitCircle { StartTime = 3000 },
             });
@@ -197,7 +197,7 @@ namespace osu.Game.Tests.Editing
             {
                 HitObjects =
                 {
-                    new HitCircle { StartTime = 500 },
+                    new HitCircle { StartTime = 500, NewCombo = true },
                     (OsuHitObject)current.HitObjects[0],
                     new HitCircle { StartTime = 1500 },
                     (OsuHitObject)current.HitObjects[1],
@@ -216,7 +216,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 500 },
+                new HitCircle { StartTime = 500, NewCombo = true },
                 new HitCircle { StartTime = 1000 },
                 new HitCircle { StartTime = 1500 },
                 new HitCircle { StartTime = 2000 },
@@ -226,6 +226,9 @@ namespace osu.Game.Tests.Editing
                 new HitCircle { StartTime = 3500 },
             });
 
+            var patchedFirst = (HitCircle)current.HitObjects[1];
+            patchedFirst.NewCombo = true;
+
             var patch = new OsuBeatmap
             {
                 HitObjects =
@@ -244,7 +247,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 500 },
+                new HitCircle { StartTime = 500, NewCombo = true },
                 new HitCircle { StartTime = 1000 },
                 new HitCircle { StartTime = 1500 },
                 new HitCircle { StartTime = 2000 },
@@ -277,7 +280,7 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 500 },
+                new HitCircle { StartTime = 500, NewCombo = true },
                 new HitCircle { StartTime = 1000 },
                 new HitCircle { StartTime = 1500 },
                 new HitCircle { StartTime = 2000 },
@@ -291,7 +294,7 @@ namespace osu.Game.Tests.Editing
             {
                 HitObjects =
                 {
-                    new HitCircle { StartTime = 750 },
+                    new HitCircle { StartTime = 750, NewCombo = true },
                     (OsuHitObject)current.HitObjects[1],
                     (OsuHitObject)current.HitObjects[4],
                     (OsuHitObject)current.HitObjects[5],
@@ -309,20 +312,20 @@ namespace osu.Game.Tests.Editing
         {
             current.AddRange(new[]
             {
-                new HitCircle { StartTime = 500, Position = new Vector2(50) },
-                new HitCircle { StartTime = 500, Position = new Vector2(100) },
-                new HitCircle { StartTime = 500, Position = new Vector2(150) },
-                new HitCircle { StartTime = 500, Position = new Vector2(200) },
+                new HitCircle { StartTime = 500, Position = new Vector2(50), NewCombo = true },
+                new HitCircle { StartTime = 500, Position = new Vector2(100), NewCombo = true },
+                new HitCircle { StartTime = 500, Position = new Vector2(150), NewCombo = true },
+                new HitCircle { StartTime = 500, Position = new Vector2(200), NewCombo = true },
             });
 
             var patch = new OsuBeatmap
             {
                 HitObjects =
                 {
-                    new HitCircle { StartTime = 500, Position = new Vector2(150) },
-                    new HitCircle { StartTime = 500, Position = new Vector2(100) },
-                    new HitCircle { StartTime = 500, Position = new Vector2(50) },
-                    new HitCircle { StartTime = 500, Position = new Vector2(200) },
+                    new HitCircle { StartTime = 500, Position = new Vector2(150), NewCombo = true },
+                    new HitCircle { StartTime = 500, Position = new Vector2(100), NewCombo = true },
+                    new HitCircle { StartTime = 500, Position = new Vector2(50), NewCombo = true },
+                    new HitCircle { StartTime = 500, Position = new Vector2(200), NewCombo = true },
                 }
             };
 
@@ -351,7 +354,7 @@ namespace osu.Game.Tests.Editing
             using (var encoded = new MemoryStream())
             {
                 using (var sw = new StreamWriter(encoded))
-                    new LegacyBeatmapEncoder(beatmap).Encode(sw);
+                    new LegacyBeatmapEncoder(beatmap, null).Encode(sw);
 
                 return encoded.ToArray();
             }

osu.Game.Tests/Editing/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -169,17 +169,17 @@ namespace osu.Game.Tests.Editing
         [Test]
         public void GetSnappedDistanceFromDistance()
         {
-            assertSnappedDistance(50, 100);
+            assertSnappedDistance(50, 0);
             assertSnappedDistance(100, 100);
-            assertSnappedDistance(150, 200);
+            assertSnappedDistance(150, 100);
             assertSnappedDistance(200, 200);
-            assertSnappedDistance(250, 300);
+            assertSnappedDistance(250, 200);
 
             AddStep("set slider multiplier = 2", () => composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2);
 
             assertSnappedDistance(50, 0);
-            assertSnappedDistance(100, 200);
-            assertSnappedDistance(150, 200);
+            assertSnappedDistance(100, 0);
+            assertSnappedDistance(150, 0);
             assertSnappedDistance(200, 200);
             assertSnappedDistance(250, 200);
 
@@ -190,8 +190,8 @@ namespace osu.Game.Tests.Editing
             });
 
             assertSnappedDistance(50, 0);
-            assertSnappedDistance(100, 200);
-            assertSnappedDistance(150, 200);
+            assertSnappedDistance(100, 0);
+            assertSnappedDistance(150, 0);
             assertSnappedDistance(200, 200);
             assertSnappedDistance(250, 200);
             assertSnappedDistance(400, 400);

osu.Game.Tests/Editing/TransactionalCommitComponentTest.cs

@@ -0,0 +1,100 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Game.Screens.Edit;
+
+namespace osu.Game.Tests.Editing
+{
+    [TestFixture]
+    public class TransactionalCommitComponentTest
+    {
+        private TestHandler handler;
+
+        [SetUp]
+        public void SetUp()
+        {
+            handler = new TestHandler();
+        }
+
+        [Test]
+        public void TestCommitTransaction()
+        {
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.BeginChange();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+            handler.EndChange();
+
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestSaveOutsideOfTransactionTriggersUpdates()
+        {
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.SaveState();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(1));
+
+            handler.SaveState();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(2));
+        }
+
+        [Test]
+        public void TestEventsFire()
+        {
+            int transactionBegan = 0;
+            int transactionEnded = 0;
+            int stateSaved = 0;
+
+            handler.TransactionBegan += () => transactionBegan++;
+            handler.TransactionEnded += () => transactionEnded++;
+            handler.SaveStateTriggered += () => stateSaved++;
+
+            handler.BeginChange();
+            Assert.That(transactionBegan, Is.EqualTo(1));
+
+            handler.EndChange();
+            Assert.That(transactionEnded, Is.EqualTo(1));
+
+            Assert.That(stateSaved, Is.EqualTo(0));
+            handler.SaveState();
+            Assert.That(stateSaved, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestSaveDuringTransactionDoesntTriggerUpdate()
+        {
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.BeginChange();
+
+            handler.SaveState();
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(0));
+
+            handler.EndChange();
+
+            Assert.That(handler.StateUpdateCount, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void TestEndWithoutBeginThrows()
+        {
+            handler.BeginChange();
+            handler.EndChange();
+            Assert.That(() => handler.EndChange(), Throws.TypeOf<InvalidOperationException>());
+        }
+
+        private class TestHandler : TransactionalCommitComponent
+        {
+            public int StateUpdateCount { get; private set; }
+
+            protected override void UpdateState()
+            {
+                StateUpdateCount++;
+            }
+        }
+    }
+}

osu.Game.Tests/Gameplay/TestSceneDrainingHealthProcessor.cs

@@ -1,15 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Utils;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Tests.Visual;
 
@@ -167,7 +170,7 @@ namespace osu.Game.Tests.Gameplay
 
             beatmap.HitObjects.Add(new JudgeableHitObject { StartTime = 0 });
             for (double time = 0; time < 5000; time += 100)
-                beatmap.HitObjects.Add(new JudgeableHitObject(false) { StartTime = time });
+                beatmap.HitObjects.Add(new JudgeableHitObject(HitResult.LargeBonus) { StartTime = time });
             beatmap.HitObjects.Add(new JudgeableHitObject { StartTime = 5000 });
 
             createProcessor(beatmap);
@@ -175,6 +178,24 @@ namespace osu.Game.Tests.Gameplay
             assertHealthNotEqualTo(0);
         }
 
+        [Test]
+        public void TestSingleLongObjectDoesNotDrain()
+        {
+            var beatmap = new Beatmap
+            {
+                HitObjects = { new JudgeableLongHitObject() }
+            };
+
+            beatmap.HitObjects[0].ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            createProcessor(beatmap);
+            setTime(0);
+            assertHealthEqualTo(1);
+
+            setTime(5000);
+            assertHealthEqualTo(1);
+        }
+
         private Beatmap createBeatmap(double startTime, double endTime, params BreakPeriod[] breaks)
         {
             var beatmap = new Beatmap
@@ -215,25 +236,43 @@ namespace osu.Game.Tests.Gameplay
 
         private class JudgeableHitObject : HitObject
         {
-            private readonly bool affectsCombo;
+            private readonly HitResult maxResult;
 
-            public JudgeableHitObject(bool affectsCombo = true)
+            public JudgeableHitObject(HitResult maxResult = HitResult.Perfect)
             {
-                this.affectsCombo = affectsCombo;
+                this.maxResult = maxResult;
             }
 
-            public override Judgement CreateJudgement() => new TestJudgement(affectsCombo);
+            public override Judgement CreateJudgement() => new TestJudgement(maxResult);
             protected override HitWindows CreateHitWindows() => new HitWindows();
 
             private class TestJudgement : Judgement
             {
-                public override bool AffectsCombo { get; }
+                public override HitResult MaxResult { get; }
 
-                public TestJudgement(bool affectsCombo)
+                public TestJudgement(HitResult maxResult)
                 {
-                    AffectsCombo = affectsCombo;
+                    MaxResult = maxResult;
                 }
             }
         }
+
+        private class JudgeableLongHitObject : JudgeableHitObject, IHasDuration
+        {
+            public double EndTime => StartTime + Duration;
+            public double Duration { get; set; } = 5000;
+
+            public JudgeableLongHitObject()
+                : base(HitResult.LargeBonus)
+            {
+            }
+
+            protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
+            {
+                base.CreateNestedHitObjects(cancellationToken);
+
+                AddNested(new JudgeableHitObject());
+            }
+        }
     }
 }

osu.Game.Tests/Gameplay/TestSceneGameplayClockContainer.cs

@@ -1,10 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using NUnit.Framework;
 using osu.Framework.Testing;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
@@ -19,7 +17,14 @@ namespace osu.Game.Tests.Gameplay
         {
             GameplayClockContainer gcc = null;
 
-            AddStep("create container", () => Add(gcc = new GameplayClockContainer(CreateWorkingBeatmap(new OsuRuleset().RulesetInfo), Array.Empty<Mod>(), 0)));
+            AddStep("create container", () =>
+            {
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.LoadTrack();
+
+                Add(gcc = new GameplayClockContainer(working, 0));
+            });
+
             AddStep("start track", () => gcc.Start());
             AddUntilStep("elapsed greater than zero", () => gcc.GameplayClock.ElapsedFrameTime > 0);
         }

osu.Game.Tests/Gameplay/TestSceneHitObjectAccentColour.cs

@@ -81,7 +81,7 @@ namespace osu.Game.Tests.Gameplay
 
         private class TestHitObjectWithCombo : ConvertHitObject, IHasComboInformation
         {
-            public bool NewCombo { get; } = false;
+            public bool NewCombo { get; set; } = false;
             public int ComboOffset { get; } = 0;
 
             public Bindable<int> IndexInCurrentComboBindable { get; } = new Bindable<int>();

osu.Game.Tests/Gameplay/TestSceneHitObjectSamples.cs

@@ -6,9 +6,9 @@ using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
-using osu.Game.Skinning;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Tests.Resources;
+using static osu.Game.Skinning.LegacySkinConfiguration;
 
 namespace osu.Game.Tests.Gameplay
 {
@@ -67,9 +67,11 @@ namespace osu.Game.Tests.Gameplay
         /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the beatmap skin:
         /// normal-hitnormal2
         /// normal-hitnormal
+        /// hitnormal
         /// </summary>
         [TestCase("normal-hitnormal2")]
         [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
         public void TestDefaultCustomSampleFromBeatmap(string expectedSample)
         {
             SetupSkins(expectedSample, expectedSample);
@@ -80,12 +82,13 @@ namespace osu.Game.Tests.Gameplay
         }
 
         /// <summary>
-        /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the user skin when the beatmap does not contain the sample:
-        /// normal-hitnormal2
+        /// Tests that a hitobject which provides a custom sample set of 2 retrieves the following samples from the user skin
+        /// (ignoring the custom sample set index) when the beatmap skin does not contain the sample:
         /// normal-hitnormal
+        /// hitnormal
         /// </summary>
-        [TestCase("normal-hitnormal2")]
         [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
         public void TestDefaultCustomSampleFromUserSkinFallback(string expectedSample)
         {
             SetupSkins(string.Empty, expectedSample);
@@ -95,6 +98,23 @@ namespace osu.Game.Tests.Gameplay
             AssertUserLookup(expectedSample);
         }
 
+        /// <summary>
+        /// Tests that a hitobject which provides a custom sample set of 2 does not retrieve a normal-hitnormal2 sample from the user skin
+        /// if the beatmap skin does not contain the sample.
+        /// User skins in stable ignore the custom sample set index when performing lookups.
+        /// </summary>
+        [Test]
+        public void TestUserSkinLookupIgnoresSampleBank()
+        {
+            const string unwanted_sample = "normal-hitnormal2";
+
+            SetupSkins(string.Empty, unwanted_sample);
+
+            CreateTestWithBeatmap("hitobject-beatmap-custom-sample.osu");
+
+            AssertNoLookup(unwanted_sample);
+        }
+
         /// <summary>
         /// Tests that a hitobject which provides a sample file retrieves the sample file from the beatmap skin.
         /// </summary>
@@ -145,6 +165,7 @@ namespace osu.Game.Tests.Gameplay
         /// </summary>
         [TestCase("normal-hitnormal2")]
         [TestCase("normal-hitnormal")]
+        [TestCase("hitnormal")]
         public void TestControlPointCustomSampleFromBeatmap(string sampleName)
         {
             SetupSkins(sampleName, sampleName);
@@ -178,7 +199,7 @@ namespace osu.Game.Tests.Gameplay
             string[] expectedSamples =
             {
                 "normal-hitnormal2",
-                "normal-hitwhistle2"
+                "normal-hitwhistle" // user skin lookups ignore custom sample set index
             };
 
             SetupSkins(expectedSamples[0], expectedSamples[1]);
@@ -190,7 +211,7 @@ namespace osu.Game.Tests.Gameplay
         }
 
         /// <summary>
-        /// Tests that when a custom sample bank is used, but <see cref="GlobalSkinConfiguration.LayeredHitSounds"/> is disabled,
+        /// Tests that when a custom sample bank is used, but <see cref="LegacySetting.LayeredHitSounds"/> is disabled,
         /// only the additional sound will be looked up.
         /// </summary>
         [Test]
@@ -209,7 +230,7 @@ namespace osu.Game.Tests.Gameplay
         }
 
         /// <summary>
-        /// Tests that when a normal sample bank is used and <see cref="GlobalSkinConfiguration.LayeredHitSounds"/> is disabled,
+        /// Tests that when a normal sample bank is used and <see cref="LegacySetting.LayeredHitSounds"/> is disabled,
         /// the normal sound will be looked up anyway.
         /// </summary>
         [Test]
@@ -226,6 +247,6 @@ namespace osu.Game.Tests.Gameplay
         }
 
         private void disableLayeredHitSounds()
-            => AddStep("set LayeredHitSounds to false", () => Skin.Configuration.ConfigDictionary[GlobalSkinConfiguration.LayeredHitSounds.ToString()] = "0");
+            => AddStep("set LayeredHitSounds to false", () => Skin.Configuration.ConfigDictionary[LegacySetting.LayeredHitSounds.ToString()] = "0");
     }
 }

osu.Game.Tests/Gameplay/TestSceneScoreProcessor.cs

@@ -0,0 +1,55 @@
+// 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.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Gameplay
+{
+    [HeadlessTest]
+    public class TestSceneScoreProcessor : OsuTestScene
+    {
+        [Test]
+        public void TestNoScoreIncreaseFromMiss()
+        {
+            var beatmap = new Beatmap<HitObject> { HitObjects = { new HitObject() } };
+
+            var scoreProcessor = new ScoreProcessor();
+            scoreProcessor.ApplyBeatmap(beatmap);
+
+            // Apply a miss judgement
+            scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new TestJudgement()) { Type = HitResult.Miss });
+
+            Assert.That(scoreProcessor.TotalScore.Value, Is.EqualTo(0.0));
+        }
+
+        [Test]
+        public void TestOnlyBonusScore()
+        {
+            var beatmap = new Beatmap<HitObject> { HitObjects = { new HitObject() } };
+
+            var scoreProcessor = new ScoreProcessor();
+            scoreProcessor.ApplyBeatmap(beatmap);
+
+            // Apply a judgement
+            scoreProcessor.ApplyResult(new JudgementResult(new HitObject(), new TestJudgement(HitResult.LargeBonus)) { Type = HitResult.LargeBonus });
+
+            Assert.That(scoreProcessor.TotalScore.Value, Is.EqualTo(Judgement.LARGE_BONUS_SCORE));
+        }
+
+        private class TestJudgement : Judgement
+        {
+            public override HitResult MaxResult { get; }
+
+            public TestJudgement(HitResult maxResult = HitResult.Perfect)
+            {
+                MaxResult = maxResult;
+            }
+        }
+    }
+}

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -4,10 +4,12 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Graphics.Audio;
 using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
 using osu.Game.Audio;
@@ -59,7 +61,10 @@ namespace osu.Game.Tests.Gameplay
 
             AddStep("create container", () =>
             {
-                Add(gameplayContainer = new GameplayClockContainer(CreateWorkingBeatmap(new OsuRuleset().RulesetInfo), Array.Empty<Mod>(), 0));
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.LoadTrack();
+
+                Add(gameplayContainer = new GameplayClockContainer(working, 0));
 
                 gameplayContainer.Add(sample = new DrawableStoryboardSample(new StoryboardSampleInfo(string.Empty, 0, 1))
                 {
@@ -103,9 +108,14 @@ namespace osu.Game.Tests.Gameplay
                 Beatmap.Value = new TestCustomSkinWorkingBeatmap(new OsuRuleset().RulesetInfo, Audio);
                 SelectedMods.Value = new[] { testedMod };
 
-                Add(gameplayContainer = new GameplayClockContainer(Beatmap.Value, SelectedMods.Value, 0));
+                var beatmapSkinSourceContainer = new BeatmapSkinProvidingContainer(Beatmap.Value.Skin);
 
-                gameplayContainer.Add(sample = new TestDrawableStoryboardSample(new StoryboardSampleInfo("test-sample", 1, 1))
+                Add(gameplayContainer = new GameplayClockContainer(Beatmap.Value, 0)
+                {
+                    Child = beatmapSkinSourceContainer
+                });
+
+                beatmapSkinSourceContainer.Add(sample = new TestDrawableStoryboardSample(new StoryboardSampleInfo("test-sample", 1, 1))
                 {
                     Clock = gameplayContainer.GameplayClock
                 });
@@ -113,7 +123,7 @@ namespace osu.Game.Tests.Gameplay
 
             AddStep("start", () => gameplayContainer.Start());
 
-            AddAssert("sample playback rate matches mod rates", () => sample.Channel.AggregateFrequency.Value == expectedRate);
+            AddAssert("sample playback rate matches mod rates", () => sample.ChildrenOfType<DrawableSample>().First().AggregateFrequency.Value == expectedRate);
         }
 
         private class TestSkin : LegacySkin
@@ -165,8 +175,6 @@ namespace osu.Game.Tests.Gameplay
                 : base(sampleInfo)
             {
             }
-
-            public new SampleChannel Channel => base.Channel;
         }
     }
 }

osu.Game.Tests/ImportTest.cs

@@ -0,0 +1,66 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.Collections;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests
+{
+    public abstract class ImportTest
+    {
+        protected virtual TestOsuGameBase LoadOsuIntoHost(GameHost host, bool withBeatmap = false)
+        {
+            var osu = new TestOsuGameBase(withBeatmap);
+            Task.Run(() => host.Run(osu));
+
+            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
+
+            bool ready = false;
+            // wait for two update frames to be executed. this ensures that all components have had a change to run LoadComplete and hopefully avoid
+            // database access (GlobalActionContainer is one to do this).
+            host.UpdateThread.Scheduler.Add(() => host.UpdateThread.Scheduler.Add(() => ready = true));
+
+            waitForOrAssert(() => ready, @"osu! failed to start in a reasonable amount of time");
+
+            return osu;
+        }
+
+        private void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
+        {
+            Task task = Task.Run(() =>
+            {
+                while (!result()) Thread.Sleep(200);
+            });
+
+            Assert.IsTrue(task.Wait(timeout), failureMessage);
+        }
+
+        public class TestOsuGameBase : OsuGameBase
+        {
+            public CollectionManager CollectionManager { get; private set; }
+
+            private readonly bool withBeatmap;
+
+            public TestOsuGameBase(bool withBeatmap)
+            {
+                this.withBeatmap = withBeatmap;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                // Beatmap must be imported before the collection manager is loaded.
+                if (withBeatmap)
+                    BeatmapManager.Import(TestResources.GetTestBeatmapForImport()).Wait();
+
+                AddInternal(CollectionManager = new CollectionManager(Storage));
+            }
+        }
+    }
+}

osu.Game.Tests/NonVisual/ControlPointInfoTest.cs

@@ -139,6 +139,22 @@ namespace osu.Game.Tests.NonVisual
             Assert.That(cpi.Groups.Count, Is.EqualTo(0));
         }
 
+        [Test]
+        public void TestRemoveGroupAlsoRemovedControlPoints()
+        {
+            var cpi = new ControlPointInfo();
+
+            var group = cpi.GroupAt(1000, true);
+
+            group.Add(new SampleControlPoint());
+
+            Assert.That(cpi.SamplePoints.Count, Is.EqualTo(1));
+
+            cpi.RemoveGroup(group);
+
+            Assert.That(cpi.SamplePoints.Count, Is.EqualTo(0));
+        }
+
         [Test]
         public void TestAddControlPointToGroup()
         {

osu.Game.Tests/NonVisual/CustomDataDirectoryTest.cs

@@ -4,8 +4,7 @@
 using System;
 using System.IO;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
+using System.Runtime.CompilerServices;
 using NUnit.Framework;
 using osu.Framework;
 using osu.Framework.Allocation;
@@ -17,18 +16,18 @@ using osu.Game.IO;
 namespace osu.Game.Tests.NonVisual
 {
     [TestFixture]
-    public class CustomDataDirectoryTest
+    public class CustomDataDirectoryTest : ImportTest
     {
         [Test]
         public void TestDefaultDirectory()
         {
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestDefaultDirectory)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
                     string defaultStorageLocation = getDefaultLocationFor(nameof(TestDefaultDirectory));
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var storage = osu.Dependencies.Get<Storage>();
 
                     Assert.That(storage.GetFullPath("."), Is.EqualTo(defaultStorageLocation));
@@ -45,14 +44,14 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (var host = new CustomTestHeadlessGameHost(nameof(TestCustomDirectory)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 using (var storageConfig = new StorageConfigManager(host.InitialStorage))
                     storageConfig.Set(StorageConfig.FullPath, customPath);
 
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     // switch to DI'd storage
                     var storage = osu.Dependencies.Get<Storage>();
@@ -71,14 +70,14 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (var host = new CustomTestHeadlessGameHost(nameof(TestSubDirectoryLookup)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 using (var storageConfig = new StorageConfigManager(host.InitialStorage))
                     storageConfig.Set(StorageConfig.FullPath, customPath);
 
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     // switch to DI'd storage
                     var storage = osu.Dependencies.Get<Storage>();
@@ -104,14 +103,15 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigration)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
                     string defaultStorageLocation = getDefaultLocationFor(nameof(TestMigration));
 
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
                     var storage = osu.Dependencies.Get<Storage>();
+                    var osuStorage = storage as MigratableStorage;
 
                     // Store the current storage's path. We'll need to refer to this for assertions in the original directory after the migration completes.
                     string originalDirectory = storage.GetFullPath(".");
@@ -138,13 +138,15 @@ namespace osu.Game.Tests.NonVisual
                     Assert.That(!Directory.Exists(Path.Combine(originalDirectory, "test-nested", "cache")));
                     Assert.That(storage.ExistsDirectory(Path.Combine("test-nested", "cache")));
 
-                    foreach (var file in OsuStorage.IGNORE_FILES)
+                    Assert.That(osuStorage, Is.Not.Null);
+
+                    foreach (var file in osuStorage.IgnoreFiles)
                     {
                         Assert.That(File.Exists(Path.Combine(originalDirectory, file)));
                         Assert.That(storage.Exists(file), Is.False);
                     }
 
-                    foreach (var dir in OsuStorage.IGNORE_DIRECTORIES)
+                    foreach (var dir in osuStorage.IgnoreDirectories)
                     {
                         Assert.That(Directory.Exists(Path.Combine(originalDirectory, dir)));
                         Assert.That(storage.ExistsDirectory(dir), Is.False);
@@ -165,11 +167,11 @@ namespace osu.Game.Tests.NonVisual
             string customPath = prepareCustomPath();
             string customPath2 = prepareCustomPath("-2");
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationBetweenTwoTargets)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     const string database_filename = "client.db";
 
@@ -194,11 +196,11 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationToSameTargetFails)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
                     Assert.Throws<ArgumentException>(() => osu.Migrate(customPath));
@@ -215,11 +217,11 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationToNestedTargetFails)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
 
@@ -244,11 +246,11 @@ namespace osu.Game.Tests.NonVisual
         {
             string customPath = prepareCustomPath();
 
-            using (HeadlessGameHost host = new CustomTestHeadlessGameHost(nameof(TestMigrationToSeeminglyNestedTarget)))
+            using (var host = new CustomTestHeadlessGameHost())
             {
                 try
                 {
-                    var osu = loadOsu(host);
+                    var osu = LoadOsuIntoHost(host);
 
                     Assert.DoesNotThrow(() => osu.Migrate(customPath));
 
@@ -268,25 +270,6 @@ namespace osu.Game.Tests.NonVisual
             }
         }
 
-        private OsuGameBase loadOsu(GameHost host)
-        {
-            var osu = new OsuGameBase();
-            Task.Run(() => host.Run(osu));
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-
-            return osu;
-        }
-
-        private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
-        {
-            Task task = Task.Run(() =>
-            {
-                while (!result()) Thread.Sleep(200);
-            });
-
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
-        }
-
         private static string getDefaultLocationFor(string testTypeName)
         {
             string path = Path.Combine(RuntimeInfo.StartupDirectory, "headless", testTypeName);
@@ -307,14 +290,14 @@ namespace osu.Game.Tests.NonVisual
             return path;
         }
 
-        public class CustomTestHeadlessGameHost : HeadlessGameHost
+        public class CustomTestHeadlessGameHost : CleanRunHeadlessGameHost
         {
             public Storage InitialStorage { get; }
 
-            public CustomTestHeadlessGameHost(string name)
-                : base(name)
+            public CustomTestHeadlessGameHost([CallerMemberName] string callingMethodName = @"")
+                : base(callingMethodName: callingMethodName)
             {
-                string defaultStorageLocation = getDefaultLocationFor(name);
+                string defaultStorageLocation = getDefaultLocationFor(callingMethodName);
 
                 InitialStorage = new DesktopStorage(defaultStorageLocation, this);
                 InitialStorage.DeleteDirectory(string.Empty);

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -94,6 +94,52 @@ namespace osu.Game.Tests.NonVisual
             Assert.IsTrue(combinations[2] is ModIncompatibleWithAofA);
         }
 
+        [Test]
+        public void TestMultiModFlattening()
+        {
+            var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModB(), new ModC())).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(4, combinations.Length);
+            Assert.IsTrue(combinations[0] is ModNoMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+            Assert.IsTrue(combinations[3] is MultiMod);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[2] is ModC);
+            Assert.IsTrue(((MultiMod)combinations[3]).Mods[0] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[3]).Mods[1] is ModC);
+        }
+
+        [Test]
+        public void TestIncompatibleThroughMultiMod()
+        {
+            var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModB(), new ModIncompatibleWithA())).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(3, combinations.Length);
+            Assert.IsTrue(combinations[0] is ModNoMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModIncompatibleWithA);
+        }
+
+        [Test]
+        public void TestIncompatibleWithSameInstanceViaMultiMod()
+        {
+            var combinations = new TestLegacyDifficultyCalculator(new ModA(), new MultiMod(new ModA(), new ModB())).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(3, combinations.Length);
+            Assert.IsTrue(combinations[0] is ModNoMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+        }
+
         private class ModA : Mod
         {
             public override string Name => nameof(ModA);
@@ -112,6 +158,13 @@ namespace osu.Game.Tests.NonVisual
             public override Type[] IncompatibleMods => new[] { typeof(ModIncompatibleWithAAndB) };
         }
 
+        private class ModC : Mod
+        {
+            public override string Name => nameof(ModC);
+            public override string Acronym => nameof(ModC);
+            public override double ScoreMultiplier => 1;
+        }
+
         private class ModIncompatibleWithA : Mod
         {
             public override string Name => $"Incompatible With {nameof(ModA)}";

osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs

@@ -197,5 +197,22 @@ namespace osu.Game.Tests.NonVisual.Filtering
             carouselItem.Filter(criteria);
             Assert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
+
+        [TestCase("202010", true)]
+        [TestCase("20201010", false)]
+        [TestCase("153", true)]
+        [TestCase("1535", false)]
+        public void TestCriteriaMatchingBeatmapIDs(string query, bool filtered)
+        {
+            var beatmap = getExampleBeatmap();
+            beatmap.OnlineBeatmapID = 20201010;
+            beatmap.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = 1535 };
+
+            var criteria = new FilterCriteria { SearchText = query };
+            var carouselItem = new CarouselBeatmap(beatmap);
+            carouselItem.Filter(criteria);
+
+            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
     }
 }

osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
         }
 
         [Test]
-        public void TestApplyDrainRateQueries()
+        public void TestApplyDrainRateQueriesByDrKeyword()
         {
             const string query = "dr>2 quite specific dr<:6";
             var filterCriteria = new FilterCriteria();
@@ -73,6 +73,20 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.Less(filterCriteria.DrainRate.Min, 6.1f);
         }
 
+        [Test]
+        public void TestApplyDrainRateQueriesByHpKeyword()
+        {
+            const string query = "hp>2 quite specific hp<=6";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.AreEqual("quite specific", filterCriteria.SearchText.Trim());
+            Assert.AreEqual(2, filterCriteria.SearchTerms.Length);
+            Assert.Greater(filterCriteria.DrainRate.Min, 2.0f);
+            Assert.Less(filterCriteria.DrainRate.Min, 2.1f);
+            Assert.Greater(filterCriteria.DrainRate.Max, 6.0f);
+            Assert.Less(filterCriteria.DrainRate.Min, 6.1f);
+        }
+
         [Test]
         public void TestApplyBPMQueries()
         {

osu.Game.Tests/NonVisual/GameplayClockTest.cs

@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Timing;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class GameplayClockTest
+    {
+        [TestCase(0)]
+        [TestCase(1)]
+        public void TestTrueGameplayRateWithZeroAdjustment(double underlyingClockRate)
+        {
+            var framedClock = new FramedClock(new ManualClock { Rate = underlyingClockRate });
+            var gameplayClock = new TestGameplayClock(framedClock);
+
+            gameplayClock.MutableNonGameplayAdjustments.Add(new BindableDouble());
+
+            Assert.That(gameplayClock.TrueGameplayRate, Is.EqualTo(0));
+        }
+
+        private class TestGameplayClock : GameplayClock
+        {
+            public List<Bindable<double>> MutableNonGameplayAdjustments { get; } = new List<Bindable<double>>();
+
+            public override IEnumerable<Bindable<double>> NonGameplayAdjustments => MutableNonGameplayAdjustments;
+
+            public TestGameplayClock(IFrameBasedClock underlyingClock)
+                : base(underlyingClock)
+            {
+            }
+        }
+    }
+}

osu.Game.Tests/NonVisual/LimitedCapacityQueueTest.cs

@@ -0,0 +1,119 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Game.Rulesets.Difficulty.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class LimitedCapacityQueueTest
+    {
+        private const int capacity = 3;
+
+        private LimitedCapacityQueue<int> queue;
+
+        [SetUp]
+        public void SetUp()
+        {
+            queue = new LimitedCapacityQueue<int>(capacity);
+        }
+
+        [Test]
+        public void TestEmptyQueue()
+        {
+            Assert.AreEqual(0, queue.Count);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);
+
+            Assert.Throws<InvalidOperationException>(() => _ = queue.Dequeue());
+
+            int count = 0;
+            foreach (var _ in queue)
+                count++;
+
+            Assert.AreEqual(0, count);
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        [TestCase(3)]
+        public void TestBelowCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            Assert.AreEqual(count, queue.Count);
+
+            for (int i = 0; i < count; ++i)
+                Assert.AreEqual(i, queue[i]);
+
+            int j = 0;
+            foreach (var item in queue)
+                Assert.AreEqual(j++, item);
+
+            for (int i = queue.Count; i < queue.Count + capacity; i++)
+                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
+        }
+
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        public void TestEnqueueAtFullCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            Assert.AreEqual(capacity, queue.Count);
+
+            for (int i = 0; i < queue.Count; ++i)
+                Assert.AreEqual(count - capacity + i, queue[i]);
+
+            int j = count - capacity;
+            foreach (var item in queue)
+                Assert.AreEqual(j++, item);
+
+            for (int i = queue.Count; i < queue.Count + capacity; i++)
+                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
+        }
+
+        [TestCase(4)]
+        [TestCase(5)]
+        [TestCase(6)]
+        public void TestDequeueAtFullCapacity(int count)
+        {
+            for (int i = 0; i < count; ++i)
+                queue.Enqueue(i);
+
+            for (int i = 0; i < capacity; ++i)
+            {
+                Assert.AreEqual(count - capacity + i, queue.Dequeue());
+                Assert.AreEqual(2 - i, queue.Count);
+            }
+
+            Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
+        }
+
+        [Test]
+        public void TestClearQueue()
+        {
+            queue.Enqueue(3);
+            queue.Enqueue(5);
+            Assert.AreEqual(2, queue.Count);
+
+            queue.Clear();
+            Assert.AreEqual(0, queue.Count);
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);
+
+            queue.Enqueue(7);
+            Assert.AreEqual(1, queue.Count);
+            Assert.AreEqual(7, queue[0]);
+            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[1]);
+
+            queue.Enqueue(9);
+            Assert.AreEqual(2, queue.Count);
+            Assert.AreEqual(9, queue[1]);
+        }
+    }
+}

osu.Game.Tests/NonVisual/Ranking/UnstableRateTest.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 System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Ranking.Statistics;
+
+namespace osu.Game.Tests.NonVisual.Ranking
+{
+    [TestFixture]
+    public class UnstableRateTest
+    {
+        [Test]
+        public void TestDistributedHits()
+        {
+            var events = Enumerable.Range(-5, 11)
+                                   .Select(t => new HitEvent(t - 5, HitResult.Great, new HitObject(), null, null));
+
+            var unstableRate = new UnstableRate(events);
+
+            Assert.IsTrue(Precision.AlmostEquals(unstableRate.Value, 10 * Math.Sqrt(10)));
+        }
+
+        [Test]
+        public void TestMissesAndEmptyWindows()
+        {
+            var events = new[]
+            {
+                new HitEvent(-100, HitResult.Miss, new HitObject(), null, null),
+                new HitEvent(0, HitResult.Great, new HitObject(), null, null),
+                new HitEvent(200, HitResult.Meh, new HitObject { HitWindows = HitWindows.Empty }, null, null),
+            };
+
+            var unstableRate = new UnstableRate(events);
+
+            Assert.AreEqual(0, unstableRate.Value);
+        }
+    }
+}

osu.Game.Tests/Resources/multi-segment-slider.osu

@@ -0,0 +1,11 @@
+osu file format v128
+
+[HitObjects]
+// Multi-segment
+63,301,1000,6,0,P|224:57|B|439:298|131:316|322:169|155:194,1,1040,0|0,0:0|0:0,0:0:0:0:
+
+// Single-segment
+63,301,2000,6,0,P|224:57|439:298,1,1040,0|0,0:0|0:0,0:0:0:0:
+
+// Implicit multi-segment
+32,192,3000,6,0,B|32:384|256:384|256:192|256:192|256:0|512:0|512:192,1,800

osu.Game.Tests/Resources/old-skin/skin.ini

@@ -0,0 +1,2 @@
+[General]
+Version: 1.0

osu.Game.Tests/Resources/skin-zero-alpha-colour.ini

@@ -1,5 +0,0 @@
-[General]
-Version: latest
-
-[Colours]
-Combo1: 255,255,255,0

osu.Game.Tests/Rulesets/Scoring/ScoreProcessorTest.cs

@@ -35,10 +35,10 @@ namespace osu.Game.Tests.Rulesets.Scoring
         }
 
         [TestCase(ScoringMode.Standardised, HitResult.Meh, 750_000)]
-        [TestCase(ScoringMode.Standardised, HitResult.Good, 800_000)]
+        [TestCase(ScoringMode.Standardised, HitResult.Ok, 800_000)]
         [TestCase(ScoringMode.Standardised, HitResult.Great, 1_000_000)]
         [TestCase(ScoringMode.Classic, HitResult.Meh, 50)]
-        [TestCase(ScoringMode.Classic, HitResult.Good, 100)]
+        [TestCase(ScoringMode.Classic, HitResult.Ok, 100)]
         [TestCase(ScoringMode.Classic, HitResult.Great, 300)]
         public void TestSingleOsuHit(ScoringMode scoringMode, HitResult hitResult, int expectedScore)
         {
@@ -53,5 +53,263 @@ namespace osu.Game.Tests.Rulesets.Scoring
 
             Assert.IsTrue(Precision.AlmostEquals(expectedScore, scoreProcessor.TotalScore.Value));
         }
+
+        /// <summary>
+        /// Test to see that all <see cref="HitResult"/>s contribute to score portions in correct amounts.
+        /// </summary>
+        /// <param name="scoringMode">Scoring mode to test.</param>
+        /// <param name="hitResult">The <see cref="HitResult"/> that will be applied to selected hit objects.</param>
+        /// <param name="maxResult">The maximum <see cref="HitResult"/> achievable.</param>
+        /// <param name="expectedScore">Expected score after all objects have been judged, rounded to the nearest integer.</param>
+        /// <remarks>
+        /// This test intentionally misses the 3rd hitobject to achieve lower than 75% accuracy and 50% max combo.
+        /// <para>
+        /// For standardised scoring, <paramref name="expectedScore"/> is calculated using the following formula:
+        /// 1_000_000 * (((3 * <paramref name="hitResult"/>) / (4 * <paramref name="maxResult"/>)) * 30% + (bestCombo / maxCombo) * 70%)
+        /// </para>
+        /// <para>
+        /// For classic scoring, <paramref name="expectedScore"/> is calculated using the following formula:
+        /// <paramref name="hitResult"/> / <paramref name="maxResult"/> * 936
+        /// where 936 is simplified from:
+        /// 75% * 4 * 300 * (1 + 1/25)
+        /// </para>
+        /// </remarks>
+        [TestCase(ScoringMode.Standardised, HitResult.Miss, HitResult.Great, 0)] // (3 * 0) / (4 * 300) * 300_000 + (0 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Meh, HitResult.Great, 387_500)] // (3 * 50) / (4 * 300) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Ok, HitResult.Great, 425_000)] // (3 * 100) / (4 * 300) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Good, HitResult.Perfect, 478_571)] // (3 * 200) / (4 * 350) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Great, HitResult.Great, 575_000)] // (3 * 300) / (4 * 300) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.Perfect, HitResult.Perfect, 575_000)] // (3 * 350) / (4 * 350) * 300_000 + (2 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickMiss, HitResult.SmallTickHit, 700_000)] // (3 * 0) / (4 * 10) * 300_000 + 700_000 (max combo 0)
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickHit, HitResult.SmallTickHit, 925_000)] // (3 * 10) / (4 * 10) * 300_000 + 700_000 (max combo 0)
+        [TestCase(ScoringMode.Standardised, HitResult.LargeTickMiss, HitResult.LargeTickHit, 0)] // (3 * 0) / (4 * 30) * 300_000 + (0 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.LargeTickHit, HitResult.LargeTickHit, 575_000)] // (3 * 30) / (4 * 30) * 300_000 + (0 / 4) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.SmallBonus, HitResult.SmallBonus, 700_030)] // 0 * 300_000 + 700_000 (max combo 0) + 3 * 10 (bonus points)
+        [TestCase(ScoringMode.Standardised, HitResult.LargeBonus, HitResult.LargeBonus, 700_150)] // 0 * 300_000 + 700_000 (max combo 0) + 3 * 50 (bonus points)
+        [TestCase(ScoringMode.Classic, HitResult.Miss, HitResult.Great, 0)] // (0 * 4 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Meh, HitResult.Great, 156)] // (((3 * 50) / (4 * 300)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Ok, HitResult.Great, 312)] // (((3 * 100) / (4 * 300)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Good, HitResult.Perfect, 535)] // (((3 * 200) / (4 * 350)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Great, HitResult.Great, 936)] // (((3 * 300) / (4 * 300)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.Perfect, HitResult.Perfect, 936)] // (((3 * 350) / (4 * 350)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickMiss, HitResult.SmallTickHit, 0)] // (0 * 1 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickHit, HitResult.SmallTickHit, 225)] // (((3 * 10) / (4 * 10)) * 1 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.LargeTickMiss, HitResult.LargeTickHit, 0)] // (0 * 4 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.LargeTickHit, HitResult.LargeTickHit, 936)] // (((3 * 50) / (4 * 50)) * 4 * 300) * (1 + 1 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallBonus, HitResult.SmallBonus, 30)] // (0 * 1 * 300) * (1 + 0 / 25) + 3 * 10 (bonus points)
+        [TestCase(ScoringMode.Classic, HitResult.LargeBonus, HitResult.LargeBonus, 150)] // (0 * 1 * 300) * (1 + 0 / 25) * 3 * 50 (bonus points)
+        public void TestFourVariousResultsOneMiss(ScoringMode scoringMode, HitResult hitResult, HitResult maxResult, int expectedScore)
+        {
+            var minResult = new TestJudgement(hitResult).MinResult;
+
+            IBeatmap fourObjectBeatmap = new TestBeatmap(new RulesetInfo())
+            {
+                HitObjects = new List<HitObject>(Enumerable.Repeat(new TestHitObject(maxResult), 4))
+            };
+            scoreProcessor.Mode.Value = scoringMode;
+            scoreProcessor.ApplyBeatmap(fourObjectBeatmap);
+
+            for (int i = 0; i < 4; i++)
+            {
+                var judgementResult = new JudgementResult(fourObjectBeatmap.HitObjects[i], new Judgement())
+                {
+                    Type = i == 2 ? minResult : hitResult
+                };
+                scoreProcessor.ApplyResult(judgementResult);
+            }
+
+            Assert.IsTrue(Precision.AlmostEquals(expectedScore, scoreProcessor.TotalScore.Value, 0.5));
+        }
+
+        /// <remarks>
+        /// This test uses a beatmap with four small ticks and one object with the <see cref="Judgement.MaxResult"/> of <see cref="HitResult.Ok"/>.
+        /// Its goal is to ensure that with the <see cref="ScoringMode"/> of <see cref="ScoringMode.Standardised"/>,
+        /// small ticks contribute to the accuracy portion, but not the combo portion.
+        /// In contrast, <see cref="ScoringMode.Classic"/> does not have separate combo and accuracy portion (they are multiplied by each other).
+        /// </remarks>
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickHit, 978_571)] // (3 * 10 + 100) / (4 * 10 + 100) * 300_000 + (1 / 1) * 700_000
+        [TestCase(ScoringMode.Standardised, HitResult.SmallTickMiss, 914_286)] // (3 * 0 + 100) / (4 * 10 + 100) * 300_000 + (1 / 1) * 700_000
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickHit, 279)] // (((3 * 10 + 100) / (4 * 10 + 100)) * 1 * 300) * (1 + 0 / 25)
+        [TestCase(ScoringMode.Classic, HitResult.SmallTickMiss, 214)] // (((3 * 0 + 100) / (4 * 10 + 100)) * 1 * 300) * (1 + 0 / 25)
+        public void TestSmallTicksAccuracy(ScoringMode scoringMode, HitResult hitResult, int expectedScore)
+        {
+            IEnumerable<HitObject> hitObjects = Enumerable
+                                                .Repeat(new TestHitObject(HitResult.SmallTickHit), 4)
+                                                .Append(new TestHitObject(HitResult.Ok));
+            IBeatmap fiveObjectBeatmap = new TestBeatmap(new RulesetInfo())
+            {
+                HitObjects = hitObjects.ToList()
+            };
+            scoreProcessor.Mode.Value = scoringMode;
+            scoreProcessor.ApplyBeatmap(fiveObjectBeatmap);
+
+            for (int i = 0; i < 4; i++)
+            {
+                var judgementResult = new JudgementResult(fiveObjectBeatmap.HitObjects[i], new Judgement())
+                {
+                    Type = i == 2 ? HitResult.SmallTickMiss : hitResult
+                };
+                scoreProcessor.ApplyResult(judgementResult);
+            }
+
+            var lastJudgementResult = new JudgementResult(fiveObjectBeatmap.HitObjects.Last(), new Judgement())
+            {
+                Type = HitResult.Ok
+            };
+            scoreProcessor.ApplyResult(lastJudgementResult);
+
+            Assert.IsTrue(Precision.AlmostEquals(expectedScore, scoreProcessor.TotalScore.Value, 0.5));
+        }
+
+        [Test]
+        public void TestEmptyBeatmap(
+            [Values(ScoringMode.Standardised, ScoringMode.Classic)]
+            ScoringMode scoringMode)
+        {
+            scoreProcessor.Mode.Value = scoringMode;
+            scoreProcessor.ApplyBeatmap(new TestBeatmap(new RulesetInfo()));
+
+            Assert.IsTrue(Precision.AlmostEquals(0, scoreProcessor.TotalScore.Value));
+        }
+
+        [TestCase(HitResult.IgnoreHit, HitResult.IgnoreMiss)]
+        [TestCase(HitResult.Meh, HitResult.Miss)]
+        [TestCase(HitResult.Ok, HitResult.Miss)]
+        [TestCase(HitResult.Good, HitResult.Miss)]
+        [TestCase(HitResult.Great, HitResult.Miss)]
+        [TestCase(HitResult.Perfect, HitResult.Miss)]
+        [TestCase(HitResult.SmallTickHit, HitResult.SmallTickMiss)]
+        [TestCase(HitResult.LargeTickHit, HitResult.LargeTickMiss)]
+        [TestCase(HitResult.SmallBonus, HitResult.IgnoreMiss)]
+        [TestCase(HitResult.LargeBonus, HitResult.IgnoreMiss)]
+        public void TestMinResults(HitResult hitResult, HitResult expectedMinResult)
+        {
+            Assert.AreEqual(expectedMinResult, new TestJudgement(hitResult).MinResult);
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, true)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, false)]
+        [TestCase(HitResult.SmallTickHit, false)]
+        [TestCase(HitResult.LargeTickMiss, true)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, false)]
+        [TestCase(HitResult.LargeBonus, false)]
+        public void TestAffectsCombo(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.AffectsCombo());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, true)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, true)]
+        [TestCase(HitResult.SmallTickHit, true)]
+        [TestCase(HitResult.LargeTickMiss, true)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, false)]
+        [TestCase(HitResult.LargeBonus, false)]
+        public void TestAffectsAccuracy(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.AffectsAccuracy());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, false)]
+        [TestCase(HitResult.Meh, false)]
+        [TestCase(HitResult.Ok, false)]
+        [TestCase(HitResult.Good, false)]
+        [TestCase(HitResult.Great, false)]
+        [TestCase(HitResult.Perfect, false)]
+        [TestCase(HitResult.SmallTickMiss, false)]
+        [TestCase(HitResult.SmallTickHit, false)]
+        [TestCase(HitResult.LargeTickMiss, false)]
+        [TestCase(HitResult.LargeTickHit, false)]
+        [TestCase(HitResult.SmallBonus, true)]
+        [TestCase(HitResult.LargeBonus, true)]
+        public void TestIsBonus(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.IsBonus());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, true)]
+        [TestCase(HitResult.Miss, false)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, false)]
+        [TestCase(HitResult.SmallTickHit, true)]
+        [TestCase(HitResult.LargeTickMiss, false)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, true)]
+        [TestCase(HitResult.LargeBonus, true)]
+        public void TestIsHit(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.IsHit());
+        }
+
+        [TestCase(HitResult.None, false)]
+        [TestCase(HitResult.IgnoreMiss, false)]
+        [TestCase(HitResult.IgnoreHit, false)]
+        [TestCase(HitResult.Miss, true)]
+        [TestCase(HitResult.Meh, true)]
+        [TestCase(HitResult.Ok, true)]
+        [TestCase(HitResult.Good, true)]
+        [TestCase(HitResult.Great, true)]
+        [TestCase(HitResult.Perfect, true)]
+        [TestCase(HitResult.SmallTickMiss, true)]
+        [TestCase(HitResult.SmallTickHit, true)]
+        [TestCase(HitResult.LargeTickMiss, true)]
+        [TestCase(HitResult.LargeTickHit, true)]
+        [TestCase(HitResult.SmallBonus, true)]
+        [TestCase(HitResult.LargeBonus, true)]
+        public void TestIsScorable(HitResult hitResult, bool expectedReturnValue)
+        {
+            Assert.AreEqual(expectedReturnValue, hitResult.IsScorable());
+        }
+
+        private class TestJudgement : Judgement
+        {
+            public override HitResult MaxResult { get; }
+
+            public TestJudgement(HitResult maxResult)
+            {
+                MaxResult = maxResult;
+            }
+        }
+
+        private class TestHitObject : HitObject
+        {
+            private readonly HitResult maxResult;
+
+            public override Judgement CreateJudgement()
+            {
+                return new TestJudgement(maxResult);
+            }
+
+            public TestHitObject(HitResult maxResult)
+            {
+                this.maxResult = maxResult;
+            }
+        }
     }
 }

osu.Game.Tests/Rulesets/TestSceneDrawableRulesetDependencies.cs

@@ -0,0 +1,136 @@
+// 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.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Rulesets
+{
+    [HeadlessTest]
+    public class TestSceneDrawableRulesetDependencies : OsuTestScene
+    {
+        [Test]
+        public void TestDisposalDoesNotDisposeParentStores()
+        {
+            DrawableWithDependencies drawable = null;
+            TestTextureStore textureStore = null;
+            TestSampleStore sampleStore = null;
+
+            AddStep("add dependencies", () =>
+            {
+                Child = drawable = new DrawableWithDependencies();
+                textureStore = drawable.ParentTextureStore;
+                sampleStore = drawable.ParentSampleStore;
+            });
+
+            AddStep("clear children", Clear);
+            AddUntilStep("wait for disposal", () => drawable.IsDisposed);
+
+            AddStep("GC", () =>
+            {
+                drawable = null;
+
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+            });
+
+            AddAssert("parent texture store not disposed", () => !textureStore.IsDisposed);
+            AddAssert("parent sample store not disposed", () => !sampleStore.IsDisposed);
+        }
+
+        private class DrawableWithDependencies : CompositeDrawable
+        {
+            public TestTextureStore ParentTextureStore { get; private set; }
+            public TestSampleStore ParentSampleStore { get; private set; }
+
+            public DrawableWithDependencies()
+            {
+                InternalChild = new Box { RelativeSizeAxes = Axes.Both };
+            }
+
+            protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
+            {
+                var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
+
+                dependencies.CacheAs<TextureStore>(ParentTextureStore = new TestTextureStore());
+                dependencies.CacheAs<ISampleStore>(ParentSampleStore = new TestSampleStore());
+
+                return new DrawableRulesetDependencies(new OsuRuleset(), dependencies);
+            }
+
+            public new bool IsDisposed { get; private set; }
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+                IsDisposed = true;
+            }
+        }
+
+        private class TestTextureStore : TextureStore
+        {
+            public override Texture Get(string name, WrapMode wrapModeS, WrapMode wrapModeT) => null;
+
+            public bool IsDisposed { get; private set; }
+
+            protected override void Dispose(bool disposing)
+            {
+                base.Dispose(disposing);
+                IsDisposed = true;
+            }
+        }
+
+        private class TestSampleStore : ISampleStore
+        {
+            public bool IsDisposed { get; private set; }
+
+            public void Dispose()
+            {
+                IsDisposed = true;
+            }
+
+            public SampleChannel Get(string name) => null;
+
+            public Task<SampleChannel> GetAsync(string name) => null;
+
+            public Stream GetStream(string name) => null;
+
+            public IEnumerable<string> GetAvailableResources() => throw new NotImplementedException();
+
+            public BindableNumber<double> Volume => throw new NotImplementedException();
+            public BindableNumber<double> Balance => throw new NotImplementedException();
+            public BindableNumber<double> Frequency => throw new NotImplementedException();
+            public BindableNumber<double> Tempo => throw new NotImplementedException();
+
+            public void AddAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotImplementedException();
+
+            public void RemoveAdjustment(AdjustableProperty type, BindableNumber<double> adjustBindable) => throw new NotImplementedException();
+
+            public void RemoveAllAdjustments(AdjustableProperty type) => throw new NotImplementedException();
+
+            public IBindable<double> AggregateVolume => throw new NotImplementedException();
+            public IBindable<double> AggregateBalance => throw new NotImplementedException();
+            public IBindable<double> AggregateFrequency => throw new NotImplementedException();
+            public IBindable<double> AggregateTempo => throw new NotImplementedException();
+
+            public int PlaybackConcurrency { get; set; }
+        }
+    }
+}

osu.Game.Tests/Scores/IO/ImportScoreTest.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -17,21 +16,20 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
-using osu.Game.Tests.Resources;
 using osu.Game.Users;
 
 namespace osu.Game.Tests.Scores.IO
 {
-    public class ImportScoreTest
+    public class ImportScoreTest : ImportTest
     {
         [Test]
         public async Task TestBasicImport()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("TestBasicImport"))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
@@ -45,7 +43,7 @@ namespace osu.Game.Tests.Scores.IO
                         OnlineScoreID = 12345,
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     Assert.AreEqual(toImport.Rank, imported.Rank);
                     Assert.AreEqual(toImport.TotalScore, imported.TotalScore);
@@ -66,18 +64,18 @@ namespace osu.Game.Tests.Scores.IO
         [Test]
         public async Task TestImportMods()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("TestImportMods"))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
                         Mods = new Mod[] { new OsuModHardRock(), new OsuModDoubleTime() },
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     Assert.IsTrue(imported.Mods.Any(m => m is OsuModHardRock));
                     Assert.IsTrue(imported.Mods.Any(m => m is OsuModDoubleTime));
@@ -92,11 +90,11 @@ namespace osu.Game.Tests.Scores.IO
         [Test]
         public async Task TestImportStatistics()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("TestImportStatistics"))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
@@ -107,7 +105,7 @@ namespace osu.Game.Tests.Scores.IO
                         }
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     Assert.AreEqual(toImport.Statistics[HitResult.Perfect], imported.Statistics[HitResult.Perfect]);
                     Assert.AreEqual(toImport.Statistics[HitResult.Miss], imported.Statistics[HitResult.Miss]);
@@ -122,11 +120,11 @@ namespace osu.Game.Tests.Scores.IO
         [Test]
         public async Task TestImportWithDeletedBeatmapSet()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("TestImportWithDeletedBeatmapSet"))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
                     var toImport = new ScoreInfo
                     {
@@ -138,7 +136,7 @@ namespace osu.Game.Tests.Scores.IO
                         }
                     };
 
-                    var imported = await loadIntoOsu(osu, toImport);
+                    var imported = await loadScoreIntoOsu(osu, toImport);
 
                     var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
                     var scoreManager = osu.Dependencies.Get<ScoreManager>();
@@ -146,7 +144,7 @@ namespace osu.Game.Tests.Scores.IO
                     beatmapManager.Delete(beatmapManager.QueryBeatmapSet(s => s.Beatmaps.Any(b => b.ID == imported.Beatmap.ID)));
                     Assert.That(scoreManager.Query(s => s.ID == imported.ID).DeletePending, Is.EqualTo(true));
 
-                    var secondImport = await loadIntoOsu(osu, imported);
+                    var secondImport = await loadScoreIntoOsu(osu, imported);
                     Assert.That(secondImport, Is.Null);
                 }
                 finally
@@ -159,13 +157,13 @@ namespace osu.Game.Tests.Scores.IO
         [Test]
         public async Task TestOnlineScoreIsAvailableLocally()
         {
-            using (HeadlessGameHost host = new CleanRunHeadlessGameHost("TestOnlineScoreIsAvailableLocally"))
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost())
             {
                 try
                 {
-                    var osu = await loadOsu(host);
+                    var osu = LoadOsuIntoHost(host, true);
 
-                    await loadIntoOsu(osu, new ScoreInfo { OnlineScoreID = 2 }, new TestArchiveReader());
+                    await loadScoreIntoOsu(osu, new ScoreInfo { OnlineScoreID = 2 }, new TestArchiveReader());
 
                     var scoreManager = osu.Dependencies.Get<ScoreManager>();
 
@@ -179,7 +177,7 @@ namespace osu.Game.Tests.Scores.IO
             }
         }
 
-        private async Task<ScoreInfo> loadIntoOsu(OsuGameBase osu, ScoreInfo score, ArchiveReader archive = null)
+        private async Task<ScoreInfo> loadScoreIntoOsu(OsuGameBase osu, ScoreInfo score, ArchiveReader archive = null)
         {
             var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
 
@@ -192,33 +190,6 @@ namespace osu.Game.Tests.Scores.IO
             return scoreManager.GetAllUsableScores().FirstOrDefault();
         }
 
-        private async Task<OsuGameBase> loadOsu(GameHost host)
-        {
-            var osu = new OsuGameBase();
-
-#pragma warning disable 4014
-            Task.Run(() => host.Run(osu));
-#pragma warning restore 4014
-
-            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
-
-            var beatmapFile = TestResources.GetTestBeatmapForImport();
-            var beatmapManager = osu.Dependencies.Get<BeatmapManager>();
-            await beatmapManager.Import(beatmapFile);
-
-            return osu;
-        }
-
-        private void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
-        {
-            Task task = Task.Run(() =>
-            {
-                while (!result()) Thread.Sleep(200);
-            });
-
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
-        }
-
         private class TestArchiveReader : ArchiveReader
         {
             public TestArchiveReader()

osu.Game.Tests/Skins/IO/ImportSkinTest.cs

@@ -0,0 +1,147 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.IO.Archives;
+using osu.Game.Skinning;
+using SharpCompress.Archives.Zip;
+
+namespace osu.Game.Tests.Skins.IO
+{
+    public class ImportSkinTest : ImportTest
+    {
+        [Test]
+        public async Task TestBasicImport()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin.osk"));
+
+                    Assert.That(imported.Name, Is.EqualTo("test skin"));
+                    Assert.That(imported.Creator, Is.EqualTo("skinner"));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportTwiceWithSameMetadata()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin.osk"));
+                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin", "skinner"), "skin2.osk"));
+
+                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Count, Is.EqualTo(1));
+
+                    // the first should be overwritten by the second import.
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().First().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportTwiceWithNoMetadata()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    // if a user downloads two skins that do have skin.ini files but don't have any creator metadata in the skin.ini, they should both import separately just for safety.
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk(string.Empty, string.Empty), "download.osk"));
+                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk(string.Empty, string.Empty), "download.osk"));
+
+                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Count, Is.EqualTo(2));
+
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().First().Files.First().FileInfoID, Is.EqualTo(imported.Files.First().FileInfoID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Last().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        [Test]
+        public async Task TestImportTwiceWithDifferentMetadata()
+        {
+            using (HeadlessGameHost host = new CleanRunHeadlessGameHost(nameof(ImportSkinTest)))
+            {
+                try
+                {
+                    var osu = LoadOsuIntoHost(host);
+
+                    var imported = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin v2", "skinner"), "skin.osk"));
+                    var imported2 = await loadSkinIntoOsu(osu, new ZipArchiveReader(createOsk("test skin v2.1", "skinner"), "skin2.osk"));
+
+                    Assert.That(imported2.ID, Is.Not.EqualTo(imported.ID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Count, Is.EqualTo(2));
+
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().First().Files.First().FileInfoID, Is.EqualTo(imported.Files.First().FileInfoID));
+                    Assert.That(osu.Dependencies.Get<SkinManager>().GetAllUserSkins().Last().Files.First().FileInfoID, Is.EqualTo(imported2.Files.First().FileInfoID));
+                }
+                finally
+                {
+                    host.Exit();
+                }
+            }
+        }
+
+        private MemoryStream createOsk(string name, string author)
+        {
+            var zipStream = new MemoryStream();
+            using var zip = ZipArchive.Create();
+            zip.AddEntry("skin.ini", generateSkinIni(name, author));
+            zip.SaveTo(zipStream);
+            return zipStream;
+        }
+
+        private MemoryStream generateSkinIni(string name, string author)
+        {
+            var stream = new MemoryStream();
+            var writer = new StreamWriter(stream);
+
+            writer.WriteLine("[General]");
+            writer.WriteLine($"Name: {name}");
+            writer.WriteLine($"Author: {author}");
+            writer.WriteLine();
+            writer.WriteLine($"# unique {Guid.NewGuid()}");
+
+            writer.Flush();
+
+            return stream;
+        }
+
+        private async Task<SkinInfo> loadSkinIntoOsu(OsuGameBase osu, ArchiveReader archive = null)
+        {
+            var skinManager = osu.Dependencies.Get<SkinManager>();
+            return await skinManager.Import(archive);
+        }
+    }
+}

osu.Game.Tests/Skins/LegacySkinDecoderTest.cs

@@ -108,15 +108,5 @@ namespace osu.Game.Tests.Skins
             using (var stream = new LineBufferedReader(resStream))
                 Assert.That(decoder.Decode(stream).LegacyVersion, Is.EqualTo(1.0m));
         }
-
-        [Test]
-        public void TestDecodeColourWithZeroAlpha()
-        {
-            var decoder = new LegacySkinDecoder();
-
-            using (var resStream = TestResources.OpenResource("skin-zero-alpha-colour.ini"))
-            using (var stream = new LineBufferedReader(resStream))
-                Assert.That(decoder.Decode(stream).ComboColours[0].A, Is.EqualTo(1.0f));
-        }
     }
 }

osu.Game.Tests/Skins/TestSceneBeatmapSkinResources.cs

@@ -26,6 +26,7 @@ namespace osu.Game.Tests.Skins
         {
             var imported = beatmaps.Import(new ZipArchiveReader(TestResources.OpenResource("Archives/ogg-beatmap.osz"))).Result;
             beatmap = beatmaps.GetWorkingBeatmap(imported.Beatmaps[0]);
+            beatmap.LoadTrack();
         }
 
         [Test]

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

@@ -193,6 +193,7 @@ namespace osu.Game.Tests.Visual.Background
 
             AddStep("Transition to Results", () => player.Push(results = new FadeAccessibleResults(new ScoreInfo
             {
+                Ruleset = new OsuRuleset().RulesetInfo,
                 User = new User { Username = "osu!" },
                 Beatmap = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo
             })));

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

@@ -0,0 +1,235 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Collections;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Dialog;
+using osu.Game.Rulesets;
+using osu.Game.Tests.Resources;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Collections
+{
+    public class TestSceneManageCollectionsDialog : OsuManualInputManagerTestScene
+    {
+        protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
+
+        private DialogOverlay dialogOverlay;
+        private CollectionManager manager;
+
+        private RulesetStore rulesets;
+        private BeatmapManager beatmapManager;
+
+        private ManageCollectionsDialog dialog;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host)
+        {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(beatmapManager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, Audio, host, Beatmap.Default));
+
+            beatmapManager.Import(TestResources.GetTestBeatmapForImport()).Wait();
+
+            base.Content.AddRange(new Drawable[]
+            {
+                manager = new CollectionManager(LocalStorage),
+                Content,
+                dialogOverlay = new DialogOverlay()
+            });
+
+            Dependencies.Cache(manager);
+            Dependencies.Cache(dialogOverlay);
+        }
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            manager.Collections.Clear();
+            Child = dialog = new ManageCollectionsDialog();
+        });
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("show dialog", () => dialog.Show());
+        }
+
+        [Test]
+        public void TestHideDialog()
+        {
+            AddWaitStep("wait for animation", 3);
+            AddStep("hide dialog", () => dialog.Hide());
+        }
+
+        [Test]
+        public void TestLastItemIsPlaceholder()
+        {
+            AddAssert("last item is placeholder", () => !manager.Collections.Contains(dialog.ChildrenOfType<DrawableCollectionListItem>().Last().Model));
+        }
+
+        [Test]
+        public void TestAddCollectionExternal()
+        {
+            AddStep("add collection", () => manager.Collections.Add(new BeatmapCollection { Name = { Value = "First collection" } }));
+            assertCollectionCount(1);
+            assertCollectionName(0, "First collection");
+
+            AddStep("add another collection", () => manager.Collections.Add(new BeatmapCollection { Name = { Value = "Second collection" } }));
+            assertCollectionCount(2);
+            assertCollectionName(1, "Second collection");
+        }
+
+        [Test]
+        public void TestFocusPlaceholderDoesNotCreateCollection()
+        {
+            AddStep("focus placeholder", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            assertCollectionCount(0);
+        }
+
+        [Test]
+        public void TestAddCollectionViaPlaceholder()
+        {
+            DrawableCollectionListItem placeholderItem = null;
+
+            AddStep("focus placeholder", () =>
+            {
+                InputManager.MoveMouseTo(placeholderItem = dialog.ChildrenOfType<DrawableCollectionListItem>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            // Done directly via the collection since InputManager methods cannot add text to textbox...
+            AddStep("change collection name", () => placeholderItem.Model.Name.Value = "a");
+            assertCollectionCount(1);
+            AddAssert("collection now exists", () => manager.Collections.Contains(placeholderItem.Model));
+
+            AddAssert("last item is placeholder", () => !manager.Collections.Contains(dialog.ChildrenOfType<DrawableCollectionListItem>().Last().Model));
+        }
+
+        [Test]
+        public void TestRemoveCollectionExternal()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" } },
+            }));
+
+            AddStep("remove first collection", () => manager.Collections.RemoveAt(0));
+            assertCollectionCount(1);
+            assertCollectionName(0, "2");
+        }
+
+        [Test]
+        public void TestRemoveCollectionViaButton()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+            }));
+
+            assertCollectionCount(2);
+
+            AddStep("click first delete button", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem.DeleteButton>().First(), new Vector2(5, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog not displayed", () => dialogOverlay.CurrentDialog == null);
+            assertCollectionCount(1);
+            assertCollectionName(0, "2");
+
+            AddStep("click first delete button", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem.DeleteButton>().First(), new Vector2(5, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog displayed", () => dialogOverlay.CurrentDialog is DeleteCollectionDialog);
+            AddStep("click confirmation", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog.ChildrenOfType<PopupDialogButton>().First());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            assertCollectionCount(0);
+        }
+
+        [Test]
+        public void TestCollectionNotRemovedWhenDialogCancelled()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" }, Beatmaps = { beatmapManager.GetAllUsableBeatmapSets().First().Beatmaps[0] } },
+            }));
+
+            assertCollectionCount(1);
+
+            AddStep("click first delete button", () =>
+            {
+                InputManager.MoveMouseTo(dialog.ChildrenOfType<DrawableCollectionListItem.DeleteButton>().First(), new Vector2(5, 0));
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("dialog displayed", () => dialogOverlay.CurrentDialog is DeleteCollectionDialog);
+            AddStep("click cancellation", () =>
+            {
+                InputManager.MoveMouseTo(dialogOverlay.CurrentDialog.ChildrenOfType<PopupDialogButton>().Last());
+                InputManager.Click(MouseButton.Left);
+            });
+
+            assertCollectionCount(1);
+        }
+
+        [Test]
+        public void TestCollectionRenamedExternal()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" } },
+            }));
+
+            AddStep("change first collection name", () => manager.Collections[0].Name.Value = "First");
+
+            assertCollectionName(0, "First");
+        }
+
+        [Test]
+        public void TestCollectionRenamedOnTextChange()
+        {
+            AddStep("add two collections", () => manager.Collections.AddRange(new[]
+            {
+                new BeatmapCollection { Name = { Value = "1" } },
+                new BeatmapCollection { Name = { Value = "2" } },
+            }));
+
+            assertCollectionCount(2);
+
+            AddStep("change first collection name", () => dialog.ChildrenOfType<TextBox>().First().Text = "First");
+            AddAssert("collection has new name", () => manager.Collections[0].Name.Value == "First");
+        }
+
+        private void assertCollectionCount(int count)
+            => AddUntilStep($"{count} collections shown", () => dialog.ChildrenOfType<DrawableCollectionListItem>().Count(i => i.IsCreated.Value) == count);
+
+        private void assertCollectionName(int index, string name)
+            => AddUntilStep($"item {index + 1} has correct name", () => dialog.ChildrenOfType<DrawableCollectionListItem>().ElementAt(index).ChildrenOfType<TextBox>().First().Text == name);
+    }
+}

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

@@ -0,0 +1,69 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneComposeSelectBox : OsuTestScene
+    {
+        private Container selectionArea;
+
+        public TestSceneComposeSelectBox()
+        {
+            SelectionBox selectionBox = null;
+
+            AddStep("create box", () =>
+                Child = selectionArea = new Container
+                {
+                    Size = new Vector2(400),
+                    Position = -new Vector2(150),
+                    Anchor = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        selectionBox = new SelectionBox
+                        {
+                            CanRotate = true,
+                            CanScaleX = true,
+                            CanScaleY = true,
+
+                            OnRotation = handleRotation,
+                            OnScale = handleScale
+                        }
+                    }
+                });
+
+            AddToggleStep("toggle rotation", state => selectionBox.CanRotate = state);
+            AddToggleStep("toggle x", state => selectionBox.CanScaleX = state);
+            AddToggleStep("toggle y", state => selectionBox.CanScaleY = state);
+        }
+
+        private void handleScale(Vector2 amount, Anchor reference)
+        {
+            if ((reference & Anchor.y1) == 0)
+            {
+                int directionY = (reference & Anchor.y0) > 0 ? -1 : 1;
+                if (directionY < 0)
+                    selectionArea.Y += amount.Y;
+                selectionArea.Height += directionY * amount.Y;
+            }
+
+            if ((reference & Anchor.x1) == 0)
+            {
+                int directionX = (reference & Anchor.x0) > 0 ? -1 : 1;
+                if (directionX < 0)
+                    selectionArea.X += amount.X;
+                selectionArea.Width += directionX * amount.X;
+            }
+        }
+
+        private void handleRotation(float angle)
+        {
+            // kinda silly and wrong, but just showing that the drag handles work.
+            selectionArea.Rotation += angle;
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+// 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.IO;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Edit.Setup;
+using osu.Game.Tests.Resources;
+using SharpCompress.Archives;
+using SharpCompress.Archives.Zip;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorBeatmapCreation : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override bool EditorComponentsReady => Editor.ChildrenOfType<SetupScreen>().SingleOrDefault()?.IsLoaded == true;
+
+        [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.
+            // probably needs a more solid resolution in the future but this will do for now.
+            AddStep("make new beatmap unique", () => EditorBeatmap.Metadata.Title = Guid.NewGuid().ToString());
+        }
+
+        [Test]
+        public void TestCreateNewBeatmap()
+        {
+            AddStep("save beatmap", () => Editor.Save());
+            AddAssert("new beatmap persisted", () => EditorBeatmap.BeatmapInfo.ID > 0);
+            AddAssert("new beatmap in database", () => beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID)?.DeletePending == false);
+        }
+
+        [Test]
+        public void TestExitWithoutSave()
+        {
+            AddStep("exit without save", () => Editor.Exit());
+            AddUntilStep("wait for exit", () => !Editor.IsCurrentScreen());
+            AddAssert("new beatmap not persisted", () => beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID)?.DeletePending == true);
+        }
+
+        [Test]
+        public void TestAddAudioTrack()
+        {
+            AddAssert("switch track to real track", () =>
+            {
+                var setup = Editor.ChildrenOfType<SetupScreen>().First();
+
+                var temp = TestResources.GetTestBeatmapForImport();
+
+                string extractedFolder = $"{temp}_extracted";
+                Directory.CreateDirectory(extractedFolder);
+
+                using (var zip = ZipArchive.Open(temp))
+                    zip.WriteToDirectory(extractedFolder);
+
+                bool success = setup.ChildrenOfType<ResourcesSection>().First().ChangeAudioTrack(Path.Combine(extractedFolder, "03. Renatus - Soleily 192kbps.mp3"));
+
+                File.Delete(temp);
+                Directory.Delete(extractedFolder, true);
+
+                return success;
+            });
+
+            AddAssert("track length changed", () => Beatmap.Value.Track.Length > 60000);
+        }
+    }
+}

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

@@ -1,28 +1,27 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Linq;
 using NUnit.Framework;
-using osu.Framework.Testing;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Screens.Edit;
 
 namespace osu.Game.Tests.Visual.Editing
 {
     public class TestSceneEditorChangeStates : EditorTestScene
     {
-        private EditorBeatmap editorBeatmap;
-
         protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
 
-        public override void SetUpSteps()
+        [Test]
+        public void TestSelectedObjects()
         {
-            base.SetUpSteps();
-
-            AddStep("get beatmap", () => editorBeatmap = Editor.ChildrenOfType<EditorBeatmap>().Single());
+            HitCircle obj = null;
+            AddStep("add hitobject", () => EditorBeatmap.Add(obj = new HitCircle { StartTime = 1000 }));
+            AddStep("select hitobject", () => EditorBeatmap.SelectedHitObjects.Add(obj));
+            AddAssert("confirm 1 selected", () => EditorBeatmap.SelectedHitObjects.Count == 1);
+            AddStep("deselect hitobject", () => EditorBeatmap.SelectedHitObjects.Remove(obj));
+            AddAssert("confirm 0 selected", () => EditorBeatmap.SelectedHitObjects.Count == 0);
         }
 
         [Test]
@@ -30,11 +29,12 @@ namespace osu.Game.Tests.Visual.Editing
         {
             int hitObjectCount = 0;
 
-            AddStep("get initial state", () => hitObjectCount = editorBeatmap.HitObjects.Count);
+            AddStep("get initial state", () => hitObjectCount = EditorBeatmap.HitObjects.Count);
 
             addUndoSteps();
 
-            AddAssert("no change occurred", () => hitObjectCount == editorBeatmap.HitObjects.Count);
+            AddAssert("no change occurred", () => hitObjectCount == EditorBeatmap.HitObjects.Count);
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -42,11 +42,12 @@ namespace osu.Game.Tests.Visual.Editing
         {
             int hitObjectCount = 0;
 
-            AddStep("get initial state", () => hitObjectCount = editorBeatmap.HitObjects.Count);
+            AddStep("get initial state", () => hitObjectCount = EditorBeatmap.HitObjects.Count);
 
             addRedoSteps();
 
-            AddAssert("no change occurred", () => hitObjectCount == editorBeatmap.HitObjects.Count);
+            AddAssert("no change occurred", () => hitObjectCount == EditorBeatmap.HitObjects.Count);
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -58,15 +59,17 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
             AddAssert("hitobject added", () => addedObject == expectedObject);
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges);
 
             addUndoSteps();
             AddAssert("hitobject removed", () => removedObject == expectedObject);
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -78,11 +81,11 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
             addUndoSteps();
 
             AddStep("reset variables", () =>
@@ -94,6 +97,17 @@ namespace osu.Game.Tests.Visual.Editing
             addRedoSteps();
             AddAssert("hitobject added", () => addedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance)
             AddAssert("no hitobject removed", () => removedObject == null);
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges);
+        }
+
+        [Test]
+        public void TestAddObjectThenSaveHasNoUnsavedChanges()
+        {
+            AddStep("add hitobject", () => EditorBeatmap.Add(new HitCircle { StartTime = 1000 }));
+
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges);
+            AddStep("save changes", () => Editor.Save());
+            AddAssert("no unsaved changes", () => !Editor.HasUnsavedChanges);
         }
 
         [Test]
@@ -105,12 +119,12 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
-            AddStep("remove object", () => editorBeatmap.Remove(expectedObject));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("remove object", () => EditorBeatmap.Remove(expectedObject));
             AddStep("reset variables", () =>
             {
                 addedObject = null;
@@ -120,6 +134,7 @@ namespace osu.Game.Tests.Visual.Editing
             addUndoSteps();
             AddAssert("hitobject added", () => addedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance)
             AddAssert("no hitobject removed", () => removedObject == null);
+            AddAssert("unsaved changes", () => Editor.HasUnsavedChanges); // 2 steps performed, 1 undone
         }
 
         [Test]
@@ -131,12 +146,12 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddStep("bind removal", () =>
             {
-                editorBeatmap.HitObjectAdded += h => addedObject = h;
-                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+                EditorBeatmap.HitObjectAdded += h => addedObject = h;
+                EditorBeatmap.HitObjectRemoved += h => removedObject = h;
             });
 
-            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
-            AddStep("remove object", () => editorBeatmap.Remove(expectedObject));
+            AddStep("add hitobject", () => EditorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("remove object", () => EditorBeatmap.Remove(expectedObject));
             addUndoSteps();
 
             AddStep("reset variables", () =>
@@ -148,19 +163,11 @@ namespace osu.Game.Tests.Visual.Editing
             addRedoSteps();
             AddAssert("hitobject removed", () => removedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance after undo)
             AddAssert("no hitobject added", () => addedObject == null);
+            AddAssert("no changes", () => !Editor.HasUnsavedChanges); // end result is empty beatmap, matching original state
         }
 
-        private void addUndoSteps() => AddStep("undo", () => ((TestEditor)Editor).Undo());
+        private void addUndoSteps() => AddStep("undo", () => Editor.Undo());
 
-        private void addRedoSteps() => AddStep("redo", () => ((TestEditor)Editor).Redo());
-
-        protected override Editor CreateEditor() => new TestEditor();
-
-        private class TestEditor : Editor
-        {
-            public new void Undo() => base.Undo();
-
-            public new void Redo() => base.Redo();
-        }
+        private void addRedoSteps() => AddStep("redo", () => Editor.Redo());
     }
 }

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

@@ -0,0 +1,154 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorClipboard : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(ruleset, false);
+
+        [Test]
+        public void TestCutRemovesObjects()
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddAssert("no hitobjects in beatmap", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [TestCase(1000)]
+        [TestCase(2000)]
+        public void TestCutPaste(double newTime)
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddStep("move forward in time", () => EditorClock.Seek(newTime));
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+
+            AddAssert("new object selected", () => EditorBeatmap.SelectedHitObjects.Single().StartTime == newTime);
+        }
+
+        [Test]
+        public void TestCutPasteSlider()
+        {
+            var addedObject = new Slider
+            {
+                StartTime = 1000,
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint(),
+                        new PathControlPoint(new Vector2(100, 0), PathType.Bezier)
+                    }
+                }
+            };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+
+            AddAssert("path matches", () =>
+            {
+                var path = ((Slider)EditorBeatmap.HitObjects.Single()).Path;
+                return path.ControlPoints.Count == 2 && path.ControlPoints.SequenceEqual(addedObject.Path.ControlPoints);
+            });
+        }
+
+        [Test]
+        public void TestCutPasteSpinner()
+        {
+            var addedObject = new Spinner
+            {
+                StartTime = 1000,
+                Duration = 5000
+            };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("cut hitobject", () => Editor.Cut());
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("is one object", () => EditorBeatmap.HitObjects.Count == 1);
+
+            AddAssert("duration matches", () => ((Spinner)EditorBeatmap.HitObjects.Single()).Duration == 5000);
+        }
+
+        [Test]
+        public void TestCopyPaste()
+        {
+            var addedObject = new HitCircle { StartTime = 1000 };
+
+            AddStep("add hitobject", () => EditorBeatmap.Add(addedObject));
+
+            AddStep("select added object", () => EditorBeatmap.SelectedHitObjects.Add(addedObject));
+
+            AddStep("copy hitobject", () => Editor.Copy());
+
+            AddStep("move forward in time", () => EditorClock.Seek(2000));
+
+            AddStep("paste hitobject", () => Editor.Paste());
+
+            AddAssert("are two objects", () => EditorBeatmap.HitObjects.Count == 2);
+
+            AddAssert("new object selected", () => EditorBeatmap.SelectedHitObjects.Single().StartTime == 2000);
+        }
+
+        [Test]
+        public void TestCutNothing()
+        {
+            AddStep("cut hitobject", () => Editor.Cut());
+            AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestCopyNothing()
+        {
+            AddStep("copy hitobject", () => Editor.Copy());
+            AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+
+        [Test]
+        public void TestPasteNothing()
+        {
+            AddStep("paste hitobject", () => Editor.Paste());
+            AddAssert("are no objects", () => EditorBeatmap.HitObjects.Count == 0);
+        }
+    }
+}

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

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -22,7 +23,7 @@ namespace osu.Game.Tests.Visual.Editing
                 {
                     new RadioButton("Item 1", () => { }),
                     new RadioButton("Item 2", () => { }),
-                    new RadioButton("Item 3", () => { }),
+                    new RadioButton("Item 3", () => { }, () => new SpriteIcon { Icon = FontAwesome.Regular.Angry }),
                     new RadioButton("Item 4", () => { }),
                     new RadioButton("Item 5", () => { })
                 }

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

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    public class TestSceneEditorSamplePlayback : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
+
+        [Test]
+        public void TestSlidingSampleStopsOnSeek()
+        {
+            DrawableSlider slider = null;
+            DrawableSample[] loopingSamples = null;
+            DrawableSample[] onceOffSamples = null;
+
+            AddStep("get first slider", () =>
+            {
+                slider = Editor.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
+                onceOffSamples = slider.ChildrenOfType<DrawableSample>().Where(s => !s.Looping).ToArray();
+                loopingSamples = slider.ChildrenOfType<DrawableSample>().Where(s => s.Looping).ToArray();
+            });
+
+            AddStep("start playback", () => EditorClock.Start());
+
+            AddUntilStep("wait for slider sliding then seek", () =>
+            {
+                if (!slider.Tracking.Value)
+                    return false;
+
+                if (!loopingSamples.Any(s => s.Playing))
+                    return false;
+
+                EditorClock.Seek(20000);
+                return true;
+            });
+
+            AddAssert("non-looping samples are playing", () => onceOffSamples.Length == 4 && loopingSamples.All(s => s.Played || s.Playing));
+            AddAssert("looping samples are not playing", () => loopingSamples.Length == 1 && loopingSamples.All(s => s.Played && !s.Playing));
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Setup;
+
+namespace osu.Game.Tests.Visual.Editing
+{
+    [TestFixture]
+    public class TestSceneSetupScreen : EditorClockTestScene
+    {
+        [Cached(typeof(EditorBeatmap))]
+        [Cached(typeof(IBeatSnapProvider))]
+        private readonly EditorBeatmap editorBeatmap;
+
+        public TestSceneSetupScreen()
+        {
+            editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
+            Child = new SetupScreen();
+        }
+    }
+}

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

@@ -5,7 +5,6 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Screens.Edit.Compose.Components;
-using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.Editing
@@ -13,7 +12,7 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneTimelineTickDisplay : TimelineTestScene
     {
-        public override Drawable CreateTestComponent() => new TimelineTickDisplay();
+        public override Drawable CreateTestComponent() => Empty(); // tick display is implicitly inside the timeline.
 
         [BackgroundDependencyLoader]
         private void load()

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

@@ -4,7 +4,7 @@
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Timing;
 
@@ -17,16 +17,26 @@ namespace osu.Game.Tests.Visual.Editing
         [Cached(typeof(IBeatSnapProvider))]
         private readonly EditorBeatmap editorBeatmap;
 
+        protected override bool ScrollUsingMouseWheel => false;
+
         public TestSceneTimingScreen()
         {
-            editorBeatmap = new EditorBeatmap(new OsuBeatmap());
+            editorBeatmap = new EditorBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
             Beatmap.Value = CreateWorkingBeatmap(editorBeatmap.PlayableBeatmap);
+            Beatmap.Disabled = true;
+
             Child = new TimingScreen();
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            Beatmap.Disabled = false;
+            base.Dispose(isDisposing);
+        }
     }
 }

osu.Game.Tests/Visual/Editing/TestSceneWaveform.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.Threading;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
@@ -76,7 +77,7 @@ namespace osu.Game.Tests.Visual.Editing
                 };
             });
 
-            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+            AddUntilStep("wait for load", () => graph.Loaded.IsSet);
         }
 
         [Test]
@@ -98,12 +99,18 @@ namespace osu.Game.Tests.Visual.Editing
                 };
             });
 
-            AddUntilStep("wait for load", () => graph.ResampledWaveform != null);
+            AddUntilStep("wait for load", () => graph.Loaded.IsSet);
         }
 
         public class TestWaveformGraph : WaveformGraph
         {
-            public new Waveform ResampledWaveform => base.ResampledWaveform;
+            public readonly ManualResetEventSlim Loaded = new ManualResetEventSlim();
+
+            protected override void OnWaveformRegenerated(Waveform waveform)
+            {
+                base.OnWaveformRegenerated(waveform);
+                Loaded.Set();
+            }
         }
     }
 }

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

@@ -0,0 +1,47 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneComboCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableComboCounter> comboCounters => CreatedDrawables.OfType<SkinnableComboCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var comboCounter = new SkinnableComboCounter();
+                comboCounter.Current.Value = 1;
+                return comboCounter;
+            }));
+        }
+
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var counter in comboCounters)
+                    counter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var counter in comboCounters)
+                    counter.Current.Value = 0;
+            });
+        }
+    }
+}

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

@@ -4,7 +4,6 @@
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
@@ -18,8 +17,6 @@ namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestSceneCompletionCancellation : OsuPlayerTestScene
     {
-        private Track track;
-
         [Resolved]
         private AudioManager audio { get; set; }
 
@@ -34,7 +31,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             base.SetUpSteps();
 
             // Ensure track has actually running before attempting to seek
-            AddUntilStep("wait for track to start running", () => track.IsRunning);
+            AddUntilStep("wait for track to start running", () => Beatmap.Value.Track.IsRunning);
         }
 
         [Test]
@@ -73,13 +70,13 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void complete()
         {
-            AddStep("seek to completion", () => track.Seek(5000));
+            AddStep("seek to completion", () => Beatmap.Value.Track.Seek(5000));
             AddUntilStep("completion set by processor", () => Player.ScoreProcessor.HasCompleted.Value);
         }
 
         private void cancel()
         {
-            AddStep("rewind to cancel", () => track.Seek(4000));
+            AddStep("rewind to cancel", () => Beatmap.Value.Track.Seek(4000));
             AddUntilStep("completion cleared by processor", () => !Player.ScoreProcessor.HasCompleted.Value);
         }
 
@@ -91,11 +88,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         }
 
         protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
-        {
-            var working = new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audio);
-            track = working.Track;
-            return working;
-        }
+            => new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audio);
 
         protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
         {

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

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -276,7 +277,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public override bool CanConvert() => true;
 
-            protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap)
+            protected override IEnumerable<TestHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
             {
                 yield return new TestHitObject
                 {

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

@@ -272,7 +272,21 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddAssert("Overlay is closed", () => pauseOverlay.State.Value == Visibility.Hidden);
         }
 
+        [Test]
+        public void TestSelectionResetOnVisibilityChange()
+        {
+            showOverlay();
+            AddStep("Select last button", () => InputManager.Key(Key.Up));
+
+            hideOverlay();
+            showOverlay();
+
+            AddAssert("No button selected",
+                () => pauseOverlay.Buttons.All(button => !button.Selected.Value));
+        }
+
         private void showOverlay() => AddStep("Show overlay", () => pauseOverlay.Show());
+        private void hideOverlay() => AddStep("Hide overlay", () => pauseOverlay.Hide());
 
         private DialogButton getButton(int index) => pauseOverlay.Buttons.Skip(index).First();
 

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

@@ -5,7 +5,6 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Utils;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
@@ -21,19 +20,13 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Resolved]
         private AudioManager audioManager { get; set; }
 
-        private Track track;
-
-        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
-        {
-            var working = new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
-            track = working.Track;
-            return working;
-        }
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null) =>
+            new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
 
         [Test]
         public void TestNoJudgementsOnRewind()
         {
-            AddUntilStep("wait for track to start running", () => track.IsRunning);
+            AddUntilStep("wait for track to start running", () => Beatmap.Value.Track.IsRunning);
             addSeekStep(3000);
             AddAssert("all judged", () => Player.DrawableRuleset.Playfield.AllHitObjects.All(h => h.Judged));
             AddUntilStep("key counter counted keys", () => Player.HUDOverlay.KeyCounter.Children.All(kc => kc.CountPresses >= 7));
@@ -46,7 +39,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void addSeekStep(double time)
         {
-            AddStep($"seek to {time}", () => track.Seek(time));
+            AddStep($"seek to {time}", () => Beatmap.Value.Track.Seek(time));
 
             // Allow a few frames of lenience
             AddUntilStep("wait for seek to finish", () => Precision.AlmostEquals(time, Player.DrawableRuleset.FrameStableClock.CurrentTime, 100));

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

@@ -0,0 +1,68 @@
+// 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.Graphics.Audio;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Play;
+using osu.Game.Skinning;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneGameplaySamplePlayback : PlayerTestScene
+    {
+        [Test]
+        public void TestAllSamplesStopDuringSeek()
+        {
+            DrawableSlider slider = null;
+            DrawableSample[] samples = null;
+            ISamplePlaybackDisabler gameplayClock = null;
+
+            AddStep("get variables", () =>
+            {
+                gameplayClock = Player.ChildrenOfType<FrameStabilityContainer>().First();
+                slider = Player.ChildrenOfType<DrawableSlider>().OrderBy(s => s.HitObject.StartTime).First();
+                samples = slider.ChildrenOfType<DrawableSample>().ToArray();
+            });
+
+            AddUntilStep("wait for slider sliding then seek", () =>
+            {
+                if (!slider.Tracking.Value)
+                    return false;
+
+                if (!samples.Any(s => s.Playing))
+                    return false;
+
+                Player.ChildrenOfType<GameplayClockContainer>().First().Seek(40000);
+                return true;
+            });
+
+            AddAssert("sample playback disabled", () => gameplayClock.SamplePlaybackDisabled.Value);
+
+            // because we are in frame stable context, it's quite likely that not all samples are "played" at this point.
+            // the important thing is that at least one started, and that sample has since stopped.
+            AddAssert("all looping samples stopped immediately", () => allStopped(allLoopingSounds));
+            AddUntilStep("all samples stopped eventually", () => allStopped(allSounds));
+
+            AddAssert("sample playback still disabled", () => gameplayClock.SamplePlaybackDisabled.Value);
+
+            AddUntilStep("seek finished, sample playback enabled", () => !gameplayClock.SamplePlaybackDisabled.Value);
+            AddUntilStep("any sample is playing", () => Player.ChildrenOfType<PausableSkinnableSound>().Any(s => s.IsPlaying));
+        }
+
+        private IEnumerable<PausableSkinnableSound> allSounds => Player.ChildrenOfType<PausableSkinnableSound>();
+        private IEnumerable<PausableSkinnableSound> allLoopingSounds => allSounds.Where(sound => sound.Looping);
+
+        private bool allStopped(IEnumerable<PausableSkinnableSound> sounds) => sounds.All(sound => !sound.IsPlaying);
+
+        protected override bool Autoplay => true;
+
+        protected override Ruleset CreatePlayerRuleset() => new OsuRuleset();
+    }
+}

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

@@ -2,23 +2,29 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
 using osu.Game.Configuration;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.Gameplay
 {
-    public class TestSceneHUDOverlay : OsuManualInputManagerTestScene
+    public class TestSceneHUDOverlay : SkinnableTestScene
     {
         private HUDOverlay hudOverlay;
 
+        private IEnumerable<HUDOverlay> hudOverlays => CreatedDrawables.OfType<HUDOverlay>();
+
         // best way to check without exposing.
         private Drawable hideTarget => hudOverlay.KeyCounter;
         private FillFlowContainer<KeyCounter> keyCounterFlow => hudOverlay.KeyCounter.ChildrenOfType<FillFlowContainer<KeyCounter>>().First();
@@ -26,6 +32,24 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Resolved]
         private OsuConfigManager config { get; set; }
 
+        [Test]
+        public void TestComboCounterIncrementing()
+        {
+            createNew();
+
+            AddRepeatStep("increase combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value++;
+            }, 10);
+
+            AddStep("reset combo", () =>
+            {
+                foreach (var hud in hudOverlays)
+                    hud.ComboCounter.Current.Value = 0;
+            });
+        }
+
         [Test]
         public void TestShownByDefault()
         {
@@ -45,7 +69,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             createNew(h => h.OnLoadComplete += _ => initialAlpha = hideTarget.Alpha);
             AddUntilStep("wait for load", () => hudOverlay.IsAlive);
-            AddAssert("initial alpha was less than 1", () => initialAlpha != null && initialAlpha < 1);
+            AddAssert("initial alpha was less than 1", () => initialAlpha < 1);
         }
 
         [Test]
@@ -53,7 +77,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             createNew();
 
-            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
+            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
 
             AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
             AddAssert("pause button is still visible", () => hudOverlay.HoldToQuit.IsPresent);
@@ -89,14 +113,14 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("set keycounter visible false", () =>
             {
                 config.Set<bool>(OsuSetting.KeyOverlay, false);
-                hudOverlay.KeyCounter.AlwaysVisible.Value = false;
+                hudOverlays.ForEach(h => h.KeyCounter.AlwaysVisible.Value = false);
             });
 
-            AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);
+            AddStep("set showhud false", () => hudOverlays.ForEach(h => h.ShowHud.Value = false));
             AddUntilStep("hidetarget is hidden", () => !hideTarget.IsPresent);
             AddAssert("key counters hidden", () => !keyCounterFlow.IsPresent);
 
-            AddStep("set showhud true", () => hudOverlay.ShowHud.Value = true);
+            AddStep("set showhud true", () => hudOverlays.ForEach(h => h.ShowHud.Value = true));
             AddUntilStep("hidetarget is visible", () => hideTarget.IsPresent);
             AddAssert("key counters still hidden", () => !keyCounterFlow.IsPresent);
 
@@ -107,13 +131,22 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             AddStep("create overlay", () =>
             {
-                Child = hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
+                SetContents(() =>
+                {
+                    hudOverlay = new HUDOverlay(null, null, null, Array.Empty<Mod>());
 
-                // Add any key just to display the key counter visually.
-                hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
+                    // Add any key just to display the key counter visually.
+                    hudOverlay.KeyCounter.Add(new KeyCounterKeyboard(Key.Space));
 
-                action?.Invoke(hudOverlay);
+                    hudOverlay.ComboCounter.Current.Value = 1;
+
+                    action?.Invoke(hudOverlay);
+
+                    return hudOverlay;
+                });
             });
         }
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
     }
 }

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

@@ -22,8 +22,10 @@ namespace osu.Game.Tests.Visual.Gameplay
     {
         private BarHitErrorMeter barMeter;
         private BarHitErrorMeter barMeter2;
+        private BarHitErrorMeter barMeter3;
         private ColourHitErrorMeter colourMeter;
         private ColourHitErrorMeter colourMeter2;
+        private ColourHitErrorMeter colourMeter3;
         private HitWindows hitWindows;
 
         public TestSceneHitErrorMeter()
@@ -98,7 +100,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Children = new[]
                 {
                     new OsuSpriteText { Text = $@"Great: {hitWindows?.WindowFor(HitResult.Great)}" },
-                    new OsuSpriteText { Text = $@"Good: {hitWindows?.WindowFor(HitResult.Good)}" },
+                    new OsuSpriteText { Text = $@"Good: {hitWindows?.WindowFor(HitResult.Ok)}" },
                     new OsuSpriteText { Text = $@"Meh: {hitWindows?.WindowFor(HitResult.Meh)}" },
                 }
             });
@@ -115,6 +117,13 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.CentreLeft,
             });
 
+            Add(barMeter3 = new BarHitErrorMeter(hitWindows, true)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.CentreLeft,
+                Rotation = 270,
+            });
+
             Add(colourMeter = new ColourHitErrorMeter(hitWindows)
             {
                 Anchor = Anchor.CentreRight,
@@ -128,6 +137,14 @@ namespace osu.Game.Tests.Visual.Gameplay
                 Origin = Anchor.CentreLeft,
                 Margin = new MarginPadding { Left = 50 }
             });
+
+            Add(colourMeter3 = new ColourHitErrorMeter(hitWindows)
+            {
+                Anchor = Anchor.BottomCentre,
+                Origin = Anchor.CentreLeft,
+                Rotation = 270,
+                Margin = new MarginPadding { Left = 50 }
+            });
         }
 
         private void newJudgement(double offset = 0)
@@ -140,8 +157,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             barMeter.OnNewJudgement(judgement);
             barMeter2.OnNewJudgement(judgement);
+            barMeter3.OnNewJudgement(judgement);
             colourMeter.OnNewJudgement(judgement);
             colourMeter2.OnNewJudgement(judgement);
+            colourMeter3.OnNewJudgement(judgement);
         }
     }
 }

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

@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Game.Overlays;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneOverlayActivation : OsuPlayerTestScene
+    {
+        protected new OverlayTestPlayer Player => base.Player as OverlayTestPlayer;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            AddUntilStep("gameplay has started",
+                () => Player.GameplayClockContainer.GameplayClock.CurrentTime > Player.DrawableRuleset.GameplayStartTime);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivation()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationPaused()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("pause gameplay", () => Player.Pause());
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
+            AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationReplayLoaded()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("load a replay", () => Player.DrawableRuleset.HasReplayLoaded.Value = true);
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationBreaks()
+        {
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("seek to break", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().StartTime));
+            AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+            AddAssert("local user not playing", () => !Player.LocalUserPlaying.Value);
+            AddStep("seek to break end", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().EndTime));
+            AddUntilStep("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddAssert("local user playing", () => Player.LocalUserPlaying.Value);
+        }
+
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new OverlayTestPlayer();
+
+        protected class OverlayTestPlayer : TestPlayer
+        {
+            public new OverlayActivation OverlayActivationMode => base.OverlayActivationMode.Value;
+            public new Bindable<bool> LocalUserPlaying => base.LocalUserPlaying;
+        }
+    }
+}

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

@@ -11,6 +11,7 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Play;
+using osu.Game.Skinning;
 using osuTK;
 using osuTK.Input;
 
@@ -157,7 +158,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         public void TestQuickRetryFromFailedGameplay()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);
-            AddStep("quick retry", () => Player.GameplayClockContainer.OfType<HotkeyRetryOverlay>().First().Action?.Invoke());
+            AddStep("quick retry", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyRetryOverlay>().First().Action?.Invoke());
 
             confirmExited();
         }
@@ -166,7 +167,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         public void TestQuickExitFromFailedGameplay()
         {
             AddUntilStep("wait for fail", () => Player.HasFailed);
-            AddStep("quick exit", () => Player.GameplayClockContainer.OfType<HotkeyExitOverlay>().First().Action?.Invoke());
+            AddStep("quick exit", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyExitOverlay>().First().Action?.Invoke());
 
             confirmExited();
         }
@@ -182,7 +183,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestQuickExitFromGameplay()
         {
-            AddStep("quick exit", () => Player.GameplayClockContainer.OfType<HotkeyExitOverlay>().First().Action?.Invoke());
+            AddStep("quick exit", () => Player.GameplayClockContainer.ChildrenOfType<HotkeyExitOverlay>().First().Action?.Invoke());
 
             confirmExited();
         }
@@ -221,6 +222,31 @@ namespace osu.Game.Tests.Visual.Gameplay
             confirmExited();
         }
 
+        [Test]
+        public void TestPauseSoundLoop()
+        {
+            AddStep("seek before gameplay", () => Player.GameplayClockContainer.Seek(-5000));
+
+            SkinnableSound getLoop() => Player.ChildrenOfType<PauseOverlay>().FirstOrDefault()?.ChildrenOfType<SkinnableSound>().FirstOrDefault();
+
+            pauseAndConfirm();
+            AddAssert("loop is playing", () => getLoop().IsPlaying);
+
+            resumeAndConfirm();
+            AddUntilStep("loop is stopped", () => !getLoop().IsPlaying);
+
+            AddUntilStep("pause again", () =>
+            {
+                Player.Pause();
+                return !Player.GameplayClockContainer.GameplayClock.IsRunning;
+            });
+
+            AddAssert("loop is playing", () => getLoop().IsPlaying);
+
+            resumeAndConfirm();
+            AddUntilStep("loop is stopped", () => !getLoop().IsPlaying);
+        }
+
         private void pauseAndConfirm()
         {
             pause();

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

@@ -46,25 +46,36 @@ namespace osu.Game.Tests.Visual.Gameplay
         /// </summary>
         /// <param name="interactive">If the test player should behave like the production one.</param>
         /// <param name="beforeLoadAction">An action to run before player load but after bindable leases are returned.</param>
-        /// <param name="afterLoadAction">An action to run after container load.</param>
-        public void ResetPlayer(bool interactive, Action beforeLoadAction = null, Action afterLoadAction = null)
+        public void ResetPlayer(bool interactive, Action beforeLoadAction = null)
         {
+            player = null;
+
             audioManager.Volume.SetDefault();
 
             InputManager.Clear();
 
+            container = new TestPlayerLoaderContainer(loader = new TestPlayerLoader(() => player = new TestPlayer(interactive, interactive)));
+
             beforeLoadAction?.Invoke();
+
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToTrack>())
                 mod.ApplyToTrack(Beatmap.Value.Track);
 
-            InputManager.Child = container = new TestPlayerLoaderContainer(
-                loader = new TestPlayerLoader(() =>
-                {
-                    afterLoadAction?.Invoke();
-                    return player = new TestPlayer(interactive, interactive);
-                }));
+            InputManager.Child = container;
+        }
+
+        [Test]
+        public void TestEarlyExitBeforePlayerConstruction()
+        {
+            AddStep("load dummy beatmap", () => ResetPlayer(false, () => SelectedMods.Value = new[] { new OsuModNightcore() }));
+            AddUntilStep("wait for current", () => loader.IsCurrentScreen());
+            AddStep("exit loader", () => loader.Exit());
+            AddUntilStep("wait for not current", () => !loader.IsCurrentScreen());
+            AddAssert("player did not load", () => player == null);
+            AddUntilStep("player disposed", () => loader.DisposalTask == null);
+            AddAssert("mod rate still applied", () => Beatmap.Value.Track.Rate != 1);
         }
 
         /// <summary>
@@ -73,11 +84,12 @@ namespace osu.Game.Tests.Visual.Gameplay
         /// speed adjustments were undone too late, causing cross-screen pollution.
         /// </summary>
         [Test]
-        public void TestEarlyExit()
+        public void TestEarlyExitAfterPlayerConstruction()
         {
             AddStep("load dummy beatmap", () => ResetPlayer(false, () => SelectedMods.Value = new[] { new OsuModNightcore() }));
             AddUntilStep("wait for current", () => loader.IsCurrentScreen());
             AddAssert("mod rate applied", () => Beatmap.Value.Track.Rate != 1);
+            AddUntilStep("wait for non-null player", () => player != null);
             AddStep("exit loader", () => loader.Exit());
             AddUntilStep("wait for not current", () => !loader.IsCurrentScreen());
             AddAssert("player did not load", () => !player.IsLoaded);
@@ -94,7 +106,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("wait for load ready", () =>
             {
                 moveMouse();
-                return player.LoadState == LoadState.Ready;
+                return player?.LoadState == LoadState.Ready;
             });
             AddRepeatStep("move mouse", moveMouse, 20);
 
@@ -195,19 +207,19 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Test]
         public void TestMutedNotificationMasterVolume()
         {
-            addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, null, () => audioManager.Volume.IsDefault);
+            addVolumeSteps("master volume", () => audioManager.Volume.Value = 0, () => audioManager.Volume.IsDefault);
         }
 
         [Test]
         public void TestMutedNotificationTrackVolume()
         {
-            addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, null, () => audioManager.VolumeTrack.IsDefault);
+            addVolumeSteps("music volume", () => audioManager.VolumeTrack.Value = 0, () => audioManager.VolumeTrack.IsDefault);
         }
 
         [Test]
         public void TestMutedNotificationMuteButton()
         {
-            addVolumeSteps("mute button", null, () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
+            addVolumeSteps("mute button", () => container.VolumeOverlay.IsMuted.Value = true, () => !container.VolumeOverlay.IsMuted.Value);
         }
 
         /// <remarks>
@@ -215,14 +227,13 @@ namespace osu.Game.Tests.Visual.Gameplay
         /// </remarks>
         /// <param name="volumeName">What part of the volume system is checked</param>
         /// <param name="beforeLoad">The action to be invoked to set the volume before loading</param>
-        /// <param name="afterLoad">The action to be invoked to set the volume after loading</param>
         /// <param name="assert">The function to be invoked and checked</param>
-        private void addVolumeSteps(string volumeName, Action beforeLoad, Action afterLoad, Func<bool> assert)
+        private void addVolumeSteps(string volumeName, Action beforeLoad, Func<bool> assert)
         {
             AddStep("reset notification lock", () => sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).Value = false);
 
-            AddStep("load player", () => ResetPlayer(false, beforeLoad, afterLoad));
-            AddUntilStep("wait for player", () => player.LoadState == LoadState.Ready);
+            AddStep("load player", () => ResetPlayer(false, beforeLoad));
+            AddUntilStep("wait for player", () => player?.LoadState == LoadState.Ready);
 
             AddAssert("check for notification", () => container.NotificationOverlay.UnreadCount.Value == 1);
             AddStep("click notification", () =>

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

@@ -173,19 +173,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             {
             }
 
-            public override List<IInput> GetPendingInputs()
+            public override void CollectPendingInputs(List<IInput> inputs)
             {
-                return new List<IInput>
-                {
-                    new MousePositionAbsoluteInput
-                    {
-                        Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero)
-                    },
-                    new ReplayState<TestAction>
-                    {
-                        PressedActions = CurrentFrame?.Actions ?? new List<TestAction>()
-                    }
-                };
+                inputs.Add(new MousePositionAbsoluteInput { Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero) });
+                inputs.Add(new ReplayState<TestAction> { PressedActions = CurrentFrame?.Actions ?? new List<TestAction>() });
             }
         }
 

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

@@ -113,19 +113,10 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
         }
 
-        public override List<IInput> GetPendingInputs()
+        public override void CollectPendingInputs(List<IInput> inputs)
         {
-            return new List<IInput>
-            {
-                new MousePositionAbsoluteInput
-                {
-                    Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero)
-                },
-                new ReplayState<TestAction>
-                {
-                    PressedActions = CurrentFrame?.Actions ?? new List<TestAction>()
-                }
-            };
+            inputs.Add(new MousePositionAbsoluteInput { Position = GamefieldToScreenSpace(CurrentFrame?.Position ?? Vector2.Zero) });
+            inputs.Add(new ReplayState<TestAction> { PressedActions = CurrentFrame?.Actions ?? new List<TestAction>() });
         }
     }
 

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

@@ -48,7 +48,10 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private class ExampleContainer : PlayerSettingsGroup
         {
-            protected override string Title => @"example";
+            public ExampleContainer()
+                : base("example")
+            {
+            }
         }
     }
 }

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

@@ -1,70 +0,0 @@
-// 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.Graphics.UserInterface;
-using osu.Game.Screens.Play.HUD;
-using osuTK;
-
-namespace osu.Game.Tests.Visual.Gameplay
-{
-    [TestFixture]
-    public class TestSceneScoreCounter : OsuTestScene
-    {
-        public TestSceneScoreCounter()
-        {
-            int numerator = 0, denominator = 0;
-
-            ScoreCounter score = new ScoreCounter(7)
-            {
-                Origin = Anchor.TopRight,
-                Anchor = Anchor.TopRight,
-                TextSize = 40,
-                Margin = new MarginPadding(20),
-            };
-            Add(score);
-
-            ComboCounter comboCounter = new StandardComboCounter
-            {
-                Origin = Anchor.BottomLeft,
-                Anchor = Anchor.BottomLeft,
-                Margin = new MarginPadding(10),
-                TextSize = 40,
-            };
-            Add(comboCounter);
-
-            PercentageCounter accuracyCounter = new PercentageCounter
-            {
-                Origin = Anchor.TopRight,
-                Anchor = Anchor.TopRight,
-                Position = new Vector2(-20, 60),
-            };
-            Add(accuracyCounter);
-
-            AddStep(@"Reset all", delegate
-            {
-                score.Current.Value = 0;
-                comboCounter.Current.Value = 0;
-                numerator = denominator = 0;
-                accuracyCounter.SetFraction(0, 0);
-            });
-
-            AddStep(@"Hit! :D", delegate
-            {
-                score.Current.Value += 300 + (ulong)(300.0 * (comboCounter.Current.Value > 0 ? comboCounter.Current.Value - 1 : 0) / 25.0);
-                comboCounter.Increment();
-                numerator++;
-                denominator++;
-                accuracyCounter.SetFraction(numerator, denominator);
-            });
-
-            AddStep(@"miss...", delegate
-            {
-                comboCounter.Current.Value = 0;
-                denominator++;
-                accuracyCounter.SetFraction(numerator, denominator);
-            });
-        }
-    }
-}

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

@@ -0,0 +1,49 @@
+// 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.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableAccuracyCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableAccuracyCounter> accuracyCounters => CreatedDrawables.OfType<SkinnableAccuracyCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var accuracyCounter = new SkinnableAccuracyCounter();
+
+                accuracyCounter.Current.Value = 1;
+
+                return accuracyCounter;
+            }));
+        }
+
+        [Test]
+        public void TestChangingAccuracy()
+        {
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in accuracyCounters)
+                    s.Current.Value = 1;
+            });
+
+            AddStep(@"Hit! :D", delegate
+            {
+                foreach (var s in accuracyCounters)
+                    s.Current.Value -= 0.023f;
+            });
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+// 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.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableHealthDisplay : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableHealthDisplay> healthDisplays => CreatedDrawables.OfType<SkinnableHealthDisplay>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create health displays", () =>
+            {
+                SetContents(() => new SkinnableHealthDisplay());
+            });
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in healthDisplays)
+                    s.Current.Value = 1;
+            });
+        }
+
+        [Test]
+        public void TestHealthDisplayIncrementing()
+        {
+            AddRepeatStep(@"decrease hp", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                    healthDisplay.Current.Value -= 0.08f;
+            }, 10);
+
+            AddRepeatStep(@"increase hp without flash", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                    healthDisplay.Current.Value += 0.1f;
+            }, 3);
+
+            AddRepeatStep(@"increase hp with flash", delegate
+            {
+                foreach (var healthDisplay in healthDisplays)
+                {
+                    healthDisplay.Current.Value += 0.1f;
+                    healthDisplay.Flash(new JudgementResult(null, new OsuJudgement()));
+                }
+            }, 3);
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+// 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.Extensions.IEnumerableExtensions;
+using osu.Framework.Testing;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableScoreCounter : SkinnableTestScene
+    {
+        private IEnumerable<SkinnableScoreCounter> scoreCounters => CreatedDrawables.OfType<SkinnableScoreCounter>();
+
+        protected override Ruleset CreateRulesetForSkinProvider() => new OsuRuleset();
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Create combo counters", () => SetContents(() =>
+            {
+                var comboCounter = new SkinnableScoreCounter();
+                comboCounter.Current.Value = 1;
+                return comboCounter;
+            }));
+        }
+
+        [Test]
+        public void TestScoreCounterIncrementing()
+        {
+            AddStep(@"Reset all", delegate
+            {
+                foreach (var s in scoreCounters)
+                    s.Current.Value = 0;
+            });
+
+            AddStep(@"Hit! :D", delegate
+            {
+                foreach (var s in scoreCounters)
+                    s.Current.Value += 300;
+            });
+        }
+
+        [Test]
+        public void TestVeryLargeScore()
+        {
+            AddStep("set large score", () => scoreCounters.ForEach(counter => counter.Current.Value = 1_000_000_000));
+        }
+    }
+}

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

@@ -0,0 +1,167 @@
+// 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.Sample;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Testing;
+using osu.Game.Audio;
+using osu.Game.Screens.Play;
+using osu.Game.Skinning;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSkinnableSound : OsuTestScene
+    {
+        private TestSkinSourceContainer skinSource;
+        private PausableSkinnableSound skinnableSound;
+
+        [SetUp]
+        public void SetUpSteps()
+        {
+            AddStep("setup hierarchy", () =>
+            {
+                Children = new Drawable[]
+                {
+                    skinSource = new TestSkinSourceContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = skinnableSound = new PausableSkinnableSound(new SampleInfo("normal-sliderslide"))
+                    },
+                };
+            });
+        }
+
+        [Test]
+        public void TestStoppedSoundDoesntResumeAfterPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample with looping", () =>
+            {
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
+
+                skinnableSound.Looping = true;
+                skinnableSound.Play();
+            });
+
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+
+            AddStep("stop sample", () => skinnableSound.Stop());
+
+            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+
+            AddWaitStep("wait a bit", 5);
+            AddAssert("sample not playing", () => !sample.Playing);
+        }
+
+        [Test]
+        public void TestLoopingSoundResumesAfterPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample with looping", () =>
+            {
+                skinnableSound.Looping = true;
+                skinnableSound.Play();
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
+            });
+
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+            AddUntilStep("wait for sample to start playing", () => sample.Playing);
+        }
+
+        [Test]
+        public void TestNonLoopingStopsWithPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample", () =>
+            {
+                skinnableSound.Play();
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().First();
+            });
+
+            AddAssert("sample playing", () => sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+
+            AddUntilStep("sample not playing", () => !sample.Playing);
+
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+
+            AddAssert("sample not playing", () => !sample.Playing);
+            AddAssert("sample not playing", () => !sample.Playing);
+            AddAssert("sample not playing", () => !sample.Playing);
+        }
+
+        [Test]
+        public void TestSkinChangeDoesntPlayOnPause()
+        {
+            DrawableSample sample = null;
+            AddStep("start sample", () =>
+            {
+                skinnableSound.Play();
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().Single();
+            });
+
+            AddAssert("sample playing", () => sample.Playing);
+
+            AddStep("disable sample playback", () => skinSource.SamplePlaybackDisabled.Value = true);
+            AddUntilStep("wait for sample to stop playing", () => !sample.Playing);
+
+            AddStep("trigger skin change", () => skinSource.TriggerSourceChanged());
+
+            AddAssert("retrieve and ensure current sample is different", () =>
+            {
+                DrawableSample oldSample = sample;
+                sample = skinnableSound.ChildrenOfType<DrawableSample>().Single();
+                return sample != oldSample;
+            });
+
+            AddAssert("new sample stopped", () => !sample.Playing);
+            AddStep("enable sample playback", () => skinSource.SamplePlaybackDisabled.Value = false);
+
+            AddWaitStep("wait a bit", 5);
+            AddAssert("new sample not played", () => !sample.Playing);
+        }
+
+        [Cached(typeof(ISkinSource))]
+        [Cached(typeof(ISamplePlaybackDisabler))]
+        private class TestSkinSourceContainer : Container, ISkinSource, ISamplePlaybackDisabler
+        {
+            [Resolved]
+            private ISkinSource source { get; set; }
+
+            public event Action SourceChanged;
+
+            public Bindable<bool> SamplePlaybackDisabled { get; } = new Bindable<bool>();
+
+            IBindable<bool> ISamplePlaybackDisabler.SamplePlaybackDisabled => SamplePlaybackDisabled;
+
+            public Drawable GetDrawableComponent(ISkinComponent component) => source?.GetDrawableComponent(component);
+            public Texture GetTexture(string componentName, WrapMode wrapModeS, WrapMode wrapModeT) => source?.GetTexture(componentName, wrapModeS, wrapModeT);
+            public SampleChannel GetSample(ISampleInfo sampleInfo) => source?.GetSample(sampleInfo);
+            public IBindable<TValue> GetConfig<TLookup, TValue>(TLookup lookup) => source?.GetConfig<TLookup, TValue>(lookup);
+
+            public void TriggerSourceChanged()
+            {
+                SourceChanged?.Invoke();
+            }
+        }
+    }
+}

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

@@ -1,11 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Play;
 using osuTK;
@@ -32,7 +30,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             requestCount = 0;
             increment = skip_time;
 
-            Child = gameplayClockContainer = new GameplayClockContainer(CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo)), Array.Empty<Mod>(), 0)
+            var working = CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
+            working.LoadTrack();
+
+            Child = gameplayClockContainer = new GameplayClockContainer(working, 0)
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]

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

@@ -22,19 +22,32 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public class TestSceneStoryboard : OsuTestScene
     {
-        private readonly Container<DrawableStoryboard> storyboardContainer;
+        private Container<DrawableStoryboard> storyboardContainer;
         private DrawableStoryboard storyboard;
 
-        [Cached]
-        private MusicController musicController = new MusicController();
+        [Test]
+        public void TestStoryboard()
+        {
+            AddStep("Restart", restart);
+            AddToggleStep("Passing", passing =>
+            {
+                if (storyboard != null) storyboard.Passing = passing;
+            });
+        }
 
-        public TestSceneStoryboard()
+        [Test]
+        public void TestStoryboardMissingVideo()
+        {
+            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
             Clock = new FramedClock();
 
             AddRange(new Drawable[]
             {
-                musicController,
                 new Container
                 {
                     RelativeSizeAxes = Axes.Both,
@@ -58,32 +71,11 @@ namespace osu.Game.Tests.Visual.Gameplay
                     State = { Value = Visibility.Visible },
                 }
             });
+
+            Beatmap.BindValueChanged(beatmapChanged, true);
         }
 
-        [Test]
-        public void TestStoryboard()
-        {
-            AddStep("Restart", restart);
-            AddToggleStep("Passing", passing =>
-            {
-                if (storyboard != null) storyboard.Passing = passing;
-            });
-        }
-
-        [Test]
-        public void TestStoryboardMissingVideo()
-        {
-            AddStep("Load storyboard with missing video", loadStoryboardNoVideo);
-        }
-
-        [BackgroundDependencyLoader]
-        private void load()
-        {
-            Beatmap.ValueChanged += beatmapChanged;
-        }
-
-        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e)
-            => loadStoryboard(e.NewValue);
+        private void beatmapChanged(ValueChangedEvent<WorkingBeatmap> e) => loadStoryboard(e.NewValue);
 
         private void restart()
         {

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

@@ -2,8 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
-using osu.Framework.Audio.Track;
 using osu.Framework.Screens;
+using osu.Framework.Utils;
 using osu.Game.Screens.Menu;
 
 namespace osu.Game.Tests.Visual.Menus
@@ -15,11 +15,9 @@ namespace osu.Game.Tests.Visual.Menus
 
         public TestSceneIntroWelcome()
         {
-            AddUntilStep("wait for load", () => getTrack() != null);
-
-            AddAssert("check if menu music loops", () => getTrack().Looping);
+            AddUntilStep("wait for load", () => MusicController.TrackLoaded);
+            AddAssert("correct track", () => Precision.AlmostEquals(MusicController.CurrentTrack.Length, 48000, 1));
+            AddAssert("check if menu music loops", () => MusicController.CurrentTrack.Looping);
         }
-
-        private Track getTrack() => (IntroStack?.CurrentScreen as MainMenu)?.Track;
     }
 }

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

@@ -0,0 +1,83 @@
+// 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.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Input.Bindings;
+using osu.Game.Overlays;
+using osu.Game.Tests.Resources;
+using osu.Game.Tests.Visual.Navigation;
+
+namespace osu.Game.Tests.Visual.Menus
+{
+    public class TestSceneMusicActionHandling : OsuGameTestScene
+    {
+        private GlobalActionContainer globalActionContainer => Game.ChildrenOfType<GlobalActionContainer>().First();
+
+        [Test]
+        public void TestMusicPlayAction()
+        {
+            AddStep("ensure playing something", () => Game.MusicController.EnsurePlayingSomething());
+            AddStep("toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddAssert("music paused", () => !Game.MusicController.IsPlaying && Game.MusicController.IsUserPaused);
+            AddStep("toggle playback", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPlay));
+            AddAssert("music resumed", () => Game.MusicController.IsPlaying && !Game.MusicController.IsUserPaused);
+        }
+
+        [Test]
+        public void TestMusicNavigationActions()
+        {
+            int importId = 0;
+            Queue<(WorkingBeatmap working, TrackChangeDirection changeDirection)> trackChangeQueue = null;
+
+            // ensure we have at least two beatmaps available to identify the direction the music controller navigated to.
+            AddRepeatStep("import beatmap", () => Game.BeatmapManager.Import(new BeatmapSetInfo
+            {
+                Beatmaps = new List<BeatmapInfo>
+                {
+                    new BeatmapInfo
+                    {
+                        BaseDifficulty = new BeatmapDifficulty(),
+                    }
+                },
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = $"a test map {importId++}",
+                    Title = "title",
+                }
+            }).Wait(), 5);
+
+            AddStep("import beatmap with track", () =>
+            {
+                var setWithTrack = Game.BeatmapManager.Import(TestResources.GetTestBeatmapForImport()).Result;
+                Beatmap.Value = Game.BeatmapManager.GetWorkingBeatmap(setWithTrack.Beatmaps.First());
+            });
+
+            AddStep("bind to track change", () =>
+            {
+                trackChangeQueue = new Queue<(WorkingBeatmap, TrackChangeDirection)>();
+                Game.MusicController.TrackChanged += (working, changeDirection) => trackChangeQueue.Enqueue((working, changeDirection));
+            });
+
+            AddStep("seek track to 6 second", () => Game.MusicController.SeekTo(6000));
+            AddUntilStep("wait for current time to update", () => Game.MusicController.CurrentTrack.CurrentTime > 5000);
+
+            AddStep("press previous", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPrev));
+            AddAssert("no track change", () => trackChangeQueue.Count == 0);
+            AddUntilStep("track restarted", () => Game.MusicController.CurrentTrack.CurrentTime < 5000);
+
+            AddStep("press previous", () => globalActionContainer.TriggerPressed(GlobalAction.MusicPrev));
+            AddAssert("track changed to previous", () =>
+                trackChangeQueue.Count == 1 &&
+                trackChangeQueue.Dequeue().changeDirection == TrackChangeDirection.Prev);
+
+            AddStep("press next", () => globalActionContainer.TriggerPressed(GlobalAction.MusicNext));
+            AddAssert("track changed to next", () =>
+                trackChangeQueue.Count == 1 &&
+                trackChangeQueue.Dequeue().changeDirection == TrackChangeDirection.Next);
+        }
+    }
+}

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

@@ -1,7 +1,6 @@
 // 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.Game.Overlays;
@@ -11,14 +10,10 @@ namespace osu.Game.Tests.Visual.Menus
 {
     public class TestSceneSongTicker : OsuTestScene
     {
-        [Cached]
-        private MusicController musicController = new MusicController();
-
         public TestSceneSongTicker()
         {
             AddRange(new Drawable[]
             {
-                musicController,
                 new SongTicker
                 {
                     Anchor = Anchor.Centre,

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

@@ -4,8 +4,10 @@
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
+using osu.Game.Overlays;
 using osu.Game.Overlays.Toolbar;
 using osu.Game.Rulesets;
 using osuTK.Input;
@@ -15,7 +17,7 @@ namespace osu.Game.Tests.Visual.Menus
     [TestFixture]
     public class TestSceneToolbar : OsuManualInputManagerTestScene
     {
-        private Toolbar toolbar;
+        private TestToolbar toolbar;
 
         [Resolved]
         private RulesetStore rulesets { get; set; }
@@ -23,7 +25,7 @@ namespace osu.Game.Tests.Visual.Menus
         [SetUp]
         public void SetUp() => Schedule(() =>
         {
-            Child = toolbar = new Toolbar { State = { Value = Visibility.Visible } };
+            Child = toolbar = new TestToolbar { State = { Value = Visibility.Visible } };
         });
 
         [Test]
@@ -72,5 +74,24 @@ namespace osu.Game.Tests.Visual.Menus
                 AddUntilStep("ruleset switched", () => rulesetSelector.Current.Value.Equals(expected));
             }
         }
+
+        [TestCase(OverlayActivation.All)]
+        [TestCase(OverlayActivation.Disabled)]
+        public void TestRespectsOverlayActivation(OverlayActivation mode)
+        {
+            AddStep($"set activation mode to {mode}", () => toolbar.OverlayActivationMode.Value = mode);
+            AddStep("hide toolbar", () => toolbar.Hide());
+            AddStep("try to show toolbar", () => toolbar.Show());
+
+            if (mode == OverlayActivation.Disabled)
+                AddAssert("toolbar still hidden", () => toolbar.State.Value == Visibility.Hidden);
+            else
+                AddAssert("toolbar is visible", () => toolbar.State.Value == Visibility.Visible);
+        }
+
+        public class TestToolbar : Toolbar
+        {
+            public new Bindable<OverlayActivation> OverlayActivationMode => base.OverlayActivationMode as Bindable<OverlayActivation>;
+        }
     }
 }

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

@@ -16,7 +16,9 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Online.Multiplayer;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Screens.Multi.Components;
 using osu.Game.Screens.Select;
 
@@ -52,7 +54,6 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 {
                     Ruleset = new OsuRuleset().RulesetInfo,
                     OnlineBeatmapID = beatmapId,
-                    Path = "normal.osu",
                     Version = $"{beatmapId} (length {TimeSpan.FromMilliseconds(length):m\\:ss}, bpm {bpm:0.#})",
                     Length = length,
                     BPM = bpm,
@@ -145,6 +146,43 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("new item has id 2", () => Room.Playlist.Last().ID == 2);
         }
 
+        /// <summary>
+        /// Tests that the same <see cref="Mod"/> instances are not shared between two playlist items.
+        /// </summary>
+        [Test]
+        public void TestNewItemHasNewModInstances()
+        {
+            AddStep("set dt mod", () => SelectedMods.Value = new[] { new OsuModDoubleTime() });
+            AddStep("create item", () => songSelect.BeatmapDetails.CreateNewItem());
+            AddStep("change mod rate", () => ((OsuModDoubleTime)SelectedMods.Value[0]).SpeedChange.Value = 2);
+            AddStep("create item", () => songSelect.BeatmapDetails.CreateNewItem());
+
+            AddAssert("item 1 has rate 1.5", () => Precision.AlmostEquals(1.5, ((OsuModDoubleTime)Room.Playlist.First().RequiredMods[0]).SpeedChange.Value));
+            AddAssert("item 2 has rate 2", () => Precision.AlmostEquals(2, ((OsuModDoubleTime)Room.Playlist.Last().RequiredMods[0]).SpeedChange.Value));
+        }
+
+        /// <summary>
+        /// Tests that the global mod instances are not retained by the rooms, as global mod instances are retained and re-used by the mod select overlay.
+        /// </summary>
+        [Test]
+        public void TestGlobalModInstancesNotRetained()
+        {
+            OsuModDoubleTime mod = null;
+
+            AddStep("set dt mod and store", () =>
+            {
+                SelectedMods.Value = new[] { new OsuModDoubleTime() };
+
+                // Mod select overlay replaces our mod.
+                mod = (OsuModDoubleTime)SelectedMods.Value[0];
+            });
+
+            AddStep("create item", () => songSelect.BeatmapDetails.CreateNewItem());
+
+            AddStep("change stored mod rate", () => mod.SpeedChange.Value = 2);
+            AddAssert("item has rate 1.5", () => Precision.AlmostEquals(1.5, ((OsuModDoubleTime)Room.Playlist.First().RequiredMods[0]).SpeedChange.Value));
+        }
+
         private class TestMatchSongSelect : MatchSongSelect
         {
             public new MatchBeatmapDetailArea BeatmapDetails => (MatchBeatmapDetailArea)base.BeatmapDetails;

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

@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual.Multiplayer
 {
@@ -10,11 +12,15 @@ namespace osu.Game.Tests.Visual.Multiplayer
     {
         protected override bool UseOnlineAPI => true;
 
+        [Cached]
+        private MusicController musicController { get; set; } = new MusicController();
+
         public TestSceneMultiScreen()
         {
             Screens.Multi.Multiplayer multi = new Screens.Multi.Multiplayer();
 
-            AddStep(@"show", () => LoadScreen(multi));
+            AddStep("show", () => LoadScreen(multi));
+            AddUntilStep("wait for loaded", () => multi.IsLoaded);
         }
     }
 }

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

@@ -3,8 +3,16 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Net;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Newtonsoft.Json.Linq;
 using NUnit.Framework;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.Multiplayer;
@@ -12,6 +20,7 @@ using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Multi.Ranking;
+using osu.Game.Screens.Ranking;
 using osu.Game.Tests.Beatmaps;
 using osu.Game.Users;
 
@@ -19,43 +28,134 @@ namespace osu.Game.Tests.Visual.Multiplayer
 {
     public class TestSceneTimeshiftResultsScreen : ScreenTestScene
     {
-        private bool roomsReceived;
+        private const int scores_per_result = 10;
+
+        private TestResultsScreen resultsScreen;
+        private int currentScoreId;
+        private bool requestComplete;
 
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            roomsReceived = false;
+            currentScoreId = 0;
+            requestComplete = false;
             bindHandler();
         });
 
         [Test]
-        public void TestShowResultsWithScore()
+        public void TestShowWithUserScore()
         {
-            createResults(new TestScoreInfo(new OsuRuleset().RulesetInfo));
-            AddWaitStep("wait for display", 5);
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(userScore: userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddAssert("user score selected", () => this.ChildrenOfType<ScorePanel>().Single(p => p.Score.OnlineScoreID == userScore.OnlineScoreID).State == PanelState.Expanded);
         }
 
         [Test]
-        public void TestShowResultsNullScore()
+        public void TestShowNullUserScore()
         {
-            createResults(null);
-            AddWaitStep("wait for display", 5);
+            createResults();
+            waitForDisplay();
+
+            AddAssert("top score selected", () => this.ChildrenOfType<ScorePanel>().OrderByDescending(p => p.Score.TotalScore).First().State == PanelState.Expanded);
         }
 
         [Test]
-        public void TestShowResultsNullScoreWithDelay()
+        public void TestShowUserScoreWithDelay()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(3000, userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddAssert("more than 1 panel displayed", () => this.ChildrenOfType<ScorePanel>().Count() > 1);
+            AddAssert("user score selected", () => this.ChildrenOfType<ScorePanel>().Single(p => p.Score.OnlineScoreID == userScore.OnlineScoreID).State == PanelState.Expanded);
+        }
+
+        [Test]
+        public void TestShowNullUserScoreWithDelay()
         {
             AddStep("bind delayed handler", () => bindHandler(3000));
-            createResults(null);
-            AddUntilStep("wait for rooms to be received", () => roomsReceived);
-            AddWaitStep("wait for display", 5);
+
+            createResults();
+            waitForDisplay();
+
+            AddAssert("top score selected", () => this.ChildrenOfType<ScorePanel>().OrderByDescending(p => p.Score.TotalScore).First().State == PanelState.Expanded);
         }
 
-        private void createResults(ScoreInfo score)
+        [Test]
+        public void TestFetchWhenScrolledToTheRight()
+        {
+            createResults();
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            for (int i = 0; i < 2; i++)
+            {
+                int beforePanelCount = 0;
+
+                AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
+                AddStep("scroll to right", () => resultsScreen.ScorePanelList.ChildrenOfType<OsuScrollContainer>().Single().ScrollToEnd(false));
+
+                AddAssert("right loading spinner shown", () => resultsScreen.RightSpinner.State.Value == Visibility.Visible);
+                waitForDisplay();
+
+                AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
+                AddAssert("right loading spinner hidden", () => resultsScreen.RightSpinner.State.Value == Visibility.Hidden);
+            }
+        }
+
+        [Test]
+        public void TestFetchWhenScrolledToTheLeft()
+        {
+            ScoreInfo userScore = null;
+
+            AddStep("bind user score info handler", () =>
+            {
+                userScore = new TestScoreInfo(new OsuRuleset().RulesetInfo) { OnlineScoreID = currentScoreId++ };
+                bindHandler(userScore: userScore);
+            });
+
+            createResults(() => userScore);
+            waitForDisplay();
+
+            AddStep("bind delayed handler", () => bindHandler(3000));
+
+            for (int i = 0; i < 2; i++)
+            {
+                int beforePanelCount = 0;
+
+                AddStep("get panel count", () => beforePanelCount = this.ChildrenOfType<ScorePanel>().Count());
+                AddStep("scroll to left", () => resultsScreen.ScorePanelList.ChildrenOfType<OsuScrollContainer>().Single().ScrollToStart(false));
+
+                AddAssert("left loading spinner shown", () => resultsScreen.LeftSpinner.State.Value == Visibility.Visible);
+                waitForDisplay();
+
+                AddAssert($"count increased by {scores_per_result}", () => this.ChildrenOfType<ScorePanel>().Count() == beforePanelCount + scores_per_result);
+                AddAssert("left loading spinner hidden", () => resultsScreen.LeftSpinner.State.Value == Visibility.Hidden);
+            }
+        }
+
+        private void createResults(Func<ScoreInfo> getScore = null)
         {
             AddStep("load results", () =>
             {
-                LoadScreen(new TimeshiftResultsScreen(score, 1, new PlaylistItem
+                LoadScreen(resultsScreen = new TestResultsScreen(getScore?.Invoke(), 1, new PlaylistItem
                 {
                     Beatmap = { Value = new TestBeatmap(new OsuRuleset().RulesetInfo).BeatmapInfo },
                     Ruleset = { Value = new OsuRuleset().RulesetInfo }
@@ -63,62 +163,214 @@ namespace osu.Game.Tests.Visual.Multiplayer
             });
         }
 
-        private void bindHandler(double delay = 0)
+        private void waitForDisplay()
         {
-            var roomScores = new List<RoomScore>();
+            AddUntilStep("wait for request to complete", () => requestComplete);
+            AddWaitStep("wait for display", 5);
+        }
 
-            for (int i = 0; i < 10; i++)
+        private void bindHandler(double delay = 0, ScoreInfo userScore = null, bool failRequests = false) => ((DummyAPIAccess)API).HandleRequest = request =>
+        {
+            requestComplete = false;
+
+            if (failRequests)
             {
-                roomScores.Add(new RoomScore
+                triggerFail(request, delay);
+                return;
+            }
+
+            switch (request)
+            {
+                case ShowPlaylistUserScoreRequest s:
+                    if (userScore == null)
+                        triggerFail(s, delay);
+                    else
+                        triggerSuccess(s, createUserResponse(userScore), delay);
+                    break;
+
+                case IndexPlaylistScoresRequest i:
+                    triggerSuccess(i, createIndexResponse(i), delay);
+                    break;
+            }
+        };
+
+        private void triggerSuccess<T>(APIRequest<T> req, T result, double delay)
+            where T : class
+        {
+            if (delay == 0)
+                success();
+            else
+            {
+                Task.Run(async () =>
                 {
-                    ID = i,
-                    Accuracy = 0.9 - 0.01 * i,
-                    EndedAt = DateTimeOffset.Now.Subtract(TimeSpan.FromHours(i)),
+                    await Task.Delay(TimeSpan.FromMilliseconds(delay));
+                    Schedule(success);
+                });
+            }
+
+            void success()
+            {
+                requestComplete = true;
+                req.TriggerSuccess(result);
+            }
+        }
+
+        private void triggerFail(APIRequest req, double delay)
+        {
+            if (delay == 0)
+                fail();
+            else
+            {
+                Task.Run(async () =>
+                {
+                    await Task.Delay(TimeSpan.FromMilliseconds(delay));
+                    Schedule(fail);
+                });
+            }
+
+            void fail()
+            {
+                requestComplete = true;
+                req.TriggerFailure(new WebException("Failed."));
+            }
+        }
+
+        private MultiplayerScore createUserResponse([NotNull] ScoreInfo userScore)
+        {
+            var multiplayerUserScore = new MultiplayerScore
+            {
+                ID = (int)(userScore.OnlineScoreID ?? currentScoreId++),
+                Accuracy = userScore.Accuracy,
+                EndedAt = userScore.Date,
+                Passed = userScore.Passed,
+                Rank = userScore.Rank,
+                Position = 200,
+                MaxCombo = userScore.MaxCombo,
+                TotalScore = userScore.TotalScore,
+                User = userScore.User,
+                Statistics = userScore.Statistics,
+                ScoresAround = new MultiplayerScoresAround
+                {
+                    Higher = new MultiplayerScores(),
+                    Lower = new MultiplayerScores()
+                }
+            };
+
+            for (int i = 1; i <= scores_per_result; i++)
+            {
+                multiplayerUserScore.ScoresAround.Lower.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = userScore.Accuracy,
+                    EndedAt = userScore.Date,
                     Passed = true,
-                    Rank = ScoreRank.B,
-                    MaxCombo = 999,
-                    TotalScore = 999999 - i * 1000,
+                    Rank = userScore.Rank,
+                    MaxCombo = userScore.MaxCombo,
+                    TotalScore = userScore.TotalScore - i,
                     User = new User
                     {
                         Id = 2,
                         Username = $"peppy{i}",
                         CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
                     },
-                    Statistics =
+                    Statistics = userScore.Statistics
+                });
+
+                multiplayerUserScore.ScoresAround.Higher.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = userScore.Accuracy,
+                    EndedAt = userScore.Date,
+                    Passed = true,
+                    Rank = userScore.Rank,
+                    MaxCombo = userScore.MaxCombo,
+                    TotalScore = userScore.TotalScore + i,
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = userScore.Statistics
+                });
+            }
+
+            addCursor(multiplayerUserScore.ScoresAround.Lower);
+            addCursor(multiplayerUserScore.ScoresAround.Higher);
+
+            return multiplayerUserScore;
+        }
+
+        private IndexedMultiplayerScores createIndexResponse(IndexPlaylistScoresRequest req)
+        {
+            var result = new IndexedMultiplayerScores();
+
+            long startTotalScore = req.Cursor?.Properties["total_score"].ToObject<long>() ?? 1000000;
+            string sort = req.IndexParams?.Properties["sort"].ToObject<string>() ?? "score_desc";
+
+            for (int i = 1; i <= scores_per_result; i++)
+            {
+                result.Scores.Add(new MultiplayerScore
+                {
+                    ID = currentScoreId++,
+                    Accuracy = 1,
+                    EndedAt = DateTimeOffset.Now,
+                    Passed = true,
+                    Rank = ScoreRank.X,
+                    MaxCombo = 1000,
+                    TotalScore = startTotalScore + (sort == "score_asc" ? i : -i),
+                    User = new User
+                    {
+                        Id = 2,
+                        Username = $"peppy{i}",
+                        CoverUrl = "https://osu.ppy.sh/images/headers/profile-covers/c3.jpg",
+                    },
+                    Statistics = new Dictionary<HitResult, int>
                     {
                         { HitResult.Miss, 1 },
                         { HitResult.Meh, 50 },
                         { HitResult.Good, 100 },
-                        { HitResult.Great, 300 },
+                        { HitResult.Great, 300 }
                     }
                 });
             }
 
-            ((DummyAPIAccess)API).HandleRequest = request =>
+            addCursor(result);
+
+            return result;
+        }
+
+        private void addCursor(MultiplayerScores scores)
+        {
+            scores.Cursor = new Cursor
             {
-                switch (request)
+                Properties = new Dictionary<string, JToken>
                 {
-                    case GetRoomPlaylistScoresRequest r:
-                        if (delay == 0)
-                            success();
-                        else
-                        {
-                            Task.Run(async () =>
-                            {
-                                await Task.Delay(TimeSpan.FromMilliseconds(delay));
-                                Schedule(success);
-                            });
-                        }
+                    { "total_score", JToken.FromObject(scores.Scores[^1].TotalScore) },
+                    { "score_id", JToken.FromObject(scores.Scores[^1].ID) },
+                }
+            };
 
-                        void success()
-                        {
-                            r.TriggerSuccess(new RoomPlaylistScores { Scores = roomScores });
-                            roomsReceived = true;
-                        }
-
-                        break;
+            scores.Params = new IndexScoresParams
+            {
+                Properties = new Dictionary<string, JToken>
+                {
+                    { "sort", JToken.FromObject(scores.Scores[^1].TotalScore > scores.Scores[^2].TotalScore ? "score_asc" : "score_desc") }
                 }
             };
         }
+
+        private class TestResultsScreen : TimeshiftResultsScreen
+        {
+            public new LoadingSpinner LeftSpinner => base.LeftSpinner;
+            public new LoadingSpinner CentreSpinner => base.CentreSpinner;
+            public new LoadingSpinner RightSpinner => base.RightSpinner;
+            public new ScorePanelList ScorePanelList => base.ScorePanelList;
+
+            public TestResultsScreen(ScoreInfo score, int roomId, PlaylistItem playlistItem, bool allowRetry = true)
+                : base(score, roomId, playlistItem, allowRetry)
+            {
+            }
+        }
     }
 }