Deukhoofd
/
PkmnLib.NET
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Migrate to TUnit for unit tests

This commit is contained in:
Deukhoofd 2024-12-27 14:30:22 +01:00
parent 5b518df24a
commit 853d6dd1cb
Signed by: Deukhoofd
GPG Key ID: F63E044490819F6F
19 changed files with 158 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
PkmnLib.Tests/Dataloader/AbilityDataLoaderTests.cs
View File

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

6
PkmnLib.Tests/Dataloader/GrowthRateDataLoaderTests.cs
View File

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

4
PkmnLib.Tests/Dataloader/ItemDataLoaderTests.cs
View File

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

4
PkmnLib.Tests/Dataloader/MoveDataLoaderTests.cs
View File

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

6
PkmnLib.Tests/Dataloader/NatureDataloaderTests.cs
View File

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

6
PkmnLib.Tests/Dataloader/SpeciesDataloaderTests.cs
View File

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

12
PkmnLib.Tests/Dataloader/TypeDataloaderTests.cs
View File

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

148
PkmnLib.Tests/Dynamic/SerializationTests.cs
View File

@ -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);
Assert.Multiple(() =>
{
Assert.That(data.Species, Is.EqualTo("bulbasaur"));
Assert.That(data.Form, Is.EqualTo("default"));
Assert.That(data.Ability, Is.EqualTo("overgrow"));
Assert.That(data.Level, Is.EqualTo(10));
Assert.That(data.PersonalityValue, Is.EqualTo(1000));
Assert.That(data.Gender, Is.EqualTo(Gender.Male));
Assert.That(data.Experience, Is.EqualTo(560));
Assert.That(data.Coloring, Is.EqualTo(0));
Assert.That(data.HeldItem, Is.Null);
Assert.That(data.CurrentHealth, Is.EqualTo(29));
Assert.That(data.Happiness, Is.EqualTo(70));
});
Assert.That(data.Moves, Has.Length.EqualTo(4));
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));
});
await Assert.That(data).IsNotNull();
await Assert.That(data.Species).IsEqualTo("bulbasaur");
await Assert.That(data.Form).IsEqualTo("default");
await Assert.That(data.Ability).IsEqualTo("overgrow");
await Assert.That(data.Level).IsEqualTo((byte)10);
await Assert.That(data.PersonalityValue).IsEqualTo((uint)1000);
await Assert.That(data.Gender).IsEqualTo(Gender.Male);
await Assert.That(data.Coloring).IsEqualTo((byte)0);
await Assert.That(data.HeldItem).IsNull();
await Assert.That(data.CurrentHealth).IsEqualTo((ushort)29);
await Assert.That(data.Happiness).IsEqualTo((byte)70);
await Assert.That(data.Moves).HasCount().EqualTo(4);
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);
await Assert.That(data.Moves[0]!.CurrentPp).IsEqualTo((byte)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(() =>
{
Assert.That(pokemon.Species.Name.ToString(), Is.EqualTo("bulbasaur"));
Assert.That(pokemon.Form.Name.ToString(), Is.EqualTo("default"));
Assert.That(pokemon.AbilityIndex.Index, Is.EqualTo(0));
Assert.That(pokemon.Level, Is.EqualTo(10));
Assert.That(pokemon.Experience, Is.EqualTo(560));
Assert.That(pokemon.PersonalityValue, Is.EqualTo(1000));
Assert.That(pokemon.Gender, Is.EqualTo(Gender.Male));
Assert.That(pokemon.Coloring, Is.EqualTo(0));
Assert.That(pokemon.HeldItem, Is.Null);
Assert.That(pokemon.CurrentHealth, Is.EqualTo(29));
Assert.That(pokemon.Happiness, Is.EqualTo(70));
Assert.That(pokemon.IndividualValues, Is.EqualTo(new IndividualValueStatisticSet(20, 20, 20, 20, 20, 20)));
Assert.That(pokemon.EffortValues, Is.EqualTo(new EffortValueStatisticSet(0, 0, 0, 0, 0, 0)));
Assert.That(pokemon.Nature.Name.ToString(), Is.EqualTo("hardy"));
Assert.That(pokemon.Nickname, Is.EqualTo("foo"));
});
Assert.That(pokemon.Moves, Has.Count.EqualTo(4));
Assert.That(pokemon.Moves[0], Is.Not.Null);
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));
});
await Assert.That(pokemon.Species.Name.ToString()).IsEqualTo("bulbasaur");
await Assert.That(pokemon.Form.Name.ToString()).IsEqualTo("default");
await Assert.That(pokemon.AbilityIndex.Index).IsEqualTo((byte)0);
await Assert.That(pokemon.Level).IsEqualTo((LevelInt)10);
await Assert.That(pokemon.Experience).IsEqualTo((uint)560);
await Assert.That(pokemon.PersonalityValue).IsEqualTo((uint)1000);
await Assert.That(pokemon.Gender).IsEqualTo(Gender.Male);
await Assert.That(pokemon.Coloring).IsEqualTo((byte)0);
await Assert.That(pokemon.HeldItem).IsNull();
await Assert.That(pokemon.CurrentHealth).IsEqualTo((uint)29);
await Assert.That(pokemon.Happiness).IsEqualTo((byte)70);
await Assert.That(pokemon.IndividualValues).IsEqualTo(new IndividualValueStatisticSet(20, 20, 20, 20, 20, 20));
await Assert.That(pokemon.EffortValues).IsEqualTo(new EffortValueStatisticSet(0, 0, 0, 0, 0, 0));
await Assert.That(pokemon.Nature.Name.ToString()).IsEqualTo("hardy");
await Assert.That(pokemon.Nickname).IsEqualTo("foo");
await Assert.That(pokemon.Moves).HasCount().EqualTo(4);
await Assert.That(pokemon.Moves[0]).IsNotNull();
await Assert.That(pokemon.Moves[0]!.MoveData.Name.ToString()).IsEqualTo("tackle");
await Assert.That(pokemon.Moves[0]!.LearnMethod).IsEqualTo(MoveLearnMethod.LevelUp);
await Assert.That(pokemon.Moves[0]!.CurrentPp).IsEqualTo((byte)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);
Assert.Multiple(() =>
{
Assert.That(deserialized!.Species, Is.EqualTo("bulbasaur"));
Assert.That(deserialized!.Form, Is.EqualTo("default"));
Assert.That(deserialized!.Ability, Is.EqualTo("overgrow"));
Assert.That(deserialized!.Level, Is.EqualTo(10));
Assert.That(deserialized!.Experience, Is.EqualTo(560));
Assert.That(deserialized!.PersonalityValue, Is.EqualTo(1000));
Assert.That(deserialized!.Gender, Is.EqualTo(Gender.Male));
Assert.That(deserialized!.Coloring, Is.EqualTo(0));
Assert.That(deserialized!.HeldItem, Is.Null);
Assert.That(deserialized!.CurrentHealth, Is.EqualTo(29));
Assert.That(deserialized!.Happiness, Is.EqualTo(70));
Assert.That(deserialized!.IndividualValues, Is.EqualTo(new SerializedStats(20, 20, 20, 20, 20, 20)));
Assert.That(deserialized!.EffortValues, Is.EqualTo(new SerializedStats(0, 0, 0, 0, 0, 0)));
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).IsNotNull();
await Assert.That(deserialized!.Species).IsEqualTo("bulbasaur");
await Assert.That(deserialized.Form).IsEqualTo("default");
await Assert.That(deserialized.Ability).IsEqualTo("overgrow");
await Assert.That(deserialized.Level).IsEqualTo((byte)10);
await Assert.That(deserialized.Experience).IsEqualTo((uint)560);
await Assert.That(deserialized.PersonalityValue).IsEqualTo((uint)1000);
await Assert.That(deserialized.Gender).IsEqualTo(Gender.Male);
await Assert.That(deserialized.Coloring).IsEqualTo((byte)0);
await Assert.That(deserialized.HeldItem).IsNull();
await Assert.That(deserialized.CurrentHealth).IsEqualTo((uint)29);
await Assert.That(deserialized.Happiness).IsEqualTo((byte)70);
await Assert.That(deserialized.IndividualValues).IsEqualTo(new SerializedStats(20, 20, 20, 20, 20, 20));
await Assert.That(deserialized.EffortValues).IsEqualTo(new SerializedStats(0, 0, 0, 0, 0, 0));
await Assert.That(deserialized.Nature).IsEqualTo("hardy");
await Assert.That(deserialized.Nickname).IsEqualTo("foo");
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);
}
}

2
PkmnLib.Tests/GlobalUsings.cs
View File

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

37
PkmnLib.Tests/Integration/IntegrationTestRunner.cs
View File

@ -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");
var serializerOptions = new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
};
foreach (var file in files)
{
var json = File.ReadAllText(file);
var test = JsonSerializer.Deserialize<IntegrationTestModel>(json, serializerOptions)!;
yield return new TestCaseData(test).SetName(test.Name).SetDescription(test.Description);
}
PropertyNameCaseInsensitive = true,
};
foreach (var file in files)
{
var json = File.ReadAllText(file);
var test = JsonSerializer.Deserialize<IntegrationTestModel>(json, serializerOptions)!;
yield return test;
}
}
[TestCaseSource(nameof(TestCases))]
public void RunIntegrationTest(IntegrationTestModel test)
[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);
}
}
}

14
PkmnLib.Tests/Integration/LibraryHelpers.cs
View File

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

23
PkmnLib.Tests/Integration/Models/IntegrationTestAction.cs
View File

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

9
PkmnLib.Tests/PkmnLib.Tests.csproj
View File

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

41
PkmnLib.Tests/Static/StringKeyTests.cs
View File

@ -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 new TestCaseData("test", "test").Returns(true);
yield return new TestCaseData("test", "test2").Returns(false);
yield return new TestCaseData("test2", "test2").Returns(true);
yield return new TestCaseData("Test", "test").Returns(true);
yield return new TestCaseData("TeSt", "tesT").Returns(true);
yield return new TestCaseData("TeSt", "tesv").Returns(false);
}
yield return () => ("test", "test", true);
yield return () => ("test", "test2", false);
yield return () => ("test2", "test2", true);
yield return () => ("Test", "test", true);
yield return () => ("TeSt", "tesT", true);
yield return () => ("TeSt", "tesv", false);
}
[Test]
[TestCaseSource(nameof(StringKeyEqualityTestCases))]
public bool StringKeyEqualityTest(string k1, string k2)
[MethodDataSource(nameof(StringKeyEqualityTestCases))]
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))]
public bool HashCodeEqualityTest(string k1, string k2)
[MethodDataSource(nameof(StringKeyEqualityTestCases))]
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))]
public bool HashSetEqualityTest(string k1, string k2)
[MethodDataSource(nameof(StringKeyEqualityTestCases))]
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);
}
}

3
Plugins/PkmnLib.Plugin.Gen7.Tests/BattleStatCalculatorTests.cs
View File

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

4
Plugins/PkmnLib.Plugin.Gen7.Tests/DamageCalculatorTests.cs
View File

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

2
Plugins/PkmnLib.Plugin.Gen7.Tests/GlobalUsings.cs
View File

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

5
Plugins/PkmnLib.Plugin.Gen7.Tests/PkmnLib.Plugin.Gen7.Tests.csproj
View File

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

12
Plugins/PkmnLib.Plugin.Gen7.Tests/Scripts/Moves/AcrobaticsTests.cs
View File

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