Update lots of packages (#36996)

It's been a while.

Notes:

- `SharpCompress` usages changed a bit. Manually adjusted these, mostly
just renames or adjusted parameters.
- nUnit 3 -> 4 migrated using
https://gist.github.com/peppy/07994386d793a117350cb5f24b156585. there's
a mode in this script to update to the newer `Assert.That` syntax but it
requires fixes and couldn't really be bothered.
- DeepEqual nuked as the only usage was on a disabled test. The reason
it's disabled has been merged upstream, but it's failing for other
(realm) reasons which I don't think is worthwhile to investigate for
now.
- This bumps Moq. I think the author is back in a sensible headspace and
the new version has the stupid shit removed, so probably okay? Nice to
be on a level playing field with packages for once in a long time.
- Automapper is silly, but we've discussed this elsewhere.
- `TestRealmKeyBindingStore` failures are a wildcard, but fixed by using
a more standardised testing method. Dunno why, don't care.

---------

Co-authored-by: Bartłomiej Dach <dach.bartlomiej@gmail.com>

.github/workflows/update-web-mod-definitions.yml

@@ -38,8 +38,12 @@ jobs:
       run: ./UseLocalOsu.sh
       working-directory: ./osu-tools
 
+    - name: Build tools
+      run: dotnet build PerformanceCalculator --nologo --verbosity quiet
+      working-directory: ./osu-tools
+
     - name: Regenerate mod definitions
-      run: dotnet run --project PerformanceCalculator -- mods > ../osu-web/database/mods.json
+      run: dotnet run --project PerformanceCalculator --no-build -- mods > ../osu-web/database/mods.json
       working-directory: ./osu-tools
 
     - name: Create pull request with changes

CONTRIBUTING.md

@@ -55,9 +55,7 @@ When in doubt, it's probably best to start with a discussion first. We will esca
 
 While pull requests from unaffiliated contributors are welcome, please note that due to significant community interest and limited review throughput, the core team's primary focus is on the issues which are currently [on the roadmap](https://github.com/orgs/ppy/projects/7/views/6). Reviewing PRs that fall outside of the scope of the roadmap is done on a best-effort basis, so please be aware that it may take a while before a core maintainer gets around to review your change.
 
-The [issue tracker](https://github.com/ppy/osu/issues) should provide plenty of issues to start with. We also have a [`good first issue`](https://github.com/ppy/osu/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) label, although from experience it is not used very often, as it is relatively rare that we can spot an issue that will definitively be a good first issue for a new contributor regardless of their programming experience.
-
-In the case of simple issues, a direct PR is okay. However, if you decide to work on an existing issue which doesn't seem trivial, **please ask us first**. This way we can try to estimate if it is a good fit for you and provide the correct direction on how to address it. In addition, note that while we do not rule out external contributors from working on roadmapped issues, we will generally prefer to handle them ourselves unless they're not very time sensitive.
+The [issue tracker](https://github.com/ppy/osu/issues) should provide plenty of issues to start with. In the case of simple issues, a direct PR is okay. However, if you decide to work on an existing issue which doesn't seem trivial, **please ask us first**. This way we can try to estimate if it is a good fit for you and provide the correct direction on how to address it. In addition, note that while we do not rule out external contributors from working on roadmapped issues, we will generally prefer to handle them ourselves unless they're not very time sensitive.
 
 If you'd like to propose a subjective change to one of the visual aspects of the game, or there is a bigger task you'd like to work on, but there is no corresponding issue or discussion thread yet for it, **please open a discussion or issue first** to avoid wasted effort. This in particular applies if you want to work on [one of the available designs from the osu! Figma master library](https://www.figma.com/file/VIkXMYNPMtQem2RJg9k2iQ/Master-Library).
 

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform.Tests/osu.Game.Rulesets.EmptyFreeform.Tests.csproj

@@ -10,8 +10,8 @@
     </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.EmptyFreeform\osu.Game.Rulesets.EmptyFreeform.csproj" />

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -10,8 +10,8 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling.Tests/osu.Game.Rulesets.EmptyScrolling.Tests.csproj

@@ -10,8 +10,8 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.EmptyScrolling\osu.Game.Rulesets.EmptyScrolling.csproj" />

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon.Tests/osu.Game.Rulesets.Pippidon.Tests.csproj

@@ -10,8 +10,8 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Game.Rulesets.Pippidon\osu.Game.Rulesets.Pippidon.csproj" />

osu.Android.props

@@ -10,7 +10,7 @@
     <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2025.1229.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.310.0" />
   </ItemGroup>
   <PropertyGroup>
     <!-- Fody does not handle Android build well, and warns when unchanged.

osu.Android/AndroidManifest.xml

@@ -5,16 +5,13 @@
 				 android:supportsRtl="true"
 				 android:label="osu!"
 				 android:icon="@mipmap/ic_launcher"
-				 android:roundIcon="@mipmap/ic_launcher" />
-	<!-- for editor usage -->
-	<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
-	<uses-permission android:name="android.permission.READ_MEDIA_AUDIO" />
-	<!--
-		READ_MEDIA_* permissions are available only on API 33 or greater. Devices with older android versions
-		don't understand the new permissions, so request the old READ_EXTERNAL_STORAGE permission to get storage access.
-		Since the old permission has no effect on >= API 33, don't request it.
-
-		Care needs to be taken to ensure runtime permission checks target the correct permission for the API level.
-	-->
-	<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32"/>
+				 android:roundIcon="@mipmap/ic_launcher">
+        <provider android:name="androidx.core.content.FileProvider"
+                  android:authorities="sh.ppy.osulazer.fileprovider"
+                  android:grantUriPermissions="true"
+                  android:exported="false">
+            <meta-data android:name="android.support.FILE_PROVIDER_PATHS"
+                       android:resource="@xml/filepaths" />
+        </provider>
+    </application>
 </manifest>

osu.Android/Resources/xml/filepaths.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <!-- https://developer.android.com/reference/androidx/core/content/FileProvider -->
+    <external-files-path path="logs" name="logs" />
+    <external-files-path path="exports" name="exports" />
+</paths>

osu.Desktop/OsuGameDesktop.cs

@@ -146,9 +146,13 @@ namespace osu.Desktop
         {
             base.SetHost(host);
 
-            var iconStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico");
-            if (iconStream != null)
-                host.Window.SetIconFromStream(iconStream);
+            // Apple operating systems use a better icon provided via external assets.
+            if (!RuntimeInfo.IsApple)
+            {
+                var iconStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(GetType(), "lazer.ico");
+                if (iconStream != null)
+                    host.Window.SetIconFromStream(iconStream);
+            }
 
             host.Window.Title = Name;
         }

osu.Desktop/Security/ElevatedPrivilegesChecker.cs

@@ -7,6 +7,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
+using osu.Game.Localisation;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 
@@ -32,7 +33,7 @@ namespace osu.Desktop.Security
         {
             public ElevatedPrivilegesNotification()
             {
-                Text = $"Running osu! as {(RuntimeInfo.IsUnix ? "root" : "administrator")} does not improve performance, may break integrations and poses a security risk. Please run the game as a normal user.";
+                Text = NotificationsStrings.ElevatedPrivileges(RuntimeInfo.IsUnix ? "root" : "Administrator");
             }
 
             [BackgroundDependencyLoader]

osu.Desktop/osu.Desktop.csproj

@@ -24,8 +24,8 @@
     <ProjectReference Include="..\osu.Game.Rulesets.Taiko\osu.Game.Rulesets.Taiko.csproj" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="System.IO.Packaging" Version="9.0.2" />
-    <PackageReference Include="DiscordRichPresence" Version="1.2.1.24" />
+    <PackageReference Include="System.IO.Packaging" Version="10.0.5" />
+    <PackageReference Include="DiscordRichPresence" Version="1.6.1.70" />
     <PackageReference Include="Velopack" Version="0.0.1298" />
   </ItemGroup>
   <ItemGroup Label="Resources">

osu.Game.Benchmarks/BenchmarkCarouselFilter.cs

@@ -5,7 +5,7 @@ using BenchmarkDotNet.Attributes;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Select;
-using osu.Game.Screens.Select.Carousel;
+using osu.Game.Tests.NonVisual.Filtering;
 
 namespace osu.Game.Benchmarks
 {
@@ -42,7 +42,7 @@ namespace osu.Game.Benchmarks
             Status = BeatmapOnlineStatus.Loved
         };
 
-        private CarouselBeatmap carouselBeatmap = null!;
+        private FilterMatchingTest.CarouselBeatmap carouselBeatmap = null!;
         private FilterCriteria criteria1 = null!;
         private FilterCriteria criteria2 = null!;
         private FilterCriteria criteria3 = null!;
@@ -55,7 +55,7 @@ namespace osu.Game.Benchmarks
             var beatmap = getExampleBeatmap();
             beatmap.OnlineID = 20201010;
             beatmap.BeatmapSet = new BeatmapSetInfo { OnlineID = 1535 };
-            carouselBeatmap = new CarouselBeatmap(beatmap);
+            carouselBeatmap = new FilterMatchingTest.CarouselBeatmap(beatmap);
             criteria1 = new FilterCriteria();
             criteria2 = new FilterCriteria
             {

osu.Game.Benchmarks/osu.Game.Benchmarks.csproj

@@ -7,9 +7,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
-    <PackageReference Include="nunit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.15.8" />
+    <PackageReference Include="nunit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
 
   <ItemGroup>

osu.Game.Rulesets.Catch.Tests.iOS/Info.plist

@@ -35,11 +35,9 @@
 		<string>UIInterfaceOrientationLandscapeRight</string>
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 	</array>
-	<key>XSAppIconAssets</key>
-	<string>Assets.xcassets/AppIcon.appiconset</string>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>CADisableMinimumFrameDurationOnPhone</key>
 	<true/>
 </dict>
-</plist>
+</plist>

osu.Game.Rulesets.Catch.Tests/CatchSkinColourDecodingTest.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.IO.Stores;
 using osu.Game.Rulesets.Catch.Skinning;
 using osu.Game.Rulesets.Catch.Skinning.Legacy;
@@ -21,9 +22,9 @@ namespace osu.Game.Rulesets.Catch.Tests
             var skinSource = new SkinProvidingContainer(rawSkin);
             var skin = new CatchLegacySkinTransformer(skinSource);
 
-            Assert.AreEqual(new Color4(232, 185, 35, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value);
-            Assert.AreEqual(new Color4(232, 74, 35, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashAfterImage)?.Value);
-            Assert.AreEqual(new Color4(0, 255, 255, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashFruit)?.Value);
+            ClassicAssert.AreEqual(new Color4(232, 185, 35, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDash)?.Value);
+            ClassicAssert.AreEqual(new Color4(232, 74, 35, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashAfterImage)?.Value);
+            ClassicAssert.AreEqual(new Color4(0, 255, 255, 255), skin.GetConfig<CatchSkinColour, Color4>(CatchSkinColour.HyperDashFruit)?.Value);
         }
 
         private class TestLegacySkin : LegacySkin

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -176,15 +176,20 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetCatch };
 
-        protected override IEnumerable<HitResult> GetValidHitResults()
+        public override IEnumerable<HitResult> GetValidHitResults()
         {
             return new[]
             {
                 HitResult.Great,
+                HitResult.Miss,
 
                 HitResult.LargeTickHit,
+                HitResult.LargeTickMiss,
                 HitResult.SmallTickHit,
+                HitResult.SmallTickMiss,
                 HitResult.LargeBonus,
+                HitResult.IgnoreHit,
+                HitResult.IgnoreMiss,
             };
         }
 

osu.Game.Rulesets.Mania.Tests.iOS/Info.plist

@@ -35,11 +35,9 @@
 		<string>UIInterfaceOrientationLandscapeRight</string>
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 	</array>
-	<key>XSAppIconAssets</key>
-	<string>Assets.xcassets/AppIcon.appiconset</string>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>CADisableMinimumFrameDurationOnPhone</key>
 	<true/>
 </dict>
-</plist>
+</plist>

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNoteTailDrag.cs

@@ -0,0 +1,351 @@
+// 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.Mania.Objects;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Input;
+using DragArea = osu.Game.Screens.Edit.Compose.Components.Timeline.TimelineHitObjectBlueprint.DragArea;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor
+{
+    public partial class TestSceneHoldNoteTailDrag : EditorTestScene
+    {
+        protected override Ruleset CreateEditorRuleset() => new ManiaRuleset();
+
+        [SetUpSteps]
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("Clear objects", () => EditorBeatmap.Clear());
+        }
+
+        [Test]
+        public void TestSimpleTailDragForward()
+        {
+            AddStep("Add hold note", () =>
+            {
+                EditorBeatmap.Add(new HoldNote { StartTime = 2170, Duration = 937.5 });
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().Single();
+                dragForward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is higher", () => ((HoldNote)EditorBeatmap.HitObjects.First())!.Duration > 937.5f);
+        }
+
+        [Test]
+        public void TestSimpleTailDragBackwards()
+        {
+            AddStep("Add hold note", () =>
+            {
+                EditorBeatmap.Add(new HoldNote { StartTime = 2170, Duration = 937.5 });
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().Single();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is lower", () => ((HoldNote)EditorBeatmap.HitObjects[0]).Duration < 937.5f);
+        }
+
+        [Test]
+        public void TestSamePositionButNotSelectedDragForward()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragForward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is higher, other is unchanged", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration > 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration == 937.5f
+            );
+        }
+
+        [Test]
+        public void TestSamePositionButNotSelectedDragBackward()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is lower, other is unchanged", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration < 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration == 937.5f
+            );
+        }
+
+        [Test]
+        public void TestSamePositionSelectedDragForward()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Select all", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragForward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Both durations are higher", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration > 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration > 937.5f
+            );
+        }
+
+        [Test]
+        public void TestSamePositionSelectedDragBackward()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Select all", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Both durations are lower", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration < 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration < 937.5f
+            );
+        }
+
+        [Test]
+        public void TestSelectedButDifferentPositions()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2404, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Select all", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is unchanged, other is lower", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration == 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration < 937.5f
+            );
+        }
+
+        [Test]
+        public void TestSelectedSameStartTimeDifferentDurations()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2170, Duration = 1171.8, Column = 1 }
+                ]);
+            });
+
+            AddStep("Select all", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects);
+            });
+
+            AddStep("Drag until both match", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                InputManager.MoveMouseTo(blueprintDragArea);
+                InputManager.PressKey(Key.LShift);
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(new Vector2(1000, 110));
+            });
+
+            AddStep("Continue the drag", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is unchanged, other is lower", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration == 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration < 937.5f
+            );
+        }
+
+        [Test]
+        public void TestSelectedSameDurationDifferentStartTimes()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2638.7, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Select all", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is unchanged, other is lower", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration == 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration < 937.5f
+            );
+        }
+
+        [Test]
+        public void TestDragNoteOutsideOfSelection()
+        {
+            AddStep("Add hold notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 1 }
+                ]);
+            });
+
+            AddStep("Select the back stack slider", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.Add(EditorBeatmap.HitObjects.Last());
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Duration is lower, other is unchanged", () =>
+                ((HoldNote)EditorBeatmap.HitObjects[0]).Duration < 937.5f &&
+                ((HoldNote)EditorBeatmap.HitObjects[^1]).Duration == 937.5f
+            );
+        }
+
+        [Test]
+        public void TestDragHoldNoteWithNotes()
+        {
+            AddStep("Add notes", () =>
+            {
+                EditorBeatmap.AddRange([
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 0 },
+                    new Note { StartTime = 2170, Column = 1 },
+                    new Note { StartTime = 3107.5, Column = 2 },
+                    new HoldNote { StartTime = 2170, Duration = 937.5, Column = 3 }
+                ]);
+            });
+
+            AddStep("Select all", () =>
+            {
+                EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects);
+            });
+
+            AddStep("Drag tail", () =>
+            {
+                var blueprintDragArea = this.ChildrenOfType<DragArea>().First();
+                dragBackward(blueprintDragArea);
+            });
+
+            AddStep("Release tail", () => InputManager.ReleaseButton(MouseButton.Left));
+
+            AddAssert("Both durations are lower", () =>
+                {
+                    var holdNotes = EditorBeatmap.HitObjects.OfType<HoldNote>();
+                    return holdNotes.First().Duration < 937.5f && holdNotes.Last().Duration < 937.5f;
+                }
+            );
+        }
+
+        private void dragForward(DragArea dragArea)
+        {
+            InputManager.MoveMouseTo(dragArea);
+            InputManager.PressButton(MouseButton.Left);
+            InputManager.MoveMouseTo(new Vector2(1100, 110));
+        }
+
+        private void dragBackward(DragArea dragArea)
+        {
+            InputManager.MoveMouseTo(dragArea);
+            InputManager.PressButton(MouseButton.Left);
+            InputManager.MoveMouseTo(new Vector2(700, 110));
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneObjectPlacement.cs

@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
             AddStep("change seek setting to true", () => config.SetValue(OsuSetting.EditorAutoSeekOnPlacement, true));
             placeObject();
             AddUntilStep("wait for seek to complete", () => !EditorClock.IsSeeking);
-            AddAssert("seeked forward to object", () => EditorClock.CurrentTime, () => Is.GreaterThan(initialTime));
+            AddAssert("seeked forward to object", () => EditorClock.CurrentTime, () => Is.GreaterThan(initialTime!));
         }
 
         [Test]

osu.Game.Rulesets.Mania.Tests/ManiaFilterCriteriaTest.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Screens.Select;
@@ -18,19 +19,19 @@ namespace osu.Game.Rulesets.Mania.Tests
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1");
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
                 new FilterCriteria
                 {
@@ -44,19 +45,19 @@ namespace osu.Game.Rulesets.Mania.Tests
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "1,3,5,7");
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
                 new FilterCriteria
                 {
@@ -70,19 +71,19 @@ namespace osu.Game.Rulesets.Mania.Tests
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1");
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
                 new FilterCriteria
                 {
@@ -96,19 +97,19 @@ namespace osu.Game.Rulesets.Mania.Tests
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "1,3,5,7");
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 4 }),
                 new FilterCriteria
                 {
@@ -122,23 +123,23 @@ namespace osu.Game.Rulesets.Mania.Tests
             var criteria = new ManiaFilterCriteria();
             criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4");
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 1 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 2 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new RulesetInfo { OnlineID = 0 }, new BeatmapDifficulty { CircleSize = 3 }),
                 new FilterCriteria
                 {
@@ -153,23 +154,23 @@ namespace osu.Game.Rulesets.Mania.Tests
             criteria.TryParseCustomKeywordCriteria("keys", Operator.Greater, "4");
             criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "7");
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 3 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 4 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 5 }),
                 new FilterCriteria()));
 
-            Assert.False(criteria.Matches(
+            ClassicAssert.False(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 7 }),
                 new FilterCriteria()));
 
-            Assert.True(criteria.Matches(
+            ClassicAssert.True(criteria.Matches(
                 new BeatmapInfo(new ManiaRuleset().RulesetInfo, new BeatmapDifficulty { CircleSize = 9 }),
                 new FilterCriteria()));
         }
@@ -179,9 +180,9 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             var criteria = new ManiaFilterCriteria();
 
-            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "some text"));
-            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
-            Assert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
+            ClassicAssert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.Equal, "some text"));
+            ClassicAssert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.NotEqual, "4,some text"));
+            ClassicAssert.False(criteria.TryParseCustomKeywordCriteria("keys", Operator.GreaterOrEqual, "4,5,6"));
         }
 
         [TestCase]
@@ -199,7 +200,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 0,
                 EndTimeObjectCount = 0
             };
-            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo1, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0");
             BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -207,7 +208,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 0
             };
-            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo2, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "100");
             BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -215,7 +216,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 100
             };
-            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo3, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "1");
             BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -223,7 +224,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 1
             };
-            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo4, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "0.1");
             BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -231,7 +232,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 1000,
                 EndTimeObjectCount = 1
             };
-            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo5, filterCriteria));
         }
 
         [TestCase]
@@ -249,7 +250,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 0,
                 EndTimeObjectCount = 0
             };
-            Assert.True(criteria.Matches(beatmapInfo1, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo1, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0");
             BeatmapInfo beatmapInfo2 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -257,7 +258,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 0
             };
-            Assert.True(criteria.Matches(beatmapInfo2, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo2, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "100");
             BeatmapInfo beatmapInfo3 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -265,7 +266,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 100
             };
-            Assert.True(criteria.Matches(beatmapInfo3, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo3, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1");
             BeatmapInfo beatmapInfo4 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -273,7 +274,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 1
             };
-            Assert.True(criteria.Matches(beatmapInfo4, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo4, filterCriteria));
 
             criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "0.1");
             BeatmapInfo beatmapInfo5 = new BeatmapInfo(new ManiaRuleset().RulesetInfo)
@@ -281,7 +282,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 1000,
                 EndTimeObjectCount = 1
             };
-            Assert.True(criteria.Matches(beatmapInfo5, filterCriteria));
+            ClassicAssert.True(criteria.Matches(beatmapInfo5, filterCriteria));
         }
 
         [TestCase]
@@ -299,7 +300,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 TotalObjectCount = 100,
                 EndTimeObjectCount = 50
             };
-            Assert.False(criteria.Matches(beatmapInfo, filterCriteria));
+            ClassicAssert.False(criteria.Matches(beatmapInfo, filterCriteria));
         }
 
         [TestCase]
@@ -307,8 +308,8 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             var criteria = new ManiaFilterCriteria();
 
-            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "some text"));
-            Assert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1some text"));
+            ClassicAssert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.Equal, "some text"));
+            ClassicAssert.False(criteria.TryParseCustomKeywordCriteria("lns", Operator.GreaterOrEqual, "1some text"));
         }
     }
 }

osu.Game.Rulesets.Mania.Tests/ManiaSpecialColumnTest.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
@@ -35,7 +36,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             var definition = new StageDefinition(columns);
             var results = getResults(definition);
-            Assert.AreEqual(special, results);
+            ClassicAssert.AreEqual(special, results);
         }
 
         private IEnumerable<bool> getResults(StageDefinition definition)

osu.Game.Rulesets.Mania.Tests/Mods/TestSceneManiaModHoldOff.cs

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Tests.Visual;
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Mods
         public void TestMapHasNoHoldNotes()
         {
             var testBeatmap = createModdedBeatmap();
-            Assert.False(testBeatmap.HitObjects.OfType<HoldNote>().Any());
+            ClassicAssert.False(testBeatmap.HitObjects.OfType<HoldNote>().Any());
         }
 
         [Test]

osu.Game.Rulesets.Mania.Tests/TestSceneAutoGeneration.cs

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Testing;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
@@ -33,11 +34,11 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
-            Assert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
+            ClassicAssert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
         }
 
         [Test]
@@ -54,11 +55,11 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
-            Assert.AreEqual(3000, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
+            ClassicAssert.AreEqual(3000, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
         }
 
         [Test]
@@ -74,11 +75,11 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
-            Assert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been released");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
+            ClassicAssert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been released");
         }
 
         [Test]
@@ -96,13 +97,13 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 2, "Incorrect number of frames");
 
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
-            Assert.AreEqual(3000, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect hit time");
+            ClassicAssert.AreEqual(3000, generated.Frames[frame_offset + 1].Time, "Incorrect release time");
 
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been released");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been released");
         }
 
         [Test]
@@ -119,15 +120,15 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 4, "Incorrect number of frames");
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect first note hit time");
-            Assert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 1].Time, "Incorrect first note release time");
-            Assert.AreEqual(2000, generated.Frames[frame_offset + 2].Time, "Incorrect second note hit time");
-            Assert.AreEqual(2000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 3].Time, "Incorrect second note release time");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key2), "Key2 has not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 3], ManiaAction.Key2), "Key2 has not been released");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 4, "Incorrect number of frames");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect first note hit time");
+            ClassicAssert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 1].Time, "Incorrect first note release time");
+            ClassicAssert.AreEqual(2000, generated.Frames[frame_offset + 2].Time, "Incorrect second note hit time");
+            ClassicAssert.AreEqual(2000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 3].Time, "Incorrect second note release time");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key2), "Key2 has not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 3], ManiaAction.Key2), "Key2 has not been released");
         }
 
         [Test]
@@ -146,16 +147,16 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 4, "Incorrect number of frames");
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect first note hit time");
-            Assert.AreEqual(3000, generated.Frames[frame_offset + 2].Time, "Incorrect first note release time");
-            Assert.AreEqual(2000, generated.Frames[frame_offset + 1].Time, "Incorrect second note hit time");
-            Assert.AreEqual(4000, generated.Frames[frame_offset + 3].Time, "Incorrect second note release time");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key1), "Key1 has not been released");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key2), "Key2 has been released");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 3], ManiaAction.Key2), "Key2 has not been released");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 4, "Incorrect number of frames");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect first note hit time");
+            ClassicAssert.AreEqual(3000, generated.Frames[frame_offset + 2].Time, "Incorrect first note release time");
+            ClassicAssert.AreEqual(2000, generated.Frames[frame_offset + 1].Time, "Incorrect second note hit time");
+            ClassicAssert.AreEqual(4000, generated.Frames[frame_offset + 3].Time, "Incorrect second note release time");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1, ManiaAction.Key2), "Key1 & Key2 have not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key1), "Key1 has not been released");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key2), "Key2 has been released");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 3], ManiaAction.Key2), "Key2 has not been released");
         }
 
         [Test]
@@ -173,14 +174,14 @@ namespace osu.Game.Rulesets.Mania.Tests
 
             var generated = new ManiaAutoGenerator(beatmap).Generate();
 
-            Assert.AreEqual(generated.Frames.Count, frame_offset + 3, "Incorrect number of frames");
-            Assert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect first note hit time");
-            Assert.AreEqual(3000, generated.Frames[frame_offset + 1].Time, "Incorrect second note press time + first note release time");
-            Assert.AreEqual(3000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 2].Time, "Incorrect second note release time");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
-            Assert.IsTrue(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key2), "Key2 has not been pressed");
-            Assert.IsFalse(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key2), "Key2 has not been released");
+            ClassicAssert.AreEqual(generated.Frames.Count, frame_offset + 3, "Incorrect number of frames");
+            ClassicAssert.AreEqual(1000, generated.Frames[frame_offset].Time, "Incorrect first note hit time");
+            ClassicAssert.AreEqual(3000, generated.Frames[frame_offset + 1].Time, "Incorrect second note press time + first note release time");
+            ClassicAssert.AreEqual(3000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[frame_offset + 2].Time, "Incorrect second note release time");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset], ManiaAction.Key1), "Key1 has not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key1), "Key1 has not been released");
+            ClassicAssert.True(checkContains(generated.Frames[frame_offset + 1], ManiaAction.Key2), "Key2 has not been pressed");
+            ClassicAssert.False(checkContains(generated.Frames[frame_offset + 2], ManiaAction.Key2), "Key2 has not been released");
         }
 
         private bool checkContains(ReplayFrame frame, params ManiaAction[] actions) => actions.All(action => ((ManiaReplayFrame)frame).Actions.Contains(action));

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -383,7 +383,7 @@ namespace osu.Game.Rulesets.Mania
             return (PlayfieldType)Enum.GetValues(typeof(PlayfieldType)).Cast<int>().OrderDescending().First(v => variant >= v);
         }
 
-        protected override IEnumerable<HitResult> GetValidHitResults()
+        public override IEnumerable<HitResult> GetValidHitResults()
         {
             return new[]
             {
@@ -392,9 +392,11 @@ namespace osu.Game.Rulesets.Mania
                 HitResult.Good,
                 HitResult.Ok,
                 HitResult.Meh,
+                HitResult.Miss,
 
-                // HitResult.SmallBonus is used for awarding perfect bonus score but is not included here as
-                // it would be a bit redundant to show this to the user.
+                HitResult.IgnoreHit,
+                HitResult.ComboBreak,
+                HitResult.IgnoreMiss,
             };
         }
 

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -7,7 +7,7 @@ using osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
-using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Mania.Configuration;
@@ -31,47 +31,45 @@ namespace osu.Game.Rulesets.Mania
 
             Children = new Drawable[]
             {
-                new SettingsEnumDropdown<ManiaScrollingDirection>
+                new SettingsItemV2(new FormEnumDropdown<ManiaScrollingDirection>
                 {
-                    LabelText = RulesetSettingsStrings.ScrollingDirection,
+                    Caption = RulesetSettingsStrings.ScrollingDirection,
                     Current = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
-                },
-                new SettingsSlider<double, ManiaScrollSlider>
+                }),
+                new SettingsItemV2(new FormSliderBar<double>
                 {
-                    LabelText = RulesetSettingsStrings.ScrollSpeed,
+                    Caption = RulesetSettingsStrings.ScrollSpeed,
                     Current = config.GetBindable<double>(ManiaRulesetSetting.ScrollSpeed),
-                    KeyboardStep = 1
-                },
-                new SettingsCheckbox
+                    KeyboardStep = 1,
+                    LabelFormat = v => RulesetSettingsStrings.ScrollSpeedTooltip((int)DrawableManiaRuleset.ComputeScrollTime(v), v),
+                }),
+                new SettingsItemV2(new FormCheckBox
+                {
+                    Caption = RulesetSettingsStrings.TimingBasedColouring,
+                    Current = config.GetBindable<bool>(ManiaRulesetSetting.TimingBasedNoteColouring),
+                })
                 {
                     Keywords = new[] { "color" },
-                    LabelText = RulesetSettingsStrings.TimingBasedColouring,
-                    Current = config.GetBindable<bool>(ManiaRulesetSetting.TimingBasedNoteColouring),
                 },
             };
 
-            Add(new SettingsCheckbox
+            Add(new SettingsItemV2(new FormCheckBox
             {
-                LabelText = RulesetSettingsStrings.TouchOverlay,
+                Caption = RulesetSettingsStrings.TouchOverlay,
                 Current = config.GetBindable<bool>(ManiaRulesetSetting.TouchOverlay)
-            });
+            }));
 
             if (RuntimeInfo.IsMobile)
             {
-                Add(new SettingsEnumDropdown<ManiaMobileLayout>
+                Add(new SettingsItemV2(new FormEnumDropdown<ManiaMobileLayout>
                 {
-                    LabelText = RulesetSettingsStrings.MobileLayout,
+                    Caption = RulesetSettingsStrings.MobileLayout,
                     Current = config.GetBindable<ManiaMobileLayout>(ManiaRulesetSetting.MobileLayout),
 #pragma warning disable CS0618 // Type or member is obsolete
                     Items = Enum.GetValues<ManiaMobileLayout>().Where(l => l != ManiaMobileLayout.LandscapeWithOverlay),
 #pragma warning restore CS0618 // Type or member is obsolete
-                });
+                }));
             }
         }
-
-        private partial class ManiaScrollSlider : RoundedSliderBar<double>
-        {
-            public override LocalisableString TooltipText => RulesetSettingsStrings.ScrollSpeedTooltip((int)DrawableManiaRuleset.ComputeScrollTime(Current.Value), Current.Value);
-        }
     }
 }

osu.Game.Rulesets.Mania/UI/Stage.cs

@@ -154,7 +154,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             var hitWindows = new ManiaHitWindows();
 
-            AddInternal(judgementPooler = new JudgementPooler<DrawableManiaJudgement>(Enum.GetValues<HitResult>().Where(r => hitWindows.IsHitResultAllowed(r))));
+            AddInternal(judgementPooler = new JudgementPooler<DrawableManiaJudgement>(Enum.GetValues<HitResult>().Where(hitWindows.IsHitResultAllowed)));
 
             RegisterPool<BarLine, DrawableBarLine>(50, 200);
         }

osu.Game.Rulesets.Osu.Tests.iOS/Info.plist

@@ -35,11 +35,9 @@
 		<string>UIInterfaceOrientationLandscapeRight</string>
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 	</array>
-	<key>XSAppIconAssets</key>
-	<string>Assets.xcassets/AppIcon.appiconset</string>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>CADisableMinimumFrameDurationOnPhone</key>
 	<true/>
 </dict>
-</plist>
+</plist>

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderReversal.cs

@@ -3,10 +3,13 @@
 
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Tests.Beatmaps;
@@ -30,6 +33,16 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 PathType.LINEAR,
                 new Vector2(100, 0),
                 new Vector2(100, 100)
+            ),
+            createPathSegment(
+                PathType.PERFECT_CURVE,
+                new Vector2(100.009f, -50.0009f),
+                new Vector2(200.0089f, -100)
+            ),
+            createPathSegment(
+                PathType.PERFECT_CURVE,
+                new Vector2(25, -50),
+                new Vector2(100, 75)
             )
         };
 
@@ -48,9 +61,13 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
         [TestCase(0, 250)]
         [TestCase(0, 200)]
-        [TestCase(1, 120)]
-        [TestCase(1, 80)]
-        public void TestSliderReversal(int pathIndex, double length)
+        [TestCase(1, 120, false, false)]
+        [TestCase(1, 80, false, false)]
+        [TestCase(2, 250)]
+        [TestCase(2, 190)]
+        [TestCase(3, 250)]
+        [TestCase(3, 190)]
+        public void TestSliderReversal(int pathIndex, double length, bool assertEqualDistances = true, bool assertSliderReduction = true)
         {
             var controlPoints = paths[pathIndex];
 
@@ -90,6 +107,215 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 InputManager.ReleaseKey(Key.LControl);
             });
 
+            if (pathIndex == 2)
+            {
+                AddRepeatStep("Reverse slider again", () =>
+                {
+                    InputManager.PressKey(Key.LControl);
+                    InputManager.Key(Key.G);
+                    InputManager.ReleaseKey(Key.LControl);
+                }, 2);
+            }
+
+            if (assertEqualDistances)
+            {
+                AddAssert("Middle control point has the same distance from start to end", () =>
+                {
+                    var pathControlPoints = selectedSlider.Path.ControlPoints;
+                    float middleToStart = Vector2.Distance(pathControlPoints[^2].Position, pathControlPoints[0].Position);
+                    float middleToEnd = Vector2.Distance(pathControlPoints[^2].Position, pathControlPoints[^1].Position);
+
+                    return Precision.AlmostEquals(middleToStart, middleToEnd, 1f);
+                });
+            }
+
+            AddAssert("Middle control point is not at start or end", () =>
+                Vector2.Distance(selectedSlider.Path.ControlPoints[^2].Position, oldStartPos) > 1 &&
+                Vector2.Distance(selectedSlider.Path.ControlPoints[^2].Position, oldEndPos) > 1
+            );
+
+            AddAssert("Slider has correct length", () =>
+                Precision.AlmostEquals(selectedSlider.Path.Distance, oldDistance));
+
+            AddAssert("Slider has correct start position", () =>
+                Vector2.Distance(selectedSlider.Position, oldEndPos) < 1);
+
+            AddAssert("Slider has correct end position", () =>
+                Vector2.Distance(selectedSlider.EndPosition, oldStartPos) < 1);
+
+            AddAssert("Control points have correct types", () =>
+            {
+                var newControlPointTypes = selectedSlider.Path.ControlPoints.Select(p => p.Type).ToArray();
+
+                return oldControlPointTypes.Take(newControlPointTypes.Length).SequenceEqual(newControlPointTypes);
+            });
+
+            if (assertSliderReduction)
+            {
+                AddStep("Move to marker", () =>
+                {
+                    var marker = this.ChildrenOfType<SliderEndDragMarker>().Single();
+                    var markerPos = (marker.ScreenSpaceDrawQuad.TopRight + marker.ScreenSpaceDrawQuad.BottomRight) / 2;
+                    // sometimes the cursor may miss the marker's hitbox so we
+                    // add a little offset here to be sure it lands in a clickable position.
+                    var position = new Vector2(markerPos.X + 2f, markerPos.Y);
+                    InputManager.MoveMouseTo(position);
+                });
+                AddStep("Click", () => InputManager.PressButton(MouseButton.Left));
+                AddStep("Reduce slider", () =>
+                {
+                    var middleControlPoint = this.ChildrenOfType<PathControlPointPiece<Slider>>().ToArray()[^2];
+                    InputManager.MoveMouseTo(middleControlPoint);
+                });
+                AddStep("Release click", () => InputManager.ReleaseButton(MouseButton.Left));
+
+                AddStep("Save half slider info", () =>
+                {
+                    oldStartPos = selectedSlider.Position;
+                    oldEndPos = selectedSlider.EndPosition;
+                    oldDistance = selectedSlider.Path.Distance;
+                });
+
+                AddStep("Reverse slider", () =>
+                {
+                    InputManager.PressKey(Key.LControl);
+                    InputManager.Key(Key.G);
+                    InputManager.ReleaseKey(Key.LControl);
+                });
+
+                AddAssert("Middle control point has the same distance from start to end", () =>
+                {
+                    var pathControlPoints = selectedSlider.Path.ControlPoints;
+                    float middleToStart = Vector2.Distance(pathControlPoints[^2].Position, pathControlPoints[0].Position);
+                    float middleToEnd = Vector2.Distance(pathControlPoints[^2].Position, pathControlPoints[^1].Position);
+
+                    return Precision.AlmostEquals(middleToStart, middleToEnd, 1f);
+                });
+
+                AddAssert("Middle control point is not at start or end", () =>
+                    Vector2.Distance(selectedSlider.Path.ControlPoints[^2].Position, oldStartPos) > 1 &&
+                    Vector2.Distance(selectedSlider.Path.ControlPoints[^2].Position, oldEndPos) > 1
+                );
+
+                AddAssert("Slider has correct length", () =>
+                    Precision.AlmostEquals(selectedSlider.Path.Distance, oldDistance));
+
+                AddAssert("Slider has correct start position", () =>
+                    Vector2.Distance(selectedSlider.Position, oldEndPos) < 1);
+
+                AddAssert("Slider has correct end position", () =>
+                    Vector2.Distance(selectedSlider.EndPosition, oldStartPos) < 1);
+
+                AddAssert("Control points have correct types", () =>
+                {
+                    var newControlPointTypes = selectedSlider.Path.ControlPoints.Select(p => p.Type).ToArray();
+
+                    return oldControlPointTypes.Take(newControlPointTypes.Length).SequenceEqual(newControlPointTypes);
+                });
+            }
+        }
+
+        [Test]
+        public void TestSegmentedSliderReversal()
+        {
+            PathControlPoint[] segmentedSliderPath =
+            [
+                new PathControlPoint
+                {
+                    Position = new Vector2(0, 0),
+                    Type = PathType.PERFECT_CURVE
+                },
+                new PathControlPoint
+                {
+                    Position = new Vector2(100, 150),
+                },
+                new PathControlPoint
+                {
+                    Position = new Vector2(75, -50),
+                    Type = PathType.PERFECT_CURVE
+                },
+                new PathControlPoint
+                {
+                    Position = new Vector2(225, -75),
+                },
+                new PathControlPoint
+                {
+                    Position = new Vector2(350, 50),
+                    Type = PathType.PERFECT_CURVE
+                },
+                new PathControlPoint
+                {
+                    Position = new Vector2(500, -75),
+                },
+                new PathControlPoint
+                {
+                    Position = new Vector2(350, -120),
+                },
+            ];
+
+            Vector2 oldStartPos = default;
+            Vector2 oldEndPos = default;
+            double oldDistance = default;
+
+            var oldControlPointTypes = segmentedSliderPath.Select(p => p.Type);
+
+            AddStep("Add slider", () =>
+            {
+                var slider = new Slider
+                {
+                    Position = new Vector2(0, 200),
+                    Path = new SliderPath(segmentedSliderPath)
+                    {
+                        ExpectedDistance = { Value = 1314 }
+                    }
+                };
+
+                EditorBeatmap.Add(slider);
+
+                oldStartPos = slider.Position;
+                oldEndPos = slider.EndPosition;
+                oldDistance = slider.Path.Distance;
+            });
+
+            AddStep("Select slider", () =>
+            {
+                var slider = (Slider)EditorBeatmap.HitObjects[0];
+                EditorBeatmap.SelectedHitObjects.Add(slider);
+            });
+
+            AddRepeatStep("Reverse slider", () =>
+            {
+                InputManager.PressKey(Key.LControl);
+                InputManager.Key(Key.G);
+                InputManager.ReleaseKey(Key.LControl);
+            }, 3);
+
+            AddAssert("First arc's control is not at the slider's middle", () =>
+                Vector2.Distance(selectedSlider.Path.ControlPoints[^2].Position, selectedSlider.Path.PositionAt(0.5)) > 1
+            );
+
+            AddAssert("Last arc's control is not at the slider's middle", () =>
+                Vector2.Distance(selectedSlider.Path.ControlPoints[1].Position, selectedSlider.Path.PositionAt(0.5)) > 1
+            );
+
+            AddAssert("First arc centered middle control point", () =>
+            {
+                var pathControlPoints = selectedSlider.Path.ControlPoints;
+                float middleToStart = Vector2.Distance(pathControlPoints[1].Position, pathControlPoints[0].Position);
+                float middleToEnd = Vector2.Distance(pathControlPoints[1].Position, pathControlPoints[2].Position);
+
+                return Precision.AlmostEquals(middleToStart, middleToEnd, 1f);
+            });
+
+            AddAssert("Last arc centered middle control point", () =>
+            {
+                var pathControlPoints = selectedSlider.Path.ControlPoints;
+                float middleToStart = Vector2.Distance(pathControlPoints[^2].Position, pathControlPoints[^3].Position);
+                float middleToEnd = Vector2.Distance(pathControlPoints[^2].Position, pathControlPoints[^1].Position);
+
+                return Precision.AlmostEquals(middleToStart, middleToEnd, 1f);
+            });
+
             AddAssert("Slider has correct length", () =>
                 Precision.AlmostEquals(selectedSlider.Path.Distance, oldDistance));
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSliderScaling.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
@@ -102,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
             for (int i = 0; i < 100; i++)
             {
-                Assert.True(Precision.AlmostEquals(sliderPathPerfect.PositionAt(i / 100.0f), sliderPathBezier.PositionAt(i / 100.0f)));
+                ClassicAssert.True(Precision.AlmostEquals(sliderPathPerfect.PositionAt(i / 100.0f), sliderPathBezier.PositionAt(i / 100.0f)));
             }
         }
 
@@ -174,7 +175,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
                 double theta = circularArcProperties.ThetaStart + (circularArcProperties.Direction * progress * circularArcProperties.ThetaRange);
                 Vector2 vector = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta)) * circularArcProperties.Radius;
 
-                Assert.True(Precision.AlmostEquals(circularArcProperties.Centre + vector, path.PositionAt(progress), 0.01f),
+                ClassicAssert.True(Precision.AlmostEquals(circularArcProperties.Centre + vector, path.PositionAt(progress), 0.01f),
                     "A perfect circle with points " + string.Join(", ", path.ControlPoints.Select(x => x.Position)) + " and radius" + circularArcProperties.Radius + "from SliderPath does not almost equal a theoretical perfect circle with " + subpoints + " subpoints"
                     + ": " + (circularArcProperties.Centre + vector) + " - " + path.PositionAt(progress)
                     + " = " + (circularArcProperties.Centre + vector - path.PositionAt(progress))

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModEasy.cs

@@ -0,0 +1,88 @@
+// 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.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public partial class TestSceneOsuModEasy : OsuModTestScene
+    {
+        protected override bool AllowFail => true;
+
+        [Test]
+        public void TestMultipleApplication()
+        {
+            bool reapplied = false;
+            CreateModTest(new ModTestData
+            {
+                Mods = [new OsuModEasy { Retries = { Value = 1 } }],
+                Autoplay = false,
+                CreateBeatmap = () =>
+                {
+                    // do stuff to speed up fails
+                    var b = new TestBeatmap(new OsuRuleset().RulesetInfo)
+                    {
+                        Difficulty = { DrainRate = 10 }
+                    };
+
+                    foreach (var ho in b.HitObjects)
+                        ho.StartTime /= 4;
+
+                    return b;
+                },
+                PassCondition = () =>
+                {
+                    if (((ModEasyTestPlayer)Player).FailuresSuppressed > 0 && !reapplied)
+                    {
+                        try
+                        {
+                            foreach (var mod in Player.GameplayState.Mods.OfType<IApplicableToDifficulty>())
+                                mod.ApplyToDifficulty(new BeatmapDifficulty());
+
+                            foreach (var mod in Player.GameplayState.Mods.OfType<IApplicableToPlayer>())
+                                mod.ApplyToPlayer(Player);
+                        }
+                        catch
+                        {
+                            // don't care if this fails. in fact a failure here is probably better than the alternative.
+                        }
+                        finally
+                        {
+                            reapplied = true;
+                        }
+                    }
+
+                    return Player.GameplayState.HasFailed && ((ModEasyTestPlayer)Player).FailuresSuppressed <= 1;
+                }
+            });
+        }
+
+        protected override TestPlayer CreateModPlayer(Ruleset ruleset) => new ModEasyTestPlayer(CurrentTestData, AllowFail);
+
+        private partial class ModEasyTestPlayer : ModTestPlayer
+        {
+            public int FailuresSuppressed { get; private set; }
+
+            public ModEasyTestPlayer(ModTestData data, bool allowFail)
+                : base(data, allowFail)
+            {
+            }
+
+            protected override bool CheckModsAllowFailure()
+            {
+                bool failureAllowed = GameplayState.Mods.OfType<IApplicableFailOverride>().All(m => m.PerformFail());
+
+                if (!failureAllowed)
+                    FailuresSuppressed++;
+
+                return failureAllowed;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFreezeFrame.cs

@@ -2,7 +2,10 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
 
 namespace osu.Game.Rulesets.Osu.Tests.Mods
 {
@@ -18,5 +21,39 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                 Autoplay = false,
             });
         }
+
+        [Test]
+        public void TestSkipToFirstCircleNotSuppressed()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModFreezeFrame(),
+                CreateBeatmap = () => new OsuBeatmap
+                {
+                    HitObjects =
+                    {
+                        new HitCircle { StartTime = 5000, Position = OsuPlayfield.BASE_SIZE / 2 }
+                    }
+                },
+                PassCondition = () => Player.GameplayClockContainer.GameplayStartTime > 0
+            });
+        }
+
+        [Test]
+        public void TestSkipToFirstSpinnerNotSuppressed()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModFreezeFrame(),
+                CreateBeatmap = () => new OsuBeatmap
+                {
+                    HitObjects =
+                    {
+                        new Spinner { StartTime = 5000, Position = OsuPlayfield.BASE_SIZE / 2 }
+                    }
+                },
+                PassCondition = () => Player.GameplayClockContainer.GameplayStartTime > 0
+            });
+        }
     }
 }

osu.Game.Rulesets.Osu.Tests/StackingTest.cs

@@ -5,6 +5,7 @@ using System;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.IO;
 using osu.Game.Rulesets.Mods;
@@ -57,7 +58,7 @@ SliderTickRate:0.5
 
                 // The last hitobject triggers the stacking
                 for (int i = 0; i < objects.Count - 1; i++)
-                    Assert.AreEqual(0, ((OsuHitObject)objects[i]).StackHeight);
+                    ClassicAssert.AreEqual(0, ((OsuHitObject)objects[i]).StackHeight);
             }
         }
 
@@ -104,7 +105,7 @@ SliderTickRate:1
 
                 // The last hitobject triggers the stacking
                 for (int i = 0; i < objects.Count - 1; i++)
-                    Assert.AreEqual(0, ((OsuHitObject)objects[i]).StackHeight);
+                    ClassicAssert.AreEqual(0, ((OsuHitObject)objects[i]).StackHeight);
             }
         }
     }

osu.Game.Rulesets.Osu.Tests/TestSceneAutoGeneration.cs

@@ -0,0 +1,63 @@
+// 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.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [TestFixture]
+    [HeadlessTest]
+    public partial class TestSceneAutoGeneration : OsuTestScene
+    {
+        [TestCase(-1, true)]
+        [TestCase(0, false)]
+        [TestCase(1, false)]
+        public void TestAlternating(double offset, bool shouldAlternate)
+        {
+            const double first_object_time = 1000;
+            double secondObjectTime = first_object_time + AutoGenerator.KEY_UP_DELAY + OsuAutoGenerator.MIN_FRAME_SEPARATION_FOR_ALTERNATING + offset;
+
+            var beatmap = new OsuBeatmap();
+            beatmap.HitObjects.Add(new HitCircle { StartTime = first_object_time });
+            beatmap.HitObjects.Add(new HitCircle { StartTime = secondObjectTime });
+
+            var generated = new OsuAutoGenerator(beatmap, []).Generate();
+            var frames = generated.Frames.OfType<OsuReplayFrame>().ToList();
+
+            Assert.That(frames.Exists(f => f.Time == first_object_time && f.Actions.SingleOrDefault() == OsuAction.LeftButton));
+            Assert.That(frames.Exists(f => f.Time == first_object_time + AutoGenerator.KEY_UP_DELAY && !f.Actions.Any()));
+
+            Assert.That(frames.Exists(f => f.Time == secondObjectTime && f.Actions.SingleOrDefault() == (shouldAlternate ? OsuAction.RightButton : OsuAction.LeftButton)));
+            Assert.That(frames.Exists(f => f.Time == secondObjectTime + AutoGenerator.KEY_UP_DELAY && !f.Actions.Any()));
+        }
+
+        [TestCase(300)]
+        [TestCase(600)]
+        [TestCase(1200)]
+        public void TestAlternatingSpecificBPM(double bpm)
+        {
+            const double first_object_time = 1000;
+            double secondObjectTime = first_object_time + 60000 / bpm;
+
+            var beatmap = new OsuBeatmap();
+            beatmap.HitObjects.Add(new HitCircle { StartTime = first_object_time });
+            beatmap.HitObjects.Add(new HitCircle { StartTime = secondObjectTime });
+
+            var generated = new OsuAutoGenerator(beatmap, []).Generate();
+            var frames = generated.Frames.OfType<OsuReplayFrame>().ToList();
+
+            Assert.That(frames.Exists(f => f.Time == first_object_time && f.Actions.SingleOrDefault() == OsuAction.LeftButton));
+            Assert.That(frames.Exists(f => f.Time == first_object_time + AutoGenerator.KEY_UP_DELAY && !f.Actions.Any()));
+
+            Assert.That(frames.Exists(f => f.Time == secondObjectTime && f.Actions.SingleOrDefault() == OsuAction.RightButton));
+            Assert.That(frames.Exists(f => f.Time == secondObjectTime + AutoGenerator.KEY_UP_DELAY && !f.Actions.Any()));
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/TestSceneShaking.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             Debug.Assert(drawableHitObject.HitObject.HitWindows != null);
 
             double delay = drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.WindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current;
-            scheduledTasks.Add(Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(), delay));
+            scheduledTasks.Add(Scheduler.AddDelayed(drawableHitObject.TriggerJudgement, delay));
 
             return drawableHitObject;
         }

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -1,10 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="Moq" Version="4.18.4" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs

@@ -7,6 +7,7 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Utils;
@@ -37,13 +38,16 @@ namespace osu.Game.Rulesets.Osu.Edit
         [Resolved]
         private IEditorChangeHandler? changeHandler { get; set; }
 
+        [Resolved]
+        private EditorBeatmap editorBeatmap { get; set; } = null!;
+
         [Resolved(CanBeNull = true)]
         private IDistanceSnapProvider? snapProvider { get; set; }
 
         private BindableList<HitObject> selectedItems { get; } = new BindableList<HitObject>();
 
         [BackgroundDependencyLoader]
-        private void load(EditorBeatmap editorBeatmap)
+        private void load()
         {
             selectedItems.BindTo(editorBeatmap.SelectedHitObjects);
         }
@@ -53,15 +57,22 @@ namespace osu.Game.Rulesets.Osu.Edit
             base.LoadComplete();
 
             selectedItems.CollectionChanged += (_, __) => updateState();
+            editorBeatmap.HitObjectUpdated += hitObjectUpdated;
             updateState();
         }
 
+        private void hitObjectUpdated(HitObject hitObject)
+        {
+            if (selectedMovableObjects.Contains(hitObject))
+                updateState();
+        }
+
         private void updateState()
         {
             var quad = GeometryUtils.GetSurroundingQuad(selectedMovableObjects);
 
-            CanScaleX.Value = quad.Width > 0;
-            CanScaleY.Value = quad.Height > 0;
+            CanScaleX.Value = Precision.DefinitelyBigger(quad.Width, 0);
+            CanScaleY.Value = Precision.DefinitelyBigger(quad.Height, 0);
             CanScaleDiagonally.Value = CanScaleX.Value && CanScaleY.Value;
             CanScaleFromPlayfieldOrigin.Value = selectedMovableObjects.Any();
             IsScalingSlider.Value = selectedMovableObjects.Count() == 1 && selectedMovableObjects.First() is Slider;
@@ -339,5 +350,13 @@ namespace osu.Game.Rulesets.Osu.Edit
                 PathControlPointTypes = (hitObject as IHasPath)?.Path.ControlPoints.Select(p => p.Type).ToArray();
             }
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (editorBeatmap.IsNotNull())
+                editorBeatmap.HitObjectUpdated -= hitObjectUpdated;
+        }
     }
 }

osu.Game.Rulesets.Osu/Edit/PolygonGenerationPopover.cs

@@ -25,10 +25,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 {
     public partial class PolygonGenerationPopover : OsuPopover
     {
-        private SliderWithTextBoxInput<double> distanceSnapInput = null!;
-        private SliderWithTextBoxInput<int> offsetAngleInput = null!;
-        private SliderWithTextBoxInput<int> repeatCountInput = null!;
-        private SliderWithTextBoxInput<int> pointInput = null!;
+        private FormSliderBar<double> distanceSnapInput { get; set; } = null!;
+        private FormSliderBar<int> offsetAngleInput { get; set; } = null!;
+        private FormSliderBar<int> repeatCountInput { get; set; } = null!;
+        private FormSliderBar<int> pointInput { get; set; } = null!;
         private RoundedButton commitButton = null!;
 
         private readonly List<HitCircle> insertedCircles = new List<HitCircle>();
@@ -64,11 +64,12 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 Width = 220,
                 AutoSizeAxes = Axes.Y,
-                Spacing = new Vector2(20),
+                Spacing = new Vector2(5),
                 Children = new Drawable[]
                 {
-                    distanceSnapInput = new SliderWithTextBoxInput<double>("Distance snap:")
+                    distanceSnapInput = new FormSliderBar<double>
                     {
+                        Caption = "Distance snap",
                         Current = new BindableNumber<double>(1)
                         {
                             MinValue = 0.1,
@@ -76,37 +77,40 @@ namespace osu.Game.Rulesets.Osu.Edit
                             Precision = 0.1,
                             Value = ((OsuHitObjectComposer)composer).DistanceSnapProvider.DistanceSpacingMultiplier.Value,
                         },
-                        Instantaneous = true
+                        TabbableContentContainer = this
                     },
-                    offsetAngleInput = new SliderWithTextBoxInput<int>("Offset angle:")
+                    offsetAngleInput = new FormSliderBar<int>
                     {
+                        Caption = "Offset angle",
                         Current = new BindableNumber<int>
                         {
                             MinValue = 0,
                             MaxValue = 180,
                             Precision = 1
                         },
-                        Instantaneous = true
+                        TabbableContentContainer = this
                     },
-                    repeatCountInput = new SliderWithTextBoxInput<int>("Repeats:")
+                    repeatCountInput = new FormSliderBar<int>
                     {
+                        Caption = "Repeats",
                         Current = new BindableNumber<int>(1)
                         {
                             MinValue = 1,
                             MaxValue = 10,
                             Precision = 1
                         },
-                        Instantaneous = true
+                        TabbableContentContainer = this
                     },
-                    pointInput = new SliderWithTextBoxInput<int>("Vertices:")
+                    pointInput = new FormSliderBar<int>
                     {
+                        Caption = "Vertices",
                         Current = new BindableNumber<int>(3)
                         {
                             MinValue = 3,
                             MaxValue = 32,
                             Precision = 1,
                         },
-                        Instantaneous = true
+                        TabbableContentContainer = this
                     },
                     commitButton = new RoundedButton
                     {

osu.Game.Rulesets.Osu/Edit/PreciseMovementPopover.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         private BindableNumber<float> xBindable = null!;
         private BindableNumber<float> yBindable = null!;
 
-        private SliderWithTextBoxInput<float> xInput = null!;
+        private FormSliderBar<float> xInput { get; set; } = null!;
         private OsuCheckbox relativeCheckbox = null!;
 
         public PreciseMovementPopover()
@@ -52,31 +52,31 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 Width = 220,
                 AutoSizeAxes = Axes.Y,
-                Spacing = new Vector2(20),
+                Spacing = new Vector2(5),
                 Children = new Drawable[]
                 {
-                    xInput = new SliderWithTextBoxInput<float>("X:")
+                    xInput = new FormSliderBar<float>
                     {
+                        Caption = "X",
                         Current = xBindable = new BindableNumber<float>
                         {
                             Precision = 1,
                         },
-                        Instantaneous = true,
-                        TabbableContentContainer = this,
+                        TabbableContentContainer = this
                     },
-                    new SliderWithTextBoxInput<float>("Y:")
+                    new FormSliderBar<float>
                     {
+                        Caption = "Y",
                         Current = yBindable = new BindableNumber<float>
                         {
                             Precision = 1,
                         },
-                        Instantaneous = true,
-                        TabbableContentContainer = this,
+                        TabbableContentContainer = this
                     },
                     relativeCheckbox = new OsuCheckbox(false)
                     {
                         RelativeSizeAxes = Axes.X,
-                        LabelText = "Relative movement",
+                        LabelText = "Relative movement"
                     }
                 }
             };

osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private readonly Bindable<PreciseRotationInfo> rotationInfo = new Bindable<PreciseRotationInfo>(new PreciseRotationInfo(0, EditorOrigin.GridCentre));
 
-        private SliderWithTextBoxInput<float> angleInput = null!;
+        private FormSliderBar<float> angleInput { get; set; } = null!;
         private EditorRadioButtonCollection rotationOrigin = null!;
 
         private RadioButton gridCentreButton = null!;
@@ -54,11 +54,12 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 Width = 220,
                 AutoSizeAxes = Axes.Y,
-                Spacing = new Vector2(20),
+                Spacing = new Vector2(5),
                 Children = new Drawable[]
                 {
-                    angleInput = new SliderWithTextBoxInput<float>("Angle (degrees):")
+                    angleInput = new FormSliderBar<float>
                     {
+                        Caption = "Angle (degrees)",
                         Current = new BindableNumber<float>
                         {
                             MinValue = -360,
@@ -66,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                             Precision = 1
                         },
                         KeyboardStep = 1f,
-                        Instantaneous = true
+                        TabbableContentContainer = this
                     },
                     rotationOrigin = new EditorRadioButtonCollection
                     {

osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private readonly Bindable<PreciseScaleInfo> scaleInfo = new Bindable<PreciseScaleInfo>(new PreciseScaleInfo(1, EditorOrigin.GridCentre, true, true));
 
-        private SliderWithTextBoxInput<float> scaleInput = null!;
+        private FormSliderBar<float> scaleInput { get; set; } = null!;
         private BindableNumber<float> scaleInputBindable = null!;
         private EditorRadioButtonCollection scaleOrigin = null!;
 
@@ -66,11 +66,12 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 Width = 220,
                 AutoSizeAxes = Axes.Y,
-                Spacing = new Vector2(20),
+                Spacing = new Vector2(5),
                 Children = new Drawable[]
                 {
-                    scaleInput = new SliderWithTextBoxInput<float>("Scale:")
+                    scaleInput = new FormSliderBar<float>
                     {
+                        Caption = "Scale",
                         Current = scaleInputBindable = new BindableNumber<float>
                         {
                             MinValue = 0.05f,
@@ -80,7 +81,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                             Default = 1,
                         },
                         KeyboardStep = 0.01f,
-                        Instantaneous = true
+                        TabbableContentContainer = this
                     },
                     scaleOrigin = new EditorRadioButtonCollection
                     {

osu.Game.Rulesets.Osu/Mods/OsuModBloom.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         [SettingSource(
             "Max size at combo",
             "The combo count at which the cursor reaches its maximum size",
-            SettingControlType = typeof(SettingsSlider<int, RoundedSliderBar<int>>)
+            SettingControlType = typeof(SettingsSlider<int, MaxSizeComboSlider>)
         )]
         public BindableInt MaxSizeComboCount { get; } = new BindableInt(50)
         {
@@ -85,4 +85,12 @@ namespace osu.Game.Rulesets.Osu.Mods
                 cursor.ModScaleAdjust.Value = (float)Interpolation.Lerp(cursor.ModScaleAdjust.Value, currentSize, Math.Clamp(cursor.Time.Elapsed / TRANSITION_DURATION, 0, 1));
         }
     }
+
+    public partial class MaxSizeComboSlider : RoundedSliderBar<int>
+    {
+        public MaxSizeComboSlider()
+        {
+            KeyboardStep = 1;
+        }
+    }
 }

osu.Game.Rulesets.Osu/Mods/OsuModDifficultyAdjust.cs

@@ -1,7 +1,9 @@
 // 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.Bindables;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
@@ -71,6 +73,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
         }
 
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModTargetPractice)).ToArray();
+
         protected override void ApplySettings(BeatmapDifficulty difficulty)
         {
             base.ApplySettings(difficulty);

osu.Game.Rulesets.Osu/Mods/OsuModFreezeFrame.cs

@@ -27,8 +27,10 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public override LocalisableString Description => "Burn the notes into your memory.";
 
-        //Alters the transforms of the approach circles, breaking the effects of these mods.
-        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModApproachDifferent), typeof(OsuModTransform), typeof(OsuModDepth) }).ToArray();
+        /// <remarks>
+        /// Incompatible with all mods that directly modify or indirectly depend on <see cref="OsuHitObject.TimePreempt"/>, or alter the behaviour of approach circles.
+        /// </remarks>
+        public override Type[] IncompatibleMods => base.IncompatibleMods.Concat(new[] { typeof(OsuModApproachDifferent), typeof(OsuModTransform), typeof(OsuModDepth), typeof(OsuModHidden) }).ToArray();
 
         public override ModType Type => ModType.Fun;
 
@@ -57,16 +59,25 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             void applyFadeInAdjustment(OsuHitObject osuObject)
             {
-                osuObject.TimePreempt += osuObject.StartTime - lastNewComboTime;
+                if (osuObject is not Spinner)
+                    osuObject.TimePreempt += osuObject.StartTime - lastNewComboTime;
+
+                int repeatCount = 0;
 
                 foreach (var nested in osuObject.NestedHitObjects.OfType<OsuHitObject>())
                 {
                     switch (nested)
                     {
-                        //Freezing the SliderTicks doesnt play well with snaking sliders
+                        // Freezing the SliderTicks doesnt play well with snaking sliders
                         case SliderTick:
-                        //SliderRepeat wont layer correctly if preempt is changed.
+                            break;
+
                         case SliderRepeat:
+                            if (repeatCount > 2)
+                                break;
+
+                            applyFadeInAdjustment(nested);
+                            repeatCount++;
                             break;
 
                         default:

osu.Game.Rulesets.Osu/Mods/OsuModHidden.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override LocalisableString Description => @"Play with no approach circles and fading circles/sliders.";
         public override double ScoreMultiplier => UsesDefaultConfiguration ? 1.06 : 1;
 
-        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModDepth) };
+        public override Type[] IncompatibleMods => new[] { typeof(IRequiresApproachCircles), typeof(OsuModSpinIn), typeof(OsuModDepth), typeof(OsuModFreezeFrame) };
 
         public const double FADE_IN_DURATION_MULTIPLIER = 0.4;
         public const double FADE_OUT_DURATION_MULTIPLIER = 0.3;

osu.Game.Rulesets.Osu/Mods/OsuModTargetPractice.cs

@@ -48,7 +48,8 @@ namespace osu.Game.Rulesets.Osu.Mods
             typeof(OsuModSpunOut),
             typeof(OsuModStrictTracking),
             typeof(OsuModSuddenDeath),
-            typeof(OsuModDepth)
+            typeof(OsuModDepth),
+            typeof(OsuModDifficultyAdjust),
         }).ToArray();
 
         [SettingSource("Seed", "Use a custom seed instead of a random one", SettingControlType = typeof(SettingsNumberBox))]

osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override string Name => "Traceable";
         public override string Acronym => "TC";
         public override IconUsage? Icon => OsuIcon.ModTraceable;
-        public override ModType Type => ModType.Fun;
+        public override ModType Type => ModType.DifficultyIncrease;
         public override LocalisableString Description => "Put your faith in the approach circles...";
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -175,7 +175,7 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModHardRock(),
                         new MultiMod(new OsuModSuddenDeath(), new OsuModPerfect()),
                         new MultiMod(new OsuModDoubleTime(), new OsuModNightcore()),
-                        new OsuModHidden(),
+                        new MultiMod(new OsuModHidden(), new OsuModTraceable()),
                         new MultiMod(new OsuModFlashlight(), new OsuModBlinds()),
                         new OsuModStrictTracking(),
                         new OsuModAccuracyChallenge(),
@@ -209,7 +209,6 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModSpinIn(),
                         new MultiMod(new OsuModGrow(), new OsuModDeflate()),
                         new MultiMod(new ModWindUp(), new ModWindDown()),
-                        new OsuModTraceable(),
                         new OsuModBarrelRoll(),
                         new OsuModApproachDifferent(),
                         new OsuModMuted(),
@@ -278,19 +277,24 @@ namespace osu.Game.Rulesets.Osu
 
         public override IRulesetConfigManager CreateConfig(SettingsStore? settings) => new OsuRulesetConfigManager(settings, RulesetInfo);
 
-        protected override IEnumerable<HitResult> GetValidHitResults()
+        public override IEnumerable<HitResult> GetValidHitResults()
         {
             return new[]
             {
                 HitResult.Great,
                 HitResult.Ok,
                 HitResult.Meh,
+                HitResult.Miss,
 
                 HitResult.LargeTickHit,
+                HitResult.LargeTickMiss,
                 HitResult.SmallTickHit,
+                HitResult.SmallTickMiss,
                 HitResult.SliderTailHit,
                 HitResult.SmallBonus,
                 HitResult.LargeBonus,
+                HitResult.IgnoreHit,
+                HitResult.IgnoreMiss,
             };
         }
 

osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs

@@ -21,6 +21,8 @@ namespace osu.Game.Rulesets.Osu.Replays
 {
     public class OsuAutoGenerator : OsuAutoGeneratorBase
     {
+        public const double MIN_FRAME_SEPARATION_FOR_ALTERNATING = 266;
+
         public new OsuBeatmap Beatmap => (OsuBeatmap)base.Beatmap;
 
         #region Parameters
@@ -245,7 +247,7 @@ namespace osu.Game.Rulesets.Osu.Replays
             double timeDifference = ApplyModsToTimeDelta(lastFrame.Time, h.StartTime);
             OsuReplayFrame? lastLastFrame = Frames.Count >= 2 ? (OsuReplayFrame)Frames[^2] : null;
 
-            if (timeDifference > 0)
+            if (timeDifference >= 0)
             {
                 // If the last frame is a key-up frame and there has been no wait period, adjust the last frame's position such that it begins eased movement instantaneously.
                 if (lastLastFrame != null && lastFrame is OsuKeyUpReplayFrame && !hasWaited)
@@ -266,7 +268,7 @@ namespace osu.Game.Rulesets.Osu.Replays
             }
 
             // Start alternating once the time separation is too small (faster than ~225BPM).
-            if (timeDifference > 0 && timeDifference < 266)
+            if (timeDifference >= 0 && timeDifference < MIN_FRAME_SEPARATION_FOR_ALTERNATING)
                 buttonIndex++;
             else
                 buttonIndex = 0;

osu.Game.Rulesets.Osu/UI/OsuSettingsSubsection.cs

@@ -3,7 +3,9 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Localisation;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Osu.Configuration;
@@ -27,32 +29,34 @@ namespace osu.Game.Rulesets.Osu.UI
 
             Children = new Drawable[]
             {
-                new SettingsCheckbox
+                new SettingsItemV2(new FormCheckBox
                 {
-                    LabelText = RulesetSettingsStrings.SnakingInSliders,
+                    Caption = RulesetSettingsStrings.SnakingInSliders,
                     Current = config.GetBindable<bool>(OsuRulesetSetting.SnakingInSliders)
-                },
-                new SettingsCheckbox
+                }),
+                new SettingsItemV2(new FormCheckBox
                 {
-                    ClassicDefault = false,
-                    LabelText = RulesetSettingsStrings.SnakingOutSliders,
+                    Caption = RulesetSettingsStrings.SnakingOutSliders,
                     Current = config.GetBindable<bool>(OsuRulesetSetting.SnakingOutSliders)
-                },
-                new SettingsCheckbox
+                })
                 {
-                    LabelText = RulesetSettingsStrings.CursorTrail,
+                    ApplyClassicDefault = c => ((IHasCurrentValue<bool>)c).Current.Value = false,
+                },
+                new SettingsItemV2(new FormCheckBox
+                {
+                    Caption = RulesetSettingsStrings.CursorTrail,
                     Current = config.GetBindable<bool>(OsuRulesetSetting.ShowCursorTrail)
-                },
-                new SettingsCheckbox
+                }),
+                new SettingsItemV2(new FormCheckBox
                 {
-                    LabelText = RulesetSettingsStrings.CursorRipples,
+                    Caption = RulesetSettingsStrings.CursorRipples,
                     Current = config.GetBindable<bool>(OsuRulesetSetting.ShowCursorRipples)
-                },
-                new SettingsEnumDropdown<PlayfieldBorderStyle>
+                }),
+                new SettingsItemV2(new FormEnumDropdown<PlayfieldBorderStyle>
                 {
-                    LabelText = RulesetSettingsStrings.PlayfieldBorderStyle,
+                    Caption = RulesetSettingsStrings.PlayfieldBorderStyle,
                     Current = config.GetBindable<PlayfieldBorderStyle>(OsuRulesetSetting.PlayfieldBorderStyle),
-                },
+                }),
             };
         }
     }

osu.Game.Rulesets.Taiko.Tests.iOS/Info.plist

@@ -35,11 +35,9 @@
 		<string>UIInterfaceOrientationLandscapeRight</string>
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 	</array>
-	<key>XSAppIconAssets</key>
-	<string>Assets.xcassets/AppIcon.appiconset</string>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>CADisableMinimumFrameDurationOnPhone</key>
 	<true/>
 </dict>
-</plist>
+</plist>

osu.Game.Rulesets.Taiko.Tests/Editor/TestSceneTaikoEditorSaving.cs

@@ -35,7 +35,7 @@ namespace osu.Game.Rulesets.Taiko.Tests.Editor
                 string export = LocalStorage.GetFiles("exports").First();
 
                 using (var stream = LocalStorage.GetStream(export))
-                using (var zip = ZipArchive.Open(stream))
+                using (var zip = ZipArchive.OpenArchive(stream))
                 {
                     using (var osuStream = zip.Entries.First().OpenEntryStream())
                     using (var reader = new StreamReader(osuStream))

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -1,9 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
-    <PackageReference Include="NUnit" Version="3.14.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="NUnit" Version="4.5.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Rulesets.Taiko/Mods/TaikoModSimplifiedRhythm.cs

@@ -122,6 +122,8 @@ namespace osu.Game.Rulesets.Taiko.Mods
                     }
                 }
             }
+
+            taikoBeatmap.HitObjects.Sort((a, b) => a.StartTime.CompareTo(b.StartTime));
         }
 
         private int getSnapBetweenNotes(ControlPointInfo controlPointInfo, Hit currentNote, Hit nextNote)

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -222,15 +222,18 @@ namespace osu.Game.Rulesets.Taiko
 
         public override RulesetSettingsSubsection CreateSettings() => new TaikoSettingsSubsection(this);
 
-        protected override IEnumerable<HitResult> GetValidHitResults()
+        public override IEnumerable<HitResult> GetValidHitResults()
         {
             return new[]
             {
                 HitResult.Great,
                 HitResult.Ok,
+                HitResult.Miss,
 
                 HitResult.SmallBonus,
                 HitResult.LargeBonus,
+                HitResult.IgnoreHit,
+                HitResult.IgnoreMiss,
             };
         }
 

osu.Game.Rulesets.Taiko/TaikoSettingsSubsection.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
+using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Taiko.Configuration;
@@ -26,11 +27,11 @@ namespace osu.Game.Rulesets.Taiko
 
             Children = new Drawable[]
             {
-                new SettingsEnumDropdown<TaikoTouchControlScheme>
+                new SettingsItemV2(new FormEnumDropdown<TaikoTouchControlScheme>
                 {
-                    LabelText = RulesetSettingsStrings.TouchControlScheme,
+                    Caption = RulesetSettingsStrings.TouchControlScheme,
                     Current = config.GetBindable<TaikoTouchControlScheme>(TaikoRulesetSetting.TouchControlScheme)
-                }
+                })
             };
         }
     }

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -194,7 +194,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
             var hitWindows = new TaikoHitWindows();
 
-            HitResult[] usableHitResults = Enum.GetValues<HitResult>().Where(r => hitWindows.IsHitResultAllowed(r)).ToArray();
+            HitResult[] usableHitResults = Enum.GetValues<HitResult>().Where(hitWindows.IsHitResultAllowed).ToArray();
 
             AddInternal(judgementPooler = new JudgementPooler<DrawableTaikoJudgement>(usableHitResults));
 

osu.Game.Tests.iOS/Info.plist

@@ -35,8 +35,31 @@
 		<string>UIInterfaceOrientationLandscapeRight</string>
 		<string>UIInterfaceOrientationLandscapeLeft</string>
 	</array>
-	<key>XSAppIconAssets</key>
-	<string>Assets.xcassets/AppIcon.appiconset</string>
+    <key>CFBundleIcons~ipad</key>
+    <dict>
+        <key>CFBundlePrimaryIcon</key>
+        <dict>
+            <key>CFBundleIconFiles</key>
+            <array>
+                <string>AppIcon60x60</string>
+            </array>
+            <key>CFBundleIconName</key>
+            <string>AppIcon</string>
+        </dict>
+    </dict>
+    <key>CFBundleIcons</key>
+    <dict>
+        <key>CFBundlePrimaryIcon</key>
+        <dict>
+            <key>CFBundleIconFiles</key>
+            <array>
+                <string>AppIcon60x60</string>
+                <string>AppIcon76x76</string>
+            </array>
+            <key>CFBundleIconName</key>
+            <string>AppIcon</string>
+        </dict>
+    </dict>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>CADisableMinimumFrameDurationOnPhone</key>

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -6,6 +6,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
@@ -42,9 +43,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var decoder = Decoder.GetDecoder<Beatmap>(stream);
                 var working = new TestWorkingBeatmap(decoder.Decode(stream));
 
-                Assert.AreEqual(6, working.Beatmap.BeatmapVersion);
+                ClassicAssert.AreEqual(6, working.Beatmap.BeatmapVersion);
                 Assert.That(working.Beatmap.BeatmapInfo.Ruleset.Name, Is.Not.EqualTo("null placeholder ruleset"));
-                Assert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapVersion);
+                ClassicAssert.AreEqual(6, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapVersion);
             }
         }
 
@@ -59,10 +60,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 ((LegacyBeatmapDecoder)decoder).ApplyOffsets = applyOffsets;
                 var working = new TestWorkingBeatmap(decoder.Decode(stream));
 
-                Assert.AreEqual(4, working.Beatmap.BeatmapVersion);
-                Assert.AreEqual(4, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapVersion);
+                ClassicAssert.AreEqual(4, working.Beatmap.BeatmapVersion);
+                ClassicAssert.AreEqual(4, working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo, Array.Empty<Mod>()).BeatmapVersion);
 
-                Assert.AreEqual(-1, working.BeatmapInfo.Metadata.PreviewTime);
+                ClassicAssert.AreEqual(-1, working.BeatmapInfo.Metadata.PreviewTime);
             }
         }
 
@@ -78,17 +79,17 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var beatmapInfo = beatmap.BeatmapInfo;
                 var metadata = beatmap.Metadata;
 
-                Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", metadata.AudioFile);
-                Assert.AreEqual(0, beatmap.AudioLeadIn);
-                Assert.AreEqual(164471, metadata.PreviewTime);
-                Assert.AreEqual(0.7f, beatmap.StackLeniency);
-                Assert.IsTrue(beatmapInfo.Ruleset.OnlineID == 0);
-                Assert.IsFalse(beatmap.LetterboxInBreaks);
-                Assert.IsFalse(beatmap.SpecialStyle);
-                Assert.IsFalse(beatmap.WidescreenStoryboard);
-                Assert.IsFalse(beatmap.SamplesMatchPlaybackRate);
-                Assert.AreEqual(CountdownType.None, beatmap.Countdown);
-                Assert.AreEqual(0, beatmap.CountdownOffset);
+                ClassicAssert.AreEqual("03. Renatus - Soleily 192kbps.mp3", metadata.AudioFile);
+                ClassicAssert.AreEqual(0, beatmap.AudioLeadIn);
+                ClassicAssert.AreEqual(164471, metadata.PreviewTime);
+                ClassicAssert.AreEqual(0.7f, beatmap.StackLeniency);
+                ClassicAssert.True(beatmapInfo.Ruleset.OnlineID == 0);
+                ClassicAssert.False(beatmap.LetterboxInBreaks);
+                ClassicAssert.False(beatmap.SpecialStyle);
+                ClassicAssert.False(beatmap.WidescreenStoryboard);
+                ClassicAssert.False(beatmap.SamplesMatchPlaybackRate);
+                ClassicAssert.AreEqual(CountdownType.None, beatmap.Countdown);
+                ClassicAssert.AreEqual(0, beatmap.CountdownOffset);
             }
         }
 
@@ -108,13 +109,13 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     95901, 106450, 116999, 119637, 130186, 140735, 151285,
                     161834, 164471, 175020, 185570, 196119, 206669, 209306
                 };
-                Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
+                ClassicAssert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
                 for (int i = 0; i < expectedBookmarks.Length; i++)
-                    Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
-                Assert.AreEqual(1.8, beatmap.DistanceSpacing);
-                Assert.AreEqual(4, beatmap.BeatmapInfo.BeatDivisor);
-                Assert.AreEqual(4, beatmap.GridSize);
-                Assert.AreEqual(2, beatmap.TimelineZoom);
+                    ClassicAssert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
+                ClassicAssert.AreEqual(1.8, beatmap.DistanceSpacing);
+                ClassicAssert.AreEqual(4, beatmap.BeatmapInfo.BeatDivisor);
+                ClassicAssert.AreEqual(4, beatmap.GridSize);
+                ClassicAssert.AreEqual(2, beatmap.TimelineZoom);
             }
         }
 
@@ -130,16 +131,16 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var beatmapInfo = beatmap.BeatmapInfo;
                 var metadata = beatmap.Metadata;
 
-                Assert.AreEqual("Renatus", metadata.Title);
-                Assert.AreEqual("Renatus", metadata.TitleUnicode);
-                Assert.AreEqual("Soleily", metadata.Artist);
-                Assert.AreEqual("Soleily", metadata.ArtistUnicode);
-                Assert.AreEqual("Gamu", metadata.Author.Username);
-                Assert.AreEqual("Insane", beatmapInfo.DifficultyName);
-                Assert.AreEqual(string.Empty, metadata.Source);
-                Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", metadata.Tags);
-                Assert.AreEqual(557821, beatmapInfo.OnlineID);
-                Assert.AreEqual(241526, beatmapInfo.BeatmapSet?.OnlineID);
+                ClassicAssert.AreEqual("Renatus", metadata.Title);
+                ClassicAssert.AreEqual("Renatus", metadata.TitleUnicode);
+                ClassicAssert.AreEqual("Soleily", metadata.Artist);
+                ClassicAssert.AreEqual("Soleily", metadata.ArtistUnicode);
+                ClassicAssert.AreEqual("Gamu", metadata.Author.Username);
+                ClassicAssert.AreEqual("Insane", beatmapInfo.DifficultyName);
+                ClassicAssert.AreEqual(string.Empty, metadata.Source);
+                ClassicAssert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", metadata.Tags);
+                ClassicAssert.AreEqual(557821, beatmapInfo.OnlineID);
+                ClassicAssert.AreEqual(241526, beatmapInfo.BeatmapSet?.OnlineID);
             }
         }
 
@@ -153,12 +154,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var difficulty = decoder.Decode(stream).Difficulty;
 
-                Assert.AreEqual(6.5f, difficulty.DrainRate);
-                Assert.AreEqual(4, difficulty.CircleSize);
-                Assert.AreEqual(8, difficulty.OverallDifficulty);
-                Assert.AreEqual(9, difficulty.ApproachRate);
-                Assert.AreEqual(1.8, difficulty.SliderMultiplier);
-                Assert.AreEqual(2, difficulty.SliderTickRate);
+                ClassicAssert.AreEqual(6.5f, difficulty.DrainRate);
+                ClassicAssert.AreEqual(4, difficulty.CircleSize);
+                ClassicAssert.AreEqual(8, difficulty.OverallDifficulty);
+                ClassicAssert.AreEqual(9, difficulty.ApproachRate);
+                ClassicAssert.AreEqual(1.8, difficulty.SliderMultiplier);
+                ClassicAssert.AreEqual(2, difficulty.SliderTickRate);
             }
         }
 
@@ -174,10 +175,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var metadata = beatmap.Metadata;
                 var breakPoint = beatmap.Breaks[0];
 
-                Assert.AreEqual("machinetop_background.jpg", metadata.BackgroundFile);
-                Assert.AreEqual(122474, breakPoint.StartTime);
-                Assert.AreEqual(140135, breakPoint.EndTime);
-                Assert.IsTrue(breakPoint.HasEffect);
+                ClassicAssert.AreEqual("machinetop_background.jpg", metadata.BackgroundFile);
+                ClassicAssert.AreEqual(122474, breakPoint.StartTime);
+                ClassicAssert.AreEqual(140135, breakPoint.EndTime);
+                ClassicAssert.True(breakPoint.HasEffect);
             }
         }
 
@@ -192,7 +193,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var beatmap = decoder.Decode(stream);
                 var metadata = beatmap.Metadata;
 
-                Assert.AreEqual("BG.jpg", metadata.BackgroundFile);
+                ClassicAssert.AreEqual("BG.jpg", metadata.BackgroundFile);
             }
         }
 
@@ -207,7 +208,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var beatmap = decoder.Decode(stream);
                 var metadata = beatmap.Metadata;
 
-                Assert.AreEqual("BG.jpg", metadata.BackgroundFile);
+                ClassicAssert.AreEqual("BG.jpg", metadata.BackgroundFile);
             }
         }
 
@@ -222,7 +223,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var beatmap = decoder.Decode(stream);
                 var metadata = beatmap.Metadata;
 
-                Assert.AreEqual("BG.jpg", metadata.BackgroundFile);
+                ClassicAssert.AreEqual("BG.jpg", metadata.BackgroundFile);
             }
         }
 
@@ -237,67 +238,67 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var beatmap = decoder.Decode(stream);
                 var controlPoints = (LegacyControlPointInfo)beatmap.ControlPointInfo;
 
-                Assert.AreEqual(4, controlPoints.TimingPoints.Count);
-                Assert.AreEqual(5, controlPoints.DifficultyPoints.Count);
-                Assert.AreEqual(34, controlPoints.SamplePoints.Count);
-                Assert.AreEqual(8, controlPoints.EffectPoints.Count);
+                ClassicAssert.AreEqual(4, controlPoints.TimingPoints.Count);
+                ClassicAssert.AreEqual(5, controlPoints.DifficultyPoints.Count);
+                ClassicAssert.AreEqual(34, controlPoints.SamplePoints.Count);
+                ClassicAssert.AreEqual(8, controlPoints.EffectPoints.Count);
 
                 var timingPoint = controlPoints.TimingPointAt(0);
-                Assert.AreEqual(956, timingPoint.Time);
-                Assert.AreEqual(329.67032967033, timingPoint.BeatLength);
-                Assert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
-                Assert.IsFalse(timingPoint.OmitFirstBarLine);
+                ClassicAssert.AreEqual(956, timingPoint.Time);
+                ClassicAssert.AreEqual(329.67032967033, timingPoint.BeatLength);
+                ClassicAssert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
+                ClassicAssert.False(timingPoint.OmitFirstBarLine);
 
                 timingPoint = controlPoints.TimingPointAt(48428);
-                Assert.AreEqual(956, timingPoint.Time);
-                Assert.AreEqual(329.67032967033d, timingPoint.BeatLength);
-                Assert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
-                Assert.IsFalse(timingPoint.OmitFirstBarLine);
+                ClassicAssert.AreEqual(956, timingPoint.Time);
+                ClassicAssert.AreEqual(329.67032967033d, timingPoint.BeatLength);
+                ClassicAssert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
+                ClassicAssert.False(timingPoint.OmitFirstBarLine);
 
                 timingPoint = controlPoints.TimingPointAt(119637);
-                Assert.AreEqual(119637, timingPoint.Time);
-                Assert.AreEqual(659.340659340659, timingPoint.BeatLength);
-                Assert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
-                Assert.IsFalse(timingPoint.OmitFirstBarLine);
+                ClassicAssert.AreEqual(119637, timingPoint.Time);
+                ClassicAssert.AreEqual(659.340659340659, timingPoint.BeatLength);
+                ClassicAssert.AreEqual(TimeSignature.SimpleQuadruple, timingPoint.TimeSignature);
+                ClassicAssert.False(timingPoint.OmitFirstBarLine);
 
                 var difficultyPoint = controlPoints.DifficultyPointAt(0);
-                Assert.AreEqual(0, difficultyPoint.Time);
-                Assert.AreEqual(1.0, difficultyPoint.SliderVelocity);
+                ClassicAssert.AreEqual(0, difficultyPoint.Time);
+                ClassicAssert.AreEqual(1.0, difficultyPoint.SliderVelocity);
 
                 difficultyPoint = controlPoints.DifficultyPointAt(48428);
-                Assert.AreEqual(0, difficultyPoint.Time);
-                Assert.AreEqual(1.0, difficultyPoint.SliderVelocity);
+                ClassicAssert.AreEqual(0, difficultyPoint.Time);
+                ClassicAssert.AreEqual(1.0, difficultyPoint.SliderVelocity);
 
                 difficultyPoint = controlPoints.DifficultyPointAt(116999);
-                Assert.AreEqual(116999, difficultyPoint.Time);
-                Assert.AreEqual(0.75, difficultyPoint.SliderVelocity, 0.1);
+                ClassicAssert.AreEqual(116999, difficultyPoint.Time);
+                ClassicAssert.AreEqual(0.75, difficultyPoint.SliderVelocity, 0.1);
 
                 var soundPoint = controlPoints.SamplePointAt(0);
-                Assert.AreEqual(956, soundPoint.Time);
-                Assert.AreEqual(HitSampleInfo.BANK_SOFT, soundPoint.SampleBank);
-                Assert.AreEqual(60, soundPoint.SampleVolume);
+                ClassicAssert.AreEqual(956, soundPoint.Time);
+                ClassicAssert.AreEqual(HitSampleInfo.BANK_SOFT, soundPoint.SampleBank);
+                ClassicAssert.AreEqual(60, soundPoint.SampleVolume);
 
                 soundPoint = controlPoints.SamplePointAt(53373);
-                Assert.AreEqual(53373, soundPoint.Time);
-                Assert.AreEqual(HitSampleInfo.BANK_SOFT, soundPoint.SampleBank);
-                Assert.AreEqual(60, soundPoint.SampleVolume);
+                ClassicAssert.AreEqual(53373, soundPoint.Time);
+                ClassicAssert.AreEqual(HitSampleInfo.BANK_SOFT, soundPoint.SampleBank);
+                ClassicAssert.AreEqual(60, soundPoint.SampleVolume);
 
                 soundPoint = controlPoints.SamplePointAt(119637);
-                Assert.AreEqual(119637, soundPoint.Time);
-                Assert.AreEqual(HitSampleInfo.BANK_SOFT, soundPoint.SampleBank);
-                Assert.AreEqual(80, soundPoint.SampleVolume);
+                ClassicAssert.AreEqual(119637, soundPoint.Time);
+                ClassicAssert.AreEqual(HitSampleInfo.BANK_SOFT, soundPoint.SampleBank);
+                ClassicAssert.AreEqual(80, soundPoint.SampleVolume);
 
                 var effectPoint = controlPoints.EffectPointAt(0);
-                Assert.AreEqual(0, effectPoint.Time);
-                Assert.IsFalse(effectPoint.KiaiMode);
+                ClassicAssert.AreEqual(0, effectPoint.Time);
+                ClassicAssert.False(effectPoint.KiaiMode);
 
                 effectPoint = controlPoints.EffectPointAt(53703);
-                Assert.AreEqual(53703, effectPoint.Time);
-                Assert.IsTrue(effectPoint.KiaiMode);
+                ClassicAssert.AreEqual(53703, effectPoint.Time);
+                ClassicAssert.True(effectPoint.KiaiMode);
 
                 effectPoint = controlPoints.EffectPointAt(116637);
-                Assert.AreEqual(95901, effectPoint.Time);
-                Assert.IsFalse(effectPoint.KiaiMode);
+                ClassicAssert.AreEqual(95901, effectPoint.Time);
+                ClassicAssert.False(effectPoint.KiaiMode);
             }
         }
 
@@ -397,9 +398,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     new Color4(255, 177, 140, 255),
                     new Color4(100, 100, 100, 255), // alpha is specified as 100, but should be ignored.
                 };
-                Assert.AreEqual(expectedColors.Length, comboColors.Count);
+                ClassicAssert.AreEqual(expectedColors.Length, comboColors.Count);
                 for (int i = 0; i < expectedColors.Length; i++)
-                    Assert.AreEqual(expectedColors[i], comboColors[i]);
+                    ClassicAssert.AreEqual(expectedColors[i], comboColors[i]);
             }
         }
 
@@ -426,9 +427,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     new Color4(100, 100, 100, 255),
                     new Color4(142, 199, 255, 255),
                 };
-                Assert.AreEqual(expectedColors.Length, comboColors.Count);
+                ClassicAssert.AreEqual(expectedColors.Length, comboColors.Count);
                 for (int i = 0; i < expectedColors.Length; i++)
-                    Assert.AreEqual(expectedColors[i], comboColors[i]);
+                    ClassicAssert.AreEqual(expectedColors[i], comboColors[i]);
             }
         }
 
@@ -464,12 +465,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 new OsuBeatmapProcessor(converted).PreProcess();
                 new OsuBeatmapProcessor(converted).PostProcess();
 
-                Assert.AreEqual(1, ((IHasComboInformation)converted.HitObjects.ElementAt(0)).ComboIndexWithOffsets);
-                Assert.AreEqual(2, ((IHasComboInformation)converted.HitObjects.ElementAt(2)).ComboIndexWithOffsets);
-                Assert.AreEqual(3, ((IHasComboInformation)converted.HitObjects.ElementAt(4)).ComboIndexWithOffsets);
-                Assert.AreEqual(4, ((IHasComboInformation)converted.HitObjects.ElementAt(6)).ComboIndexWithOffsets);
-                Assert.AreEqual(8, ((IHasComboInformation)converted.HitObjects.ElementAt(8)).ComboIndexWithOffsets);
-                Assert.AreEqual(9, ((IHasComboInformation)converted.HitObjects.ElementAt(11)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(1, ((IHasComboInformation)converted.HitObjects.ElementAt(0)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(2, ((IHasComboInformation)converted.HitObjects.ElementAt(2)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(3, ((IHasComboInformation)converted.HitObjects.ElementAt(4)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(4, ((IHasComboInformation)converted.HitObjects.ElementAt(6)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(8, ((IHasComboInformation)converted.HitObjects.ElementAt(8)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(9, ((IHasComboInformation)converted.HitObjects.ElementAt(11)).ComboIndexWithOffsets);
             }
         }
 
@@ -487,12 +488,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 new CatchBeatmapProcessor(converted).PreProcess();
                 new CatchBeatmapProcessor(converted).PostProcess();
 
-                Assert.AreEqual(1, ((IHasComboInformation)converted.HitObjects.ElementAt(0)).ComboIndexWithOffsets);
-                Assert.AreEqual(2, ((IHasComboInformation)converted.HitObjects.ElementAt(2)).ComboIndexWithOffsets);
-                Assert.AreEqual(3, ((IHasComboInformation)converted.HitObjects.ElementAt(4)).ComboIndexWithOffsets);
-                Assert.AreEqual(4, ((IHasComboInformation)converted.HitObjects.ElementAt(6)).ComboIndexWithOffsets);
-                Assert.AreEqual(8, ((IHasComboInformation)converted.HitObjects.ElementAt(8)).ComboIndexWithOffsets);
-                Assert.AreEqual(9, ((IHasComboInformation)converted.HitObjects.ElementAt(11)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(1, ((IHasComboInformation)converted.HitObjects.ElementAt(0)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(2, ((IHasComboInformation)converted.HitObjects.ElementAt(2)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(3, ((IHasComboInformation)converted.HitObjects.ElementAt(4)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(4, ((IHasComboInformation)converted.HitObjects.ElementAt(6)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(8, ((IHasComboInformation)converted.HitObjects.ElementAt(8)).ComboIndexWithOffsets);
+                ClassicAssert.AreEqual(9, ((IHasComboInformation)converted.HitObjects.ElementAt(11)).ComboIndexWithOffsets);
             }
         }
 
@@ -508,8 +509,8 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 var positionData = hitObjects[0] as IHasPosition;
 
-                Assert.IsNotNull(positionData);
-                Assert.AreEqual(new Vector2(256, 256), positionData!.Position);
+                ClassicAssert.NotNull(positionData);
+                ClassicAssert.AreEqual(new Vector2(256, 256), positionData!.Position);
             }
         }
 
@@ -525,8 +526,8 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 var positionData = hitObjects[0] as IHasPosition;
 
-                Assert.IsNotNull(positionData);
-                Assert.AreEqual(new Vector2(256.99853f, 256.001f), positionData!.Position);
+                ClassicAssert.NotNull(positionData);
+                ClassicAssert.AreEqual(new Vector2(256.99853f, 256.001f), positionData!.Position);
             }
         }
 
@@ -543,18 +544,18 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var curveData = hitObjects[0] as IHasPathWithRepeats;
                 var positionData = hitObjects[0] as IHasPosition;
 
-                Assert.IsNotNull(positionData);
-                Assert.IsNotNull(curveData);
-                Assert.AreEqual(new Vector2(192, 168), positionData!.Position);
-                Assert.AreEqual(956, hitObjects[0].StartTime);
-                Assert.IsTrue(hitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
+                ClassicAssert.NotNull(positionData);
+                ClassicAssert.NotNull(curveData);
+                ClassicAssert.AreEqual(new Vector2(192, 168), positionData!.Position);
+                ClassicAssert.AreEqual(956, hitObjects[0].StartTime);
+                ClassicAssert.True(hitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
 
                 positionData = hitObjects[1] as IHasPosition;
 
-                Assert.IsNotNull(positionData);
-                Assert.AreEqual(new Vector2(304, 56), positionData!.Position);
-                Assert.AreEqual(1285, hitObjects[1].StartTime);
-                Assert.IsTrue(hitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
+                ClassicAssert.NotNull(positionData);
+                ClassicAssert.AreEqual(new Vector2(304, 56), positionData!.Position);
+                ClassicAssert.AreEqual(1285, hitObjects[1].StartTime);
+                ClassicAssert.True(hitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
             }
         }
 
@@ -585,22 +586,22 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
-                Assert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
-                Assert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
-                Assert.AreEqual("Gameplay/normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
-                Assert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[3]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[3]).LookupNames.First());
 
                 // The fourth object is a slider.
                 // `Samples` of a slider are presumed to control the volume of sounds that last the entire duration of the slider
                 // (such as ticks, slider slide sounds, etc.)
                 // Thus, the point of query of control points used for `Samples` is just beyond the start time of the slider.
-                Assert.AreEqual("Gameplay/soft-hitnormal11", getTestableSampleInfo(hitObjects[4]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/soft-hitnormal11", getTestableSampleInfo(hitObjects[4]).LookupNames.First());
 
                 // That said, the `NodeSamples` of the slider are responsible for the sounds of the slider's head / tail / repeats / large ticks etc.
                 // Therefore, they should be read at the time instant correspondent to the given node.
                 // This means that the tail should use bank 8 rather than 11.
-                Assert.AreEqual("Gameplay/soft-hitnormal11", ((ConvertSlider)hitObjects[4]).NodeSamples[0][0].LookupNames.First());
-                Assert.AreEqual("Gameplay/soft-hitnormal8", ((ConvertSlider)hitObjects[4]).NodeSamples[1][0].LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/soft-hitnormal11", ((ConvertSlider)hitObjects[4]).NodeSamples[0][0].LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/soft-hitnormal8", ((ConvertSlider)hitObjects[4]).NodeSamples[1][0].LookupNames.First());
             }
 
             static HitSampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.Samples[0];
@@ -616,9 +617,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
-                Assert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
-                Assert.AreEqual("Gameplay/normal-hitnormal2", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
-                Assert.AreEqual("Gameplay/normal-hitnormal3", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal2", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal3", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
             }
 
             static HitSampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.Samples[0];
@@ -634,11 +635,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
-                Assert.AreEqual("hit_1.wav", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
-                Assert.AreEqual("hit_2.wav", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
-                Assert.AreEqual("Gameplay/normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
-                Assert.AreEqual("hit_1.wav", getTestableSampleInfo(hitObjects[3]).LookupNames.First());
-                Assert.AreEqual(70, getTestableSampleInfo(hitObjects[3]).Volume);
+                ClassicAssert.AreEqual("hit_1.wav", getTestableSampleInfo(hitObjects[0]).LookupNames.First());
+                ClassicAssert.AreEqual("hit_2.wav", getTestableSampleInfo(hitObjects[1]).LookupNames.First());
+                ClassicAssert.AreEqual("Gameplay/normal-hitnormal2", getTestableSampleInfo(hitObjects[2]).LookupNames.First());
+                ClassicAssert.AreEqual("hit_1.wav", getTestableSampleInfo(hitObjects[3]).LookupNames.First());
+                ClassicAssert.AreEqual(70, getTestableSampleInfo(hitObjects[3]).Volume);
             }
 
             static HitSampleInfo getTestableSampleInfo(HitObject hitObject) => hitObject.Samples[0];
@@ -656,35 +657,35 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 var slider1 = (ConvertSlider)hitObjects[0];
 
-                Assert.AreEqual(1, slider1.NodeSamples[0].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider1.NodeSamples[0][0].Name);
-                Assert.AreEqual(1, slider1.NodeSamples[1].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider1.NodeSamples[1][0].Name);
-                Assert.AreEqual(1, slider1.NodeSamples[2].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider1.NodeSamples[2][0].Name);
+                ClassicAssert.AreEqual(1, slider1.NodeSamples[0].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider1.NodeSamples[0][0].Name);
+                ClassicAssert.AreEqual(1, slider1.NodeSamples[1].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider1.NodeSamples[1][0].Name);
+                ClassicAssert.AreEqual(1, slider1.NodeSamples[2].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider1.NodeSamples[2][0].Name);
 
                 var slider2 = (ConvertSlider)hitObjects[1];
 
-                Assert.AreEqual(2, slider2.NodeSamples[0].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider2.NodeSamples[0][0].Name);
-                Assert.AreEqual(HitSampleInfo.HIT_CLAP, slider2.NodeSamples[0][1].Name);
-                Assert.AreEqual(2, slider2.NodeSamples[1].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider2.NodeSamples[1][0].Name);
-                Assert.AreEqual(HitSampleInfo.HIT_CLAP, slider2.NodeSamples[1][1].Name);
-                Assert.AreEqual(2, slider2.NodeSamples[2].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider2.NodeSamples[2][0].Name);
-                Assert.AreEqual(HitSampleInfo.HIT_CLAP, slider2.NodeSamples[2][1].Name);
+                ClassicAssert.AreEqual(2, slider2.NodeSamples[0].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider2.NodeSamples[0][0].Name);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_CLAP, slider2.NodeSamples[0][1].Name);
+                ClassicAssert.AreEqual(2, slider2.NodeSamples[1].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider2.NodeSamples[1][0].Name);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_CLAP, slider2.NodeSamples[1][1].Name);
+                ClassicAssert.AreEqual(2, slider2.NodeSamples[2].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider2.NodeSamples[2][0].Name);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_CLAP, slider2.NodeSamples[2][1].Name);
 
                 var slider3 = (ConvertSlider)hitObjects[2];
 
-                Assert.AreEqual(2, slider3.NodeSamples[0].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider3.NodeSamples[0][0].Name);
-                Assert.AreEqual(HitSampleInfo.HIT_WHISTLE, slider3.NodeSamples[0][1].Name);
-                Assert.AreEqual(1, slider3.NodeSamples[1].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider3.NodeSamples[1][0].Name);
-                Assert.AreEqual(2, slider3.NodeSamples[2].Count);
-                Assert.AreEqual(HitSampleInfo.HIT_NORMAL, slider3.NodeSamples[2][0].Name);
-                Assert.AreEqual(HitSampleInfo.HIT_CLAP, slider3.NodeSamples[2][1].Name);
+                ClassicAssert.AreEqual(2, slider3.NodeSamples[0].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider3.NodeSamples[0][0].Name);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_WHISTLE, slider3.NodeSamples[0][1].Name);
+                ClassicAssert.AreEqual(1, slider3.NodeSamples[1].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider3.NodeSamples[1][0].Name);
+                ClassicAssert.AreEqual(2, slider3.NodeSamples[2].Count);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_NORMAL, slider3.NodeSamples[2][0].Name);
+                ClassicAssert.AreEqual(HitSampleInfo.HIT_CLAP, slider3.NodeSamples[2][1].Name);
             }
         }
 
@@ -698,7 +699,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var hitObjects = decoder.Decode(stream).HitObjects;
 
-                Assert.AreEqual(hitObjects[0].Samples[0].Bank, hitObjects[0].Samples[1].Bank);
+                ClassicAssert.AreEqual(hitObjects[0].Samples[0].Bank, hitObjects[0].Samples[1].Bank);
             }
         }
 
@@ -739,10 +740,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             static void assertObjectHasBanks(HitObject hitObject, string normalBank, string? additionsBank = null)
             {
-                Assert.AreEqual(normalBank, hitObject.Samples[0].Bank);
+                ClassicAssert.AreEqual(normalBank, hitObject.Samples[0].Bank);
 
                 if (additionsBank != null)
-                    Assert.AreEqual(additionsBank, hitObject.Samples[1].Bank);
+                    ClassicAssert.AreEqual(additionsBank, hitObject.Samples[1].Bank);
             }
         }
 
@@ -756,11 +757,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
                 Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
-                Assert.IsNotNull(beatmap);
-                Assert.AreEqual("Beatmap with corrupted header", beatmap.Metadata.Title);
-                Assert.AreEqual("Evil Hacker", beatmap.Metadata.Author.Username);
+                ClassicAssert.NotNull(beatmap);
+                ClassicAssert.AreEqual("Beatmap with corrupted header", beatmap.Metadata.Title);
+                ClassicAssert.AreEqual("Evil Hacker", beatmap.Metadata.Author.Username);
             }
         }
 
@@ -774,11 +775,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
                 Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
-                Assert.IsNotNull(beatmap);
-                Assert.AreEqual("Beatmap with no header", beatmap.Metadata.Title);
-                Assert.AreEqual("Incredibly Evil Hacker", beatmap.Metadata.Author.Username);
+                ClassicAssert.NotNull(beatmap);
+                ClassicAssert.AreEqual("Beatmap with no header", beatmap.Metadata.Title);
+                ClassicAssert.AreEqual("Incredibly Evil Hacker", beatmap.Metadata.Author.Username);
             }
         }
 
@@ -792,11 +793,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
                 Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
-                Assert.IsNotNull(beatmap);
-                Assert.AreEqual("Empty lines at start", beatmap.Metadata.Title);
-                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.Author.Username);
+                ClassicAssert.NotNull(beatmap);
+                ClassicAssert.AreEqual("Empty lines at start", beatmap.Metadata.Title);
+                ClassicAssert.AreEqual("Edge Case Hunter", beatmap.Metadata.Author.Username);
             }
         }
 
@@ -810,11 +811,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
                 Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
-                Assert.IsNotNull(beatmap);
-                Assert.AreEqual("The dog ate the file header", beatmap.Metadata.Title);
-                Assert.AreEqual("Why does this keep happening", beatmap.Metadata.Author.Username);
+                ClassicAssert.NotNull(beatmap);
+                ClassicAssert.AreEqual("The dog ate the file header", beatmap.Metadata.Title);
+                ClassicAssert.AreEqual("Why does this keep happening", beatmap.Metadata.Author.Username);
             }
         }
 
@@ -828,11 +829,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
                 Assert.DoesNotThrow(() => beatmap = decoder.Decode(stream));
-                Assert.IsNotNull(beatmap);
-                Assert.AreEqual("No empty line delimiting header from contents", beatmap.Metadata.Title);
-                Assert.AreEqual("Edge Case Hunter", beatmap.Metadata.Author.Username);
+                ClassicAssert.NotNull(beatmap);
+                ClassicAssert.AreEqual("No empty line delimiting header from contents", beatmap.Metadata.Title);
+                ClassicAssert.AreEqual("Edge Case Hunter", beatmap.Metadata.Author.Username);
             }
         }
 
@@ -855,7 +856,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyBeatmapDecoder>(decoder);
             }
 
             Assert.DoesNotThrow(LegacyDifficultyCalculatorBeatmapDecoder.Register);
@@ -864,7 +865,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var stream = new LineBufferedReader(resStream))
             {
                 Assert.DoesNotThrow(() => decoder = Decoder.GetDecoder<Beatmap>(stream));
-                Assert.IsInstanceOf<LegacyDifficultyCalculatorBeatmapDecoder>(decoder);
+                ClassicAssert.IsInstanceOf<LegacyDifficultyCalculatorBeatmapDecoder>(decoder);
             }
         }
 

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapEncoderTest.cs

@@ -8,6 +8,7 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Audio.Track;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
@@ -100,7 +101,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 // emulate non-legacy control points by cloning the non-legacy portion.
                 // the assertion is that the encoder can recreate this losslessly from hitobject data.
-                Assert.IsInstanceOf<LegacyControlPointInfo>(controlPointInfo);
+                ClassicAssert.IsInstanceOf<LegacyControlPointInfo>(controlPointInfo);
 
                 var newControlPoints = new ControlPointInfo();
 
@@ -129,7 +130,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.That(actual.beatmap.HitObjects.Serialize(), Is.EqualTo(expected.beatmap.HitObjects.Serialize()));
 
             // Check skin.
-            Assert.IsTrue(areComboColoursEqual(expected.skin.Configuration, actual.skin.Configuration));
+            ClassicAssert.True(areComboColoursEqual(expected.skin.Configuration, actual.skin.Configuration));
         }
 
         [Test]

osu.Game.Tests/Beatmaps/Formats/LegacyScoreDecoderTest.cs

@@ -9,6 +9,7 @@ using System.Globalization;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
@@ -58,18 +59,18 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var score = decoder.Parse(resourceStream);
 
-                Assert.AreEqual(3, score.ScoreInfo.Ruleset.OnlineID);
+                ClassicAssert.AreEqual(3, score.ScoreInfo.Ruleset.OnlineID);
 
-                Assert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.Great]);
-                Assert.AreEqual(1, score.ScoreInfo.Statistics[HitResult.Good]);
+                ClassicAssert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.Great]);
+                ClassicAssert.AreEqual(1, score.ScoreInfo.Statistics[HitResult.Good]);
 
-                Assert.AreEqual(829_931, score.ScoreInfo.LegacyTotalScore);
-                Assert.AreEqual(3, score.ScoreInfo.MaxCombo);
+                ClassicAssert.AreEqual(829_931, score.ScoreInfo.LegacyTotalScore);
+                ClassicAssert.AreEqual(3, score.ScoreInfo.MaxCombo);
 
                 Assert.That(score.ScoreInfo.APIMods.Select(m => m.Acronym), Is.EquivalentTo(new[] { "CL", "9K", "DS" }));
 
                 Assert.That((2 * 300d + 1 * 200) / (3 * 305d), Is.EqualTo(score.ScoreInfo.Accuracy).Within(0.0001));
-                Assert.AreEqual(ScoreRank.B, score.ScoreInfo.Rank);
+                ClassicAssert.AreEqual(ScoreRank.B, score.ScoreInfo.Rank);
 
                 Assert.That(score.Replay.Frames, Has.One.Matches<ManiaReplayFrame>(frame =>
                     frame.Time == 414 && frame.Actions.SequenceEqual(new[] { ManiaAction.Key1, ManiaAction.Key18 })));
@@ -85,10 +86,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var score = decoder.Parse(resourceStream);
 
-                Assert.AreEqual(1, score.ScoreInfo.Ruleset.OnlineID);
-                Assert.AreEqual(4, score.ScoreInfo.Statistics[HitResult.Great]);
-                Assert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.LargeBonus]);
-                Assert.AreEqual(4, score.ScoreInfo.MaxCombo);
+                ClassicAssert.AreEqual(1, score.ScoreInfo.Ruleset.OnlineID);
+                ClassicAssert.AreEqual(4, score.ScoreInfo.Statistics[HitResult.Great]);
+                ClassicAssert.AreEqual(2, score.ScoreInfo.Statistics[HitResult.LargeBonus]);
+                ClassicAssert.AreEqual(4, score.ScoreInfo.MaxCombo);
 
                 Assert.That(score.Replay.Frames, Is.Not.Empty);
             }

osu.Game.Tests/Beatmaps/Formats/LegacyStoryboardDecoderTest.cs

@@ -3,6 +3,7 @@
 
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osuTK;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps.Formats;
@@ -25,73 +26,73 @@ namespace osu.Game.Tests.Beatmaps.Formats
             {
                 var storyboard = decoder.Decode(stream);
 
-                Assert.IsTrue(storyboard.HasDrawable);
-                Assert.AreEqual(6, storyboard.Layers.Count());
+                ClassicAssert.True(storyboard.HasDrawable);
+                ClassicAssert.AreEqual(6, storyboard.Layers.Count());
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.IsNotNull(background);
-                Assert.AreEqual(16, background.Elements.Count);
-                Assert.IsTrue(background.VisibleWhenFailing);
-                Assert.IsTrue(background.VisibleWhenPassing);
-                Assert.AreEqual("Background", background.Name);
+                ClassicAssert.NotNull(background);
+                ClassicAssert.AreEqual(16, background.Elements.Count);
+                ClassicAssert.True(background.VisibleWhenFailing);
+                ClassicAssert.True(background.VisibleWhenPassing);
+                ClassicAssert.AreEqual("Background", background.Name);
 
                 StoryboardLayer fail = storyboard.Layers.Single(l => l.Depth == 2);
-                Assert.IsNotNull(fail);
-                Assert.AreEqual(0, fail.Elements.Count);
-                Assert.IsTrue(fail.VisibleWhenFailing);
-                Assert.IsFalse(fail.VisibleWhenPassing);
-                Assert.AreEqual("Fail", fail.Name);
+                ClassicAssert.NotNull(fail);
+                ClassicAssert.AreEqual(0, fail.Elements.Count);
+                ClassicAssert.True(fail.VisibleWhenFailing);
+                ClassicAssert.False(fail.VisibleWhenPassing);
+                ClassicAssert.AreEqual("Fail", fail.Name);
 
                 StoryboardLayer pass = storyboard.Layers.Single(l => l.Depth == 1);
-                Assert.IsNotNull(pass);
-                Assert.AreEqual(0, pass.Elements.Count);
-                Assert.IsFalse(pass.VisibleWhenFailing);
-                Assert.IsTrue(pass.VisibleWhenPassing);
-                Assert.AreEqual("Pass", pass.Name);
+                ClassicAssert.NotNull(pass);
+                ClassicAssert.AreEqual(0, pass.Elements.Count);
+                ClassicAssert.False(pass.VisibleWhenFailing);
+                ClassicAssert.True(pass.VisibleWhenPassing);
+                ClassicAssert.AreEqual("Pass", pass.Name);
 
                 StoryboardLayer foreground = storyboard.Layers.Single(l => l.Depth == 0);
-                Assert.IsNotNull(foreground);
-                Assert.AreEqual(151, foreground.Elements.Count);
-                Assert.IsTrue(foreground.VisibleWhenFailing);
-                Assert.IsTrue(foreground.VisibleWhenPassing);
-                Assert.AreEqual("Foreground", foreground.Name);
+                ClassicAssert.NotNull(foreground);
+                ClassicAssert.AreEqual(151, foreground.Elements.Count);
+                ClassicAssert.True(foreground.VisibleWhenFailing);
+                ClassicAssert.True(foreground.VisibleWhenPassing);
+                ClassicAssert.AreEqual("Foreground", foreground.Name);
 
                 StoryboardLayer overlay = storyboard.Layers.Single(l => l.Depth == int.MinValue);
-                Assert.IsNotNull(overlay);
-                Assert.IsEmpty(overlay.Elements);
-                Assert.IsTrue(overlay.VisibleWhenFailing);
-                Assert.IsTrue(overlay.VisibleWhenPassing);
-                Assert.AreEqual("Overlay", overlay.Name);
+                ClassicAssert.NotNull(overlay);
+                ClassicAssert.IsEmpty(overlay.Elements);
+                ClassicAssert.True(overlay.VisibleWhenFailing);
+                ClassicAssert.True(overlay.VisibleWhenPassing);
+                ClassicAssert.AreEqual("Overlay", overlay.Name);
 
                 int spriteCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardSprite));
                 int animationCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardAnimation));
                 int sampleCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardSampleInfo));
 
-                Assert.AreEqual(15, spriteCount);
-                Assert.AreEqual(1, animationCount);
-                Assert.AreEqual(0, sampleCount);
-                Assert.AreEqual(background.Elements.Count, spriteCount + animationCount + sampleCount);
+                ClassicAssert.AreEqual(15, spriteCount);
+                ClassicAssert.AreEqual(1, animationCount);
+                ClassicAssert.AreEqual(0, sampleCount);
+                ClassicAssert.AreEqual(background.Elements.Count, spriteCount + animationCount + sampleCount);
 
                 var sprite = background.Elements.ElementAt(0) as StoryboardSprite;
-                Assert.NotNull(sprite);
-                Assert.IsTrue(sprite!.HasCommands);
-                Assert.AreEqual(new Vector2(320, 240), sprite.InitialPosition);
-                Assert.IsTrue(sprite.IsDrawable);
-                Assert.AreEqual(Anchor.Centre, sprite.Origin);
-                Assert.AreEqual("SB/lyric/ja-21.png", sprite.Path);
+                ClassicAssert.NotNull(sprite);
+                ClassicAssert.True(sprite!.HasCommands);
+                ClassicAssert.AreEqual(new Vector2(320, 240), sprite.InitialPosition);
+                ClassicAssert.True(sprite.IsDrawable);
+                ClassicAssert.AreEqual(Anchor.Centre, sprite.Origin);
+                ClassicAssert.AreEqual("SB/lyric/ja-21.png", sprite.Path);
 
                 var animation = background.Elements.OfType<StoryboardAnimation>().First();
-                Assert.NotNull(animation);
-                Assert.AreEqual(141175, animation.EndTime);
-                Assert.AreEqual(10, animation.FrameCount);
-                Assert.AreEqual(30, animation.FrameDelay);
-                Assert.IsTrue(animation.HasCommands);
-                Assert.AreEqual(new Vector2(320, 240), animation.InitialPosition);
-                Assert.IsTrue(animation.IsDrawable);
-                Assert.AreEqual(AnimationLoopType.LoopForever, animation.LoopType);
-                Assert.AreEqual(Anchor.Centre, animation.Origin);
-                Assert.AreEqual("SB/red jitter/red_0000.jpg", animation.Path);
-                Assert.AreEqual(78993, animation.StartTime);
+                ClassicAssert.NotNull(animation);
+                ClassicAssert.AreEqual(141175, animation.EndTime);
+                ClassicAssert.AreEqual(10, animation.FrameCount);
+                ClassicAssert.AreEqual(30, animation.FrameDelay);
+                ClassicAssert.True(animation.HasCommands);
+                ClassicAssert.AreEqual(new Vector2(320, 240), animation.InitialPosition);
+                ClassicAssert.True(animation.IsDrawable);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopForever, animation.LoopType);
+                ClassicAssert.AreEqual(Anchor.Centre, animation.Origin);
+                ClassicAssert.AreEqual("SB/red jitter/red_0000.jpg", animation.Path);
+                ClassicAssert.AreEqual(78993, animation.StartTime);
             }
         }
 
@@ -106,13 +107,13 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.AreEqual(1, background.Elements.Count);
+                ClassicAssert.AreEqual(1, background.Elements.Count);
 
-                Assert.AreEqual(2000, background.Elements[0].StartTime);
-                Assert.AreEqual(2000, (background.Elements[0] as StoryboardAnimation)?.EarliestTransformTime);
+                ClassicAssert.AreEqual(2000, background.Elements[0].StartTime);
+                ClassicAssert.AreEqual(2000, (background.Elements[0] as StoryboardAnimation)?.EarliestTransformTime);
 
-                Assert.AreEqual(3000, (background.Elements[0] as StoryboardAnimation)?.GetEndTime());
-                Assert.AreEqual(12000, (background.Elements[0] as StoryboardAnimation)?.EndTimeForDisplay);
+                ClassicAssert.AreEqual(3000, (background.Elements[0] as StoryboardAnimation)?.GetEndTime());
+                ClassicAssert.AreEqual(12000, (background.Elements[0] as StoryboardAnimation)?.EndTimeForDisplay);
             }
         }
 
@@ -127,11 +128,11 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.AreEqual(1, background.Elements.Count);
+                ClassicAssert.AreEqual(1, background.Elements.Count);
 
-                Assert.AreEqual(2000, background.Elements[0].StartTime);
+                ClassicAssert.AreEqual(2000, background.Elements[0].StartTime);
                 // This property should be used in DrawableStoryboardAnimation as a starting point for animation playback.
-                Assert.AreEqual(1000, (background.Elements[0] as StoryboardAnimation)?.EarliestTransformTime);
+                ClassicAssert.AreEqual(1000, (background.Elements[0] as StoryboardAnimation)?.EarliestTransformTime);
             }
         }
 
@@ -146,10 +147,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.AreEqual(2, background.Elements.Count);
+                ClassicAssert.AreEqual(2, background.Elements.Count);
 
-                Assert.AreEqual(1500, background.Elements[0].StartTime);
-                Assert.AreEqual(1500, background.Elements[1].StartTime);
+                ClassicAssert.AreEqual(1500, background.Elements[0].StartTime);
+                ClassicAssert.AreEqual(1500, background.Elements[1].StartTime);
             }
         }
 
@@ -164,12 +165,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.AreEqual(2, background.Elements.Count);
+                ClassicAssert.AreEqual(2, background.Elements.Count);
 
-                Assert.AreEqual(1500, background.Elements[0].StartTime);
-                Assert.AreEqual(1000, background.Elements[1].StartTime);
+                ClassicAssert.AreEqual(1500, background.Elements[0].StartTime);
+                ClassicAssert.AreEqual(1000, background.Elements[1].StartTime);
 
-                Assert.AreEqual(1000, storyboard.EarliestEventTime);
+                ClassicAssert.AreEqual(1000, storyboard.EarliestEventTime);
             }
         }
 
@@ -184,12 +185,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.AreEqual(2, background.Elements.Count);
+                ClassicAssert.AreEqual(2, background.Elements.Count);
 
-                Assert.AreEqual(1000, background.Elements[0].StartTime);
-                Assert.AreEqual(1000, background.Elements[1].StartTime);
+                ClassicAssert.AreEqual(1000, background.Elements[0].StartTime);
+                ClassicAssert.AreEqual(1000, background.Elements[1].StartTime);
 
-                Assert.AreEqual(1000, storyboard.EarliestEventTime);
+                ClassicAssert.AreEqual(1000, storyboard.EarliestEventTime);
             }
         }
 
@@ -204,7 +205,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
-                Assert.AreEqual(3456, ((StoryboardSprite)background.Elements.Single()).InitialPosition.X);
+                ClassicAssert.AreEqual(3456, ((StoryboardSprite)background.Elements.Single()).InitialPosition.X);
             }
         }
 
@@ -221,7 +222,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 StoryboardLayer video = storyboard.Layers.Single(l => l.Name == "Video");
                 Assert.That(video.Elements.Count, Is.EqualTo(1));
 
-                Assert.AreEqual("Video.avi", ((StoryboardVideo)video.Elements[0]).Path);
+                ClassicAssert.AreEqual("Video.avi", ((StoryboardVideo)video.Elements[0]).Path);
             }
         }
 
@@ -238,7 +239,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 StoryboardLayer video = storyboard.Layers.Single(l => l.Name == "Video");
                 Assert.That(video.Elements.Count, Is.EqualTo(1));
 
-                Assert.AreEqual("Video.AVI", ((StoryboardVideo)video.Elements[0]).Path);
+                ClassicAssert.AreEqual("Video.AVI", ((StoryboardVideo)video.Elements[0]).Path);
             }
         }
 
@@ -268,12 +269,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var storyboard = decoder.Decode(stream);
 
                 StoryboardLayer foreground = storyboard.Layers.Single(l => l.Depth == 0);
-                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[0]).LoopType);
-                Assert.AreEqual(AnimationLoopType.LoopOnce, ((StoryboardAnimation)foreground.Elements[1]).LoopType);
-                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[2]).LoopType);
-                Assert.AreEqual(AnimationLoopType.LoopOnce, ((StoryboardAnimation)foreground.Elements[3]).LoopType);
-                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[4]).LoopType);
-                Assert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[5]).LoopType);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[0]).LoopType);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopOnce, ((StoryboardAnimation)foreground.Elements[1]).LoopType);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[2]).LoopType);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopOnce, ((StoryboardAnimation)foreground.Elements[3]).LoopType);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[4]).LoopType);
+                ClassicAssert.AreEqual(AnimationLoopType.LoopForever, ((StoryboardAnimation)foreground.Elements[5]).LoopType);
             }
         }
 

osu.Game.Tests/Beatmaps/Formats/OsuJsonDecoderTest.cs

@@ -5,8 +5,8 @@
 
 using System.IO;
 using System.Linq;
-using DeepEqual.Syntax;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
@@ -15,7 +15,6 @@ using osu.Game.IO.Serialization;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Beatmaps;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Tests.Resources;
 using osuTK;
 
@@ -33,17 +32,17 @@ namespace osu.Game.Tests.Beatmaps.Formats
         {
             var beatmap = decodeAsJson(normal);
             var meta = beatmap.BeatmapInfo.Metadata;
-            Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet?.OnlineID);
-            Assert.AreEqual("Soleily", meta.Artist);
-            Assert.AreEqual("Soleily", meta.ArtistUnicode);
-            Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
-            Assert.AreEqual("Gamu", meta.Author.Username);
-            Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
-            Assert.AreEqual(164471, meta.PreviewTime);
-            Assert.AreEqual(string.Empty, meta.Source);
-            Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
-            Assert.AreEqual("Renatus", meta.Title);
-            Assert.AreEqual("Renatus", meta.TitleUnicode);
+            ClassicAssert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet?.OnlineID);
+            ClassicAssert.AreEqual("Soleily", meta.Artist);
+            ClassicAssert.AreEqual("Soleily", meta.ArtistUnicode);
+            ClassicAssert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
+            ClassicAssert.AreEqual("Gamu", meta.Author.Username);
+            ClassicAssert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
+            ClassicAssert.AreEqual(164471, meta.PreviewTime);
+            ClassicAssert.AreEqual(string.Empty, meta.Source);
+            ClassicAssert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
+            ClassicAssert.AreEqual("Renatus", meta.Title);
+            ClassicAssert.AreEqual("Renatus", meta.TitleUnicode);
         }
 
         [Test]
@@ -51,14 +50,14 @@ namespace osu.Game.Tests.Beatmaps.Formats
         {
             var beatmap = decodeAsJson(normal);
             var beatmapInfo = beatmap.BeatmapInfo;
-            Assert.AreEqual(0, beatmap.AudioLeadIn);
-            Assert.AreEqual(0.7f, beatmap.StackLeniency);
-            Assert.AreEqual(false, beatmap.SpecialStyle);
-            Assert.IsTrue(beatmapInfo.Ruleset.OnlineID == 0);
-            Assert.AreEqual(false, beatmap.LetterboxInBreaks);
-            Assert.AreEqual(false, beatmap.WidescreenStoryboard);
-            Assert.AreEqual(CountdownType.None, beatmap.Countdown);
-            Assert.AreEqual(0, beatmap.CountdownOffset);
+            ClassicAssert.AreEqual(0, beatmap.AudioLeadIn);
+            ClassicAssert.AreEqual(0.7f, beatmap.StackLeniency);
+            ClassicAssert.AreEqual(false, beatmap.SpecialStyle);
+            ClassicAssert.True(beatmapInfo.Ruleset.OnlineID == 0);
+            ClassicAssert.AreEqual(false, beatmap.LetterboxInBreaks);
+            ClassicAssert.AreEqual(false, beatmap.WidescreenStoryboard);
+            ClassicAssert.AreEqual(CountdownType.None, beatmap.Countdown);
+            ClassicAssert.AreEqual(0, beatmap.CountdownOffset);
         }
 
         [Test]
@@ -73,13 +72,13 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 95901, 106450, 116999, 119637, 130186, 140735, 151285,
                 161834, 164471, 175020, 185570, 196119, 206669, 209306
             };
-            Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
+            ClassicAssert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
             for (int i = 0; i < expectedBookmarks.Length; i++)
-                Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
-            Assert.AreEqual(1.8, beatmap.DistanceSpacing);
-            Assert.AreEqual(4, beatmapInfo.BeatDivisor);
-            Assert.AreEqual(4, beatmap.GridSize);
-            Assert.AreEqual(2, beatmap.TimelineZoom);
+                ClassicAssert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
+            ClassicAssert.AreEqual(1.8, beatmap.DistanceSpacing);
+            ClassicAssert.AreEqual(4, beatmapInfo.BeatDivisor);
+            ClassicAssert.AreEqual(4, beatmap.GridSize);
+            ClassicAssert.AreEqual(2, beatmap.TimelineZoom);
         }
 
         [Test]
@@ -87,12 +86,12 @@ namespace osu.Game.Tests.Beatmaps.Formats
         {
             var beatmap = decodeAsJson(normal);
             var difficulty = beatmap.Difficulty;
-            Assert.AreEqual(6.5f, difficulty.DrainRate);
-            Assert.AreEqual(4, difficulty.CircleSize);
-            Assert.AreEqual(8, difficulty.OverallDifficulty);
-            Assert.AreEqual(9, difficulty.ApproachRate);
-            Assert.AreEqual(1.8, difficulty.SliderMultiplier);
-            Assert.AreEqual(2, difficulty.SliderTickRate);
+            ClassicAssert.AreEqual(6.5f, difficulty.DrainRate);
+            ClassicAssert.AreEqual(4, difficulty.CircleSize);
+            ClassicAssert.AreEqual(8, difficulty.OverallDifficulty);
+            ClassicAssert.AreEqual(9, difficulty.ApproachRate);
+            ClassicAssert.AreEqual(1.8, difficulty.SliderMultiplier);
+            ClassicAssert.AreEqual(2, difficulty.SliderTickRate);
         }
 
         [Test]
@@ -112,19 +111,19 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var curveData = beatmap.HitObjects[0] as IHasPathWithRepeats;
             var positionData = beatmap.HitObjects[0] as IHasPosition;
 
-            Assert.IsNotNull(positionData);
-            Assert.IsNotNull(curveData);
-            Assert.AreEqual(90, curveData.Path.Distance);
-            Assert.AreEqual(new Vector2(192, 168), positionData.Position);
-            Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
-            Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
+            Assert.That(positionData, Is.Not.Null);
+            Assert.That(curveData, Is.Not.Null);
+            ClassicAssert.AreEqual(90, curveData.Path.Distance);
+            ClassicAssert.AreEqual(new Vector2(192, 168), positionData.Position);
+            ClassicAssert.AreEqual(956, beatmap.HitObjects[0].StartTime);
+            ClassicAssert.True(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
 
             positionData = beatmap.HitObjects[1] as IHasPosition;
 
-            Assert.IsNotNull(positionData);
-            Assert.AreEqual(new Vector2(304, 56), positionData.Position);
-            Assert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
-            Assert.IsTrue(beatmap.HitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
+            Assert.That(positionData, Is.Not.Null);
+            ClassicAssert.AreEqual(new Vector2(304, 56), positionData.Position);
+            ClassicAssert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
+            ClassicAssert.True(beatmap.HitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
         }
 
         [Test]
@@ -135,35 +134,35 @@ namespace osu.Game.Tests.Beatmaps.Formats
             var curveData = beatmap.HitObjects[0] as IHasPathWithRepeats;
             var positionData = beatmap.HitObjects[0] as IHasPosition;
 
-            Assert.IsNotNull(positionData);
-            Assert.IsNotNull(curveData);
-            Assert.AreEqual(90, curveData.Path.Distance);
-            Assert.AreEqual(new Vector2(192, 168), positionData.Position);
-            Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
-            Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
+            Assert.That(positionData, Is.Not.Null);
+            Assert.That(curveData, Is.Not.Null);
+            ClassicAssert.AreEqual(90, curveData.Path.Distance);
+            ClassicAssert.AreEqual(new Vector2(192, 168), positionData.Position);
+            ClassicAssert.AreEqual(956, beatmap.HitObjects[0].StartTime);
+            ClassicAssert.True(beatmap.HitObjects[0].Samples.Any(s => s.Name == HitSampleInfo.HIT_NORMAL));
 
             positionData = beatmap.HitObjects[1] as IHasPosition;
 
-            Assert.IsNotNull(positionData);
-            Assert.AreEqual(new Vector2(304, 56), positionData.Position);
-            Assert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
-            Assert.IsTrue(beatmap.HitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
+            Assert.That(positionData, Is.Not.Null);
+            ClassicAssert.AreEqual(new Vector2(304, 56), positionData.Position);
+            ClassicAssert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
+            ClassicAssert.True(beatmap.HitObjects[1].Samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP));
         }
 
-        [TestCase(normal)]
-        [TestCase(marathon)]
-        [Ignore("temporarily disabled pending DeepEqual fix (https://github.com/jamesfoster/DeepEqual/pull/35)")]
-        // Currently fails:
-        // [TestCase(with_sb)]
-        public void TestParity(string beatmap)
-        {
-            var legacy = decode(beatmap, out Beatmap json);
-            json.WithDeepEqual(legacy)
-                .IgnoreProperty(r => r.DeclaringType == typeof(HitWindows)
-                                     // Todo: CustomSampleBank shouldn't exist going forward, we need a conversion mechanism
-                                     || r.Name == nameof(LegacyDecoder<Beatmap>.LegacySampleControlPoint.CustomSampleBank))
-                .Assert();
-        }
+        // [TestCase(normal)]
+        // [TestCase(marathon)]
+        // [Ignore("temporarily disabled pending DeepEqual fix (https://github.com/jamesfoster/DeepEqual/pull/35)")]
+        // // Currently fails:
+        // // [TestCase(with_sb)]
+        // public void TestParity(string beatmap)
+        // {
+        //     var legacy = decode(beatmap, out Beatmap json);
+        //     json.WithDeepEqual(legacy)
+        //         .IgnoreProperty(r => r.DeclaringType == typeof(HitWindows)
+        //                              // Todo: CustomSampleBank shouldn't exist going forward, we need a conversion mechanism
+        //                              || r.Name == nameof(LegacyDecoder<Beatmap>.LegacySampleControlPoint.CustomSampleBank))
+        //         .Assert();
+        // }
 
         [Test]
         public void TestGetJsonDecoder()
@@ -187,7 +186,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 }
             }
 
-            Assert.IsInstanceOf(typeof(JsonBeatmapDecoder), decoder);
+            ClassicAssert.IsInstanceOf(typeof(JsonBeatmapDecoder), decoder);
         }
 
         /// <summary>

osu.Game.Tests/Beatmaps/Formats/ParsingTest.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Globalization;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps.Formats;
 
 namespace osu.Game.Tests.Beatmaps.Formats
@@ -33,9 +34,9 @@ namespace osu.Game.Tests.Beatmaps.Formats
         [TestCase(-10, 10)]
         public void TestValidRanges(double input, double limit = Parsing.MAX_PARSE_VALUE)
         {
-            Assert.AreEqual(Parsing.ParseInt((input).ToString(CultureInfo.InvariantCulture), (int)limit), (int)input);
-            Assert.AreEqual(Parsing.ParseFloat((input).ToString(CultureInfo.InvariantCulture), (float)limit), (float)input);
-            Assert.AreEqual(Parsing.ParseDouble((input).ToString(CultureInfo.InvariantCulture), limit), input);
+            ClassicAssert.AreEqual(Parsing.ParseInt((input).ToString(CultureInfo.InvariantCulture), (int)limit), (int)input);
+            ClassicAssert.AreEqual(Parsing.ParseFloat((input).ToString(CultureInfo.InvariantCulture), (float)limit), (float)input);
+            ClassicAssert.AreEqual(Parsing.ParseDouble((input).ToString(CultureInfo.InvariantCulture), limit), input);
         }
 
         [TestCase(double.PositiveInfinity)]

osu.Game.Tests/Beatmaps/IO/BeatmapImportHelper.cs

@@ -8,7 +8,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
-using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
@@ -62,16 +62,16 @@ namespace osu.Game.Tests.Beatmaps.IO
             // TODO: add back some extra checks outside of the realm ones?
             // var set = queryBeatmapSets().First();
             // foreach (BeatmapInfo b in set.Beatmaps)
-            //     Assert.IsTrue(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
-            // Assert.IsTrue(set.Beatmaps.Count > 0);
+            //     ClassicAssert.True(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
+            // ClassicAssert.True(set.Beatmaps.Count > 0);
             // var beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 0))?.Beatmap;
-            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // ClassicAssert.True(beatmap?.HitObjects.Any() == true);
             // beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 1))?.Beatmap;
-            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // ClassicAssert.True(beatmap?.HitObjects.Any() == true);
             // beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 2))?.Beatmap;
-            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // ClassicAssert.True(beatmap?.HitObjects.Any() == true);
             // beatmap = store.GetWorkingBeatmap(set.Beatmaps.First(b => b.RulesetID == 3))?.Beatmap;
-            // Assert.IsTrue(beatmap?.HitObjects.Any() == true);
+            // ClassicAssert.True(beatmap?.HitObjects.Any() == true);
         }
 
         private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)
@@ -81,7 +81,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 while (!result()) Thread.Sleep(200);
             });
 
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
+            ClassicAssert.True(task.Wait(timeout), failureMessage);
         }
     }
 }

osu.Game.Tests/Beatmaps/IO/LineBufferedReaderTest.cs

@@ -5,6 +5,7 @@ using System;
 using System.IO;
 using System.Text;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.IO;
 
 namespace osu.Game.Tests.Beatmaps.IO
@@ -20,10 +21,10 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.AreEqual("line 1", bufferedReader.ReadLine());
-                Assert.AreEqual("line 2", bufferedReader.ReadLine());
-                Assert.AreEqual("line 3", bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("line 1", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("line 2", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("line 3", bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.ReadLine());
             }
         }
 
@@ -35,11 +36,11 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.AreEqual("line 1", bufferedReader.ReadLine());
-                Assert.AreEqual("peek this", bufferedReader.PeekLine());
-                Assert.AreEqual("peek this", bufferedReader.ReadLine());
-                Assert.AreEqual("line 3", bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("line 1", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("peek this", bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("peek this", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("line 3", bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.ReadLine());
             }
         }
 
@@ -51,14 +52,14 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.AreEqual("peek this once", bufferedReader.PeekLine());
-                Assert.AreEqual("peek this once", bufferedReader.ReadLine());
-                Assert.AreEqual("line 2", bufferedReader.ReadLine());
-                Assert.AreEqual("peek this a lot", bufferedReader.PeekLine());
-                Assert.AreEqual("peek this a lot", bufferedReader.PeekLine());
-                Assert.AreEqual("peek this a lot", bufferedReader.PeekLine());
-                Assert.AreEqual("peek this a lot", bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("peek this once", bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("peek this once", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("line 2", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("peek this a lot", bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("peek this a lot", bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("peek this a lot", bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("peek this a lot", bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.ReadLine());
             }
         }
 
@@ -70,11 +71,11 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.AreEqual("first line", bufferedReader.ReadLine());
-                Assert.AreEqual("second line", bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.PeekLine());
-                Assert.IsNull(bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("first line", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("second line", bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.PeekLine());
+                ClassicAssert.Null(bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.PeekLine());
             }
         }
 
@@ -84,10 +85,10 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream())
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.IsNull(bufferedReader.PeekLine());
-                Assert.IsNull(bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.ReadLine());
-                Assert.IsNull(bufferedReader.PeekLine());
+                ClassicAssert.Null(bufferedReader.PeekLine());
+                ClassicAssert.Null(bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.ReadLine());
+                ClassicAssert.Null(bufferedReader.PeekLine());
             }
         }
 
@@ -99,7 +100,7 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.AreEqual(contents, bufferedReader.ReadToEnd());
+                ClassicAssert.AreEqual(contents, bufferedReader.ReadToEnd());
             }
         }
 
@@ -111,14 +112,14 @@ namespace osu.Game.Tests.Beatmaps.IO
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(contents)))
             using (var bufferedReader = new LineBufferedReader(stream))
             {
-                Assert.AreEqual("this line is gone", bufferedReader.ReadLine());
-                Assert.AreEqual("this one shouldn't be", bufferedReader.PeekLine());
+                ClassicAssert.AreEqual("this line is gone", bufferedReader.ReadLine());
+                ClassicAssert.AreEqual("this one shouldn't be", bufferedReader.PeekLine());
 
                 string[] endingLines = bufferedReader.ReadToEnd().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
-                Assert.AreEqual(3, endingLines.Length);
-                Assert.AreEqual("this one shouldn't be", endingLines[0]);
-                Assert.AreEqual("these ones", endingLines[1]);
-                Assert.AreEqual("definitely not", endingLines[2]);
+                ClassicAssert.AreEqual(3, endingLines.Length);
+                ClassicAssert.AreEqual("this one shouldn't be", endingLines[0]);
+                ClassicAssert.AreEqual("these ones", endingLines[1]);
+                ClassicAssert.AreEqual("definitely not", endingLines[2]);
             }
         }
     }

osu.Game.Tests/Beatmaps/IO/OszArchiveReaderTest.cs

@@ -4,6 +4,7 @@
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Tests.Resources;
 using osu.Game.Beatmaps.Formats;
@@ -38,7 +39,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 };
                 string[] maps = reader.Filenames.ToArray();
                 foreach (string map in expected)
-                    Assert.Contains(map, maps);
+                    ClassicAssert.Contains(map, maps);
             }
         }
 
@@ -56,17 +57,17 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                 var meta = beatmap.Metadata;
 
-                Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet?.OnlineID);
-                Assert.AreEqual("Soleily", meta.Artist);
-                Assert.AreEqual("Soleily", meta.ArtistUnicode);
-                Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
-                Assert.AreEqual("Deif", meta.Author.Username);
-                Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
-                Assert.AreEqual(164471, meta.PreviewTime);
-                Assert.AreEqual(string.Empty, meta.Source);
-                Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
-                Assert.AreEqual("Renatus", meta.Title);
-                Assert.AreEqual("Renatus", meta.TitleUnicode);
+                ClassicAssert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet?.OnlineID);
+                ClassicAssert.AreEqual("Soleily", meta.Artist);
+                ClassicAssert.AreEqual("Soleily", meta.ArtistUnicode);
+                ClassicAssert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
+                ClassicAssert.AreEqual("Deif", meta.Author.Username);
+                ClassicAssert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
+                ClassicAssert.AreEqual(164471, meta.PreviewTime);
+                ClassicAssert.AreEqual(string.Empty, meta.Source);
+                ClassicAssert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
+                ClassicAssert.AreEqual("Renatus", meta.Title);
+                ClassicAssert.AreEqual("Renatus", meta.TitleUnicode);
             }
         }
 
@@ -79,7 +80,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                 using (var stream = new StreamReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
                 {
-                    Assert.AreEqual("osu file format v13", stream.ReadLine()?.Trim());
+                    ClassicAssert.AreEqual("osu file format v13", stream.ReadLine()?.Trim());
                 }
             }
         }

osu.Game.Tests/Beatmaps/TestSceneBeatmapDifficultyCache.cs

@@ -4,10 +4,12 @@
 #nullable disable
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
@@ -15,6 +17,7 @@ using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Tests.Beatmaps.IO;
 using osu.Game.Tests.Visual;
@@ -34,6 +37,12 @@ namespace osu.Game.Tests.Beatmaps
 
         private IBindable<StarDifficulty> starDifficultyBindable;
 
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; }
+
+        [Resolved]
+        private BeatmapDifficultyCache actualDifficultyCache { get; set; }
+
         [BackgroundDependencyLoader]
         private void load(OsuGameBase osu)
         {
@@ -55,6 +64,36 @@ namespace osu.Game.Tests.Beatmaps
             AddUntilStep($"star difficulty -> {BASE_STARS}", () => starDifficultyBindable.Value.Stars == BASE_STARS);
         }
 
+        [Test]
+        public void TestInvalidationFlow()
+        {
+            BeatmapInfo postEditBeatmapInfo = null;
+            BeatmapInfo preEditBeatmapInfo = null;
+
+            IBindable<StarDifficulty> bindableDifficulty = null;
+
+            AddStep("get bindable stars", () =>
+            {
+                preEditBeatmapInfo = importedSet.Beatmaps.First();
+                bindableDifficulty = actualDifficultyCache.GetBindableDifficulty(preEditBeatmapInfo);
+            });
+
+            AddUntilStep("wait for stars retrieved", () => bindableDifficulty.Value.Stars, () => Is.GreaterThan(0));
+
+            AddStep("remove all hitobjects", () =>
+            {
+                var working = beatmapManager.GetWorkingBeatmap(preEditBeatmapInfo);
+
+                ((IList<HitObject>)working.Beatmap.HitObjects).Clear();
+
+                beatmapManager.Save(working.BeatmapInfo, working.Beatmap);
+                postEditBeatmapInfo = working.BeatmapInfo;
+            });
+
+            AddAssert("stars is now zero", () => actualDifficultyCache.GetDifficultyAsync(postEditBeatmapInfo).GetResultSafely()!.Value.Stars, () => Is.Zero);
+            AddUntilStep("bindable stars is now zero", () => bindableDifficulty.Value.Stars, () => Is.Zero);
+        }
+
         [Test]
         public void TestStarDifficultyChangesOnModSettings()
         {
@@ -76,6 +115,30 @@ namespace osu.Game.Tests.Beatmaps
             AddUntilStep($"star difficulty -> {BASE_STARS + 1.75}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.75);
         }
 
+        [Test]
+        public void TestStarDifficultyChangesOnModSettingsCorrectlyTrackAcrossReferenceChanges()
+        {
+            OsuModDoubleTime dt = null;
+
+            AddStep("set computation function", () => difficultyCache.ComputeDifficulty = lookup =>
+            {
+                var modRateAdjust = (ModRateAdjust)lookup.OrderedMods.SingleOrDefault(mod => mod is ModRateAdjust);
+                return new StarDifficulty(BASE_STARS + modRateAdjust?.SpeedChange.Value ?? 0, 0);
+            });
+
+            AddStep("change selected mod to DT", () => SelectedMods.Value = new[] { dt = new OsuModDoubleTime { SpeedChange = { Value = 1.5 } } });
+            AddUntilStep($"star difficulty -> {BASE_STARS + 1.5}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.5);
+
+            AddStep("change DT speed to 1.25", () => dt.SpeedChange.Value = 1.25);
+            AddUntilStep($"star difficulty -> {BASE_STARS + 1.25}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.25);
+
+            AddStep("reconstruct DT mod with same settings", () => SelectedMods.Value = new[] { dt = (OsuModDoubleTime)dt.DeepClone() });
+            AddUntilStep($"star difficulty -> {BASE_STARS + 1.25}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 1.25);
+
+            AddStep("change DT speed to 1.25", () => dt.SpeedChange.Value = 2);
+            AddUntilStep($"star difficulty -> {BASE_STARS + 2}", () => starDifficultyBindable.Value.Stars == BASE_STARS + 2);
+        }
+
         [Test]
         public void TestStarDifficultyAdjustHashCodeConflict()
         {
@@ -122,8 +185,10 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyDoesntEqualWithDifferentModSettings()
         {
-            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.1 } } });
-            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.9 } } });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 },
+                new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.1 } } });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 },
+                new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.9 } } });
 
             Assert.That(key1, Is.Not.EqualTo(key2));
             Assert.That(key1.GetHashCode(), Is.Not.EqualTo(key2.GetHashCode()));
@@ -132,8 +197,10 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyEqualWithMatchingModSettings()
         {
-            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
-            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 }, new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 },
+                new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(new BeatmapInfo { ID = guid }, new RulesetInfo { OnlineID = 0 },
+                new Mod[] { new OsuModDoubleTime { SpeedChange = { Value = 1.25 } } });
 
             Assert.That(key1, Is.EqualTo(key2));
             Assert.That(key1.GetHashCode(), Is.EqualTo(key2.GetHashCode()));
@@ -159,7 +226,7 @@ namespace osu.Game.Tests.Beatmaps
         {
             var actualBracket = StarDifficulty.GetDifficultyRating(starRating);
 
-            Assert.AreEqual(expectedBracket, actualBracket);
+            ClassicAssert.AreEqual(expectedBracket, actualBracket);
         }
 
         private partial class TestBeatmapDifficultyCache : BeatmapDifficultyCache

osu.Game.Tests/Beatmaps/TestSceneEditorBeatmap.cs

@@ -247,7 +247,7 @@ namespace osu.Game.Tests.Beatmaps
 
             AddStep("change all start times", () =>
             {
-                editorBeatmap.HitObjectUpdated += h => updatedObjects.Add(h);
+                editorBeatmap.HitObjectUpdated += updatedObjects.Add;
 
                 for (int i = 0; i < 10; i++)
                     allHitObjects[i].StartTime += 10;
@@ -282,7 +282,7 @@ namespace osu.Game.Tests.Beatmaps
 
             AddStep("change start time twice", () =>
             {
-                editorBeatmap.HitObjectUpdated += h => updatedObjects.Add(h);
+                editorBeatmap.HitObjectUpdated += updatedObjects.Add;
 
                 editorBeatmap.HitObjects[0].StartTime = 10;
                 editorBeatmap.HitObjects[0].StartTime = 20;

osu.Game.Tests/Beatmaps/WorkingBeatmapTest.cs

@@ -10,6 +10,7 @@ using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Moq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
@@ -29,7 +30,7 @@ namespace osu.Game.Tests.Beatmaps
 
             working.ResetEvent.Set();
 
-            Assert.NotNull(working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo));
+            ClassicAssert.NotNull(working.GetPlayableBeatmap(new OsuRuleset().RulesetInfo));
         }
 
         [Test]
@@ -48,11 +49,11 @@ namespace osu.Game.Tests.Beatmaps
                 loadCompleted.Set();
             }, TaskCreationOptions.LongRunning);
 
-            Assert.IsTrue(loadStarted.Wait(10000));
+            ClassicAssert.True(loadStarted.Wait(10000));
 
             cts.Cancel();
 
-            Assert.IsTrue(loadCompleted.Wait(10000));
+            ClassicAssert.True(loadCompleted.Wait(10000));
 
             working.ResetEvent.Set();
         }

osu.Game.Tests/Chat/MessageFormatterTests.cs

@@ -4,6 +4,7 @@
 #nullable disable
 
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Online.Chat;
 
 namespace osu.Game.Tests.Chat
@@ -31,8 +32,8 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a gopher://really-old-protocol we don't support." });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(0, result.Links.Count);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(0, result.Links.Count);
         }
 
         [Test]
@@ -40,8 +41,8 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a osunotarealprotocol://completely-made-up-protocol we don't support." });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(0, result.Links.Count);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(0, result.Links.Count);
         }
 
         [Test]
@@ -49,9 +50,9 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "forgotspacehttps://dev.ppy.sh joinmyosump://12345 jointheosu://chan/#english" });
 
-            Assert.AreEqual("https://dev.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual("osump://12345", result.Links[1].Url);
-            Assert.AreEqual("osu://chan/#english", result.Links[2].Url);
+            ClassicAssert.AreEqual("https://dev.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual("osump://12345", result.Links[1].Url);
+            ClassicAssert.AreEqual("osu://chan/#english", result.Links[2].Url);
         }
 
         [Test]
@@ -59,11 +60,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a http://www.basic-link.com/?test=test." });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("http://www.basic-link.com/?test=test", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(36, result.Links[0].Length);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("http://www.basic-link.com/?test=test", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(36, result.Links[0].Length);
         }
 
         [TestCase(LinkAction.OpenBeatmap, "456", "https://dev.ppy.sh/beatmapsets/123#osu/456")]
@@ -79,12 +80,12 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = link });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual(expectedAction, result.Links[0].Action);
-            Assert.AreEqual(expectedArg, result.Links[0].Argument);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual(expectedAction, result.Links[0].Action);
+            ClassicAssert.AreEqual(expectedArg, result.Links[0].Argument);
             if (expectedAction == LinkAction.External)
-                Assert.AreEqual(link, result.Links[0].Url);
+                ClassicAssert.AreEqual(link, result.Links[0].Url);
         }
 
         [Test]
@@ -95,20 +96,20 @@ namespace osu.Game.Tests.Chat
                 Content = "This is a http://test.io/link#fragment. (see https://twitter.com). Also, This string should not be altered. http://example.com/"
             });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(3, result.Links.Count);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(3, result.Links.Count);
 
-            Assert.AreEqual("http://test.io/link#fragment", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(28, result.Links[0].Length);
+            ClassicAssert.AreEqual("http://test.io/link#fragment", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(28, result.Links[0].Length);
 
-            Assert.AreEqual("https://twitter.com", result.Links[1].Url);
-            Assert.AreEqual(45, result.Links[1].Index);
-            Assert.AreEqual(19, result.Links[1].Length);
+            ClassicAssert.AreEqual("https://twitter.com", result.Links[1].Url);
+            ClassicAssert.AreEqual(45, result.Links[1].Index);
+            ClassicAssert.AreEqual(19, result.Links[1].Length);
 
-            Assert.AreEqual("http://example.com/", result.Links[2].Url);
-            Assert.AreEqual(108, result.Links[2].Index);
-            Assert.AreEqual(19, result.Links[2].Length);
+            ClassicAssert.AreEqual("http://example.com/", result.Links[2].Url);
+            ClassicAssert.AreEqual(108, result.Links[2].Index);
+            ClassicAssert.AreEqual(19, result.Links[2].Length);
         }
 
         [Test]
@@ -116,10 +117,10 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "https://twitter.com/#!/hashbanglinks" });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(result.Content, result.Links[0].Url);
-            Assert.AreEqual(0, result.Links[0].Index);
-            Assert.AreEqual(36, result.Links[0].Length);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(result.Content, result.Links[0].Url);
+            ClassicAssert.AreEqual(0, result.Links[0].Index);
+            ClassicAssert.AreEqual(36, result.Links[0].Length);
         }
 
         [Test]
@@ -127,10 +128,10 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "http://www.chiark.greenend.org.uk/~sgtatham/putty/" });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(result.Content, result.Links[0].Url);
-            Assert.AreEqual(0, result.Links[0].Index);
-            Assert.AreEqual(50, result.Links[0].Length);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(result.Content, result.Links[0].Url);
+            ClassicAssert.AreEqual(0, result.Links[0].Index);
+            ClassicAssert.AreEqual(50, result.Links[0].Length);
         }
 
         [Test]
@@ -138,9 +139,9 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "look: http://puu.sh/7Ggh8xcC6/asf0asd9876.NEF" });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(6, result.Links[0].Index);
-            Assert.AreEqual(39, result.Links[0].Length);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(6, result.Links[0].Index);
+            ClassicAssert.AreEqual(39, result.Links[0].Length);
         }
 
         [Test]
@@ -148,11 +149,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [[Wiki Link]]." });
 
-            Assert.AreEqual("This is a Wiki Link.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://dev.ppy.sh/wiki/Wiki Link", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(9, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a Wiki Link.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://dev.ppy.sh/wiki/Wiki Link", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(9, result.Links[0].Length);
         }
 
         [Test]
@@ -160,20 +161,20 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [[Wiki Link]] [[Wiki:Link]][[Wiki.Link]]." });
 
-            Assert.AreEqual("This is a Wiki Link Wiki:LinkWiki.Link.", result.DisplayContent);
-            Assert.AreEqual(3, result.Links.Count);
+            ClassicAssert.AreEqual("This is a Wiki Link Wiki:LinkWiki.Link.", result.DisplayContent);
+            ClassicAssert.AreEqual(3, result.Links.Count);
 
-            Assert.AreEqual("https://dev.ppy.sh/wiki/Wiki Link", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(9, result.Links[0].Length);
+            ClassicAssert.AreEqual("https://dev.ppy.sh/wiki/Wiki Link", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(9, result.Links[0].Length);
 
-            Assert.AreEqual("https://dev.ppy.sh/wiki/Wiki:Link", result.Links[1].Url);
-            Assert.AreEqual(20, result.Links[1].Index);
-            Assert.AreEqual(9, result.Links[1].Length);
+            ClassicAssert.AreEqual("https://dev.ppy.sh/wiki/Wiki:Link", result.Links[1].Url);
+            ClassicAssert.AreEqual(20, result.Links[1].Index);
+            ClassicAssert.AreEqual(9, result.Links[1].Length);
 
-            Assert.AreEqual("https://dev.ppy.sh/wiki/Wiki.Link", result.Links[2].Url);
-            Assert.AreEqual(29, result.Links[2].Index);
-            Assert.AreEqual(9, result.Links[2].Length);
+            ClassicAssert.AreEqual("https://dev.ppy.sh/wiki/Wiki.Link", result.Links[2].Url);
+            ClassicAssert.AreEqual(29, result.Links[2].Index);
+            ClassicAssert.AreEqual(9, result.Links[2].Length);
         }
 
         [Test]
@@ -181,11 +182,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a (simple test)[https://osu.ppy.sh] of links." });
 
-            Assert.AreEqual("This is a simple test of links.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(11, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a simple test of links.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(11, result.Links[0].Length);
         }
 
         [Test]
@@ -193,11 +194,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a (tricky (one))[https://osu.ppy.sh]!" });
 
-            Assert.AreEqual("This is a tricky (one)!", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(12, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a tricky (one)!", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(12, result.Links[0].Length);
         }
 
         [Test]
@@ -205,22 +206,22 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is (another loose bracket \\))[https://osu.ppy.sh]." });
 
-            Assert.AreEqual("This is another loose bracket ).", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(8, result.Links[0].Index);
-            Assert.AreEqual(23, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is another loose bracket ).", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(8, result.Links[0].Index);
+            ClassicAssert.AreEqual(23, result.Links[0].Length);
         }
 
         [Test]
         public void TestOldFormatWithBackslashes()
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This link (should end with a backslash \\)[https://osu.ppy.sh]." });
-            Assert.AreEqual("This link should end with a backslash \\.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(29, result.Links[0].Length);
+            ClassicAssert.AreEqual("This link should end with a backslash \\.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(29, result.Links[0].Length);
         }
 
         [Test]
@@ -228,11 +229,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a (\\)super\\(\\( tricky (one))[https://osu.ppy.sh]!" });
 
-            Assert.AreEqual("This is a )super(( tricky (one)!", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(21, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a )super(( tricky (one)!", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(21, result.Links[0].Length);
         }
 
         [Test]
@@ -240,11 +241,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [https://osu.ppy.sh simple test]." });
 
-            Assert.AreEqual("This is a simple test.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(11, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a simple test.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(11, result.Links[0].Length);
         }
 
         [Test]
@@ -252,11 +253,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [https://osu.ppy.sh nasty link with escaped brackets: \\] and \\[]" });
 
-            Assert.AreEqual("This is a nasty link with escaped brackets: ] and [", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(41, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a nasty link with escaped brackets: ] and [", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(41, result.Links[0].Length);
         }
 
         [Test]
@@ -264,11 +265,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [https://osu.ppy.sh link \\ with \\ backslashes \\]" });
 
-            Assert.AreEqual("This is a link \\ with \\ backslashes \\", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(27, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a link \\ with \\ backslashes \\", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(27, result.Links[0].Length);
         }
 
         [Test]
@@ -276,11 +277,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [https://osu.ppy.sh [link [with \\] too many brackets \\[ ]]]" });
 
-            Assert.AreEqual("This is a [link [with ] too many brackets [ ]]", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(36, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a [link [with ] too many brackets [ ]]", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(36, result.Links[0].Length);
         }
 
         [Test]
@@ -288,11 +289,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [simple test](https://osu.ppy.sh)." });
 
-            Assert.AreEqual("This is a simple test.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(11, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a simple test.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(11, result.Links[0].Length);
         }
 
         [Test]
@@ -300,11 +301,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [tricky [one]](https://osu.ppy.sh)!" });
 
-            Assert.AreEqual("This is a tricky [one]!", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(12, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a tricky [one]!", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(12, result.Links[0].Length);
         }
 
         [Test]
@@ -312,22 +313,22 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is [another loose bracket \\]](https://osu.ppy.sh)." });
 
-            Assert.AreEqual("This is another loose bracket ].", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(8, result.Links[0].Index);
-            Assert.AreEqual(23, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is another loose bracket ].", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(8, result.Links[0].Index);
+            ClassicAssert.AreEqual(23, result.Links[0].Length);
         }
 
         [Test]
         public void TestMarkdownFormatWithBackslashes()
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This link [should end with a backslash \\](https://osu.ppy.sh)." });
-            Assert.AreEqual("This link should end with a backslash \\.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(29, result.Links[0].Length);
+            ClassicAssert.AreEqual("This link should end with a backslash \\.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(29, result.Links[0].Length);
         }
 
         [Test]
@@ -335,11 +336,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [\\]super\\[\\[ tricky [one]](https://osu.ppy.sh)!" });
 
-            Assert.AreEqual("This is a ]super[[ tricky [one]!", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(21, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a ]super[[ tricky [one]!", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(21, result.Links[0].Length);
         }
 
         [Test]
@@ -347,11 +348,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "I haven't seen [this link format](https://osu.ppy.sh \"osu!\") before..." });
 
-            Assert.AreEqual("I haven't seen this link format before...", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(15, result.Links[0].Index);
-            Assert.AreEqual(16, result.Links[0].Length);
+            ClassicAssert.AreEqual("I haven't seen this link format before...", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(15, result.Links[0].Index);
+            ClassicAssert.AreEqual(16, result.Links[0].Length);
         }
 
         [Test]
@@ -359,11 +360,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "I haven't seen [this link format](https://osu.ppy.sh \"inner quote \\\" just to confuse \") before..." });
 
-            Assert.AreEqual("I haven't seen this link format before...", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(15, result.Links[0].Index);
-            Assert.AreEqual(16, result.Links[0].Length);
+            ClassicAssert.AreEqual("I haven't seen this link format before...", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(15, result.Links[0].Index);
+            ClassicAssert.AreEqual(16, result.Links[0].Length);
         }
 
         [Test]
@@ -371,11 +372,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "I haven't seen [https://osu.ppy.sh](https://osu.ppy.sh \"https://osu.ppy.sh\") before..." });
 
-            Assert.AreEqual("I haven't seen https://osu.ppy.sh before...", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(15, result.Links[0].Index);
-            Assert.AreEqual(18, result.Links[0].Length);
+            ClassicAssert.AreEqual("I haven't seen https://osu.ppy.sh before...", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(15, result.Links[0].Index);
+            ClassicAssert.AreEqual(18, result.Links[0].Length);
         }
 
         [Test]
@@ -383,11 +384,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "I haven't seen [oh no, text here! https://osu.ppy.sh](https://osu.ppy.sh) before..." });
 
-            Assert.AreEqual("I haven't seen oh no, text here! https://osu.ppy.sh before...", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(15, result.Links[0].Index);
-            Assert.AreEqual(36, result.Links[0].Length);
+            ClassicAssert.AreEqual("I haven't seen oh no, text here! https://osu.ppy.sh before...", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(15, result.Links[0].Index);
+            ClassicAssert.AreEqual(36, result.Links[0].Length);
         }
 
         [Test]
@@ -395,11 +396,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "I haven't seen [https://google.com](https://osu.ppy.sh) before..." });
 
-            Assert.AreEqual("I haven't seen https://google.com before...", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(15, result.Links[0].Index);
-            Assert.AreEqual(18, result.Links[0].Length);
+            ClassicAssert.AreEqual("I haven't seen https://google.com before...", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(15, result.Links[0].Index);
+            ClassicAssert.AreEqual(18, result.Links[0].Length);
         }
 
         [Test]
@@ -407,11 +408,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "super broken https://[osu.ppy](https://reddit.com).sh/" });
 
-            Assert.AreEqual("super broken https://osu.ppy.sh/", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://reddit.com", result.Links[0].Url);
-            Assert.AreEqual(21, result.Links[0].Index);
-            Assert.AreEqual(7, result.Links[0].Length);
+            ClassicAssert.AreEqual("super broken https://osu.ppy.sh/", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://reddit.com", result.Links[0].Url);
+            ClassicAssert.AreEqual(21, result.Links[0].Index);
+            ClassicAssert.AreEqual(7, result.Links[0].Length);
         }
 
         [Test]
@@ -420,16 +421,16 @@ namespace osu.Game.Tests.Chat
             // the raw link has a port at the end of it, so that the raw link regex terminates at the port and doesn't consume display text from the formatted one
             Message result = MessageFormatter.FormatMessage(new Message { Content = "https://localhost:8080[https://osu.ppy.sh](https://osu.ppy.sh) should be two links" });
 
-            Assert.AreEqual("https://localhost:8080https://osu.ppy.sh should be two links", result.DisplayContent);
-            Assert.AreEqual(2, result.Links.Count);
+            ClassicAssert.AreEqual("https://localhost:8080https://osu.ppy.sh should be two links", result.DisplayContent);
+            ClassicAssert.AreEqual(2, result.Links.Count);
 
-            Assert.AreEqual("https://localhost:8080", result.Links[0].Url);
-            Assert.AreEqual(0, result.Links[0].Index);
-            Assert.AreEqual(22, result.Links[0].Length);
+            ClassicAssert.AreEqual("https://localhost:8080", result.Links[0].Url);
+            ClassicAssert.AreEqual(0, result.Links[0].Index);
+            ClassicAssert.AreEqual(22, result.Links[0].Length);
 
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[1].Url);
-            Assert.AreEqual(22, result.Links[1].Index);
-            Assert.AreEqual(18, result.Links[1].Length);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[1].Url);
+            ClassicAssert.AreEqual(22, result.Links[1].Index);
+            ClassicAssert.AreEqual(18, result.Links[1].Length);
         }
 
         [Test]
@@ -437,10 +438,10 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is an #english and #japanese." });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(2, result.Links.Count);
-            Assert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#english", result.Links[0].Url);
-            Assert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#japanese", result.Links[1].Url);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(2, result.Links.Count);
+            ClassicAssert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#english", result.Links[0].Url);
+            ClassicAssert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#japanese", result.Links[1].Url);
         }
 
         [Test]
@@ -448,20 +449,20 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = $"This is a custom protocol {OsuGameBase.OSU_PROTOCOL}chan/#english." });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#english", result.Links[0].Url);
-            Assert.AreEqual(26, result.Links[0].Index);
-            Assert.AreEqual(19, result.Links[0].Length);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#english", result.Links[0].Url);
+            ClassicAssert.AreEqual(26, result.Links[0].Index);
+            ClassicAssert.AreEqual(19, result.Links[0].Length);
 
             result = MessageFormatter.FormatMessage(new Message { Content = $"This is a [custom protocol]({OsuGameBase.OSU_PROTOCOL}chan/#english)." });
 
-            Assert.AreEqual("This is a custom protocol.", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#english", result.Links[0].Url);
-            Assert.AreEqual("#english", result.Links[0].Argument);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(15, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a custom protocol.", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual($"{OsuGameBase.OSU_PROTOCOL}chan/#english", result.Links[0].Url);
+            ClassicAssert.AreEqual("#english", result.Links[0].Argument);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(15, result.Links[0].Length);
         }
 
         [Test]
@@ -469,11 +470,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "Join my multiplayer game osump://12346." });
 
-            Assert.AreEqual(result.Content, result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("osump://12346", result.Links[0].Url);
-            Assert.AreEqual(25, result.Links[0].Index);
-            Assert.AreEqual(13, result.Links[0].Length);
+            ClassicAssert.AreEqual(result.Content, result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("osump://12346", result.Links[0].Url);
+            ClassicAssert.AreEqual(25, result.Links[0].Index);
+            ClassicAssert.AreEqual(13, result.Links[0].Length);
         }
 
         [Test]
@@ -481,11 +482,11 @@ namespace osu.Game.Tests.Chat
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "This is a [https://osu.ppy.sh [[simple test]]]." });
 
-            Assert.AreEqual("This is a [[simple test]].", result.DisplayContent);
-            Assert.AreEqual(1, result.Links.Count);
-            Assert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
-            Assert.AreEqual(10, result.Links[0].Index);
-            Assert.AreEqual(15, result.Links[0].Length);
+            ClassicAssert.AreEqual("This is a [[simple test]].", result.DisplayContent);
+            ClassicAssert.AreEqual(1, result.Links.Count);
+            ClassicAssert.AreEqual("https://osu.ppy.sh", result.Links[0].Url);
+            ClassicAssert.AreEqual(10, result.Links[0].Index);
+            ClassicAssert.AreEqual(15, result.Links[0].Length);
         }
 
         [Test]
@@ -496,44 +497,44 @@ namespace osu.Game.Tests.Chat
                 Content = "This is a [http://www.simple-test.com simple test] with some [traps] and [[wiki links]]. Don't forget to visit https://osu.ppy.sh (now!)[http://google.com]\uD83D\uDE12"
             });
 
-            Assert.AreEqual("This is a simple test with some [traps] and wiki links. Don't forget to visit https://osu.ppy.sh now![emoji]", result.DisplayContent);
-            Assert.AreEqual(4, result.Links.Count);
+            ClassicAssert.AreEqual("This is a simple test with some [traps] and wiki links. Don't forget to visit https://osu.ppy.sh now![emoji]", result.DisplayContent);
+            ClassicAssert.AreEqual(4, result.Links.Count);
 
             Link f = result.Links.Find(l => l.Url == "https://dev.ppy.sh/wiki/wiki links");
             Assert.That(f, Is.Not.Null);
-            Assert.AreEqual(44, f.Index);
-            Assert.AreEqual(10, f.Length);
+            ClassicAssert.AreEqual(44, f.Index);
+            ClassicAssert.AreEqual(10, f.Length);
 
             f = result.Links.Find(l => l.Url == "http://www.simple-test.com");
             Assert.That(f, Is.Not.Null);
-            Assert.AreEqual(10, f.Index);
-            Assert.AreEqual(11, f.Length);
+            ClassicAssert.AreEqual(10, f.Index);
+            ClassicAssert.AreEqual(11, f.Length);
 
             f = result.Links.Find(l => l.Url == "http://google.com");
             Assert.That(f, Is.Not.Null);
-            Assert.AreEqual(97, f.Index);
-            Assert.AreEqual(4, f.Length);
+            ClassicAssert.AreEqual(97, f.Index);
+            ClassicAssert.AreEqual(4, f.Length);
 
             f = result.Links.Find(l => l.Url == "https://osu.ppy.sh");
             Assert.That(f, Is.Not.Null);
-            Assert.AreEqual(78, f.Index);
-            Assert.AreEqual(18, f.Length);
+            ClassicAssert.AreEqual(78, f.Index);
+            ClassicAssert.AreEqual(18, f.Length);
         }
 
         [Test]
         public void TestEmoji()
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "Hello world\uD83D\uDE12<--This is an emoji,There are more emojis among us:\uD83D\uDE10\uD83D\uDE00,\uD83D\uDE20" });
-            Assert.AreEqual("Hello world[emoji]<--This is an emoji,There are more emojis among us:[emoji][emoji],[emoji]", result.DisplayContent);
-            Assert.AreEqual(result.Links.Count, 0);
+            ClassicAssert.AreEqual("Hello world[emoji]<--This is an emoji,There are more emojis among us:[emoji][emoji],[emoji]", result.DisplayContent);
+            ClassicAssert.AreEqual(result.Links.Count, 0);
         }
 
         [Test]
         public void TestEmojiWithSuccessiveParens()
         {
             Message result = MessageFormatter.FormatMessage(new Message { Content = "\uD83D\uDE10(let's hope this doesn't accidentally turn into a link)" });
-            Assert.AreEqual("[emoji](let's hope this doesn't accidentally turn into a link)", result.DisplayContent);
-            Assert.AreEqual(result.Links.Count, 0);
+            ClassicAssert.AreEqual("[emoji](let's hope this doesn't accidentally turn into a link)", result.DisplayContent);
+            ClassicAssert.AreEqual(result.Links.Count, 0);
         }
 
         [Test]
@@ -541,8 +542,8 @@ namespace osu.Game.Tests.Chat
         {
             LinkDetails result = MessageFormatter.GetLinkDetails("https://google.com");
 
-            Assert.AreEqual(LinkAction.External, result.Action);
-            Assert.AreEqual("https://google.com", result.Argument);
+            ClassicAssert.AreEqual(LinkAction.External, result.Action);
+            ClassicAssert.AreEqual("https://google.com", result.Argument);
         }
 
         [Test]
@@ -550,8 +551,8 @@ namespace osu.Game.Tests.Chat
         {
             LinkDetails result = MessageFormatter.GetLinkDetails("/relative");
 
-            Assert.AreEqual(LinkAction.External, result.Action);
-            Assert.AreEqual("/relative", result.Argument);
+            ClassicAssert.AreEqual(LinkAction.External, result.Action);
+            ClassicAssert.AreEqual("/relative", result.Argument);
         }
 
         [TestCase("https://dev.ppy.sh/home/changelog", "")]
@@ -560,8 +561,8 @@ namespace osu.Game.Tests.Chat
         {
             LinkDetails result = MessageFormatter.GetLinkDetails(link);
 
-            Assert.AreEqual(LinkAction.OpenChangelog, result.Action);
-            Assert.AreEqual(expectedArg, result.Argument);
+            ClassicAssert.AreEqual(LinkAction.OpenChangelog, result.Action);
+            ClassicAssert.AreEqual(expectedArg, result.Argument);
         }
     }
 }

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -9,6 +9,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Logging;
@@ -42,7 +43,7 @@ namespace osu.Game.Tests.Database
                 {
                     var beatmapSet = await importer.Import(new ImportTask(TestResources.GetTestBeatmapStream(), "renatus.osz"));
 
-                    Assert.NotNull(beatmapSet);
+                    ClassicAssert.NotNull(beatmapSet);
                     Debug.Assert(beatmapSet != null);
 
                     BeatmapSetInfo? detachedBeatmapSet = null;
@@ -52,23 +53,23 @@ namespace osu.Game.Tests.Database
                         detachedBeatmapSet = live.Detach();
 
                         // files are omitted
-                        Assert.AreEqual(0, detachedBeatmapSet.Files.Count);
+                        ClassicAssert.AreEqual(0, detachedBeatmapSet.Files.Count);
 
-                        Assert.AreEqual(live.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count);
-                        Assert.AreEqual(live.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
-                        Assert.AreEqual(live.Metadata, detachedBeatmapSet.Metadata);
+                        ClassicAssert.AreEqual(live.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count);
+                        ClassicAssert.AreEqual(live.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
+                        ClassicAssert.AreEqual(live.Metadata, detachedBeatmapSet.Metadata);
                     });
 
                     Debug.Assert(detachedBeatmapSet != null);
 
                     // Check detached instances can all be accessed without throwing.
-                    Assert.AreEqual(0, detachedBeatmapSet.Files.Count);
-                    Assert.NotNull(detachedBeatmapSet.Beatmaps.Count);
-                    Assert.NotZero(detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
-                    Assert.NotNull(detachedBeatmapSet.Metadata);
+                    ClassicAssert.AreEqual(0, detachedBeatmapSet.Files.Count);
+                    ClassicAssert.NotNull(detachedBeatmapSet.Beatmaps.Count);
+                    ClassicAssert.NotZero(detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
+                    ClassicAssert.NotNull(detachedBeatmapSet.Metadata);
 
                     // Check cyclic reference to beatmap set
-                    Assert.AreEqual(detachedBeatmapSet, detachedBeatmapSet.Beatmaps.First().BeatmapSet);
+                    ClassicAssert.AreEqual(detachedBeatmapSet, detachedBeatmapSet.Beatmaps.First().BeatmapSet);
                 }
             });
         }
@@ -84,7 +85,7 @@ namespace osu.Game.Tests.Database
                 {
                     var beatmapSet = await importer.Import(new ImportTask(TestResources.GetTestBeatmapStream(), "renatus.osz"));
 
-                    Assert.NotNull(beatmapSet);
+                    ClassicAssert.NotNull(beatmapSet);
                     Debug.Assert(beatmapSet != null);
 
                     // Detach at the BeatmapInfo point, similar to what GetWorkingBeatmap does.
@@ -101,28 +102,25 @@ namespace osu.Game.Tests.Database
                     detachedBeatmapSet.Beatmaps.First().Metadata.Artist = "New Artist";
                     detachedBeatmapSet.Beatmaps.First().Metadata.Author = newUser;
 
-                    Assert.AreNotEqual(detachedBeatmapSet.Status, BeatmapOnlineStatus.Ranked);
+                    ClassicAssert.AreNotEqual(detachedBeatmapSet.Status, BeatmapOnlineStatus.Ranked);
                     detachedBeatmapSet.Status = BeatmapOnlineStatus.Ranked;
 
-                    beatmapSet.PerformWrite(s =>
-                    {
-                        detachedBeatmapSet.CopyChangesToRealm(s);
-                    });
+                    beatmapSet.PerformWrite(detachedBeatmapSet.CopyChangesToRealm);
 
                     beatmapSet.PerformRead(s =>
                     {
                         // Check above changes explicitly.
-                        Assert.AreEqual(BeatmapOnlineStatus.Ranked, s.Status);
-                        Assert.AreEqual("New Artist", s.Beatmaps.First().Metadata.Artist);
-                        Assert.AreEqual(newUser, s.Beatmaps.First().Metadata.Author);
-                        Assert.NotZero(s.Files.Count);
+                        ClassicAssert.AreEqual(BeatmapOnlineStatus.Ranked, s.Status);
+                        ClassicAssert.AreEqual("New Artist", s.Beatmaps.First().Metadata.Artist);
+                        ClassicAssert.AreEqual(newUser, s.Beatmaps.First().Metadata.Author);
+                        ClassicAssert.NotZero(s.Files.Count);
 
                         // Check nothing was lost in the copy operation.
-                        Assert.AreEqual(s.Files.Count, detachedBeatmapSet.Files.Count);
-                        Assert.AreEqual(s.Files.Select(f => f.File).Count(), detachedBeatmapSet.Files.Select(f => f.File).Count());
-                        Assert.AreEqual(s.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count);
-                        Assert.AreEqual(s.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
-                        Assert.AreEqual(s.Metadata, detachedBeatmapSet.Metadata);
+                        ClassicAssert.AreEqual(s.Files.Count, detachedBeatmapSet.Files.Count);
+                        ClassicAssert.AreEqual(s.Files.Select(f => f.File).Count(), detachedBeatmapSet.Files.Select(f => f.File).Count());
+                        ClassicAssert.AreEqual(s.Beatmaps.Count, detachedBeatmapSet.Beatmaps.Count);
+                        ClassicAssert.AreEqual(s.Beatmaps.Select(f => f.Difficulty).Count(), detachedBeatmapSet.Beatmaps.Select(f => f.Difficulty).Count());
+                        ClassicAssert.AreEqual(s.Metadata, detachedBeatmapSet.Metadata);
                     });
                 }
             });
@@ -145,7 +143,7 @@ namespace osu.Game.Tests.Database
                     {
                         var beatmapSet = await importer.Import(new ImportTask(TestResources.GetTestBeatmapStream(), "renatus.osz"));
 
-                        Assert.NotNull(beatmapSet);
+                        ClassicAssert.NotNull(beatmapSet);
                         Debug.Assert(beatmapSet != null);
 
                         // Intentionally detach on async thread as to not trigger a refresh on the main thread.
@@ -170,20 +168,20 @@ namespace osu.Game.Tests.Database
                     var imported = await importer.Import(new ImportTask(TestResources.GetTestBeatmapStream(), "renatus.osz"));
                     EnsureLoaded(realm.Realm);
 
-                    Assert.AreEqual(1, realm.Realm.All<BeatmapSetInfo>().Count());
+                    ClassicAssert.AreEqual(1, realm.Realm.All<BeatmapSetInfo>().Count());
 
-                    Assert.NotNull(imported);
+                    ClassicAssert.NotNull(imported);
                     Debug.Assert(imported != null);
 
                     imported.PerformWrite(s => s.DeletePending = true);
 
-                    Assert.AreEqual(1, realm.Realm.All<BeatmapSetInfo>().Count(s => s.DeletePending));
+                    ClassicAssert.AreEqual(1, realm.Realm.All<BeatmapSetInfo>().Count(s => s.DeletePending));
                 }
             });
 
             Logger.Log("Running with no work to purge pending deletions");
 
-            RunTestWithRealm((realm, _) => { Assert.AreEqual(0, realm.Realm.All<BeatmapSetInfo>().Count()); });
+            RunTestWithRealm((realm, _) => { ClassicAssert.AreEqual(0, realm.Realm.All<BeatmapSetInfo>().Count()); });
         }
 
         [Test]
@@ -211,8 +209,8 @@ namespace osu.Game.Tests.Database
                 var beatmap = imported.Beatmaps.First();
                 var file = beatmap.File;
 
-                Assert.NotNull(file);
-                Assert.AreEqual(beatmap.Hash, file!.File.Hash);
+                ClassicAssert.NotNull(file);
+                ClassicAssert.AreEqual(beatmap.Hash, file!.File.Hash);
             });
         }
 
@@ -248,10 +246,10 @@ namespace osu.Game.Tests.Database
                     EnsureLoaded(realm.Realm);
                 }
 
-                Assert.NotNull(importedSet);
+                ClassicAssert.NotNull(importedSet);
                 Debug.Assert(importedSet != null);
 
-                Assert.IsTrue(File.Exists(tempPath), "Stream source file somehow went missing");
+                ClassicAssert.True(File.Exists(tempPath), "Stream source file somehow went missing");
                 File.Delete(tempPath);
 
                 var imported = realm.Realm.All<BeatmapSetInfo>().First(beatmapSet => beatmapSet.ID == importedSet.ID);
@@ -272,8 +270,8 @@ namespace osu.Game.Tests.Database
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
-                Assert.IsTrue(imported.ID == importedSecondTime.ID);
-                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                ClassicAssert.True(imported.ID == importedSecondTime.ID);
+                ClassicAssert.True(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
 
                 checkBeatmapSetCount(realm.Realm, 1);
                 checkSingleReferencedFileCount(realm.Realm, 18);
@@ -295,7 +293,7 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
                     foreach (var file in new DirectoryInfo(extractedFolder).GetFiles("*.osu"))
@@ -307,7 +305,7 @@ namespace osu.Game.Tests.Database
                     }
 
                     var imported = await importer.Import(new ImportTask(extractedFolder));
-                    Assert.IsNull(imported);
+                    ClassicAssert.Null(imported);
                 }
                 finally
                 {
@@ -336,28 +334,28 @@ namespace osu.Game.Tests.Database
 
                     string hashBefore = hashFile(temp);
 
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
                     }
 
                     // zip files differ because different compression or encoder.
-                    Assert.AreNotEqual(hashBefore, hashFile(temp));
+                    ClassicAssert.AreNotEqual(hashBefore, hashFile(temp));
 
                     var importedSecondTime = await importer.Import(new ImportTask(temp));
 
                     EnsureLoaded(realm.Realm);
 
-                    Assert.NotNull(importedSecondTime);
+                    ClassicAssert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
 
                     // but contents doesn't, so existing should still be used.
-                    Assert.IsTrue(imported.ID == importedSecondTime.ID);
-                    Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                    ClassicAssert.True(imported.ID == importedSecondTime.ID);
+                    ClassicAssert.True(imported.Beatmaps.First().ID == importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
                 }
                 finally
                 {
@@ -385,7 +383,7 @@ namespace osu.Game.Tests.Database
 
                     await createScoreForBeatmap(realm.Realm, imported.Beatmaps.First());
 
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
                     // arbitrary write to hashed file
@@ -393,7 +391,7 @@ namespace osu.Game.Tests.Database
                     using (var sw = new FileInfo(Directory.GetFiles(extractedFolder, "*.osu").First()).AppendText())
                         await sw.WriteLineAsync("// changed");
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
@@ -404,11 +402,11 @@ namespace osu.Game.Tests.Database
                     EnsureLoaded(realm.Realm);
 
                     // check the newly "imported" beatmap is not the original.
-                    Assert.NotNull(importedSecondTime);
+                    ClassicAssert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
 
-                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
-                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                    ClassicAssert.True(imported.ID != importedSecondTime.ID);
+                    ClassicAssert.True(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
                 }
                 finally
                 {
@@ -504,7 +502,7 @@ namespace osu.Game.Tests.Database
                 EnsureLoaded(realm.Realm);
 
                 // check the newly "imported" beatmap is not the original.
-                Assert.NotNull(importedSecondTime);
+                ClassicAssert.NotNull(importedSecondTime);
                 Debug.Assert(importedSecondTime != null);
                 Assert.That(imported.ID != importedSecondTime.ID);
 
@@ -536,14 +534,14 @@ namespace osu.Game.Tests.Database
                 {
                     var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
                     // arbitrary write to non-hashed file
                     using (var sw = new FileInfo(Directory.GetFiles(extractedFolder, "*.mp3").First()).AppendText())
                         await sw.WriteLineAsync("text");
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
@@ -553,12 +551,12 @@ namespace osu.Game.Tests.Database
 
                     EnsureLoaded(realm.Realm);
 
-                    Assert.NotNull(importedSecondTime);
+                    ClassicAssert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
 
                     // check the newly "imported" beatmap is not the original.
-                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
-                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                    ClassicAssert.True(imported.ID != importedSecondTime.ID);
+                    ClassicAssert.True(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
                 }
                 finally
                 {
@@ -584,14 +582,14 @@ namespace osu.Game.Tests.Database
                 {
                     var imported = await LoadOszIntoStore(importer, realm.Realm);
 
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
                     // change filename
                     var firstFile = new FileInfo(Directory.GetFiles(extractedFolder).First());
                     firstFile.MoveTo(Path.Combine(firstFile.DirectoryName.AsNonNull(), $"{firstFile.Name}-changed{firstFile.Extension}"));
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
@@ -601,12 +599,12 @@ namespace osu.Game.Tests.Database
 
                     EnsureLoaded(realm.Realm);
 
-                    Assert.NotNull(importedSecondTime);
+                    ClassicAssert.NotNull(importedSecondTime);
                     Debug.Assert(importedSecondTime != null);
 
                     // check the newly "imported" beatmap is not the original.
-                    Assert.IsTrue(imported.ID != importedSecondTime.ID);
-                    Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
+                    ClassicAssert.True(imported.ID != importedSecondTime.ID);
+                    ClassicAssert.True(imported.Beatmaps.First().ID != importedSecondTime.PerformRead(s => s.Beatmaps.First().ID));
                 }
                 finally
                 {
@@ -639,11 +637,11 @@ namespace osu.Game.Tests.Database
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 using (var stream = fileStorage.GetStream(firstFile.File.GetStoragePath()))
-                    Assert.AreEqual(stream.Length, originalLength, "Corruption was not fixed on second import");
+                    ClassicAssert.AreEqual(stream.Length, originalLength, "Corruption was not fixed on second import");
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
-                Assert.IsTrue(imported.ID == importedSecondTime.ID);
-                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                ClassicAssert.True(imported.ID == importedSecondTime.ID);
+                ClassicAssert.True(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
 
                 checkBeatmapSetCount(realm.Realm, 1);
                 checkSingleReferencedFileCount(realm.Realm, 18);
@@ -662,7 +660,7 @@ namespace osu.Game.Tests.Database
 
                 var zipStream = new MemoryStream();
 
-                using (var zip = ZipArchive.Create())
+                using (var zip = ZipArchive.CreateArchive())
                     zip.SaveTo(zipStream, new ZipWriterOptions(CompressionType.Deflate));
 
                 var imported = await importer.Import(
@@ -675,8 +673,8 @@ namespace osu.Game.Tests.Database
                 checkBeatmapSetCount(realm.Realm, 0);
                 checkBeatmapCount(realm.Realm, 0);
 
-                Assert.IsEmpty(imported);
-                Assert.AreEqual(ProgressNotificationState.Cancelled, progressNotification.State);
+                ClassicAssert.IsEmpty(imported);
+                ClassicAssert.AreEqual(ProgressNotificationState.Cancelled, progressNotification.State);
             });
         }
 
@@ -712,7 +710,7 @@ namespace osu.Game.Tests.Database
                 File.Delete(brokenTempFilename);
 
                 using (var outStream = File.Open(brokenTempFilename, FileMode.CreateNew))
-                using (var zip = ZipArchive.Open(brokenOsz))
+                using (var zip = ZipArchive.OpenArchive(brokenOsz))
                 {
                     foreach (var entry in zip.Entries.ToArray())
                     {
@@ -740,7 +738,7 @@ namespace osu.Game.Tests.Database
 
                 checkSingleReferencedFileCount(realm.Realm, 18);
 
-                Assert.AreEqual(0, loggedExceptionCount);
+                ClassicAssert.AreEqual(0, loggedExceptionCount);
 
                 File.Delete(brokenTempFilename);
             });
@@ -758,17 +756,17 @@ namespace osu.Game.Tests.Database
 
                 deleteBeatmapSet(imported, realm.Realm);
 
-                Assert.IsTrue(imported.DeletePending);
+                ClassicAssert.True(imported.DeletePending);
 
                 var originalAddedDate = imported.DateAdded;
 
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
-                Assert.IsTrue(imported.ID == importedSecondTime.ID);
-                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
-                Assert.IsFalse(imported.DeletePending);
-                Assert.IsFalse(importedSecondTime.DeletePending);
+                ClassicAssert.True(imported.ID == importedSecondTime.ID);
+                ClassicAssert.True(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                ClassicAssert.False(imported.DeletePending);
+                ClassicAssert.False(importedSecondTime.DeletePending);
                 Assert.That(importedSecondTime.DateAdded, Is.GreaterThan(originalAddedDate));
             });
         }
@@ -790,13 +788,13 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    using (var zip = ZipArchive.Open(pathOriginal))
+                    using (var zip = ZipArchive.OpenArchive(pathOriginal))
                         zip.WriteToDirectory(extractedFolder);
 
                     // remove one difficulty before first import
                     new FileInfo(Directory.GetFiles(extractedFolder, "*.osu").First()).Delete();
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(pathMissingOneBeatmap, new ZipWriterOptions(CompressionType.Deflate));
@@ -844,7 +842,7 @@ namespace osu.Game.Tests.Database
 
                 deleteBeatmapSet(imported, realmFactory.Realm);
 
-                Assert.IsTrue(imported.DeletePending);
+                ClassicAssert.True(imported.DeletePending);
 
                 // intentionally nuke all files
                 storage.DeleteDirectory("files");
@@ -854,10 +852,10 @@ namespace osu.Game.Tests.Database
                 var importedSecondTime = await LoadOszIntoStore(importer, realmFactory.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
-                Assert.IsTrue(imported.ID == importedSecondTime.ID);
-                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
-                Assert.IsFalse(imported.DeletePending);
-                Assert.IsFalse(importedSecondTime.DeletePending);
+                ClassicAssert.True(imported.ID == importedSecondTime.ID);
+                ClassicAssert.True(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                ClassicAssert.False(imported.DeletePending);
+                ClassicAssert.False(importedSecondTime.DeletePending);
 
                 // check that the files now exist, even though they were deleted above.
                 Assert.That(importedSecondTime.Files.All(f => storage.GetStorageForDirectory("files").Exists(f.File.GetStoragePath())));
@@ -876,17 +874,17 @@ namespace osu.Game.Tests.Database
 
                 deleteBeatmapSet(imported, realm.Realm);
 
-                Assert.IsTrue(imported.DeletePending);
+                ClassicAssert.True(imported.DeletePending);
 
                 var originalAddedDate = imported.DateAdded;
 
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap is actually just the restored previous import. since it matches hash.
-                Assert.IsTrue(imported.ID == importedSecondTime.ID);
-                Assert.IsTrue(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
-                Assert.IsFalse(imported.DeletePending);
-                Assert.IsFalse(importedSecondTime.DeletePending);
+                ClassicAssert.True(imported.ID == importedSecondTime.ID);
+                ClassicAssert.True(imported.Beatmaps.First().ID == importedSecondTime.Beatmaps.First().ID);
+                ClassicAssert.False(imported.DeletePending);
+                ClassicAssert.False(importedSecondTime.DeletePending);
                 Assert.That(importedSecondTime.DateAdded, Is.GreaterThan(originalAddedDate));
             });
         }
@@ -912,8 +910,8 @@ namespace osu.Game.Tests.Database
                 var importedSecondTime = await LoadOszIntoStore(importer, realm.Realm);
 
                 // check the newly "imported" beatmap has been reimported due to mismatch (even though hashes matched)
-                Assert.IsTrue(imported.ID != importedSecondTime.ID);
-                Assert.IsTrue(imported.Beatmaps.First().ID != importedSecondTime.Beatmaps.First().ID);
+                ClassicAssert.True(imported.ID != importedSecondTime.ID);
+                ClassicAssert.True(imported.Beatmaps.First().ID != importedSecondTime.Beatmaps.First().ID);
             });
         }
 
@@ -957,11 +955,11 @@ namespace osu.Game.Tests.Database
 
                 realm.Run(r => r.Refresh());
 
-                Assert.NotNull(imported);
+                ClassicAssert.NotNull(imported);
                 Debug.Assert(imported != null);
 
-                Assert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[0].OnlineID));
-                Assert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[1].OnlineID));
+                ClassicAssert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[0].OnlineID));
+                ClassicAssert.AreEqual(-1, imported.PerformRead(s => s.Beatmaps[1].OnlineID));
             });
         }
 
@@ -978,7 +976,7 @@ namespace osu.Game.Tests.Database
                     await importer.Import(temp);
                 EnsureLoaded(realm.Realm);
                 File.Delete(temp);
-                Assert.IsFalse(File.Exists(temp), "We likely held a read lock on the file when we shouldn't");
+                ClassicAssert.False(File.Exists(temp), "We likely held a read lock on the file when we shouldn't");
             });
         }
 
@@ -997,10 +995,10 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.AddEntry("duplicate.osu", Directory.GetFiles(extractedFolder, "*.osu").First());
@@ -1033,7 +1031,7 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(extractedFolder);
 
                     var subdirectory = Directory.CreateDirectory(Path.Combine(extractedFolder, "subdir"));
@@ -1044,7 +1042,7 @@ namespace osu.Game.Tests.Database
                     using (var textWriter = new StreamWriter(stream))
                         await textWriter.WriteLineAsync("# adding a comment so that the hashes are different");
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
@@ -1078,10 +1076,10 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(subfolder);
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
@@ -1089,12 +1087,12 @@ namespace osu.Game.Tests.Database
 
                     var imported = await importer.Import(new ImportTask(temp));
 
-                    Assert.NotNull(imported);
+                    ClassicAssert.NotNull(imported);
                     Debug.Assert(imported != null);
 
                     EnsureLoaded(realm.Realm);
 
-                    Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("subfolder"))), "Files contain common subfolder");
+                    ClassicAssert.False(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("subfolder"))), "Files contain common subfolder");
                 }
                 finally
                 {
@@ -1128,10 +1126,10 @@ namespace osu.Game.Tests.Database
 
                 try
                 {
-                    using (var zip = ZipArchive.Open(temp))
+                    using (var zip = ZipArchive.OpenArchive(temp))
                         zip.WriteToDirectory(dataFolder);
 
-                    using (var zip = ZipArchive.Create())
+                    using (var zip = ZipArchive.CreateArchive())
                     {
                         zip.AddAllFromDirectory(extractedFolder);
                         zip.SaveTo(temp, new ZipWriterOptions(CompressionType.Deflate));
@@ -1139,13 +1137,13 @@ namespace osu.Game.Tests.Database
 
                     var imported = await importer.Import(new ImportTask(temp));
 
-                    Assert.NotNull(imported);
+                    ClassicAssert.NotNull(imported);
                     Debug.Assert(imported != null);
 
                     EnsureLoaded(realm.Realm);
 
-                    Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("__MACOSX"))), "Files contain resource fork folder, which should be ignored");
-                    Assert.IsFalse(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("actual_data"))), "Files contain common subfolder");
+                    ClassicAssert.False(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("__MACOSX"))), "Files contain resource fork folder, which should be ignored");
+                    ClassicAssert.False(imported.PerformRead(s => s.Files.Any(f => f.Filename.Contains("actual_data"))), "Files contain common subfolder");
                 }
                 finally
                 {
@@ -1185,7 +1183,7 @@ namespace osu.Game.Tests.Database
 
             var importedSet = await importer.Import(new ImportTask(temp));
 
-            Assert.NotNull(importedSet);
+            ClassicAssert.NotNull(importedSet);
 
             EnsureLoaded(realm);
 
@@ -1200,7 +1198,7 @@ namespace osu.Game.Tests.Database
 
             var importedSet = await importer.Import(new ImportTask(temp), new ImportParameters { Batch = batchImport });
 
-            Assert.NotNull(importedSet);
+            ClassicAssert.NotNull(importedSet);
             Debug.Assert(importedSet != null);
 
             EnsureLoaded(realm);
@@ -1217,7 +1215,7 @@ namespace osu.Game.Tests.Database
             checkBeatmapSetCount(realm, 0);
             checkBeatmapSetCount(realm, 1, true);
 
-            Assert.IsTrue(realm.All<BeatmapSetInfo>().First(_ => true).DeletePending);
+            ClassicAssert.True(realm.All<BeatmapSetInfo>().First(_ => true).DeletePending);
         }
 
         private static Task createScoreForBeatmap(Realm realm, BeatmapInfo beatmap) =>
@@ -1233,7 +1231,7 @@ namespace osu.Game.Tests.Database
 
         private static void checkBeatmapSetCount(Realm realm, int expected, bool includeDeletePending = false)
         {
-            Assert.AreEqual(expected, includeDeletePending
+            ClassicAssert.AreEqual(expected, includeDeletePending
                 ? realm.All<BeatmapSetInfo>().Count()
                 : realm.All<BeatmapSetInfo>().Count(s => !s.DeletePending));
         }
@@ -1246,7 +1244,7 @@ namespace osu.Game.Tests.Database
 
         private static void checkBeatmapCount(Realm realm, int expected)
         {
-            Assert.AreEqual(expected, realm.All<BeatmapInfo>().Where(_ => true).ToList().Count);
+            ClassicAssert.AreEqual(expected, realm.All<BeatmapInfo>().Where(_ => true).ToList().Count);
         }
 
         private static void checkSingleReferencedFileCount(Realm realm, int expected)
@@ -1259,7 +1257,7 @@ namespace osu.Game.Tests.Database
                     singleReferencedCount++;
             }
 
-            Assert.AreEqual(expected, singleReferencedCount);
+            ClassicAssert.AreEqual(expected, singleReferencedCount);
         }
 
         internal static void EnsureLoaded(Realm realm, int timeout = 60000)
@@ -1273,7 +1271,7 @@ namespace osu.Game.Tests.Database
             }, @"BeatmapSet did not import to the database in allocated time.", timeout);
 
             // ensure we were stored to beatmap database backing...
-            Assert.IsTrue(resultSets?.Count() == 1, $@"Incorrect result count found ({resultSets?.Count()} but should be 1).");
+            ClassicAssert.True(resultSets?.Count() == 1, $@"Incorrect result count found ({resultSets?.Count()} but should be 1).");
 
             IEnumerable<BeatmapSetInfo> queryBeatmapSets() => realm.All<BeatmapSetInfo>().Where(s => !s.DeletePending && s.OnlineID == 241526);
 
@@ -1282,20 +1280,20 @@ namespace osu.Game.Tests.Database
             // ReSharper disable once PossibleUnintendedReferenceComparison
             IEnumerable<BeatmapInfo> queryBeatmaps() => realm.All<BeatmapInfo>().Where(s => s.BeatmapSet != null && s.BeatmapSet == set);
 
-            Assert.AreEqual(12, queryBeatmaps().Count(), @"Beatmap count was not correct");
-            Assert.AreEqual(1, queryBeatmapSets().Count(), @"Beatmapset count was not correct");
+            ClassicAssert.AreEqual(12, queryBeatmaps().Count(), @"Beatmap count was not correct");
+            ClassicAssert.AreEqual(1, queryBeatmapSets().Count(), @"Beatmapset count was not correct");
 
             int countBeatmapSetBeatmaps;
             int countBeatmaps;
 
-            Assert.AreEqual(
+            ClassicAssert.AreEqual(
                 countBeatmapSetBeatmaps = queryBeatmapSets().First().Beatmaps.Count,
                 countBeatmaps = queryBeatmaps().Count(),
                 $@"Incorrect database beatmap count post-import ({countBeatmaps} but should be {countBeatmapSetBeatmaps}).");
 
             foreach (BeatmapInfo b in set.Beatmaps)
-                Assert.IsTrue(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
-            Assert.IsTrue(set.Beatmaps.Count > 0);
+                ClassicAssert.True(set.Beatmaps.Any(c => c.OnlineID == b.OnlineID));
+            ClassicAssert.True(set.Beatmaps.Count > 0);
         }
 
         private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 60000)

osu.Game.Tests/Database/BeatmapImporterUpdateTests.cs

@@ -680,14 +680,14 @@ namespace osu.Game.Tests.Database
             string extractedFolder = $"{path}_extracted";
             Directory.CreateDirectory(extractedFolder);
 
-            using (var zip = ZipArchive.Open(path))
+            using (var zip = ZipArchive.OpenArchive(path))
                 zip.WriteToDirectory(extractedFolder);
 
             applyModifications(new DirectoryInfo(extractedFolder));
 
             File.Delete(path);
 
-            using (var zip = ZipArchive.Create())
+            using (var zip = ZipArchive.CreateArchive())
             {
                 zip.AddAllFromDirectory(extractedFolder);
                 zip.SaveTo(path, new ZipWriterOptions(CompressionType.Deflate));

osu.Game.Tests/Database/FileStoreTests.cs

@@ -5,6 +5,7 @@ using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Logging;
 using osu.Game.Database;
 using osu.Game.Extensions;
@@ -26,8 +27,8 @@ namespace osu.Game.Tests.Database
 
                 realm.Write(() => files.Add(testData, realm));
 
-                Assert.True(files.Storage.Exists("0/05/054edec1d0211f624fed0cbca9d4f9400b0e491c43742af2c5b0abebf0c990d8"));
-                Assert.True(files.Storage.Exists(realm.All<RealmFile>().First().GetStoragePath()));
+                ClassicAssert.True(files.Storage.Exists("0/05/054edec1d0211f624fed0cbca9d4f9400b0e491c43742af2c5b0abebf0c990d8"));
+                ClassicAssert.True(files.Storage.Exists(realm.All<RealmFile>().First().GetStoragePath()));
             });
         }
 
@@ -44,7 +45,7 @@ namespace osu.Game.Tests.Database
                 realm.Write(() => files.Add(testData, realm));
                 realm.Write(() => files.Add(testData, realm));
 
-                Assert.AreEqual(1, realm.All<RealmFile>().Count());
+                ClassicAssert.AreEqual(1, realm.All<RealmFile>().Count());
             });
         }
 
@@ -75,15 +76,15 @@ namespace osu.Game.Tests.Database
 
                 string path = file.GetStoragePath();
 
-                Assert.True(realm.All<RealmFile>().Any());
-                Assert.True(files.Storage.Exists(path));
+                ClassicAssert.True(realm.All<RealmFile>().Any());
+                ClassicAssert.True(files.Storage.Exists(path));
 
                 files.Cleanup();
                 Logger.Log($"Cleanup complete at {timer.ElapsedMilliseconds}");
 
-                Assert.True(realm.All<RealmFile>().Any());
-                Assert.True(file.IsValid);
-                Assert.True(files.Storage.Exists(path));
+                ClassicAssert.True(realm.All<RealmFile>().Any());
+                ClassicAssert.True(file.IsValid);
+                ClassicAssert.True(files.Storage.Exists(path));
             });
         }
 
@@ -99,14 +100,14 @@ namespace osu.Game.Tests.Database
 
                 string path = file.GetStoragePath();
 
-                Assert.True(realm.All<RealmFile>().Any());
-                Assert.True(files.Storage.Exists(path));
+                ClassicAssert.True(realm.All<RealmFile>().Any());
+                ClassicAssert.True(files.Storage.Exists(path));
 
                 files.Cleanup();
 
-                Assert.False(realm.All<RealmFile>().Any());
-                Assert.False(file.IsValid);
-                Assert.False(files.Storage.Exists(path));
+                ClassicAssert.False(realm.All<RealmFile>().Any());
+                ClassicAssert.False(file.IsValid);
+                ClassicAssert.False(files.Storage.Exists(path));
             });
         }
     }

osu.Game.Tests/Database/GeneralUsageTests.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
@@ -143,7 +144,7 @@ namespace osu.Game.Tests.Database
                     return null;
                 });
 
-                Assert.IsTrue(callbackRan);
+                ClassicAssert.True(callbackRan);
             });
         }
 

osu.Game.Tests/Database/LegacyBeatmapImporterTest.cs

@@ -7,6 +7,7 @@ using System.IO;
 using System.IO.Compression;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -93,8 +94,8 @@ namespace osu.Game.Tests.Database
 
                     var importedSet = realm.Realm.All<BeatmapSetInfo>().Single();
 
-                    Assert.NotNull(importedSet);
-                    Assert.AreEqual(new DateTimeOffset(new DateTime(2000, 1, 1, 12, 0, 0, DateTimeKind.Utc)), importedSet.DateAdded);
+                    ClassicAssert.NotNull(importedSet);
+                    ClassicAssert.AreEqual(new DateTimeOffset(new DateTime(2000, 1, 1, 12, 0, 0, DateTimeKind.Utc)), importedSet.DateAdded);
                 }
             });
         }

osu.Game.Tests/Database/RealmLiveTests.cs

@@ -6,6 +6,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Extensions;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -25,7 +26,7 @@ namespace osu.Game.Tests.Database
 
                 Live<BeatmapInfo> beatmap2 = realm.Run(r => r.All<BeatmapInfo>().First().ToLive(realm));
 
-                Assert.AreEqual(beatmap, beatmap2);
+                ClassicAssert.AreEqual(beatmap, beatmap2);
             });
         }
 
@@ -52,7 +53,7 @@ namespace osu.Game.Tests.Database
                     using (realm.BlockAllOperations("testing"))
                         storage.Migrate(migratedStorage);
 
-                    Assert.IsFalse(liveBeatmap?.PerformRead(l => l.Hidden));
+                    ClassicAssert.False(liveBeatmap?.PerformRead(l => l.Hidden));
                 });
             }
         }
@@ -111,7 +112,7 @@ namespace osu.Game.Tests.Database
                             r.Add(beatmap)))
                 );
 
-                Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+                ClassicAssert.False(liveBeatmap.PerformRead(l => l.Hidden));
             });
         }
 
@@ -126,7 +127,7 @@ namespace osu.Game.Tests.Database
 
                 realm.Run(r => r.Write(_ => r.Add(beatmap)));
 
-                Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+                ClassicAssert.False(liveBeatmap.PerformRead(l => l.Hidden));
             });
         }
 
@@ -136,15 +137,15 @@ namespace osu.Game.Tests.Database
             var beatmap = new BeatmapInfo(CreateRuleset(), new BeatmapDifficulty(), new BeatmapMetadata());
             var liveBeatmap = beatmap.ToLiveUnmanaged();
 
-            Assert.IsFalse(beatmap.Hidden);
-            Assert.IsFalse(liveBeatmap.Value.Hidden);
-            Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+            ClassicAssert.False(beatmap.Hidden);
+            ClassicAssert.False(liveBeatmap.Value.Hidden);
+            ClassicAssert.False(liveBeatmap.PerformRead(l => l.Hidden));
 
             Assert.Throws<InvalidOperationException>(() => liveBeatmap.PerformWrite(l => l.Hidden = true));
 
-            Assert.IsFalse(beatmap.Hidden);
-            Assert.IsFalse(liveBeatmap.Value.Hidden);
-            Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+            ClassicAssert.False(beatmap.Hidden);
+            ClassicAssert.False(liveBeatmap.Value.Hidden);
+            ClassicAssert.False(liveBeatmap.PerformRead(l => l.Hidden));
         }
 
         [Test]
@@ -159,10 +160,10 @@ namespace osu.Game.Tests.Database
                 var liveBeatmap = beatmap.ToLive(realm);
 
                 Assert.Throws<InvalidOperationException>(() => liveBeatmap.PerformWrite(l => throw new InvalidOperationException()));
-                Assert.IsFalse(liveBeatmap.PerformRead(l => l.Hidden));
+                ClassicAssert.False(liveBeatmap.PerformRead(l => l.Hidden));
 
                 liveBeatmap.PerformWrite(l => l.Hidden = true);
-                Assert.IsTrue(liveBeatmap.PerformRead(l => l.Hidden));
+                ClassicAssert.True(liveBeatmap.PerformRead(l => l.Hidden));
             });
         }
 
@@ -188,8 +189,8 @@ namespace osu.Game.Tests.Database
                 {
                     liveBeatmap.PerformRead(beatmap =>
                     {
-                        Assert.IsTrue(beatmap.IsValid);
-                        Assert.IsFalse(beatmap.Hidden);
+                        ClassicAssert.True(beatmap.IsValid);
+                        ClassicAssert.False(beatmap.Hidden);
                     });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
             });
@@ -216,7 +217,7 @@ namespace osu.Game.Tests.Database
                 Task.Factory.StartNew(() =>
                 {
                     liveBeatmap.PerformWrite(beatmap => { beatmap.Hidden = true; });
-                    liveBeatmap.PerformRead(beatmap => { Assert.IsTrue(beatmap.Hidden); });
+                    liveBeatmap.PerformRead(beatmap => { ClassicAssert.True(beatmap.Hidden); });
                 }, TaskCreationOptions.LongRunning | TaskCreationOptions.HideScheduler).WaitSafely();
             });
         }
@@ -333,17 +334,17 @@ namespace osu.Game.Tests.Database
                     Debug.Assert(liveBeatmap != null);
 
                     // not yet seen by main context
-                    Assert.AreEqual(0, outerRealm.All<BeatmapInfo>().Count());
-                    Assert.AreEqual(0, changesTriggered);
+                    ClassicAssert.AreEqual(0, outerRealm.All<BeatmapInfo>().Count());
+                    ClassicAssert.AreEqual(0, changesTriggered);
 
                     liveBeatmap.PerformRead(resolved =>
                     {
                         // retrieval causes an implicit refresh. even changes that aren't related to the retrieval are fired at this point.
-                        Assert.AreEqual(2, outerRealm.All<BeatmapInfo>().Count());
-                        Assert.AreEqual(1, changesTriggered);
+                        ClassicAssert.AreEqual(2, outerRealm.All<BeatmapInfo>().Count());
+                        ClassicAssert.AreEqual(1, changesTriggered);
 
                         // can access properties without a crash.
-                        Assert.IsFalse(resolved.Hidden);
+                        ClassicAssert.False(resolved.Hidden);
 
                         outerRealm.Write(r =>
                         {

osu.Game.Tests/Database/RulesetStoreTests.cs

@@ -5,8 +5,10 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
@@ -26,8 +28,8 @@ namespace osu.Game.Tests.Database
             {
                 using var rulesets = new RealmRulesetStore(realm, storage);
 
-                Assert.AreEqual(4, rulesets.AvailableRulesets.Count());
-                Assert.AreEqual(4, realm.Realm.All<RulesetInfo>().Count());
+                ClassicAssert.AreEqual(4, rulesets.AvailableRulesets.Count());
+                ClassicAssert.AreEqual(4, realm.Realm.All<RulesetInfo>().Count());
             });
         }
 
@@ -39,11 +41,11 @@ namespace osu.Game.Tests.Database
                 using var rulesets = new RealmRulesetStore(realm, storage);
                 using var rulesets2 = new RealmRulesetStore(realm, storage);
 
-                Assert.AreEqual(4, rulesets.AvailableRulesets.Count());
-                Assert.AreEqual(4, rulesets2.AvailableRulesets.Count());
+                ClassicAssert.AreEqual(4, rulesets.AvailableRulesets.Count());
+                ClassicAssert.AreEqual(4, rulesets2.AvailableRulesets.Count());
 
-                Assert.AreEqual(rulesets.AvailableRulesets.First(), rulesets2.AvailableRulesets.First());
-                Assert.AreEqual(4, realm.Realm.All<RulesetInfo>().Count());
+                ClassicAssert.AreEqual(rulesets.AvailableRulesets.First(), rulesets2.AvailableRulesets.First());
+                ClassicAssert.AreEqual(4, realm.Realm.All<RulesetInfo>().Count());
             });
         }
 
@@ -54,9 +56,9 @@ namespace osu.Game.Tests.Database
             {
                 using var rulesets = new RealmRulesetStore(realm, storage);
 
-                Assert.IsFalse(rulesets.AvailableRulesets.First().IsManaged);
-                Assert.IsFalse(rulesets.GetRuleset(0)?.IsManaged);
-                Assert.IsFalse(rulesets.GetRuleset("mania")?.IsManaged);
+                ClassicAssert.False(rulesets.AvailableRulesets.First().IsManaged);
+                ClassicAssert.False(rulesets.GetRuleset(0)?.IsManaged);
+                ClassicAssert.False(rulesets.GetRuleset("mania")?.IsManaged);
             });
         }
 
@@ -116,6 +118,69 @@ namespace osu.Game.Tests.Database
             });
         }
 
+        [Test]
+        public void TestFakedRulesetIdIsDetected()
+        {
+            RunTestWithRealm((realm, storage) =>
+            {
+                LoadTestRuleset.HasImplementations = true;
+                LoadTestRuleset.Version = Ruleset.CURRENT_RULESET_API_VERSION;
+
+                var ruleset = new LoadTestRuleset();
+                string rulesetShortName = ruleset.RulesetInfo.ShortName;
+
+                realm.Write(r => r.Add(new RulesetInfo(rulesetShortName, ruleset.RulesetInfo.Name, ruleset.RulesetInfo.InstantiationInfo, 0)
+                {
+                    Available = true,
+                }));
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName)!.Available), Is.True);
+
+                // Availability is updated on construction of a RealmRulesetStore
+                using var _ = new RealmRulesetStore(realm, storage);
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(rulesetShortName)!.Available), Is.False);
+            });
+        }
+
+        [Test]
+        public void TestMultipleRulesetWithSameOnlineIdsAreDetected()
+        {
+            RunTestWithRealm((realm, storage) =>
+            {
+                LoadTestRuleset.HasImplementations = true;
+                LoadTestRuleset.Version = Ruleset.CURRENT_RULESET_API_VERSION;
+                LoadTestRuleset.OnlineID = 2;
+
+                var first = new LoadTestRuleset();
+                var second = new CatchRuleset();
+
+                realm.Write(r => r.Add(new RulesetInfo(first.ShortName, first.RulesetInfo.Name, first.RulesetInfo.InstantiationInfo, first.RulesetInfo.OnlineID)
+                {
+                    Available = true,
+                }));
+                realm.Write(r => r.Add(new RulesetInfo(second.ShortName, second.RulesetInfo.Name, second.RulesetInfo.InstantiationInfo, second.RulesetInfo.OnlineID)
+                {
+                    Available = true,
+                }));
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(first.ShortName)!.Available), Is.True);
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(second.ShortName)!.Available), Is.True);
+
+                // Availability is updated on construction of a RealmRulesetStore
+                using var _ = new RealmRulesetStore(realm, storage);
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(first.ShortName)!.Available), Is.False);
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(second.ShortName)!.Available), Is.False);
+
+                realm.Write(r => r.Remove(r.Find<RulesetInfo>(first.ShortName)!));
+
+                using var __ = new RealmRulesetStore(realm, storage);
+
+                Assert.That(realm.Run(r => r.Find<RulesetInfo>(second.ShortName)!.Available), Is.True);
+            });
+        }
+
         private class LoadTestRuleset : Ruleset
         {
             public override string RulesetAPIVersionSupported => Version;
@@ -124,6 +189,13 @@ namespace osu.Game.Tests.Database
 
             public static string Version { get; set; } = CURRENT_RULESET_API_VERSION;
 
+            public static int OnlineID { get; set; } = -1;
+
+            public LoadTestRuleset()
+            {
+                RulesetInfo.OnlineID = OnlineID;
+            }
+
             public override IEnumerable<Mod> GetModsFor(ModType type)
             {
                 if (!HasImplementations)

osu.Game.Tests/Database/TestRealmKeyBindingStore.cs

@@ -3,14 +3,11 @@
 
 #nullable disable
 
-using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Platform;
 using osu.Game.Database;
 using osu.Game.Input;
 using osu.Game.Input.Bindings;
@@ -20,63 +17,87 @@ using Realms;
 namespace osu.Game.Tests.Database
 {
     [TestFixture]
-    public partial class TestRealmKeyBindingStore
+    public partial class TestRealmKeyBindingStore : RealmTest
     {
-        private NativeStorage storage;
-
-        private RealmKeyBindingStore keyBindingStore;
-
-        private RealmAccess realm;
-
-        [SetUp]
-        public void SetUp()
-        {
-            var directory = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString()));
-
-            storage = new NativeStorage(directory.FullName);
-
-            realm = new RealmAccess(storage, "test");
-            keyBindingStore = new RealmKeyBindingStore(realm, new ReadableKeyCombinationProvider());
-        }
-
         [Test]
         public void TestDefaultsPopulationAndQuery()
         {
-            Assert.That(queryCount(), Is.EqualTo(0));
+            RunTestWithRealm((realm, _) =>
+            {
+                Assert.That(queryCount(realm), Is.EqualTo(0));
 
-            KeyBindingContainer testContainer = new TestKeyBindingContainer();
+                KeyBindingContainer testContainer = new TestKeyBindingContainer();
 
-            keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
+                var keyBindingStore = new RealmKeyBindingStore(realm, new ReadableKeyCombinationProvider());
+                keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
 
-            Assert.That(queryCount(), Is.EqualTo(3));
+                Assert.That(queryCount(realm), Is.EqualTo(3));
 
-            Assert.That(queryCount(GlobalAction.Back), Is.EqualTo(1));
-            Assert.That(queryCount(GlobalAction.Select), Is.EqualTo(2));
+                Assert.That(queryCount(realm, GlobalAction.Back), Is.EqualTo(1));
+                Assert.That(queryCount(realm, GlobalAction.Select), Is.EqualTo(2));
+            });
         }
 
         [Test]
         public void TestDefaultsPopulationRemovesExcess()
         {
-            Assert.That(queryCount(), Is.EqualTo(0));
-
-            KeyBindingContainer testContainer = new TestKeyBindingContainer();
-
-            // Add some excess bindings for an action which only supports 1.
-            realm.Write(r =>
+            RunTestWithRealm((realm, _) =>
             {
-                r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.A)));
-                r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.S)));
-                r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.D)));
+                Assert.That(queryCount(realm), Is.EqualTo(0));
+
+                KeyBindingContainer testContainer = new TestKeyBindingContainer();
+
+                // Add some excess bindings for an action which only supports 1.
+                realm.Write(r =>
+                {
+                    r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.A)));
+                    r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.S)));
+                    r.Add(new RealmKeyBinding(GlobalAction.Back, new KeyCombination(InputKey.D)));
+                });
+
+                Assert.That(queryCount(realm, GlobalAction.Back), Is.EqualTo(3));
+
+                var keyBindingStore = new RealmKeyBindingStore(realm, new ReadableKeyCombinationProvider());
+                keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
+
+                Assert.That(queryCount(realm, GlobalAction.Back), Is.EqualTo(1));
             });
-
-            Assert.That(queryCount(GlobalAction.Back), Is.EqualTo(3));
-
-            keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
-
-            Assert.That(queryCount(GlobalAction.Back), Is.EqualTo(1));
         }
 
-        private int queryCount(GlobalAction? match = null)
+        [Test]
+        public void TestUpdateViaQueriedReference()
+        {
+            RunTestWithRealm((realm, _) =>
+            {
+                KeyBindingContainer testContainer = new TestKeyBindingContainer();
+
+                var keyBindingStore = new RealmKeyBindingStore(realm, new ReadableKeyCombinationProvider());
+                keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
+
+                realm.Run(outerRealm =>
+                {
+                    var backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
+
+                    Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.Escape }));
+
+                    var tsr = ThreadSafeReference.Create(backBinding);
+
+                    realm.Run(innerRealm =>
+                    {
+                        var binding = innerRealm.ResolveReference(tsr)!;
+                        innerRealm.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
+                    });
+
+                    Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
+
+                    // check still correct after re-query.
+                    backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
+                    Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
+                });
+            });
+        }
+
+        private static int queryCount(RealmAccess realm, GlobalAction? match = null)
         {
             return realm.Run(r =>
             {
@@ -87,42 +108,6 @@ namespace osu.Game.Tests.Database
             });
         }
 
-        [Test]
-        public void TestUpdateViaQueriedReference()
-        {
-            KeyBindingContainer testContainer = new TestKeyBindingContainer();
-
-            keyBindingStore.Register(testContainer, Enumerable.Empty<RulesetInfo>());
-
-            realm.Run(outerRealm =>
-            {
-                var backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
-
-                Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.Escape }));
-
-                var tsr = ThreadSafeReference.Create(backBinding);
-
-                realm.Run(innerRealm =>
-                {
-                    var binding = innerRealm.ResolveReference(tsr)!;
-                    innerRealm.Write(() => binding.KeyCombination = new KeyCombination(InputKey.BackSpace));
-                });
-
-                Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
-
-                // check still correct after re-query.
-                backBinding = outerRealm.All<RealmKeyBinding>().Single(k => k.ActionInt == (int)GlobalAction.Back);
-                Assert.That(backBinding.KeyCombination.Keys, Is.EquivalentTo(new[] { InputKey.BackSpace }));
-            });
-        }
-
-        [TearDown]
-        public void TearDown()
-        {
-            realm.Dispose();
-            storage.DeleteDirectory(string.Empty);
-        }
-
         public partial class TestKeyBindingContainer : KeyBindingContainer
         {
             public override IEnumerable<IKeyBinding> DefaultKeyBindings =>

osu.Game.Tests/Editing/Checks/CheckAudioInVideoTest.cs

@@ -5,6 +5,7 @@ using System.IO;
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Checks;
@@ -44,7 +45,7 @@ namespace osu.Game.Tests.Editing.Checks
         public void TestRegularVideoFile()
         {
             using (var resourceStream = TestResources.OpenResource("Videos/test-video.mp4"))
-                Assert.IsEmpty(check.Run(getContext(resourceStream)));
+                ClassicAssert.IsEmpty(check.Run(getContext(resourceStream)));
         }
 
         [Test]
@@ -88,7 +89,7 @@ namespace osu.Game.Tests.Editing.Checks
             var layer = storyboard.GetLayer("Video");
             layer.Add(new StoryboardVideo("abc123.mp4", 0));
 
-            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null!, null!);
             mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
             mockWorkingBeatmap.As<IWorkingBeatmap>().SetupGet(w => w.Storyboard).Returns(storyboard);
 

osu.Game.Tests/Editing/Checks/CheckDelayedHitsoundsTest.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using ManagedBass;
 using Moq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Models;
 using osu.Game.Rulesets.Edit;
@@ -49,7 +50,7 @@ namespace osu.Game.Tests.Editing.Checks
         public void TestNoDelayedHitsounds()
         {
             using var resourceStream = TestResources.OpenResource("Samples/hitsound-no-delay.wav");
-            Assert.IsEmpty(check.Run(getContext(resourceStream)));
+            ClassicAssert.IsEmpty(check.Run(getContext(resourceStream)));
         }
 
         [Test]
@@ -96,7 +97,7 @@ namespace osu.Game.Tests.Editing.Checks
 
         private BeatmapVerifierContext getContext(Stream? resourceStream)
         {
-            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null!, null!);
             mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
 
             return new BeatmapVerifierContext(beatmap, mockWorkingBeatmap.Object);

osu.Game.Tests/Editing/Checks/CheckHitsoundsFormatTest.cs

@@ -139,7 +139,7 @@ namespace osu.Game.Tests.Editing.Checks
                         Metadata = new BeatmapMetadata { AudioFile = beatmapSet.Files[0].Filename }
                     }
                 };
-                var firstWorking = new Mock<TestWorkingBeatmap>(firstPlayable, null, null);
+                var firstWorking = new Mock<TestWorkingBeatmap>(firstPlayable, null!, null!);
                 firstWorking.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
 
                 var secondPlayable = new Beatmap<HitObject>
@@ -150,7 +150,7 @@ namespace osu.Game.Tests.Editing.Checks
                         Metadata = new BeatmapMetadata { AudioFile = beatmapSet.Files[1].Filename }
                     }
                 };
-                var secondWorking = new Mock<TestWorkingBeatmap>(secondPlayable, null, null);
+                var secondWorking = new Mock<TestWorkingBeatmap>(secondPlayable, null!, null!);
                 secondWorking.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
 
                 var context = new BeatmapVerifierContext(
@@ -165,7 +165,7 @@ namespace osu.Game.Tests.Editing.Checks
 
         private BeatmapVerifierContext getContext(Stream? resourceStream)
         {
-            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null!, null!);
             mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
 
             return new BeatmapVerifierContext(beatmap, mockWorkingBeatmap.Object);

osu.Game.Tests/Editing/Checks/CheckSongFormatTest.cs

@@ -103,7 +103,7 @@ namespace osu.Game.Tests.Editing.Checks
 
         private BeatmapVerifierContext getContext(Stream? resourceStream)
         {
-            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null!, null!);
             mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
 
             return new BeatmapVerifierContext(beatmap, mockWorkingBeatmap.Object);

osu.Game.Tests/Editing/Checks/CheckTooShortAudioFilesTest.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using ManagedBass;
 using Moq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Checks;
@@ -52,7 +53,7 @@ namespace osu.Game.Tests.Editing.Checks
             beatmap.BeatmapInfo.BeatmapSet.Files.Add(CheckTestHelpers.CreateMockFile("jpg"));
 
             // Should fail to load, but not produce an error due to the extension not being expected to load.
-            Assert.IsEmpty(check.Run(getContext(null)));
+            ClassicAssert.IsEmpty(check.Run(getContext(null)));
         }
 
         [Test]
@@ -60,7 +61,7 @@ namespace osu.Game.Tests.Editing.Checks
         {
             using (var resourceStream = TestResources.OpenResource("Samples/test-sample.mp3"))
             {
-                Assert.IsEmpty(check.Run(getContext(resourceStream)));
+                ClassicAssert.IsEmpty(check.Run(getContext(resourceStream)));
             }
         }
 
@@ -70,7 +71,7 @@ namespace osu.Game.Tests.Editing.Checks
             using (var resourceStream = TestResources.OpenResource("Samples/blank.wav"))
             {
                 // This is a 0 ms duration audio file, commonly used to silence sliderslides/ticks, and so should be fine.
-                Assert.IsEmpty(check.Run(getContext(resourceStream)));
+                ClassicAssert.IsEmpty(check.Run(getContext(resourceStream)));
             }
         }
 
@@ -91,13 +92,13 @@ namespace osu.Game.Tests.Editing.Checks
         {
             using (var resourceStream = TestResources.OpenResource("Samples/missing.mp3"))
             {
-                Assert.IsEmpty(check.Run(getContext(resourceStream)));
+                ClassicAssert.IsEmpty(check.Run(getContext(resourceStream)));
             }
         }
 
         private BeatmapVerifierContext getContext(Stream? resourceStream)
         {
-            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null!, null!);
             mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
 
             return new BeatmapVerifierContext(beatmap, mockWorkingBeatmap.Object);

osu.Game.Tests/Editing/Checks/CheckVideoResolutionTest.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Tests.Editing.Checks
             var layer = storyboard.GetLayer("Video");
             layer.Add(new StoryboardVideo("abc123.mp4", 0));
 
-            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null!, null!);
             mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
             mockWorkingBeatmap.As<IWorkingBeatmap>().SetupGet(w => w.Storyboard).Returns(storyboard);
 

osu.Game.Tests/Editing/Checks/CheckZeroByteFilesTest.cs

@@ -5,6 +5,7 @@ using System.IO;
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Checks;
@@ -40,7 +41,7 @@ namespace osu.Game.Tests.Editing.Checks
         [Test]
         public void TestNonZeroBytes()
         {
-            Assert.IsEmpty(check.Run(getContext(byteLength: 44)));
+            ClassicAssert.IsEmpty(check.Run(getContext(byteLength: 44)));
         }
 
         [Test]
@@ -55,7 +56,7 @@ namespace osu.Game.Tests.Editing.Checks
         [Test]
         public void TestMissing()
         {
-            Assert.IsEmpty(check.Run(getContextMissing()));
+            ClassicAssert.IsEmpty(check.Run(getContextMissing()));
         }
 
         private BeatmapVerifierContext getContext(long byteLength)

osu.Game.Tests/ImportTest.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions;
 using osu.Framework.Platform;
@@ -42,7 +43,7 @@ namespace osu.Game.Tests
                 while (!result()) Thread.Sleep(200);
             });
 
-            Assert.IsTrue(task.Wait(timeout), failureMessage);
+            ClassicAssert.True(task.Wait(timeout), failureMessage);
         }
 
         public partial class TestOsuGameBase : OsuGameBase

osu.Game.Tests/Localisation/BeatmapMetadataRomanisationTest.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 
 namespace osu.Game.Tests.Localisation
@@ -21,8 +22,8 @@ namespace osu.Game.Tests.Localisation
             };
             var romanisableString = metadata.GetDisplayTitleRomanisable();
 
-            Assert.AreEqual(metadata.ToString(), romanisableString.Romanised);
-            Assert.AreEqual($"{metadata.ArtistUnicode} - {metadata.TitleUnicode}", romanisableString.Original);
+            ClassicAssert.AreEqual(metadata.ToString(), romanisableString.Romanised);
+            ClassicAssert.AreEqual($"{metadata.ArtistUnicode} - {metadata.TitleUnicode}", romanisableString.Original);
         }
 
         [Test]
@@ -35,7 +36,7 @@ namespace osu.Game.Tests.Localisation
             };
             var romanisableString = metadata.GetDisplayTitleRomanisable();
 
-            Assert.AreEqual(romanisableString.Romanised, romanisableString.Original);
+            ClassicAssert.AreEqual(romanisableString.Romanised, romanisableString.Original);
         }
     }
 }

osu.Game.Tests/Mods/ModUtilsTest.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Moq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Extensions.TypeExtensions;
 using osu.Framework.Localisation;
 using osu.Game.Online.Rooms;
@@ -196,7 +197,7 @@ namespace osu.Game.Tests.Mods
             Assert.That(isValid, Is.EqualTo(expectedInvalid.Length == 0));
 
             if (isValid)
-                Assert.IsNull(invalid);
+                ClassicAssert.Null(invalid);
             else
                 Assert.That(invalid?.Select(t => t.GetType()), Is.EquivalentTo(expectedInvalid));
         }
@@ -214,21 +215,21 @@ namespace osu.Game.Tests.Mods
         [Test]
         public void TestFormatScoreMultiplier()
         {
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.9999).ToString(), "0.99x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.0).ToString(), "1.00x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.0001).ToString(), "1.01x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(0.9999).ToString(), "0.99x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.0).ToString(), "1.00x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.0001).ToString(), "1.01x");
 
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.899999999999999).ToString(), "0.90x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.9).ToString(), "0.90x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(0.900000000000001).ToString(), "0.90x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(0.899999999999999).ToString(), "0.90x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(0.9).ToString(), "0.90x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(0.900000000000001).ToString(), "0.90x");
 
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.099999999999999).ToString(), "1.10x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.1).ToString(), "1.10x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.100000000000001).ToString(), "1.10x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.099999999999999).ToString(), "1.10x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.1).ToString(), "1.10x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.100000000000001).ToString(), "1.10x");
 
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.045).ToString(), "1.05x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.05).ToString(), "1.05x");
-            Assert.AreEqual(ModUtils.FormatScoreMultiplier(1.055).ToString(), "1.06x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.045).ToString(), "1.05x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.05).ToString(), "1.05x");
+            ClassicAssert.AreEqual(ModUtils.FormatScoreMultiplier(1.055).ToString(), "1.06x");
         }
 
         private static readonly object[] multiplayer_mod_test_scenarios =
@@ -309,7 +310,7 @@ namespace osu.Game.Tests.Mods
             Assert.That(isValid, Is.EqualTo(scenario.InvalidTypes.Length == 0));
 
             if (isValid)
-                Assert.IsNull(invalidMods);
+                ClassicAssert.Null(invalidMods);
             else
                 Assert.That(invalidMods?.Select(t => t.GetType()), Is.EquivalentTo(scenario.InvalidTypes));
         }
@@ -318,12 +319,12 @@ namespace osu.Game.Tests.Mods
         public void TestPlaylistsModScenarios()
         {
             // The rest are tested by TestMultiplayerModScenarios.
-            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModHardRock(), false, MatchType.Playlists, false));
-            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModHardRock(), true, MatchType.Playlists, false));
-            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModDoubleTime(), false, MatchType.Playlists, false));
-            Assert.IsTrue(ModUtils.IsValidModForMatch(new OsuModDoubleTime(), true, MatchType.Playlists, false));
-            Assert.IsTrue(ModUtils.IsValidModForMatch(new ModAdaptiveSpeed(), false, MatchType.Playlists, false));
-            Assert.IsTrue(ModUtils.IsValidModForMatch(new ModAdaptiveSpeed(), true, MatchType.Playlists, false));
+            ClassicAssert.True(ModUtils.IsValidModForMatch(new OsuModHardRock(), false, MatchType.Playlists, false));
+            ClassicAssert.True(ModUtils.IsValidModForMatch(new OsuModHardRock(), true, MatchType.Playlists, false));
+            ClassicAssert.True(ModUtils.IsValidModForMatch(new OsuModDoubleTime(), false, MatchType.Playlists, false));
+            ClassicAssert.True(ModUtils.IsValidModForMatch(new OsuModDoubleTime(), true, MatchType.Playlists, false));
+            ClassicAssert.True(ModUtils.IsValidModForMatch(new ModAdaptiveSpeed(), false, MatchType.Playlists, false));
+            ClassicAssert.True(ModUtils.IsValidModForMatch(new ModAdaptiveSpeed(), true, MatchType.Playlists, false));
         }
 
         [Test]

osu.Game.Tests/NonVisual/BarLineGeneratorTest.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -54,13 +55,13 @@ namespace osu.Game.Tests.NonVisual
                 // every seventh bar's start time should be at least greater than the whole number we expect.
                 // It cannot be less, as that can affect overlapping scroll algorithms
                 // (the previous timing point might be chosen incorrectly if this is not the case)
-                Assert.GreaterOrEqual(barLine.StartTime, expectedTime);
+                ClassicAssert.GreaterOrEqual(barLine.StartTime, expectedTime);
 
                 // on the other side, make sure we don't stray too far from the expected time either.
-                Assert.IsTrue(Precision.AlmostEquals(barLine.StartTime, expectedTime));
+                ClassicAssert.True(Precision.AlmostEquals(barLine.StartTime, expectedTime));
 
                 // check major/minor lines for good measure too
-                Assert.AreEqual(i % signature.Numerator == 0, barLine.Major);
+                ClassicAssert.AreEqual(i % signature.Numerator == 0, barLine.Major);
             }
         }
 

osu.Game.Tests/NonVisual/BeatmapSetInfoEqualityTest.cs

@@ -6,6 +6,7 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Extensions;
 using osu.Game.Models;
@@ -22,8 +23,8 @@ namespace osu.Game.Tests.NonVisual
             var ourInfo = new BeatmapSetInfo { OnlineID = 123 };
             var otherInfo = new BeatmapSetInfo { OnlineID = 123 };
 
-            Assert.AreNotEqual(ourInfo, otherInfo);
-            Assert.IsTrue(ourInfo.MatchesOnlineID(otherInfo));
+            ClassicAssert.AreNotEqual(ourInfo, otherInfo);
+            ClassicAssert.True(ourInfo.MatchesOnlineID(otherInfo));
         }
 
         [Test]
@@ -32,8 +33,8 @@ namespace osu.Game.Tests.NonVisual
             var beatmapSetA = TestResources.CreateTestBeatmapSetInfo(1);
             var beatmapSetB = TestResources.CreateTestBeatmapSetInfo(1);
 
-            Assert.AreNotEqual(beatmapSetA, beatmapSetB);
-            Assert.IsTrue(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
+            ClassicAssert.AreNotEqual(beatmapSetA, beatmapSetB);
+            ClassicAssert.True(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
         }
 
         [Test]
@@ -49,8 +50,8 @@ namespace osu.Game.Tests.NonVisual
             addAudioFile(beatmapSetA, "abc", "AuDiO.mP3");
             addAudioFile(beatmapSetB, "abc", "audio.mp3");
 
-            Assert.AreNotEqual(beatmapSetA, beatmapSetB);
-            Assert.IsTrue(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
+            ClassicAssert.AreNotEqual(beatmapSetA, beatmapSetB);
+            ClassicAssert.True(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
         }
 
         [Test]
@@ -62,8 +63,8 @@ namespace osu.Game.Tests.NonVisual
             addAudioFile(beatmapSetA, "abc");
             addAudioFile(beatmapSetB, "abc");
 
-            Assert.AreNotEqual(beatmapSetA, beatmapSetB);
-            Assert.IsTrue(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
+            ClassicAssert.AreNotEqual(beatmapSetA, beatmapSetB);
+            ClassicAssert.True(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
         }
 
         [Test]
@@ -75,8 +76,8 @@ namespace osu.Game.Tests.NonVisual
             addAudioFile(beatmapSetA);
             addAudioFile(beatmapSetB);
 
-            Assert.AreNotEqual(beatmapSetA, beatmapSetB);
-            Assert.IsTrue(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
+            ClassicAssert.AreNotEqual(beatmapSetA, beatmapSetB);
+            ClassicAssert.True(beatmapSetA.Beatmaps.Single().AudioEquals(beatmapSetB.Beatmaps.Single()));
         }
 
         [Test]
@@ -89,8 +90,8 @@ namespace osu.Game.Tests.NonVisual
             var beatmap1 = beatmapSet.Beatmaps.First();
             var beatmap2 = beatmapSet.Beatmaps.Last();
 
-            Assert.AreNotEqual(beatmap1, beatmap2);
-            Assert.IsTrue(beatmap1.AudioEquals(beatmap2));
+            ClassicAssert.AreNotEqual(beatmap1, beatmap2);
+            ClassicAssert.True(beatmap1.AudioEquals(beatmap2));
         }
 
         [Test]
@@ -107,12 +108,12 @@ namespace osu.Game.Tests.NonVisual
             var beatmap1 = beatmapSet.Beatmaps.First();
             var beatmap2 = beatmapSet.Beatmaps.Last();
 
-            Assert.AreNotEqual(beatmap1, beatmap2);
+            ClassicAssert.AreNotEqual(beatmap1, beatmap2);
 
             beatmap1.Metadata.AudioFile = filename1;
             beatmap2.Metadata.AudioFile = filename2;
 
-            Assert.IsFalse(beatmap1.AudioEquals(beatmap2));
+            ClassicAssert.False(beatmap1.AudioEquals(beatmap2));
         }
 
         private static void addAudioFile(BeatmapSetInfo beatmapSetInfo, string hash = null, string filename = null)
@@ -128,7 +129,7 @@ namespace osu.Game.Tests.NonVisual
             var ourInfo = new BeatmapSetInfo { ID = guid };
             var otherInfo = new BeatmapSetInfo { ID = guid };
 
-            Assert.AreEqual(ourInfo, otherInfo);
+            ClassicAssert.AreEqual(ourInfo, otherInfo);
         }
 
         [Test]
@@ -137,8 +138,8 @@ namespace osu.Game.Tests.NonVisual
             var ourInfo = new BeatmapSetInfo { ID = Guid.NewGuid(), OnlineID = 12 };
             var otherInfo = new BeatmapSetInfo { OnlineID = 12 };
 
-            Assert.AreNotEqual(ourInfo, otherInfo);
-            Assert.IsTrue(ourInfo.MatchesOnlineID(otherInfo));
+            ClassicAssert.AreNotEqual(ourInfo, otherInfo);
+            ClassicAssert.True(ourInfo.MatchesOnlineID(otherInfo));
         }
 
         [Test]
@@ -147,7 +148,7 @@ namespace osu.Game.Tests.NonVisual
             var ourInfo = new BeatmapSetInfo { Hash = "1" };
             var otherInfo = new BeatmapSetInfo { Hash = "2" };
 
-            Assert.AreNotEqual(ourInfo, otherInfo);
+            ClassicAssert.AreNotEqual(ourInfo, otherInfo);
         }
     }
 }

osu.Game.Tests/NonVisual/ClosestBeatDivisorTest.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Objects;
@@ -66,6 +67,18 @@ namespace osu.Game.Tests.NonVisual
             assertClosestDivisors(divisors, closestDivisors, cpi);
         }
 
+        [Test]
+        public void TestNegativeTimingPointOffset()
+        {
+            var cpi = new ControlPointInfo();
+            cpi.Add(-300000, new TimingControlPoint { BeatLength = 1000 });
+
+            double[] divisors = { 3.03d, 0.97d, 14, 13, 7.94d, 6.08d, 3.93d, 2.96d, 2.02d, 64 };
+            double[] closestDivisors = { 3, 1, 16, 12, 8, 6, 4, 3, 2, 1 };
+
+            assertClosestDivisors(divisors, closestDivisors, cpi);
+        }
+
         private static void assertClosestDivisors(IReadOnlyList<double> divisors, IReadOnlyList<double> closestDivisors, ControlPointInfo cpi, double step = 1)
         {
             List<HitObject> hitobjects = new List<HitObject>();
@@ -85,7 +98,7 @@ namespace osu.Game.Tests.NonVisual
             };
 
             for (int i = 0; i < divisors.Count; ++i)
-                Assert.AreEqual(closestDivisors[i], beatmap.ControlPointInfo.GetClosestBeatDivisor(beatmap.HitObjects[i].StartTime), $"at index {i}");
+                ClassicAssert.AreEqual(closestDivisors[i], beatmap.ControlPointInfo.GetClosestBeatDivisor(beatmap.HitObjects[i].StartTime), $"at index {i}");
         }
     }
 }

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
@@ -141,7 +142,7 @@ namespace osu.Game.Tests.NonVisual
 
         private void assertCombinations(Type[][] expectedCombinations, Mod[] actualCombinations)
         {
-            Assert.AreEqual(expectedCombinations.Length, actualCombinations.Length);
+            ClassicAssert.AreEqual(expectedCombinations.Length, actualCombinations.Length);
 
             Assert.Multiple(() =>
             {

osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs

@@ -5,13 +5,13 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Select;
-using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
 
 namespace osu.Game.Tests.NonVisual.Filtering
@@ -62,7 +62,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var criteria = new FilterCriteria();
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.IsFalse(carouselItem.Filtered.Value);
+            ClassicAssert.False(carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -75,7 +75,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.IsTrue(carouselItem.Filtered.Value);
+            ClassicAssert.True(carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -89,7 +89,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.IsFalse(carouselItem.Filtered.Value);
+            ClassicAssert.False(carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -103,7 +103,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.IsFalse(carouselItem.Filtered.Value);
+            ClassicAssert.False(carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -124,7 +124,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(!inclusive, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(!inclusive, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -145,7 +145,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(!inclusive, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(!inclusive, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -167,7 +167,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -196,7 +196,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -216,7 +216,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -237,7 +237,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -261,7 +261,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -279,7 +279,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             };
             var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
             carouselItem.Filter(criteria);
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [TestCase("202010", true)]
@@ -296,7 +296,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -313,7 +313,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.True(carouselItem.Filtered.Value);
+            ClassicAssert.True(carouselItem.Filtered.Value);
         }
 
         [TestCase("simple", false)]
@@ -328,7 +328,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(filtered, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -346,7 +346,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(false, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(false, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -364,7 +364,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(true, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(true, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -381,7 +381,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(true, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(true, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -399,7 +399,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(true, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(true, carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -411,7 +411,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             carouselItem.BeatmapInfo.Metadata.UserTags.Clear();
             carouselItem.Filter(criteria);
 
-            Assert.True(carouselItem.Filtered.Value);
+            ClassicAssert.True(carouselItem.Filtered.Value);
         }
 
         [Test]
@@ -424,7 +424,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var carouselItem = new CarouselBeatmap(beatmap);
             carouselItem.Filter(criteria);
 
-            Assert.AreEqual(matchCustomCriteria == false, carouselItem.Filtered.Value);
+            ClassicAssert.AreEqual(matchCustomCriteria == false, carouselItem.Filtered.Value);
         }
 
         [TestCase("title!=Title", new[] { 2, 4, 6 })]
@@ -588,6 +588,26 @@ namespace osu.Game.Tests.NonVisual.Filtering
             Assert.That(visibleBeatmaps, Is.EqualTo(expectedBeatmapIndexes));
         }
 
+        // This is a temporary class that emulates what these tests originally used from song select v1.
+        // If anyone ever ends up tidying up these test, here's a starting point:
+        // https://gist.github.com/peppy/67fda38f6483fd1dd01ef845ed5bf932
+        public class CarouselBeatmap
+        {
+            public readonly BeatmapInfo BeatmapInfo;
+
+            public BindableBool Filtered = new BindableBool();
+
+            public CarouselBeatmap(BeatmapInfo beatmapInfo)
+            {
+                BeatmapInfo = beatmapInfo;
+            }
+
+            public void Filter(FilterCriteria criteria)
+            {
+                Filtered.Value = !BeatmapCarouselFilterMatching.CheckCriteriaMatch(BeatmapInfo, criteria);
+            }
+        }
+
         private class CustomCriteria : IRulesetFilterCriteria
         {
             private readonly bool match;

osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs

@@ -5,12 +5,12 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Select;
-using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
 
 namespace osu.Game.Tests.NonVisual.Filtering
@@ -24,8 +24,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "looking for a beatmap";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("looking for a beatmap", filterCriteria.SearchText);
-            Assert.AreEqual(4, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("looking for a beatmap", filterCriteria.SearchText);
+            ClassicAssert.AreEqual(4, filterCriteria.SearchTerms.Length);
         }
 
         [Test]
@@ -34,8 +34,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "looking for \"a beatmap\"! like \"this\"";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("looking for \"a beatmap\"! like \"this\"", filterCriteria.SearchText);
-            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("looking for \"a beatmap\"! like \"this\"", filterCriteria.SearchText);
+            ClassicAssert.AreEqual(5, filterCriteria.SearchTerms.Length);
 
             Assert.That(filterCriteria.SearchTerms[0].SearchTerm, Is.EqualTo("a beatmap"));
             Assert.That(filterCriteria.SearchTerms[0].MatchMode, Is.EqualTo(FilterCriteria.MatchMode.FullPhrase));
@@ -59,8 +59,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "looking for \"circles!\"!";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("looking for \"circles!\"!", filterCriteria.SearchText);
-            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("looking for \"circles!\"!", filterCriteria.SearchText);
+            ClassicAssert.AreEqual(3, filterCriteria.SearchTerms.Length);
 
             Assert.That(filterCriteria.SearchTerms[0].SearchTerm, Is.EqualTo("circles!"));
             Assert.That(filterCriteria.SearchTerms[0].MatchMode, Is.EqualTo(FilterCriteria.MatchMode.FullPhrase));
@@ -78,8 +78,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "\"!";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("\"!", filterCriteria.SearchText);
-            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("\"!", filterCriteria.SearchText);
+            ClassicAssert.AreEqual(1, filterCriteria.SearchTerms.Length);
 
             Assert.That(filterCriteria.SearchTerms[0].SearchTerm, Is.EqualTo("!"));
             Assert.That(filterCriteria.SearchTerms[0].MatchMode, Is.EqualTo(FilterCriteria.MatchMode.IsolatedPhrase));
@@ -92,11 +92,11 @@ namespace osu.Game.Tests.NonVisual.Filtering
             string query = $"{variant}<4 easy";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("easy", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
-            Assert.IsNotNull(filterCriteria.StarDifficulty.Max);
-            Assert.AreEqual(filterCriteria.StarDifficulty.Max, 4.00d);
-            Assert.IsNull(filterCriteria.StarDifficulty.Min);
+            ClassicAssert.AreEqual("easy", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            ClassicAssert.NotNull(filterCriteria.StarDifficulty.Max);
+            ClassicAssert.AreEqual(filterCriteria.StarDifficulty.Max!, 4.00d);
+            ClassicAssert.Null(filterCriteria.StarDifficulty.Min);
         }
 
         [Test]
@@ -105,9 +105,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "stars>=6";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(filterCriteria.StarDifficulty.Min, 6.00d);
-            Assert.True(filterCriteria.StarDifficulty.IsLowerInclusive);
-            Assert.IsNull(filterCriteria.StarDifficulty.Max);
+            ClassicAssert.AreEqual(filterCriteria.StarDifficulty.Min!, 6.00d);
+            ClassicAssert.True(filterCriteria.StarDifficulty.IsLowerInclusive);
+            ClassicAssert.Null(filterCriteria.StarDifficulty.Max);
         }
 
         /*
@@ -126,12 +126,12 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "ar>=9 difficult";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("difficult", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
-            Assert.IsNotNull(filterCriteria.ApproachRate.Min);
-            Assert.Greater(filterCriteria.ApproachRate.Min, 8.9f);
-            Assert.Less(filterCriteria.ApproachRate.Min, 9.0f);
-            Assert.IsNull(filterCriteria.ApproachRate.Max);
+            ClassicAssert.AreEqual("difficult", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            ClassicAssert.NotNull(filterCriteria.ApproachRate.Min);
+            ClassicAssert.Greater(filterCriteria.ApproachRate.Min!, 8.9f);
+            ClassicAssert.Less(filterCriteria.ApproachRate.Min!, 9.0f);
+            ClassicAssert.Null(filterCriteria.ApproachRate.Max);
         }
 
         [Test]
@@ -140,12 +140,12 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "dr>2 quite specific dr<:6";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("quite specific", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(2, filterCriteria.SearchTerms.Length);
-            Assert.Greater(filterCriteria.DrainRate.Min, 2.0f);
-            Assert.Less(filterCriteria.DrainRate.Min, 2.1f);
-            Assert.Greater(filterCriteria.DrainRate.Max, 6.0f);
-            Assert.Less(filterCriteria.DrainRate.Min, 6.1f);
+            ClassicAssert.AreEqual("quite specific", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(2, filterCriteria.SearchTerms.Length);
+            ClassicAssert.Greater(filterCriteria.DrainRate.Min!, 2.0f);
+            ClassicAssert.Less(filterCriteria.DrainRate.Min!, 2.1f);
+            ClassicAssert.Greater(filterCriteria.DrainRate.Max!, 6.0f);
+            ClassicAssert.Less(filterCriteria.DrainRate.Min!, 6.1f);
         }
 
         [Test]
@@ -154,12 +154,12 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "hp>2 quite specific hp<=6";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("quite specific", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(2, filterCriteria.SearchTerms.Length);
-            Assert.Greater(filterCriteria.DrainRate.Min, 2.0f);
-            Assert.Less(filterCriteria.DrainRate.Min, 2.1f);
-            Assert.Greater(filterCriteria.DrainRate.Max, 6.0f);
-            Assert.Less(filterCriteria.DrainRate.Min, 6.1f);
+            ClassicAssert.AreEqual("quite specific", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(2, filterCriteria.SearchTerms.Length);
+            ClassicAssert.Greater(filterCriteria.DrainRate.Min!, 2.0f);
+            ClassicAssert.Less(filterCriteria.DrainRate.Min!, 2.1f);
+            ClassicAssert.Greater(filterCriteria.DrainRate.Max!, 6.0f);
+            ClassicAssert.Less(filterCriteria.DrainRate.Min!, 6.1f);
         }
 
         [Test]
@@ -168,12 +168,12 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "od>4 easy od<8";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("easy", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
-            Assert.Greater(filterCriteria.OverallDifficulty.Min, 4.0);
-            Assert.Less(filterCriteria.OverallDifficulty.Min, 4.1);
-            Assert.Greater(filterCriteria.OverallDifficulty.Max, 7.9);
-            Assert.Less(filterCriteria.OverallDifficulty.Max, 8.0);
+            ClassicAssert.AreEqual("easy", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            ClassicAssert.Greater(filterCriteria.OverallDifficulty.Min!, 4.0);
+            ClassicAssert.Less(filterCriteria.OverallDifficulty.Min!, 4.1);
+            ClassicAssert.Greater(filterCriteria.OverallDifficulty.Max!, 7.9);
+            ClassicAssert.Less(filterCriteria.OverallDifficulty.Max!, 8.0);
         }
 
         [Test]
@@ -182,8 +182,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "bpm=200";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(filterCriteria.BPM.Min, 199.5d);
-            Assert.AreEqual(filterCriteria.BPM.Max, 200.5d);
+            ClassicAssert.AreEqual(filterCriteria.BPM.Min!, 199.5d);
+            ClassicAssert.AreEqual(filterCriteria.BPM.Max!, 200.5d);
         }
 
         [Test]
@@ -192,11 +192,11 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "bpm>:200 gotta go fast";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("gotta go fast", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
-            Assert.IsNotNull(filterCriteria.BPM.Min);
-            Assert.AreEqual(filterCriteria.BPM.Min, 199.5d);
-            Assert.IsNull(filterCriteria.BPM.Max);
+            ClassicAssert.AreEqual("gotta go fast", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            ClassicAssert.NotNull(filterCriteria.BPM.Min);
+            ClassicAssert.AreEqual(filterCriteria.BPM.Min!, 199.5d);
+            ClassicAssert.Null(filterCriteria.BPM.Max);
         }
 
         private static readonly object[] correct_length_query_examples =
@@ -229,10 +229,10 @@ namespace osu.Game.Tests.NonVisual.Filtering
             string query = $"length={lengthQuery} time";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("time", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual(expectedLength.TotalMilliseconds - scale.TotalMilliseconds / 2.0, filterCriteria.Length.Min);
-            Assert.AreEqual(expectedLength.TotalMilliseconds + scale.TotalMilliseconds / 2.0, filterCriteria.Length.Max);
+            ClassicAssert.AreEqual("time", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual(expectedLength.TotalMilliseconds - scale.TotalMilliseconds / 2.0, filterCriteria.Length.Min);
+            ClassicAssert.AreEqual(expectedLength.TotalMilliseconds + scale.TotalMilliseconds / 2.0, filterCriteria.Length.Max);
         }
 
         private static readonly object[] incorrect_length_query_examples =
@@ -255,7 +255,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             string query = $"length={lengthQuery} time";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(false, filterCriteria.Length.HasFilter);
+            ClassicAssert.AreEqual(false, filterCriteria.Length.HasFilter);
         }
 
         [Test]
@@ -264,12 +264,12 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "that's a time signature alright! divisor:12";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("that's a time signature alright!", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual(12, filterCriteria.BeatDivisor.Min);
-            Assert.IsTrue(filterCriteria.BeatDivisor.IsLowerInclusive);
-            Assert.AreEqual(12, filterCriteria.BeatDivisor.Max);
-            Assert.IsTrue(filterCriteria.BeatDivisor.IsUpperInclusive);
+            ClassicAssert.AreEqual("that's a time signature alright!", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual(12, filterCriteria.BeatDivisor.Min);
+            ClassicAssert.True(filterCriteria.BeatDivisor.IsLowerInclusive);
+            ClassicAssert.AreEqual(12, filterCriteria.BeatDivisor.Max);
+            ClassicAssert.True(filterCriteria.BeatDivisor.IsUpperInclusive);
         }
 
         [Test]
@@ -278,7 +278,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "status=r";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
+            ClassicAssert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
             Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Ranked));
         }
 
@@ -288,9 +288,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "I want the pp status=ranked";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("I want the pp", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(4, filterCriteria.SearchTerms.Length);
-            Assert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
+            ClassicAssert.AreEqual("I want the pp", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(4, filterCriteria.SearchTerms.Length);
+            ClassicAssert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
             Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Ranked));
         }
 
@@ -309,7 +309,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "status!=r";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
+            ClassicAssert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
             Assert.That(filterCriteria.OnlineStatus.Values, Does.Not.Contain(BeatmapOnlineStatus.Ranked));
         }
 
@@ -375,9 +375,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             string query = $"beatmap specifically by {keyword}=my_fav";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("beatmap specifically by", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("my_fav", filterCriteria.Creator.SearchTerm);
+            ClassicAssert.AreEqual("beatmap specifically by", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("my_fav", filterCriteria.Creator.SearchTerm);
         }
 
         [Test]
@@ -386,9 +386,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "find me songs with title=\"a certain title\" please";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("find me songs with  please", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("a certain title", filterCriteria.Title.SearchTerm);
+            ClassicAssert.AreEqual("find me songs with  please", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("a certain title", filterCriteria.Title.SearchTerm);
             Assert.That(filterCriteria.Title.MatchMode, Is.EqualTo(FilterCriteria.MatchMode.IsolatedPhrase));
         }
 
@@ -398,9 +398,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "find me songs by artist=singer please";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("find me songs by  please", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("singer", filterCriteria.Artist.SearchTerm);
+            ClassicAssert.AreEqual("find me songs by  please", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("singer", filterCriteria.Artist.SearchTerm);
             Assert.That(filterCriteria.Artist.MatchMode, Is.EqualTo(FilterCriteria.MatchMode.Substring));
         }
 
@@ -410,9 +410,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "really like artist=\"name with space\" yes";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("really like  yes", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(3, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("name with space", filterCriteria.Artist.SearchTerm);
+            ClassicAssert.AreEqual("really like  yes", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(3, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("name with space", filterCriteria.Artist.SearchTerm);
             Assert.That(filterCriteria.Artist.MatchMode, Is.EqualTo(FilterCriteria.MatchMode.IsolatedPhrase));
         }
 
@@ -423,8 +423,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.That(filterCriteria.SearchText.Trim(), Is.Empty);
-            Assert.AreEqual(0, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("The Only One", filterCriteria.Artist.SearchTerm);
+            ClassicAssert.AreEqual(0, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("The Only One", filterCriteria.Artist.SearchTerm);
             Assert.That(filterCriteria.Artist.MatchMode, Is.EqualTo(FilterCriteria.MatchMode.FullPhrase));
         }
 
@@ -434,9 +434,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "weird artist=double\"quote";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("weird", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(1, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("double\"quote", filterCriteria.Artist.SearchTerm);
+            ClassicAssert.AreEqual("weird", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(1, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("double\"quote", filterCriteria.Artist.SearchTerm);
         }
 
         [Test]
@@ -445,7 +445,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "artist=><something";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("><something", filterCriteria.Artist.SearchTerm);
+            ClassicAssert.AreEqual("><something", filterCriteria.Artist.SearchTerm);
         }
 
         [Test]
@@ -454,7 +454,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "unrecognised=keyword";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("unrecognised=keyword", filterCriteria.SearchText);
+            ClassicAssert.AreEqual("unrecognised=keyword", filterCriteria.SearchText);
         }
 
         [TestCase("cs=nope")]
@@ -465,7 +465,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
         {
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(query, filterCriteria.SearchText);
+            ClassicAssert.AreEqual(query, filterCriteria.SearchText);
         }
 
         [Test]
@@ -475,8 +475,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "custom=readme unrecognised=keyword";
             var filterCriteria = new FilterCriteria { RulesetCriteria = customCriteria };
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("readme", customCriteria.CustomValue);
-            Assert.AreEqual("unrecognised=keyword", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual("readme", customCriteria.CustomValue);
+            ClassicAssert.AreEqual("unrecognised=keyword", filterCriteria.SearchText.Trim());
         }
 
         [TestCase("[1]", new[] { 0 })]
@@ -509,7 +509,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
                 ("Another One", "diff ]with [[ brackets]]]"),
                 ("Diff in title", "a"),
                 ("a", "Diff in diff"),
-            }).Select(info => new CarouselBeatmap(new BeatmapInfo
+            }).Select(info => new FilterMatchingTest.CarouselBeatmap(new BeatmapInfo
             {
                 Metadata = new BeatmapMetadata
                 {
@@ -536,9 +536,9 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "find me songs with source=\"unit tests\" please";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual("find me songs with  please", filterCriteria.SearchText.Trim());
-            Assert.AreEqual(5, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual("unit tests", filterCriteria.Source.SearchTerm);
+            ClassicAssert.AreEqual("find me songs with  please", filterCriteria.SearchText.Trim());
+            ClassicAssert.AreEqual(5, filterCriteria.SearchTerms.Length);
+            ClassicAssert.AreEqual("unit tests", filterCriteria.Source.SearchTerm);
             Assert.That(filterCriteria.Source.MatchMode, Is.EqualTo(FilterCriteria.MatchMode.IsolatedPhrase));
         }
 
@@ -581,7 +581,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             string query = $"lastplayed<{dateQuery} time";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
+            ClassicAssert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
         }
 
         private static readonly object[] incorrect_date_query_examples =
@@ -606,7 +606,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             string query = $"played<{dateQuery} time";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(false, filterCriteria.LastPlayed.HasFilter);
+            ClassicAssert.AreEqual(false, filterCriteria.LastPlayed.HasFilter);
         }
 
         [Test]
@@ -615,11 +615,11 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "lastplayed>50";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.That(filterCriteria.LastPlayed.Max, Is.Not.Null);
-            Assert.That(filterCriteria.LastPlayed.Min, Is.Null);
+            Assert.That(filterCriteria.LastPlayed.Max!, Is.Not.Null);
+            Assert.That(filterCriteria.LastPlayed.Min!, Is.Null);
             // the parser internally references `DateTimeOffset.Now`, so to not make things too annoying for tests, just assume some tolerance
             // (irrelevant in proportion to the actual filter proscribed).
-            Assert.That(filterCriteria.LastPlayed.Max, Is.EqualTo(DateTimeOffset.Now.AddDays(-50)).Within(TimeSpan.FromSeconds(5)));
+            Assert.That(filterCriteria.LastPlayed.Max!, Is.EqualTo(DateTimeOffset.Now.AddDays(-50)).Within(TimeSpan.FromSeconds(5)));
         }
 
         [Test]
@@ -628,11 +628,11 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "lastplayed<50";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.That(filterCriteria.LastPlayed.Max, Is.Null);
-            Assert.That(filterCriteria.LastPlayed.Min, Is.Not.Null);
+            Assert.That(filterCriteria.LastPlayed.Max!, Is.Null);
+            Assert.That(filterCriteria.LastPlayed.Min!, Is.Not.Null);
             // the parser internally references `DateTimeOffset.Now`, so to not make things too annoying for tests, just assume some tolerance
             // (irrelevant in proportion to the actual filter proscribed).
-            Assert.That(filterCriteria.LastPlayed.Min, Is.EqualTo(DateTimeOffset.Now.AddDays(-50)).Within(TimeSpan.FromSeconds(5)));
+            Assert.That(filterCriteria.LastPlayed.Min!, Is.EqualTo(DateTimeOffset.Now.AddDays(-50)).Within(TimeSpan.FromSeconds(5)));
         }
 
         [Test]
@@ -641,12 +641,12 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "lastplayed>3M lastplayed<1y6M";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.That(filterCriteria.LastPlayed.Min, Is.Not.Null);
-            Assert.That(filterCriteria.LastPlayed.Max, Is.Not.Null);
+            Assert.That(filterCriteria.LastPlayed.Min!, Is.Not.Null);
+            Assert.That(filterCriteria.LastPlayed.Max!, Is.Not.Null);
             // the parser internally references `DateTimeOffset.Now`, so to not make things too annoying for tests, just assume some tolerance
             // (irrelevant in proportion to the actual filter proscribed).
-            Assert.That(filterCriteria.LastPlayed.Min, Is.EqualTo(DateTimeOffset.Now.AddMonths(-6).AddYears(-1)).Within(TimeSpan.FromSeconds(5)));
-            Assert.That(filterCriteria.LastPlayed.Max, Is.EqualTo(DateTimeOffset.Now.AddMonths(-3)).Within(TimeSpan.FromSeconds(5)));
+            Assert.That(filterCriteria.LastPlayed.Min!, Is.EqualTo(DateTimeOffset.Now.AddMonths(-6).AddYears(-1)).Within(TimeSpan.FromSeconds(5)));
+            Assert.That(filterCriteria.LastPlayed.Max!, Is.EqualTo(DateTimeOffset.Now.AddMonths(-3)).Within(TimeSpan.FromSeconds(5)));
         }
 
         [Test]
@@ -655,7 +655,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "lastplayed=50";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(false, filterCriteria.LastPlayed.HasFilter);
+            ClassicAssert.AreEqual(false, filterCriteria.LastPlayed.HasFilter);
         }
 
         [Test]
@@ -664,8 +664,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "lastplayed<10000y";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
-            Assert.AreEqual(DateTimeOffset.MinValue.AddMilliseconds(1), filterCriteria.LastPlayed.Min);
+            ClassicAssert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
+            ClassicAssert.AreEqual(DateTimeOffset.MinValue.AddMilliseconds(1), filterCriteria.LastPlayed.Min);
         }
 
         private static DateTimeOffset dateTimeOffsetFromDateOnly(int year, int month, int day) =>
@@ -707,8 +707,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
         {
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(true, filterCriteria.DateRanked.HasFilter);
-            Assert.AreEqual(expected, f(filterCriteria));
+            ClassicAssert.AreEqual(true, filterCriteria.DateRanked.HasFilter);
+            ClassicAssert.AreEqual(expected, f(filterCriteria));
         }
 
         private static readonly object[] ranked_date_invalid_test_cases =
@@ -724,7 +724,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
         {
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(false, filterCriteria.DateRanked.HasFilter);
+            ClassicAssert.AreEqual(false, filterCriteria.DateRanked.HasFilter);
         }
 
         private static readonly object[] submitted_date_test_cases =
@@ -756,7 +756,7 @@ namespace osu.Game.Tests.NonVisual.Filtering
         {
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(expected, filterCriteria.DateSubmitted.HasFilter);
+            ClassicAssert.AreEqual(expected, filterCriteria.DateSubmitted.HasFilter);
         }
 
         private static readonly object[] played_query_tests =
@@ -782,8 +782,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
         {
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, $"played={query}");
-            Assert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
-            Assert.AreEqual(matched, filterCriteria.LastPlayed.IsInRange(reference));
+            ClassicAssert.AreEqual(true, filterCriteria.LastPlayed.HasFilter);
+            ClassicAssert.AreEqual(matched, filterCriteria.LastPlayed.IsInRange(reference));
         }
 
         [Test]

osu.Game.Tests/NonVisual/FirstAvailableHitWindowsTest.cs

@@ -7,6 +7,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Audio;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Judgements;
@@ -37,7 +38,7 @@ namespace osu.Game.Tests.NonVisual
             testObject.AddNested(nested);
             testDrawableRuleset.HitObjects = new List<HitObject> { testObject };
 
-            Assert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, nested.HitWindows);
+            ClassicAssert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, nested.HitWindows);
         }
 
         [Test]
@@ -48,7 +49,7 @@ namespace osu.Game.Tests.NonVisual
             testObject.AddNested(nested);
             testDrawableRuleset.HitObjects = new List<HitObject> { testObject };
 
-            Assert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, testObject.HitWindows);
+            ClassicAssert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, testObject.HitWindows);
         }
 
         [Test]
@@ -61,7 +62,7 @@ namespace osu.Game.Tests.NonVisual
             var secondObject = new TestHitObject(new DefaultHitWindows());
             testDrawableRuleset.HitObjects = new List<HitObject> { firstObject, secondObject };
 
-            Assert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, secondObject.HitWindows);
+            ClassicAssert.AreSame(testDrawableRuleset.FirstAvailableHitWindows, secondObject.HitWindows);
         }
 
         [Test]
@@ -73,7 +74,7 @@ namespace osu.Game.Tests.NonVisual
 
             testDrawableRuleset.HitObjects = new List<HitObject> { firstObject };
 
-            Assert.IsNull(testDrawableRuleset.FirstAvailableHitWindows);
+            ClassicAssert.Null(testDrawableRuleset.FirstAvailableHitWindows);
         }
 
         [SuppressMessage("ReSharper", "UnassignedGetOnlyAutoProperty")]

osu.Game.Tests/NonVisual/FormatUtilsTest.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Utils;
 
 namespace osu.Game.Tests.NonVisual
@@ -19,7 +20,7 @@ namespace osu.Game.Tests.NonVisual
         [TestCase(1, "100.00%")]
         public void TestAccuracyFormatting(double input, string expectedOutput)
         {
-            Assert.AreEqual(expectedOutput, input.FormatAccuracy().ToString());
+            ClassicAssert.AreEqual(expectedOutput, input.FormatAccuracy().ToString());
         }
 
         [TestCase(3, "3.00")]
@@ -32,7 +33,7 @@ namespace osu.Game.Tests.NonVisual
         [TestCase(4, "4.00")]
         public void TestStarRatingFormatting(double input, string expectedOutput)
         {
-            Assert.AreEqual(expectedOutput, input.FormatStarRating().ToString());
+            ClassicAssert.AreEqual(expectedOutput, input.FormatStarRating().ToString());
         }
     }
 }

osu.Game.Tests/NonVisual/FramedReplayInputHandlerTest.cs

@@ -7,6 +7,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Replays;
 
@@ -223,7 +224,7 @@ namespace osu.Game.Tests.NonVisual
             // no frames are arrived yet
             setTime(0, null);
             setTime(1000, null);
-            Assert.IsTrue(handler.WaitingForFrame, "Should be waiting for the first frame");
+            ClassicAssert.True(handler.WaitingForFrame, "Should be waiting for the first frame");
 
             replay.Frames.Add(new TestReplayFrame(0));
             replay.Frames.Add(new TestReplayFrame(1000));
@@ -231,11 +232,11 @@ namespace osu.Game.Tests.NonVisual
             // should always play from beginning
             setTime(1000, 0);
             confirmCurrentFrame(0);
-            Assert.IsFalse(handler.WaitingForFrame, "Should not be waiting yet");
+            ClassicAssert.False(handler.WaitingForFrame, "Should not be waiting yet");
             setTime(1000, 1000);
             confirmCurrentFrame(1);
             confirmNextFrame(null);
-            Assert.IsTrue(handler.WaitingForFrame, "Should be waiting");
+            ClassicAssert.True(handler.WaitingForFrame, "Should be waiting");
 
             // cannot seek beyond the last frame
             setTime(1500, null);
@@ -359,17 +360,17 @@ namespace osu.Game.Tests.NonVisual
 
         private void setTime(double set, double? expect)
         {
-            Assert.AreEqual(expect, handler.SetFrameFromTime(set), "Unexpected return value");
+            ClassicAssert.AreEqual(expect, handler.SetFrameFromTime(set), "Unexpected return value");
         }
 
         private void confirmCurrentFrame(int? frame)
         {
-            Assert.AreEqual(frame is int x ? replay.Frames[x].Time : null, handler.CurrentFrame?.Time, "Unexpected current frame");
+            ClassicAssert.AreEqual(frame is int x ? replay.Frames[x].Time : null, handler.CurrentFrame?.Time, "Unexpected current frame");
         }
 
         private void confirmNextFrame(int? frame)
         {
-            Assert.AreEqual(frame is int x ? replay.Frames[x].Time : null, handler.NextFrame?.Time, "Unexpected next frame");
+            ClassicAssert.AreEqual(frame is int x ? replay.Frames[x].Time : null, handler.NextFrame?.Time, "Unexpected next frame");
         }
 
         private class TestReplayFrame : ReplayFrame