Add grouping of visual tests

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

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

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

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.GameTypes;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Screens.Multi.Match.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchHeader : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Header)
+        };
+
+        public TestCaseMatchHeader()
+        {
+            Room.Playlist.Add(new PlaylistItem
+            {
+                Beatmap = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata
+                    {
+                        Title = "Title",
+                        Artist = "Artist",
+                        AuthorString = "Author",
+                    },
+                    Version = "Version",
+                    Ruleset = new OsuRuleset().RulesetInfo
+                },
+                RequiredMods =
+                {
+                    new OsuModDoubleTime(),
+                    new OsuModNoFail(),
+                    new OsuModRelax(),
+                }
+            });
+
+            Room.Type.Value = new GameTypeTimeshift();
+
+            Child = new Header();
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Screens.Multi.Match.Components;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchHostInfo : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(HostInfo)
+        };
+
+        private readonly Bindable<User> host = new Bindable<User>(new User { Username = "SomeHost" });
+
+        public TestCaseMatchHostInfo()
+        {
+            HostInfo hostInfo;
+
+            Child = hostInfo = new HostInfo
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre
+            };
+
+            hostInfo.Host.BindTo(host);
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.RoomStatuses;
+using osu.Game.Rulesets;
+using osu.Game.Screens.Multi.Match.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMatchInfo : MultiplayerTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Info),
+            typeof(HeaderButton),
+            typeof(ReadyButton),
+            typeof(ViewBeatmapButton)
+        };
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            Add(new Info());
+
+            AddStep(@"set name", () => Room.Name.Value = @"Room Name?");
+            AddStep(@"set availability", () => Room.Availability.Value = RoomAvailability.FriendsOnly);
+            AddStep(@"set status", () => Room.Status.Value = new RoomStatusPlaying());
+            AddStep(@"set beatmap", () =>
+            {
+                Room.Playlist.Clear();
+                Room.Playlist.Add(new PlaylistItem
+                {
+                    Beatmap = new BeatmapInfo
+                    {
+                        StarDifficulty = 2.4,
+                        Ruleset = rulesets.GetRuleset(0),
+                        Metadata = new BeatmapMetadata
+                        {
+                            Title = @"My Song",
+                            Artist = @"VisualTests",
+                            AuthorString = @"osu!lazer",
+                        },
+                    }
+                });
+            });
+
+            AddStep(@"change name", () => Room.Name.Value = @"Room Name!");
+            AddStep(@"change availability", () => Room.Availability.Value = RoomAvailability.InviteOnly);
+            AddStep(@"change status", () => Room.Status.Value = new RoomStatusOpen());
+            AddStep(@"null beatmap", () => Room.Playlist.Clear());
+            AddStep(@"change beatmap", () =>
+            {
+                Room.Playlist.Clear();
+                Room.Playlist.Add(new PlaylistItem
+                {
+                    Beatmap = new BeatmapInfo
+                    {
+                        StarDifficulty = 4.2,
+                        Ruleset = rulesets.GetRuleset(3),
+                        Metadata = new BeatmapMetadata
+                        {
+                            Title = @"Your Song",
+                            Artist = @"Tester",
+                            AuthorString = @"Someone",
+                        },
+                    }
+                });
+            });
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Online.API;
+using osu.Game.Screens.Multi.Match.Components;
+using osu.Game.Users;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseMatchLeaderboard : MultiplayerTestCase
+    {
+        public TestCaseMatchLeaderboard()
+        {
+            Room.RoomID.Value = 3;
+
+            Add(new MatchLeaderboard
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Size = new Vector2(550f, 450f),
+                Scope = MatchLeaderboardScope.Overall,
+            });
+        }
+
+        [Resolved]
+        private IAPIProvider api { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            var req = new GetRoomScoresRequest();
+            req.Success += v => { };
+            req.Failure += _ => { };
+
+            api.Queue(req);
+        }
+
+        private class GetRoomScoresRequest : APIRequest<List<RoomScore>>
+        {
+            protected override string Target => "rooms/3/leaderboard";
+        }
+
+        private class RoomScore
+        {
+            [JsonProperty("user")]
+            public User User { get; set; }
+
+            [JsonProperty("accuracy")]
+            public double Accuracy { get; set; }
+
+            [JsonProperty("total_score")]
+            public int TotalScore { get; set; }
+
+            [JsonProperty("pp")]
+            public double PP { get; set; }
+
+            [JsonProperty("attempts")]
+            public int TotalAttempts { get; set; }
+
+            [JsonProperty("completed")]
+            public int CompletedAttempts { get; set; }
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Screens.Multi.Match.Components;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMatchParticipants : MultiplayerTestCase
+    {
+        public TestCaseMatchParticipants()
+        {
+            Add(new Participants { RelativeSizeAxes = Axes.Both });
+
+            AddStep(@"set max to null", () => Room.MaxParticipants.Value = null);
+            AddStep(@"set users", () => Room.Participants.Value = new[]
+            {
+                new User
+                {
+                    Username = @"Feppla",
+                    Id = 4271601,
+                    Country = new Country { FlagName = @"SE" },
+                    CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c2.jpg",
+                    IsSupporter = true,
+                },
+                new User
+                {
+                    Username = @"Xilver",
+                    Id = 3099689,
+                    Country = new Country { FlagName = @"IL" },
+                    CoverUrl = @"https://osu.ppy.sh/images/headers/profile-covers/c2.jpg",
+                    IsSupporter = true,
+                },
+                new User
+                {
+                    Username = @"Wucki",
+                    Id = 5287410,
+                    Country = new Country { FlagName = @"FI" },
+                    CoverUrl = @"https://assets.ppy.sh/user-profile-covers/5287410/5cfeaa9dd41cbce038ecdc9d781396ed4b0108089170bf7f50492ef8eadeb368.jpeg",
+                    IsSupporter = true,
+                },
+            });
+
+            AddStep(@"set max", () => Room.MaxParticipants.Value = 10);
+            AddStep(@"clear users", () => Room.Participants.Value = new User[] { });
+            AddStep(@"set max to null", () => Room.MaxParticipants.Value = null);
+        }
+    }
+}

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

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

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

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

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

@@ -0,0 +1,44 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Screens;
+using osu.Game.Screens;
+using osu.Game.Screens.Multi;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMultiHeader : OsuTestCase
+    {
+        public TestCaseMultiHeader()
+        {
+            int index = 0;
+
+            ScreenStack screenStack = new ScreenStack(new TestMultiplayerSubScreen(index)) { RelativeSizeAxes = Axes.Both };
+
+            Children = new Drawable[]
+            {
+                screenStack,
+                new Header(screenStack)
+            };
+
+            AddStep("push multi screen", () => screenStack.CurrentScreen.Push(new TestMultiplayerSubScreen(++index)));
+        }
+
+        private class TestMultiplayerSubScreen : OsuScreen, IMultiplayerSubScreen
+        {
+            private readonly int index;
+
+            public string ShortTitle => $"Screen {index}";
+
+            public TestMultiplayerSubScreen(int index)
+            {
+                this.index = index;
+            }
+
+            public override string ToString() => ShortTitle;
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Screens.Multi.Lounge;
+using osu.Game.Screens.Multi.Lounge.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    [TestFixture]
+    public class TestCaseMultiScreen : ScreenTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(Screens.Multi.Multiplayer),
+            typeof(LoungeSubScreen),
+            typeof(FilterControl)
+        };
+
+        public TestCaseMultiScreen()
+        {
+            Screens.Multi.Multiplayer multi = new Screens.Multi.Multiplayer();
+
+            AddStep(@"show", () => LoadScreen(multi));
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Online.Multiplayer;
+using osu.Game.Online.Multiplayer.RoomStatuses;
+using osu.Game.Screens.Multi.Lounge.Components;
+
+namespace osu.Game.Tests.Visual.Multiplayer
+{
+    public class TestCaseRoomStatus : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(RoomStatusEnded),
+            typeof(RoomStatusOpen),
+            typeof(RoomStatusPlaying)
+        };
+
+        public TestCaseRoomStatus()
+        {
+            Child = new FillFlowContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Width = 0.5f,
+                Children = new Drawable[]
+                {
+                    new DrawableRoom(new Room
+                    {
+                        Name = { Value = "Room 1" },
+                        Status = { Value = new RoomStatusOpen() }
+                    }),
+                    new DrawableRoom(new Room
+                    {
+                        Name = { Value = "Room 2" },
+                        Status = { Value = new RoomStatusPlaying() }
+                    }),
+                    new DrawableRoom(new Room
+                    {
+                        Name = { Value = "Room 3" },
+                        Status = { Value = new RoomStatusEnded() }
+                    }),
+                }
+            };
+        }
+    }
+}