Merge branch 'master' into beatmap-listing-expanded

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

@@ -0,0 +1,195 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Compose.Components.Timeline;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Editor
+{
+    public class TestSceneEditorChangeStates : ScreenTestScene
+    {
+        private EditorBeatmap editorBeatmap;
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+
+            Screens.Edit.Editor editor = null;
+
+            AddStep("load editor", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                LoadScreen(editor = new Screens.Edit.Editor());
+            });
+
+            AddUntilStep("wait for editor to load", () => editor.ChildrenOfType<HitObjectComposer>().FirstOrDefault()?.IsLoaded == true
+                                                          && editor.ChildrenOfType<TimelineArea>().FirstOrDefault()?.IsLoaded == true);
+            AddStep("get beatmap", () => editorBeatmap = editor.ChildrenOfType<EditorBeatmap>().Single());
+        }
+
+        [Test]
+        public void TestUndoFromInitialState()
+        {
+            int hitObjectCount = 0;
+
+            AddStep("get initial state", () => hitObjectCount = editorBeatmap.HitObjects.Count);
+
+            addUndoSteps();
+
+            AddAssert("no change occurred", () => hitObjectCount == editorBeatmap.HitObjects.Count);
+        }
+
+        [Test]
+        public void TestRedoFromInitialState()
+        {
+            int hitObjectCount = 0;
+
+            AddStep("get initial state", () => hitObjectCount = editorBeatmap.HitObjects.Count);
+
+            addRedoSteps();
+
+            AddAssert("no change occurred", () => hitObjectCount == editorBeatmap.HitObjects.Count);
+        }
+
+        [Test]
+        public void TestAddObjectAndUndo()
+        {
+            HitObject addedObject = null;
+            HitObject removedObject = null;
+            HitObject expectedObject = null;
+
+            AddStep("bind removal", () =>
+            {
+                editorBeatmap.HitObjectAdded += h => addedObject = h;
+                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+            });
+
+            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddAssert("hitobject added", () => addedObject == expectedObject);
+
+            addUndoSteps();
+            AddAssert("hitobject removed", () => removedObject == expectedObject);
+        }
+
+        [Test]
+        public void TestAddObjectThenUndoThenRedo()
+        {
+            HitObject addedObject = null;
+            HitObject removedObject = null;
+            HitObject expectedObject = null;
+
+            AddStep("bind removal", () =>
+            {
+                editorBeatmap.HitObjectAdded += h => addedObject = h;
+                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+            });
+
+            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            addUndoSteps();
+
+            AddStep("reset variables", () =>
+            {
+                addedObject = null;
+                removedObject = null;
+            });
+
+            addRedoSteps();
+            AddAssert("hitobject added", () => addedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance)
+            AddAssert("no hitobject removed", () => removedObject == null);
+        }
+
+        [Test]
+        public void TestRemoveObjectThenUndo()
+        {
+            HitObject addedObject = null;
+            HitObject removedObject = null;
+            HitObject expectedObject = null;
+
+            AddStep("bind removal", () =>
+            {
+                editorBeatmap.HitObjectAdded += h => addedObject = h;
+                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+            });
+
+            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("remove object", () => editorBeatmap.Remove(expectedObject));
+            AddStep("reset variables", () =>
+            {
+                addedObject = null;
+                removedObject = null;
+            });
+
+            addUndoSteps();
+            AddAssert("hitobject added", () => addedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance)
+            AddAssert("no hitobject removed", () => removedObject == null);
+        }
+
+        [Test]
+        public void TestRemoveObjectThenUndoThenRedo()
+        {
+            HitObject addedObject = null;
+            HitObject removedObject = null;
+            HitObject expectedObject = null;
+
+            AddStep("bind removal", () =>
+            {
+                editorBeatmap.HitObjectAdded += h => addedObject = h;
+                editorBeatmap.HitObjectRemoved += h => removedObject = h;
+            });
+
+            AddStep("add hitobject", () => editorBeatmap.Add(expectedObject = new HitCircle { StartTime = 1000 }));
+            AddStep("remove object", () => editorBeatmap.Remove(expectedObject));
+            addUndoSteps();
+
+            AddStep("reset variables", () =>
+            {
+                addedObject = null;
+                removedObject = null;
+            });
+
+            addRedoSteps();
+            AddAssert("hitobject removed", () => removedObject.StartTime == expectedObject.StartTime); // Can't compare via equality (new hitobject instance after undo)
+            AddAssert("no hitobject added", () => addedObject == null);
+        }
+
+        private void addUndoSteps()
+        {
+            AddStep("press undo", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.PressKey(Key.Z);
+            });
+
+            AddStep("release keys", () =>
+            {
+                InputManager.ReleaseKey(Key.LControl);
+                InputManager.ReleaseKey(Key.Z);
+            });
+        }
+
+        private void addRedoSteps()
+        {
+            AddStep("press redo", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.PressKey(Key.LShift);
+                InputManager.PressKey(Key.Z);
+            });
+
+            AddStep("release keys", () =>
+            {
+                InputManager.ReleaseKey(Key.LControl);
+                InputManager.ReleaseKey(Key.LShift);
+                InputManager.ReleaseKey(Key.Z);
+            });
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+// 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.Testing;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneFailingLayer : OsuTestScene
+    {
+        private FailingLayer layer;
+
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create layer", () =>
+            {
+                Child = layer = new FailingLayer();
+                layer.BindHealthProcessor(new DrainingHealthProcessor(1));
+            });
+
+            AddStep("enable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, true));
+            AddUntilStep("layer is visible", () => layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerFading()
+        {
+            AddSliderStep("current health", 0.0, 1.0, 1.0, val =>
+            {
+                if (layer != null)
+                    layer.Current.Value = val;
+            });
+
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddUntilStep("layer fade is visible", () => layer.Child.Alpha > 0.1f);
+            AddStep("set health to 1", () => layer.Current.Value = 1f);
+            AddUntilStep("layer fade is invisible", () => !layer.Child.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerDisabledViaConfig()
+        {
+            AddStep("disable layer", () => config.Set(OsuSetting.FadePlayfieldWhenHealthLow, false));
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddUntilStep("layer is not visible", () => !layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerVisibilityWithAccumulatingProcessor()
+        {
+            AddStep("bind accumulating processor", () => layer.BindHealthProcessor(new AccumulatingHealthProcessor(1)));
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddUntilStep("layer is not visible", () => !layer.IsPresent);
+        }
+
+        [Test]
+        public void TestLayerVisibilityWithDrainingProcessor()
+        {
+            AddStep("bind accumulating processor", () => layer.BindHealthProcessor(new DrainingHealthProcessor(1)));
+            AddStep("set health to 0.10", () => layer.Current.Value = 0.1);
+            AddWaitStep("wait for potential fade", 10);
+            AddAssert("layer is still visible", () => layer.IsPresent);
+        }
+    }
+}

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

@@ -20,26 +20,30 @@ namespace osu.Game.Tests.Visual.Navigation
         public void TestFromMainMenu()
         {
             var firstImport = importBeatmap(1);
+            var secondimport = importBeatmap(3);
+
             presentAndConfirm(firstImport);
-
-            AddStep("return to menu", () => Game.ScreenStack.CurrentScreen.Exit());
-            AddUntilStep("wait for menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
-
-            var secondimport = importBeatmap(2);
+            returnToMenu();
             presentAndConfirm(secondimport);
+            returnToMenu();
+            presentSecondDifficultyAndConfirm(firstImport, 1);
+            returnToMenu();
+            presentSecondDifficultyAndConfirm(secondimport, 3);
         }
 
         [Test]
         public void TestFromMainMenuDifferentRuleset()
         {
             var firstImport = importBeatmap(1);
+            var secondimport = importBeatmap(3, new ManiaRuleset().RulesetInfo);
+
             presentAndConfirm(firstImport);
-
-            AddStep("return to menu", () => Game.ScreenStack.CurrentScreen.Exit());
-            AddUntilStep("wait for menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
-
-            var secondimport = importBeatmap(2, new ManiaRuleset().RulesetInfo);
+            returnToMenu();
             presentAndConfirm(secondimport);
+            returnToMenu();
+            presentSecondDifficultyAndConfirm(firstImport, 1);
+            returnToMenu();
+            presentSecondDifficultyAndConfirm(secondimport, 3);
         }
 
         [Test]
@@ -48,8 +52,11 @@ namespace osu.Game.Tests.Visual.Navigation
             var firstImport = importBeatmap(1);
             presentAndConfirm(firstImport);
 
-            var secondimport = importBeatmap(2);
+            var secondimport = importBeatmap(3);
             presentAndConfirm(secondimport);
+
+            presentSecondDifficultyAndConfirm(firstImport, 1);
+            presentSecondDifficultyAndConfirm(secondimport, 3);
         }
 
         [Test]
@@ -58,8 +65,17 @@ namespace osu.Game.Tests.Visual.Navigation
             var firstImport = importBeatmap(1);
             presentAndConfirm(firstImport);
 
-            var secondimport = importBeatmap(2, new ManiaRuleset().RulesetInfo);
+            var secondimport = importBeatmap(3, new ManiaRuleset().RulesetInfo);
             presentAndConfirm(secondimport);
+
+            presentSecondDifficultyAndConfirm(firstImport, 1);
+            presentSecondDifficultyAndConfirm(secondimport, 3);
+        }
+
+        private void returnToMenu()
+        {
+            AddStep("return to menu", () => Game.ScreenStack.CurrentScreen.Exit());
+            AddUntilStep("wait for menu", () => Game.ScreenStack.CurrentScreen is MainMenu);
         }
 
         private Func<BeatmapSetInfo> importBeatmap(int i, RulesetInfo ruleset = null)
@@ -89,6 +105,13 @@ namespace osu.Game.Tests.Visual.Navigation
                             BaseDifficulty = difficulty,
                             Ruleset = ruleset ?? new OsuRuleset().RulesetInfo
                         },
+                        new BeatmapInfo
+                        {
+                            OnlineBeatmapID = i * 2048,
+                            Metadata = metadata,
+                            BaseDifficulty = difficulty,
+                            Ruleset = ruleset ?? new OsuRuleset().RulesetInfo
+                        },
                     }
                 }).Result;
             });
@@ -106,5 +129,15 @@ namespace osu.Game.Tests.Visual.Navigation
             AddUntilStep("correct beatmap displayed", () => Game.Beatmap.Value.BeatmapSetInfo.ID == getImport().ID);
             AddAssert("correct ruleset selected", () => Game.Ruleset.Value.ID == getImport().Beatmaps.First().Ruleset.ID);
         }
+
+        private void presentSecondDifficultyAndConfirm(Func<BeatmapSetInfo> getImport, int importedID)
+        {
+            Predicate<BeatmapInfo> pred = b => b.OnlineBeatmapID == importedID * 2048;
+            AddStep("present difficulty", () => Game.PresentBeatmap(getImport(), pred));
+
+            AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect);
+            AddUntilStep("correct beatmap displayed", () => Game.Beatmap.Value.BeatmapInfo.OnlineBeatmapID == importedID * 2048);
+            AddAssert("correct ruleset selected", () => Game.Ruleset.Value.ID == getImport().Beatmaps.First().Ruleset.ID);
+        }
     }
 }

osu.Game.Tests/Visual/Online/TestSceneChangelogOverlay.cs

@@ -24,7 +24,6 @@ namespace osu.Game.Tests.Visual.Online
             typeof(ChangelogListing),
             typeof(ChangelogSingleBuild),
             typeof(ChangelogBuild),
-            typeof(Comments),
         };
 
         protected override bool UseOnlineAPI => true;

osu.Game.Tests/Visual/Online/TestSceneDirectDownloadButton.cs

@@ -149,8 +149,8 @@ namespace osu.Game.Tests.Visual.Online
 
             public DownloadState DownloadState => State.Value;
 
-            public TestDownloadButton(BeatmapSetInfo beatmapSet, bool noVideo = false)
-                : base(beatmapSet, noVideo)
+            public TestDownloadButton(BeatmapSetInfo beatmapSet)
+                : base(beatmapSet)
             {
             }
         }

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

@@ -54,6 +54,35 @@ namespace osu.Game.Tests.Visual.SongSelect
             this.rulesets = rulesets;
         }
 
+        [Test]
+        public void TestRecommendedSelection()
+        {
+            loadBeatmaps();
+
+            AddStep("set recommendation function", () => carousel.GetRecommendedBeatmap = beatmaps => beatmaps.LastOrDefault());
+
+            // check recommended was selected
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(1, 3);
+
+            // change away from recommended
+            advanceSelection(direction: -1, diff: true);
+            waitForSelection(1, 2);
+
+            // next set, check recommended
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(2, 3);
+
+            // next set, check recommended
+            advanceSelection(direction: 1, diff: false);
+            waitForSelection(3, 3);
+
+            // go back to first set and ensure user selection was retained
+            advanceSelection(direction: -1, diff: false);
+            advanceSelection(direction: -1, diff: false);
+            waitForSelection(1, 2);
+        }
+
         /// <summary>
         /// Test keyboard traversal
         /// </summary>

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

@@ -0,0 +1,113 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.Containers;
+using osu.Game.Overlays;
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Shapes;
+using osuTK.Graphics;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.UserInterface
+{
+    public class TestSceneOverlayScrollContainer : OsuManualInputManagerTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(OverlayScrollContainer)
+        };
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Blue);
+
+        private TestScrollContainer scroll;
+
+        private int invocationCount;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            Child = scroll = new TestScrollContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = new Container
+                {
+                    Height = 3000,
+                    RelativeSizeAxes = Axes.X,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.Gray
+                    }
+                }
+            };
+
+            invocationCount = 0;
+
+            scroll.Button.Action += () => invocationCount++;
+        });
+
+        [Test]
+        public void TestButtonVisibility()
+        {
+            AddAssert("button is hidden", () => scroll.Button.State == Visibility.Hidden);
+
+            AddStep("scroll to end", () => scroll.ScrollToEnd(false));
+            AddAssert("button is visible", () => scroll.Button.State == Visibility.Visible);
+
+            AddStep("scroll to start", () => scroll.ScrollToStart(false));
+            AddAssert("button is hidden", () => scroll.Button.State == Visibility.Hidden);
+
+            AddStep("scroll to 500", () => scroll.ScrollTo(500));
+            AddUntilStep("scrolled to 500", () => Precision.AlmostEquals(scroll.Current, 500, 0.1f));
+            AddAssert("button is visible", () => scroll.Button.State == Visibility.Visible);
+        }
+
+        [Test]
+        public void TestButtonAction()
+        {
+            AddStep("scroll to end", () => scroll.ScrollToEnd(false));
+
+            AddStep("invoke action", () => scroll.Button.Action.Invoke());
+
+            AddUntilStep("scrolled back to start", () => Precision.AlmostEquals(scroll.Current, 0, 0.1f));
+        }
+
+        [Test]
+        public void TestClick()
+        {
+            AddStep("scroll to end", () => scroll.ScrollToEnd(false));
+
+            AddStep("click button", () =>
+            {
+                InputManager.MoveMouseTo(scroll.Button);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddUntilStep("scrolled back to start", () => Precision.AlmostEquals(scroll.Current, 0, 0.1f));
+        }
+
+        [Test]
+        public void TestMultipleClicks()
+        {
+            AddStep("scroll to end", () => scroll.ScrollToEnd(false));
+
+            AddAssert("invocation count is 0", () => invocationCount == 0);
+
+            AddStep("hover button", () => InputManager.MoveMouseTo(scroll.Button));
+            AddRepeatStep("click button", () => InputManager.Click(MouseButton.Left), 3);
+
+            AddAssert("invocation count is 1", () => invocationCount == 1);
+        }
+
+        private class TestScrollContainer : OverlayScrollContainer
+        {
+            public new ScrollToTopButton Button => base.Button;
+        }
+    }
+}