Refactor TestSceneScreenFooter to test entire OsuScreens (#36718)

Part of the `ScreenFooter` refactor, which intends to move the footer
content handling to `OsuScreen`. This commit updates the `ScreenFooter`
test to operate on entire `OsuScreen`s, in order to better test the
entire flow of pushing a screen, and having it create and add its own
content to the footer.

This should be 80-90% identical to the original test case structure
wise, just that instead of manually manipulating the footer with
`SetButtons()`, various screens with the appropriate buttons are being
moved around the screen stack.

Additionally this adds some more tests handling common use cases, as
well as removes `TestLoadOverlayAfterFooterIsDisplayed()`, since as far
as I understand the behaviour described in it doesn't actually happen in
production code. From what I can see, Screens instantiate their overlays
in `load()`, and then register them in `LoadComplete()`. There seems to
be no case where a `ShearedOverlayContainer` is created in the middle of
a screen's lifecycle.

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

@@ -8,9 +8,13 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
 using osu.Game.Screens;
 using osu.Game.Screens.Footer;
 
@@ -23,10 +27,13 @@ namespace osu.Game.Tests.Visual.Navigation
         [Test]
         public void TestFooterButtonsOnScreenTransitions()
         {
-            PushAndConfirm(() => new TestScreenOne());
+            PushAndConfirm(() => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button One" }]
+            });
             AddUntilStep("button one shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button One"));
 
-            PushAndConfirm(() => new TestScreenTwo());
+            PushAndConfirm(() => new TestScreen { CreateButtons = () => [new ScreenFooterButton { Text = "Button Two" }] });
             AddUntilStep("button two shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button Two"));
 
             AddStep("exit screen", () => Game.ScreenStack.Exit());
@@ -40,7 +47,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("footer hidden", () => screenFooter.State.Value, () => Is.EqualTo(Visibility.Hidden));
             AddAssert("old back button shown", () => Game.BackButton.State.Value, () => Is.EqualTo(Visibility.Visible));
 
-            PushAndConfirm(() => new TestScreen(true));
+            PushAndConfirm(() => new TestScreen());
             AddAssert("footer shown", () => screenFooter.State.Value, () => Is.EqualTo(Visibility.Visible));
             AddAssert("old back button hidden", () => Game.BackButton.State.Value, () => Is.EqualTo(Visibility.Hidden));
 
@@ -69,10 +76,16 @@ namespace osu.Game.Tests.Visual.Navigation
             AddAssert("footer hidden", () => screenFooter.State.Value, () => Is.EqualTo(Visibility.Hidden));
             AddAssert("old back button shown", () => Game.BackButton.State.Value, () => Is.EqualTo(Visibility.Visible));
 
-            pushSubScreenAndConfirm(() => screen, () => new TestScreenOne());
+            pushSubScreenAndConfirm(() => screen, () => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button One" }]
+            });
             AddUntilStep("button one shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button One"));
 
-            pushSubScreenAndConfirm(() => screen, () => new TestScreenTwo());
+            pushSubScreenAndConfirm(() => screen, () => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button Two" }]
+            });
             AddUntilStep("button two shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button Two"));
 
             AddStep("exit sub screen", () => screen.ExitSubScreen());
@@ -92,10 +105,16 @@ namespace osu.Game.Tests.Visual.Navigation
             TestScreenWithSubScreen screen = null!;
 
             PushAndConfirm(() => screen = new TestScreenWithSubScreen());
-            pushSubScreenAndConfirm(() => screen, () => new TestScreenOne());
+            pushSubScreenAndConfirm(() => screen, () => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button One" }]
+            });
             AddUntilStep("button one shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button One"));
 
-            PushAndConfirm(() => new TestScreenTwo());
+            PushAndConfirm(() => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button Two" }]
+            });
             AddUntilStep("button two shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button Two"));
 
             AddStep("exit parent screen", () => Game.ScreenStack.Exit());
@@ -111,14 +130,23 @@ namespace osu.Game.Tests.Visual.Navigation
             TestScreenWithSubScreen screen = null!;
 
             PushAndConfirm(() => screen = new TestScreenWithSubScreen());
-            pushSubScreenAndConfirm(() => screen, () => new TestScreenOne());
+            pushSubScreenAndConfirm(() => screen, () => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button One" }]
+            });
             AddUntilStep("button one shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button One"));
 
-            PushAndConfirm(() => new TestScreenOne());
+            PushAndConfirm(() => new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button One" }]
+            });
             AddUntilStep("button one shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button One"));
 
             // Can't use the helper method because the screen never loads
-            AddStep("Push new sub screen", () => screen.PushSubScreen(new TestScreenTwo()));
+            AddStep("Push new sub screen", () => screen.PushSubScreen(new TestScreen
+            {
+                CreateButtons = () => [new ScreenFooterButton { Text = "Button Two" }]
+            }));
             AddWaitStep("wait for potential screen load", 5);
             AddUntilStep("button one still shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button One"));
 
@@ -126,6 +154,83 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("button two shown", () => screenFooter.ChildrenOfType<ScreenFooterButton>().First().Text.ToString(), () => Is.EqualTo("Button Two"));
         }
 
+        /// <summary>
+        /// Tests clicking the back button while an overlay is open.
+        /// </summary>
+        [Test]
+        public void TestBackButtonWhenOverlayOpen()
+        {
+            TestScreen screen = null!;
+
+            PushAndConfirm(() =>
+            {
+                ShearedOverlayContainer overlay = new TestShearedOverlayContainer();
+
+                return screen = new TestScreen
+                {
+                    Overlay = overlay,
+                    CreateButtons = () =>
+                    [
+                        new ScreenFooterButton(overlay)
+                        {
+                            AccentColour = Dependencies.Get<OsuColour>().Orange1,
+                            Icon = FontAwesome.Solid.Toolbox,
+                            Text = "One",
+                        },
+                        new ScreenFooterButton { Text = "Two", Action = () => { } },
+                        new ScreenFooterButton { Text = "Three", Action = () => { } },
+                    ],
+                };
+            });
+
+            AddStep("show overlay", () => screen.Overlay.Show());
+            AddAssert("overlay shown", () => screen.Overlay.State.Value, () => Is.EqualTo(Visibility.Visible));
+
+            AddStep("press back", () => screenFooter.ChildrenOfType<ScreenBackButton>().Single().TriggerClick());
+            AddAssert("overlay hidden", () => screen.Overlay.State.Value, () => Is.EqualTo(Visibility.Hidden));
+            AddAssert("screen still shown", () => screen.IsCurrentScreen(), () => Is.True);
+        }
+
+        /// <summary>
+        /// Tests clicking the back button on an overlay with `BackButtonPressed` being overridden.
+        /// </summary>
+        [Test]
+        public void TestBackButtonWithCustomBackButtonPressed()
+        {
+            TestScreen screen = null!;
+            TestShearedOverlayContainer overlay = null!;
+
+            PushAndConfirm(() =>
+            {
+                return screen = new TestScreen
+                {
+                    Overlay = overlay = new TestShearedOverlayContainer(),
+                    CreateButtons = () =>
+                    [
+                        new ScreenFooterButton(overlay)
+                        {
+                            AccentColour = Dependencies.Get<OsuColour>().Orange1,
+                            Icon = FontAwesome.Solid.Toolbox,
+                            Text = "One",
+                        },
+                        new ScreenFooterButton { Text = "Two", Action = () => { } },
+                        new ScreenFooterButton { Text = "Three", Action = () => { } },
+                    ],
+                };
+            });
+
+            AddStep("show overlay", () => screen.Overlay.Show());
+            AddAssert("overlay shown", () => screen.Overlay.State.Value, () => Is.EqualTo(Visibility.Visible));
+            AddStep("set block count", () => overlay.BackButtonCount = 1);
+
+            AddStep("press back", () => screenFooter.ChildrenOfType<ScreenBackButton>().Single().TriggerClick());
+            AddAssert("overlay still shown", () => screen.Overlay.State.Value, () => Is.EqualTo(Visibility.Visible));
+
+            AddStep("press back again", () => screenFooter.ChildrenOfType<ScreenBackButton>().Single().TriggerClick());
+            AddAssert("overlay hidden", () => screen.Overlay.State.Value, () => Is.EqualTo(Visibility.Hidden));
+            AddAssert("screen still shown", () => screen.IsCurrentScreen(), () => Is.True);
+        }
+
         private void pushSubScreenAndConfirm(Func<TestScreenWithSubScreen> target, Func<Screen> newScreen)
         {
             Screen screen = null!;
@@ -142,39 +247,45 @@ namespace osu.Game.Tests.Visual.Navigation
                                                       && (previousScreen == null || previousScreen.GetChildScreen() == screen));
         }
 
-        private partial class TestScreenOne : OsuScreen
-        {
-            public override bool ShowFooter => true;
-
-            [Cached]
-            private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
-
-            public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => new[]
-            {
-                new ScreenFooterButton { Text = "Button One" },
-            };
-        }
-
-        private partial class TestScreenTwo : OsuScreen
-        {
-            public override bool ShowFooter => true;
-
-            [Cached]
-            private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
-
-            public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => new[]
-            {
-                new ScreenFooterButton { Text = "Button Two" },
-            };
-        }
-
         private partial class TestScreen : OsuScreen
         {
             public override bool ShowFooter { get; }
 
-            public TestScreen(bool footer)
+            public Func<IReadOnlyList<ScreenFooterButton>> CreateButtons = Array.Empty<ScreenFooterButton>;
+
+            public ShearedOverlayContainer Overlay = new TestShearedOverlayContainer();
+
+            private IDisposable? overlayRegistration;
+
+            [Cached]
+            private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+            [Resolved]
+            private IOverlayManager? overlayManager { get; set; }
+
+            public TestScreen(bool showFooter = true)
             {
-                ShowFooter = footer;
+                ShowFooter = showFooter;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                LoadComponent(Overlay);
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                overlayRegistration = overlayManager?.RegisterBlockingOverlay(Overlay);
+            }
+
+            public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => CreateButtons.Invoke();
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+                overlayRegistration?.Dispose();
             }
         }
 
@@ -196,5 +307,66 @@ namespace osu.Game.Tests.Visual.Navigation
 
             public void ExitSubScreen() => SubScreenStack.Exit();
         }
+
+        private partial class TestShearedOverlayContainer : ShearedOverlayContainer
+        {
+            public TestShearedOverlayContainer()
+                : base(OverlayColourScheme.Orange)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Header.Title = "Test overlay";
+                Header.Description = "An overlay that is made purely for testing purposes.";
+            }
+
+            public int BackButtonCount;
+
+            public override bool OnBackButton()
+            {
+                if (BackButtonCount > 0)
+                {
+                    BackButtonCount--;
+                    return true;
+                }
+
+                return false;
+            }
+
+            public override VisibilityContainer CreateFooterContent() => new TestFooterContent();
+
+            public partial class TestFooterContent : VisibilityContainer
+            {
+                [BackgroundDependencyLoader]
+                private void load()
+                {
+                    AutoSizeAxes = Axes.Both;
+
+                    InternalChild = new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Children = new[]
+                        {
+                            new ShearedButton(200) { Text = "Action #1", Action = () => { } },
+                            new ShearedButton(140) { Text = "Action #2", Action = () => { } },
+                        }
+                    };
+                }
+
+                protected override void PopIn()
+                {
+                    this.MoveToY(0, 400, Easing.OutQuint)
+                        .FadeIn(400, Easing.OutQuint);
+                }
+
+                protected override void PopOut()
+                {
+                    this.MoveToY(-20f, 200, Easing.OutQuint)
+                        .FadeOut(200, Easing.OutQuint);
+                }
+            }
+        }
     }
 }

osu.Game.Tests/Visual/SongSelectV2/TestSceneScreenFooter.cs

@@ -1,301 +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 System;
-using System.Linq;
-using NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
-using osu.Game.Graphics;
-using osu.Game.Graphics.UserInterface;
-using osu.Game.Overlays;
-using osu.Game.Overlays.Mods;
-using osu.Game.Screens.Footer;
-using osu.Game.Screens.SelectV2;
-
-namespace osu.Game.Tests.Visual.SongSelectV2
-{
-    public partial class TestSceneScreenFooter : OsuManualInputManagerTestScene
-    {
-        private DependencyProvidingContainer contentContainer = null!;
-        private ScreenFooter screenFooter = null!;
-        private UserModSelectOverlay modOverlay = null!;
-
-        [SetUp]
-        public void SetUp() => Schedule(() =>
-        {
-            screenFooter = new ScreenFooter();
-
-            Child = contentContainer = new DependencyProvidingContainer
-            {
-                RelativeSizeAxes = Axes.Both,
-                CachedDependencies = new (Type, object)[]
-                {
-                    (typeof(ScreenFooter), screenFooter)
-                },
-                Children = new Drawable[]
-                {
-                    modOverlay = new UserModSelectOverlay { ShowPresets = true },
-                    new PopoverContainer
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Depth = float.MinValue,
-                        Child = screenFooter,
-                    },
-                },
-            };
-
-            screenFooter.SetButtons(new ScreenFooterButton[]
-            {
-                new FooterButtonMods(modOverlay) { Current = SelectedMods },
-                new FooterButtonRandom(),
-                new FooterButtonOptions(),
-            });
-        });
-
-        [SetUpSteps]
-        public void SetUpSteps()
-        {
-            AddStep("show footer", () => screenFooter.Show());
-        }
-
-        /// <summary>
-        /// Transition when moving from a screen with no buttons to a screen with buttons.
-        /// </summary>
-        [Test]
-        public void TestButtonsIn()
-        {
-        }
-
-        /// <summary>
-        /// Transition when moving from a screen with buttons to a screen with no buttons.
-        /// </summary>
-        [Test]
-        public void TestButtonsOut()
-        {
-            AddStep("clear buttons", () => screenFooter.SetButtons(Array.Empty<ScreenFooterButton>()));
-        }
-
-        /// <summary>
-        /// Transition when moving from a screen with buttons to a screen with buttons.
-        /// </summary>
-        [Test]
-        public void TestReplaceButtons()
-        {
-            AddStep("replace buttons", () => screenFooter.SetButtons(new[]
-            {
-                new ScreenFooterButton { Text = "One", Action = () => { } },
-                new ScreenFooterButton { Text = "Two", Action = () => { } },
-                new ScreenFooterButton { Text = "Three", Action = () => { } },
-            }));
-        }
-
-        [Test]
-        public void TestExternalOverlayContent()
-        {
-            TestShearedOverlayContainer externalOverlay = null!;
-
-            AddStep("add overlay", () => contentContainer.Add(externalOverlay = new TestShearedOverlayContainer()));
-            AddStep("set buttons", () => screenFooter.SetButtons(new[]
-            {
-                new ScreenFooterButton(externalOverlay)
-                {
-                    AccentColour = Dependencies.Get<OsuColour>().Orange1,
-                    Icon = FontAwesome.Solid.Toolbox,
-                    Text = "One",
-                },
-                new ScreenFooterButton { Text = "Two", Action = () => { } },
-                new ScreenFooterButton { Text = "Three", Action = () => { } },
-            }));
-            AddWaitStep("wait for transition", 3);
-
-            AddStep("show overlay", () => externalOverlay.Show());
-            contentDisplayed();
-            AddUntilStep("other buttons hidden", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.Child.Parent!.Y > 0));
-
-            AddStep("hide overlay", () => externalOverlay.Hide());
-            contentHidden();
-            AddUntilStep("other buttons returned", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
-        }
-
-        [Test]
-        public void TestTemporarilyShowFooter()
-        {
-            TestShearedOverlayContainer externalOverlay = null!;
-
-            AddStep("hide footer", () => screenFooter.Hide());
-            AddStep("remove buttons", () => screenFooter.SetButtons(Array.Empty<ScreenFooterButton>()));
-
-            AddStep("add external overlay", () => contentContainer.Add(externalOverlay = new TestShearedOverlayContainer()));
-            AddStep("show external overlay", () => externalOverlay.Show());
-            AddAssert("footer shown", () => screenFooter.State.Value == Visibility.Visible);
-            contentDisplayed();
-
-            AddStep("hide external overlay", () => externalOverlay.Hide());
-            AddAssert("footer hidden", () => screenFooter.State.Value == Visibility.Hidden);
-            contentHidden();
-
-            AddStep("show footer", () => screenFooter.Show());
-            AddAssert("content still hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
-
-            AddStep("show external overlay", () => externalOverlay.Show());
-            AddAssert("footer still visible", () => screenFooter.State.Value == Visibility.Visible);
-
-            AddStep("hide external overlay", () => externalOverlay.Hide());
-            AddAssert("footer still visible", () => screenFooter.State.Value == Visibility.Visible);
-
-            AddStep("hide footer", () => screenFooter.Hide());
-            AddStep("show external overlay", () => externalOverlay.Show());
-        }
-
-        [Test]
-        public void TestBackButton()
-        {
-            TestShearedOverlayContainer externalOverlay = null!;
-
-            AddStep("hide footer", () => screenFooter.Hide());
-            AddStep("remove buttons", () => screenFooter.SetButtons(Array.Empty<ScreenFooterButton>()));
-
-            AddStep("add external overlay", () => contentContainer.Add(externalOverlay = new TestShearedOverlayContainer()));
-            AddStep("show external overlay", () => externalOverlay.Show());
-            AddAssert("footer shown", () => screenFooter.State.Value == Visibility.Visible);
-
-            AddStep("press back", () => this.ChildrenOfType<ScreenBackButton>().Single().TriggerClick());
-            AddAssert("overlay hidden", () => externalOverlay.State.Value == Visibility.Hidden);
-            AddAssert("footer hidden", () => screenFooter.State.Value == Visibility.Hidden);
-
-            AddStep("show external overlay", () => externalOverlay.Show());
-            AddStep("set block count", () => externalOverlay.BackButtonCount = 1);
-            AddStep("press back", () => this.ChildrenOfType<ScreenBackButton>().Single().TriggerClick());
-            AddAssert("overlay still visible", () => externalOverlay.State.Value == Visibility.Visible);
-            AddAssert("footer still shown", () => screenFooter.State.Value == Visibility.Visible);
-            AddStep("press back again", () => this.ChildrenOfType<ScreenBackButton>().Single().TriggerClick());
-            AddAssert("overlay hidden", () => externalOverlay.State.Value == Visibility.Hidden);
-            AddAssert("footer hidden", () => screenFooter.State.Value == Visibility.Hidden);
-        }
-
-        [Test]
-        public void TestLoadOverlayAfterFooterIsDisplayed()
-        {
-            TestShearedOverlayContainer externalOverlay = null!;
-
-            AddStep("show mod overlay", () => modOverlay.Show());
-            AddUntilStep("mod footer content shown", () => this.ChildrenOfType<ModSelectFooterContent>().SingleOrDefault()?.IsPresent, () => Is.True);
-
-            AddStep("add external overlay", () => contentContainer.Add(externalOverlay = new TestShearedOverlayContainer()));
-            AddUntilStep("wait for load", () => externalOverlay.IsLoaded);
-            AddAssert("mod footer content still shown", () => this.ChildrenOfType<ModSelectFooterContent>().SingleOrDefault()?.IsPresent, () => Is.True);
-            AddAssert("external overlay content not shown", () => this.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent, () => Is.Not.True);
-
-            AddStep("hide mod overlay", () => modOverlay.Hide());
-            AddUntilStep("mod footer content hidden", () => this.ChildrenOfType<ModSelectFooterContent>().SingleOrDefault()?.IsPresent, () => Is.Not.True);
-            AddAssert("external overlay content still not shown", () => this.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent, () => Is.Not.True);
-        }
-
-        [Test]
-        public void TestButtonResizedAfterFooterIsDisplayed()
-        {
-            TestShearedOverlayContainer externalOverlay = null!;
-
-            AddStep("add overlay", () => contentContainer.Add(externalOverlay = new TestShearedOverlayContainer()));
-            AddStep("set buttons", () => screenFooter.SetButtons(new[]
-            {
-                new ScreenFooterButton(externalOverlay)
-                {
-                    AccentColour = Dependencies.Get<OsuColour>().Orange1,
-                    Icon = FontAwesome.Solid.Toolbox,
-                    Text = "One",
-                },
-                new ScreenFooterButton { Text = "Two", Action = () => { } },
-                new ScreenFooterButton { Text = "Three", Action = () => { } },
-            }));
-            AddWaitStep("wait for transition", 3);
-
-            AddStep("show overlay", () => externalOverlay.Show());
-            contentDisplayed();
-            AddUntilStep("other buttons hidden", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.Child.Parent!.Y > 0));
-
-            AddStep("resize active button", () => this.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(240, 300, Easing.OutQuint));
-            AddStep("resize active button back", () => this.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(116, 300, Easing.OutQuint));
-
-            AddStep("hide overlay", () => externalOverlay.Hide());
-            contentHidden();
-            AddUntilStep("other buttons returned", () => screenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
-        }
-
-        private void contentHidden()
-        {
-            AddUntilStep("content hidden from footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
-        }
-
-        private void contentDisplayed()
-        {
-            AddUntilStep("content displayed in footer", () => screenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().Single().IsPresent);
-        }
-
-        private partial class TestShearedOverlayContainer : ShearedOverlayContainer
-        {
-            public TestShearedOverlayContainer()
-                : base(OverlayColourScheme.Orange)
-            {
-            }
-
-            [BackgroundDependencyLoader]
-            private void load()
-            {
-                Header.Title = "Test overlay";
-                Header.Description = "An overlay that is made purely for testing purposes.";
-            }
-
-            public int BackButtonCount;
-
-            public override bool OnBackButton()
-            {
-                if (BackButtonCount > 0)
-                {
-                    BackButtonCount--;
-                    return true;
-                }
-
-                return false;
-            }
-
-            public override VisibilityContainer CreateFooterContent() => new TestFooterContent();
-
-            public partial class TestFooterContent : VisibilityContainer
-            {
-                [BackgroundDependencyLoader]
-                private void load()
-                {
-                    AutoSizeAxes = Axes.Both;
-
-                    InternalChild = new FillFlowContainer
-                    {
-                        AutoSizeAxes = Axes.Both,
-                        Children = new[]
-                        {
-                            new ShearedButton(200) { Text = "Action #1", Action = () => { } },
-                            new ShearedButton(140) { Text = "Action #2", Action = () => { } },
-                        }
-                    };
-                }
-
-                protected override void PopIn()
-                {
-                    this.MoveToY(0, 400, Easing.OutQuint)
-                        .FadeIn(400, Easing.OutQuint);
-                }
-
-                protected override void PopOut()
-                {
-                    this.MoveToY(-20f, 200, Easing.OutQuint)
-                        .FadeOut(200, Easing.OutQuint);
-                }
-            }
-        }
-    }
-}

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

@@ -0,0 +1,365 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Screens;
+using osu.Framework.Testing;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Mods;
+using osu.Game.Screens;
+using osu.Game.Screens.Footer;
+using osu.Game.Screens.SelectV2;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public partial class TestSceneScreenFooter : ScreenTestScene
+    {
+        [Test]
+        public void TestButtonsIn()
+        {
+            AddStep("push empty screen", () => LoadScreen(new TestScreen()));
+            AddStep("push screen", () => LoadScreen(new TestScreen
+            {
+                CreateButtons = () => new[]
+                {
+                    new ScreenFooterButton { Text = "Button 1", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 2", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 3", Action = () => { } },
+                },
+            }));
+        }
+
+        [Test]
+        public void TestButtonsOut()
+        {
+            AddStep("push empty screen", () => LoadScreen(new TestScreen()));
+            AddStep("push screen", () => LoadScreen(new TestScreen
+            {
+                CreateButtons = () => new[]
+                {
+                    new ScreenFooterButton { Text = "Button 1", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 2", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 3", Action = () => { } },
+                },
+            }));
+            AddStep("exit screen", () => Stack.Exit());
+        }
+
+        [Test]
+        public void TestReplaceButtons()
+        {
+            AddStep("push first screen", () => LoadScreen(new TestScreen
+            {
+                CreateButtons = () => new[]
+                {
+                    new ScreenFooterButton { Text = "Button 1", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 2", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 3", Action = () => { } },
+                },
+            }));
+            AddStep("push second screen", () => LoadScreen(new TestScreen
+            {
+                CreateButtons = () => new[]
+                {
+                    new ScreenFooterButton { Text = "Button 4", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 5", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 6", Action = () => { } },
+                },
+            }));
+        }
+
+        [Test]
+        public void TestFooterVisibility()
+        {
+            TestScreen screen = null!;
+            TestScreen screenWithoutFooter = null!;
+
+            AddAssert("footer hidden", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Hidden));
+
+            AddStep("push screen", () => LoadScreen(screen = new TestScreen
+            {
+                CreateButtons = () => new[]
+                {
+                    new ScreenFooterButton { Text = "Button 1", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 2", Action = () => { } },
+                    new ScreenFooterButton { Text = "Button 3", Action = () => { } },
+                },
+            }));
+            AddUntilStep("wait until screen is loaded", () => screen.IsCurrentScreen(), () => Is.True);
+            AddAssert("footer shown", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Visible));
+
+            AddStep("push screen with no footer", () => LoadScreen(screenWithoutFooter = new TestScreen(showFooter: false)));
+            AddUntilStep("wait until screen is loaded", () => screenWithoutFooter.IsCurrentScreen(), () => Is.True);
+            AddAssert("footer hidden", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Hidden));
+
+            AddStep("exit screen", () => Stack.Exit());
+            AddUntilStep("wait until screen is loaded", () => screen.IsCurrentScreen(), () => Is.True);
+            AddAssert("footer shown", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Visible));
+        }
+
+        [Test]
+        public void TestExternalOverlayContent()
+        {
+            TestScreen screen = null!;
+
+            AddStep("push screen", () =>
+            {
+                ShearedOverlayContainer overlay = new TestShearedOverlayContainer();
+
+                LoadScreen(screen = new TestScreen
+                {
+                    Overlay = overlay,
+                    CreateButtons = () => new[]
+                    {
+                        new ScreenFooterButton(overlay)
+                        {
+                            AccentColour = Dependencies.Get<OsuColour>().Orange1,
+                            Icon = FontAwesome.Solid.Toolbox,
+                            Text = "One",
+                        },
+                        new ScreenFooterButton { Text = "Two", Action = () => { } },
+                        new ScreenFooterButton { Text = "Three", Action = () => { } },
+                    },
+                });
+            });
+            AddUntilStep("wait until screen is loaded", () => screen.IsCurrentScreen(), () => Is.True);
+
+            AddStep("show overlay", () => screen.Overlay.Show());
+            contentDisplayed();
+            AddAssert("other buttons hidden", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.Child.Parent!.Y > 0));
+
+            AddStep("hide overlay", () => screen.Overlay.Hide());
+            contentHidden();
+            AddAssert("other buttons returned", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
+        }
+
+        [Test]
+        public void TestTemporarilyShowFooter()
+        {
+            TestScreen screen = null!;
+
+            AddStep("push screen", () => LoadScreen(screen = new TestScreen(showFooter: false)));
+            AddUntilStep("wait until screen is loaded", () => screen.IsCurrentScreen(), () => Is.True);
+            AddAssert("footer hidden", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Hidden));
+
+            AddStep("show overlay", () => screen.Overlay.Show());
+            AddAssert("footer shown", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Visible));
+            contentDisplayed();
+
+            AddStep("hide overlay", () => screen.Overlay.Hide());
+            AddAssert("footer hidden", () => ScreenFooter.State.Value, () => Is.EqualTo(Visibility.Hidden));
+            contentHidden();
+        }
+
+        [Test]
+        public void TestShowOverlayHidesOtherOverlays()
+        {
+            TestScreen screen = null!;
+
+            AddStep("push screen", () =>
+            {
+                ShearedOverlayContainer overlay = new TestShearedOverlayContainer();
+                ModSelectOverlay secondOverlay = new ModSelectOverlay();
+
+                LoadScreen(screen = new TestScreen
+                {
+                    Overlay = overlay,
+                    SecondOverlay = secondOverlay,
+                    CreateButtons = () => new[]
+                    {
+                        new ScreenFooterButton(overlay)
+                        {
+                            AccentColour = Dependencies.Get<OsuColour>().Orange1,
+                            Icon = FontAwesome.Solid.Toolbox,
+                            Text = "One",
+                        },
+                        new FooterButtonMods(secondOverlay),
+                        new ScreenFooterButton { Text = "Two", Action = () => { } },
+                        new ScreenFooterButton { Text = "Three", Action = () => { } },
+                    },
+                });
+            });
+            AddUntilStep("wait until screen is loaded", () => screen.IsCurrentScreen(), () => Is.True);
+
+            AddStep("show mods overlay", () => ScreenFooter.ChildrenOfType<FooterButtonMods>().First().TriggerClick());
+            AddUntilStep("wait until overlay is shown", () => screen.SecondOverlay.State.Value, () => Is.EqualTo(Visibility.Visible));
+            AddAssert("first button still visible", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().First(b => b.Text == "One").Y, () => Is.EqualTo(0));
+
+            AddStep("show test overlay", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().First(b => b.Text == "One").TriggerClick());
+            AddUntilStep("wait until overlay is shown", () => screen.Overlay.State.Value, () => Is.EqualTo(Visibility.Visible));
+            AddAssert("mod overlay is hidden", () => screen.SecondOverlay.State.Value, () => Is.EqualTo(Visibility.Hidden));
+
+            AddStep("hide test overlay", () => screen.Overlay.Hide());
+            contentHidden();
+            AddAssert("other buttons returned", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
+        }
+
+        [Test]
+        public void TestButtonResizedAfterFooterIsDisplayed()
+        {
+            TestScreen screen = null!;
+
+            const float initial_width = 116;
+            const float width_increase = 124;
+
+            float secondButtonX = 0;
+            float overlayContentX = 0;
+
+            AddStep("push screen", () =>
+            {
+                ShearedOverlayContainer overlay = new TestShearedOverlayContainer();
+
+                LoadScreen(screen = new TestScreen
+                {
+                    Overlay = overlay,
+                    CreateButtons = () => new[]
+                    {
+                        new ScreenFooterButton(overlay)
+                        {
+                            AccentColour = Dependencies.Get<OsuColour>().Orange1,
+                            Icon = FontAwesome.Solid.Toolbox,
+                            Text = "One",
+                        },
+                        new ScreenFooterButton { Text = "Two", Action = () => { } },
+                        new ScreenFooterButton { Text = "Three", Action = () => { } },
+                    },
+                });
+            });
+            AddUntilStep("wait until screen is loaded", () => screen.IsCurrentScreen(), () => Is.True);
+            AddStep("save second button position", () => secondButtonX = ScreenFooter.ChildrenOfType<ScreenFooterButton>().ElementAt(1).X);
+
+            AddStep("resize active button", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(initial_width + width_increase, 300, Easing.OutQuint));
+            AddUntilStep("second button moved", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().ElementAt(1).X, () => Is.EqualTo(secondButtonX + width_increase).Within(0.001));
+            AddStep("resize active button back", () => this.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(initial_width, 300, Easing.OutQuint));
+            AddUntilStep("second button moved back", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().ElementAt(1).X, () => Is.EqualTo(secondButtonX).Within(0.001));
+
+            AddStep("show overlay", () => screen.Overlay.Show());
+            contentDisplayed();
+            AddAssert("other buttons hidden", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.Child.Parent!.Y > 0));
+            AddStep("save overlay content position", () => overlayContentX = ScreenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().First().Parent!.Parent!.X);
+
+            AddStep("resize active button", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(initial_width + width_increase, 300, Easing.OutQuint));
+            AddUntilStep("overlay content moved", () => ScreenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().First().Parent!.Parent!.X, () => Is.EqualTo(overlayContentX + width_increase).Within(0.001));
+            AddStep("resize active button back", () => this.ChildrenOfType<ScreenFooterButton>().First().ResizeWidthTo(initial_width, 300, Easing.OutQuint));
+            AddUntilStep("overlay content moved back", () => ScreenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().First().Parent!.Parent!.X, () => Is.EqualTo(overlayContentX).Within(0.001));
+
+            AddStep("hide overlay", () => screen.Overlay.Hide());
+            contentHidden();
+            AddUntilStep("other buttons returned", () => ScreenFooter.ChildrenOfType<ScreenFooterButton>().Skip(1).All(b => b.ChildrenOfType<Container>().First().Y == 0));
+        }
+
+        private void contentHidden()
+        {
+            AddUntilStep("content hidden from footer", () => ScreenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().SingleOrDefault()?.IsPresent != true);
+        }
+
+        private void contentDisplayed()
+        {
+            AddUntilStep("content displayed in footer", () => ScreenFooter.ChildrenOfType<TestShearedOverlayContainer.TestFooterContent>().Single().IsPresent);
+        }
+
+        private partial class TestScreen : OsuScreen
+        {
+            public override bool ShowFooter { get; }
+
+            public Func<IReadOnlyList<ScreenFooterButton>> CreateButtons = Array.Empty<ScreenFooterButton>;
+
+            public ShearedOverlayContainer Overlay = new TestShearedOverlayContainer();
+            public ShearedOverlayContainer SecondOverlay = new TestShearedOverlayContainer();
+
+            private IDisposable? overlayRegistration;
+            private IDisposable? secondOverlayRegistration;
+
+            [Cached]
+            private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+            [Resolved]
+            private IOverlayManager? overlayManager { get; set; }
+
+            public TestScreen(bool showFooter = true)
+            {
+                ShowFooter = showFooter;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                LoadComponent(Overlay);
+                LoadComponent(SecondOverlay);
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                overlayRegistration = overlayManager?.RegisterBlockingOverlay(Overlay);
+                secondOverlayRegistration = overlayManager?.RegisterBlockingOverlay(SecondOverlay);
+            }
+
+            public override IReadOnlyList<ScreenFooterButton> CreateFooterButtons() => CreateButtons.Invoke();
+
+            protected override void Dispose(bool isDisposing)
+            {
+                base.Dispose(isDisposing);
+                overlayRegistration?.Dispose();
+                secondOverlayRegistration?.Dispose();
+            }
+        }
+
+        private partial class TestShearedOverlayContainer : ShearedOverlayContainer
+        {
+            public TestShearedOverlayContainer()
+                : base(OverlayColourScheme.Orange)
+            {
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Header.Title = "Test overlay";
+                Header.Description = "An overlay that is made purely for testing purposes.";
+            }
+
+            public override VisibilityContainer CreateFooterContent() => new TestFooterContent();
+
+            public partial class TestFooterContent : VisibilityContainer
+            {
+                [BackgroundDependencyLoader]
+                private void load()
+                {
+                    AutoSizeAxes = Axes.Both;
+
+                    InternalChild = new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Children = new[]
+                        {
+                            new ShearedButton(200) { Text = "Action #1", Action = () => { } },
+                            new ShearedButton(140) { Text = "Action #2", Action = () => { } },
+                        }
+                    };
+                }
+
+                protected override void PopIn()
+                {
+                    this.MoveToY(0, 400, Easing.OutQuint)
+                        .FadeIn(400, Easing.OutQuint);
+                }
+
+                protected override void PopOut()
+                {
+                    this.MoveToY(-20f, 200, Easing.OutQuint)
+                        .FadeOut(200, Easing.OutQuint);
+                }
+            }
+        }
+    }
+}

osu.Game/OsuGame.cs

@@ -1139,6 +1139,7 @@ namespace osu.Game
                                 },
                                 new PopoverContainer
                                 {
+                                    // Ensure the footer is displayed above any content and/or overlays.
                                     Depth = -1,
                                     RelativeSizeAxes = Axes.Both,
                                     Child = screenStackFooter = new ScreenStackFooter(ScreenStack, backReceptor)

osu.Game/Tests/Visual/ScreenTestScene.cs

@@ -62,7 +62,7 @@ namespace osu.Game.Tests.Visual
                         },
                         screenStackFooter = new ScreenStackFooter(Stack, backReceptor)
                         {
-                            BackButtonPressed = () => Stack.Exit()
+                            BackButtonPressed = BackButtonPressed,
                         }
                     }
                 },
@@ -74,6 +74,8 @@ namespace osu.Game.Tests.Visual
             Stack.ScreenExited += (_, newScreen) => Logger.Log($"{nameof(ScreenTestScene)} screen changed ← {newScreen}");
         }
 
+        protected virtual void BackButtonPressed() => Stack.Exit();
+
         protected void LoadScreen(OsuScreen screen) => Stack.Push(screen);
 
         [SetUpSteps]