Build 0.18.0.0

2022-05-13 00:55:52 +09:00
parent 15d18e6ff6
commit 7547a9b78a
218 changed files with 3881 additions and 2192 deletions
@@ -0,0 +1,205 @@
+#nullable enable
+
+using System;
+using Barotrauma;
+using Barotrauma.Networking;
+using FluentAssertions;
+using FsCheck;
+using Microsoft.Xna.Framework;
+using Xunit;
+
+namespace TestProject
+{
+    // ReSharper disable UnusedMember.Local NotAccessedField.Local UnusedMember.Global
+    public class INetSerializableStructTests
+    {
+        private class CustomGenerators
+        {
+            // no null strings!!!
+            public static Arbitrary<string> StringGeneratorOverride() => Arb.Default.String().Generator.Where(s => s != null).ToArbitrary();
+        }
+
+        public INetSerializableStructTests()
+        {
+            Arb.Register<TestProject.CustomGenerators>();
+            Arb.Register<CustomGenerators>();
+        }
+
+        [Fact]
+        public void TestOptional()
+        {
+            Prop.ForAll<Option<Int32>>(SerializeDeserialize).QuickCheckThrowOnFailure();
+            Prop.ForAll<Option<Byte[]>>(SerializeDeserialize).QuickCheckThrowOnFailure();
+            Prop.ForAll<Option<String>>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestNested()
+        {
+            Prop.ForAll<String, Int32, Boolean>((arg1, arg2, arg3) => SerializeDeserializeNullableTuple(arg1, new TupleNullableStruct<int, bool> { One = arg2, Two = arg3 })).QuickCheckThrowOnFailure();
+            Prop.ForAll<Byte, UInt64>((arg1, arg2) => SerializeDeserialize(new TupleNullableStruct<byte, ulong> { One = arg1, Two = arg2 })).QuickCheckThrowOnFailure();
+            Prop.ForAll<Int16, String>((arg1, arg2) => SerializeDeserialize(new TupleNullableStruct<short, string> { One = arg1, Two = arg2 })).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestVector2()
+        {
+            Prop.ForAll<Vector2>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestColor()
+        {
+            Prop.ForAll<Color>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestEnum()
+        {
+            Prop.ForAll<EnumTest>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestArray()
+        {
+            Prop.ForAll<Int32[]>(SerializeDeserialize).QuickCheckThrowOnFailure();
+            Prop.ForAll<Boolean[]>(SerializeDeserialize).QuickCheckThrowOnFailure();
+            Prop.ForAll<String[]>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestNullable()
+        {
+            Prop.ForAll<Int32?, String?>(SerializeDeserializeNullableTuple).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestBoolean()
+        {
+            Prop.ForAll<Boolean>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestByte()
+        {
+            Prop.ForAll<Byte>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestUInt16()
+        {
+            Prop.ForAll<UInt16>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestInt16()
+        {
+            Prop.ForAll<Int16>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestUInt32()
+        {
+            Prop.ForAll<UInt32>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestInt32()
+        {
+            Prop.ForAll<Int32>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestUInt64()
+        {
+            Prop.ForAll<UInt64>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestInt64()
+        {
+            Prop.ForAll<Int64>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestSingle()
+        {
+            Prop.ForAll<Single>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestDouble()
+        {
+            Prop.ForAll<Double>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        [Fact]
+        public void TestString()
+        {
+            Prop.ForAll<String>(SerializeDeserialize).QuickCheckThrowOnFailure();
+        }
+
+        private enum EnumTest
+        {
+            One = 1,
+            Two = 2,
+            Three = 3,
+            Thousand = 1000
+        }
+
+        private struct TestStruct<T> : INetSerializableStruct
+        {
+            [NetworkSerialize]
+            public T Value;
+
+            public T NotSerializedValue;
+
+            public T NotSerializedFunction() => throw new NotImplementedException();
+        }
+
+        private struct TupleNullableStruct<T, U> : INetSerializableStruct
+        {
+            [NetworkSerialize]
+            public T? One;
+
+            [NetworkSerialize]
+            public U? Two;
+
+            public (T, U) NotSerializedValue;
+            public (T, U) NotSerializedFunction() => throw new NotImplementedException();
+        }
+
+        private static void SerializeDeserialize<T>(T arg) where T : notnull
+        {
+            ReadWriteMessage msg = new ReadWriteMessage();
+            TestStruct<T> writeStruct = new TestStruct<T>
+            {
+                Value = arg
+            };
+
+            ((INetSerializableStruct)writeStruct).Write(msg);
+            msg.BitPosition = 0;
+
+            TestStruct<T> readStruct = INetSerializableStruct.Read<TestStruct<T>>(msg);
+
+            readStruct.Should().BeEquivalentTo(writeStruct, options => options.ComparingByMembers<TestStruct<T>>());
+        }
+
+        private static void SerializeDeserializeNullableTuple<T, U>(T arg1, U arg2)
+        {
+            ReadWriteMessage msg = new ReadWriteMessage();
+            TupleNullableStruct<T, U> writeStruct = new TupleNullableStruct<T, U>
+            {
+                One = arg1,
+                Two = arg2
+            };
+
+            ((INetSerializableStruct)writeStruct).Write(msg);
+            msg.BitPosition = 0;
+
+            TupleNullableStruct<T, U> readStruct = INetSerializableStruct.Read<TupleNullableStruct<T, U>>(msg);
+
+            readStruct.Should().BeEquivalentTo(writeStruct, options => options.ComparingByMembers<TupleNullableStruct<T, U>>());
+        }
+    }
+}