Migrate to TUnit for unit tests

PkmnLib.Tests/Dataloader/AbilityDataLoaderTests.cs

@@ -5,10 +5,10 @@ namespace PkmnLib.Tests.Dataloader;
 public class AbilityDataLoaderTests
 {
     [Test]
-    public void TestPrimaryAbilityFile()
+    public async Task TestPrimaryAbilityFile()
     {
         using var stream = File.OpenRead("Data/Abilities.json");
         var library = AbilityDataLoader.LoadAbilities(stream);
-        Assert.That(library, Is.Not.Null);
+        await Assert.That(library).IsNotNull();
     }
 }

PkmnLib.Tests/Dataloader/GrowthRateDataLoaderTests.cs

@@ -5,10 +5,10 @@ namespace PkmnLib.Tests.Dataloader;
 public class GrowthRateDataLoaderTests
 {
     [Test]
-    public void TestPrimaryGrowthRateFile()
+    public async Task TestPrimaryGrowthRateFile()
     {
-        using var file = File.Open("Data/GrowthRates.json", FileMode.Open);
+        using var file = File.Open("Data/GrowthRates.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var library = GrowthRateDataLoader.LoadGrowthRates(file);
-        Assert.That(library, Is.Not.Null);
+        await Assert.That(library).IsNotNull();
     }
 }

PkmnLib.Tests/Dataloader/ItemDataLoaderTests.cs

@@ -5,10 +5,10 @@ namespace PkmnLib.Tests.Dataloader;
 public class ItemDataLoaderTests
 {
     [Test]
-    public void TestPrimaryItemFile()
+    public async Task TestPrimaryItemFile()
     {
         using var stream = File.OpenRead("Data/Items.json");
         var library = ItemDataLoader.LoadItems(stream);
-        Assert.That(library, Is.Not.Null);
+        await Assert.That(library).IsNotNull();
     }
 }

PkmnLib.Tests/Dataloader/MoveDataLoaderTests.cs

@@ -6,7 +6,7 @@ namespace PkmnLib.Tests.Dataloader;
 public class MoveDataLoaderTests
 {
     [Test]
-    public void TestPrimaryMoveFile()
+    public async Task TestPrimaryMoveFile()
     {
         using var stream = File.OpenRead("Data/Moves.json");
         var typeLibrary = new TypeLibrary();
@@ -30,6 +30,6 @@ public class MoveDataLoaderTests
         typeLibrary.RegisterType("Fairy");
 
         var library = MoveDataLoader.LoadMoves(stream, typeLibrary);
-        Assert.That(library, Is.Not.Null);
+        await Assert.That(library).IsNotNull();
     }
 }

PkmnLib.Tests/Dataloader/NatureDataloaderTests.cs

@@ -5,10 +5,10 @@ namespace PkmnLib.Tests.Dataloader;
 public class NatureDataloaderTests
 {
     [Test]
-    public void TestPrimaryNatureFile()
+    public async Task TestPrimaryNatureFile()
     {
-        using var file = File.Open("Data/Natures.csv", FileMode.Open);
+        using var file = File.Open("Data/Natures.csv", FileMode.Open, FileAccess.Read, FileShare.Read);
         var library = NatureDataLoader.LoadNatureLibrary(file);
-        Assert.That(library, Is.Not.Null);
+        await Assert.That(library).IsNotNull();
     }
 }

PkmnLib.Tests/Dataloader/SpeciesDataloaderTests.cs

@@ -6,9 +6,9 @@ namespace PkmnLib.Tests.Dataloader;
 public class SpeciesDataloaderTests
 {
     [Test]
-    public void TestPrimarySpeciesFile()
+    public async Task TestPrimarySpeciesFile()
     {
-        using var file = File.Open("Data/Pokemon.json", FileMode.Open);
+        using var file = File.Open("Data/Pokemon.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var typeLibrary = new TypeLibrary();
         typeLibrary.RegisterType("Normal");
         typeLibrary.RegisterType("Fire");
@@ -30,6 +30,6 @@ public class SpeciesDataloaderTests
         typeLibrary.RegisterType("Fairy");
         
         var library = SpeciesDataLoader.LoadSpecies(file, typeLibrary);
-        Assert.NotNull(library);
+        await Assert.That(library).IsNotNull();
     }
 }

PkmnLib.Tests/Dataloader/TypeDataloaderTests.cs

@@ -5,18 +5,18 @@ namespace PkmnLib.Tests.Dataloader;
 public class TypeDataloaderTests
 {
     [Test]
-    public void TestPrimaryTypesFile()
+    public async Task TestPrimaryTypesFile()
     {
-        using var file = File.Open("Data/Types.csv", FileMode.Open);
+        await using var file = File.Open("Data/Types.csv", FileMode.Open, FileAccess.Read, FileShare.Read);
         var library = TypeDataLoader.LoadTypeLibrary(file);
-        Assert.That(library, Is.Not.Null);
+        await Assert.That(library).IsNotNull();
         
         var fire = library.TryGetTypeIdentifier("Fire", out var fireId);
-        Assert.That(fire, Is.True);
+        await Assert.That(fire).IsTrue();
         var grass = library.TryGetTypeIdentifier("Grass", out var grassId);
-        Assert.That(grass, Is.True);
+        await Assert.That(grass).IsTrue();
         
         var fireEffectiveness = library.GetSingleEffectiveness(fireId, grassId);
-        Assert.That(fireEffectiveness, Is.EqualTo(2.0f));
+        await Assert.That(fireEffectiveness).IsEqualTo(2.0f);
     }
 }

PkmnLib.Tests/Dynamic/SerializationTests.cs

@@ -10,11 +10,11 @@ namespace PkmnLib.Tests.Dynamic;
 public class SerializationTests
 {
     [Test]
-    public void SerializePokemon()
+    public async Task SerializePokemon()
     {
         var library = LibraryHelpers.LoadLibrary();
-        Assert.That(library.StaticLibrary.Species.TryGet("bulbasaur", out var species));
+        await Assert.That(library.StaticLibrary.Species.TryGet("bulbasaur", out var species)).IsTrue();
-        
+
         var pokemon = new PokemonImpl(library, species!, species!.GetDefaultForm(), new AbilityIndex()
         {
             Index = 0,
@@ -23,34 +23,27 @@ public class SerializationTests
         pokemon.LearnMove("tackle", MoveLearnMethod.LevelUp, 255);
 
         var data = pokemon.Serialize();
-        Assert.That(data, Is.Not.Null);
+        await Assert.That(data).IsNotNull();
-        Assert.Multiple(() =>
+        await Assert.That(data.Species).IsEqualTo("bulbasaur");
-        {
+        await Assert.That(data.Form).IsEqualTo("default");
-            Assert.That(data.Species, Is.EqualTo("bulbasaur"));
+        await Assert.That(data.Ability).IsEqualTo("overgrow");
-            Assert.That(data.Form, Is.EqualTo("default"));
+        await Assert.That(data.Level).IsEqualTo((byte)10);
-            Assert.That(data.Ability, Is.EqualTo("overgrow"));
+        await Assert.That(data.PersonalityValue).IsEqualTo((uint)1000);
-            Assert.That(data.Level, Is.EqualTo(10));
+        await Assert.That(data.Gender).IsEqualTo(Gender.Male);
-            Assert.That(data.PersonalityValue, Is.EqualTo(1000));
+        await Assert.That(data.Coloring).IsEqualTo((byte)0);
-            Assert.That(data.Gender, Is.EqualTo(Gender.Male));
+        await Assert.That(data.HeldItem).IsNull();
-            Assert.That(data.Experience, Is.EqualTo(560));
+        await Assert.That(data.CurrentHealth).IsEqualTo((ushort)29);
-            Assert.That(data.Coloring, Is.EqualTo(0));
+        await Assert.That(data.Happiness).IsEqualTo((byte)70);
-            Assert.That(data.HeldItem, Is.Null);
+
-            Assert.That(data.CurrentHealth, Is.EqualTo(29));
+        await Assert.That(data.Moves).HasCount().EqualTo(4);
-            Assert.That(data.Happiness, Is.EqualTo(70));
+        await Assert.That(data.Moves[0]).IsNotNull();
-        });
+        await Assert.That(data.Moves[0]!.MoveName).IsEqualTo("tackle");
-        
+        await Assert.That(data.Moves[0]!.LearnMethod).IsEqualTo(MoveLearnMethod.LevelUp);
-        Assert.That(data.Moves, Has.Length.EqualTo(4));
+        await Assert.That(data.Moves[0]!.CurrentPp).IsEqualTo((byte)35);
-        Assert.That(data.Moves[0], Is.Not.Null);
-        Assert.Multiple(() =>
-        {
-            Assert.That(data.Moves[0]!.MoveName, Is.EqualTo("tackle"));
-            Assert.That(data.Moves[0]!.LearnMethod, Is.EqualTo(MoveLearnMethod.LevelUp));
-            Assert.That(data.Moves[0]!.CurrentPp, Is.EqualTo(35));
-        });
     }
 
     [Test]
-    public void DeserializePokemon()
+    public async Task DeserializePokemon()
     {
         var library = LibraryHelpers.LoadLibrary();
         var data = new SerializedPokemon
@@ -85,36 +78,30 @@ public class SerializationTests
         };
 
         var pokemon = new PokemonImpl(library, data);
-        Assert.Multiple(() =>
+        await Assert.That(pokemon.Species.Name.ToString()).IsEqualTo("bulbasaur");
-        {
+        await Assert.That(pokemon.Form.Name.ToString()).IsEqualTo("default");
-            Assert.That(pokemon.Species.Name.ToString(), Is.EqualTo("bulbasaur"));
+        await Assert.That(pokemon.AbilityIndex.Index).IsEqualTo((byte)0);
-            Assert.That(pokemon.Form.Name.ToString(), Is.EqualTo("default"));
+        await Assert.That(pokemon.Level).IsEqualTo((LevelInt)10);
-            Assert.That(pokemon.AbilityIndex.Index, Is.EqualTo(0));
+        await Assert.That(pokemon.Experience).IsEqualTo((uint)560);
-            Assert.That(pokemon.Level, Is.EqualTo(10));
+        await Assert.That(pokemon.PersonalityValue).IsEqualTo((uint)1000);
-            Assert.That(pokemon.Experience, Is.EqualTo(560));
+        await Assert.That(pokemon.Gender).IsEqualTo(Gender.Male);
-            Assert.That(pokemon.PersonalityValue, Is.EqualTo(1000));
+        await Assert.That(pokemon.Coloring).IsEqualTo((byte)0);
-            Assert.That(pokemon.Gender, Is.EqualTo(Gender.Male));
+        await Assert.That(pokemon.HeldItem).IsNull();
-            Assert.That(pokemon.Coloring, Is.EqualTo(0));
+        await Assert.That(pokemon.CurrentHealth).IsEqualTo((uint)29);
-            Assert.That(pokemon.HeldItem, Is.Null);
+        await Assert.That(pokemon.Happiness).IsEqualTo((byte)70);
-            Assert.That(pokemon.CurrentHealth, Is.EqualTo(29));
+        await Assert.That(pokemon.IndividualValues).IsEqualTo(new IndividualValueStatisticSet(20, 20, 20, 20, 20, 20));
-            Assert.That(pokemon.Happiness, Is.EqualTo(70));
+        await Assert.That(pokemon.EffortValues).IsEqualTo(new EffortValueStatisticSet(0, 0, 0, 0, 0, 0));
-            Assert.That(pokemon.IndividualValues, Is.EqualTo(new IndividualValueStatisticSet(20, 20, 20, 20, 20, 20)));
+        await Assert.That(pokemon.Nature.Name.ToString()).IsEqualTo("hardy");
-            Assert.That(pokemon.EffortValues, Is.EqualTo(new EffortValueStatisticSet(0, 0, 0, 0, 0, 0)));
+        await Assert.That(pokemon.Nickname).IsEqualTo("foo");
-            Assert.That(pokemon.Nature.Name.ToString(), Is.EqualTo("hardy"));
+        await Assert.That(pokemon.Moves).HasCount().EqualTo(4);
-            Assert.That(pokemon.Nickname, Is.EqualTo("foo"));
+        await Assert.That(pokemon.Moves[0]).IsNotNull();
-        });
+        await Assert.That(pokemon.Moves[0]!.MoveData.Name.ToString()).IsEqualTo("tackle");
-        Assert.That(pokemon.Moves, Has.Count.EqualTo(4));
+        await Assert.That(pokemon.Moves[0]!.LearnMethod).IsEqualTo(MoveLearnMethod.LevelUp);
-        Assert.That(pokemon.Moves[0], Is.Not.Null);
+        await Assert.That(pokemon.Moves[0]!.CurrentPp).IsEqualTo((byte)23);
-        Assert.Multiple(() =>
-        {
-            Assert.That(pokemon.Moves[0]!.MoveData.Name.ToString(), Is.EqualTo("tackle"));
-            Assert.That(pokemon.Moves[0]!.LearnMethod, Is.EqualTo(MoveLearnMethod.LevelUp));
-            Assert.That(pokemon.Moves[0]!.CurrentPp, Is.EqualTo(23));
-        });
     }
 
     [Test]
-    public void SerializedPokemonToJson()
+    public async Task SerializedPokemonToJson()
     {
         var data = new SerializedPokemon
         {
@@ -149,34 +136,27 @@ public class SerializationTests
 
         var json = JsonSerializer.Serialize(data);
         var deserialized = JsonSerializer.Deserialize<SerializedPokemon>(json);
-        Assert.That(deserialized, Is.Not.Null);
+        await Assert.That(deserialized).IsNotNull();
-        Assert.Multiple(() =>
+        await Assert.That(deserialized!.Species).IsEqualTo("bulbasaur");
-        {
+        await Assert.That(deserialized.Form).IsEqualTo("default");
-            Assert.That(deserialized!.Species, Is.EqualTo("bulbasaur"));
+        await Assert.That(deserialized.Ability).IsEqualTo("overgrow");
-            Assert.That(deserialized!.Form, Is.EqualTo("default"));
+        await Assert.That(deserialized.Level).IsEqualTo((byte)10);
-            Assert.That(deserialized!.Ability, Is.EqualTo("overgrow"));
+        await Assert.That(deserialized.Experience).IsEqualTo((uint)560);
-            Assert.That(deserialized!.Level, Is.EqualTo(10));
+        await Assert.That(deserialized.PersonalityValue).IsEqualTo((uint)1000);
-            Assert.That(deserialized!.Experience, Is.EqualTo(560));
+        await Assert.That(deserialized.Gender).IsEqualTo(Gender.Male);
-            Assert.That(deserialized!.PersonalityValue, Is.EqualTo(1000));
+        await Assert.That(deserialized.Coloring).IsEqualTo((byte)0);
-            Assert.That(deserialized!.Gender, Is.EqualTo(Gender.Male));
+        await Assert.That(deserialized.HeldItem).IsNull();
-            Assert.That(deserialized!.Coloring, Is.EqualTo(0));
+        await Assert.That(deserialized.CurrentHealth).IsEqualTo((uint)29);
-            Assert.That(deserialized!.HeldItem, Is.Null);
+        await Assert.That(deserialized.Happiness).IsEqualTo((byte)70);
-            Assert.That(deserialized!.CurrentHealth, Is.EqualTo(29));
+        await Assert.That(deserialized.IndividualValues).IsEqualTo(new SerializedStats(20, 20, 20, 20, 20, 20));
-            Assert.That(deserialized!.Happiness, Is.EqualTo(70));
+        await Assert.That(deserialized.EffortValues).IsEqualTo(new SerializedStats(0, 0, 0, 0, 0, 0));
-            Assert.That(deserialized!.IndividualValues, Is.EqualTo(new SerializedStats(20, 20, 20, 20, 20, 20)));
+        await Assert.That(deserialized.Nature).IsEqualTo("hardy");
-            Assert.That(deserialized!.EffortValues, Is.EqualTo(new SerializedStats(0, 0, 0, 0, 0, 0)));
+        await Assert.That(deserialized.Nickname).IsEqualTo("foo");
-            Assert.That(deserialized!.Nature, Is.EqualTo("hardy"));
-            Assert.That(deserialized!.Nickname, Is.EqualTo("foo"));
-        });
-        
-        Assert.That(deserialized!.Moves, Has.Length.EqualTo(4));
-        Assert.That(deserialized!.Moves[0], Is.Not.Null);
-        Assert.Multiple(() =>
-        {
-            Assert.That(deserialized!.Moves[0]!.MoveName, Is.EqualTo("tackle"));
-            Assert.That(deserialized!.Moves[0]!.LearnMethod, Is.EqualTo(MoveLearnMethod.LevelUp));
-            Assert.That(deserialized!.Moves[0]!.CurrentPp, Is.EqualTo(23));
-        });
-    }
 
+        await Assert.That(deserialized.Moves).HasCount().EqualTo(4);
+        await Assert.That(deserialized.Moves[0]).IsNotNull();
+        await Assert.That(deserialized.Moves[0]!.MoveName).IsEqualTo("tackle");
+        await Assert.That(deserialized.Moves[0]!.LearnMethod).IsEqualTo(MoveLearnMethod.LevelUp);
+        await Assert.That(deserialized.Moves[0]!.CurrentPp).IsEqualTo((byte)23);
+    }
 }

PkmnLib.Tests/GlobalUsings.cs

@@ -1,4 +1,4 @@
-global using NUnit.Framework;
+global using TUnit;
 global using FluentAssertions;
 
 global using LevelInt = byte;

PkmnLib.Tests/Integration/IntegrationTestRunner.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Text.Json;
+using EnumerableAsyncProcessor.Extensions;
 using PkmnLib.Dynamic.Models;
 using PkmnLib.Static.Species;
 using PkmnLib.Tests.Integration.Models;
@@ -8,36 +9,34 @@ namespace PkmnLib.Tests.Integration;
 
 public class IntegrationTestRunner
 {
-    private static IEnumerable TestCases
+    public static IEnumerable<IntegrationTestModel> TestCases()
     {
-        get
+        var files = Directory.GetFiles("Integration/Tests", "*.json");
+        var serializerOptions = new JsonSerializerOptions
         {
-            var files = Directory.GetFiles("Integration/Tests", "*.json");
+            PropertyNameCaseInsensitive = true,
-            var serializerOptions = new JsonSerializerOptions
+        };
-            {
+        foreach (var file in files)
-                PropertyNameCaseInsensitive = true,
+        {
-            };
+            var json = File.ReadAllText(file);
-            foreach (var file in files)
+            var test = JsonSerializer.Deserialize<IntegrationTestModel>(json, serializerOptions)!;
-            {
+            yield return test;
-                var json = File.ReadAllText(file);
-                var test = JsonSerializer.Deserialize<IntegrationTestModel>(json, serializerOptions)!;
-                yield return new TestCaseData(test).SetName(test.Name).SetDescription(test.Description);
-            }
         }
     }
 
-    [TestCaseSource(nameof(TestCases))]
+    [Test]
-    public void RunIntegrationTest(IntegrationTestModel test)
+    [MethodDataSource(nameof(TestCases))]
+    public async Task RunIntegrationTest(IntegrationTestModel test)
     {
         var library = LibraryHelpers.LoadLibrary();
 
-        var parties = test.BattleSetup.Parties.Select(IBattleParty (x) =>
+        var parties = await test.BattleSetup.Parties.SelectAsync(async Task<IBattleParty> (x) =>
         {
             var party = new PokemonParty(6);
             for (var index = 0; index < x.Pokemon.Length; index++)
             {
                 var pokemon = x.Pokemon[index];
-                Assert.That(library.StaticLibrary.Species.TryGet(pokemon.Species, out var species), Is.True);
+                await Assert.That(library.StaticLibrary.Species.TryGet(pokemon.Species, out var species)).IsTrue();
                 var mon = new PokemonImpl(library, species!, species!.GetDefaultForm(), new AbilityIndex
                     {
                         IsHidden = false,
@@ -53,13 +52,13 @@ public class IntegrationTestRunner
             }
 
             return new BattlePartyImpl(party, x.Indices.Select(y => new ResponsibleIndex(y[0], y[1])).ToArray());
-        }).ToArray();
+        }).ProcessOneAtATime().GetResultsAsync();
         var battle = new BattleImpl(library, parties, test.BattleSetup.CanFlee, test.BattleSetup.NumberOfSides,
             test.BattleSetup.PositionsPerSide);
 
         foreach (var action in test.Actions)
         {
-            action.Execute(battle);
+            await action.Execute(battle);
         }
     }
 }

PkmnLib.Tests/Integration/LibraryHelpers.cs

@@ -9,19 +9,19 @@ public static class LibraryHelpers
 {
     public static IDynamicLibrary LoadLibrary()
     {
-        using var typesFile = File.Open("Data/Types.csv", FileMode.Open);
+        using var typesFile = File.Open("Data/Types.csv", FileMode.Open, FileAccess.Read, FileShare.Read);
         var types = TypeDataLoader.LoadTypeLibrary(typesFile);
-        using var naturesFile = File.Open("Data/Natures.csv", FileMode.Open);
+        using var naturesFile = File.Open("Data/Natures.csv", FileMode.Open, FileAccess.Read, FileShare.Read);
         var natures = NatureDataLoader.LoadNatureLibrary(naturesFile);
-        using var movesFile = File.Open("Data/Moves.json", FileMode.Open);
+        using var movesFile = File.Open("Data/Moves.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var moves = MoveDataLoader.LoadMoves(movesFile, types);
-        using var itemsFile = File.Open("Data/Items.json", FileMode.Open);
+        using var itemsFile = File.Open("Data/Items.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var items = ItemDataLoader.LoadItems(itemsFile);
-        using var abilitiesFile = File.Open("Data/Abilities.json", FileMode.Open);
+        using var abilitiesFile = File.Open("Data/Abilities.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var abilities = AbilityDataLoader.LoadAbilities(abilitiesFile);
-        using var growthRatesFile = File.Open("Data/GrowthRates.json", FileMode.Open);
+        using var growthRatesFile = File.Open("Data/GrowthRates.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var growthRates = GrowthRateDataLoader.LoadGrowthRates(growthRatesFile);
-        using var speciesFile = File.Open("Data/Pokemon.json", FileMode.Open);
+        using var speciesFile = File.Open("Data/Pokemon.json", FileMode.Open, FileAccess.Read, FileShare.Read);
         var species = SpeciesDataLoader.LoadSpecies(speciesFile, types);
 
         var staticLibrary = new StaticLibraryImpl(new LibrarySettings()

PkmnLib.Tests/Integration/Models/IntegrationTestAction.cs

@@ -14,7 +14,7 @@ namespace PkmnLib.Tests.Integration.Models;
 [JsonDerivedType(typeof(AssertAction), "assert")]
 public abstract class IntegrationTestAction
 {
-    public abstract void Execute(IBattle battle);
+    public abstract Task Execute(IBattle battle);
 }
 
 public class SetPokemonAction : IntegrationTestAction
@@ -22,10 +22,11 @@ public class SetPokemonAction : IntegrationTestAction
     public List<byte> Place { get; set; } = null!;
     public List<byte> FromParty { get; set; } = null!;
 
-    public override void Execute(IBattle battle)
+    public override Task Execute(IBattle battle)
     {
         var mon = battle.Parties[FromParty[0]].Party[FromParty[1]];
         battle.Sides[Place[0]].SwapPokemon(Place[1], mon);
+        return Task.CompletedTask;
     }
 }
 
@@ -37,14 +38,14 @@ public class SetMoveChoiceAction : IntegrationTestAction
 
 
     /// <inheritdoc />
-    public override void Execute(IBattle battle)
+    public override async Task Execute(IBattle battle)
     {
         var user = battle.Sides[Place[0]].Pokemon[Place[1]];
-        Assert.That(user, Is.Not.Null);
+        await Assert.That(user).IsNotNull();
         var move = user.Moves.First(m => m?.MoveData.Name == Move);
-        Assert.That(move, Is.Not.Null);
+        await Assert.That(move).IsNotNull();
         var res = battle.TrySetChoice(new MoveChoice(user, move, Target[0], Target[1]));
-        Assert.That(res, Is.True);
+        await Assert.That(res).IsTrue();
     }
 }
 
@@ -53,12 +54,12 @@ public class SetPassChoiceAction : IntegrationTestAction
     public List<byte> Place { get; set; } = null!;
 
     /// <inheritdoc />
-    public override void Execute(IBattle battle)
+    public override async Task Execute(IBattle battle)
     {
         var user = battle.Sides[Place[0]].Pokemon[Place[1]];
-        Assert.That(user, Is.Not.Null);
+        await Assert.That(user).IsNotNull();
         var res = battle.TrySetChoice(new PassChoice(user));
-        Assert.That(res, Is.True);
+        await Assert.That(res).IsTrue();
     }
 }
 
@@ -68,12 +69,12 @@ public class AssertAction : IntegrationTestAction
     public JsonNode Expected { get; set; } = null!;
 
     /// <inheritdoc />
-    public override void Execute(IBattle battle)
+    public override async Task Execute(IBattle battle)
     {
         var list = battle.Path(Value).ToList();
         var value = list.Count == 1 ? list[0] : list;
         
         var serialized = JsonSerializer.Serialize(value);
-        Assert.That(serialized, Is.EqualTo(Expected.ToJsonString()));
+        await Assert.That(serialized).IsEqualTo(Expected.ToJsonString());
     }
 }

PkmnLib.Tests/PkmnLib.Tests.csproj

@@ -12,11 +12,9 @@
     <ItemGroup>
         <PackageReference Include="CSPath" Version="0.0.4" />
         <PackageReference Include="FluentAssertions" Version="6.12.0"/>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
-        <PackageReference Include="NUnit" Version="3.13.3"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1"/>
-        <PackageReference Include="NUnit.Analyzers" Version="3.6.1"/>
         <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <PackageReference Include="System.Linq.Async" Version="6.0.1" />
+        <PackageReference Include="TUnit" Version="0.5.18" />
     </ItemGroup>
 
     <ItemGroup>
@@ -39,4 +37,7 @@
         </None>
     </ItemGroup>
 
+    <Target Name="WorkaroundRider117732" AfterTargets="Build" Condition="!$([MSBuild]::IsOSPlatform('Windows'))">
+        <Copy Condition="Exists('$(OutputPath)$(AssemblyName)')" SourceFiles="$(OutputPath)$(AssemblyName)" DestinationFiles="$(OutputPath)$(AssemblyName).exe"/>
+    </Target>
 </Project>

PkmnLib.Tests/Static/StringKeyTests.cs

@@ -5,44 +5,41 @@ namespace PkmnLib.Tests.Static;
 
 public class StringKeyTests
 {
-    private static IEnumerable StringKeyEqualityTestCases
+    public static IEnumerable<Func<(string, string, bool)>> StringKeyEqualityTestCases()
     {
-        get
+        yield return () => ("test", "test", true);
-        { 
+        yield return () => ("test", "test2", false);
-            yield return new TestCaseData("test", "test").Returns(true);
+        yield return () => ("test2", "test2", true);
-            yield return new TestCaseData("test", "test2").Returns(false);
+        yield return () => ("Test", "test", true);
-            yield return new TestCaseData("test2", "test2").Returns(true);
+        yield return () => ("TeSt", "tesT", true);
-            yield return new TestCaseData("Test", "test").Returns(true);
+        yield return () => ("TeSt", "tesv", false);
-            yield return new TestCaseData("TeSt", "tesT").Returns(true);
-            yield return new TestCaseData("TeSt", "tesv").Returns(false);
-        }
     }
-    
+
     [Test]
-    [TestCaseSource(nameof(StringKeyEqualityTestCases))]
+    [MethodDataSource(nameof(StringKeyEqualityTestCases))]
-    public bool StringKeyEqualityTest(string k1, string k2)
+    public async Task StringKeyEqualityTest(string k1, string k2, bool expected)
     {
         var sk1 = new StringKey(k1);
         var sk2 = new StringKey(k2);
-        return sk1 == sk2;
+        await Assert.That(sk1 == sk2).IsEqualTo(expected);
     }
-    
+
     [Test]
-    [TestCaseSource(nameof(StringKeyEqualityTestCases))]
+    [MethodDataSource(nameof(StringKeyEqualityTestCases))]
-    public bool HashCodeEqualityTest(string k1, string k2)
+    public async Task HashCodeEqualityTest(string k1, string k2, bool expected)
     {
         var sk1 = new StringKey(k1);
         var sk2 = new StringKey(k2);
-        return sk1.GetHashCode() == sk2.GetHashCode();
+        await Assert.That(sk1.GetHashCode() == sk2.GetHashCode()).IsEqualTo(expected);
     }
-    
+
     [Test]
-    [TestCaseSource(nameof(StringKeyEqualityTestCases))]
+    [MethodDataSource(nameof(StringKeyEqualityTestCases))]
-    public bool HashSetEqualityTest(string k1, string k2)
+    public async Task HashSetEqualityTest(string k1, string k2, bool expected)
     {
         var sk1 = new StringKey(k1);
         var sk2 = new StringKey(k2);
         var hs = new HashSet<StringKey> { sk1 };
-        return hs.Contains(sk2);
+        await Assert.That(hs.Contains(sk2)).IsEqualTo(expected);
     }
 }

Plugins/PkmnLib.Plugin.Gen7.Tests/BattleStatCalculatorTests.cs

@@ -3,8 +3,7 @@ namespace PkmnLib.Plugin.Gen7.Tests;
 public class BattleStatCalculatorTests
 {
     [Test]
-    public void Test1()
+    public async Task Test1()
     {
-        Assert.Pass();
     }
 }

Plugins/PkmnLib.Plugin.Gen7.Tests/DamageCalculatorTests.cs

@@ -21,7 +21,7 @@ public class DamageCalculatorTests
     /// That means Ice Fang will do between 168 and 196 HP damage, depending on luck. 
     /// </para>
     [Test]
-    public void BulbapediaExampleDamageTest()
+    public async Task BulbapediaExampleDamageTest()
     {
         var attacker = new Mock<IPokemon>();
         // Imagine a level 75 Glaceon
@@ -58,6 +58,6 @@ public class DamageCalculatorTests
         var damage = damageCalculator.GetDamage(executingMove.Object, defender.Object, 0, hit.Object);
         // That means Ice Fang will do between 168 and 196 HP damage, depending on luck.
         // Note that we are testing deterministic damage, so we expect the maximum damage.
-        Assert.That(damage, Is.EqualTo(196));
+        await Assert.That(damage).IsEqualTo((uint)196);
     }
 }

Plugins/PkmnLib.Plugin.Gen7.Tests/GlobalUsings.cs

@@ -1,2 +1,2 @@
-global using NUnit.Framework;
+global using TUnit;
 global using Moq;

Plugins/PkmnLib.Plugin.Gen7.Tests/PkmnLib.Plugin.Gen7.Tests.csproj

@@ -10,12 +10,9 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
         <PackageReference Include="Moq" Version="4.20.70" />
-        <PackageReference Include="NUnit" Version="3.13.3"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1"/>
-        <PackageReference Include="NUnit.Analyzers" Version="3.6.1"/>
         <PackageReference Include="coverlet.collector" Version="6.0.0"/>
+        <PackageReference Include="TUnit" Version="0.5.18" />
     </ItemGroup>
 
     <ItemGroup>

Plugins/PkmnLib.Plugin.Gen7.Tests/Scripts/Moves/AcrobaticsTests.cs

@@ -7,7 +7,7 @@ namespace PkmnLib.Plugin.Gen7.Tests.Scripts.Moves;
 public class AcrobaticsTests
 {
     [Test]
-    public void ChangeBasePower_UserNotHoldingItem_BasePowerDoubles()
+    public async Task ChangeBasePower_UserNotHoldingItem_BasePowerDoubles()
     {
         // Arrange
         var move = new Mock<IExecutingMove>();
@@ -21,11 +21,11 @@ public class AcrobaticsTests
         acrobatics.ChangeBasePower(move.Object, target.Object, 0, ref basePower);
 
         // Assert
-        Assert.That(basePower, Is.EqualTo(20));
+        await Assert.That(basePower).IsEqualTo((byte)20);
     }
     
     [Test]
-    public void ChangeBasePower_UserHoldingItem_BasePowerUnchanged()
+    public async Task ChangeBasePower_UserHoldingItem_BasePowerUnchanged()
     {
         // Arrange
         var move = new Mock<IExecutingMove>();
@@ -39,11 +39,11 @@ public class AcrobaticsTests
         acrobatics.ChangeBasePower(move.Object, target.Object, 0, ref basePower);
 
         // Assert
-        Assert.That(basePower, Is.EqualTo(10));
+        await Assert.That(basePower).IsEqualTo((byte)10);
     }
 
     [Test]
-    public void ChangeBasePower_UserNotHoldingItem_NoOverflow()
+    public async Task ChangeBasePower_UserNotHoldingItem_NoOverflow()
     {
         // Arrange
         var move = new Mock<IExecutingMove>();
@@ -57,7 +57,7 @@ public class AcrobaticsTests
         acrobatics.ChangeBasePower(move.Object, target.Object, 0, ref basePower);
 
         // Assert
-        Assert.That(basePower, Is.EqualTo(byte.MaxValue));
+        await Assert.That(basePower).IsEqualTo(byte.MaxValue);
     }
     
 }