106 lines
4.0 KiB
C#
106 lines
4.0 KiB
C#
using System.Text.Json;
|
|
|
|
using MultiversalDiplomacy.Adjudicate;
|
|
using MultiversalDiplomacy.Model;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MultiversalDiplomacyTests;
|
|
|
|
public class SerializationTest
|
|
{
|
|
private JsonSerializerOptions Options = new() {
|
|
WriteIndented = true,
|
|
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
|
|
};
|
|
|
|
[Test]
|
|
public void SerializeRoundTrip_NewGame()
|
|
{
|
|
World world = World.WithStandardMap();
|
|
string serialized = JsonSerializer.Serialize(world, Options);
|
|
World? deserialized = JsonSerializer.Deserialize<World>(serialized, Options);
|
|
|
|
Assert.That(deserialized, Is.Not.Null, "Failed to deserialize");
|
|
Assert.That(deserialized!.Map, Is.Not.Null, "Failed to deserialize map");
|
|
Assert.That(deserialized!.Seasons, Is.Not.Null, "Failed to deserialize seasons");
|
|
Assert.That(deserialized!.Units, Is.Not.Null, "Failed to deserialize units");
|
|
Assert.That(deserialized!.RetreatingUnits, Is.Not.Null, "Failed to deserialize retreats");
|
|
Assert.That(deserialized!.OrderHistory, Is.Not.Null, "Failed to deserialize history");
|
|
Assert.That(deserialized!.Timelines, Is.Not.Null, "Failed to deserialize timelines");
|
|
Assert.That(deserialized!.Options, Is.Not.Null, "Failed to deserialize options");
|
|
Assert.That(deserialized.Timelines.nextTimeline, Is.EqualTo(world.Timelines.nextTimeline));
|
|
|
|
JsonElement document = JsonSerializer.SerializeToDocument(world, Options).RootElement;
|
|
Assert.That(
|
|
document.EnumerateObject().Select(prop => prop.Name),
|
|
Is.EquivalentTo(new List<string> {
|
|
"mapType",
|
|
"seasons",
|
|
"units",
|
|
"retreatingUnits",
|
|
"orderHistory",
|
|
"options",
|
|
"timelines",
|
|
}));
|
|
}
|
|
|
|
[Test]
|
|
public void SerializeRoundTrip_MDATC_3_A_2()
|
|
{
|
|
// Set up MDATC 3.A.2
|
|
TestCaseBuilder setup = new(World.WithStandardMap(), MovementPhaseAdjudicator.Instance);
|
|
setup[("a", 0)]
|
|
.GetReference(out Season s0)
|
|
["Germany"]
|
|
.Army("Mun").MovesTo("Tyr").GetReference(out var mun0)
|
|
["Austria"]
|
|
.Army("Tyr").Holds().GetReference(out var tyr0);
|
|
|
|
setup.ValidateOrders();
|
|
Assert.That(mun0, Is.Valid);
|
|
Assert.That(tyr0, Is.Valid);
|
|
setup.AdjudicateOrders();
|
|
Assert.That(mun0, Is.Repelled);
|
|
Assert.That(tyr0, Is.NotDislodged);
|
|
setup.UpdateWorld();
|
|
|
|
// Serialize the world
|
|
string serialized = JsonSerializer.Serialize(setup.World, Options);
|
|
|
|
// Deserialize the world
|
|
Console.WriteLine(serialized);
|
|
World reserialized = JsonSerializer.Deserialize<World>(serialized, Options)
|
|
?? throw new AssertionException("Failed to reserialize world");
|
|
|
|
// Resume the test case
|
|
setup = new(reserialized, MovementPhaseAdjudicator.Instance);
|
|
setup[("a", 1)]
|
|
["Germany"]
|
|
.Army("Mun").Supports.Army("Mun", season: reserialized.GetSeason("a0")).MoveTo("Tyr").GetReference(out var mun1)
|
|
["Austria"]
|
|
.Army("Tyr").Holds();
|
|
|
|
setup.ValidateOrders();
|
|
Assert.That(mun1, Is.Valid);
|
|
setup.AdjudicateOrders();
|
|
Assert.That(mun1, Is.NotCut);
|
|
Assert.That(mun0, Is.Victorious);
|
|
Assert.That(tyr0, Is.Dislodged);
|
|
|
|
// Confirm that an alternate future is created.
|
|
World world = setup.UpdateWorld();
|
|
Season fork = world.GetSeason("b1");
|
|
Unit tyr1 = world.GetUnitAt("Tyr", fork);
|
|
Assert.That(
|
|
tyr1.Past,
|
|
Is.EqualTo(mun0.Order.Unit.Designation),
|
|
"Expected A Mun a0 to advance to Tyr b1");
|
|
Assert.That(
|
|
world.RetreatingUnits.Count,
|
|
Is.EqualTo(1),
|
|
"Expected A Tyr a0 to be in retreat");
|
|
Assert.That(world.RetreatingUnits.First().Unit, Is.EqualTo(tyr0.Order.Unit));
|
|
}
|
|
}
|