Add extensible test scene for beatmap skins fallback instead

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

@@ -0,0 +1,129 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Graphics;
+using osu.Framework.Lists;
+using osu.Framework.Testing;
+using osu.Framework.Timing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Extensions;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Skinning.Legacy;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Skinning;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneBeatmapSkinFallbacks : OsuPlayerTestScene
+    {
+        private ISkin currentBeatmapSkin;
+
+        [Resolved]
+        private SkinManager skinManager { get; set; }
+
+        [Cached]
+        private ScoreProcessor scoreProcessor = new ScoreProcessor();
+
+        [Cached(typeof(HealthProcessor))]
+        private HealthProcessor healthProcessor = new DrainingHealthProcessor(0);
+
+        protected override bool HasCustomSteps => true;
+
+        [Test]
+        public void TestEmptyDefaultBeatmapSkinFallsBack()
+        {
+            CreateSkinTest(DefaultLegacySkin.Info, () => new TestWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo)).Skin);
+            AssertComponentsFromExpectedSource(SkinnableTarget.MainHUDComponents, () => skinManager.CurrentSkin.Value);
+        }
+
+        protected void CreateSkinTest(SkinInfo gameCurrentSkin, Func<ISkin> beatmapSkin)
+        {
+            CreateTest(() =>
+            {
+                AddStep("setup skins", () =>
+                {
+                    skinManager.CurrentSkinInfo.Value = gameCurrentSkin;
+                    currentBeatmapSkin = beatmapSkin();
+                });
+            });
+        }
+
+        protected void AssertComponentsFromExpectedSource(SkinnableTarget target, Func<ISkin> expectedSource)
+        {
+            AddAssert($"{target} from {expectedSource.GetType().Name}", () =>
+            {
+                var expectedComponentsContainer = (SkinnableTargetComponentsContainer)expectedSource().GetDrawableComponent(new SkinnableTargetComponent(target));
+
+                Add(expectedComponentsContainer);
+                expectedComponentsContainer?.UpdateSubTree();
+                var expectedInfo = expectedComponentsContainer?.CreateSkinnableInfo();
+                Remove(expectedComponentsContainer);
+
+                var actualInfo = Player.ChildrenOfType<SkinnableTargetContainer>().First(s => s.Target == target)
+                                       .ChildrenOfType<SkinnableTargetComponentsContainer>().Single().CreateSkinnableInfo();
+
+                return almostEqual(actualInfo, expectedInfo, 2f);
+            });
+
+            static bool almostEqual(SkinnableInfo info, SkinnableInfo other, float positionTolerance) =>
+                other != null
+                && info.Anchor == other.Anchor
+                && info.Origin == other.Origin
+                && Precision.AlmostEquals(info.Position, other.Position, positionTolerance)
+                && info.Children.SequenceEqual(other.Children, new FuncEqualityComparer<SkinnableInfo>((s1, s2) => almostEqual(s1, s2, positionTolerance)));
+        }
+
+        protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
+            => new CustomSkinWorkingBeatmap(beatmap, storyboard, Clock, Audio, currentBeatmapSkin);
+
+        protected override Ruleset CreatePlayerRuleset() => new TestOsuRuleset();
+
+        private class CustomSkinWorkingBeatmap : ClockBackedTestWorkingBeatmap
+        {
+            private readonly ISkin beatmapSkin;
+
+            public CustomSkinWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard, IFrameBasedClock referenceClock, AudioManager audio, ISkin beatmapSkin)
+                : base(beatmap, storyboard, referenceClock, audio)
+            {
+                this.beatmapSkin = beatmapSkin;
+            }
+
+            protected override ISkin GetSkin() => beatmapSkin;
+        }
+
+        private class TestOsuRuleset : OsuRuleset
+        {
+            public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new TestOsuLegacySkinTransformer(source);
+
+            private class TestOsuLegacySkinTransformer : OsuLegacySkinTransformer
+            {
+                public TestOsuLegacySkinTransformer(ISkinSource source)
+                    : base(source)
+                {
+                }
+
+                public override Drawable GetDrawableComponent(ISkinComponent component)
+                {
+                    var drawable = base.GetDrawableComponent(component);
+                    if (drawable != null)
+                        return drawable;
+
+                    // this isn't really supposed to make a difference from returning null,
+                    // but it appears it does, returning null will skip over falling back to beatmap skin,
+                    // while calling Source.GetDrawableComponent() doesn't.
+                    return Source.GetDrawableComponent(component);
+                }
+            }
+        }
+    }
+}