Merge branch 'master' into rankings-overlay-refactor

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

@@ -7,7 +7,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
@@ -44,7 +43,7 @@ namespace osu.Game.Tests.Visual.Editor
                     RelativeSizeAxes = Axes.Both,
                     Colour = Color4.SlateGray
                 },
-                new TestDistanceSnapGrid(new HitObject(), grid_position)
+                new TestDistanceSnapGrid()
             };
         });
 
@@ -73,7 +72,7 @@ namespace osu.Game.Tests.Visual.Editor
                         RelativeSizeAxes = Axes.Both,
                         Colour = Color4.SlateGray
                     },
-                    new TestDistanceSnapGrid(new HitObject(), grid_position, new HitObject { StartTime = 100 })
+                    new TestDistanceSnapGrid(100)
                 };
             });
         }
@@ -82,68 +81,68 @@ namespace osu.Game.Tests.Visual.Editor
         {
             public new float DistanceSpacing => base.DistanceSpacing;
 
-            public TestDistanceSnapGrid(HitObject hitObject, Vector2 centrePosition, HitObject nextHitObject = null)
-                : base(hitObject, nextHitObject, centrePosition)
+            public TestDistanceSnapGrid(double? endTime = null)
+                : base(grid_position, 0, endTime)
             {
             }
 
-            protected override void CreateContent(Vector2 centrePosition)
+            protected override void CreateContent(Vector2 startPosition)
             {
                 AddInternal(new Circle
                 {
                     Origin = Anchor.Centre,
                     Size = new Vector2(5),
-                    Position = centrePosition
+                    Position = startPosition
                 });
 
                 int beatIndex = 0;
 
-                for (float s = centrePosition.X + DistanceSpacing; s <= DrawWidth && beatIndex < MaxIntervals; s += DistanceSpacing, beatIndex++)
+                for (float s = startPosition.X + DistanceSpacing; s <= DrawWidth && beatIndex < MaxIntervals; s += DistanceSpacing, beatIndex++)
                 {
                     AddInternal(new Circle
                     {
                         Origin = Anchor.Centre,
                         Size = new Vector2(5, 10),
-                        Position = new Vector2(s, centrePosition.Y),
+                        Position = new Vector2(s, startPosition.Y),
                         Colour = GetColourForBeatIndex(beatIndex)
                     });
                 }
 
                 beatIndex = 0;
 
-                for (float s = centrePosition.X - DistanceSpacing; s >= 0 && beatIndex < MaxIntervals; s -= DistanceSpacing, beatIndex++)
+                for (float s = startPosition.X - DistanceSpacing; s >= 0 && beatIndex < MaxIntervals; s -= DistanceSpacing, beatIndex++)
                 {
                     AddInternal(new Circle
                     {
                         Origin = Anchor.Centre,
                         Size = new Vector2(5, 10),
-                        Position = new Vector2(s, centrePosition.Y),
+                        Position = new Vector2(s, startPosition.Y),
                         Colour = GetColourForBeatIndex(beatIndex)
                     });
                 }
 
                 beatIndex = 0;
 
-                for (float s = centrePosition.Y + DistanceSpacing; s <= DrawHeight && beatIndex < MaxIntervals; s += DistanceSpacing, beatIndex++)
+                for (float s = startPosition.Y + DistanceSpacing; s <= DrawHeight && beatIndex < MaxIntervals; s += DistanceSpacing, beatIndex++)
                 {
                     AddInternal(new Circle
                     {
                         Origin = Anchor.Centre,
                         Size = new Vector2(10, 5),
-                        Position = new Vector2(centrePosition.X, s),
+                        Position = new Vector2(startPosition.X, s),
                         Colour = GetColourForBeatIndex(beatIndex)
                     });
                 }
 
                 beatIndex = 0;
 
-                for (float s = centrePosition.Y - DistanceSpacing; s >= 0 && beatIndex < MaxIntervals; s -= DistanceSpacing, beatIndex++)
+                for (float s = startPosition.Y - DistanceSpacing; s >= 0 && beatIndex < MaxIntervals; s -= DistanceSpacing, beatIndex++)
                 {
                     AddInternal(new Circle
                     {
                         Origin = Anchor.Centre,
                         Size = new Vector2(10, 5),
-                        Position = new Vector2(centrePosition.X, s),
+                        Position = new Vector2(startPosition.X, s),
                         Colour = GetColourForBeatIndex(beatIndex)
                     });
                 }

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

@@ -13,6 +13,8 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osuTK;
 using osuTK.Graphics;
@@ -25,6 +27,7 @@ namespace osu.Game.Tests.Visual.Editor
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(TimelineArea),
+            typeof(TimelineHitObjectDisplay),
             typeof(Timeline),
             typeof(TimelineButton),
             typeof(CentreMarker)
@@ -35,6 +38,8 @@ namespace osu.Game.Tests.Visual.Editor
         {
             Beatmap.Value = new WaveformTestBeatmap(audio);
 
+            var editorBeatmap = new EditorBeatmap<HitObject>((Beatmap<HitObject>)Beatmap.Value.Beatmap);
+
             Children = new Drawable[]
             {
                 new FillFlowContainer
@@ -50,6 +55,7 @@ namespace osu.Game.Tests.Visual.Editor
                 },
                 new TimelineArea
                 {
+                    Child = new TimelineHitObjectDisplay(editorBeatmap),
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     RelativeSizeAxes = Axes.X,

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

@@ -285,8 +285,6 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         protected class PausePlayer : TestPlayer
         {
-            public new GameplayClockContainer GameplayClockContainer => base.GameplayClockContainer;
-
             public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
 
             public new HUDOverlay HUDOverlay => base.HUDOverlay;

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

@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Platform;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    [HeadlessTest] // we alter unsafe properties on the game host to test inactive window state.
+    public class TestScenePauseWhenInactive : PlayerTestScene
+    {
+        protected new TestPlayer Player => (TestPlayer)base.Player;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
+        {
+            var beatmap = (Beatmap)base.CreateBeatmap(ruleset);
+
+            beatmap.HitObjects.RemoveAll(h => h.StartTime < 30000);
+
+            return beatmap;
+        }
+
+        [Resolved]
+        private GameHost host { get; set; }
+
+        public TestScenePauseWhenInactive()
+            : base(new OsuRuleset())
+        {
+        }
+
+        [Test]
+        public void TestDoesntPauseDuringIntro()
+        {
+            AddStep("set inactive", () => ((Bindable<bool>)host.IsActive).Value = false);
+
+            AddStep("resume player", () => Player.GameplayClockContainer.Start());
+            AddAssert("ensure not paused", () => !Player.GameplayClockContainer.IsPaused.Value);
+            AddUntilStep("wait for pause", () => Player.GameplayClockContainer.IsPaused.Value);
+            AddAssert("time of pause is after gameplay start time", () => Player.GameplayClockContainer.GameplayClock.CurrentTime >= Player.DrawableRuleset.GameplayStartTime);
+        }
+
+        protected override Player CreatePlayer(Ruleset ruleset) => new TestPlayer(true, true, true);
+    }
+}

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

@@ -57,8 +57,8 @@ namespace osu.Game.Tests.Visual.Gameplay
             beforeLoadAction?.Invoke();
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
 
-            foreach (var mod in Mods.Value.OfType<IApplicableToClock>())
-                mod.ApplyToClock(Beatmap.Value.Track);
+            foreach (var mod in Mods.Value.OfType<IApplicableToTrack>())
+                mod.ApplyToTrack(Beatmap.Value.Track);
 
             InputManager.Child = container = new TestPlayerLoaderContainer(
                 loader = new TestPlayerLoader(() =>

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

@@ -0,0 +1,193 @@
+// 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;
+using osu.Framework.Graphics.Lines;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneSliderPath : OsuTestScene
+    {
+        private readonly SmoothPath drawablePath;
+        private SliderPath path;
+
+        public TestSceneSliderPath()
+        {
+            Child = drawablePath = new SmoothPath
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
+        }
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            path = new SliderPath();
+        });
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (path != null)
+            {
+                List<Vector2> vertices = new List<Vector2>();
+                path.GetPathToProgress(vertices, 0, 1);
+
+                drawablePath.Vertices = vertices;
+            }
+        }
+
+        [Test]
+        public void TestEmptyPath()
+        {
+        }
+
+        [TestCase(PathType.Linear)]
+        [TestCase(PathType.Bezier)]
+        [TestCase(PathType.Catmull)]
+        [TestCase(PathType.PerfectCurve)]
+        public void TestSingleSegment(PathType type)
+            => AddStep("create path", () => path.ControlPoints.AddRange(createSegment(type, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+
+        [TestCase(PathType.Linear)]
+        [TestCase(PathType.Bezier)]
+        [TestCase(PathType.Catmull)]
+        [TestCase(PathType.PerfectCurve)]
+        public void TestMultipleSegment(PathType type)
+        {
+            AddStep("create path", () =>
+            {
+                path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero));
+                path.ControlPoints.AddRange(createSegment(type, new Vector2(0, 100), new Vector2(100), Vector2.Zero));
+            });
+        }
+
+        [Test]
+        public void TestAddControlPoint()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100))));
+            AddStep("add point", () => path.ControlPoints.Add(new PathControlPoint { Position = { Value = new Vector2(100) } }));
+        }
+
+        [Test]
+        public void TestInsertControlPoint()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(100))));
+            AddStep("insert point", () => path.ControlPoints.Insert(1, new PathControlPoint { Position = { Value = new Vector2(0, 100) } }));
+        }
+
+        [Test]
+        public void TestRemoveControlPoint()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("remove second point", () => path.ControlPoints.RemoveAt(1));
+        }
+
+        [Test]
+        public void TestChangePathType()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("change type to bezier", () => path.ControlPoints[0].Type.Value = PathType.Bezier);
+        }
+
+        [Test]
+        public void TestAddSegmentByChangingType()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100), new Vector2(100, 0))));
+            AddStep("change second point type to bezier", () => path.ControlPoints[1].Type.Value = PathType.Bezier);
+        }
+
+        [Test]
+        public void TestRemoveSegmentByChangingType()
+        {
+            AddStep("create path", () =>
+            {
+                path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100), new Vector2(100, 0)));
+                path.ControlPoints[1].Type.Value = PathType.Bezier;
+            });
+
+            AddStep("change second point type to null", () => path.ControlPoints[1].Type.Value = null);
+        }
+
+        [Test]
+        public void TestRemoveSegmentByRemovingControlPoint()
+        {
+            AddStep("create path", () =>
+            {
+                path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100), new Vector2(100, 0)));
+                path.ControlPoints[1].Type.Value = PathType.Bezier;
+            });
+
+            AddStep("remove second point", () => path.ControlPoints.RemoveAt(1));
+        }
+
+        [TestCase(2)]
+        [TestCase(4)]
+        public void TestPerfectCurveFallbackScenarios(int points)
+        {
+            AddStep("create path", () =>
+            {
+                switch (points)
+                {
+                    case 2:
+                        path.ControlPoints.AddRange(createSegment(PathType.PerfectCurve, Vector2.Zero, new Vector2(0, 100)));
+                        break;
+
+                    case 4:
+                        path.ControlPoints.AddRange(createSegment(PathType.PerfectCurve, Vector2.Zero, new Vector2(0, 100), new Vector2(100), new Vector2(100, 0)));
+                        break;
+                }
+            });
+        }
+
+        [Test]
+        public void TestLengthenLastSegment()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("lengthen last segment", () => path.ExpectedDistance.Value = 300);
+        }
+
+        [Test]
+        public void TestShortenLastSegment()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("shorten last segment", () => path.ExpectedDistance.Value = 150);
+        }
+
+        [Test]
+        public void TestShortenFirstSegment()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("shorten first segment", () => path.ExpectedDistance.Value = 50);
+        }
+
+        [Test]
+        public void TestShortenToZeroLength()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("shorten to 0 length", () => path.ExpectedDistance.Value = 0);
+        }
+
+        [Test]
+        public void TestShortenToNegativeLength()
+        {
+            AddStep("create path", () => path.ControlPoints.AddRange(createSegment(PathType.Linear, Vector2.Zero, new Vector2(0, 100), new Vector2(100))));
+            AddStep("shorten to -10 length", () => path.ExpectedDistance.Value = -10);
+        }
+
+        private List<PathControlPoint> createSegment(PathType type, params Vector2[] controlPoints)
+        {
+            var points = controlPoints.Select(p => new PathControlPoint { Position = { Value = p } }).ToList();
+            points[0].Type.Value = type;
+            return points;
+        }
+    }
+}

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

@@ -0,0 +1,65 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Configuration;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Settings
+{
+    [TestFixture]
+    public class TestSceneSettingsSource : OsuTestScene
+    {
+        public TestSceneSettingsSource()
+        {
+            Children = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(20),
+                    Width = 0.5f,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Padding = new MarginPadding(50),
+                    ChildrenEnumerable = new TestTargetClass().CreateSettingsControls()
+                },
+            };
+        }
+
+        private class TestTargetClass
+        {
+            [SettingSource("Sample bool", "Clicking this changes a setting")]
+            public BindableBool TickBindable { get; } = new BindableBool();
+
+            [SettingSource("Sample float", "Change something for a mod")]
+            public BindableFloat SliderBindable { get; } = new BindableFloat
+            {
+                MinValue = 0,
+                MaxValue = 10,
+                Default = 5,
+                Value = 7
+            };
+
+            [SettingSource("Sample enum", "Change something for a mod")]
+            public Bindable<TestEnum> EnumBindable { get; } = new Bindable<TestEnum>
+            {
+                Default = TestEnum.Value1,
+                Value = TestEnum.Value2
+            };
+
+            [SettingSource("Sample string", "Change something for a mod")]
+            public Bindable<string> StringBindable { get; } = new Bindable<string>();
+        }
+
+        private enum TestEnum
+        {
+            Value1,
+            Value2
+        }
+    }
+}

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

@@ -95,6 +95,42 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("filter count is 1", () => songSelect.FilterCount == 1);
         }
 
+        [Test]
+        public void TestNoFilterOnSimpleResume()
+        {
+            addRulesetImportStep(0);
+            addRulesetImportStep(0);
+
+            createSongSelect();
+
+            AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
+            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+
+            AddStep("return", () => songSelect.MakeCurrent());
+            AddUntilStep("wait for current", () => songSelect.IsCurrentScreen());
+            AddAssert("filter count is 1", () => songSelect.FilterCount == 1);
+        }
+
+        [Test]
+        public void TestFilterOnResumeAfterChange()
+        {
+            addRulesetImportStep(0);
+            addRulesetImportStep(0);
+
+            AddStep("change convert setting", () => config.Set(OsuSetting.ShowConvertedBeatmaps, false));
+
+            createSongSelect();
+
+            AddStep("push child screen", () => Stack.Push(new TestSceneOsuScreenStack.TestScreen("test child")));
+            AddUntilStep("wait for not current", () => !songSelect.IsCurrentScreen());
+
+            AddStep("change convert setting", () => config.Set(OsuSetting.ShowConvertedBeatmaps, true));
+
+            AddStep("return", () => songSelect.MakeCurrent());
+            AddUntilStep("wait for current", () => songSelect.IsCurrentScreen());
+            AddAssert("filter count is 2", () => songSelect.FilterCount == 2);
+        }
+
         [Test]
         public void TestAudioResuming()
         {

osu.Game.Tests/Visual/TestSceneOsuScreenStack.cs

@@ -42,7 +42,7 @@ namespace osu.Game.Tests.Visual
             AddAssert("Parallax is off", () => stack.ParallaxAmount == 0);
         }
 
-        private class TestScreen : ScreenWithBeatmapBackground
+        public class TestScreen : ScreenWithBeatmapBackground
         {
             private readonly string screenText;
 

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

@@ -0,0 +1,107 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneModSettings : OsuTestScene
+    {
+        private TestModSelectOverlay modSelect;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(modSelect = new TestModSelectOverlay
+            {
+                RelativeSizeAxes = Axes.X,
+                Origin = Anchor.BottomCentre,
+                Anchor = Anchor.BottomCentre,
+            });
+
+            var testMod = new TestModCustomisable1();
+
+            AddStep("open", modSelect.Show);
+            AddAssert("button disabled", () => !modSelect.CustomiseButton.Enabled.Value);
+            AddUntilStep("wait for button load", () => modSelect.ButtonsLoaded);
+            AddStep("select mod", () => modSelect.SelectMod(testMod));
+            AddAssert("button enabled", () => modSelect.CustomiseButton.Enabled.Value);
+            AddStep("open Customisation", () => modSelect.CustomiseButton.Click());
+            AddStep("deselect mod", () => modSelect.SelectMod(testMod));
+            AddAssert("controls hidden", () => modSelect.ModSettingsContainer.Alpha == 0);
+        }
+
+        private class TestModSelectOverlay : ModSelectOverlay
+        {
+            public new Container ModSettingsContainer => base.ModSettingsContainer;
+            public new TriangleButton CustomiseButton => base.CustomiseButton;
+
+            public bool ButtonsLoaded => ModSectionsContainer.Children.All(c => c.ModIconsLoaded);
+
+            public void SelectMod(Mod mod) =>
+                ModSectionsContainer.Children.Single(s => s.ModType == mod.Type)
+                                    .ButtonsContainer.OfType<ModButton>().Single(b => b.Mods.Any(m => m.GetType() == mod.GetType())).SelectNext(1);
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                foreach (var section in ModSectionsContainer)
+                {
+                    if (section.ModType == ModType.Conversion)
+                    {
+                        section.Mods = new Mod[]
+                        {
+                            new TestModCustomisable1(),
+                            new TestModCustomisable2()
+                        };
+                    }
+                    else
+                        section.Mods = Array.Empty<Mod>();
+                }
+            }
+        }
+
+        private class TestModCustomisable1 : TestModCustomisable
+        {
+            public override string Name => "Customisable Mod 1";
+
+            public override string Acronym => "CM1";
+        }
+
+        private class TestModCustomisable2 : TestModCustomisable
+        {
+            public override string Name => "Customisable Mod 2";
+
+            public override string Acronym => "CM2";
+        }
+
+        private abstract class TestModCustomisable : Mod, IApplicableMod
+        {
+            public override double ScoreMultiplier => 1.0;
+
+            public override ModType Type => ModType.Conversion;
+
+            [SettingSource("Sample float", "Change something for a mod")]
+            public BindableFloat SliderBindable { get; } = new BindableFloat
+            {
+                MinValue = 0,
+                MaxValue = 10,
+                Default = 5,
+                Value = 7
+            };
+
+            [SettingSource("Sample bool", "Clicking this changes a setting")]
+            public BindableBool TickBindable { get; } = new BindableBool();
+        }
+    }
+}

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

@@ -1,9 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Dialog;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -11,13 +14,22 @@ namespace osu.Game.Tests.Visual.UserInterface
     [TestFixture]
     public class TestScenePopupDialog : OsuTestScene
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(PopupDialogOkButton),
+            typeof(PopupDialogCancelButton),
+            typeof(PopupDialogButton),
+            typeof(DialogButton),
+        };
+
         public TestScenePopupDialog()
         {
-            Add(new TestPopupDialog
-            {
-                RelativeSizeAxes = Axes.Both,
-                State = { Value = Framework.Graphics.Containers.Visibility.Visible },
-            });
+            AddStep("new popup", () =>
+                Add(new TestPopupDialog
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    State = { Value = Framework.Graphics.Containers.Visibility.Visible },
+                }));
         }
 
         private class TestPopupDialog : PopupDialog