a6c9c36b68
* Give .props files 2-space indents.
* Move to Central Package Management.
Allows us to store NuGet package versions all in one place. Yay!
* Update NuGet packages and fix code for changes.
Notable:
Changes to ILVerify.
Npgsql doesn't need hacks for inet anymore, now we need hacks to make the old code work with this new reality.
NUnit's analyzers are already complaining and I didn't even update it to 4.x yet.
TerraFX changed to GetLastSystemError so error handling had to be changed.
Buncha APIs have more NRT annotations.
* Remove dotnet-eng NuGet package source.
I genuinely don't know what this was for, and Central Package Management starts throwing warnings about it, so YEET.
* Remove Robust.Physics project.
Never used.
* Remove erroneous NVorbis reference.
Should be VorbisPizza and otherwise wasn't used.
* Sandbox fixes
* Remove unused unit test package references.
Castle.Core and NUnit.ConsoleRunner.
* Update NUnit to 4.0.1
This requires replacing all the old assertion methods because they removed them 🥲
* Oh so that's what dotnet-eng was used for. Yeah ok that makes sense.
* Add Robust.Analyzers.Test
* Update submodule
* commit to re-run CI
83 lines
3.1 KiB
C#
83 lines
3.1 KiB
C#
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Robust.Shared.Reflection;
|
|
using Robust.Shared.Serialization.Manager;
|
|
using Robust.Shared.Serialization.Manager.Attributes;
|
|
using Robust.Shared.Serialization.Markdown.Value;
|
|
|
|
namespace Content.IntegrationTests.Tests.Serialization;
|
|
|
|
[TestFixture]
|
|
public sealed partial class SerializationTest
|
|
{
|
|
/// <summary>
|
|
/// Check that serializing generic enums works as intended. This should really be in engine, but engine
|
|
/// integrations tests block reflection and I am lazy..
|
|
/// </summary>
|
|
[Test]
|
|
public async Task SerializeGenericEnums()
|
|
{
|
|
await using var pair = await PoolManager.GetServerClient();
|
|
var server = pair.Server;
|
|
var seriMan = server.ResolveDependency<ISerializationManager>();
|
|
var refMan = server.ResolveDependency<IReflectionManager>();
|
|
|
|
Enum value = TestEnum.Bb;
|
|
|
|
var node = seriMan.WriteValue(value, notNullableOverride:true);
|
|
var valueNode = node as ValueDataNode;
|
|
Assert.That(valueNode, Is.Not.Null);
|
|
|
|
var expected = refMan.GetEnumReference(value);
|
|
Assert.That(valueNode!.Value, Is.EqualTo(expected));
|
|
|
|
var errors = seriMan.ValidateNode<Enum>(valueNode).GetErrors();
|
|
Assert.That(errors.Any(), Is.False);
|
|
|
|
var deserialized = seriMan.Read<Enum>(node, notNullableOverride:true);
|
|
Assert.That(deserialized, Is.EqualTo(value));
|
|
|
|
// Repeat test with enums in a data definitions.
|
|
var data = new TestData
|
|
{
|
|
Value = TestEnum.Cc,
|
|
Sequence = new() {TestEnum.Dd, TestEnum.Aa}
|
|
};
|
|
|
|
node = seriMan.WriteValue(data, notNullableOverride:true);
|
|
|
|
errors = seriMan.ValidateNode<TestData>(node).GetErrors();
|
|
Assert.That(errors.Any(), Is.False);
|
|
|
|
var deserializedData = seriMan.Read<TestData>(node, notNullableOverride:false);
|
|
|
|
Assert.That(deserializedData.Value, Is.EqualTo(data.Value));
|
|
Assert.That(deserializedData.Sequence.Count, Is.EqualTo(data.Sequence.Count));
|
|
Assert.That(deserializedData.Sequence[0], Is.EqualTo(data.Sequence[0]));
|
|
Assert.That(deserializedData.Sequence[1], Is.EqualTo(data.Sequence[1]));
|
|
|
|
// Check that Generic & non-generic serializers are incompativle.
|
|
Enum genericValue = TestEnum.Bb;
|
|
TestEnum typedValue = TestEnum.Bb;
|
|
|
|
var genericNode = seriMan.WriteValue(genericValue, notNullableOverride:true);
|
|
var typedNode = seriMan.WriteValue(typedValue);
|
|
|
|
Assert.That(seriMan.ValidateNode<Enum>(genericNode).GetErrors().Any(), Is.False);
|
|
Assert.That(seriMan.ValidateNode<TestEnum>(genericNode).GetErrors().Any(), Is.True);
|
|
Assert.That(seriMan.ValidateNode<Enum>(typedNode).GetErrors().Any(), Is.True);
|
|
Assert.That(seriMan.ValidateNode<TestEnum>(typedNode).GetErrors().Any(), Is.False);
|
|
|
|
await pair.CleanReturnAsync();
|
|
}
|
|
|
|
private enum TestEnum : byte { Aa, Bb, Cc, Dd }
|
|
|
|
[DataDefinition]
|
|
private sealed partial class TestData
|
|
{
|
|
[DataField("value")] public Enum Value = default!;
|
|
[DataField("sequence")] public List<Enum> Sequence = default!;
|
|
}
|
|
}
|