Add models for improvements to matchmaking lobby (#37226 )

1. Gives `MatchmakingJoinLobby` parameters. 2. Adds additional data to lobby status update models. A further PR will build upon (2) to add more data to the queue screen.
Localise tabs on DashboardOverlay (#37236 )
2026-05-18 04:59:52 +08:00 · 2026-04-08 18:43:51 +09:00 · 2026-04-08 14:46:14 +09:00 · 2026-04-08 00:40:50 +09:00 · 2026-04-08 00:03:05 +09:00 · 2026-04-08 00:02:32 +09:00
338 changed files with 7366 additions and 4021 deletions
@@ -3,28 +3,25 @@
  "isRoot": true,
  "tools": {
    "jetbrains.resharper.globaltools": {
-      "version": "2023.3.3",
+      "version": "2025.2.3",
      "commands": [
        "jb"
-      ]
-    },
-    "nvika": {
-      "version": "4.0.0",
-      "commands": [
-        "nvika"
-      ]
+      ],
+      "rollForward": false
    },
    "codefilesanity": {
      "version": "0.0.37",
      "commands": [
        "CodeFileSanity"
-      ]
+      ],
+      "rollForward": false
    },
    "ppy.localisationanalyser.tools": {
      "version": "2025.1208.0",
      "commands": [
        "localisation"
-      ]
+      ],
+      "rollForward": false
    }
  }
-}
+}
@@ -44,7 +44,7 @@ jobs:

    steps:
      - name: Checkout diffcalc-sheet-generator
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
        with:
          path: ${{ inputs.id }}
          repository: 'smoogipoo/diffcalc-sheet-generator'
@@ -6,6 +6,7 @@ concurrency:

 permissions:
  contents: read # to fetch code (actions/checkout)
+  security-events: write # for reporting InspectCode issues

 jobs:
  inspect-code:
@@ -13,10 +14,10 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Install .NET 8.0.x
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: "8.0.x"

@@ -27,7 +28,7 @@ jobs:
        run: dotnet restore osu.Desktop.slnf

      - name: Restore inspectcode cache
-        uses: actions/cache@v4
+        uses: actions/cache@v5
        with:
          path: ${{ github.workspace }}/inspectcode
          key: inspectcode-${{ hashFiles('.config/dotnet-tools.json', '.github/workflows/ci.yml', 'osu.sln*', 'osu*.slnf', '.editorconfig', '.globalconfig', 'CodeAnalysis/*', '**/*.csproj', '**/*.props') }}
@@ -49,10 +50,14 @@ jobs:
          exit $exit_code

      - name: InspectCode
-        run: dotnet jb inspectcode $(pwd)/osu.Desktop.slnf --no-build --output="inspectcodereport.xml" --caches-home="inspectcode" --verbosity=WARN
-
-      - name: NVika
-        run: dotnet nvika parsereport "${{github.workspace}}/inspectcodereport.xml" --treatwarningsaserrors
+        uses: JetBrains/ReSharper-InspectCode@v0.12
+        with:
+          # this is WTF tier but if you don't specify *both* of these the defaults assume `build: true`
+          build: false
+          no-build: true
+          solution: ./osu.Desktop.slnf
+          caches-home: inspectcode
+          verbosity: WARN

  test:
    name: Test
@@ -71,10 +76,10 @@ jobs:
    timeout-minutes: 120
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Install .NET 8.0.x
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: "8.0.x"

@@ -96,30 +101,58 @@ jobs:
          NUnit.ConsoleOut=0

      # Attempt to upload results even if test fails.
-      # https://docs.github.com/en/actions/reference/context-and-expression-syntax-for-github-actions#always
+      # https://docs.github.com/en/actions/reference/workflows-and-actions/expressions#cancelled
      - name: Upload Test Results
-        uses: actions/upload-artifact@v4
-        if: ${{ always() }}
+        uses: actions/upload-artifact@v7
+        if: ${{ !cancelled() }}
        with:
          name: osu-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
          path: ${{github.workspace}}/TestResults/TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx

+  test-results:
+    name: Test results
+    runs-on: ubuntu-latest
+    # we want to wait for the `test` job to complete, but run regardless of whether it succeeds or fails
+    # https://docs.github.com/en/actions/reference/workflows-and-actions/workflow-syntax#example-not-requiring-successful-dependent-jobs
+    if: ${{ !cancelled() }}
+    needs: test
+    timeout-minutes: 5
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v6
+
+      - name: Download results
+        uses: actions/download-artifact@v8
+        with:
+          pattern: osu-test-results-*
+          merge-multiple: true
+
+      - name: Add test results summary to workflow run
+        uses: dorny/test-reporter@v3.0.0
+        with:
+          name: Results
+          path: "*.trx"
+          reporter: dotnet-trx
+          list-suites: 'failed'
+          list-tests: 'failed'
+          use-actions-summary: 'true'
+
  build-only-android:
    name: Build only (Android)
    runs-on: windows-latest
    timeout-minutes: 60
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Setup JDK 11
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
        with:
          distribution: microsoft
          java-version: 11

      - name: Install .NET 8.0.x
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: "8.0.x"

@@ -135,10 +168,10 @@ jobs:
    timeout-minutes: 60
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Install .NET 8.0.x
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: "8.0.x"

@@ -3,7 +3,8 @@ name: Pack and nuget
 on:
  push:
    tags:
-      - '*'
+      - '*.*.*'
+      - '!*-*'

 jobs:
  notify_pending_production_deploy:
@@ -43,14 +44,14 @@ jobs:
    environment: production
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6

      - name: Set artifacts directory
        id: artifactsPath
        run: echo "::set-output name=nuget_artifacts::${{github.workspace}}/artifacts"

      - name: Install .NET 8.0.x
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
        with:
          dotnet-version: "8.0.x"

@@ -76,7 +77,7 @@ jobs:
          dotnet pack -c Release Templates /p:Version=${{ github.ref_name }} -o ${{steps.artifactsPath.outputs.nuget_artifacts}}

      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
        with:
          name: osu
          path: |
@@ -1,45 +0,0 @@
-# This is a workaround to allow PRs to report their coverage. This will run inside the base repository.
-# See:
-#   * https://github.com/dorny/test-reporter#recommended-setup-for-public-repositories
-#   * https://docs.github.com/en/actions/reference/authentication-in-a-workflow#permissions-for-the-github_token
-name: Annotate CI run with test results
-on:
-  workflow_run:
-    workflows: [ "Continuous Integration" ]
-    types:
-      - completed
-
-permissions:
-  contents: read
-  actions: read
-  checks: write
-
-jobs:
-  annotate:
-    name: Annotate CI run with test results
-    runs-on: ubuntu-latest
-    if: ${{ github.event.workflow_run.conclusion != 'cancelled' }}
-    timeout-minutes: 5
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.event.workflow_run.repository.full_name }}
-          ref: ${{ github.event.workflow_run.head_sha }}
-
-      - name: Download results
-        uses: actions/download-artifact@v4
-        with:
-          pattern: osu-test-results-*
-          merge-multiple: true
-          run-id: ${{ github.event.workflow_run.id }}
-          github-token: ${{ github.token }}
-
-      - name: Annotate CI run with test results
-        uses: dorny/test-reporter@v1.8.0
-        with:
-          name: Results
-          path: "*.trx"
-          reporter: dotnet-trx
-          list-suites: 'failed'
-          list-tests: 'failed'
@@ -13,12 +13,12 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
        with:
          fetch-depth: 0

      - name: Create Sentry release
-        uses: getsentry/action-release@v1
+        uses: getsentry/action-release@v3
        env:
          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
          SENTRY_ORG: ppy
@@ -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
@@ -13,6 +13,19 @@
            "preLaunchTask": "Build osu! (Debug)",
            "console": "internalConsole"
        },
+        {
+            "name": "osu! (Debug, Second Client)",
+            "type": "coreclr",
+            "request": "launch",
+            "program": "dotnet",
+            "args": [
+                "${workspaceRoot}/osu.Desktop/bin/Debug/net8.0/osu!.dll",
+                "--debug-client-id=1"
+            ],
+            "cwd": "${workspaceRoot}",
+            "preLaunchTask": "Build osu! (Debug)",
+            "console": "internalConsole"
+        },
        {
            "name": "osu! (Release)",
            "type": "coreclr",
@@ -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" />
@@ -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" />
@@ -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" />
@@ -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" />
@@ -10,7 +10,7 @@
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
  </PropertyGroup>
  <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.310.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.318.0" />
  </ItemGroup>
  <PropertyGroup>
    <!-- Fody does not handle Android build well, and warns when unchanged.
@@ -58,6 +58,7 @@ namespace osu.Desktop
        private readonly RichPresence presence = new RichPresence
        {
            Assets = new Assets { LargeImageKey = "osu_logo_lazer" },
+            Timestamps = Timestamps.Now,
            Secrets = new Secrets
            {
                JoinSecret = null,
@@ -0,0 +1,55 @@
+// 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.IO;
+using osu.Framework;
+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;
+
+namespace osu.Desktop.MacOS
+{
+    /// <summary>
+    /// Checks if the game is located at `Applications` folder and displays a warning notification if not so.
+    /// </summary>
+    public partial class MacOSAppLocationChecker : Component
+    {
+        [Resolved]
+        private INotificationOverlay notification { get; set; } = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            string assemblyPath = RuntimeInfo.EntryAssembly.Location;
+
+            bool inRootApp = assemblyPath.StartsWith("/Applications/", StringComparison.Ordinal);
+            bool inUserApp = assemblyPath.StartsWith(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Applications/"), StringComparison.Ordinal);
+
+            if (!inRootApp && !inUserApp)
+                notification.Post(new MacOSAppLocationNotification());
+
+            Expire();
+        }
+
+        private partial class MacOSAppLocationNotification : SimpleNotification
+        {
+            public MacOSAppLocationNotification()
+            {
+                Text = NotificationsStrings.MacOSAppLocation(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile));
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                Icon = FontAwesome.Solid.ShieldAlt;
+                IconContent.Colour = colours.YellowDark;
+            }
+        }
+    }
+}
@@ -5,7 +5,6 @@ using System;
 using System.IO;
 using System.Reflection;
 using System.Runtime.Versioning;
-using System.Threading.Tasks;
 using Microsoft.Win32;
 using osu.Desktop.Performance;
 using osu.Desktop.Security;
@@ -15,12 +14,12 @@ using osu.Desktop.Updater;
 using osu.Framework;
 using osu.Framework.Logging;
 using osu.Game.Updater;
+using osu.Desktop.MacOS;
 using osu.Desktop.Windows;
 using osu.Framework.Allocation;
 using osu.Game.Configuration;
 using osu.Game.IO;
 using osu.Game.IPC;
-using osu.Game.Online.Multiplayer;
 using osu.Game.Performance;
 using osu.Game.Utils;

@@ -123,7 +122,7 @@ namespace osu.Desktop

        public override bool RestartAppWhenExited()
        {
-            Task.Run(() => Velopack.UpdateExe.Start(waitPid: (uint)Environment.ProcessId)).FireAndForget();
+            RestartOnExitAction = () => Velopack.UpdateExe.Start(waitPid: (uint)Environment.ProcessId);
            return true;
        }

@@ -133,8 +132,17 @@ namespace osu.Desktop

            LoadComponentAsync(new DiscordRichPresence(), Add);

-            if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
-                LoadComponentAsync(new GameplayWinKeyBlocker(), Add);
+            switch (RuntimeInfo.OS)
+            {
+                case RuntimeInfo.Platform.Windows:
+                    LoadComponentAsync(new GameplayWinKeyBlocker(), Add);
+                    break;
+
+                case RuntimeInfo.Platform.macOS when !IsPackageManaged && IsDeployedBuild:
+                    if (!IsPackageManaged && IsDeployedBuild)
+                        LoadComponentAsync(new MacOSAppLocationChecker(), Add);
+                    break;
+            }

            LoadComponentAsync(new ElevatedPrivilegesChecker(), Add);

@@ -27,6 +27,8 @@ namespace osu.Desktop.Security

            if (Environment.IsPrivilegedProcess)
                notifications.Post(new ElevatedPrivilegesNotification());
+
+            Expire();
        }

        private partial class ElevatedPrivilegesNotification : SimpleNotification
@@ -146,11 +146,11 @@ namespace osu.Desktop.Updater
            action();
        }

-        private void restartToApplyUpdate(Velopack.UpdateManager updateManager, UpdateInfo update) => Task.Run(async () =>
+        private void restartToApplyUpdate(Velopack.UpdateManager updateManager, UpdateInfo update)
        {
-            await updateManager.WaitExitThenApplyUpdatesAsync(update.TargetFullRelease).ConfigureAwait(false);
-            Schedule(() => game.AttemptExit());
-        });
+            game.RestartOnExitAction = () => updateManager.WaitExitThenApplyUpdates(update.TargetFullRelease);
+            game.AttemptExit();
+        }

        private static void log(string text) => Logger.Log($"VelopackUpdateManager: {text}");
    }
@@ -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">
@@ -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>
@@ -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
@@ -193,20 +193,20 @@ namespace osu.Game.Rulesets.Catch.Tests
        {
            public Color4 HyperDashColour
            {
-                get => Configuration.CustomColours[CatchSkinColour.HyperDash.ToString()];
-                set => Configuration.CustomColours[CatchSkinColour.HyperDash.ToString()] = value;
+                get => Configuration.CustomColours[nameof(CatchSkinColour.HyperDash)];
+                set => Configuration.CustomColours[nameof(CatchSkinColour.HyperDash)] = value;
            }

            public Color4 HyperDashAfterImageColour
            {
-                get => Configuration.CustomColours[CatchSkinColour.HyperDashAfterImage.ToString()];
-                set => Configuration.CustomColours[CatchSkinColour.HyperDashAfterImage.ToString()] = value;
+                get => Configuration.CustomColours[nameof(CatchSkinColour.HyperDashAfterImage)];
+                set => Configuration.CustomColours[nameof(CatchSkinColour.HyperDashAfterImage)] = value;
            }

            public Color4 HyperDashFruitColour
            {
-                get => Configuration.CustomColours[CatchSkinColour.HyperDashFruit.ToString()];
-                set => Configuration.CustomColours[CatchSkinColour.HyperDashFruit.ToString()] = value;
+                get => Configuration.CustomColours[nameof(CatchSkinColour.HyperDashFruit)];
+                set => Configuration.CustomColours[nameof(CatchSkinColour.HyperDashFruit)] = value;
            }

            public TestSkin()
@@ -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>
@@ -155,6 +155,7 @@ namespace osu.Game.Rulesets.Catch
                        new CatchModMuted(),
                        new CatchModNoScope(),
                        new CatchModMovingFast(),
+                        new CatchModSynesthesia(),
                    };

                case ModType.System:
@@ -0,0 +1,60 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Screens.Edit;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Mods
+{
+    /// <summary>
+    /// Mod that colours <see cref="HitObject"/>s based on the musical division they are on
+    /// </summary>
+    public class CatchModSynesthesia : ModSynesthesia, IApplicableToBeatmap, IApplicableToDrawableHitObject
+    {
+        private readonly OsuColour colours = new OsuColour();
+
+        private IBeatmap? currentBeatmap { get; set; }
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            //Store a reference to the current beatmap to look up the beat divisor when notes are drawn
+            if (currentBeatmap != beatmap)
+                currentBeatmap = beatmap;
+        }
+
+        public void ApplyToDrawableHitObject(DrawableHitObject d)
+        {
+            if (currentBeatmap == null) return;
+
+            Color4? timingBasedColour = null;
+
+            d.HitObjectApplied += _ =>
+            {
+                // Block bananas from getting coloured.
+                if (d.HitObject is not Banana)
+                {
+                    timingBasedColour = BindableBeatDivisor.GetColourFor(currentBeatmap.ControlPointInfo.GetClosestBeatDivisor(d.HitObject.StartTime), colours);
+                }
+
+                // Colour droplets into a solid colour, as droplets aren't generated snapped to timeline ticks.
+                if (d.HitObject is Droplet)
+                {
+                    timingBasedColour = Color4.LightGreen;
+                }
+            };
+
+            // Need to set this every update to ensure it doesn't get overwritten by DrawableHitObject.OnApply() -> UpdateComboColour().
+            d.OnUpdate += _ =>
+            {
+                if (timingBasedColour != null)
+                    d.AccentColour.Value = timingBasedColour.Value;
+            };
+        }
+    }
+}
@@ -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]
@@ -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"));
        }
    }
 }
@@ -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)
@@ -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]
@@ -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));
@@ -10,6 +10,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Objects;
@@ -505,6 +506,29 @@ namespace osu.Game.Rulesets.Mania.Tests
                                                             .All(j => j.Type.IsHit()));
        }

+        /// <summary>
+        /// This ensures that the value of <see cref="DrawableHoldNote.MissingStartTime"/>
+        /// will be set correctly when the body receives a judgment during the hold.
+        ///
+        ///     -----[           ]-----
+        ///          x     o
+        /// </summary>
+        [Test]
+        public void TestReleaseDuringHoldMissingStartTime()
+        {
+            performTest([
+                new ManiaReplayFrame(time_head, ManiaAction.Key1),
+                new ManiaReplayFrame(time_during_hold_1)
+            ]);
+
+            assertHeadJudgement(HitResult.Perfect);
+            assertTailJudgement(HitResult.Miss);
+            assertNoteJudgement(HitResult.IgnoreMiss);
+
+            AddAssert("body judgement is miss", () => !judgementResults.Single(j => j.HitObject is HoldNoteBody).IsHit);
+            AddAssert("body judgement time indicates during hold", () => judgementResults.Single(j => j.HitObject is HoldNoteBody).TimeAbsolute, () => Is.EqualTo(time_during_hold_1).Within(100));
+        }
+
        private void assertHitObjectJudgement(HitObject hitObject, HitResult result)
            => AddAssert($"object judged as {result}", () => judgementResults.First(j => j.HitObject == hitObject).Type, () => Is.EqualTo(result));

@@ -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>
@@ -31,10 +31,21 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
    {
        public override bool DisplayResult => false;

+        /// <summary>
+        /// Whether the user is currently pressing the hold note.
+        /// </summary>
        public IBindable<bool> IsHolding => isHolding;

        private readonly Bindable<bool> isHolding = new Bindable<bool>();

+        /// <summary>
+        /// The time at which the user starting missing the hold note.
+        /// This could be the time at which they missed the head, broke on the body, or missed the tail.
+        /// </summary>
+        public IBindable<double?> MissingStartTime => missingStartTime;
+
+        private readonly Bindable<double?> missingStartTime = new Bindable<double?>();
+
        public DrawableHoldNoteHead Head => headContainer.Child;
        public DrawableHoldNoteTail Tail => tailContainer.Child;
        public DrawableHoldNoteBody Body => bodyContainer.Child;
@@ -197,11 +208,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
        public override void OnKilled()
        {
            base.OnKilled();
+
            // flush the final state of holding on kill.
            // this matters because some skin implementations like legacy skin
            // insert drawables in the hierarchy that are not a child of this DHO
            // (see `LegacyBodyPiece` and related machinations with `lightContainer` being added at column level)
            isHolding.Value = Result.IsHolding(Time.Current);
+            missingStartTime.Value = null;
            (bodyPiece.Drawable as IHoldNoteBody)?.Recycle();
        }

@@ -209,6 +222,13 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
        {
            base.Update();

+            if (Head.Judged && !Head.IsHit)
+                missingStartTime.Value ??= Head.Result.TimeAbsolute;
+            if (Body.HasHoldBreak)
+                missingStartTime.Value ??= Body.Result.TimeAbsolute;
+            if (Tail.Judged && !Tail.IsHit)
+                missingStartTime.Value ??= Tail.Result.TimeAbsolute;
+
            isHolding.Value = Result.IsHolding(Time.Current);

            // Pad the full size container so its contents (i.e. the masking container) reach under the tail.
@@ -3,6 +3,7 @@

 #nullable disable

+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -14,6 +15,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
    /// </summary>
    public partial class DrawableHoldNoteHead : DrawableNote
    {
+        /// <summary>
+        /// The time at which the user starting missing the hold note.
+        /// This could be the time at which they missed the head, broke on the body, or missed the tail.
+        /// </summary>
+        public readonly IBindable<double?> MissingStartTime = new Bindable<double?>();
+
        protected override ManiaSkinComponents Component => ManiaSkinComponents.HoldNoteHead;

        public DrawableHoldNoteHead()
@@ -28,6 +35,22 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            Origin = Anchor.TopCentre;
        }

+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            if (ParentHitObject is DrawableHoldNote parentHold)
+                MissingStartTime.BindTo(parentHold.MissingStartTime);
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            if (ParentHitObject is DrawableHoldNote parentHold)
+                MissingStartTime.UnbindFrom(parentHold.MissingStartTime);
+        }
+
        public bool UpdateResult() => base.UpdateResult(true);

        protected override void UpdateHitStateTransforms(ArmedState state)
@@ -3,6 +3,7 @@

 #nullable disable

+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Scoring;
@@ -14,6 +15,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
    /// </summary>
    public partial class DrawableHoldNoteTail : DrawableNote
    {
+        /// <summary>
+        /// The time at which the user starting missing the hold note.
+        /// This could be the time at which they missed the head, broke on the body, or missed the tail.
+        /// </summary>
+        public readonly IBindable<double?> MissingStartTime = new Bindable<double?>();
+
        protected override ManiaSkinComponents Component => ManiaSkinComponents.HoldNoteTail;

        protected internal DrawableHoldNote HoldNote => (DrawableHoldNote)ParentHitObject;
@@ -30,6 +37,22 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            Origin = Anchor.TopCentre;
        }

+        protected override void OnApply()
+        {
+            base.OnApply();
+
+            if (ParentHitObject is DrawableHoldNote parentHold)
+                MissingStartTime.BindTo(parentHold.MissingStartTime);
+        }
+
+        protected override void OnFree()
+        {
+            base.OnFree();
+
+            if (ParentHitObject is DrawableHoldNote parentHold)
+                MissingStartTime.UnbindFrom(parentHold.MissingStartTime);
+        }
+
        public void UpdateResult() => base.UpdateResult(true);

        protected override void CheckForResult(bool userTriggered, double timeOffset) =>
@@ -118,7 +118,8 @@ namespace osu.Game.Rulesets.Mania.Objects
            AddNested(Body = new HoldNoteBody
            {
                StartTime = StartTime,
-                Column = Column
+                Column = Column,
+                Duration = Duration
            });
        }

@@ -3,6 +3,7 @@

 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Mania.Objects
@@ -13,9 +14,11 @@ namespace osu.Game.Rulesets.Mania.Objects
    /// On hit - the hold note was held correctly for the full duration.<br />
    /// On miss - the hold note was released at some point during its judgement period.
    /// </summary>
-    public class HoldNoteBody : ManiaHitObject
+    public class HoldNoteBody : ManiaHitObject, IHasDuration
    {
        public override Judgement CreateJudgement() => new HoldNoteBodyJudgement();
        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+        public double Duration { get; set; }
+        public double EndTime => StartTime + Duration;
    }
 }
@@ -25,17 +25,10 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy

        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
        private readonly IBindable<bool> isHitting = new Bindable<bool>();
-
-        /// <summary>
-        /// Stores the start time of the fade animation that plays when any of the nested
-        /// hitobjects of the hold note are missed.
-        /// </summary>
-        private readonly Bindable<double?> missFadeTime = new Bindable<double?>();
+        private readonly IBindable<double?> missingStartTime = new Bindable<double?>();

        private Drawable? bodySprite;
-
        private Drawable? lightContainer;
-
        private Drawable? light;
        private LegacyNoteBodyStyle? bodyStyle;

@@ -87,6 +80,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy

            direction.BindTo(scrollingInfo.Direction);
            isHitting.BindTo(holdNote.IsHolding);
+            missingStartTime.BindTo(holdNote.MissingStartTime);

            bodySprite = skin.GetAnimation(imageName, wrapMode, wrapMode, true, true, frameLength: 30)?.With(d =>
            {
@@ -109,26 +103,9 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy

            direction.BindValueChanged(onDirectionChanged, true);
            isHitting.BindValueChanged(onIsHittingChanged, true);
-            missFadeTime.BindValueChanged(onMissFadeTimeChanged, true);
+            missingStartTime.BindValueChanged(onMissingStartTimeChanged, true);

-            holdNote.ApplyCustomUpdateState += applyCustomUpdateState;
-            applyCustomUpdateState(holdNote, holdNote.State.Value);
-        }
-
-        private void applyCustomUpdateState(DrawableHitObject hitObject, ArmedState state)
-        {
-            switch (hitObject)
-            {
-                // Ensure that the hold note is also faded out when the head/tail/body is missed.
-                // Importantly, we filter out unrelated objects like DrawableNotePerfectBonus.
-                case DrawableHoldNoteTail:
-                case DrawableHoldNoteHead:
-                case DrawableHoldNoteBody:
-                    if (state == ArmedState.Miss)
-                        missFadeTime.Value ??= hitObject.HitStateUpdateTime;
-
-                    break;
-            }
+            holdNote.ApplyCustomUpdateState += onApplyCustomUpdateState;
        }

        private void onIsHittingChanged(ValueChangedEvent<bool> isHitting)
@@ -187,23 +164,19 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
            }
        }

-        private void onMissFadeTimeChanged(ValueChangedEvent<double?> missFadeTimeChange)
+        private void onMissingStartTimeChanged(ValueChangedEvent<double?> startTime)
+            => applyMissingDim();
+
+        private void onApplyCustomUpdateState(DrawableHitObject obj, ArmedState state)
+            => applyMissingDim();
+
+        private void applyMissingDim()
        {
-            if (missFadeTimeChange.NewValue == null)
+            if (missingStartTime.Value == null)
                return;

-            // this update could come from any nested object of the hold note (or even from an input).
-            // make sure the transforms are consistent across all affected parts.
-            using (BeginAbsoluteSequence(missFadeTimeChange.NewValue.Value))
-            {
-                // colour and duration matches stable
-                // transforms not applied to entire hold note in order to not affect hit lighting
-                const double fade_duration = 60;
-
-                holdNote.Head.FadeColour(Colour4.DarkGray, fade_duration);
-                holdNote.Tail.FadeColour(Colour4.DarkGray, fade_duration);
-                bodySprite?.FadeColour(Colour4.DarkGray, fade_duration);
-            }
+            using (BeginAbsoluteSequence(missingStartTime.Value.Value))
+                this.FadeColour(Colour4.DarkGray, 60);
        }

        protected override void Update()
@@ -213,9 +186,6 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
            if (!isHitting.Value)
                (bodySprite as TextureAnimation)?.GotoFrame(0);

-            if (holdNote.Body.HasHoldBreak)
-                missFadeTime.Value = holdNote.Body.Result.TimeAbsolute;
-
            int scaleDirection = (direction.Value == ScrollingDirection.Down ? 1 : -1);

            // here we go...
@@ -251,7 +221,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
            base.Dispose(isDisposing);

            if (holdNote.IsNotNull())
-                holdNote.ApplyCustomUpdateState -= applyCustomUpdateState;
+                holdNote.ApplyCustomUpdateState -= onApplyCustomUpdateState;

            lightContainer?.Expire();
        }
@@ -1,18 +1,61 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;

 namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
    public partial class LegacyHoldNoteHeadPiece : LegacyNotePiece
    {
+        private readonly IBindable<double?> missingStartTime = new Bindable<double?>();
+
+        [Resolved]
+        private DrawableHitObject drawableObject { get; set; } = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            missingStartTime.BindTo(((DrawableHoldNoteHead)drawableObject).MissingStartTime);
+            missingStartTime.BindValueChanged(onMissingStartTimeChanged, true);
+
+            drawableObject.ApplyCustomUpdateState += onApplyCustomUpdateState;
+        }
+
+        private void onMissingStartTimeChanged(ValueChangedEvent<double?> startTime)
+            => applyMissingDim();
+
+        private void onApplyCustomUpdateState(DrawableHitObject obj, ArmedState state)
+            => applyMissingDim();
+
+        private void applyMissingDim()
+        {
+            if (missingStartTime.Value == null)
+                return;
+
+            using (BeginAbsoluteSequence(missingStartTime.Value.Value))
+                this.FadeColour(Colour4.DarkGray, 60);
+        }
+
        protected override Drawable? GetAnimation(ISkinSource skin)
        {
            // TODO: Should fallback to the head from default legacy skin instead of note.
            return GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
                   ?? GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableObject.IsNotNull())
+                drawableObject.ApplyCustomUpdateState -= onApplyCustomUpdateState;
+        }
    }
 }
@@ -1,8 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.

+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;

@@ -10,6 +14,36 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
 {
    public partial class LegacyHoldNoteTailPiece : LegacyNotePiece
    {
+        private readonly IBindable<double?> missingStartTime = new Bindable<double?>();
+
+        [Resolved]
+        private DrawableHitObject drawableObject { get; set; } = null!;
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            missingStartTime.BindTo(((DrawableHoldNoteTail)drawableObject).MissingStartTime);
+            missingStartTime.BindValueChanged(onMissingStartTimeChanged, true);
+
+            drawableObject.ApplyCustomUpdateState += onApplyCustomUpdateState;
+        }
+
+        private void onMissingStartTimeChanged(ValueChangedEvent<double?> startTime)
+            => applyMissingDim();
+
+        private void onApplyCustomUpdateState(DrawableHitObject obj, ArmedState state)
+            => applyMissingDim();
+
+        private void applyMissingDim()
+        {
+            if (missingStartTime.Value == null)
+                return;
+
+            using (BeginAbsoluteSequence(missingStartTime.Value.Value))
+                this.FadeColour(Colour4.DarkGray, 60);
+        }
+
        protected override void OnDirectionChanged(ValueChangedEvent<ScrollingDirection> direction)
        {
            // Invert the direction
@@ -25,5 +59,13 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
                   ?? GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.HoldNoteHeadImage)
                   ?? GetAnimationFromLookup(skin, LegacyManiaSkinConfigurationLookups.NoteImage);
        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            if (drawableObject.IsNotNull())
+                drawableObject.ApplyCustomUpdateState -= onApplyCustomUpdateState;
+        }
    }
 }
@@ -9,9 +9,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Input;
-using osu.Framework.Platform;
 using osu.Framework.Threading;
-using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Handlers;
@@ -63,16 +61,11 @@ namespace osu.Game.Rulesets.Mania.UI

        public double TargetTimeRange { get; protected set; }

-        private double currentTimeRange;
-
        // Stores the current speed adjustment active in gameplay.
        private readonly Track speedAdjustmentTrack = new TrackVirtual(0);

        private ISkinSource currentSkin = null!;

-        [Resolved]
-        private GameHost gameHost { get; set; } = null!;
-
        public DrawableManiaRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod>? mods = null)
            : base(ruleset, beatmap, mods)
        {
@@ -119,7 +112,7 @@ namespace osu.Game.Rulesets.Mania.UI
                TargetTimeRange = ComputeScrollTime(speed.NewValue);
            });

-            TimeRange.Value = TargetTimeRange = currentTimeRange = ComputeScrollTime(configScrollSpeed.Value);
+            TimeRange.Value = TargetTimeRange = ComputeScrollTime(configScrollSpeed.Value);

            Config.BindWith(ManiaRulesetSetting.MobileLayout, mobileLayout);
            mobileLayout.BindValueChanged(_ => updateMobileLayout(), true);
@@ -179,9 +172,7 @@ namespace osu.Game.Rulesets.Mania.UI
            // This scaling factor preserves the scroll speed as the scroll length varies from changes to the hit position.
            float scale = lengthToHitPosition / length_to_default_hit_position;

-            // we're intentionally using the game host's update clock here to decouple the time range tween from the gameplay clock (which can be arbitrarily paused, or even rewinding)
-            currentTimeRange = Interpolation.DampContinuously(currentTimeRange, TargetTimeRange, 50, gameHost.UpdateThread.Clock.ElapsedFrameTime);
-            TimeRange.Value = currentTimeRange * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value * scale;
+            TimeRange.Value = TargetTimeRange * speedAdjustmentTrack.AggregateTempo.Value * speedAdjustmentTrack.AggregateFrequency.Value * scale;
        }

        /// <summary>
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor

            Vector2 oldStartPos = default;
            Vector2 oldEndPos = default;
-            double oldDistance = default;
+            double oldDistance = 0;
            var oldControlPointTypes = controlPoints.Select(p => p.Type);

            AddStep("Add slider", () =>
@@ -255,7 +255,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor

            Vector2 oldStartPos = default;
            Vector2 oldEndPos = default;
-            double oldDistance = default;
+            double oldDistance = 0;

            var oldControlPointTypes = segmentedSliderPath.Select(p => p.Type);

@@ -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))
@@ -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);
            }
        }
    }
@@ -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>
@@ -141,6 +141,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        /// </summary>
        public void MissForcefully() => ApplyMinResult();

+        // ReSharper disable once FunctionRecursiveOnAllPaths (TODO: remove after fixed https://youtrack.jetbrains.com/issue/RIDER-135036/Incorrect-recursive-on-all-execution-paths-inspection)
        private RectangleF parentScreenSpaceRectangle => ((DrawableOsuHitObject)ParentHitObject)?.parentScreenSpaceRectangle ?? Parent!.ScreenSpaceDrawQuad.AABBFloat;

        /// <summary>
@@ -9,12 +9,12 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
    public partial class TrianglesPiece : Triangles
    {
        protected override bool CreateNewTriangles => false;
-        protected override float SpawnRatio => 0.5f;

        public TrianglesPiece(int? seed = null)
            : base(seed)
        {
            TriangleScale = 1.2f;
+            SpawnRatio = 0.5f;
            HideAlphaDiscrepancies = false;
            ClampAxes = Axes.None;
        }
@@ -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))
@@ -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>
@@ -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);
            }
        }

@@ -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]
@@ -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);
            }
@@ -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);
            }
        }

@@ -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>
@@ -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)]
@@ -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);
        }
    }
 }
@@ -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.IO;
+using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -24,6 +26,36 @@ namespace osu.Game.Tests.Beatmaps.IO
        [Resolved]
        private BeatmapManager beatmaps { get; set; } = null!;

+        [TestCase(96, 32)]
+        [TestCase(32, 32)]
+        [TestCase(24, 32)]
+        [TestCase(23, 16)]
+        [TestCase(15, 16)]
+        [TestCase(12, 16)]
+        [TestCase(11, 8)]
+        [TestCase(6, 8)]
+        [TestCase(2, 4)]
+        public void TestGridSizeClampedToStableValues(int set, int expected)
+        {
+            IWorkingBeatmap beatmap = null!;
+            MemoryStream outStream = null!;
+
+            AddStep("import beatmap", () => beatmap = importBeatmapFromArchives(@"decimal-timing-beatmap.olz"));
+            AddStep("adjust grid", () => beatmap.Beatmap.GridSize = set);
+            AddStep("save", () => beatmaps.Save((beatmap.BeatmapInfo as BeatmapInfo)!, beatmap.Beatmap));
+
+            AddStep("export", () =>
+            {
+                outStream = new MemoryStream();
+
+                new LegacyBeatmapExporter(LocalStorage)
+                    .ExportToStream((BeatmapSetInfo)beatmap.BeatmapInfo.BeatmapSet!, outStream, null);
+            });
+
+            AddStep("import beatmap again", () => beatmap = importBeatmapFromStream(outStream));
+            AddAssert("grid clamped", () => beatmap.Beatmap.GridSize, () => Is.EqualTo(expected));
+        }
+
        [Test]
        public void TestObjectsSnappedAfterTruncatingExport()
        {
@@ -131,6 +163,48 @@ namespace osu.Game.Tests.Beatmaps.IO
            }
        }

+        [Test]
+        public void TestExportUsesCarriageReturnLineFeed()
+        {
+            IWorkingBeatmap beatmap = null!;
+            MemoryStream outStream = null!;
+
+            AddStep("import beatmap", () => beatmap = importBeatmapFromArchives(@"legacy-export-stability-test.olz"));
+            AddStep("export", () =>
+            {
+                outStream = new MemoryStream();
+
+                new LegacyBeatmapExporter(LocalStorage)
+                    .ExportToStream((BeatmapSetInfo)beatmap.BeatmapInfo.BeatmapSet!, outStream, null);
+            });
+
+            AddAssert(".osu file uses CRLF line endings",
+                () => hasBareLineFeed(outStream.GetBuffer()),
+                () => Is.False);
+
+            bool hasBareLineFeed(byte[] archiveBytes)
+            {
+                using var memoryStream = new MemoryStream(archiveBytes);
+                using var archiveReader = new ZipArchiveReader(memoryStream);
+
+                foreach (string filename in archiveReader.Filenames.Where(f => f.EndsWith(".osu", StringComparison.Ordinal)))
+                {
+                    byte[] content = archiveReader.GetStream(filename).ReadAllBytesToArray();
+
+                    for (int i = 0; i < content.Length; i++)
+                    {
+                        if (content[i] != '\n')
+                            continue;
+
+                        if (i == 0 || content[i - 1] != '\r')
+                            return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
        private IWorkingBeatmap importBeatmapFromStream(Stream stream)
        {
            var imported = beatmaps.Import(new ImportTask(stream, "filename.osz")).GetResultSafely();
@@ -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]);
            }
        }
    }
@@ -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());
                }
            }
        }
@@ -9,6 +9,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.Bindables;
 using osu.Framework.Extensions;
@@ -64,6 +65,7 @@ namespace osu.Game.Tests.Beatmaps
        }

        [Test]
+        [FlakyTest] // one fix attempted in https://github.com/ppy/osu/pull/37178, didn't work
        public void TestInvalidationFlow()
        {
            BeatmapInfo postEditBeatmapInfo = null;
@@ -225,7 +227,7 @@ namespace osu.Game.Tests.Beatmaps
        {
            var actualBracket = StarDifficulty.GetDifficultyRating(starRating);

-            Assert.AreEqual(expectedBracket, actualBracket);
+            ClassicAssert.AreEqual(expectedBracket, actualBracket);
        }

        private partial class TestBeatmapDifficultyCache : BeatmapDifficultyCache
@@ -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();
        }
@@ -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);
        }
    }
 }
@@ -187,6 +187,7 @@ namespace osu.Game.Tests.Database
        }

        [Test]
+        [FlakyTest]
        public void TestCustomRulesetScoreNotSubjectToUpgrades([Values] bool available)
        {
            RulesetInfo rulesetInfo = null!;
@@ -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,7 +102,7 @@ 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(detachedBeatmapSet.CopyChangesToRealm);
@@ -109,17 +110,17 @@ namespace osu.Game.Tests.Database
                    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);
                    });
                }
            });
@@ -142,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.
@@ -167,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]
@@ -208,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);
            });
        }

@@ -245,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);
@@ -269,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);
@@ -292,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"))
@@ -304,7 +305,7 @@ namespace osu.Game.Tests.Database
                    }

                    var imported = await importer.Import(new ImportTask(extractedFolder));
-                    Assert.IsNull(imported);
+                    ClassicAssert.Null(imported);
                }
                finally
                {
@@ -333,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
                {
@@ -382,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
@@ -390,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));
@@ -401,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
                {
@@ -501,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);

@@ -533,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));
@@ -550,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
                {
@@ -581,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));
@@ -598,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
                {
@@ -636,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);
@@ -659,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(
@@ -672,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);
            });
        }

@@ -709,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())
                    {
@@ -737,7 +738,7 @@ namespace osu.Game.Tests.Database

                checkSingleReferencedFileCount(realm.Realm, 18);

-                Assert.AreEqual(0, loggedExceptionCount);
+                ClassicAssert.AreEqual(0, loggedExceptionCount);

                File.Delete(brokenTempFilename);
            });
@@ -755,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));
            });
        }
@@ -787,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));
@@ -841,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");
@@ -851,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())));
@@ -873,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));
            });
        }
@@ -909,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);
            });
        }

@@ -954,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));
            });
        }

@@ -975,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");
            });
        }

@@ -994,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());
@@ -1030,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"));
@@ -1041,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));
@@ -1075,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));
@@ -1086,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
                {
@@ -1125,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));
@@ -1136,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
                {
@@ -1182,7 +1183,7 @@ namespace osu.Game.Tests.Database

            var importedSet = await importer.Import(new ImportTask(temp));

-            Assert.NotNull(importedSet);
+            ClassicAssert.NotNull(importedSet);

            EnsureLoaded(realm);

@@ -1197,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);
@@ -1214,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) =>
@@ -1230,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));
        }
@@ -1243,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)
@@ -1256,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)
@@ -1270,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);

@@ -1279,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)
@@ -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));
@@ -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));
            });
        }
    }
@@ -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);
            });
        }

@@ -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);
                }
            });
        }
@@ -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 =>
                        {
@@ -5,6 +5,7 @@ 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;
@@ -27,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());
            });
        }

@@ -40,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());
            });
        }

@@ -55,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);
            });
        }

@@ -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 =>
@@ -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);

@@ -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);
@@ -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);
@@ -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);
@@ -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);
@@ -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);

@@ -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)
@@ -258,6 +258,6 @@ namespace osu.Game.Tests.Gameplay
        }

        private void disableLayeredHitSounds()
-            => AddStep("set LayeredHitSounds to false", () => Skin.Configuration.ConfigDictionary[LegacySetting.LayeredHitSounds.ToString()] = "0");
+            => AddStep("set LayeredHitSounds to false", () => Skin.Configuration.ConfigDictionary[nameof(LegacySetting.LayeredHitSounds)] = "0");
    }
 }
@@ -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
@@ -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);
        }
    }
 }
@@ -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]
@@ -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);
            }
        }

@@ -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);
        }
    }
 }
@@ -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;
@@ -97,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}");
        }
    }
 }
@@ -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(() =>
            {
@@ -5,6 +5,7 @@ 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;
@@ -61,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]
@@ -74,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]
@@ -88,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]
@@ -102,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]
@@ -123,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]
@@ -144,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]
@@ -166,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]
@@ -195,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]
@@ -215,7 +216,47 @@ 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]
+        [TestCase("\"quoted words\"", false)]
+        [TestCase("\"the artist\"", false)]
+        [TestCase("the artist \"quoted words\"", false)]
+        [TestCase("\"unknown\"", true)]
+        public void TestCriteriaMatchingTermsAdjacentToPunctuation(string terms, bool filtered)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            exampleBeatmapInfo.Metadata.Title = "the artist \"quoted words\"";
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { OnlineID = 6 },
+                AllowConvertedBeatmaps = true,
+                SearchText = terms
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase("~quoted words~", false)]
+        [TestCase("the artist", false)]
+        [TestCase("the artist ~quoted words~", false)]
+        [TestCase("~unknown~", true)]
+        public void TestCriteriaMatchingTermsAdjacentToMathSymbols(string terms, bool filtered)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            exampleBeatmapInfo.Metadata.Title = "the artist ~quoted words~";
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { OnlineID = 6 },
+                AllowConvertedBeatmaps = true,
+                SearchText = terms
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            ClassicAssert.AreEqual(filtered, carouselItem.Filtered.Value);
        }

        [Test]
@@ -236,7 +277,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]
@@ -260,7 +301,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]
@@ -278,7 +319,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)]
@@ -295,7 +336,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]
@@ -312,7 +353,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)]
@@ -327,7 +368,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]
@@ -345,7 +386,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]
@@ -363,7 +404,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]
@@ -380,7 +421,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]
@@ -398,7 +439,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]
@@ -410,7 +451,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]
@@ -423,7 +464,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 })]
@@ -5,6 +5,7 @@ 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;
@@ -23,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]
@@ -33,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));
@@ -58,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));
@@ -77,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));
@@ -91,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]
@@ -104,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);
        }

        /*
@@ -125,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]
@@ -139,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]
@@ -153,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]
@@ -167,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]
@@ -181,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]
@@ -191,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 =
@@ -228,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 =
@@ -254,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]
@@ -263,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]
@@ -277,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));
        }

@@ -287,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));
        }

@@ -308,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));
        }

@@ -374,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]
@@ -385,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));
        }

@@ -397,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));
        }

@@ -409,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));
        }

@@ -422,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));
        }

@@ -433,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]
@@ -444,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]
@@ -453,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")]
@@ -464,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]
@@ -474,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 })]
@@ -535,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));
        }

@@ -580,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 =
@@ -605,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]
@@ -614,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]
@@ -627,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]
@@ -640,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]
@@ -654,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]
@@ -663,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) =>
@@ -706,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 =
@@ -723,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 =
@@ -755,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 =
@@ -781,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]
@@ -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")]
@@ -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());
        }
    }
 }
@@ -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
@@ -5,6 +5,7 @@

 using System;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Utils;

 namespace osu.Game.Tests.NonVisual
@@ -25,7 +26,7 @@ namespace osu.Game.Tests.NonVisual
        [Test]
        public void TestEmptyQueue()
        {
-            Assert.AreEqual(0, queue.Count);
+            ClassicAssert.AreEqual(0, queue.Count);

            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);

@@ -35,7 +36,7 @@ namespace osu.Game.Tests.NonVisual
            foreach (int _ in queue)
                count++;

-            Assert.AreEqual(0, count);
+            ClassicAssert.AreEqual(0, count);
        }

        [TestCase(1)]
@@ -46,14 +47,14 @@ namespace osu.Game.Tests.NonVisual
            for (int i = 0; i < count; ++i)
                queue.Enqueue(i);

-            Assert.AreEqual(count, queue.Count);
+            ClassicAssert.AreEqual(count, queue.Count);

            for (int i = 0; i < count; ++i)
-                Assert.AreEqual(i, queue[i]);
+                ClassicAssert.AreEqual(i, queue[i]);

            int j = 0;
            foreach (int item in queue)
-                Assert.AreEqual(j++, item);
+                ClassicAssert.AreEqual(j++, item);

            for (int i = queue.Count; i < queue.Count + capacity; i++)
                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
@@ -67,14 +68,14 @@ namespace osu.Game.Tests.NonVisual
            for (int i = 0; i < count; ++i)
                queue.Enqueue(i);

-            Assert.AreEqual(capacity, queue.Count);
+            ClassicAssert.AreEqual(capacity, queue.Count);

            for (int i = 0; i < queue.Count; ++i)
-                Assert.AreEqual(count - capacity + i, queue[i]);
+                ClassicAssert.AreEqual(count - capacity + i, queue[i]);

            int j = count - capacity;
            foreach (int item in queue)
-                Assert.AreEqual(j++, item);
+                ClassicAssert.AreEqual(j++, item);

            for (int i = queue.Count; i < queue.Count + capacity; i++)
                Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[i]);
@@ -90,8 +91,8 @@ namespace osu.Game.Tests.NonVisual

            for (int i = 0; i < capacity; ++i)
            {
-                Assert.AreEqual(count - capacity + i, queue.Dequeue());
-                Assert.AreEqual(2 - i, queue.Count);
+                ClassicAssert.AreEqual(count - capacity + i, queue.Dequeue());
+                ClassicAssert.AreEqual(2 - i, queue.Count);
            }

            Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
@@ -102,20 +103,20 @@ namespace osu.Game.Tests.NonVisual
        {
            queue.Enqueue(3);
            queue.Enqueue(5);
-            Assert.AreEqual(2, queue.Count);
+            ClassicAssert.AreEqual(2, queue.Count);

            queue.Clear();
-            Assert.AreEqual(0, queue.Count);
+            ClassicAssert.AreEqual(0, queue.Count);
            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[0]);

            queue.Enqueue(7);
-            Assert.AreEqual(1, queue.Count);
-            Assert.AreEqual(7, queue[0]);
+            ClassicAssert.AreEqual(1, queue.Count);
+            ClassicAssert.AreEqual(7, queue[0]);
            Assert.Throws<ArgumentOutOfRangeException>(() => _ = queue[1]);

            queue.Enqueue(9);
-            Assert.AreEqual(2, queue.Count);
-            Assert.AreEqual(9, queue[1]);
+            ClassicAssert.AreEqual(2, queue.Count);
+            ClassicAssert.AreEqual(9, queue[1]);
        }
    }
 }
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Utils;
 using osu.Game.Utils;

@@ -28,9 +29,9 @@ namespace osu.Game.Tests.NonVisual
            var tracker = new PeriodTracker(single_period);

            var period = single_period.Single();
-            Assert.IsTrue(tracker.IsInAny(period.Start));
-            Assert.IsTrue(tracker.IsInAny(getMidpoint(period)));
-            Assert.IsTrue(tracker.IsInAny(period.End));
+            ClassicAssert.True(tracker.IsInAny(period.Start));
+            ClassicAssert.True(tracker.IsInAny(getMidpoint(period)));
+            ClassicAssert.True(tracker.IsInAny(period.End));
        }

        [Test]
@@ -39,7 +40,7 @@ namespace osu.Game.Tests.NonVisual
            var tracker = new PeriodTracker(unordered_periods);

            foreach (var period in unordered_periods)
-                Assert.IsTrue(tracker.IsInAny(getMidpoint(period)));
+                ClassicAssert.True(tracker.IsInAny(getMidpoint(period)));
        }

        [Test]
@@ -48,7 +49,7 @@ namespace osu.Game.Tests.NonVisual
            var tracker = new PeriodTracker(unordered_periods);

            foreach (var period in unordered_periods.OrderBy(_ => RNG.Next()))
-                Assert.IsTrue(tracker.IsInAny(getMidpoint(period)));
+                ClassicAssert.True(tracker.IsInAny(getMidpoint(period)));
        }

        [Test]
@@ -60,12 +61,12 @@ namespace osu.Game.Tests.NonVisual
                new Period(3.0, 4.0)
            });

-            Assert.IsFalse(tracker.IsInAny(0.9), "Time before first period is being considered inside");
+            ClassicAssert.False(tracker.IsInAny(0.9), "Time before first period is being considered inside");

-            Assert.IsFalse(tracker.IsInAny(2.1), "Time right after first period is being considered inside");
-            Assert.IsFalse(tracker.IsInAny(2.9), "Time right before second period is being considered inside");
+            ClassicAssert.False(tracker.IsInAny(2.1), "Time right after first period is being considered inside");
+            ClassicAssert.False(tracker.IsInAny(2.9), "Time right before second period is being considered inside");

-            Assert.IsFalse(tracker.IsInAny(4.1), "Time after last period is being considered inside");
+            ClassicAssert.False(tracker.IsInAny(4.1), "Time after last period is being considered inside");
        }

        [Test]
@@ -6,6 +6,7 @@
 using System;
 using System.Linq;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
@@ -25,8 +26,8 @@ namespace osu.Game.Tests.NonVisual.Ranking

            var unstableRate = new UnstableRate(events);

-            Assert.IsNotNull(unstableRate.Value);
-            Assert.AreEqual(unstableRate.Value.Value, 10 * Math.Sqrt(10), Precision.DOUBLE_EPSILON);
+            Assert.That(unstableRate.Value, Is.Not.Null);
+            ClassicAssert.AreEqual(unstableRate.Value.Value, 10 * Math.Sqrt(10), Precision.DOUBLE_EPSILON);
        }

        [Test]
@@ -50,8 +51,8 @@ namespace osu.Game.Tests.NonVisual.Ranking

            result = events.GetRange(0, 2).CalculateUnstableRate(result);

-            Assert.IsNotNull(result!.Result);
-            Assert.AreEqual(5, result.Result, Precision.DOUBLE_EPSILON);
+            ClassicAssert.NotNull(result!.Result);
+            ClassicAssert.AreEqual(5, result.Result, Precision.DOUBLE_EPSILON);
        }

        [Test]
@@ -73,8 +74,8 @@ namespace osu.Game.Tests.NonVisual.Ranking
                               .CalculateUnstableRate(result);
            }

-            Assert.IsNotNull(result!.Result);
-            Assert.AreEqual(10 * Math.Sqrt(10), result.Result, Precision.DOUBLE_EPSILON);
+            ClassicAssert.NotNull(result!.Result);
+            ClassicAssert.AreEqual(10 * Math.Sqrt(10), result.Result, Precision.DOUBLE_EPSILON);
        }

        [Test]
@@ -89,7 +90,7 @@ namespace osu.Game.Tests.NonVisual.Ranking

            var unstableRate = new UnstableRate(events);

-            Assert.AreEqual(0, unstableRate.Value);
+            ClassicAssert.AreEqual(0, unstableRate.Value);
        }

        [Test]
@@ -105,7 +106,7 @@ namespace osu.Game.Tests.NonVisual.Ranking

            var unstableRate = new UnstableRate(events);

-            Assert.AreEqual(10 * 100, unstableRate.Value);
+            ClassicAssert.AreEqual(10 * 100, unstableRate.Value);
        }

        [Test]
@@ -121,7 +122,7 @@ namespace osu.Game.Tests.NonVisual.Ranking

            var unstableRate = new UnstableRate(events);

-            Assert.AreEqual(10 * 100, unstableRate.Value);
+            ClassicAssert.AreEqual(10 * 100, unstableRate.Value);
        }
    }
 }
@@ -5,6 +5,7 @@

 using System;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Rulesets.Difficulty.Utils;

 namespace osu.Game.Tests.NonVisual
@@ -23,7 +24,7 @@ namespace osu.Game.Tests.NonVisual
        [Test]
        public void TestEmptyQueue()
        {
-            Assert.AreEqual(0, queue.Count);
+            ClassicAssert.AreEqual(0, queue.Count);

            Assert.Throws<ArgumentOutOfRangeException>(() =>
            {
@@ -34,7 +35,7 @@ namespace osu.Game.Tests.NonVisual
            foreach (char unused in queue)
                count++;

-            Assert.AreEqual(0, count);
+            ClassicAssert.AreEqual(0, count);
        }

        [Test]
@@ -45,21 +46,21 @@ namespace osu.Game.Tests.NonVisual
            queue.Enqueue('b');
            queue.Enqueue('c');

-            Assert.AreEqual('c', queue[0]);
-            Assert.AreEqual('b', queue[1]);
-            Assert.AreEqual('a', queue[2]);
+            ClassicAssert.AreEqual('c', queue[0]);
+            ClassicAssert.AreEqual('b', queue[1]);
+            ClassicAssert.AreEqual('a', queue[2]);

            // Assert correct values and reverse index after enqueueing beyond initial capacity of 4
            queue.Enqueue('d');
            queue.Enqueue('e');
            queue.Enqueue('f');

-            Assert.AreEqual('f', queue[0]);
-            Assert.AreEqual('e', queue[1]);
-            Assert.AreEqual('d', queue[2]);
-            Assert.AreEqual('c', queue[3]);
-            Assert.AreEqual('b', queue[4]);
-            Assert.AreEqual('a', queue[5]);
+            ClassicAssert.AreEqual('f', queue[0]);
+            ClassicAssert.AreEqual('e', queue[1]);
+            ClassicAssert.AreEqual('d', queue[2]);
+            ClassicAssert.AreEqual('c', queue[3]);
+            ClassicAssert.AreEqual('b', queue[4]);
+            ClassicAssert.AreEqual('a', queue[5]);
        }

        [Test]
@@ -73,13 +74,13 @@ namespace osu.Game.Tests.NonVisual
            queue.Enqueue('f');

            // Assert correct item return and no longer in queue after dequeueing
-            Assert.AreEqual('a', queue[5]);
+            ClassicAssert.AreEqual('a', queue[5]);
            char dequeuedItem = queue.Dequeue();

-            Assert.AreEqual('a', dequeuedItem);
-            Assert.AreEqual(5, queue.Count);
-            Assert.AreEqual('f', queue[0]);
-            Assert.AreEqual('b', queue[4]);
+            ClassicAssert.AreEqual('a', dequeuedItem);
+            ClassicAssert.AreEqual(5, queue.Count);
+            ClassicAssert.AreEqual('f', queue[0]);
+            ClassicAssert.AreEqual('b', queue[4]);
            Assert.Throws<ArgumentOutOfRangeException>(() =>
            {
                char unused = queue[5];
@@ -97,8 +98,8 @@ namespace osu.Game.Tests.NonVisual
            queue.Dequeue();
            queue.Dequeue();

-            Assert.AreEqual(1, queue.Count);
-            Assert.AreEqual('i', queue[0]);
+            ClassicAssert.AreEqual(1, queue.Count);
+            ClassicAssert.AreEqual('i', queue[0]);
        }

        [Test]
@@ -114,7 +115,7 @@ namespace osu.Game.Tests.NonVisual
            // Assert queue is empty after clearing
            queue.Clear();

-            Assert.AreEqual(0, queue.Count);
+            ClassicAssert.AreEqual(0, queue.Count);
            Assert.Throws<ArgumentOutOfRangeException>(() =>
            {
                char unused = queue[0];
@@ -137,7 +138,7 @@ namespace osu.Game.Tests.NonVisual
            // Assert items are enumerated in correct order
            foreach (char item in queue)
            {
-                Assert.AreEqual(expectedValues[expectedValueIndex], item);
+                ClassicAssert.AreEqual(expectedValues[expectedValueIndex], item);
                expectedValueIndex++;
            }
        }
@@ -5,6 +5,7 @@

 using System;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Configuration;
 using osu.Game.Online.API.Requests.Responses;

@@ -26,20 +27,20 @@ namespace osu.Game.Tests.NonVisual
            sessionStatics.SetValue(Static.LastHoverSoundPlaybackTime, (double?)1d);
            sessionStatics.SetValue(Static.SeasonalBackgrounds, new APISeasonalBackgrounds { EndDate = new DateTimeOffset(2022, 1, 1, 0, 0, 0, TimeSpan.Zero) });

-            Assert.IsFalse(sessionStatics.GetBindable<bool>(Static.LoginOverlayDisplayed).IsDefault);
-            Assert.IsFalse(sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).IsDefault);
-            Assert.IsFalse(sessionStatics.GetBindable<bool>(Static.LowBatteryNotificationShownOnce).IsDefault);
-            Assert.IsFalse(sessionStatics.GetBindable<double?>(Static.LastHoverSoundPlaybackTime).IsDefault);
-            Assert.IsFalse(sessionStatics.GetBindable<APISeasonalBackgrounds>(Static.SeasonalBackgrounds).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<bool>(Static.LoginOverlayDisplayed).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<bool>(Static.LowBatteryNotificationShownOnce).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<double?>(Static.LastHoverSoundPlaybackTime).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<APISeasonalBackgrounds>(Static.SeasonalBackgrounds).IsDefault);

            sessionStatics.ResetAfterInactivity();

-            Assert.IsTrue(sessionStatics.GetBindable<bool>(Static.LoginOverlayDisplayed).IsDefault);
-            Assert.IsTrue(sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).IsDefault);
-            Assert.IsTrue(sessionStatics.GetBindable<bool>(Static.LowBatteryNotificationShownOnce).IsDefault);
+            ClassicAssert.True(sessionStatics.GetBindable<bool>(Static.LoginOverlayDisplayed).IsDefault);
+            ClassicAssert.True(sessionStatics.GetBindable<bool>(Static.MutedAudioNotificationShownOnce).IsDefault);
+            ClassicAssert.True(sessionStatics.GetBindable<bool>(Static.LowBatteryNotificationShownOnce).IsDefault);
            // some statics should not reset despite inactivity.
-            Assert.IsFalse(sessionStatics.GetBindable<double?>(Static.LastHoverSoundPlaybackTime).IsDefault);
-            Assert.IsFalse(sessionStatics.GetBindable<APISeasonalBackgrounds>(Static.SeasonalBackgrounds).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<double?>(Static.LastHoverSoundPlaybackTime).IsDefault);
+            ClassicAssert.False(sessionStatics.GetBindable<APISeasonalBackgrounds>(Static.SeasonalBackgrounds).IsDefault);
        }
    }
 }
@@ -10,6 +10,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Framework.Audio;
 using osu.Framework.Graphics.Rendering;
 using osu.Framework.Graphics.Rendering.Dummy;
@@ -93,9 +94,9 @@ namespace osu.Game.Tests.NonVisual.Skinning

            var texture = legacySkin.GetTexture(requestedComponent);

-            Assert.IsNotNull(texture);
-            Assert.AreEqual(textureStore.Textures[expectedTexture].Width, texture.Width);
-            Assert.AreEqual(expectedScale, texture.ScaleAdjust);
+            Assert.That(texture, Is.Not.Null);
+            ClassicAssert.AreEqual(textureStore.Textures[expectedTexture].Width, texture.Width);
+            ClassicAssert.AreEqual(expectedScale, texture.ScaleAdjust);
        }

        [Test]
@@ -106,7 +107,7 @@ namespace osu.Game.Tests.NonVisual.Skinning

            var texture = legacySkin.GetTexture("Gameplay/osu/followpoint");

-            Assert.IsNull(texture);
+            ClassicAssert.Null(texture);
        }

        [Test]
@@ -117,15 +118,15 @@ namespace osu.Game.Tests.NonVisual.Skinning

            var texture = legacySkin.GetTexture("hitcircle");

-            Assert.IsNotNull(texture);
+            Assert.That(texture, Is.Not.Null);
            Assert.That(texture.ScaleAdjust, Is.EqualTo(1));

            var twoTimesTexture = legacySkin.GetTexture("hitcircle@2x");

-            Assert.IsNotNull(twoTimesTexture);
+            Assert.That(twoTimesTexture, Is.Not.Null);
            Assert.That(twoTimesTexture.ScaleAdjust, Is.EqualTo(1));

-            Assert.AreNotEqual(texture, twoTimesTexture);
+            ClassicAssert.AreNotEqual(texture, twoTimesTexture);
        }

        [Test]
@@ -136,15 +137,15 @@ namespace osu.Game.Tests.NonVisual.Skinning

            var texture = legacySkin.GetTexture("hitcircle");

-            Assert.IsNotNull(texture);
+            Assert.That(texture, Is.Not.Null);
            Assert.That(texture.ScaleAdjust, Is.EqualTo(2));

            var twoTimesTexture = legacySkin.GetTexture("hitcircle@2x");

-            Assert.IsNotNull(twoTimesTexture);
+            Assert.That(twoTimesTexture, Is.Not.Null);
            Assert.That(twoTimesTexture.ScaleAdjust, Is.EqualTo(2));

-            Assert.AreEqual(texture, twoTimesTexture);
+            ClassicAssert.AreEqual(texture, twoTimesTexture);
        }

        private class TestLegacySkin : LegacySkin
@@ -3,6 +3,7 @@

 using System;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Extensions;

 namespace osu.Game.Tests.NonVisual
@@ -21,7 +22,7 @@ namespace osu.Game.Tests.NonVisual
        [TestCaseSource(nameof(editor_formatted_duration_tests))]
        public void TestEditorFormat(TimeSpan input, string expectedOutput)
        {
-            Assert.AreEqual(expectedOutput, input.ToEditorFormattedString());
+            ClassicAssert.AreEqual(expectedOutput, input.ToEditorFormattedString());
        }

        private static readonly object[][] formatted_duration_tests =
@@ -35,7 +36,7 @@ namespace osu.Game.Tests.NonVisual
        [TestCaseSource(nameof(formatted_duration_tests))]
        public void TestFormattedDuration(TimeSpan input, string expectedOutput)
        {
-            Assert.AreEqual(expectedOutput, input.ToFormattedDuration().ToString());
+            ClassicAssert.AreEqual(expectedOutput, input.ToFormattedDuration().ToString());
        }
    }
 }
@@ -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.Online.Chat;

 namespace osu.Game.Tests.Online.Chat
@@ -12,79 +13,79 @@ namespace osu.Game.Tests.Online.Chat
        [Test]
        public void TestContainsUsernameMidlinePositive()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("This is a test message", "Test").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("This is a test message", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameStartOfLinePositive()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("Test message", "Test").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("Test message", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameEndOfLinePositive()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("This is a test", "Test").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("This is a test", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameMidlineNegative()
        {
-            Assert.IsFalse(MessageNotifier.MatchUsername("This is a testmessage for notifications", "Test").Success);
+            ClassicAssert.False(MessageNotifier.MatchUsername("This is a testmessage for notifications", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameStartOfLineNegative()
        {
-            Assert.IsFalse(MessageNotifier.MatchUsername("Testmessage", "Test").Success);
+            ClassicAssert.False(MessageNotifier.MatchUsername("Testmessage", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameEndOfLineNegative()
        {
-            Assert.IsFalse(MessageNotifier.MatchUsername("This is a notificationtest", "Test").Success);
+            ClassicAssert.False(MessageNotifier.MatchUsername("This is a notificationtest", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameBetweenPunctuation()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("Hello 'test'-message", "Test").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("Hello 'test'-message", "Test").Success);
        }

        [Test]
        public void TestContainsUsernameUnicode()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("Test \u0460\u0460 message", "\u0460\u0460").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("Test \u0460\u0460 message", "\u0460\u0460").Success);
        }

        [Test]
        public void TestContainsUsernameUnicodeNegative()
        {
-            Assert.IsFalse(MessageNotifier.MatchUsername("Test ha\u0460\u0460o message", "\u0460\u0460").Success);
+            ClassicAssert.False(MessageNotifier.MatchUsername("Test ha\u0460\u0460o message", "\u0460\u0460").Success);
        }

        [Test]
        public void TestContainsUsernameSpecialCharactersPositive()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("Test [#^-^#] message", "[#^-^#]").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("Test [#^-^#] message", "[#^-^#]").Success);
        }

        [Test]
        public void TestContainsUsernameSpecialCharactersNegative()
        {
-            Assert.IsFalse(MessageNotifier.MatchUsername("Test pad[#^-^#]oru message", "[#^-^#]").Success);
+            ClassicAssert.False(MessageNotifier.MatchUsername("Test pad[#^-^#]oru message", "[#^-^#]").Success);
        }

        [Test]
        public void TestContainsUsernameAtSign()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("@username hi", "username").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("@username hi", "username").Success);
        }

        [Test]
        public void TestContainsUsernameColon()
        {
-            Assert.IsTrue(MessageNotifier.MatchUsername("username: hi", "username").Success);
+            ClassicAssert.True(MessageNotifier.MatchUsername("username: hi", "username").Success);
        }
    }
 }
@@ -3,6 +3,7 @@

 using System;
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Multiplayer.MatchTypes.Matchmaking;

@@ -30,17 +31,17 @@ namespace osu.Game.Tests.Online.Matchmaking
                new SoloScoreInfo { UserID = 3, TotalScore = 750 },
            ], placement_points);

-            Assert.AreEqual(8, state.Users.GetOrAdd(1).Points);
-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(8, state.Users.GetOrAdd(1).Points);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Rounds.GetOrAdd(1).Placement);

-            Assert.AreEqual(6, state.Users.GetOrAdd(2).Points);
-            Assert.AreEqual(3, state.Users.GetOrAdd(2).Placement);
-            Assert.AreEqual(3, state.Users.GetOrAdd(2).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(6, state.Users.GetOrAdd(2).Points);
+            ClassicAssert.AreEqual(3, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(3, state.Users.GetOrAdd(2).Rounds.GetOrAdd(1).Placement);

-            Assert.AreEqual(7, state.Users.GetOrAdd(3).Points);
-            Assert.AreEqual(2, state.Users.GetOrAdd(3).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(3).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(7, state.Users.GetOrAdd(3).Points);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(3).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(3).Rounds.GetOrAdd(1).Placement);

            // 2 -> 1 -> 3

@@ -52,17 +53,17 @@ namespace osu.Game.Tests.Online.Matchmaking
                new SoloScoreInfo { UserID = 3, TotalScore = 500 },
            ], placement_points);

-            Assert.AreEqual(15, state.Users.GetOrAdd(1).Points);
-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(1).Rounds.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(15, state.Users.GetOrAdd(1).Points);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(1).Rounds.GetOrAdd(2).Placement);

-            Assert.AreEqual(14, state.Users.GetOrAdd(2).Points);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
-            Assert.AreEqual(1, state.Users.GetOrAdd(2).Rounds.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(14, state.Users.GetOrAdd(2).Points);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(2).Rounds.GetOrAdd(2).Placement);

-            Assert.AreEqual(13, state.Users.GetOrAdd(3).Points);
-            Assert.AreEqual(3, state.Users.GetOrAdd(3).Placement);
-            Assert.AreEqual(3, state.Users.GetOrAdd(3).Rounds.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(13, state.Users.GetOrAdd(3).Points);
+            ClassicAssert.AreEqual(3, state.Users.GetOrAdd(3).Placement);
+            ClassicAssert.AreEqual(3, state.Users.GetOrAdd(3).Rounds.GetOrAdd(2).Placement);
        }

        [Test]
@@ -81,21 +82,21 @@ namespace osu.Game.Tests.Online.Matchmaking
                new SoloScoreInfo { UserID = 4, TotalScore = 500 },
            ], placement_points);

-            Assert.AreEqual(7, state.Users.GetOrAdd(1).Points);
-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(1).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(7, state.Users.GetOrAdd(1).Points);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(1).Rounds.GetOrAdd(1).Placement);

-            Assert.AreEqual(7, state.Users.GetOrAdd(2).Points);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(7, state.Users.GetOrAdd(2).Points);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Rounds.GetOrAdd(1).Placement);

-            Assert.AreEqual(5, state.Users.GetOrAdd(3).Points);
-            Assert.AreEqual(3, state.Users.GetOrAdd(3).Placement);
-            Assert.AreEqual(4, state.Users.GetOrAdd(3).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(5, state.Users.GetOrAdd(3).Points);
+            ClassicAssert.AreEqual(3, state.Users.GetOrAdd(3).Placement);
+            ClassicAssert.AreEqual(4, state.Users.GetOrAdd(3).Rounds.GetOrAdd(1).Placement);

-            Assert.AreEqual(5, state.Users.GetOrAdd(4).Points);
-            Assert.AreEqual(4, state.Users.GetOrAdd(4).Placement);
-            Assert.AreEqual(4, state.Users.GetOrAdd(4).Rounds.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(5, state.Users.GetOrAdd(4).Points);
+            ClassicAssert.AreEqual(4, state.Users.GetOrAdd(4).Placement);
+            ClassicAssert.AreEqual(4, state.Users.GetOrAdd(4).Rounds.GetOrAdd(1).Placement);
        }

        [Test]
@@ -121,8 +122,8 @@ namespace osu.Game.Tests.Online.Matchmaking
                new SoloScoreInfo { UserID = 2, TotalScore = 1000 },
            ], placement_points);

-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
        }

        [Test]
@@ -143,12 +144,12 @@ namespace osu.Game.Tests.Online.Matchmaking
                new SoloScoreInfo { UserID = 5, TotalScore = 1000 },
            ], placement_points);

-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
-            Assert.AreEqual(3, state.Users.GetOrAdd(3).Placement);
-            Assert.AreEqual(4, state.Users.GetOrAdd(4).Placement);
-            Assert.AreEqual(5, state.Users.GetOrAdd(5).Placement);
-            Assert.AreEqual(6, state.Users.GetOrAdd(6).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(3, state.Users.GetOrAdd(3).Placement);
+            ClassicAssert.AreEqual(4, state.Users.GetOrAdd(4).Placement);
+            ClassicAssert.AreEqual(5, state.Users.GetOrAdd(5).Placement);
+            ClassicAssert.AreEqual(6, state.Users.GetOrAdd(6).Placement);
        }

        [Test]
@@ -163,20 +164,20 @@ namespace osu.Game.Tests.Online.Matchmaking
                new SoloScoreInfo { UserID = 2, TotalScore = 500 },
            ], placement_points);

-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Placement);

            state.Users.GetOrAdd(1).AbandonedAt = DateTimeOffset.Now;
            state.RecordScores([], placement_points);

-            Assert.AreEqual(2, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(1, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(2).Placement);

            state.Users.GetOrAdd(2).AbandonedAt = DateTimeOffset.Now - TimeSpan.FromMinutes(1);
            state.RecordScores([], placement_points);

-            Assert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
-            Assert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
+            ClassicAssert.AreEqual(1, state.Users.GetOrAdd(1).Placement);
+            ClassicAssert.AreEqual(2, state.Users.GetOrAdd(2).Placement);
        }
    }
 }
--- a/Show More
+++ b/Show More