From fd78b79db052e6468988b1e910a46ac3dd59a8f7 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sat, 2 Mar 2024 22:21:53 -0800 Subject: [PATCH 01/14] Convert E2E tests to use MSTest and try out native AOT test harness --- src/Directory.Packages.props | 3 + src/NuGet.config | 18 + .../FlatBufferSerializerNonGenericTests.cs | 55 +-- .../ClassLib/FlatBufferVectorOfUnionTests.cs | 40 +-- .../ClassLib/FlatBufferVectorTests.cs | 121 +++---- .../GeneratedSerializerWrapperTests.cs | 11 +- .../ClassLib/IndexedVectorTests.cs | 128 ++++--- .../ClassLib/NonScalarVectorTests.cs | 29 +- .../ClassLib/SerializerConfigurationTests.cs | 75 ++-- .../ClassLib/SpanComparerTests.cs | 73 ++-- .../ClassLib/VTableTests.cs | 55 +-- .../CopyConstructors/CopyConstructorTests.cs | 159 ++++----- .../DefaultValues/DefaultValuesTests.cs | 29 +- .../DepthLimit/DepthLimitTests.cs | 19 +- .../DeserializationOptionClassData.cs | 23 +- .../Documentation/DocumentationTestCases.cs | 77 ++--- .../FileIdentifier/FileIdentifierTests.cs | 9 +- .../FlatSharpEndToEndTests.csproj | 27 +- .../GlobalNamespaceBlocker.cs | 6 +- .../FlatSharpEndToEndTests/GlobalUsings.cs | 2 +- .../Grpc/EchoServiceTestCases.cs | 93 ++--- src/Tests/FlatSharpEndToEndTests/Helpers.cs | 119 ++++--- .../IO/InputBufferTests.cs | 75 ++-- .../MetadataAttributeTests.cs | 93 +++-- .../Oracle/AlignmentTests.cs | 91 ++--- .../Oracle/OracleDeserializeTests.cs | 191 +++++------ .../Oracle/OracleSerializeTests.cs | 241 ++++++------- .../PartialMethods/PartialMethodsTests.cs | 17 +- src/Tests/FlatSharpEndToEndTests/Program.cs | 41 +++ .../RawData/RawDataSharedStringTests.cs | 25 +- .../RawData/RawDataStringTests.cs | 17 +- .../RawData/RawDataTableTests.cs | 171 +++++----- .../Required/Required.cs | 33 +- .../SetterTests/AccessModifiers.cs | 47 +-- .../DeserailizationOptionsTests.cs | 153 ++++----- .../TableMembers/TableMembersTests.cs | 115 +++---- .../Unions/UnionsTestCases.cs | 49 +-- .../ValueStructs/ValueStructTests.cs | 195 +++++------ .../Vectors/Sorted/IndexedVectorTests.cs | 81 ++--- .../Vectors/Sorted/SortedVectorTests.cs | 151 ++++---- .../Vectors/Standard/StandardVectorTests.cs | 321 +++++++++--------- 41 files changed, 1680 insertions(+), 1598 deletions(-) create mode 100644 src/NuGet.config create mode 100644 src/Tests/FlatSharpEndToEndTests/Program.cs diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props index 422bb551..cdbc8314 100644 --- a/src/Directory.Packages.props +++ b/src/Directory.Packages.props @@ -16,6 +16,9 @@ + + + diff --git a/src/NuGet.config b/src/NuGet.config new file mode 100644 index 00000000..5430a707 --- /dev/null +++ b/src/NuGet.config @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + + + diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferSerializerNonGenericTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferSerializerNonGenericTests.cs index 4014fc6a..8cc9d4de 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferSerializerNonGenericTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferSerializerNonGenericTests.cs @@ -16,61 +16,62 @@ namespace FlatSharpEndToEndTests.ClassLib.FlatBufferSerializerNonGenericTests; +[TestClass] public class FlatBufferSerializerNonGenericTests { - [Fact] + [TestMethod] public void NonGenericSerializer_FromInstance() { ISerializer serializer = (ISerializer)SomeTable.Serializer.WithSettings(s => s.UseLazyDeserialization()); - Assert.IsAssignableFrom>(serializer); - Assert.Equal(typeof(SomeTable), serializer.RootType); + Assert.IsInstanceOfType>(serializer); + Assert.AreEqual(typeof(SomeTable), serializer.RootType); - Assert.True(serializer.GetMaxSize(new SomeTable()) > 0); - Assert.Throws(() => serializer.GetMaxSize(null)); - Assert.Throws(() => serializer.GetMaxSize(new SomeOtherTable())); + Assert.IsTrue(serializer.GetMaxSize(new SomeTable()) > 0); + Assert.ThrowsException(() => serializer.GetMaxSize(null)); + Assert.ThrowsException(() => serializer.GetMaxSize(new SomeOtherTable())); #if NET6_0_OR_GREATER { var bw = new ArrayBufferWriter(); - Assert.Throws(() => serializer.Write(bw, null)); - Assert.Throws(() => serializer.Write(bw, new SomeOtherTable())); + Assert.ThrowsException(() => serializer.Write(bw, null)); + Assert.ThrowsException(() => serializer.Write(bw, new SomeOtherTable())); int written = serializer.Write(bw, new SomeTable { A = 3 }); - Assert.True(written > 0); - Assert.Equal(written, bw.WrittenCount); + Assert.IsTrue(written > 0); + Assert.AreEqual(written, bw.WrittenCount); object parsed = serializer.Parse(bw.WrittenMemory); - Assert.True(typeof(SomeTable).IsAssignableFrom(parsed.GetType())); - Assert.NotEqual(typeof(SomeTable), parsed.GetType()); - Assert.IsAssignableFrom(parsed); + Assert.IsTrue(typeof(SomeTable).IsAssignableFrom(parsed.GetType())); + Assert.AreNotEqual(typeof(SomeTable), parsed.GetType()); + Assert.IsInstanceOfType(parsed); var deserialized = (IFlatBufferDeserializedObject)parsed; - Assert.Equal(typeof(SomeTable), deserialized.TableOrStructType); - Assert.NotNull(deserialized.InputBuffer); // lazy - Assert.Equal(FlatBufferDeserializationOption.Lazy, deserialized.DeserializationContext.DeserializationOption); - Assert.Equal(FlatBufferDeserializationOption.Lazy, serializer.DeserializationOption); + Assert.AreEqual(typeof(SomeTable), deserialized.TableOrStructType); + Assert.IsNotNull(deserialized.InputBuffer); // lazy + Assert.AreEqual(FlatBufferDeserializationOption.Lazy, deserialized.DeserializationContext.DeserializationOption); + Assert.AreEqual(FlatBufferDeserializationOption.Lazy, serializer.DeserializationOption); } #endif { var bw = new byte[1024]; - Assert.Throws(() => serializer.Write(bw, null)); - Assert.Throws(() => serializer.Write(bw, new SomeOtherTable())); + Assert.ThrowsException(() => serializer.Write(bw, null)); + Assert.ThrowsException(() => serializer.Write(bw, new SomeOtherTable())); int written = serializer.Write(bw, new SomeTable { A = 3 }); - Assert.True(written > 0); + Assert.IsTrue(written > 0); object parsed = serializer.Parse(bw); - Assert.True(typeof(SomeTable).IsAssignableFrom(parsed.GetType())); - Assert.NotEqual(typeof(SomeTable), parsed.GetType()); - Assert.IsAssignableFrom(parsed); + Assert.IsTrue(typeof(SomeTable).IsAssignableFrom(parsed.GetType())); + Assert.AreNotEqual(typeof(SomeTable), parsed.GetType()); + Assert.IsInstanceOfType(parsed); var deserialized = (IFlatBufferDeserializedObject)parsed; - Assert.Equal(typeof(SomeTable), deserialized.TableOrStructType); - Assert.NotNull(deserialized.InputBuffer); // lazy - Assert.Equal(FlatBufferDeserializationOption.Lazy, deserialized.DeserializationContext.DeserializationOption); - Assert.Equal(FlatBufferDeserializationOption.Lazy, serializer.DeserializationOption); + Assert.AreEqual(typeof(SomeTable), deserialized.TableOrStructType); + Assert.IsNotNull(deserialized.InputBuffer); // lazy + Assert.AreEqual(FlatBufferDeserializationOption.Lazy, deserialized.DeserializationContext.DeserializationOption); + Assert.AreEqual(FlatBufferDeserializationOption.Lazy, serializer.DeserializationOption); } } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorOfUnionTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorOfUnionTests.cs index ce0cb059..39991a75 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorOfUnionTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorOfUnionTests.cs @@ -19,7 +19,7 @@ namespace FlatSharpEndToEndTests.ClassLib.FlatBufferVectorOfUnionTests; /// /// Tests for FlatSharp's IList of Union. /// - +[TestClass] public class FlatBufferVectorOfUnionTests { private TableVector vector; @@ -39,47 +39,47 @@ public FlatBufferVectorOfUnionTests() this.vector = original.SerializeAndParse(FlatBufferDeserializationOption.Lazy); } - [Fact] + [TestMethod] public void FlatBufferVector_OutOfRange() { - Assert.Throws(() => this.vector.Vector[-1]); - Assert.Throws(() => this.vector.Vector[5]); + Assert.ThrowsException(() => this.vector.Vector[-1]); + Assert.ThrowsException(() => this.vector.Vector[5]); } - [Fact] + [TestMethod] public void FlatBufferVector_NotMutable() { - Assert.True(this.vector.Vector.IsReadOnly); - Assert.Throws(() => this.vector.Vector[0] = new MyUnion("foobar")); - Assert.Throws(() => this.vector.Vector.Add(new MyUnion("foobar"))); - Assert.Throws(() => this.vector.Vector.Clear()); - Assert.Throws(() => this.vector.Vector.Insert(0, new MyUnion("foobar"))); - Assert.Throws(() => this.vector.Vector.Remove(new MyUnion("foobar"))); - Assert.Throws(() => this.vector.Vector.RemoveAt(0)); + Assert.IsTrue(this.vector.Vector.IsReadOnly); + Assert.ThrowsException(() => this.vector.Vector[0] = new MyUnion("foobar")); + Assert.ThrowsException(() => this.vector.Vector.Add(new MyUnion("foobar"))); + Assert.ThrowsException(() => this.vector.Vector.Clear()); + Assert.ThrowsException(() => this.vector.Vector.Insert(0, new MyUnion("foobar"))); + Assert.ThrowsException(() => this.vector.Vector.Remove(new MyUnion("foobar"))); + Assert.ThrowsException(() => this.vector.Vector.RemoveAt(0)); } - [Fact] + [TestMethod] public void FlatBufferVector_GetEnumerator() { int i = 0; foreach (var item in this.vector.Vector) { - Assert.Equal(i + 1, item.Discriminator); + Assert.AreEqual(i + 1, item.Discriminator); i++; } } - [Fact] + [TestMethod] public void FlatBufferVector_Contains() { - Assert.True(this.vector.Vector.Contains(new MyUnion("foobar"))); - Assert.False(this.vector.Vector.Contains(new MyUnion("blah"))); + Assert.IsTrue(this.vector.Vector.Contains(new MyUnion("foobar"))); + Assert.IsFalse(this.vector.Vector.Contains(new MyUnion("blah"))); } - [Fact] + [TestMethod] public void FlatBufferVector_IndexOf() { - Assert.Equal(0, this.vector.Vector.IndexOf(new MyUnion("foobar"))); - Assert.Equal(-1, this.vector.Vector.IndexOf(new MyUnion("monster"))); + Assert.AreEqual(0, this.vector.Vector.IndexOf(new MyUnion("foobar"))); + Assert.AreEqual(-1, this.vector.Vector.IndexOf(new MyUnion("monster"))); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorTests.cs index 428881e2..086842c5 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/FlatBufferVectorTests.cs @@ -21,6 +21,7 @@ namespace FlatSharpEndToEndTests.ClassLib.FlatBufferVectorTests; /// /// Tests for FlatSharp's IList implementations. /// +[TestClass] public class FlatBufferVectorTests { private static readonly IReadOnlyList ExpectedStringContents = new List { "one", "two", "three", "four", "five" }; @@ -48,90 +49,90 @@ public FlatBufferVectorTests() this.progressiveIntVector = originalIntVector.SerializeAndParse(FlatBufferDeserializationOption.Progressive); } - [Fact] + [TestMethod] public void FlatBufferVector_OutOfRange() { - Assert.Throws(() => this.stringVector.Vector[-1]); - Assert.Throws(() => this.stringVector.Vector[5]); + Assert.ThrowsException(() => this.stringVector.Vector[-1]); + Assert.ThrowsException(() => this.stringVector.Vector[5]); - Assert.Throws(() => this.progressiveStringVector.Vector[-1]); - Assert.Throws(() => this.progressiveStringVector.Vector[5]); + Assert.ThrowsException(() => this.progressiveStringVector.Vector[-1]); + Assert.ThrowsException(() => this.progressiveStringVector.Vector[5]); } - [Fact] + [TestMethod] public void FlatBufferVector_NotMutable() { - Assert.True(this.stringVector.Vector.IsReadOnly); - Assert.Throws(() => this.stringVector.Vector[0] = "foobar"); - Assert.Throws(() => this.stringVector.Vector.Add("foobar")); - Assert.Throws(() => this.stringVector.Vector.Clear()); - Assert.Throws(() => this.stringVector.Vector.Insert(0, "foobar")); - Assert.Throws(() => this.stringVector.Vector.Remove("foobar")); - Assert.Throws(() => this.stringVector.Vector.RemoveAt(0)); - - Assert.True(this.progressiveStringVector.Vector.IsReadOnly); - Assert.Throws(() => this.progressiveStringVector.Vector[0] = "foobar"); - Assert.Throws(() => this.progressiveStringVector.Vector.Add("foobar")); - Assert.Throws(() => this.progressiveStringVector.Vector.Clear()); - Assert.Throws(() => this.progressiveStringVector.Vector.Insert(0, "foobar")); - Assert.Throws(() => this.progressiveStringVector.Vector.Remove("foobar")); - Assert.Throws(() => this.progressiveStringVector.Vector.RemoveAt(0)); + Assert.IsTrue(this.stringVector.Vector.IsReadOnly); + Assert.ThrowsException(() => this.stringVector.Vector[0] = "foobar"); + Assert.ThrowsException(() => this.stringVector.Vector.Add("foobar")); + Assert.ThrowsException(() => this.stringVector.Vector.Clear()); + Assert.ThrowsException(() => this.stringVector.Vector.Insert(0, "foobar")); + Assert.ThrowsException(() => this.stringVector.Vector.Remove("foobar")); + Assert.ThrowsException(() => this.stringVector.Vector.RemoveAt(0)); + + Assert.IsTrue(this.progressiveStringVector.Vector.IsReadOnly); + Assert.ThrowsException(() => this.progressiveStringVector.Vector[0] = "foobar"); + Assert.ThrowsException(() => this.progressiveStringVector.Vector.Add("foobar")); + Assert.ThrowsException(() => this.progressiveStringVector.Vector.Clear()); + Assert.ThrowsException(() => this.progressiveStringVector.Vector.Insert(0, "foobar")); + Assert.ThrowsException(() => this.progressiveStringVector.Vector.Remove("foobar")); + Assert.ThrowsException(() => this.progressiveStringVector.Vector.RemoveAt(0)); } - [Fact] + [TestMethod] public void FlatBufferVector_GetEnumerator() { int i = 0; foreach (var item in this.stringVector.Vector) { - Assert.Equal(item, ExpectedStringContents[i]); + Assert.AreEqual(item, ExpectedStringContents[i]); i++; } i = 0; foreach (var item in this.progressiveStringVector.Vector) { - Assert.Equal(item, ExpectedStringContents[i]); + Assert.AreEqual(item, ExpectedStringContents[i]); i++; } i = 0; foreach (var item in this.intVector.Vector) { - Assert.Equal(item, ExpectedIntContents[i]); + Assert.AreEqual(item, ExpectedIntContents[i]); i++; } i = 0; foreach (var item in this.progressiveIntVector.Vector) { - Assert.Equal(item, ExpectedIntContents[i]); + Assert.AreEqual(item, ExpectedIntContents[i]); i++; } } - [Fact] + [TestMethod] public void FlatBufferVector_Contains() { - Assert.True(this.stringVector.Vector.Contains("one")); - Assert.False(this.stringVector.Vector.Contains("foobar")); - Assert.False(this.stringVector.Vector.Contains(null)); + Assert.IsTrue(this.stringVector.Vector.Contains("one")); + Assert.IsFalse(this.stringVector.Vector.Contains("foobar")); + Assert.IsFalse(this.stringVector.Vector.Contains(null)); - Assert.True(this.progressiveStringVector.Vector.Contains("one")); - Assert.False(this.progressiveStringVector.Vector.Contains("foobar")); - Assert.False(this.progressiveStringVector.Vector.Contains(null)); + Assert.IsTrue(this.progressiveStringVector.Vector.Contains("one")); + Assert.IsFalse(this.progressiveStringVector.Vector.Contains("foobar")); + Assert.IsFalse(this.progressiveStringVector.Vector.Contains(null)); - Assert.False(this.intVector.Vector.Contains(-1)); - Assert.False(this.progressiveIntVector.Vector.Contains(-1)); + Assert.IsFalse(this.intVector.Vector.Contains(-1)); + Assert.IsFalse(this.progressiveIntVector.Vector.Contains(-1)); foreach (var i in ExpectedIntContents) { - Assert.True(this.intVector.Vector.Contains(i)); - Assert.True(this.progressiveIntVector.Vector.Contains(i)); + Assert.IsTrue(this.intVector.Vector.Contains(i)); + Assert.IsTrue(this.progressiveIntVector.Vector.Contains(i)); } } - [Fact] + [TestMethod] public void FlatBufferVector_CopyTo() { string[] array = new string[100]; @@ -140,17 +141,17 @@ public void FlatBufferVector_CopyTo() for (int i = 0; i < 50; ++i) { - Assert.Null(array[i]); + Assert.IsNull(array[i]); } for (int i = 0; i < ExpectedStringContents.Count; ++i) { - Assert.Equal(ExpectedStringContents[i], array[i + 50]); + Assert.AreEqual(ExpectedStringContents[i], array[i + 50]); } for (int i = 50 + ExpectedStringContents.Count; i < array.Length; ++i) { - Assert.Null(array[i]); + Assert.IsNull(array[i]); } array = new string[100]; @@ -159,21 +160,21 @@ public void FlatBufferVector_CopyTo() for (int i = 0; i < 50; ++i) { - Assert.Null(array[i]); + Assert.IsNull(array[i]); } for (int i = 0; i < ExpectedStringContents.Count; ++i) { - Assert.Equal(ExpectedStringContents[i], array[i + 50]); + Assert.AreEqual(ExpectedStringContents[i], array[i + 50]); } for (int i = 50 + ExpectedStringContents.Count; i < array.Length; ++i) { - Assert.Null(array[i]); + Assert.IsNull(array[i]); } } - [Fact] + [TestMethod] public void FlatBufferVector_CopyTo_SizedArray() { string[] array = new string[this.stringVector.Vector.Count]; @@ -181,7 +182,7 @@ public void FlatBufferVector_CopyTo_SizedArray() for (int i = 0; i < ExpectedStringContents.Count; ++i) { - Assert.Equal(ExpectedStringContents[i], array[i]); + Assert.AreEqual(ExpectedStringContents[i], array[i]); } array = new string[this.progressiveStringVector.Vector.Count]; @@ -189,36 +190,36 @@ public void FlatBufferVector_CopyTo_SizedArray() for (int i = 0; i < ExpectedStringContents.Count; ++i) { - Assert.Equal(ExpectedStringContents[i], array[i]); + Assert.AreEqual(ExpectedStringContents[i], array[i]); } } - [Fact] + [TestMethod] public void FlatBufferVector_IndexOf() { for (int i = 0; i < ExpectedStringContents.Count; ++i) { - Assert.Equal(i, this.stringVector.Vector.IndexOf(ExpectedStringContents[i])); - Assert.Equal(i, this.progressiveStringVector.Vector.IndexOf(ExpectedStringContents[i])); + Assert.AreEqual(i, this.stringVector.Vector.IndexOf(ExpectedStringContents[i])); + Assert.AreEqual(i, this.progressiveStringVector.Vector.IndexOf(ExpectedStringContents[i])); } for (int i = 0; i < ExpectedIntContents.Count; ++i) { - Assert.Equal(i, this.intVector.Vector.IndexOf(ExpectedIntContents[i])); - Assert.Equal(i, this.progressiveIntVector.Vector.IndexOf(ExpectedIntContents[i])); + Assert.AreEqual(i, this.intVector.Vector.IndexOf(ExpectedIntContents[i])); + Assert.AreEqual(i, this.progressiveIntVector.Vector.IndexOf(ExpectedIntContents[i])); } - Assert.Equal(-1, this.stringVector.Vector.IndexOf("foobar")); - Assert.Equal(-1, this.stringVector.Vector.IndexOf(null)); - Assert.Equal(-1, this.progressiveStringVector.Vector.IndexOf("foobar")); - Assert.Equal(-1, this.progressiveStringVector.Vector.IndexOf(null)); - Assert.Equal(-1, this.intVector.Vector.IndexOf(int.MinValue)); + Assert.AreEqual(-1, this.stringVector.Vector.IndexOf("foobar")); + Assert.AreEqual(-1, this.stringVector.Vector.IndexOf(null)); + Assert.AreEqual(-1, this.progressiveStringVector.Vector.IndexOf("foobar")); + Assert.AreEqual(-1, this.progressiveStringVector.Vector.IndexOf(null)); + Assert.AreEqual(-1, this.intVector.Vector.IndexOf(int.MinValue)); } - [Fact] + [TestMethod] public void FlatBufferVector_Caching() { - Assert.NotSame(this.stringVector.Vector[0], this.stringVector.Vector[0]); - Assert.Same(this.progressiveStringVector.Vector[0], this.progressiveStringVector.Vector[0]); + Assert.AreNotSame(this.stringVector.Vector[0], this.stringVector.Vector[0]); + Assert.AreSame(this.progressiveStringVector.Vector[0], this.progressiveStringVector.Vector[0]); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/GeneratedSerializerWrapperTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/GeneratedSerializerWrapperTests.cs index 0644c7b9..31a11140 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/GeneratedSerializerWrapperTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/GeneratedSerializerWrapperTests.cs @@ -18,9 +18,10 @@ namespace FlatSharpEndToEndTests.ClassLib; +[TestClass] public class GeneratedSerializerWrapperTests { - [Fact] + [TestMethod] public void Serialize_DestinationBuffer_TooShort() { FlatBufferSerializerNonGenericTests.SomeTable table = new(); @@ -29,16 +30,16 @@ public void Serialize_DestinationBuffer_TooShort() var serializer = FlatBufferSerializerNonGenericTests.SomeTable.Serializer; byte[] destination = new byte[7]; - Assert.Throws(() => serializer.Write(destination, table)); + Assert.ThrowsException(() => serializer.Write(destination, table)); } - [Fact] + [TestMethod] public void Serialize_RootTable_Null() { var serializer = FlatBufferSerializerNonGenericTests.SomeTable.Serializer; byte[] destination = new byte[7]; - var ex = Assert.Throws(() => serializer.Write(destination, null)); - Assert.Contains("The root table may not be null.", ex.Message); + var ex = Assert.ThrowsException(() => serializer.Write(destination, null)); + Assert.IsTrue(ex.Message.Contains("The root table may not be null.")); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/IndexedVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/IndexedVectorTests.cs index eebfa46d..061131d4 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/IndexedVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/IndexedVectorTests.cs @@ -19,6 +19,7 @@ namespace FlatSharpEndToEndTests.ClassLib.IndexedVectorTests; /// /// Tests for the FlatBufferVector class that implements IList. /// +[TestClass] public class IndexedVectorTests { private List stringKeys; @@ -45,41 +46,41 @@ public IndexedVectorTests() this.intVectorSource.IntVector.Freeze(); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void IndexedVector_KeyNotFound(FlatBufferDeserializationOption option) { Container stringValue = this.stringVectorSource.SerializeAndParse(option); Container intValue = this.intVectorSource.SerializeAndParse(option); - Assert.Throws(() => this.stringVectorSource.StringVector[null]); - Assert.Throws(() => this.stringVectorSource.StringVector[string.Empty]); - Assert.Throws(() => stringValue.StringVector[null]); - Assert.Throws(() => stringValue.StringVector[string.Empty]); + Assert.ThrowsException(() => this.stringVectorSource.StringVector[null]); + Assert.ThrowsException(() => this.stringVectorSource.StringVector[string.Empty]); + Assert.ThrowsException(() => stringValue.StringVector[null]); + Assert.ThrowsException(() => stringValue.StringVector[string.Empty]); - Assert.Throws(() => this.intVectorSource.IntVector[int.MinValue]); - Assert.Throws(() => this.intVectorSource.IntVector[int.MaxValue]); - Assert.Throws(() => intValue.IntVector[int.MinValue]); - Assert.Throws(() => intValue.IntVector[int.MaxValue]); + Assert.ThrowsException(() => this.intVectorSource.IntVector[int.MinValue]); + Assert.ThrowsException(() => this.intVectorSource.IntVector[int.MaxValue]); + Assert.ThrowsException(() => intValue.IntVector[int.MinValue]); + Assert.ThrowsException(() => intValue.IntVector[int.MaxValue]); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void IndexedVector_NotMutable(FlatBufferDeserializationOption option) { Container stringValue = this.stringVectorSource.SerializeAndParse(option); - Assert.Equal( + Assert.AreEqual( FlatBufferDeserializationOption.GreedyMutable != option, stringValue.StringVector.IsReadOnly); - Assert.True(this.stringVectorSource.StringVector.IsReadOnly); + Assert.IsTrue(this.stringVectorSource.StringVector.IsReadOnly); // root is frozen. - Assert.Throws(() => this.stringVectorSource.StringVector.AddOrReplace(null)); - Assert.Throws(() => this.stringVectorSource.StringVector.Clear()); - Assert.Throws(() => this.stringVectorSource.StringVector.Remove(null)); - Assert.Throws(() => this.stringVectorSource.StringVector.Add(null)); + Assert.ThrowsException(() => this.stringVectorSource.StringVector.AddOrReplace(null)); + Assert.ThrowsException(() => this.stringVectorSource.StringVector.Clear()); + Assert.ThrowsException(() => this.stringVectorSource.StringVector.Remove(null)); + Assert.ThrowsException(() => this.stringVectorSource.StringVector.Add(null)); Action[] actions = new Action[] { @@ -97,13 +98,13 @@ public void IndexedVector_NotMutable(FlatBufferDeserializationOption option) } else { - Assert.Throws(item); + Assert.ThrowsException(item); } } } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void IndexedVector_GetEnumerator(FlatBufferDeserializationOption option) { Container stringValue = this.stringVectorSource.SerializeAndParse(option); @@ -117,90 +118,85 @@ private void EnumeratorTest(IIndexedVector vector) int i = 0; foreach (var item in vector) { - Assert.Equal(item.Key, i.ToString()); - Assert.Equal(item.Value.Key, i.ToString()); + Assert.AreEqual(item.Key, i.ToString()); + Assert.AreEqual(item.Value.Key, i.ToString()); i++; } var keys = new HashSet(this.stringKeys); - Assert.Equal(vector.Count, keys.Count); + Assert.AreEqual(vector.Count, keys.Count); foreach (string key in keys) { - Assert.True(vector.ContainsKey(key)); + Assert.IsTrue(vector.ContainsKey(key)); } foreach (var kvp in vector) { - Assert.True(vector.ContainsKey(kvp.Key)); - Assert.True(vector.TryGetValue(kvp.Key, out var value)); - Assert.Equal(kvp.Key, value.Key); + Assert.IsTrue(vector.ContainsKey(kvp.Key)); + Assert.IsTrue(vector.TryGetValue(kvp.Key, out var value)); + Assert.AreEqual(kvp.Key, value.Key); keys.Remove(value.Key); } - Assert.Empty(keys); + Assert.IsTrue(keys.Count == 0); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void IndexedVector_ContainsKey(FlatBufferDeserializationOption option) { Container stringValue = this.stringVectorSource.SerializeAndParse(option); - Assert.True(this.stringVectorSource.StringVector.ContainsKey("1")); - Assert.True(this.stringVectorSource.StringVector.ContainsKey("5")); - Assert.False(this.stringVectorSource.StringVector.ContainsKey("20")); - Assert.Throws(() => this.stringVectorSource.StringVector.ContainsKey(null)); + Assert.IsTrue(this.stringVectorSource.StringVector.ContainsKey("1")); + Assert.IsTrue(this.stringVectorSource.StringVector.ContainsKey("5")); + Assert.IsFalse(this.stringVectorSource.StringVector.ContainsKey("20")); + Assert.ThrowsException(() => this.stringVectorSource.StringVector.ContainsKey(null)); - Assert.True(stringValue.StringVector.ContainsKey("1")); - Assert.True(stringValue.StringVector.ContainsKey("5")); - Assert.False(stringValue.StringVector.ContainsKey("20")); - Assert.Throws(() => stringValue.StringVector.ContainsKey(null)); + Assert.IsTrue(stringValue.StringVector.ContainsKey("1")); + Assert.IsTrue(stringValue.StringVector.ContainsKey("5")); + Assert.IsFalse(stringValue.StringVector.ContainsKey("20")); + Assert.ThrowsException(() => stringValue.StringVector.ContainsKey(null)); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void IndexedVector_Caching(FlatBufferDeserializationOption option) { Container stringValue = this.stringVectorSource.SerializeAndParse(option); foreach (var key in this.stringKeys) { - Assert.True(stringValue.StringVector.TryGetValue(key, out var value)); - Assert.True(stringValue.StringVector.TryGetValue(key, out var value2)); - Assert.Equal( + Assert.IsTrue(stringValue.StringVector.TryGetValue(key, out var value)); + Assert.IsTrue(stringValue.StringVector.TryGetValue(key, out var value2)); + Assert.AreEqual( option != FlatBufferDeserializationOption.Lazy, object.ReferenceEquals(value, value2)); } } - [Fact] + [TestMethod] public void IndexedVector_Mutations() { IndexedVector vector = new IndexedVector(); var item = new StringKey { Key = "foobar" }; - Assert.False(vector.ContainsKey(item.Key)); - Assert.False(vector.TryGetValue(item.Key, out _)); - Assert.Equal(0, vector.Count); - Assert.Empty(vector); - Assert.True(vector.Add(item)); - Assert.False(vector.Add(item)); - Assert.True(vector.ContainsKey(item.Key)); - Assert.True(vector.TryGetValue(item.Key, out _)); - Assert.Equal(1, vector.Count); - Assert.Single(vector); - Assert.True(vector.Remove(item.Key)); - Assert.False(vector.Remove(item.Key)); - Assert.Equal(0, vector.Count); - Assert.Empty(vector); - Assert.True(vector.Add(item)); - Assert.Equal(1, vector.Count); - Assert.Single(vector); + Assert.IsFalse(vector.ContainsKey(item.Key)); + Assert.IsFalse(vector.TryGetValue(item.Key, out _)); + Assert.AreEqual(0, vector.Count); + Assert.IsTrue(vector.Add(item)); + Assert.IsFalse(vector.Add(item)); + Assert.IsTrue(vector.ContainsKey(item.Key)); + Assert.IsTrue(vector.TryGetValue(item.Key, out _)); + Assert.AreEqual(1, vector.Count); + Assert.IsTrue(vector.Remove(item.Key)); + Assert.IsFalse(vector.Remove(item.Key)); + Assert.AreEqual(0, vector.Count); + Assert.IsTrue(vector.Add(item)); + Assert.AreEqual(1, vector.Count); vector.Clear(); - Assert.Equal(0, vector.Count); - Assert.Empty(vector); - Assert.False(vector.ContainsKey(item.Key)); - Assert.False(vector.TryGetValue(item.Key, out _)); + Assert.AreEqual(0, vector.Count); + Assert.IsFalse(vector.ContainsKey(item.Key)); + Assert.IsFalse(vector.TryGetValue(item.Key, out _)); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/NonScalarVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/NonScalarVectorTests.cs index b9ac8e03..383ef416 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/NonScalarVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/NonScalarVectorTests.cs @@ -21,20 +21,13 @@ namespace FlatSharpEndToEndTests.ClassLib.NonScalarVectorTests; /// /// Tests various types of vectors (List/ReadOnlyList/Memory/ReadOnlyMemory/Array) for non-primitive types. /// +[TestClass] public class NonScalarVectorTests { private static readonly Random r = new Random(); - public static IEnumerable EnumValues() - { - foreach (var item in Enum.GetValues(typeof(FlatBufferDeserializationOption))) - { - yield return new object[] { item }; - } - } - - [Theory] - [MemberData(nameof(EnumValues))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void StringVector(FlatBufferDeserializationOption option) { this.TestType( @@ -47,8 +40,8 @@ public void StringVector(FlatBufferDeserializationOption option) }); } - [Theory] - [MemberData(nameof(EnumValues))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void TableVector(FlatBufferDeserializationOption option) { this.TestType( @@ -61,8 +54,8 @@ public void TableVector(FlatBufferDeserializationOption option) }); } - [Theory] - [MemberData(nameof(EnumValues))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void StructVector(FlatBufferDeserializationOption option) { this.TestType( @@ -89,10 +82,10 @@ private void TestType(FlatBufferDeserializationOption for (int i = 0; i < memoryTableResult.Vector.Count; ++i) { - Assert.Equal(memoryTable.Vector[i], resultVector[i]); + Assert.AreEqual(memoryTable.Vector[i], resultVector[i]); // reference equality should correspond to the serializer. - Assert.Equal(option != FlatBufferDeserializationOption.Lazy, object.ReferenceEquals(resultVector[i], resultVector[i])); + Assert.AreEqual(option != FlatBufferDeserializationOption.Lazy, object.ReferenceEquals(resultVector[i], resultVector[i])); } } @@ -107,10 +100,10 @@ private void TestType(FlatBufferDeserializationOption for (int i = 0; i < memoryTableResult.Vector.Count; ++i) { - Assert.Equal(memoryTable.Vector[i], resultVector[i]); + Assert.AreEqual(memoryTable.Vector[i], resultVector[i]); // reference equality should correspond to the serializer. - Assert.Equal(option != FlatBufferDeserializationOption.Lazy, object.ReferenceEquals(resultVector[i], resultVector[i])); + Assert.AreEqual(option != FlatBufferDeserializationOption.Lazy, object.ReferenceEquals(resultVector[i], resultVector[i])); } } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/SerializerConfigurationTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/SerializerConfigurationTests.cs index 290ca3b4..fc87dc26 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/SerializerConfigurationTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/SerializerConfigurationTests.cs @@ -19,10 +19,11 @@ namespace FlatSharpEndToEndTests.ClassLib.SerializerConfigurationTests; +[TestClass] public class SerializerConfigurationTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UseDeserializationMode(FlatBufferDeserializationOption option) { var item = new Root { StringVector = new string[] { "a", "b", "c" } }; @@ -31,10 +32,10 @@ public void UseDeserializationMode(FlatBufferDeserializationOption option) Root parsed = item.SerializeAndParse(serializer); IFlatBufferDeserializedObject obj = parsed as IFlatBufferDeserializedObject; - Assert.Equal(option, obj.DeserializationContext.DeserializationOption); + Assert.AreEqual(option, obj.DeserializationContext.DeserializationOption); } - [Fact] + [TestMethod] public void UseLazyDeserialization() { var item = new Root { StringVector = new string[] { "a", "b", "c" } }; @@ -43,10 +44,10 @@ public void UseLazyDeserialization() Root parsed = item.SerializeAndParse(serializer); IFlatBufferDeserializedObject obj = parsed as IFlatBufferDeserializedObject; - Assert.Equal(FlatBufferDeserializationOption.Lazy, obj.DeserializationContext.DeserializationOption); + Assert.AreEqual(FlatBufferDeserializationOption.Lazy, obj.DeserializationContext.DeserializationOption); } - [Fact] + [TestMethod] public void UseProgressiveDeserialization() { var item = new Root { StringVector = new string[] { "a", "b", "c" } }; @@ -55,10 +56,10 @@ public void UseProgressiveDeserialization() Root parsed = item.SerializeAndParse(serializer); IFlatBufferDeserializedObject obj = parsed as IFlatBufferDeserializedObject; - Assert.Equal(FlatBufferDeserializationOption.Progressive, obj.DeserializationContext.DeserializationOption); + Assert.AreEqual(FlatBufferDeserializationOption.Progressive, obj.DeserializationContext.DeserializationOption); } - [Fact] + [TestMethod] public void UseGreedyDeserialization() { var item = new Root { StringVector = new string[] { "a", "b", "c" } }; @@ -67,10 +68,10 @@ public void UseGreedyDeserialization() Root parsed = item.SerializeAndParse(serializer); IFlatBufferDeserializedObject obj = parsed as IFlatBufferDeserializedObject; - Assert.Equal(FlatBufferDeserializationOption.Greedy, obj.DeserializationContext.DeserializationOption); + Assert.AreEqual(FlatBufferDeserializationOption.Greedy, obj.DeserializationContext.DeserializationOption); } - [Fact] + [TestMethod] public void UseGreedyMutableDeserialization() { var item = new Root { StringVector = new string[] { "a", "b", "c" } }; @@ -79,18 +80,18 @@ public void UseGreedyMutableDeserialization() Root parsed = item.SerializeAndParse(serializer); IFlatBufferDeserializedObject obj = parsed as IFlatBufferDeserializedObject; - Assert.Equal(FlatBufferDeserializationOption.GreedyMutable, obj.DeserializationContext.DeserializationOption); + Assert.AreEqual(FlatBufferDeserializationOption.GreedyMutable, obj.DeserializationContext.DeserializationOption); } - [Theory] - [InlineData(FlatBufferDeserializationOption.Lazy, false, false)] - [InlineData(FlatBufferDeserializationOption.Lazy, true, true)] - [InlineData(FlatBufferDeserializationOption.Progressive, false, false)] - [InlineData(FlatBufferDeserializationOption.Progressive, true, true)] - [InlineData(FlatBufferDeserializationOption.Greedy, false, false)] - [InlineData(FlatBufferDeserializationOption.Greedy, true, false)] - [InlineData(FlatBufferDeserializationOption.GreedyMutable, false, false)] - [InlineData(FlatBufferDeserializationOption.GreedyMutable, true, false)] + [TestMethod] + [DataRow(FlatBufferDeserializationOption.Lazy, false, false)] + [DataRow(FlatBufferDeserializationOption.Lazy, true, true)] + [DataRow(FlatBufferDeserializationOption.Progressive, false, false)] + [DataRow(FlatBufferDeserializationOption.Progressive, true, true)] + [DataRow(FlatBufferDeserializationOption.Greedy, false, false)] + [DataRow(FlatBufferDeserializationOption.Greedy, true, false)] + [DataRow(FlatBufferDeserializationOption.GreedyMutable, false, false)] + [DataRow(FlatBufferDeserializationOption.GreedyMutable, true, false)] public void UseMemoryCopySerialization(FlatBufferDeserializationOption option, bool enableMemCopy, bool expectMemCopy) { Root t = new() { StringVector = new[] { "A", "b", "c", } }; @@ -101,9 +102,9 @@ public void UseMemoryCopySerialization(FlatBufferDeserializationOption option, b byte[] data = new byte[1024]; int maxBytes = compiled.GetMaxSize(t); - Assert.Equal(88, maxBytes); + Assert.AreEqual(88, maxBytes); int actualBytes = compiled.Write(data, t); - Assert.Equal(58, actualBytes); + Assert.AreEqual(58, actualBytes); // First test: Parse the array but don't trim the buffer. This causes the underlying // buffer to be much larger than the actual data. @@ -113,28 +114,28 @@ public void UseMemoryCopySerialization(FlatBufferDeserializationOption option, b if (expectMemCopy) { - Assert.Equal(1024, bytesWritten); // We use mem copy serialization here, and we gave it 1024 bytes when we parsed. So we get 1024 bytes back out. - Assert.Equal(1024, compiled.GetMaxSize(parsed)); - Assert.Throws(() => compiled.Write(new byte[maxBytes], parsed)); + Assert.AreEqual(1024, bytesWritten); // We use mem copy serialization here, and we gave it 1024 bytes when we parsed. So we get 1024 bytes back out. + Assert.AreEqual(1024, compiled.GetMaxSize(parsed)); + Assert.ThrowsException(() => compiled.Write(new byte[maxBytes], parsed)); // Repeat, but now using the trimmed array. parsed = compiled.Parse(data.AsMemory().Slice(0, actualBytes)); bytesWritten = compiled.Write(data2, parsed); - Assert.Equal(58, bytesWritten); - Assert.Equal(58, compiled.GetMaxSize(parsed)); + Assert.AreEqual(58, bytesWritten); + Assert.AreEqual(58, compiled.GetMaxSize(parsed)); // Default still returns 88. - Assert.Equal(88, Root.Serializer.GetMaxSize(parsed)); + Assert.AreEqual(88, Root.Serializer.GetMaxSize(parsed)); } else { - Assert.Equal(58, bytesWritten); - Assert.Equal(88, compiled.GetMaxSize(parsed)); + Assert.AreEqual(58, bytesWritten); + Assert.AreEqual(88, compiled.GetMaxSize(parsed)); compiled.Write(new byte[maxBytes], parsed); } } - [Fact] + [TestMethod] public void SharedStringWriters() { ISerializer noSharedStrings = Root.Serializer.WithSettings(opt => opt.DisableSharedStrings()); @@ -151,9 +152,9 @@ public void SharedStringWriters() byte[] perfectShared = root.AllocateAndSerialize(perfectSharedStrings); // Small shared doesn't accomplish anything since it alternates. - Assert.Equal(notShared.Length, smallShared.Length); - Assert.True(largeShared.Length < smallShared.Length); - Assert.Equal(largeShared.Length, perfectShared.Length); + Assert.AreEqual(notShared.Length, smallShared.Length); + Assert.IsTrue(largeShared.Length < smallShared.Length); + Assert.AreEqual(largeShared.Length, perfectShared.Length); } { @@ -165,9 +166,9 @@ public void SharedStringWriters() byte[] perfectShared = root.AllocateAndSerialize(perfectSharedStrings); // Small shared doesn't accomplish anything since it alternates. - Assert.True(smallShared.Length < notShared.Length); - Assert.Equal(largeShared.Length, smallShared.Length); - Assert.Equal(largeShared.Length, perfectShared.Length); + Assert.IsTrue(smallShared.Length < notShared.Length); + Assert.AreEqual(largeShared.Length, smallShared.Length); + Assert.AreEqual(largeShared.Length, perfectShared.Length); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/SpanComparerTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/SpanComparerTests.cs index 6c02b3ca..f5e3c7af 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/SpanComparerTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/SpanComparerTests.cs @@ -20,9 +20,10 @@ namespace FlatSharpEndToEndTests.ClassLib; +[TestClass] public class SpanComparerTests { - [Fact] + [TestMethod] [ExcludeFromCodeCoverage] public void RandomFlatBufferStringComparison() { @@ -47,38 +48,38 @@ public void RandomFlatBufferStringComparison() Span span2 = SerializationHelpers.Encoding.GetBytes(str2); Utf8StringComparer utf8Comparer = new Utf8StringComparer(); - Assert.Equal(0, StringSpanComparer.Instance.Compare(true, span, true, span)); - Assert.Equal(0, utf8Comparer.Compare(str, str)); + Assert.AreEqual(0, StringSpanComparer.Instance.Compare(true, span, true, span)); + Assert.AreEqual(0, utf8Comparer.Compare(str, str)); - Assert.Equal(0, StringSpanComparer.Instance.Compare(true, span2, true, span2)); - Assert.Equal(0, utf8Comparer.Compare(str2, str2)); + Assert.AreEqual(0, StringSpanComparer.Instance.Compare(true, span2, true, span2)); + Assert.AreEqual(0, utf8Comparer.Compare(str2, str2)); int expected = utf8Comparer.Compare(str, str2); int actual = StringSpanComparer.Instance.Compare(true, span, true, span2); - Assert.Equal(expected, actual); + Assert.AreEqual(expected, actual); expected = utf8Comparer.Compare(str2, str); actual = StringSpanComparer.Instance.Compare(true, span2, true, span); - Assert.Equal(expected, actual); + Assert.AreEqual(expected, actual); } } - [Fact] + [TestMethod] public void StringComparer_NullItems() { StringSpanComparer comp = default; - var ex = Assert.Throws(() => comp.Compare(false, default, false, default)); - Assert.Equal("Strings may not be null when used as sorted vector keys.", ex.Message); + var ex = Assert.ThrowsException(() => comp.Compare(false, default, false, default)); + Assert.AreEqual("Strings may not be null when used as sorted vector keys.", ex.Message); - ex = Assert.Throws(() => comp.Compare(false, default, true, default)); - Assert.Equal("Strings may not be null when used as sorted vector keys.", ex.Message); + ex = Assert.ThrowsException(() => comp.Compare(false, default, true, default)); + Assert.AreEqual("Strings may not be null when used as sorted vector keys.", ex.Message); - ex = Assert.Throws(() => comp.Compare(true, default, false, default)); - Assert.Equal("Strings may not be null when used as sorted vector keys.", ex.Message); + ex = Assert.ThrowsException(() => comp.Compare(true, default, false, default)); + Assert.AreEqual("Strings may not be null when used as sorted vector keys.", ex.Message); } - [Fact] + [TestMethod] public void TestBoolComparer() { BoolSpanComparer comparer = new BoolSpanComparer(default); @@ -86,40 +87,40 @@ public void TestBoolComparer() Span f = new byte[1] { SerializationHelpers.False }; Span t = new byte[1] { SerializationHelpers.True }; - Assert.Equal(false.CompareTo(true), comparer.Compare(true, f, true, t)); - Assert.Equal(false.CompareTo(false), comparer.Compare(true, f, true, f)); - Assert.Equal(true.CompareTo(true), comparer.Compare(true, t, true, t)); - Assert.Equal(true.CompareTo(false), comparer.Compare(true, t, true, f)); + Assert.AreEqual(false.CompareTo(true), comparer.Compare(true, f, true, t)); + Assert.AreEqual(false.CompareTo(false), comparer.Compare(true, f, true, f)); + Assert.AreEqual(true.CompareTo(true), comparer.Compare(true, t, true, t)); + Assert.AreEqual(true.CompareTo(false), comparer.Compare(true, t, true, f)); } - [Fact] + [TestMethod] public void TestByteComparer() => this.Compare(new ByteSpanComparer(default), sizeof(byte)); - [Fact] + [TestMethod] public void TestSByteComparer() => this.Compare(new SByteSpanComparer(default), sizeof(sbyte)); - [Fact] + [TestMethod] public void TestUShortComparer() => this.Compare(new UShortSpanComparer(default), sizeof(ushort)); - [Fact] + [TestMethod] public void TestShortComparer() => this.Compare(new ShortSpanComparer(default), sizeof(short)); - [Fact] + [TestMethod] public void TestUIntComaprer() => this.Compare(new UIntSpanComparer(default), sizeof(uint)); - [Fact] + [TestMethod] public void TestIntComparer() => this.Compare(new IntSpanComparer(default), sizeof(int)); - [Fact] + [TestMethod] public void TestULongComparer() => this.Compare(new ULongSpanComparer(default), sizeof(ulong)); - [Fact] + [TestMethod] public void TestLongComparer() => this.Compare(new LongSpanComparer(default), sizeof(long)); - [Fact] + [TestMethod] public void TestDoubleComparer() => this.Compare(new DoubleSpanComparer(default), sizeof(double)); - [Fact] + [TestMethod] public void TestFloatComparer() => this.Compare(new FloatSpanComparer(default), sizeof(float)); private void Compare(ISpanComparer comparer, int size) where T : struct, IComparable @@ -139,22 +140,22 @@ private void Compare(ISpanComparer comparer, int size) where T : struct, ICom var leftSpan = leftData.AsSpan().Slice(0, size); var rightSpan = rightData.AsSpan().Slice(0, size); - Assert.Equal( + Assert.AreEqual( a.CompareTo(b), comparer.Compare(true, leftSpan, true, rightSpan)); - Assert.Equal( + Assert.AreEqual( b.CompareTo(a), comparer.Compare(true, rightSpan, true, leftSpan)); - Assert.Equal(0, comparer.Compare(true, leftSpan, true, leftSpan)); - Assert.Equal(0, comparer.Compare(true, rightSpan, true, rightSpan)); + Assert.AreEqual(0, comparer.Compare(true, leftSpan, true, leftSpan)); + Assert.AreEqual(0, comparer.Compare(true, rightSpan, true, rightSpan)); } // Verify that the not-present case works as expected. byte[] defaultData = new byte[32]; - Assert.Equal(0, comparer.Compare(true, defaultData, false, default)); - Assert.Equal(0, comparer.Compare(false, default, true, defaultData)); - Assert.Equal(0, comparer.Compare(false, default, false, default)); + Assert.AreEqual(0, comparer.Compare(true, defaultData, false, default)); + Assert.AreEqual(0, comparer.Compare(false, default, true, defaultData)); + Assert.AreEqual(0, comparer.Compare(false, default, false, default)); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ClassLib/VTableTests.cs b/src/Tests/FlatSharpEndToEndTests/ClassLib/VTableTests.cs index 42936fb7..e321a9b2 100644 --- a/src/Tests/FlatSharpEndToEndTests/ClassLib/VTableTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ClassLib/VTableTests.cs @@ -19,32 +19,33 @@ namespace FlatSharpEndToEndTests.ClassLib.VTables; +[TestClass] public class VTableTests { public delegate void CreateCallback(ArrayInputBuffer buffer, int offset, out TVTable vt); - [Fact] + [TestMethod] public void Test_VTable4_Auto() => this.RunTests(3, VTable4.Create); - [Fact] + [TestMethod] public void Test_VTable4_LE() => this.RunTests(3, VTable4.CreateLittleEndian); - [Fact] + [TestMethod] public void Test_VTable4_BE() => this.RunTests(3, VTable4.CreateBigEndian); - [Fact] + [TestMethod] public void Test_VTable8_Auto() => this.RunTests(7, VTable8.Create); - [Fact] + [TestMethod] public void Test_VTable8_LE() => this.RunTests(7, VTable8.CreateLittleEndian); - [Fact] + [TestMethod] public void Test_VTable8_BE() => this.RunTests(7, VTable8.CreateBigEndian); - [Fact] + [TestMethod] public void Test_VTableGeneric() => this.RunTests(255, VTableGeneric.Create); - [Fact] + [TestMethod] public void InitializeVTable_NormalTable() { byte[] buffer = @@ -64,12 +65,12 @@ public void InitializeVTable_NormalTable() out nuint fieldCount, out ReadOnlySpan fieldData); - Assert.Equal(0, vtableOffset); - Assert.Equal((nuint)2, fieldCount); - Assert.Equal(4, fieldData.Length); + Assert.AreEqual(0, vtableOffset); + Assert.AreEqual((nuint)2, fieldCount); + Assert.AreEqual(4, fieldData.Length); } - [Fact] + [TestMethod] public void InitializeVTable_EmptyTable() { byte[] buffer = @@ -85,12 +86,12 @@ public void InitializeVTable_EmptyTable() out nuint fieldCount, out ReadOnlySpan fieldData); - Assert.Equal(0, vtableOffset); - Assert.Equal((nuint)0, fieldCount); - Assert.Equal(0, fieldData.Length); + Assert.AreEqual(0, vtableOffset); + Assert.AreEqual((nuint)0, fieldCount); + Assert.AreEqual(0, fieldData.Length); } - [Fact] + [TestMethod] public void InitializeVTable_InvalidLength() { byte[] buffer = @@ -100,23 +101,23 @@ public void InitializeVTable_InvalidLength() 4, 0, 0, 0 // soffset to vtable. }; - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => new ArrayInputBuffer(buffer).InitializeVTable(4, out _, out _, out _)); - Assert.Equal( + Assert.AreEqual( "FlatBuffer was in an invalid format: VTable was not long enough to be valid.", ex.Message); } - [Fact] + [TestMethod] public void ReadUOffset() { byte[] buffer = { 4, 0, 0, 0 }; - Assert.Equal(4, new ArrayInputBuffer(buffer).ReadUOffset(0)); + Assert.AreEqual(4, new ArrayInputBuffer(buffer).ReadUOffset(0)); buffer = new byte[] { 3, 0, 0, 0 }; - var ex = Assert.Throws(() => new ArrayInputBuffer(buffer).ReadUOffset(0)); - Assert.Equal( + var ex = Assert.ThrowsException(() => new ArrayInputBuffer(buffer).ReadUOffset(0)); + Assert.AreEqual( "FlatBuffer was in an invalid format: Decoded uoffset_t had value less than 4. Value = 3", ex.Message); } @@ -152,21 +153,21 @@ private void Test( var buffer = new ArrayInputBuffer(vtable); callback(buffer, 0, out TVTable vt); - Assert.Equal(expectedMaxIndex, vt.MaxSupportedIndex); + Assert.AreEqual(expectedMaxIndex, vt.MaxSupportedIndex); for (int i = 0; i <= Math.Max(actualMaxIndex, expectedMaxIndex); ++i) { if (i <= Math.Min(actualMaxIndex, expectedMaxIndex)) { - Assert.Equal(i, vt.OffsetOf(buffer, i)); + Assert.AreEqual(i, vt.OffsetOf(buffer, i)); } else { - Assert.Equal(0, vt.OffsetOf(buffer, i)); + Assert.AreEqual(0, vt.OffsetOf(buffer, i)); } } - Assert.Equal(0, vt.OffsetOf(buffer, vt.MaxSupportedIndex + 1)); - Assert.Equal(0, vt.OffsetOf(buffer, -1)); + Assert.AreEqual(0, vt.OffsetOf(buffer, vt.MaxSupportedIndex + 1)); + Assert.AreEqual(0, vt.OffsetOf(buffer, -1)); } } diff --git a/src/Tests/FlatSharpEndToEndTests/CopyConstructors/CopyConstructorTests.cs b/src/Tests/FlatSharpEndToEndTests/CopyConstructors/CopyConstructorTests.cs index 892f57c7..33d56204 100644 --- a/src/Tests/FlatSharpEndToEndTests/CopyConstructors/CopyConstructorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/CopyConstructors/CopyConstructorTests.cs @@ -16,10 +16,11 @@ namespace FlatSharpEndToEndTests.CopyConstructors; +[TestClass] public class CopyConstructorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void CopyConstructorsTest(FlatBufferDeserializationOption option) { OuterTable original = new OuterTable @@ -74,81 +75,81 @@ public void CopyConstructorsTest(FlatBufferDeserializationOption option) OuterTable copied = new OuterTable(parsed); // Strings can be copied by reference since they are immutable. - Assert.Equal(original.A, copied.A); - Assert.Equal(original.A, parsed.A); - - Assert.Equal(original.B, copied.B); - Assert.Equal(original.C, copied.C); - Assert.Equal(original.D, copied.D); - Assert.Equal(original.E, copied.E); - Assert.Equal(original.F, copied.F); - Assert.Equal(original.G, copied.G); - Assert.Equal(original.H, copied.H); - Assert.Equal(original.I, copied.I); + Assert.AreEqual(original.A, copied.A); + Assert.AreEqual(original.A, parsed.A); + + Assert.AreEqual(original.B, copied.B); + Assert.AreEqual(original.C, copied.C); + Assert.AreEqual(original.D, copied.D); + Assert.AreEqual(original.E, copied.E); + Assert.AreEqual(original.F, copied.F); + Assert.AreEqual(original.G, copied.G); + Assert.AreEqual(original.H, copied.H); + Assert.AreEqual(original.I, copied.I); DeepCompareIntVector(original.IntVectorArray, parsed.IntVectorArray, copied.IntVectorArray); DeepCompareIntVector(original.IntVectorList, parsed.IntVectorList, copied.IntVectorList); DeepCompareIntVector(original.IntVectorRoList, parsed.IntVectorRoList, copied.IntVectorRoList); - Assert.Equal((byte)3, original.UnionVal.Value.Discriminator); - Assert.Equal((byte)3, parsed.UnionVal.Value.Discriminator); - Assert.Equal((byte)3, copied.UnionVal.Value.Discriminator); + Assert.AreEqual((byte)3, original.UnionVal.Value.Discriminator); + Assert.AreEqual((byte)3, parsed.UnionVal.Value.Discriminator); + Assert.AreEqual((byte)3, copied.UnionVal.Value.Discriminator); - Assert.True(copied.UnionVal.Value.TryGet(out OuterStruct? _)); - Assert.NotNull(copied.UnionVal.Value.Item3); + Assert.IsTrue(copied.UnionVal.Value.TryGet(out OuterStruct? _)); + Assert.IsNotNull(copied.UnionVal.Value.Item3); - Assert.IsType(copied.UnionVal.Value.Item3); - Assert.IsNotType(parsed.UnionVal.Value.Item3); + Assert.IsInstanceOfType(copied.UnionVal.Value.Item3); + Assert.AreNotEqual(typeof(OuterStruct), parsed.UnionVal.Value.Item3.GetType()); for (int i = 1; i <= 4; ++i) { - Assert.Equal((byte)i, original.VectorOfUnion[i - 1].Discriminator); - Assert.Equal((byte)i, parsed.VectorOfUnion[i - 1].Discriminator); - Assert.Equal((byte)i, copied.VectorOfUnion[i - 1].Discriminator); + Assert.AreEqual((byte)i, original.VectorOfUnion[i - 1].Discriminator); + Assert.AreEqual((byte)i, parsed.VectorOfUnion[i - 1].Discriminator); + Assert.AreEqual((byte)i, copied.VectorOfUnion[i - 1].Discriminator); } - Assert.NotSame(parsed.VectorOfUnion[0].Item1, copied.VectorOfUnion[0].Item1); - Assert.NotSame(parsed.VectorOfUnion[1].Item2, copied.VectorOfUnion[1].Item2); - Assert.NotSame(parsed.VectorOfUnion[2].Item3, copied.VectorOfUnion[2].Item3); - Assert.NotSame(parsed.VectorOfUnion[3].Item4, copied.VectorOfUnion[3].Item4); + Assert.AreNotSame(parsed.VectorOfUnion[0].Item1, copied.VectorOfUnion[0].Item1); + Assert.AreNotSame(parsed.VectorOfUnion[1].Item2, copied.VectorOfUnion[1].Item2); + Assert.AreNotSame(parsed.VectorOfUnion[2].Item3, copied.VectorOfUnion[2].Item3); + Assert.AreNotSame(parsed.VectorOfUnion[3].Item4, copied.VectorOfUnion[3].Item4); for (int i = 1; i <= 4; ++i) { - Assert.Equal((byte)i, original.VectorOfUnionRoList[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)parsed.VectorOfUnionRoList[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)copied.VectorOfUnionRoList[i - 1].Discriminator); + Assert.AreEqual((byte)i, original.VectorOfUnionRoList[i - 1].Discriminator); + Assert.AreEqual((byte)i, (byte)parsed.VectorOfUnionRoList[i - 1].Discriminator); + Assert.AreEqual((byte)i, (byte)copied.VectorOfUnionRoList[i - 1].Discriminator); } - Assert.NotSame(parsed.VectorOfUnionRoList[0].Item1, copied.VectorOfUnionRoList[0].Item1); - Assert.NotSame(parsed.VectorOfUnionRoList[1].Item2, copied.VectorOfUnionRoList[1].Item2); - Assert.NotSame(parsed.VectorOfUnionRoList[2].Item3, copied.VectorOfUnionRoList[2].Item3); - Assert.NotSame(parsed.VectorOfUnionRoList[3].Item4, copied.VectorOfUnionRoList[3].Item4); + Assert.AreNotSame(parsed.VectorOfUnionRoList[0].Item1, copied.VectorOfUnionRoList[0].Item1); + Assert.AreNotSame(parsed.VectorOfUnionRoList[1].Item2, copied.VectorOfUnionRoList[1].Item2); + Assert.AreNotSame(parsed.VectorOfUnionRoList[2].Item3, copied.VectorOfUnionRoList[2].Item3); + Assert.AreNotSame(parsed.VectorOfUnionRoList[3].Item4, copied.VectorOfUnionRoList[3].Item4); for (int i = 1; i <= 4; ++i) { - Assert.Equal((byte)i, original.VectorOfUnionArray[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)parsed.VectorOfUnionArray[i - 1].Discriminator); - Assert.Equal((byte)i, (byte)copied.VectorOfUnionArray[i - 1].Discriminator); + Assert.AreEqual((byte)i, original.VectorOfUnionArray[i - 1].Discriminator); + Assert.AreEqual((byte)i, (byte)parsed.VectorOfUnionArray[i - 1].Discriminator); + Assert.AreEqual((byte)i, (byte)copied.VectorOfUnionArray[i - 1].Discriminator); } - Assert.NotSame(parsed.VectorOfUnionArray[0].Item1, copied.VectorOfUnionArray[0].Item1); - Assert.NotSame(parsed.VectorOfUnionArray[1].Item2, copied.VectorOfUnionArray[1].Item2); - Assert.NotSame(parsed.VectorOfUnionArray[2].Item3, copied.VectorOfUnionArray[2].Item3); - Assert.NotSame(parsed.VectorOfUnionArray[3].Item4, copied.VectorOfUnionArray[3].Item4); + Assert.AreNotSame(parsed.VectorOfUnionArray[0].Item1, copied.VectorOfUnionArray[0].Item1); + Assert.AreNotSame(parsed.VectorOfUnionArray[1].Item2, copied.VectorOfUnionArray[1].Item2); + Assert.AreNotSame(parsed.VectorOfUnionArray[2].Item3, copied.VectorOfUnionArray[2].Item3); + Assert.AreNotSame(parsed.VectorOfUnionArray[3].Item4, copied.VectorOfUnionArray[3].Item4); Memory? mem = copied.ByteVector; Memory? pMem = parsed.ByteVector; - Assert.True(original.ByteVector.Value.Span.SequenceEqual(mem.Value.Span)); - Assert.False(mem.Value.Span.Overlaps(pMem.Value.Span)); + Assert.IsTrue(original.ByteVector.Value.Span.SequenceEqual(mem.Value.Span)); + Assert.IsFalse(mem.Value.Span.Overlaps(pMem.Value.Span)); ReadOnlyMemory? roMem = copied.ByteVectorRO; ReadOnlyMemory? pRoMem = parsed.ByteVectorRO; - Assert.True(original.ByteVectorRO.Value.Span.SequenceEqual(roMem.Value.Span)); - Assert.False(roMem.Value.Span.Overlaps(pRoMem.Value.Span)); + Assert.IsTrue(original.ByteVectorRO.Value.Span.SequenceEqual(roMem.Value.Span)); + Assert.IsFalse(roMem.Value.Span.Overlaps(pRoMem.Value.Span)); // array of table { - Assert.NotSame(parsed.TableVectorArray, copied.TableVectorArray); + Assert.AreNotSame(parsed.TableVectorArray, copied.TableVectorArray); DeepCompareInnerTableList( (IReadOnlyList)original.TableVectorArray, (IReadOnlyList)parsed.TableVectorArray, @@ -157,7 +158,7 @@ public void CopyConstructorsTest(FlatBufferDeserializationOption option) // list of table. { - Assert.NotSame(parsed.TableVectorList, copied.TableVectorList); + Assert.AreNotSame(parsed.TableVectorList, copied.TableVectorList); DeepCompareInnerTableList( (IReadOnlyList)original.TableVectorList, @@ -167,7 +168,7 @@ public void CopyConstructorsTest(FlatBufferDeserializationOption option) // read only list of table. { - Assert.NotSame(parsed.TableVectorRoList, copied.TableVectorRoList); + Assert.AreNotSame(parsed.TableVectorRoList, copied.TableVectorRoList); DeepCompareInnerTableList( original.TableVectorRoList, @@ -177,7 +178,7 @@ public void CopyConstructorsTest(FlatBufferDeserializationOption option) // indexed vector of table. { - Assert.NotSame(parsed.TableVectorIndexed, copied.TableVectorIndexed); + Assert.AreNotSame(parsed.TableVectorIndexed, copied.TableVectorIndexed); foreach (var kvp in original.TableVectorIndexed) { string key = kvp.Key; @@ -186,8 +187,8 @@ public void CopyConstructorsTest(FlatBufferDeserializationOption option) var parsedValue = parsed.TableVectorIndexed[key]; var copiedValue = copied.TableVectorIndexed[key]; - Assert.NotNull(parsedValue); - Assert.NotNull(copiedValue); + Assert.IsNotNull(parsedValue); + Assert.IsNotNull(copiedValue); DeepCompareInnerTable(value, parsedValue, copiedValue); } @@ -196,25 +197,25 @@ public void CopyConstructorsTest(FlatBufferDeserializationOption option) private void DeepCompareIntVector(IReadOnlyList a, IReadOnlyList b, IReadOnlyList c) { - Assert.Equal(a.Count, b.Count); - Assert.Equal(a.Count, c.Count); + Assert.AreEqual(a.Count, b.Count); + Assert.AreEqual(a.Count, c.Count); for (int i = 0; i < a.Count; ++i) { - Assert.Equal(a[i], b[i]); - Assert.Equal(a[i], c[i]); + Assert.AreEqual(a[i], b[i]); + Assert.AreEqual(a[i], c[i]); } } private void DeepCompareIntVector(IList a, IList b, IList c) { - Assert.Equal(a.Count, b.Count); - Assert.Equal(a.Count, c.Count); + Assert.AreEqual(a.Count, b.Count); + Assert.AreEqual(a.Count, c.Count); for (int i = 0; i < a.Count; ++i) { - Assert.Equal(a[i], b[i]); - Assert.Equal(a[i], c[i]); + Assert.AreEqual(a[i], b[i]); + Assert.AreEqual(a[i], c[i]); } } @@ -242,8 +243,8 @@ private InnerTable[] CreateInner(params string[] names) private static void DeepCompareInnerTableList(IReadOnlyList aList, IReadOnlyList pList, IReadOnlyList cList) { - Assert.Equal(aList.Count, pList.Count); - Assert.Equal(pList.Count, cList.Count); + Assert.AreEqual(aList.Count, pList.Count); + Assert.AreEqual(pList.Count, cList.Count); for (int i = 0; i < pList.Count; ++i) { @@ -257,39 +258,39 @@ private static void DeepCompareInnerTableList(IReadOnlyList aList, I private static void DeepCompareInnerTable(InnerTable a, InnerTable p, InnerTable c) { - Assert.NotSame(p, c); + Assert.AreNotSame(p, c); - Assert.IsNotType(p); - Assert.IsType(c); - Assert.IsType(a); + Assert.AreNotEqual(typeof(InnerTable), p.GetType()); + Assert.IsInstanceOfType(c); + Assert.IsInstanceOfType(a); - Assert.Equal(a.Name, p.Name); - Assert.Equal(a.Name, c.Name); + Assert.AreEqual(a.Name, p.Name); + Assert.AreEqual(a.Name, c.Name); var aOuter = a.OuterStructVal; var pOuter = p.OuterStructVal; var cOuter = c.OuterStructVal; - Assert.NotSame(pOuter, cOuter); + Assert.AreNotSame(pOuter, cOuter); - Assert.IsType(aOuter); - Assert.IsType(cOuter); - Assert.IsNotType(pOuter); + Assert.IsInstanceOfType(aOuter); + Assert.IsInstanceOfType(cOuter); + Assert.AreNotEqual(typeof(OuterStruct), pOuter.GetType()); - Assert.Equal(aOuter.Value, pOuter.Value); - Assert.Equal(aOuter.Value, cOuter.Value); + Assert.AreEqual(aOuter.Value, pOuter.Value); + Assert.AreEqual(aOuter.Value, cOuter.Value); var pInner = pOuter.InnerStructVal; var cInner = cOuter.InnerStructVal; var aInner = aOuter.InnerStructVal; - Assert.NotSame(pInner, cInner); + Assert.AreNotSame(pInner, cInner); - Assert.IsType(aInner); - Assert.IsType(cInner); - Assert.IsNotType(pInner); + Assert.IsInstanceOfType(aInner); + Assert.IsInstanceOfType(cInner); + Assert.AreNotEqual(typeof(InnerStruct), pInner.GetType()); - Assert.Equal(aInner.LongValue, pInner.LongValue); - Assert.Equal(aInner.LongValue, cInner.LongValue); + Assert.AreEqual(aInner.LongValue, pInner.LongValue); + Assert.AreEqual(aInner.LongValue, cInner.LongValue); } } diff --git a/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs b/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs index 3b1e6c00..1a9283a5 100644 --- a/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/DefaultValues/DefaultValuesTests.cs @@ -16,37 +16,38 @@ namespace FlatSharpEndToEndTests.DefaultValues; +[TestClass] public class DefaultValuesTests { - [Fact] + [TestMethod] public void DefaultValue_Enum_Negative() { Defaults defaults = new(); - Assert.Equal(long.MaxValue, (long)defaults.EnumLongMax); - Assert.Equal((long)-1, (long)defaults.EnumLongNegOne); + Assert.AreEqual(long.MaxValue, (long)defaults.EnumLongMax); + Assert.AreEqual((long)-1, (long)defaults.EnumLongNegOne); - Assert.Equal(long.MaxValue, defaults.LongMax); - Assert.Equal(-1, defaults.LongNegOne); + Assert.AreEqual(long.MaxValue, defaults.LongMax); + Assert.AreEqual(-1, defaults.LongNegOne); - Assert.Equal(0ul, defaults.ULongZero); + Assert.AreEqual(0ul, defaults.ULongZero); // FlatC bug: ulong values over 2^63 are not supported. - Assert.Equal(0ul, defaults.ULongMax); + Assert.AreEqual(0ul, defaults.ULongMax); - Assert.Equal(0ul, (ulong)defaults.EnumULongZero); + Assert.AreEqual(0ul, (ulong)defaults.EnumULongZero); // FlatC bug: ulong values over 2^63 are not supported. - Assert.Equal(0ul, (ulong)defaults.EnumULongMax); + Assert.AreEqual(0ul, (ulong)defaults.EnumULongMax); } - [Fact] + [TestMethod] public void Enum_Values() { - Assert.Equal(-1L, (long)Int64Enum.NegOne); - Assert.Equal(long.MaxValue, (long)Int64Enum.LongMax); + Assert.AreEqual(-1L, (long)Int64Enum.NegOne); + Assert.AreEqual(long.MaxValue, (long)Int64Enum.LongMax); - Assert.Equal(0UL, (ulong)UInt64Enum.Zero); - Assert.Equal(ulong.MaxValue, (ulong)UInt64Enum.Max); + Assert.AreEqual(0UL, (ulong)UInt64Enum.Zero); + Assert.AreEqual(ulong.MaxValue, (ulong)UInt64Enum.Max); } } diff --git a/src/Tests/FlatSharpEndToEndTests/DepthLimit/DepthLimitTests.cs b/src/Tests/FlatSharpEndToEndTests/DepthLimit/DepthLimitTests.cs index b4f306d4..6ea649c3 100644 --- a/src/Tests/FlatSharpEndToEndTests/DepthLimit/DepthLimitTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/DepthLimit/DepthLimitTests.cs @@ -18,20 +18,21 @@ namespace FlatSharpEndToEndTests.DepthLimit; +[TestClass] public class DepthLimitTests { - [Fact] + [TestMethod] public void DepthLimit_Negative() { - var ex = Assert.Throws( + var ex = Assert.ThrowsException( () => LLNode.Serializer.WithSettings(opt => opt.WithObjectDepthLimit(-1))); - Assert.Contains("ObjectDepthLimit must be nonnegative.", ex.Message); + Assert.IsTrue(ex.Message.Contains("ObjectDepthLimit must be nonnegative.")); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void DepthLimit_OneOver(FlatBufferDeserializationOption option) { const int Limit = 50; @@ -40,14 +41,14 @@ public void DepthLimit_OneOver(FlatBufferDeserializationOption option) LLNode head = CreateList(Limit + 1); - var ex = Assert.Throws( + var ex = Assert.ThrowsException( () => ParseAndTraverseList(head, serializer)); - Assert.Contains("FlatSharp passed the configured depth limit when deserializing.", ex.Message); + Assert.IsTrue(ex.Message.Contains("FlatSharp passed the configured depth limit when deserializing.")); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void DepthLimit_Exact(FlatBufferDeserializationOption option) { const int Limit = 50; diff --git a/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs b/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs index c89e9a15..f46d4f2f 100644 --- a/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs +++ b/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs @@ -16,19 +16,20 @@ namespace FlatSharpEndToEndTests; -public class DeserializationOptionClassData : IEnumerable +public static class DynamicDataHelper { - public IEnumerator GetEnumerator() + public static IEnumerable DeserializationModes { - yield return new object[] { FlatBufferDeserializationOption.Lazy }; - yield return new object[] { FlatBufferDeserializationOption.Progressive }; - yield return new object[] { FlatBufferDeserializationOption.Greedy }; - yield return new object[] { FlatBufferDeserializationOption.GreedyMutable }; - } - - IEnumerator IEnumerable.GetEnumerator() - { - return this.GetEnumerator(); + get + { + return new[] + { + new object[] { FlatBufferDeserializationOption.Lazy }, + new object[] { FlatBufferDeserializationOption.Progressive }, + new object[] { FlatBufferDeserializationOption.Greedy }, + new object[] { FlatBufferDeserializationOption.GreedyMutable }, + }; + } } } diff --git a/src/Tests/FlatSharpEndToEndTests/Documentation/DocumentationTestCases.cs b/src/Tests/FlatSharpEndToEndTests/Documentation/DocumentationTestCases.cs index 7b8a8612..05822879 100644 --- a/src/Tests/FlatSharpEndToEndTests/Documentation/DocumentationTestCases.cs +++ b/src/Tests/FlatSharpEndToEndTests/Documentation/DocumentationTestCases.cs @@ -16,6 +16,7 @@ namespace FlatSharpEndToEndTests.Documentation; +[TestClass] public class DocumentationTestCases { private System.Xml.XmlDocument xmlDoc; @@ -26,131 +27,131 @@ public DocumentationTestCases() this.xmlDoc.Load("FlatSharpEndToEndTests.xml"); } - [Fact] + [TestMethod] public void EnumDocumentation() { - Assert.Equal( + Assert.AreEqual( "CommentTest:73c67946-5c52-4643-baa9-a1a0c0d758d7", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.TestEnum")); - Assert.Equal( + Assert.AreEqual( "CommentTest:282048b4-2817-4312-93ec-8c21e8d42f8d", this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.TestEnum.A")); - Assert.Null(this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.TestEnum.Uncommented")); - Assert.Null(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UndocumentedEnum")); + Assert.IsNull(this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.TestEnum.Uncommented")); + Assert.IsNull(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UndocumentedEnum")); } - [Fact] + [TestMethod] public void UnionDocumentation() { - Assert.Equal( + Assert.AreEqual( "CommentTest:d54eef2c-f1d0-497f-874f-eeb0e47588b6", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.TestUnion")); - Assert.Null(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UndocumentedUnion")); + Assert.IsNull(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UndocumentedUnion")); } - [Fact] + [TestMethod] public void TableDocumentation() { - Assert.Equal( + Assert.AreEqual( "CommentTest:eb9a0f9a-6f4e-4839-be67-e719b411a274", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.Table")); - Assert.Equal( + Assert.AreEqual( "CommentTest:41b60a53-10a9-4f4a-9d36-3bf73fb95392", this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.Table.Property")); - Assert.Equal( + Assert.AreEqual( "<><>", this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.Table.EscapeTest")); - Assert.Null(this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.Table.Uncommented")); - Assert.Null(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UndocumentedTable")); + Assert.IsNull(this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.Table.Uncommented")); + Assert.IsNull(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UndocumentedTable")); } - [Fact] + [TestMethod] public void RefStructDocumentation() { - Assert.Equal( + Assert.AreEqual( "CommentTest:cb1b9369-c724-4106-b02b-2afe4984cf89", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.RefStruct")); - Assert.Equal( + Assert.AreEqual( "CommentTest:95571f1b-c255-4191-a489-2b06ddcae495", this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.RefStruct.Property")); - Assert.Equal( + Assert.AreEqual( "CommentTest:93efd448-fa30-4ddb-9d3b-56ca3f10b403", this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.RefStruct.Vector")); - Assert.Null(this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.RefStruct.UncommentedProperty")); - Assert.Null(this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.RefStruct.UncommentedVector")); - Assert.Null(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UncommentedRefStruct")); + Assert.IsNull(this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.RefStruct.UncommentedProperty")); + Assert.IsNull(this.GetSummaryText("P:FlatSharpEndToEndTests.Documentation.RefStruct.UncommentedVector")); + Assert.IsNull(this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.UncommentedRefStruct")); } - [Fact] + [TestMethod] public void ValueStructDocumentation() { - Assert.Equal( + Assert.AreEqual( "CommentTest:7a379625-7511-48f9-8b57-34b41c073da8", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.ValueStruct")); - Assert.Equal( + Assert.AreEqual( "CommentTest:62d5d69b-b3a0-4446-9abe-d0b314555a4b", this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.ValueStruct.Property")); - Assert.Equal( + Assert.AreEqual( "CommentTest:30add22e-345d-46e2-a1a2-346043cfd444", this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.ValueStruct.Vector_Item(FlatSharpEndToEndTests.Documentation.ValueStruct@,System.Int32)")); - Assert.Equal( + Assert.AreEqual( "CommentTest:30add22e-345d-46e2-a1a2-346043cfd444", this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.ValueStruct__FlatSharpExtensions.Vector(FlatSharpEndToEndTests.Documentation.ValueStruct@,System.Int32)")); - Assert.Null( + Assert.IsNull( this.GetSummaryText("F:FlatSharpEndToEndTests.Documentation.ValueStruct.UncommentedProperty")); - Assert.Null( + Assert.IsNull( this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.ValueStruct.UncommentedVector_Item(FlatSharpEndToEndTests.Documentation.ValueStruct@,System.Int32)")); - Assert.Null( + Assert.IsNull( this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.ValueStruct__FlatSharpExtensions.UncommentedVector(FlatSharpEndToEndTests.Documentation.ValueStruct@,System.Int32)")); } - [Fact] + [TestMethod] public void RpcServiceDocumentation() { - Assert.Equal( + Assert.AreEqual( "CommentTest:d9232e86-035e-4b86-bc77-a3cb04575ba1", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.Service")); - Assert.Equal( + Assert.AreEqual( "CommentTest:d9232e86-035e-4b86-bc77-a3cb04575ba1", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.Service.ServiceServerBase")); - Assert.Equal( + Assert.AreEqual( "CommentTest:d9232e86-035e-4b86-bc77-a3cb04575ba1", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.Service.ServiceClient")); - Assert.Equal( + Assert.AreEqual( "CommentTest:d9232e86-035e-4b86-bc77-a3cb04575ba1", this.GetSummaryText("T:FlatSharpEndToEndTests.Documentation.IService")); - Assert.Equal( + Assert.AreEqual( "CommentTest:932b099d-1cff-4533-81f3-b0eef65e21f3", this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.IService.MethodCall(FlatSharpEndToEndTests.Documentation.Table,System.Threading.CancellationToken)")); - Assert.Equal( + Assert.AreEqual( "CommentTest:932b099d-1cff-4533-81f3-b0eef65e21f3", this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.Service.ServiceServerBase.MethodCall(FlatSharpEndToEndTests.Documentation.Table,Grpc.Core.ServerCallContext)")); - Assert.Equal( + Assert.AreEqual( "CommentTest:932b099d-1cff-4533-81f3-b0eef65e21f3", this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.Service.ServiceClient.MethodCall(FlatSharpEndToEndTests.Documentation.Table,Grpc.Core.Metadata,System.Nullable{System.DateTime},System.Threading.CancellationToken)")); - Assert.Equal( + Assert.AreEqual( "CommentTest:932b099d-1cff-4533-81f3-b0eef65e21f3", this.GetSummaryText("M:FlatSharpEndToEndTests.Documentation.Service.ServiceClient.MethodCall(FlatSharpEndToEndTests.Documentation.Table,Grpc.Core.CallOptions)")); } diff --git a/src/Tests/FlatSharpEndToEndTests/FileIdentifier/FileIdentifierTests.cs b/src/Tests/FlatSharpEndToEndTests/FileIdentifier/FileIdentifierTests.cs index 02097d50..59127959 100644 --- a/src/Tests/FlatSharpEndToEndTests/FileIdentifier/FileIdentifierTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/FileIdentifier/FileIdentifierTests.cs @@ -18,6 +18,7 @@ namespace FlatSharpEndToEndTests.FileIdentifiers; +[TestClass] public class FileIdentifierTests { private static byte[] EmptyTableWithId = @@ -37,17 +38,17 @@ public class FileIdentifierTests 4, 0, // table length }; - [Fact] + [TestMethod] public void FileIdentifier_Serialized() { byte[] buffer = new HasId().AllocateAndSerialize(); - Assert.True(EmptyTableWithId.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(EmptyTableWithId.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void NoFileIdentifier_Serialized() { byte[] buffer = new NoId().AllocateAndSerialize(); - Assert.True(EmptyTableWithoutId.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(EmptyTableWithoutId.AsSpan().SequenceEqual(buffer)); } } \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj index 71ee800f..cc91e62d 100644 --- a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj +++ b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj @@ -2,7 +2,7 @@ false true - net7.0;net6.0;net8.0 + net6.0;net7.0;net8.0 net472;net6.0;net7.0;net8.0 net6.0;net7.0;net8.0 net8.0 @@ -19,25 +19,36 @@ True latest - + + + true + net8.0 + FlatSharpEndToEndTests.Program + true + exe + $(DefineConstants);AOT + + + + + + + + + all runtime; build; native; contentfiles; analyzers; buildtransitive + - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - diff --git a/src/Tests/FlatSharpEndToEndTests/GlobalNamespaceBlocker.cs b/src/Tests/FlatSharpEndToEndTests/GlobalNamespaceBlocker.cs index 55c8a5ab..37b237da 100644 --- a/src/Tests/FlatSharpEndToEndTests/GlobalNamespaceBlocker.cs +++ b/src/Tests/FlatSharpEndToEndTests/GlobalNamespaceBlocker.cs @@ -14,8 +14,12 @@ * limitations under the License. */ +#if !AOT + namespace FlatSharpEndToEndTests.FlatSharp; public static class Fake { -} \ No newline at end of file +} + +#endif \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs b/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs index 3ab1c593..0fbc5784 100644 --- a/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs +++ b/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs @@ -28,4 +28,4 @@ global using System.Runtime.CompilerServices; global using FlatSharp; global using FlatSharp.Attributes; -global using Xunit; +global using Microsoft.VisualStudio.TestTools.UnitTesting; diff --git a/src/Tests/FlatSharpEndToEndTests/Grpc/EchoServiceTestCases.cs b/src/Tests/FlatSharpEndToEndTests/Grpc/EchoServiceTestCases.cs index 06c3d33c..4e5765e3 100644 --- a/src/Tests/FlatSharpEndToEndTests/Grpc/EchoServiceTestCases.cs +++ b/src/Tests/FlatSharpEndToEndTests/Grpc/EchoServiceTestCases.cs @@ -22,32 +22,33 @@ namespace FlatSharpEndToEndTests.GrpcTests; -#if NET7_0_OR_GREATER +#if NET7_0_OR_GREATER && !AOT +[TestClass] public class EchoServiceTestCases { - [Fact] + [TestMethod] public async Task GrpcSerializersOverridable_EnableSharedStrings() { EchoService.Serializer.Value = MultiStringMessage.Serializer .WithSettings(s => s.UseDefaultSharedStringWriter()); int length = await this.SharedStringsTest_Common(); - Assert.True(length <= 2048); + Assert.IsTrue(length <= 2048); } - [Fact] + [TestMethod] public async Task GrpcSerializersOverridable_NoSharedStrings() { try { - Assert.Throws( + Assert.ThrowsException( () => EchoService.Serializer.Value = null); EchoService.Serializer.Value = MultiStringMessage.Serializer.WithSettings( s => s.DisableSharedStrings()); int length = await this.SharedStringsTest_Common(); - Assert.True(length >= 100_000); + Assert.IsTrue(length >= 100_000); } finally { @@ -76,7 +77,7 @@ await this.EchoTest(async client => MultiStringMessage response = await ((IEchoService)client).EchoClientStreaming(requestStream, default); // Test that the string is only written once. This confirms that our update to the serializer worked as intended. - Assert.IsAssignableFrom(response); + Assert.IsInstanceOfType(response); IFlatBufferDeserializedObject obj = (IFlatBufferDeserializedObject)response; length = obj.InputBuffer.Length; @@ -85,27 +86,27 @@ await this.EchoTest(async client => return length; } - [Fact] + [TestMethod] public Task EchoUnary() { return this.EchoTest(async client => { var response = await client.EchoUnary(new StringMessage { Value = "hi" }); - Assert.Equal("hi", response.Value); + Assert.AreEqual("hi", response.Value); }); } - [Fact] + [TestMethod] public Task EchoUnary_Interface() { return this.EchoTest_Interface(async client => { var response = await client.EchoUnary(new StringMessage { Value = "hi" }, CancellationToken.None); - Assert.Equal("hi", response.Value); + Assert.AreEqual("hi", response.Value); }); } - [Fact] + [TestMethod] public Task EchoUnary_Interface_Canceled() { return this.EchoTest_Interface(async client => @@ -118,7 +119,7 @@ await this.AssertCanceled( }); } - [Fact] + [TestMethod] public Task EchoClientStreaming() { return this.EchoTest(async client => @@ -137,15 +138,15 @@ public Task EchoClientStreaming() MultiStringMessage response = await streamingCall; - Assert.Equal(100, response.Value.Count); + Assert.AreEqual(100, response.Value.Count); for (int i = 0; i < 100; ++i) { - Assert.Equal(messages[i], response.Value[i]); + Assert.AreEqual(messages[i], response.Value[i]); } }); } - [Fact] + [TestMethod] public Task EchoClientStreaming_Interface() { return this.EchoTest_Interface(async client => @@ -164,15 +165,15 @@ public Task EchoClientStreaming_Interface() MultiStringMessage response = await client.EchoClientStreaming(requestChannel, CancellationToken.None); - Assert.Equal(100, response.Value.Count); + Assert.AreEqual(100, response.Value.Count); for (int i = 0; i < 100; ++i) { - Assert.Equal(messages[i], response.Value[i]); + Assert.AreEqual(messages[i], response.Value[i]); } }); } - [Fact] + [TestMethod] public Task EchoClientStreaming_Interface_Canceled() { return this.EchoTest_Interface(async client => @@ -190,7 +191,7 @@ public Task EchoClientStreaming_Interface_Canceled() }); } - [Fact] + [TestMethod] public Task EchoServerStreaming() { return this.EchoTest(async client => @@ -204,14 +205,14 @@ public Task EchoServerStreaming() int i = 0; while (await streamingCall.ResponseStream.MoveNext()) { - Assert.Equal(message.Value[i++], streamingCall.ResponseStream.Current.Value); + Assert.AreEqual(message.Value[i++], streamingCall.ResponseStream.Current.Value); } - Assert.Equal(100, i); + Assert.AreEqual(100, i); }); } - [Fact] + [TestMethod] public Task EchoServerStreaming_Interface() { return this.EchoTest_Interface(async client => @@ -228,21 +229,21 @@ public Task EchoServerStreaming_Interface() int i = 0; while (await channel.Reader.WaitToReadAsync()) { - Assert.True(channel.Reader.TryRead(out var item)); - Assert.Equal(message.Value[i++], item.Value); + Assert.IsTrue(channel.Reader.TryRead(out var item)); + Assert.AreEqual(message.Value[i++], item.Value); } - Assert.Equal(100, i); + Assert.AreEqual(100, i); await task; - Assert.True(channel.Reader.Completion.IsCompleted); - Assert.False(channel.Reader.Completion.IsFaulted); + Assert.IsTrue(channel.Reader.Completion.IsCompleted); + Assert.IsFalse(channel.Reader.Completion.IsFaulted); }); } /* - [Fact] + [TestMethod] public Task EchoServerStreaming_Interface_Canceled() { return this.EchoTest_Interface(async client => @@ -260,8 +261,8 @@ public Task EchoServerStreaming_Interface_Canceled() int i = 0; while (await channel.Reader.WaitToReadAsync(cts.Token)) { - Assert.True(channel.Reader.TryRead(out var item)); - Assert.Equal(message.Value[i++], item.Value); + Assert.IsTrue(channel.Reader.TryRead(out var item)); + Assert.AreEqual(message.Value[i++], item.Value); if (i == 50) { @@ -276,13 +277,13 @@ await this.AssertCanceled( await this.AssertCanceled(() => task); - Assert.True(channel.Reader.Completion.IsCompleted); - Assert.False(channel.Reader.Completion.IsFaulted); + Assert.IsTrue(channel.Reader.Completion.IsCompleted); + Assert.IsFalse(channel.Reader.Completion.IsFaulted); }); } */ - [Fact] + [TestMethod] public Task EchoDuplexStreaming() { return this.EchoTest(async client => @@ -294,14 +295,14 @@ public Task EchoDuplexStreaming() await duplexCall.RequestStream.WriteAsync(new StringMessage { Value = str }); await duplexCall.ResponseStream.MoveNext(); - Assert.Equal(str, duplexCall.ResponseStream.Current.Value); + Assert.AreEqual(str, duplexCall.ResponseStream.Current.Value); } await duplexCall.RequestStream.CompleteAsync(); }); } - [Fact] + [TestMethod] public Task EchoDuplexStreaming_Interface() { return this.EchoTest_Interface(async client => @@ -316,17 +317,17 @@ public Task EchoDuplexStreaming_Interface() await sourceChannel.Writer.WriteAsync(new StringMessage { Value = str }); var item = await destChannel.Reader.ReadAsync(); - Assert.Equal(str, item.Value); + Assert.AreEqual(str, item.Value); } sourceChannel.Writer.Complete(); await duplexCall; - Assert.False(duplexCall.IsFaulted); + Assert.IsFalse(duplexCall.IsFaulted); }); } - [Fact] + [TestMethod] public Task EchoDuplexStreaming_Interface_Canceled_BeforeCompletion() { return this.EchoTest_Interface(async client => @@ -344,7 +345,7 @@ public Task EchoDuplexStreaming_Interface_Canceled_BeforeCompletion() await sourceChannel.Writer.WriteAsync(new StringMessage { Value = str }); var item = await destChannel.Reader.ReadAsync(); - Assert.Equal(str, item.Value); + Assert.AreEqual(str, item.Value); } cts.Cancel(); @@ -352,12 +353,12 @@ public Task EchoDuplexStreaming_Interface_Canceled_BeforeCompletion() sourceChannel.Writer.Complete(); await this.AssertCanceled(() => duplexCall); - Assert.True(destChannel.Reader.Completion.IsCompleted); - Assert.True(destChannel.Reader.Completion.IsFaulted); + Assert.IsTrue(destChannel.Reader.Completion.IsCompleted); + Assert.IsTrue(destChannel.Reader.Completion.IsFaulted); }); } - [Fact] + [TestMethod] public Task EchoDuplexStreaming_Interface_Canceled_OnWrite() { return this.EchoTest_Interface(async client => @@ -397,14 +398,14 @@ public Task EchoDuplexStreaming_Interface_Canceled_OnWrite() else { var item = await destChannel.Reader.ReadAsync(); - Assert.Equal(i.ToString(), item.Value); + Assert.AreEqual(i.ToString(), item.Value); } } await this.AssertCanceled(() => duplexCall); - Assert.True(destChannel.Reader.Completion.IsCompleted); - Assert.True(destChannel.Reader.Completion.IsCanceled || destChannel.Reader.Completion.IsFaulted); + Assert.IsTrue(destChannel.Reader.Completion.IsCompleted); + Assert.IsTrue(destChannel.Reader.Completion.IsCanceled || destChannel.Reader.Completion.IsFaulted); }); } diff --git a/src/Tests/FlatSharpEndToEndTests/Helpers.cs b/src/Tests/FlatSharpEndToEndTests/Helpers.cs index cdbf76bc..5a5ce288 100644 --- a/src/Tests/FlatSharpEndToEndTests/Helpers.cs +++ b/src/Tests/FlatSharpEndToEndTests/Helpers.cs @@ -21,7 +21,6 @@ using System.Reflection; using System.Text; using System.Threading; -using Xunit.Abstractions; namespace FlatSharpEndToEndTests; @@ -104,7 +103,7 @@ public static void AssertSequenceEqual( Span actual) { //var combined = expected.ToArray().Zip(actual.ToArray()).ToArray(); - Assert.Equal(expected.Length, actual.Length); + Assert.AreEqual(expected.Length, actual.Length); for (int i = 0; i < expected.Length; ++i) { @@ -123,25 +122,25 @@ public static void AssertMutationWorks( TProperty newValue, Action? assertEqual = null) { - Assert.True(parent is IFlatBufferDeserializedObject); + Assert.IsTrue(parent is IFlatBufferDeserializedObject); { var dobj = (IFlatBufferDeserializedObject)parent; - Assert.Equal(option, dobj.DeserializationContext.DeserializationOption); - Assert.Equal(typeof(TSource), dobj.TableOrStructType); + Assert.AreEqual(option, dobj.DeserializationContext.DeserializationOption); + Assert.AreEqual(typeof(TSource), dobj.TableOrStructType); switch (option) { case FlatBufferDeserializationOption.Greedy: case FlatBufferDeserializationOption.GreedyMutable: - Assert.False(dobj.CanSerializeWithMemoryCopy); - Assert.Null(dobj.InputBuffer); + Assert.IsFalse(dobj.CanSerializeWithMemoryCopy); + Assert.IsNull(dobj.InputBuffer); break; default: - Assert.True(dobj.CanSerializeWithMemoryCopy); - Assert.NotNull(dobj.InputBuffer); + Assert.IsTrue(dobj.CanSerializeWithMemoryCopy); + Assert.IsNotNull(dobj.InputBuffer); break; } } @@ -165,15 +164,15 @@ public static void AssertMutationWorks( return; default: - var ex = Assert.Throws(new Action(() => + var ex = Assert.ThrowsException(new Action(() => { - var ex = Assert.Throws(set).InnerException; + var ex = Assert.ThrowsException(set).InnerException; throw ex; })); if (isWriteThrough && option == FlatBufferDeserializationOption.GreedyMutable) { - Assert.Equal("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers.", ex.Message); + Assert.AreEqual("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers.", ex.Message); } return; @@ -190,23 +189,23 @@ public static void ValidateListVector( if (items is IFlatBufferDeserializedVector vec) { - Assert.ThrowsAny(() => vec.OffsetOf(-1)); - Assert.ThrowsAny(() => vec.OffsetOf(items.Count)); + Assert.ThrowsException(() => vec.OffsetOf(-1)); + Assert.ThrowsException(() => vec.OffsetOf(items.Count)); for (int i = 0; i < vec.Count; ++i) { - Assert.Equal(vec.OffsetOf(i), vec.OffsetBase + (i * vec.ItemSize)); + Assert.AreEqual(vec.OffsetOf(i), vec.OffsetBase + (i * vec.ItemSize)); } - Assert.ThrowsAny(() => vec.ItemAt(-1)); - Assert.ThrowsAny(() => vec.ItemAt(items.Count)); + Assert.ThrowsException(() => vec.ItemAt(-1)); + Assert.ThrowsException(() => vec.ItemAt(items.Count)); } { T[] target = new T[items.Count]; items.CopyTo(target, 0); - Assert.Equal(items.Count, target.Length); + Assert.AreEqual(items.Count, target.Length); if (option != FlatBufferDeserializationOption.Lazy || typeof(T).IsPrimitive || typeof(T) == typeof(string)) { @@ -214,31 +213,31 @@ public static void ValidateListVector( { if (typeof(T).IsValueType || option == FlatBufferDeserializationOption.Lazy) { - Assert.Equal(items[i], target[i]); + Assert.AreEqual(items[i], target[i]); } else { #pragma warning disable xUnit2005 // Do not use identity check on value type - Assert.Same(items[i], items[i]); + Assert.AreSame(items[i], items[i]); #pragma warning restore xUnit2005 // Do not use identity check on value type } - Assert.Equal(i, items.IndexOf(items[i])); - Assert.True(items.Contains(items[i])); + Assert.AreEqual(i, items.IndexOf(items[i])); + Assert.IsTrue(items.Contains(items[i])); } } else if (!typeof(T).IsValueType) { for (int i = 0; i < items.Count; ++i) { - Assert.NotEqual(i, items.IndexOf(items[i])); - Assert.False(items.Contains(items[i])); - Assert.NotEqual(items[i], target[i]); + Assert.AreNotEqual(i, items.IndexOf(items[i])); + Assert.IsFalse(items.Contains(items[i])); + Assert.AreNotEqual(items[i], target[i]); } } } - Assert.Equal( + Assert.AreEqual( items.IsReadOnly, option != FlatBufferDeserializationOption.GreedyMutable); @@ -254,24 +253,24 @@ public static void ValidateListVector( // For value types, validate that they are the same. if (typeof(T).IsValueType) { - Assert.Equal(newValue, items[i]); + Assert.AreEqual(newValue, items[i]); } else if (option != FlatBufferDeserializationOption.Lazy) { - Assert.True(object.ReferenceEquals(newValue, items[i])); + Assert.IsTrue(object.ReferenceEquals(newValue, items[i])); } break; default: - var ex = Assert.Throws(new Action(() => + var ex = Assert.ThrowsException(new Action(() => { items[i] = newValue; })); if (isWriteThrough && option == FlatBufferDeserializationOption.GreedyMutable) { - Assert.Equal("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers.", ex.Message); + Assert.AreEqual("WriteThrough fields are implemented as readonly when using 'GreedyMutable' serializers.", ex.Message); } break; @@ -281,27 +280,27 @@ public static void ValidateListVector( if (option == FlatBufferDeserializationOption.GreedyMutable && !isWriteThrough) { items.Clear(); - Assert.Empty(items); + Assert.AreEqual(0, items.Count); items.Add(default); - Assert.Single(items); + Assert.AreEqual(1, items.Count); items.Remove(items[0]); - Assert.Empty(items); + Assert.AreEqual(0, items.Count); items.Insert(0, default); - Assert.Single(items); + Assert.AreEqual(1, items.Count); items.RemoveAt(0); - Assert.Empty(items); + Assert.AreEqual(0, items.Count); } else { - Assert.Throws(() => items.Clear()); - Assert.Throws(() => items.Add(default)); - Assert.Throws(() => items.Remove(items[0])); - Assert.Throws(() => items.Insert(0, default)); - Assert.Throws(() => items.RemoveAt(0)); + Assert.ThrowsException(() => items.Clear()); + Assert.ThrowsException(() => items.Add(default)); + Assert.ThrowsException(() => items.Remove(items[0])); + Assert.ThrowsException(() => items.Insert(0, default)); + Assert.ThrowsException(() => items.RemoveAt(0)); } } @@ -332,23 +331,23 @@ bool IsFieldPresent() return vt.OffsetOf(obj.InputBuffer!, index) != 0; } - Assert.False(IsFieldLoaded()); - Assert.Equal(expected, IsFieldPresent()); + Assert.IsFalse(IsFieldLoaded()); + Assert.AreEqual(expected, IsFieldPresent()); for (int i = 0; i < 10; ++i) { T item = getter(parent); - Assert.True(IsFieldLoaded()); + Assert.IsTrue(IsFieldLoaded()); T next = getter(parent); if (typeof(T).IsValueType) { - Assert.Equal(item, next); + Assert.AreEqual(item, next); } else { - Assert.True(object.ReferenceEquals(item, next)); + Assert.IsTrue(object.ReferenceEquals(item, next)); } } @@ -439,17 +438,17 @@ private static void AssertEquality(FlatBufferDeserializationOption option, T { if (typeof(T).IsValueType && (typeof(T).IsPrimitive || typeof(T).IsEnum)) { - assertEqual = (a, b) => Assert.Equal(a, b); + assertEqual = (a, b) => Assert.AreEqual(a, b); } else if (typeof(T) == typeof(string)) { - assertEqual = (a, b) => Assert.Equal(a, b); + assertEqual = (a, b) => Assert.AreEqual(a, b); } } if (!typeof(T).IsValueType && option != FlatBufferDeserializationOption.Lazy) { - Assert.True(object.ReferenceEquals(a, b)); + Assert.IsTrue(object.ReferenceEquals(a, b)); } assertEqual?.Invoke(a, b); @@ -459,25 +458,25 @@ private static void CheckRangeExceptions(FlatBufferDeserializationOption opti { if (option == FlatBufferDeserializationOption.Lazy || option == FlatBufferDeserializationOption.Progressive) { - Assert.Throws(() => list[-1]); - Assert.Throws(() => list[list.Count]); - Assert.Throws(() => list[-1] = default); - Assert.Throws(() => list[list.Count] = default); + Assert.ThrowsException(() => list[-1]); + Assert.ThrowsException(() => list[list.Count]); + Assert.ThrowsException(() => list[-1] = default); + Assert.ThrowsException(() => list[list.Count] = default); } else if (option == FlatBufferDeserializationOption.Greedy || (isWriteThrough && option == FlatBufferDeserializationOption.GreedyMutable)) { - Assert.Throws(() => list[-1]); - Assert.Throws(() => list[list.Count]); - Assert.Throws(() => list[-1] = default); - Assert.Throws(() => list[list.Count] = default); + Assert.ThrowsException(() => list[-1]); + Assert.ThrowsException(() => list[list.Count]); + Assert.ThrowsException(() => list[-1] = default); + Assert.ThrowsException(() => list[list.Count] = default); } else { - Assert.Throws(() => list[-1]); - Assert.Throws(() => list[list.Count]); - Assert.Throws(() => list[-1] = default); - Assert.Throws(() => list[list.Count] = default); + Assert.ThrowsException(() => list[-1]); + Assert.ThrowsException(() => list[list.Count]); + Assert.ThrowsException(() => list[-1] = default); + Assert.ThrowsException(() => list[list.Count] = default); } } } \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/IO/InputBufferTests.cs b/src/Tests/FlatSharpEndToEndTests/IO/InputBufferTests.cs index a84fa153..979a07dc 100644 --- a/src/Tests/FlatSharpEndToEndTests/IO/InputBufferTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/IO/InputBufferTests.cs @@ -21,6 +21,7 @@ namespace FlatSharpEndToEndTests.IO.InputBufferTests; +[TestClass] public class InputBufferTests { private const string StringData = "how now brown cow"; @@ -45,8 +46,8 @@ static InputBufferTests() StringInput = stringData; } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SerializationInvocations(FlatBufferDeserializationOption option) { var serializer = PrimitiveTypesTable.Serializer.WithSettings(settings => settings.UseDeserializationMode(option)); @@ -68,16 +69,16 @@ public void SerializationInvocations(FlatBufferDeserializationOption option) if (item is IFlatBufferDeserializedObject obj) { - Assert.Equal(option, obj.DeserializationContext.DeserializationOption); + Assert.AreEqual(option, obj.DeserializationContext.DeserializationOption); } else { - Assert.False(true); + Assert.IsFalse(true); } } } - [Fact] + [TestMethod] public void MemoryInputBuffer() { this.InputBufferTest(new MemoryInputBuffer(Input)); @@ -89,7 +90,7 @@ public void MemoryInputBuffer() (s, b) => s.Parse(b.AsMemory())); } - [Fact] + [TestMethod] public void ReadOnlyMemoryInputBuffer() { this.InputBufferTest(new ReadOnlyMemoryInputBuffer(Input)); @@ -97,16 +98,16 @@ public void ReadOnlyMemoryInputBuffer() this.TestDeserialize(b => new ReadOnlyMemoryInputBuffer(b)); this.TestReadByteArray(true, b => new ReadOnlyMemoryInputBuffer(b)); - var ex = Assert.Throws( + var ex = Assert.ThrowsException( () => this.TestDeserialize(b => new ReadOnlyMemoryInputBuffer(b))); - Assert.Equal("ReadOnlyMemory inputs may not deserialize writable memory.", ex.Message); + Assert.AreEqual("ReadOnlyMemory inputs may not deserialize writable memory.", ex.Message); this.TableSerializationTest( default(SpanWriter), (s, b) => s.Parse((ReadOnlyMemory)b.AsMemory())); } - [Fact] + [TestMethod] public void ArrayInputBuffer() { this.InputBufferTest(new ArrayInputBuffer(Input)); @@ -118,7 +119,7 @@ public void ArrayInputBuffer() (s, b) => s.Parse(b)); } - [Fact] + [TestMethod] public void ArraySegmentInputBuffer() { this.InputBufferTest(new ArraySegmentInputBuffer(new ArraySegment(Input))); @@ -155,27 +156,27 @@ private void TableSerializationTest( PrimitiveTypesTable.Serializer.Write(writer, data, original); PrimitiveTypesTable parsed = parse(PrimitiveTypesTable.Serializer, data); - Assert.Equal(original.A, parsed.A); - Assert.Equal(original.B, parsed.B); - Assert.Equal(original.C, parsed.C); - Assert.Equal(original.D, parsed.D); - Assert.Equal(original.E, parsed.E); - Assert.Equal(original.F, parsed.F); - Assert.Equal(original.G, parsed.G); - Assert.Equal(original.H, parsed.H); - Assert.Equal(original.I, parsed.I); - Assert.Equal(original.J, parsed.J); - Assert.Equal(original.K, parsed.K); - Assert.Equal(original.L, parsed.L); - Assert.Equal(original.M, parsed.M); + Assert.AreEqual(original.A, parsed.A); + Assert.AreEqual(original.B, parsed.B); + Assert.AreEqual(original.C, parsed.C); + Assert.AreEqual(original.D, parsed.D); + Assert.AreEqual(original.E, parsed.E); + Assert.AreEqual(original.F, parsed.F); + Assert.AreEqual(original.G, parsed.G); + Assert.AreEqual(original.H, parsed.H); + Assert.AreEqual(original.I, parsed.I); + Assert.AreEqual(original.J, parsed.J); + Assert.AreEqual(original.K, parsed.K); + Assert.AreEqual(original.L, parsed.L); + Assert.AreEqual(original.M, parsed.M); } private void InputBufferTest(IInputBuffer ib) { var mem = new Memory(Input); - Assert.False(ib.ReadBool(0)); - Assert.True(ib.ReadBool(1)); + Assert.IsFalse(ib.ReadBool(0)); + Assert.IsTrue(ib.ReadBool(1)); this.CompareEqual(sizeof(byte), i => mem.Span[i], i => ib.ReadByte(i)); this.CompareEqual(sizeof(sbyte), i => (sbyte)mem.Span[i], i => ib.ReadSByte(i)); @@ -197,7 +198,7 @@ private void InputBufferTest(IInputBuffer ib) private void StringInputBufferTest(IInputBuffer ib) { - Assert.Equal(StringData, ib.ReadString(0)); + Assert.AreEqual(StringData, ib.ReadString(0)); } private void CompareEqual( @@ -209,7 +210,7 @@ private void CompareEqual( { var memory = readMemoryAtIndex(i); var bufferValue = readAtIndex(i); - Assert.Equal(memory, bufferValue); + Assert.AreEqual(memory, bufferValue); } } @@ -226,22 +227,22 @@ private void TestReadByteArray(bool isReadOnly, Func b byte[] expected = new byte[] { 1, 2, 3, 4, 5, 6, 7, }; - Assert.True(inputBuffer.ReadByteReadOnlyMemoryBlock(0).Span.SequenceEqual(expected)); - Assert.Equal(isReadOnly, inputBuffer.IsReadOnly); + Assert.IsTrue(inputBuffer.ReadByteReadOnlyMemoryBlock(0).Span.SequenceEqual(expected)); + Assert.AreEqual(isReadOnly, inputBuffer.IsReadOnly); - Assert.True(inputBuffer.GetReadOnlySpan().SequenceEqual(buffer)); - Assert.True(inputBuffer.GetReadOnlyMemory().Span.SequenceEqual(buffer)); + Assert.IsTrue(inputBuffer.GetReadOnlySpan().SequenceEqual(buffer)); + Assert.IsTrue(inputBuffer.GetReadOnlyMemory().Span.SequenceEqual(buffer)); if (isReadOnly) { - Assert.Throws(() => inputBuffer.GetSpan()); - Assert.Throws(() => inputBuffer.GetMemory()); + Assert.ThrowsException(() => inputBuffer.GetSpan()); + Assert.ThrowsException(() => inputBuffer.GetMemory()); } else { - Assert.True(inputBuffer.GetMemory().Span.SequenceEqual(buffer)); - Assert.True(inputBuffer.GetSpan().SequenceEqual(buffer)); - Assert.True(inputBuffer.ReadByteMemoryBlock(0).Span.SequenceEqual(expected)); + Assert.IsTrue(inputBuffer.GetMemory().Span.SequenceEqual(buffer)); + Assert.IsTrue(inputBuffer.GetSpan().SequenceEqual(buffer)); + Assert.IsTrue(inputBuffer.ReadByteMemoryBlock(0).Span.SequenceEqual(expected)); } } @@ -261,7 +262,7 @@ private void TestDeserialize(Func bufferBuilder var parsed = table.Serializer.Parse(buffer); for (int i = 1; i <= 5; ++i) { - Assert.Equal(i + 5, parsed.Memory.Span[i - 1]); + Assert.AreEqual(i + 5, parsed.Memory.Span[i - 1]); } } } diff --git a/src/Tests/FlatSharpEndToEndTests/MetadataAttributes/MetadataAttributeTests.cs b/src/Tests/FlatSharpEndToEndTests/MetadataAttributes/MetadataAttributeTests.cs index f2535f5c..3b01e49c 100644 --- a/src/Tests/FlatSharpEndToEndTests/MetadataAttributes/MetadataAttributeTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/MetadataAttributes/MetadataAttributeTests.cs @@ -14,102 +14,99 @@ * limitations under the License. */ -using System.Threading; -using System.Threading.Tasks; -using Grpc.Core; -using Other.Namespace.Foobar; -using SChannel = System.Threading.Channels.Channel; - namespace FlatSharpEndToEndTests.MetadataAttributes; +[TestClass] public class MetadataAttributesTestCases { - [Fact] +#if !AOT + [TestMethod] public void Enum_Attributes() { var attrs = GetAttributes(); - Assert.Single(attrs); - Assert.Equal("MyEnum", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("MyEnum", attrs["test"]); attrs = GetAttributes(typeof(MyEnum).GetMember("A").Single()); - Assert.Single(attrs); - Assert.Equal("A", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("A", attrs["test"]); attrs = GetAttributes(typeof(MyEnum).GetMember("B").Single()); - Assert.Single(attrs); - Assert.Equal("B", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("B", attrs["test"]); } +#endif - [Fact] + [TestMethod] public void Union_Attributes() { var attrs = GetAttributes(); - Assert.Single(attrs); - Assert.Equal("MyUnion", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("MyUnion", attrs["test"]); } - [Fact] + [TestMethod] public void Value_Struct_Attributes() { var attrs = GetAttributes(); - Assert.Equal(2, attrs.Count); - Assert.Equal("ValueStruct", attrs["test"]); - Assert.Equal("0", attrs["fs_valueStruct"]); // empty + Assert.AreEqual(2, attrs.Count); + Assert.AreEqual("ValueStruct", attrs["test"]); + Assert.AreEqual("0", attrs["fs_valueStruct"]); // empty attrs = GetAttributes(typeof(ValueStruct).GetField("I")); - Assert.Single(attrs); - Assert.Equal("i", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("i", attrs["test"]); } - [Fact] + [TestMethod] public void Ref_Struct_Attributes() { var attrs = GetAttributes(); - Assert.Single(attrs); - Assert.Equal("RefStruct", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("RefStruct", attrs["test"]); attrs = GetAttributes(typeof(RefStruct).GetProperty("I")); - Assert.Single(attrs); - Assert.Equal("i", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("i", attrs["test"]); } - [Fact] + [TestMethod] public void Service_Attributes() { var attrs = GetAttributes(typeof(EchoService)); - Assert.Equal(2, attrs.Count); - Assert.Equal("0", attrs["fs_rpcInterface"]); - Assert.Equal("EchoService", attrs["test"]); + Assert.AreEqual(2, attrs.Count); + Assert.AreEqual("0", attrs["fs_rpcInterface"]); + Assert.AreEqual("EchoService", attrs["test"]); } - [Fact] + [TestMethod] public void Table_Attributes() { var attrs = GetAttributes(); - Assert.Equal(2, attrs.Count); - Assert.Equal("Lazy", attrs["fs_serializer"]); - Assert.Equal("Message", attrs["test"]); + Assert.AreEqual(2, attrs.Count); + Assert.AreEqual("Lazy", attrs["fs_serializer"]); + Assert.AreEqual("Message", attrs["test"]); attrs = GetAttributes(typeof(Message).GetProperty("Value")); - Assert.Equal(3, attrs.Count); - Assert.Equal("0", attrs["required"]); - Assert.Equal("0", attrs["fs_sharedString"]); - Assert.Equal("value", attrs["test"]); + Assert.AreEqual(3, attrs.Count); + Assert.AreEqual("0", attrs["required"]); + Assert.AreEqual("0", attrs["fs_sharedString"]); + Assert.AreEqual("value", attrs["test"]); attrs = GetAttributes(typeof(Message).GetProperty("SingleInt")); - Assert.Single(attrs); - Assert.Equal("single_int", attrs["test"]); + Assert.AreEqual(1, attrs.Count); + Assert.AreEqual("single_int", attrs["test"]); attrs = GetAttributes(typeof(Message).GetProperty("VectorInt")); - Assert.Equal(2, attrs.Count); - Assert.Equal("IList", attrs["fs_vectorKind"]); - Assert.Equal("vector_int", attrs["test"]); + Assert.AreEqual(2, attrs.Count); + Assert.AreEqual("IList", attrs["fs_vectorKind"]); + Assert.AreEqual("vector_int", attrs["test"]); attrs = GetAttributes(typeof(Message).GetProperty("ValueStruct")); - Assert.Equal(3, attrs.Count); - Assert.Equal("0", attrs["required"]); - Assert.Equal("0", attrs["fs_writeThrough"]); - Assert.Equal("value_struct", attrs["test"]); + Assert.AreEqual(3, attrs.Count); + Assert.AreEqual("0", attrs["required"]); + Assert.AreEqual("0", attrs["fs_writeThrough"]); + Assert.AreEqual("value_struct", attrs["test"]); } private static Dictionary GetAttributes() => GetAttributes(typeof(T)); diff --git a/src/Tests/FlatSharpEndToEndTests/Oracle/AlignmentTests.cs b/src/Tests/FlatSharpEndToEndTests/Oracle/AlignmentTests.cs index 3b83c097..401ee20a 100644 --- a/src/Tests/FlatSharpEndToEndTests/Oracle/AlignmentTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Oracle/AlignmentTests.cs @@ -18,9 +18,10 @@ namespace FlatSharpEndToEndTests.Oracle; +[TestClass] public class AlignmentTests { - [Fact] + [TestMethod] public void NestedStructWithOddAlignment_Parse() { var builder = new FlatBufferBuilder(1024); @@ -33,25 +34,25 @@ public void NestedStructWithOddAlignment_Parse() byte[] realBuffer = builder.SizedByteArray(); var parsed = FS.AlignmentTestOuterHoder.Serializer.Parse(realBuffer); - Assert.NotNull(parsed); + Assert.IsNotNull(parsed); var outer = parsed.Value; - Assert.NotNull(outer); - Assert.Equal(1, outer.A); - Assert.Equal(2, outer.B); - Assert.Equal(3, outer.C); - Assert.Equal(4u, outer.D); - Assert.Equal(5, outer.E); - Assert.Equal(6ul, outer.F); + Assert.IsNotNull(outer); + Assert.AreEqual(1, outer.A); + Assert.AreEqual(2, outer.B); + Assert.AreEqual(3, outer.C); + Assert.AreEqual(4u, outer.D); + Assert.AreEqual(5, outer.E); + Assert.AreEqual(6ul, outer.F); var inner = outer.G; - Assert.NotNull(inner); - Assert.Equal(7, inner.A); - Assert.Equal(8, inner.B); - Assert.Equal(9, inner.C); + Assert.IsNotNull(inner); + Assert.AreEqual(7, inner.A); + Assert.AreEqual(8, inner.B); + Assert.AreEqual(9, inner.C); } - [Fact] + [TestMethod] public void NestedStructWithOddAlignment_Serialize() { FS.AlignmentTestOuterHoder holder = new() @@ -79,20 +80,20 @@ public void NestedStructWithOddAlignment_Serialize() var parsed = Flatc.AlignmentTestOuterHoder.GetRootAsAlignmentTestOuterHoder(new ByteBuffer(memory.Slice(0, offset).ToArray())); var outer = parsed.Value.Value; - Assert.Equal(1, outer.A); - Assert.Equal(2, outer.B); - Assert.Equal(3, outer.C); - Assert.Equal(4u, outer.D); - Assert.Equal(5, outer.E); - Assert.Equal(6ul, outer.F); + Assert.AreEqual(1, outer.A); + Assert.AreEqual(2, outer.B); + Assert.AreEqual(3, outer.C); + Assert.AreEqual(4u, outer.D); + Assert.AreEqual(5, outer.E); + Assert.AreEqual(6ul, outer.F); var inner = outer.G; - Assert.Equal(7, inner.A); - Assert.Equal(8, inner.B); - Assert.Equal(9, inner.C); + Assert.AreEqual(7, inner.A); + Assert.AreEqual(8, inner.B); + Assert.AreEqual(9, inner.C); } - [Fact] + [TestMethod] public void StructVectorDeserialize() { Flatc.StructVectorsTableT table = new Flatc.StructVectorsTableT @@ -117,22 +118,22 @@ public void StructVectorDeserialize() var parsed = FS.StructVectorsTable.Serializer.Parse(serialized); - Assert.Equal(1, parsed.Vec.HashVec[0]); - Assert.Equal(2, parsed.Vec.HashVec[1]); - Assert.Equal(3, parsed.Vec.HashVec[2]); - Assert.Equal(4, parsed.Vec.HashVec[3]); + Assert.AreEqual(1, parsed.Vec.HashVec[0]); + Assert.AreEqual(2, parsed.Vec.HashVec[1]); + Assert.AreEqual(3, parsed.Vec.HashVec[2]); + Assert.AreEqual(4, parsed.Vec.HashVec[3]); - Assert.Equal(5, parsed.Vec.AlignmentVec[0].Int); - Assert.Equal(6, parsed.Vec.AlignmentVec[0].Byte); + Assert.AreEqual(5, parsed.Vec.AlignmentVec[0].Int); + Assert.AreEqual(6, parsed.Vec.AlignmentVec[0].Byte); - Assert.Equal(7, parsed.Vec.AlignmentVec[1].Int); - Assert.Equal(8, parsed.Vec.AlignmentVec[1].Byte); + Assert.AreEqual(7, parsed.Vec.AlignmentVec[1].Int); + Assert.AreEqual(8, parsed.Vec.AlignmentVec[1].Byte); - Assert.Equal(9, parsed.Vec.AlignmentVec[2].Int); - Assert.Equal(10, parsed.Vec.AlignmentVec[2].Byte); + Assert.AreEqual(9, parsed.Vec.AlignmentVec[2].Int); + Assert.AreEqual(10, parsed.Vec.AlignmentVec[2].Byte); } - [Fact] + [TestMethod] public void StructVectorSerialize() { FS.StructVectorsTable table = new() @@ -154,18 +155,18 @@ public void StructVectorSerialize() var parsed = Flatc.StructVectorsTable.GetRootAsStructVectorsTable(new ByteBuffer(data)).UnPack(); - Assert.Equal(1, parsed.Vec.HashVec[0]); - Assert.Equal(2, parsed.Vec.HashVec[1]); - Assert.Equal(3, parsed.Vec.HashVec[2]); - Assert.Equal(4, parsed.Vec.HashVec[3]); + Assert.AreEqual(1, parsed.Vec.HashVec[0]); + Assert.AreEqual(2, parsed.Vec.HashVec[1]); + Assert.AreEqual(3, parsed.Vec.HashVec[2]); + Assert.AreEqual(4, parsed.Vec.HashVec[3]); - Assert.Equal(5, parsed.Vec.AlignmentVec[0].Int); - Assert.Equal(6, parsed.Vec.AlignmentVec[0].Byte); + Assert.AreEqual(5, parsed.Vec.AlignmentVec[0].Int); + Assert.AreEqual(6, parsed.Vec.AlignmentVec[0].Byte); - Assert.Equal(7, parsed.Vec.AlignmentVec[1].Int); - Assert.Equal(8, parsed.Vec.AlignmentVec[1].Byte); + Assert.AreEqual(7, parsed.Vec.AlignmentVec[1].Int); + Assert.AreEqual(8, parsed.Vec.AlignmentVec[1].Byte); - Assert.Equal(9, parsed.Vec.AlignmentVec[2].Int); - Assert.Equal(10, parsed.Vec.AlignmentVec[2].Byte); + Assert.AreEqual(9, parsed.Vec.AlignmentVec[2].Int); + Assert.AreEqual(10, parsed.Vec.AlignmentVec[2].Byte); } } diff --git a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs index 4fe4d40b..cfec4b3d 100644 --- a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs @@ -24,9 +24,10 @@ namespace FlatSharpEndToEndTests.Oracle; /// Does oracle-based testing using Google's flatbuffers code. These tests all boil down to: /// Can we parse data we created using the official Google library? /// +[TestClass] public partial class OracleDeserializeTests { - [Fact] + [TestMethod] public void SimpleTypes() { var builder = new FlatBufferBuilder(1024); @@ -54,30 +55,30 @@ public void SimpleTypes() foreach (var parsed in new[] { simple }) { - Assert.True(parsed.Bool); - Assert.Equal(oracle.Byte, parsed.Byte); - Assert.Equal(oracle.SByte, parsed.SByte); + Assert.IsTrue(parsed.Bool); + Assert.AreEqual(oracle.Byte, parsed.Byte); + Assert.AreEqual(oracle.SByte, parsed.SByte); - Assert.Equal(oracle.UShort, parsed.UShort); - Assert.Equal(oracle.Short, parsed.Short); + Assert.AreEqual(oracle.UShort, parsed.UShort); + Assert.AreEqual(oracle.Short, parsed.Short); - Assert.Equal(oracle.UInt, parsed.UInt); - Assert.Equal(oracle.Int, parsed.Int); + Assert.AreEqual(oracle.UInt, parsed.UInt); + Assert.AreEqual(oracle.Int, parsed.Int); - Assert.Equal(oracle.ULong, parsed.ULong); - Assert.Equal(oracle.Long, parsed.Long); + Assert.AreEqual(oracle.ULong, parsed.ULong); + Assert.AreEqual(oracle.Long, parsed.Long); - Assert.Equal(oracle.Float, parsed.Float); - Assert.Equal(oracle.Double, parsed.Double); - Assert.Equal("foobar", parsed.String); + Assert.AreEqual(oracle.Float, parsed.Float); + Assert.AreEqual(oracle.Double, parsed.Double); + Assert.AreEqual("foobar", parsed.String); } // Ensures the caching works correctly. //Assert.ReferenceEquals(cached.String, cached.String); - Assert.True(object.ReferenceEquals(simple.String, simple.String)); + Assert.IsTrue(object.ReferenceEquals(simple.String, simple.String)); } - [Fact] + [TestMethod] public void LinkedList() { var builder = new FlatBufferBuilder(1024); @@ -94,15 +95,15 @@ public void LinkedList() var linkedList = FS.LinkedListNode.Serializer.Parse(realBuffer); - Assert.NotNull(linkedList); - Assert.NotNull(linkedList.Next); - Assert.Null(linkedList.Next.Next); + Assert.IsNotNull(linkedList); + Assert.IsNotNull(linkedList.Next); + Assert.IsNull(linkedList.Next.Next); - Assert.Equal("node 1", linkedList.Value); - Assert.Equal("node 2", linkedList.Next.Value); + Assert.AreEqual("node 1", linkedList.Value); + Assert.AreEqual("node 2", linkedList.Next.Value); } - [Fact] + [TestMethod] public void ScalarVectors() { var builder = new FlatBufferBuilder(1024); @@ -121,30 +122,30 @@ public void ScalarVectors() var parsed = FS.Vectors.Serializer.Parse(realBuffer); IList intItems = parsed.IntVector; - Assert.Equal(6, intItems.Count); + Assert.AreEqual(6, intItems.Count); for (int i = 0; i < 6; ++i) { - Assert.Equal(1 + i, intItems[i]); + Assert.AreEqual(1 + i, intItems[i]); } IList longItems = parsed.LongVector; - Assert.Equal(6, longItems.Count); + Assert.AreEqual(6, longItems.Count); for (int i = 0; i < 6; ++i) { - Assert.Equal(7 + i, longItems[i]); + Assert.AreEqual(7 + i, longItems[i]); } Memory mem = parsed.ByteVector2.Value; - Assert.Equal(5, mem.Length); + Assert.AreEqual(5, mem.Length); for (int i = 1; i <= 5; ++i) { - Assert.Equal(i, mem.Span[i - 1]); + Assert.AreEqual(i, mem.Span[i - 1]); } - Assert.True(parsed.ByteVector3.IsEmpty); + Assert.IsTrue(parsed.ByteVector3.IsEmpty); } - [Fact] + [TestMethod] public void LocationStruct() { var builder = new FlatBufferBuilder(1024); @@ -166,21 +167,21 @@ public void LocationStruct() byte[] realBuffer = builder.SizedByteArray(); var parsed = FS.LocationHolder.Serializer.Parse(realBuffer); - Assert.Equal("foobar", parsed.Fake); - Assert.Equal(0.1f, parsed.SingleLocation.X); - Assert.Equal(0.2f, parsed.SingleLocation.Y); - Assert.Equal(0.3f, parsed.SingleLocation.Z); - Assert.Equal(3, parsed.LocationVector.Count); + Assert.AreEqual("foobar", parsed.Fake); + Assert.AreEqual(0.1f, parsed.SingleLocation.X); + Assert.AreEqual(0.2f, parsed.SingleLocation.Y); + Assert.AreEqual(0.3f, parsed.SingleLocation.Z); + Assert.AreEqual(3, parsed.LocationVector.Count); for (int i = 0; i < 3; ++i) { - Assert.Equal((float)(3 * i + 1), parsed.LocationVector[i].X); - Assert.Equal((float)(3 * i + 2), parsed.LocationVector[i].Y); - Assert.Equal((float)(3 * i + 3), parsed.LocationVector[i].Z); + Assert.AreEqual((float)(3 * i + 1), parsed.LocationVector[i].X); + Assert.AreEqual((float)(3 * i + 2), parsed.LocationVector[i].Y); + Assert.AreEqual((float)(3 * i + 3), parsed.LocationVector[i].Z); } } - [Fact] + [TestMethod] public void FiveByteStructVector() { var builder = new FlatBufferBuilder(1024); @@ -199,18 +200,18 @@ public void FiveByteStructVector() byte[] realBuffer = builder.SizedByteArray(); var parsed = FS.FiveByteStructTable.Serializer.Parse(realBuffer); - Assert.Equal(3, parsed.Vector.Count); + Assert.AreEqual(3, parsed.Vector.Count); - Assert.Equal(1, parsed.Vector[0].Int); - Assert.Equal(2, parsed.Vector[1].Int); - Assert.Equal(3, parsed.Vector[2].Int); + Assert.AreEqual(1, parsed.Vector[0].Int); + Assert.AreEqual(2, parsed.Vector[1].Int); + Assert.AreEqual(3, parsed.Vector[2].Int); - Assert.Equal((byte)1, parsed.Vector[0].Byte); - Assert.Equal((byte)2, parsed.Vector[1].Byte); - Assert.Equal((byte)3, parsed.Vector[2].Byte); + Assert.AreEqual((byte)1, parsed.Vector[0].Byte); + Assert.AreEqual((byte)2, parsed.Vector[1].Byte); + Assert.AreEqual((byte)3, parsed.Vector[2].Byte); } - [Fact] + [TestMethod] public void Union_Table_BasicTypes() { var builder = new FlatBufferBuilder(1024); @@ -240,29 +241,29 @@ public void Union_Table_BasicTypes() var oracle = Flatc.UnionTable.GetRootAsUnionTable(new ByteBuffer(realBuffer)).Value().Value; var unionTable = FS.UnionTable.Serializer.Parse(realBuffer); - Assert.Equal(1, unionTable.Value.Value.Discriminator); + Assert.AreEqual(1, unionTable.Value.Value.Discriminator); var parsed = unionTable.Value.Value.Item1; - Assert.NotNull(parsed); + Assert.IsNotNull(parsed); - Assert.True(parsed.Bool); - Assert.Equal(oracle.Byte, parsed.Byte); - Assert.Equal(oracle.SByte, parsed.SByte); + Assert.IsTrue(parsed.Bool); + Assert.AreEqual(oracle.Byte, parsed.Byte); + Assert.AreEqual(oracle.SByte, parsed.SByte); - Assert.Equal(oracle.UShort, parsed.UShort); - Assert.Equal(oracle.Short, parsed.Short); + Assert.AreEqual(oracle.UShort, parsed.UShort); + Assert.AreEqual(oracle.Short, parsed.Short); - Assert.Equal(oracle.UInt, parsed.UInt); - Assert.Equal(oracle.Int, parsed.Int); + Assert.AreEqual(oracle.UInt, parsed.UInt); + Assert.AreEqual(oracle.Int, parsed.Int); - Assert.Equal(oracle.ULong, parsed.ULong); - Assert.Equal(oracle.Long, parsed.Long); + Assert.AreEqual(oracle.ULong, parsed.ULong); + Assert.AreEqual(oracle.Long, parsed.Long); - Assert.Equal(oracle.Float, parsed.Float); - Assert.Equal(oracle.Double, parsed.Double); - Assert.Equal("foobar", parsed.String); + Assert.AreEqual(oracle.Float, parsed.Float); + Assert.AreEqual(oracle.Double, parsed.Double); + Assert.AreEqual("foobar", parsed.String); } - [Fact] + [TestMethod] public void Union_Struct_Location() { var builder = new FlatBufferBuilder(1024); @@ -281,16 +282,16 @@ public void Union_Struct_Location() byte[] realBuffer = builder.DataBuffer.ToSizedArray(); var unionTable = FS.UnionTable.Serializer.Parse(realBuffer); - Assert.Equal(2, unionTable.Value.Value.Discriminator); + Assert.AreEqual(2, unionTable.Value.Value.Discriminator); var parsed = unionTable.Value.Value.Item2; - Assert.NotNull(parsed); + Assert.IsNotNull(parsed); - Assert.Equal(1.0f, parsed.X); - Assert.Equal(2.0f, parsed.Y); - Assert.Equal(3.0f, parsed.Z); + Assert.AreEqual(1.0f, parsed.X); + Assert.AreEqual(2.0f, parsed.Y); + Assert.AreEqual(3.0f, parsed.Z); } - [Fact] + [TestMethod] public void Union_String() { var builder = new FlatBufferBuilder(1024); @@ -305,12 +306,12 @@ public void Union_String() byte[] realBuffer = builder.DataBuffer.ToSizedArray(); var unionTable = FS.UnionTable.Serializer.Parse(realBuffer); - Assert.Equal(3, unionTable.Value.Value.Discriminator); + Assert.AreEqual(3, unionTable.Value.Value.Discriminator); string parsed = unionTable.Value.Value.Item3; - Assert.Equal("foobar", parsed); + Assert.AreEqual("foobar", parsed); } - [Fact] + [TestMethod] public void Union_NotSet() { var builder = new FlatBufferBuilder(1024); @@ -321,10 +322,10 @@ public void Union_NotSet() byte[] realBuffer = builder.DataBuffer.ToSizedArray(); var unionTable = FS.UnionTable.Serializer.Parse(realBuffer); - Assert.Null(unionTable.Value); + Assert.IsNull(unionTable.Value); } - [Fact] + [TestMethod] public void NestedStruct() { var builder = new FlatBufferBuilder(1024); @@ -338,14 +339,14 @@ public void NestedStruct() var parsed = FS.NestedStructs.Serializer.Parse(realBuffer); - Assert.NotNull(parsed.Outer?.Inner); + Assert.IsNotNull(parsed.Outer?.Inner); - Assert.Equal(401, parsed.Outer.Inner.A); - Assert.Equal(100, parsed.Outer.A); + Assert.AreEqual(401, parsed.Outer.Inner.A); + Assert.AreEqual(100, parsed.Outer.A); } - [Fact] + [TestMethod] public void VectorOfUnion() { Flatc.VectorOfUnionTableT table = new Flatc.VectorOfUnionTableT @@ -365,26 +366,26 @@ public void VectorOfUnion() var parsed = FS.VectorOfUnionTable.Serializer.Parse(data); - Assert.Equal(3, parsed.Value.Count); + Assert.AreEqual(3, parsed.Value.Count); - Assert.Equal(1, parsed.Value[0].Discriminator); - Assert.Equal(2, parsed.Value[1].Discriminator); - Assert.Equal(3, parsed.Value[2].Discriminator); + Assert.AreEqual(1, parsed.Value[0].Discriminator); + Assert.AreEqual(2, parsed.Value[1].Discriminator); + Assert.AreEqual(3, parsed.Value[2].Discriminator); - Assert.True(parsed.Value[0].TryGet(out FS.BasicTypes basicTypes)); - Assert.Equal(7, basicTypes.Int); + Assert.IsTrue(parsed.Value[0].TryGet(out FS.BasicTypes basicTypes)); + Assert.AreEqual(7, basicTypes.Int); - Assert.True(parsed.Value[1].TryGet(out FS.Location location)); - Assert.Equal(1, location.X); - Assert.Equal(2, location.Y); - Assert.Equal(3, location.Z); + Assert.IsTrue(parsed.Value[1].TryGet(out FS.Location location)); + Assert.AreEqual(1, location.X); + Assert.AreEqual(2, location.Y); + Assert.AreEqual(3, location.Z); - Assert.True(parsed.Value[2].TryGet(out string str)); - Assert.Equal("foobar", str); + Assert.IsTrue(parsed.Value[2].TryGet(out string str)); + Assert.AreEqual("foobar", str); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SortedVectors(FlatBufferDeserializationOption option) { var builder = new FlatBufferBuilder(1024 * 1024); @@ -439,7 +440,7 @@ public void SortedVectors(FlatBufferDeserializationOption option) VerifySorted(parsed.Double, s => s.Value, Comparer.Default, doubles, new List { Math.PI, Math.E, Math.Sqrt(2) }); } - [Fact] + [TestMethod] public void SortedVectors_NullKey_NotAllowed() { var builder = new FlatBufferBuilder(1024 * 1024); @@ -459,7 +460,7 @@ public void SortedVectors_NullKey_NotAllowed() stringOffsets.Add(Flatc.SortedVectorStringTable.CreateSortedVectorStringTable(builder, strOffset)); } - Assert.Throws( + Assert.ThrowsException( () => Flatc.SortedVectorStringTable.CreateSortedVectorOfSortedVectorStringTable(builder, stringOffsets.ToArray())); } @@ -475,18 +476,18 @@ private static void VerifySorted( for (int i = 1; i < items.Count; ++i) { TKey current = keyGetter(items[i]); - Assert.True(comparer.Compare(previous, current) <= 0); + Assert.IsTrue(comparer.Compare(previous, current) <= 0); } foreach (var expectedItem in expectedItems) { var item = items.BinarySearchByFlatBufferKey(expectedItem); - Assert.NotNull(item); + Assert.IsNotNull(item); } foreach (var unexpectedItem in unexpectedItems) { - Assert.Null(items.BinarySearchByFlatBufferKey(unexpectedItem)); + Assert.IsNull(items.BinarySearchByFlatBufferKey(unexpectedItem)); } } diff --git a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs index 96840b5a..d480e5f0 100644 --- a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs @@ -23,9 +23,10 @@ namespace FlatSharpEndToEndTests.Oracle; /// Does oracle-based testing using the Google.Flatbuffers code. These test all boil down to: /// Can the Google Flatbuffer code parse data we generated? /// +[TestClass] public partial class OracleSerializeTests { - [Fact] + [TestMethod] public void SimpleTypes_WithValues() { var simple = new FS.BasicTypes() @@ -48,27 +49,27 @@ public void SimpleTypes_WithValues() int size = FS.BasicTypes.Serializer.Write(memory, simple); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.BasicTypesVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.BasicTypesVerify.Verify(new(bb), 4)); var oracle = Flatc.BasicTypes.GetRootAsBasicTypes(bb); - Assert.Equal(oracle.Byte, simple.Byte); - Assert.Equal(oracle.SByte, simple.SByte); + Assert.AreEqual(oracle.Byte, simple.Byte); + Assert.AreEqual(oracle.SByte, simple.SByte); - Assert.Equal(oracle.UShort, simple.UShort); - Assert.Equal(oracle.Short, simple.Short); + Assert.AreEqual(oracle.UShort, simple.UShort); + Assert.AreEqual(oracle.Short, simple.Short); - Assert.Equal(oracle.UInt, simple.UInt); - Assert.Equal(oracle.Int, simple.Int); + Assert.AreEqual(oracle.UInt, simple.UInt); + Assert.AreEqual(oracle.Int, simple.Int); - Assert.Equal(oracle.ULong, simple.ULong); - Assert.Equal(oracle.Long, simple.Long); + Assert.AreEqual(oracle.ULong, simple.ULong); + Assert.AreEqual(oracle.Long, simple.Long); - Assert.Equal(oracle.Float, simple.Float); - Assert.Equal(oracle.Double, simple.Double); - Assert.Equal(oracle.String, simple.String); + Assert.AreEqual(oracle.Float, simple.Float); + Assert.AreEqual(oracle.Double, simple.Double); + Assert.AreEqual(oracle.String, simple.String); } - [Fact] + [TestMethod] public void SimpleTypes_Defaults() { var simple = new FS.BasicTypes(); @@ -77,27 +78,27 @@ public void SimpleTypes_Defaults() int size = FS.BasicTypes.Serializer.Write(memory, simple); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.BasicTypesVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.BasicTypesVerify.Verify(new(bb), 4)); var oracle = Flatc.BasicTypes.GetRootAsBasicTypes(bb); - Assert.Equal(oracle.Byte, simple.Byte); - Assert.Equal(oracle.SByte, simple.SByte); + Assert.AreEqual(oracle.Byte, simple.Byte); + Assert.AreEqual(oracle.SByte, simple.SByte); - Assert.Equal(oracle.UShort, simple.UShort); - Assert.Equal(oracle.Short, simple.Short); + Assert.AreEqual(oracle.UShort, simple.UShort); + Assert.AreEqual(oracle.Short, simple.Short); - Assert.Equal(oracle.UInt, simple.UInt); - Assert.Equal(oracle.Int, simple.Int); + Assert.AreEqual(oracle.UInt, simple.UInt); + Assert.AreEqual(oracle.Int, simple.Int); - Assert.Equal(oracle.ULong, simple.ULong); - Assert.Equal(oracle.Long, simple.Long); + Assert.AreEqual(oracle.ULong, simple.ULong); + Assert.AreEqual(oracle.Long, simple.Long); - Assert.Equal(oracle.Float, simple.Float); - Assert.Equal(oracle.Double, simple.Double); - Assert.Equal(oracle.String, simple.String); + Assert.AreEqual(oracle.Float, simple.Float); + Assert.AreEqual(oracle.Double, simple.Double); + Assert.AreEqual(oracle.String, simple.String); } - [Fact] + [TestMethod] public void LinkedList() { var simple = new FS.LinkedListNode @@ -114,15 +115,15 @@ public void LinkedList() int size = FS.LinkedListNode.Serializer.Write(memory, simple); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.LinkedListNodeVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.LinkedListNodeVerify.Verify(new(bb), 4)); var oracle = Flatc.LinkedListNode.GetRootAsLinkedListNode(bb); - Assert.Equal(oracle.Value, simple.Value); - Assert.Equal(oracle.Next?.Value, simple.Next.Value); - Assert.Null(oracle.Next?.Next); + Assert.AreEqual(oracle.Value, simple.Value); + Assert.AreEqual(oracle.Next?.Value, simple.Next.Value); + Assert.IsNull(oracle.Next?.Next); } - [Fact] + [TestMethod] public void StructWithinTable() { FS.LocationHolder holder = new() @@ -141,29 +142,29 @@ public void StructWithinTable() int size = FS.LocationHolder.Serializer.Write(memory, holder); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.LocationHolderVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.LocationHolderVerify.Verify(new(bb), 4)); var oracle = Flatc.LocationHolder.GetRootAsLocationHolder(bb); - Assert.Equal(holder.Fake, oracle.Fake); + Assert.AreEqual(holder.Fake, oracle.Fake); - Assert.Equal(holder.SingleLocation.X, oracle.SingleLocation.Value.X); - Assert.Equal(holder.SingleLocation.Y, oracle.SingleLocation.Value.Y); - Assert.Equal(holder.SingleLocation.Z, oracle.SingleLocation.Value.Z); + Assert.AreEqual(holder.SingleLocation.X, oracle.SingleLocation.Value.X); + Assert.AreEqual(holder.SingleLocation.Y, oracle.SingleLocation.Value.Y); + Assert.AreEqual(holder.SingleLocation.Z, oracle.SingleLocation.Value.Z); - Assert.Equal(holder.LocationVector.Count, oracle.LocationVectorLength); + Assert.AreEqual(holder.LocationVector.Count, oracle.LocationVectorLength); for (int i = 0; i < holder.LocationVector.Count; ++i) { var holderLoc = holder.LocationVector[i]; var oracleLoc = oracle.LocationVector(i); - Assert.Equal(holderLoc.X, oracleLoc.Value.X); - Assert.Equal(holderLoc.Y, oracleLoc.Value.Y); - Assert.Equal(holderLoc.Z, oracleLoc.Value.Z); + Assert.AreEqual(holderLoc.X, oracleLoc.Value.X); + Assert.AreEqual(holderLoc.Y, oracleLoc.Value.Y); + Assert.AreEqual(holderLoc.Z, oracleLoc.Value.Z); } } - [Fact] + [TestMethod] public void ScalarVectors() { FS.Vectors table = new() @@ -179,37 +180,37 @@ public void ScalarVectors() int size = FS.Vectors.Serializer.Write(memory, table); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.VectorsVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.VectorsVerify.Verify(new(bb), 4)); var oracle = Flatc.Vectors.GetRootAsVectors(bb); - Assert.Equal(table.IntVector.Count, oracle.IntVectorLength); - Assert.Equal(table.LongVector.Count, oracle.LongVectorLength); - Assert.Equal(table.ByteVector1.Value.Length, oracle.ByteVector1Length); - Assert.Equal(table.ByteVector2.Value.Length, oracle.ByteVector2Length); - Assert.Equal(table.ByteVector3.Length, oracle.ByteVector3Length); + Assert.AreEqual(table.IntVector.Count, oracle.IntVectorLength); + Assert.AreEqual(table.LongVector.Count, oracle.LongVectorLength); + Assert.AreEqual(table.ByteVector1.Value.Length, oracle.ByteVector1Length); + Assert.AreEqual(table.ByteVector2.Value.Length, oracle.ByteVector2Length); + Assert.AreEqual(table.ByteVector3.Length, oracle.ByteVector3Length); for (int i = 0; i < table.IntVector.Count; ++i) { - Assert.Equal(table.IntVector[i], oracle.IntVector(i)); + Assert.AreEqual(table.IntVector[i], oracle.IntVector(i)); } for (int i = 0; i < table.LongVector.Count; ++i) { - Assert.Equal(table.LongVector[i], oracle.LongVector(i)); + Assert.AreEqual(table.LongVector[i], oracle.LongVector(i)); } for (int i = 0; i < table.ByteVector1.Value.Length; ++i) { - Assert.Equal(table.ByteVector1.Value.Span[i], oracle.ByteVector1(i)); + Assert.AreEqual(table.ByteVector1.Value.Span[i], oracle.ByteVector1(i)); } for (int i = 0; i < table.ByteVector2.Value.Length; ++i) { - Assert.Equal(table.ByteVector2.Value.Span[i], oracle.ByteVector2(i)); + Assert.AreEqual(table.ByteVector2.Value.Span[i], oracle.ByteVector2(i)); } } - [Fact] + [TestMethod] public void FiveByteStructVector() { FS.FiveByteStructTable table = new() @@ -227,22 +228,22 @@ public void FiveByteStructVector() buffer = buffer.Slice(0, bytecount); var bb = new ByteBuffer(buffer.ToArray()); - Assert.True(Flatc.FiveByteStructTableVerify.Verify(new Verifier(bb), 4)); + Assert.IsTrue(Flatc.FiveByteStructTableVerify.Verify(new Verifier(bb), 4)); var oracle = Flatc.FiveByteStructTable.GetRootAsFiveByteStructTable(bb); - Assert.Equal(3, oracle.VectorLength); + Assert.AreEqual(3, oracle.VectorLength); - Assert.Equal(1, oracle.Vector(0).Value.Int); - Assert.Equal((byte)1, oracle.Vector(0).Value.Byte); + Assert.AreEqual(1, oracle.Vector(0).Value.Int); + Assert.AreEqual((byte)1, oracle.Vector(0).Value.Byte); - Assert.Equal(2, oracle.Vector(1).Value.Int); - Assert.Equal((byte)2, oracle.Vector(1).Value.Byte); + Assert.AreEqual(2, oracle.Vector(1).Value.Int); + Assert.AreEqual((byte)2, oracle.Vector(1).Value.Byte); - Assert.Equal(3, oracle.Vector(2).Value.Int); - Assert.Equal((byte)3, oracle.Vector(2).Value.Byte); + Assert.AreEqual(3, oracle.Vector(2).Value.Int); + Assert.AreEqual((byte)3, oracle.Vector(2).Value.Byte); } - [Fact] + [TestMethod] public void Union_Table_BasicTypes() { var simple = new FS.BasicTypes() @@ -270,31 +271,31 @@ public void Union_Table_BasicTypes() int size = FS.UnionTable.Serializer.Write(memory, table); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.UnionTableVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.UnionTableVerify.Verify(new(bb), 4)); var oracle = Flatc.UnionTable.GetRootAsUnionTable(bb); - Assert.Equal(1, (int)oracle.ValueType); + Assert.AreEqual(1, (int)oracle.ValueType); var bt = oracle.Value().Value; - Assert.True(bt.Bool); - Assert.Equal(bt.Byte, simple.Byte); - Assert.Equal(bt.SByte, simple.SByte); + Assert.IsTrue(bt.Bool); + Assert.AreEqual(bt.Byte, simple.Byte); + Assert.AreEqual(bt.SByte, simple.SByte); - Assert.Equal(bt.UShort, simple.UShort); - Assert.Equal(bt.Short, simple.Short); + Assert.AreEqual(bt.UShort, simple.UShort); + Assert.AreEqual(bt.Short, simple.Short); - Assert.Equal(bt.UInt, simple.UInt); - Assert.Equal(bt.Int, simple.Int); + Assert.AreEqual(bt.UInt, simple.UInt); + Assert.AreEqual(bt.Int, simple.Int); - Assert.Equal(bt.ULong, simple.ULong); - Assert.Equal(bt.Long, simple.Long); + Assert.AreEqual(bt.ULong, simple.ULong); + Assert.AreEqual(bt.Long, simple.Long); - Assert.Equal(bt.Float, simple.Float); - Assert.Equal(bt.Double, simple.Double); - Assert.Equal(bt.String, simple.String); + Assert.AreEqual(bt.Float, simple.Float); + Assert.AreEqual(bt.Double, simple.Double); + Assert.AreEqual(bt.String, simple.String); } - [Fact] + [TestMethod] public void Union_String() { var table = new FS.UnionTable @@ -306,14 +307,14 @@ public void Union_String() int size = FS.UnionTable.Serializer.Write(memory, table); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.UnionTableVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.UnionTableVerify.Verify(new(bb), 4)); var oracle = Flatc.UnionTable.GetRootAsUnionTable(bb); - Assert.Equal(3, (int)oracle.ValueType); - Assert.Equal("foobar", oracle.ValueAsString()); + Assert.AreEqual(3, (int)oracle.ValueType); + Assert.AreEqual("foobar", oracle.ValueAsString()); } - [Fact] + [TestMethod] public void Union_NotSet() { var table = new FS.UnionTable @@ -325,13 +326,13 @@ public void Union_NotSet() int size = FS.UnionTable.Serializer.Write(memory, table); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.UnionTableVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.UnionTableVerify.Verify(new(bb), 4)); var oracle = Flatc.UnionTable.GetRootAsUnionTable(bb); - Assert.Equal(0, (int)oracle.ValueType); + Assert.AreEqual(0, (int)oracle.ValueType); } - [Fact] + [TestMethod] public void Union_Struct_Location() { var location = new FS.Location @@ -350,18 +351,18 @@ public void Union_Struct_Location() int size = FS.UnionTable.Serializer.Write(memory, table); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.UnionTableVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.UnionTableVerify.Verify(new(bb), 4)); var oracle = Flatc.UnionTable.GetRootAsUnionTable(bb); - Assert.Equal(2, (int)oracle.ValueType); + Assert.AreEqual(2, (int)oracle.ValueType); var bt = oracle.Value().Value; - Assert.Equal(bt.X, location.X); - Assert.Equal(bt.Y, location.Y); - Assert.Equal(bt.Z, location.Z); + Assert.AreEqual(bt.X, location.X); + Assert.AreEqual(bt.Y, location.Y); + Assert.AreEqual(bt.Z, location.Z); } - [Fact] + [TestMethod] public void NestedStruct_InnerStructSet() { var nested = new FS.NestedStructs @@ -377,17 +378,17 @@ public void NestedStruct_InnerStructSet() int size = FS.NestedStructs.Serializer.Write(memory, nested); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.NestedStructsVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.NestedStructsVerify.Verify(new(bb), 4)); var oracle = Flatc.NestedStructs.GetRootAsNestedStructs(bb); - Assert.NotNull(oracle.Outer); + Assert.IsNotNull(oracle.Outer); var outer = oracle.Outer.Value; - Assert.Equal(100, outer.A); - Assert.Equal(401, outer.Inner.A); + Assert.AreEqual(100, outer.A); + Assert.AreEqual(401, outer.Inner.A); } - [Fact] + [TestMethod] public void NestedStruct_InnerStructNotSet() { var nested = new FS.NestedStructs @@ -403,17 +404,17 @@ public void NestedStruct_InnerStructNotSet() int size = FS.NestedStructs.Serializer.Write(memory, nested); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.NestedStructsVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.NestedStructsVerify.Verify(new(bb), 4)); var oracle = Flatc.NestedStructs.GetRootAsNestedStructs(bb); - Assert.NotNull(oracle.Outer); + Assert.IsNotNull(oracle.Outer); var outer = oracle.Outer.Value; - Assert.Equal(100, outer.A); - Assert.Equal(0, outer.Inner.A); + Assert.AreEqual(100, outer.A); + Assert.AreEqual(0, outer.Inner.A); } - [Fact] + [TestMethod] public void VectorOfUnion() { FS.VectorOfUnionTable table = new() @@ -430,28 +431,28 @@ public void VectorOfUnion() int size = FS.VectorOfUnionTable.Serializer.Write(memory, table); var bb = new ByteBuffer(memory.Slice(0, size).ToArray()); - Assert.True(Flatc.UnionVectorTableVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.UnionVectorTableVerify.Verify(new(bb), 4)); var oracle = Flatc.UnionVectorTable.GetRootAsUnionVectorTable(bb); - Assert.Equal(3, oracle.ValueLength); + Assert.AreEqual(3, oracle.ValueLength); - Assert.Equal(Flatc.Union.BasicTypes, oracle.ValueType(0)); - Assert.Equal(Flatc.Union.Location, oracle.ValueType(1)); - Assert.Equal(Flatc.Union.stringValue, oracle.ValueType(2)); + Assert.AreEqual(Flatc.Union.BasicTypes, oracle.ValueType(0)); + Assert.AreEqual(Flatc.Union.Location, oracle.ValueType(1)); + Assert.AreEqual(Flatc.Union.stringValue, oracle.ValueType(2)); var basicTypes = oracle.Value(0).Value; - Assert.Equal(7, basicTypes.Int); + Assert.AreEqual(7, basicTypes.Int); var location = oracle.Value(1).Value; - Assert.Equal(1, location.X); - Assert.Equal(2, location.Y); - Assert.Equal(3, location.Z); + Assert.AreEqual(1, location.X); + Assert.AreEqual(2, location.Y); + Assert.AreEqual(3, location.Z); string stringValue = oracle.ValueAsString(2); - Assert.Equal("foobar", stringValue); + Assert.AreEqual("foobar", stringValue); } - [Fact] + [TestMethod] public void SortedVectors() { var test = new FS.SortedVectorTest @@ -478,7 +479,7 @@ public void SortedVectors() var parsed = FS.SortedVectorTest.Serializer.Parse(data); var bb = new ByteBuffer(data); - Assert.True(Flatc.SortedVectorTestVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.SortedVectorTestVerify.Verify(new(bb), 4)); var table = Flatc.SortedVectorTest.GetRootAsSortedVectorTest(bb); VerifySorted, FS.SortedVectorStringTable, string>(parsed.String, i => i.Value, i => table.String(i)?.Value, t => table.StringByKey(t) != null, new Utf8StringComparer()); @@ -486,7 +487,7 @@ public void SortedVectors() VerifySorted, FS.SortedVectorDoubleTable, double>(parsed.Double, i => i.Value, i => table.Double(i).Value.Value, t => table.DoubleByKey(t) != null, Comparer.Default); } - [Fact] + [TestMethod] public void SortedVectors_DefaultValue() { var test = new FS.SortedVectorTest @@ -495,7 +496,7 @@ public void SortedVectors_DefaultValue() }; var myItem = new FS.SortedVectorInt32Table(); - Assert.Equal(5, myItem.Value); + Assert.AreEqual(5, myItem.Value); byte[] data = new byte[1024 * 1024]; @@ -514,7 +515,7 @@ public void SortedVectors_DefaultValue() var parsed = FS.SortedVectorTest.Serializer.Parse(data); var bb = new ByteBuffer(data); - Assert.True(Flatc.SortedVectorTestVerify.Verify(new(bb), 4)); + Assert.IsTrue(Flatc.SortedVectorTestVerify.Verify(new(bb), 4)); var table = Flatc.SortedVectorTest.GetRootAsSortedVectorTest(bb); VerifySorted, FS.SortedVectorInt32Table, int>(parsed.Int32, i => i.Value, i => table.Int32(i).Value.Value, t => table.Int32ByKey(t) != null, Comparer.Default); @@ -528,19 +529,19 @@ private static void VerifySorted( IComparer comparer) where TList : IList { TKey previous = keyGet(items[0]); - Assert.True(oracleContains(previous)); + Assert.IsTrue(oracleContains(previous)); for (int i = 0; i < items.Count; ++i) { TKey current = keyGet(items[i]); TKey oracle = oracleGet(i); - Assert.True(comparer.Compare(previous, current) <= 0, $"Expect: {previous} <= {current}"); - Assert.True(comparer.Compare(previous, oracle) <= 0, $"Expect: {previous} <= {oracle}"); - Assert.True(comparer.Compare(current, oracle) == 0, $"Expect: {current} == {oracle}"); + Assert.IsTrue(comparer.Compare(previous, current) <= 0, $"Expect: {previous} <= {current}"); + Assert.IsTrue(comparer.Compare(previous, oracle) <= 0, $"Expect: {previous} <= {oracle}"); + Assert.IsTrue(comparer.Compare(current, oracle) == 0, $"Expect: {current} == {oracle}"); // FlatBuffers c# has a bug where binary search is broken when using default values. - Assert.True(oracleContains(current)); + Assert.IsTrue(oracleContains(current)); } } diff --git a/src/Tests/FlatSharpEndToEndTests/PartialMethods/PartialMethodsTests.cs b/src/Tests/FlatSharpEndToEndTests/PartialMethods/PartialMethodsTests.cs index 800716f9..2f99c644 100644 --- a/src/Tests/FlatSharpEndToEndTests/PartialMethods/PartialMethodsTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/PartialMethods/PartialMethodsTests.cs @@ -16,10 +16,11 @@ namespace FlatSharpEndToEndTests.PartialMethods; +[TestClass] public class PartialMethods { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void OnInitialized(FlatBufferDeserializationOption option) { Table template = new() @@ -27,16 +28,16 @@ public void OnInitialized(FlatBufferDeserializationOption option) S = new() { A = 4 } }; - Assert.Null(template.OnInitializedContext); - Assert.Null(template.S.OnInitializedContext); + Assert.IsNull(template.OnInitializedContext); + Assert.IsNull(template.S.OnInitializedContext); Table parsed = template.SerializeAndParse(option); - Assert.NotNull(parsed.OnInitializedContext); - Assert.NotNull(parsed.S.OnInitializedContext); + Assert.IsNotNull(parsed.OnInitializedContext); + Assert.IsNotNull(parsed.S.OnInitializedContext); - Assert.Equal(option, parsed.OnInitializedContext.Value.DeserializationOption); - Assert.Equal(option, parsed.S.OnInitializedContext.Value.DeserializationOption); + Assert.AreEqual(option, parsed.OnInitializedContext.Value.DeserializationOption); + Assert.AreEqual(option, parsed.S.OnInitializedContext.Value.DeserializationOption); } } diff --git a/src/Tests/FlatSharpEndToEndTests/Program.cs b/src/Tests/FlatSharpEndToEndTests/Program.cs new file mode 100644 index 00000000..e7042097 --- /dev/null +++ b/src/Tests/FlatSharpEndToEndTests/Program.cs @@ -0,0 +1,41 @@ +/* + * Copyright 2023 James Courtney + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#if AOT + +using Microsoft.Testing.Framework; +using Microsoft.Testing.Platform.Builder; +using System.Threading.Tasks; +using Microsoft.Testing.Extensions; + +namespace FlatSharpEndToEndTests; + +public static class Program +{ + public static int Main(string[] args) + { + Console.WriteLine("Beginning AOT test pass..."); + + var builder = TestApplication.CreateBuilderAsync(args).GetAwaiter().GetResult(); + // Registers TestFramework, with tree of test nodes + // that are generated into your project by source generator. + builder.AddTestFramework(new SourceGeneratedTestNodesBuilder()); + var app = builder.BuildAsync().GetAwaiter().GetResult(); + return app.RunAsync().GetAwaiter().GetResult(); + } +} + +#endif \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/RawData/RawDataSharedStringTests.cs b/src/Tests/FlatSharpEndToEndTests/RawData/RawDataSharedStringTests.cs index 659db80d..b1f3317a 100644 --- a/src/Tests/FlatSharpEndToEndTests/RawData/RawDataSharedStringTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/RawData/RawDataSharedStringTests.cs @@ -16,9 +16,10 @@ namespace FlatSharpEndToEndTests.RawData; +[TestClass] public class RawDataSharedStringTests { - [Fact] + [TestMethod] public void SharedStrings_Vector_Disabled() { var t = new SharedStringTable @@ -55,10 +56,10 @@ public void SharedStrings_Vector_Disabled() (byte)'n', (byte)'g', 0, // null terminator }; - Assert.True(expectedBytes.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedBytes.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void SharedStrings_Table_Disabled() { var t = new SharedStringTable @@ -92,10 +93,10 @@ public void SharedStrings_Table_Disabled() (byte)'n', (byte)'g', 0, // null terminator. }; - Assert.True(expectedBytes.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedBytes.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void SharedStrings_Table() { var t = new SharedStringTable @@ -122,10 +123,10 @@ public void SharedStrings_Table() (byte)'n', (byte)'g', 0, // null terminator. }; - Assert.True(expectedBytes.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedBytes.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void SharedStrings_Table_WithNull() { var t = new SharedStringTable @@ -149,10 +150,10 @@ public void SharedStrings_Table_WithNull() (byte)'n', (byte)'g', 0 // null terminator. }; - Assert.True(expectedBytes.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedBytes.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void SharedStrings_Table_WithEviction() { var t = new SharedStringTable @@ -185,10 +186,10 @@ public void SharedStrings_Table_WithEviction() (byte)'n', (byte)'g', 0 // null terminator }; - Assert.True(expectedBytes.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedBytes.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void SharedStrings_Vector() { var t = new SharedStringTable @@ -217,6 +218,6 @@ public void SharedStrings_Vector() (byte)'n', (byte)'g', 0, }; - Assert.True(expectedBytes.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedBytes.AsSpan().SequenceEqual(buffer)); } } \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/RawData/RawDataStringTests.cs b/src/Tests/FlatSharpEndToEndTests/RawData/RawDataStringTests.cs index 3ddd7a06..b5cabe5d 100644 --- a/src/Tests/FlatSharpEndToEndTests/RawData/RawDataStringTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/RawData/RawDataStringTests.cs @@ -18,9 +18,10 @@ namespace FlatSharpEndToEndTests.RawData; using StringTable = FlatSharpEndToEndTests.TableMembers.StringTable; +[TestClass] public class RawDataStringTests { - [Fact] + [TestMethod] public void EmptyString() { var root = new StringTable @@ -43,10 +44,10 @@ public void EmptyString() 0, // null terminator (special case for strings). }; - Assert.True(expectedResult.AsSpan().SequenceEqual(data)); + Assert.IsTrue(expectedResult.AsSpan().SequenceEqual(data)); } - [Fact] + [TestMethod] public void DeprecatedString() { var root = new StringTable @@ -64,10 +65,10 @@ public void DeprecatedString() 4, 0, // table length }; - Assert.True(expectedResult.AsSpan().SequenceEqual(data)); + Assert.IsTrue(expectedResult.AsSpan().SequenceEqual(data)); } - [Fact] + [TestMethod] public void SimpleString() { var root = new StringTable @@ -90,10 +91,10 @@ public void SimpleString() 1, 2, 3, 0, // data + null terminator (special case for string vectors). }; - Assert.True(expectedResult.AsSpan().SequenceEqual(target)); + Assert.IsTrue(expectedResult.AsSpan().SequenceEqual(target)); } - [Fact] + [TestMethod] public void StringVector() { var root = new StringTable @@ -128,6 +129,6 @@ public void StringVector() (byte)'g', (byte)'h', (byte)'i', 0, // string 2 }; - Assert.True(expectedResult.AsSpan().SequenceEqual(data)); + Assert.IsTrue(expectedResult.AsSpan().SequenceEqual(data)); } } \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/RawData/RawDataTableTests.cs b/src/Tests/FlatSharpEndToEndTests/RawData/RawDataTableTests.cs index 846dca72..8fe9256a 100644 --- a/src/Tests/FlatSharpEndToEndTests/RawData/RawDataTableTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/RawData/RawDataTableTests.cs @@ -18,9 +18,10 @@ namespace FlatSharpEndToEndTests.RawData; +[TestClass] public class RawDataTableTests { - [Fact] + [TestMethod] public void AllMembersNull() { SimpleTable table = new SimpleTable(); @@ -34,10 +35,10 @@ public void AllMembersNull() 4, 0, }; - Assert.True(expectedData.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedData.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void TableWithStruct() { SimpleTable table = new SimpleTable @@ -61,10 +62,10 @@ public void TableWithStruct() 4, 0, // Index 1 offset }; - Assert.True(expectedData.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedData.AsSpan().SequenceEqual(buffer)); } - [Fact] + [TestMethod] public void TableWithStructAndString() { SimpleTable table = new SimpleTable @@ -91,11 +92,11 @@ public void TableWithStructAndString() 104, 105, 0, // hi + null terminator }; - Assert.True(expectedData.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedData.AsSpan().SequenceEqual(buffer)); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void TableWithNullReferenceStruct(FlatBufferDeserializationOption option) { SimpleTable table = new SimpleTable @@ -124,16 +125,16 @@ public void TableWithNullReferenceStruct(FlatBufferDeserializationOption option) 4, 0, // Index 4 offset }; - Assert.True(expectedData.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedData.AsSpan().SequenceEqual(buffer)); SimpleTable parsed = SimpleTable.Serializer.Parse(buffer, option); - Assert.Equal(0u, parsed.OuterStruct.Inner.Uint); - Assert.Equal(0, parsed.OuterStruct.Inner.Byte); - Assert.Equal(0L, parsed.OuterStruct.Inner.Long); + Assert.AreEqual(0u, parsed.OuterStruct.Inner.Uint); + Assert.AreEqual(0, parsed.OuterStruct.Inner.Byte); + Assert.AreEqual(0L, parsed.OuterStruct.Inner.Long); } - [Fact] + [TestMethod] public void EmptyTable_Serialize_MaxSize() { EmptyTable table = new EmptyTable(); @@ -148,43 +149,43 @@ public void EmptyTable_Serialize_MaxSize() 4, 0, }; - Assert.True(expectedData.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedData.AsSpan().SequenceEqual(buffer)); int maxSize = EmptyTable.Serializer.GetMaxSize(table); - Assert.Equal(23, maxSize); + Assert.AreEqual(23, maxSize); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Table_With_Default_Values(FlatBufferDeserializationOption option) { DefaultValueTypes defaults = new(); - Assert.True(defaults.Bool); - Assert.Equal(1, defaults.Byte); - Assert.Equal(-1, defaults.Sbyte); - Assert.Equal(ushort.MaxValue, defaults.Ushort); - Assert.Equal(short.MinValue, defaults.Short); - Assert.Equal(uint.MaxValue, defaults.Uint); - Assert.Equal(int.MinValue, defaults.Int); - Assert.Equal(3.14f, defaults.Float); - Assert.Equal(long.MaxValue, defaults.Ulong); // FlatC issue where it can't represent defaults over long.MaxValue - Assert.Equal(long.MinValue, defaults.Long); - Assert.Equal(3.14159d, defaults.Double); - Assert.Equal(SimpleEnum.B, defaults.SimpleEnum); - - Assert.Null(defaults.OptBool); - Assert.Null(defaults.OptByte); - Assert.Null(defaults.OptSbyte); - Assert.Null(defaults.OptUshort); - Assert.Null(defaults.OptShort); - Assert.Null(defaults.OptInt); - Assert.Null(defaults.OptUint); - Assert.Null(defaults.OptFloat); - Assert.Null(defaults.OptUlong); - Assert.Null(defaults.OptLong); - Assert.Null(defaults.OptDouble); - Assert.Null(defaults.OptSimpleEnum); + Assert.IsTrue(defaults.Bool); + Assert.AreEqual(1, defaults.Byte); + Assert.AreEqual(-1, defaults.Sbyte); + Assert.AreEqual(ushort.MaxValue, defaults.Ushort); + Assert.AreEqual(short.MinValue, defaults.Short); + Assert.AreEqual(uint.MaxValue, defaults.Uint); + Assert.AreEqual(int.MinValue, defaults.Int); + Assert.AreEqual(3.14f, defaults.Float); + Assert.AreEqual(long.MaxValue, defaults.Ulong); // FlatC issue where it can't represent defaults over long.MaxValue + Assert.AreEqual(long.MinValue, defaults.Long); + Assert.AreEqual(3.14159d, defaults.Double); + Assert.AreEqual(SimpleEnum.B, defaults.SimpleEnum); + + Assert.IsNull(defaults.OptBool); + Assert.IsNull(defaults.OptByte); + Assert.IsNull(defaults.OptSbyte); + Assert.IsNull(defaults.OptUshort); + Assert.IsNull(defaults.OptShort); + Assert.IsNull(defaults.OptInt); + Assert.IsNull(defaults.OptUint); + Assert.IsNull(defaults.OptFloat); + Assert.IsNull(defaults.OptUlong); + Assert.IsNull(defaults.OptLong); + Assert.IsNull(defaults.OptDouble); + Assert.IsNull(defaults.OptSimpleEnum); byte[] buffer = defaults.AllocateAndSerialize(); @@ -196,39 +197,39 @@ public void Table_With_Default_Values(FlatBufferDeserializationOption option) 4, 0, }; - Assert.True(expectedData.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(expectedData.AsSpan().SequenceEqual(buffer)); defaults = DefaultValueTypes.Serializer.Parse(buffer, option); - Assert.True(defaults.Bool); - Assert.Equal(1, defaults.Byte); - Assert.Equal(-1, defaults.Sbyte); - Assert.Equal(ushort.MaxValue, defaults.Ushort); - Assert.Equal(short.MinValue, defaults.Short); - Assert.Equal(uint.MaxValue, defaults.Uint); - Assert.Equal(int.MinValue, defaults.Int); - Assert.Equal(3.14f, defaults.Float); - Assert.Equal(long.MaxValue, defaults.Ulong); // FlatC issue where it can't represent defaults over long.MaxValue - Assert.Equal(long.MinValue, defaults.Long); - Assert.Equal(3.14159d, defaults.Double); - Assert.Equal(SimpleEnum.B, defaults.SimpleEnum); - - Assert.Null(defaults.OptBool); - Assert.Null(defaults.OptByte); - Assert.Null(defaults.OptSbyte); - Assert.Null(defaults.OptUshort); - Assert.Null(defaults.OptShort); - Assert.Null(defaults.OptInt); - Assert.Null(defaults.OptUint); - Assert.Null(defaults.OptFloat); - Assert.Null(defaults.OptUlong); - Assert.Null(defaults.OptLong); - Assert.Null(defaults.OptDouble); - Assert.Null(defaults.OptSimpleEnum); + Assert.IsTrue(defaults.Bool); + Assert.AreEqual(1, defaults.Byte); + Assert.AreEqual(-1, defaults.Sbyte); + Assert.AreEqual(ushort.MaxValue, defaults.Ushort); + Assert.AreEqual(short.MinValue, defaults.Short); + Assert.AreEqual(uint.MaxValue, defaults.Uint); + Assert.AreEqual(int.MinValue, defaults.Int); + Assert.AreEqual(3.14f, defaults.Float); + Assert.AreEqual(long.MaxValue, defaults.Ulong); // FlatC issue where it can't represent defaults over long.MaxValue + Assert.AreEqual(long.MinValue, defaults.Long); + Assert.AreEqual(3.14159d, defaults.Double); + Assert.AreEqual(SimpleEnum.B, defaults.SimpleEnum); + + Assert.IsNull(defaults.OptBool); + Assert.IsNull(defaults.OptByte); + Assert.IsNull(defaults.OptSbyte); + Assert.IsNull(defaults.OptUshort); + Assert.IsNull(defaults.OptShort); + Assert.IsNull(defaults.OptInt); + Assert.IsNull(defaults.OptUint); + Assert.IsNull(defaults.OptFloat); + Assert.IsNull(defaults.OptUlong); + Assert.IsNull(defaults.OptLong); + Assert.IsNull(defaults.OptDouble); + Assert.IsNull(defaults.OptSimpleEnum); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void DeprecatedValue_IgnoreOnRead(FlatBufferDeserializationOption option) { // hand-craft a table here: @@ -248,17 +249,17 @@ public void DeprecatedValue_IgnoreOnRead(FlatBufferDeserializationOption option) var parsed = DeprecatedItemTable.Serializer.Parse(data, option); - Assert.Equal(0, parsed.Value); - Assert.Equal(255L, parsed.Other); + Assert.AreEqual(0, parsed.Value); + Assert.AreEqual(255L, parsed.Other); var nonDeprecatedParsed = NonDeprecatedItemTable.Serializer.Parse(data, option); - Assert.Equal(123, nonDeprecatedParsed.Value); - Assert.Equal(255L, nonDeprecatedParsed.Other); + Assert.AreEqual(123, nonDeprecatedParsed.Value); + Assert.AreEqual(255L, nonDeprecatedParsed.Other); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void DeprecatedValue_IgnoreOnWrite(FlatBufferDeserializationOption option) { var deprecatedTable = new DeprecatedItemTable @@ -280,21 +281,21 @@ public void DeprecatedValue_IgnoreOnWrite(FlatBufferDeserializationOption option }; byte[] buffer = deprecatedTable.AllocateAndSerialize(); - Assert.True(data.AsSpan().SequenceEqual(buffer)); + Assert.IsTrue(data.AsSpan().SequenceEqual(buffer)); var nonDeprecatedParsed = NonDeprecatedItemTable.Serializer.Parse(data, option); - Assert.Equal(0, nonDeprecatedParsed.Value); - Assert.Equal(255L, nonDeprecatedParsed.Other); + Assert.AreEqual(0, nonDeprecatedParsed.Value); + Assert.AreEqual(255L, nonDeprecatedParsed.Other); } - [Fact] + [TestMethod] public void ForceWriteTable_WritesDefault() { var table = new ForceWriteTable(); byte[] buffer = table.AllocateAndSerialize(); - Assert.Equal(1, table.Value); + Assert.AreEqual(1, table.Value); byte[] expectedData = { @@ -306,14 +307,14 @@ public void ForceWriteTable_WritesDefault() 4, 0, }; - Assert.True(buffer.AsSpan().SequenceEqual(expectedData)); + Assert.IsTrue(buffer.AsSpan().SequenceEqual(expectedData)); } - [Fact] + [TestMethod] public void NonForceWriteTable_DoesNotWriteDefault() { var table = new NonForceWriteTable(); - Assert.Equal(1, table.Value); + Assert.AreEqual(1, table.Value); byte[] buffer = table.AllocateAndSerialize(); byte[] expectedData = @@ -324,6 +325,6 @@ public void NonForceWriteTable_DoesNotWriteDefault() 4, 0, }; - Assert.True(buffer.AsSpan().SequenceEqual(expectedData)); + Assert.IsTrue(buffer.AsSpan().SequenceEqual(expectedData)); } } \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/Required/Required.cs b/src/Tests/FlatSharpEndToEndTests/Required/Required.cs index 737901a8..cb81032a 100644 --- a/src/Tests/FlatSharpEndToEndTests/Required/Required.cs +++ b/src/Tests/FlatSharpEndToEndTests/Required/Required.cs @@ -18,13 +18,14 @@ namespace FlatSharpEndToEndTests.Required; +[TestClass] public class RequiredTests { - [Theory] - [InlineData("A")] - [InlineData("B")] - [InlineData("C")] - [InlineData("E")] + [TestMethod] + [DataRow("A")] + [DataRow("B")] + [DataRow("C")] + [DataRow("E")] public void Serialize_ReferenceFieldNotPresent(string fieldName) { RequiredTable table = new RequiredTable @@ -39,15 +40,15 @@ public void Serialize_ReferenceFieldNotPresent(string fieldName) typeof(RequiredTable).GetProperty(fieldName).SetMethod.Invoke(table, new object[] { null }); - var ex = Assert.Throws(() => table.AllocateAndSerialize()); - Assert.Equal( + var ex = Assert.ThrowsException(() => table.AllocateAndSerialize()); + Assert.AreEqual( $"Table property 'FlatSharpEndToEndTests.Required.RequiredTable.{fieldName}' is marked as required, but was not set.", ex.Message); } - [Theory] - [InlineData("D")] - [InlineData("F")] + [TestMethod] + [DataRow("D")] + [DataRow("F")] public void Serialize_ValueFields(string fieldName) { RequiredTable table = new RequiredTable @@ -61,13 +62,13 @@ public void Serialize_ValueFields(string fieldName) }; PropertyInfo info = typeof(RequiredTable).GetProperty(fieldName); - Assert.True(info.PropertyType.IsValueType); - Assert.Null(Nullable.GetUnderlyingType(info.PropertyType)); + Assert.IsTrue(info.PropertyType.IsValueType); + Assert.IsNull(Nullable.GetUnderlyingType(info.PropertyType)); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Parse(FlatBufferDeserializationOption option) { void ParseAndUse(string fieldName) @@ -118,8 +119,8 @@ void ParseAndUse(string fieldName) for (char c = 'A'; c <= 'F'; ++c) { - var ex = Assert.Throws(() => ParseAndUse(c.ToString())); - Assert.Equal( + var ex = Assert.ThrowsException(() => ParseAndUse(c.ToString())); + Assert.AreEqual( $"Table property 'FlatSharpEndToEndTests.Required.RequiredTable.{c}' is marked as required, but was missing from the buffer.", ex.Message); } diff --git a/src/Tests/FlatSharpEndToEndTests/SetterTests/AccessModifiers.cs b/src/Tests/FlatSharpEndToEndTests/SetterTests/AccessModifiers.cs index 5c33ae23..7264513e 100644 --- a/src/Tests/FlatSharpEndToEndTests/SetterTests/AccessModifiers.cs +++ b/src/Tests/FlatSharpEndToEndTests/SetterTests/AccessModifiers.cs @@ -16,69 +16,70 @@ namespace FlatSharpEndToEndTests.AccessModifiers; +[TestClass] public class SetterTests { - [Fact] + [TestMethod] public void NoSetter() { var method = this.GetSetMethod(nameof(Table.None)); - Assert.Null(method); + Assert.IsNull(method); } - [Fact] + [TestMethod] public void PublicImplicitSet() { var method = this.GetSetMethod(nameof(Table.PublicImplicit)); - Assert.True(method.IsPublic); - Assert.False(IsInitMethod(method)); + Assert.IsTrue(method.IsPublic); + Assert.IsFalse(IsInitMethod(method)); } - [Fact] + [TestMethod] public void PublicExplicitSet() { var method = this.GetSetMethod(nameof(Table.Public)); - Assert.True(method.IsPublic); - Assert.False(IsInitMethod(method)); + Assert.IsTrue(method.IsPublic); + Assert.IsFalse(IsInitMethod(method)); } - [Fact] + [TestMethod] public void ProtectedSet() { var method = this.GetSetMethod(nameof(Table.Protected)); - Assert.True(method.IsFamily); - Assert.False(IsInitMethod(method)); + Assert.IsTrue(method.IsFamily); + Assert.IsFalse(IsInitMethod(method)); } - [Fact] + [TestMethod] public void ProtectedInternalSet() { var method = this.GetSetMethod(nameof(Table.ProtectedInternal)); - Assert.True(method.IsFamilyOrAssembly); - Assert.False(IsInitMethod(method)); + Assert.IsTrue(method.IsFamilyOrAssembly); + Assert.IsFalse(IsInitMethod(method)); } - [Fact] + [TestMethod] public void PublicExplicitInit() { var method = this.GetSetMethod(nameof(Table.PublicInit)); - Assert.True(method.IsPublic); - Assert.True(IsInitMethod(method)); + Assert.IsTrue(method.IsPublic); + Assert.IsTrue(IsInitMethod(method)); } - [Fact] + [TestMethod] public void ProtectedInit() { var method = this.GetSetMethod(nameof(Table.ProtectedInit)); - Assert.True(method.IsFamily); - Assert.True(IsInitMethod(method)); + Assert.IsTrue(method.IsFamily); + Assert.IsTrue(IsInitMethod(method)); } - [Fact] + [TestMethod] public void ProtectedInternalInit() { var method = this.GetSetMethod(nameof(Table.ProtectedInternalInit)); - Assert.True(method.IsFamilyOrAssembly); - Assert.True(IsInitMethod(method)); + Assert.IsTrue(method.IsFamilyOrAssembly); + Assert.IsTrue(IsInitMethod(method)); } private MethodInfo? GetSetMethod(string name) diff --git a/src/Tests/FlatSharpEndToEndTests/TableMembers/DeserailizationOptionsTests.cs b/src/Tests/FlatSharpEndToEndTests/TableMembers/DeserailizationOptionsTests.cs index 2cab098f..b5c21b71 100644 --- a/src/Tests/FlatSharpEndToEndTests/TableMembers/DeserailizationOptionsTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/TableMembers/DeserailizationOptionsTests.cs @@ -16,6 +16,7 @@ namespace FlatSharpEndToEndTests.TableMembers; +[TestClass] public class DeserializationOptionsTests { private readonly DeserializationOptionsTable Template = new() @@ -26,125 +27,125 @@ public class DeserializationOptionsTests Union = new("banana"), }; - [Fact] + [TestMethod] public void DeserializationOption_Lazy() { DeserializationOptionsTable parsed = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out _); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); - Assert.NotSame(parsed.Str, parsed.Str); - Assert.NotSame(parsed.FirstStruct, parsed.FirstStruct); - Assert.NotSame(parsed.SecondStruct, parsed.SecondStruct); + Assert.AreNotSame(parsed.Str, parsed.Str); + Assert.AreNotSame(parsed.FirstStruct, parsed.FirstStruct); + Assert.AreNotSame(parsed.SecondStruct, parsed.SecondStruct); var first = parsed.FirstStruct; - Assert.NotSame(first.SecondStruct, first.SecondStruct); + Assert.AreNotSame(first.SecondStruct, first.SecondStruct); - Assert.Equal(Template.Str, parsed.Str); - Assert.Equal(Template.FirstStruct.First, parsed.FirstStruct.First); - Assert.Equal(Template.FirstStruct.Second, parsed.FirstStruct.Second); - Assert.Equal(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); + Assert.AreEqual(Template.Str, parsed.Str); + Assert.AreEqual(Template.FirstStruct.First, parsed.FirstStruct.First); + Assert.AreEqual(Template.FirstStruct.Second, parsed.FirstStruct.Second); + Assert.AreEqual(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); - Assert.Equal(3, parsed.Union.Value.Discriminator); + Assert.AreEqual(3, parsed.Union.Value.Discriminator); var union = parsed.Union.Value; - Assert.Equal("banana", union.str); - Assert.Same(union.str, union.str); - - Assert.Throws(() => parsed.Str = null); - Assert.Throws(() => parsed.FirstStruct = null); - Assert.Throws(() => parsed.FirstStruct.First = 0); - Assert.Throws(() => parsed.FirstStruct.SecondStruct = null); - Assert.Throws(() => parsed.FirstStruct.SecondStruct.Value = 0); - Assert.Throws(() => parsed.Union = null); + Assert.AreEqual("banana", union.str); + Assert.AreSame(union.str, union.str); + + Assert.ThrowsException(() => parsed.Str = null); + Assert.ThrowsException(() => parsed.FirstStruct = null); + Assert.ThrowsException(() => parsed.FirstStruct.First = 0); + Assert.ThrowsException(() => parsed.FirstStruct.SecondStruct = null); + Assert.ThrowsException(() => parsed.FirstStruct.SecondStruct.Value = 0); + Assert.ThrowsException(() => parsed.Union = null); } - [Fact] + [TestMethod] public void DeserializationOption_Progressive() { DeserializationOptionsTable parsed = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out _); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); - Assert.Same(parsed.Str, parsed.Str); - Assert.Same(parsed.FirstStruct, parsed.FirstStruct); - Assert.Same(parsed.SecondStruct, parsed.SecondStruct); + Assert.AreSame(parsed.Str, parsed.Str); + Assert.AreSame(parsed.FirstStruct, parsed.FirstStruct); + Assert.AreSame(parsed.SecondStruct, parsed.SecondStruct); var first = parsed.FirstStruct; - Assert.Same(first.SecondStruct, first.SecondStruct); + Assert.AreSame(first.SecondStruct, first.SecondStruct); - Assert.Equal(Template.Str, parsed.Str); - Assert.Equal(Template.FirstStruct.First, parsed.FirstStruct.First); - Assert.Equal(Template.FirstStruct.Second, parsed.FirstStruct.Second); - Assert.Equal(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); + Assert.AreEqual(Template.Str, parsed.Str); + Assert.AreEqual(Template.FirstStruct.First, parsed.FirstStruct.First); + Assert.AreEqual(Template.FirstStruct.Second, parsed.FirstStruct.Second); + Assert.AreEqual(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); - Assert.Equal(3, parsed.Union.Value.Discriminator); + Assert.AreEqual(3, parsed.Union.Value.Discriminator); var union = parsed.Union.Value; - Assert.Equal("banana", union.str); - Assert.Same(union.str, union.str); - - Assert.Throws(() => parsed.Str = null); - Assert.Throws(() => parsed.FirstStruct = null); - Assert.Throws(() => parsed.FirstStruct.First = 0); - Assert.Throws(() => parsed.FirstStruct.SecondStruct = null); - Assert.Throws(() => parsed.FirstStruct.SecondStruct.Value = 0); - Assert.Throws(() => parsed.Union = null); + Assert.AreEqual("banana", union.str); + Assert.AreSame(union.str, union.str); + + Assert.ThrowsException(() => parsed.Str = null); + Assert.ThrowsException(() => parsed.FirstStruct = null); + Assert.ThrowsException(() => parsed.FirstStruct.First = 0); + Assert.ThrowsException(() => parsed.FirstStruct.SecondStruct = null); + Assert.ThrowsException(() => parsed.FirstStruct.SecondStruct.Value = 0); + Assert.ThrowsException(() => parsed.Union = null); } - [Fact] + [TestMethod] public void DeserializationOption_Greedy() { DeserializationOptionsTable parsed = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); - Assert.Same(parsed.Str, parsed.Str); - Assert.Same(parsed.FirstStruct, parsed.FirstStruct); - Assert.Same(parsed.SecondStruct, parsed.SecondStruct); + Assert.AreSame(parsed.Str, parsed.Str); + Assert.AreSame(parsed.FirstStruct, parsed.FirstStruct); + Assert.AreSame(parsed.SecondStruct, parsed.SecondStruct); var first = parsed.FirstStruct; - Assert.Same(first.SecondStruct, first.SecondStruct); + Assert.AreSame(first.SecondStruct, first.SecondStruct); - Assert.Equal(Template.Str, parsed.Str); - Assert.Equal(Template.FirstStruct.First, parsed.FirstStruct.First); - Assert.Equal(Template.FirstStruct.Second, parsed.FirstStruct.Second); - Assert.Equal(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); + Assert.AreEqual(Template.Str, parsed.Str); + Assert.AreEqual(Template.FirstStruct.First, parsed.FirstStruct.First); + Assert.AreEqual(Template.FirstStruct.Second, parsed.FirstStruct.Second); + Assert.AreEqual(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); - Assert.Equal(3, parsed.Union.Value.Discriminator); + Assert.AreEqual(3, parsed.Union.Value.Discriminator); var union = parsed.Union.Value; - Assert.Equal("banana", union.str); - Assert.Same(union.str, union.str); - - Assert.Throws(() => parsed.Str = null); - Assert.Throws(() => parsed.FirstStruct = null); - Assert.Throws(() => parsed.FirstStruct.First = 0); - Assert.Throws(() => parsed.FirstStruct.SecondStruct = null); - Assert.Throws(() => parsed.FirstStruct.SecondStruct.Value = 0); - Assert.Throws(() => parsed.Union = null); + Assert.AreEqual("banana", union.str); + Assert.AreSame(union.str, union.str); + + Assert.ThrowsException(() => parsed.Str = null); + Assert.ThrowsException(() => parsed.FirstStruct = null); + Assert.ThrowsException(() => parsed.FirstStruct.First = 0); + Assert.ThrowsException(() => parsed.FirstStruct.SecondStruct = null); + Assert.ThrowsException(() => parsed.FirstStruct.SecondStruct.Value = 0); + Assert.ThrowsException(() => parsed.Union = null); } - [Fact] + [TestMethod] public void DeserializationOption_GreedyMutable() { DeserializationOptionsTable parsed = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); - Assert.Same(parsed.Str, parsed.Str); - Assert.Same(parsed.FirstStruct, parsed.FirstStruct); - Assert.Same(parsed.SecondStruct, parsed.SecondStruct); + Assert.AreSame(parsed.Str, parsed.Str); + Assert.AreSame(parsed.FirstStruct, parsed.FirstStruct); + Assert.AreSame(parsed.SecondStruct, parsed.SecondStruct); var first = parsed.FirstStruct; - Assert.Same(first.SecondStruct, first.SecondStruct); + Assert.AreSame(first.SecondStruct, first.SecondStruct); - Assert.Equal(Template.Str, parsed.Str); - Assert.Equal(Template.FirstStruct.First, parsed.FirstStruct.First); - Assert.Equal(Template.FirstStruct.Second, parsed.FirstStruct.Second); - Assert.Equal(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); + Assert.AreEqual(Template.Str, parsed.Str); + Assert.AreEqual(Template.FirstStruct.First, parsed.FirstStruct.First); + Assert.AreEqual(Template.FirstStruct.Second, parsed.FirstStruct.Second); + Assert.AreEqual(Template.FirstStruct.SecondStruct.Value, parsed.FirstStruct.SecondStruct.Value); - Assert.Equal(3, parsed.Union.Value.Discriminator); + Assert.AreEqual(3, parsed.Union.Value.Discriminator); var union = parsed.Union.Value; - Assert.Equal("banana", union.str); - Assert.Same(union.str, union.str); + Assert.AreEqual("banana", union.str); + Assert.AreSame(union.str, union.str); parsed.FirstStruct.SecondStruct.Value = 0; parsed.FirstStruct.SecondStruct = null; @@ -156,7 +157,7 @@ public void DeserializationOption_GreedyMutable() // everything is default now. Reparse byte[] reserialized = parsed.AllocateAndSerialize(); - Assert.Equal(12, reserialized.Length); // empty buffer. + Assert.AreEqual(12, reserialized.Length); // empty buffer. } private DeserializationOptionsTable SerializeAndParse(FlatBufferDeserializationOption option, out IFlatBufferDeserializedObject obj, out byte[] inputBuffer) @@ -167,8 +168,8 @@ private DeserializationOptionsTable SerializeAndParse(FlatBufferDeserializationO obj = table as IFlatBufferDeserializedObject; - Assert.NotNull(obj); - Assert.Equal(option, obj.DeserializationContext.DeserializationOption); + Assert.IsNotNull(obj); + Assert.AreEqual(option, obj.DeserializationContext.DeserializationOption); return table; } } \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs b/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs index dd9e352b..27127ce1 100644 --- a/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs @@ -16,14 +16,15 @@ namespace FlatSharpEndToEndTests.TableMembers; +[TestClass] public partial class TableMemberTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Bool(FlatBufferDeserializationOption option) => this.RunTest(true, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Byte(FlatBufferDeserializationOption option) { this.RunTest(1, option); @@ -34,67 +35,67 @@ public void Byte(FlatBufferDeserializationOption option) ByteTable parsed = table.SerializeAndParse(option); - Assert.NotNull(parsed.ItemMemory); - Assert.NotNull(parsed.ItemReadonlyMemory); + Assert.IsNotNull(parsed.ItemMemory); + Assert.IsNotNull(parsed.ItemReadonlyMemory); Memory mem = parsed.ItemMemory.Value; ReadOnlyMemory romem = parsed.ItemReadonlyMemory.Value; for (int i = 0; i < table.ItemMemory.Value.Length; ++i) { - Assert.Equal(table.ItemMemory.Value.Span[i], mem.Span[i]); - Assert.Equal(table.ItemMemory.Value.Span[i], romem.Span[i]); + Assert.AreEqual(table.ItemMemory.Value.Span[i], mem.Span[i]); + Assert.AreEqual(table.ItemMemory.Value.Span[i], romem.Span[i]); } } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SByte(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Short(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UShort(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Int(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UInt(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Long(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ULong(FlatBufferDeserializationOption option) => this.RunTest(1, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Float(FlatBufferDeserializationOption option) => this.RunTest(2.71f, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Double(FlatBufferDeserializationOption option) => this.RunTest(3.14, option); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void String(FlatBufferDeserializationOption option) { { byte[] emptyTable = new EmptyTable().AllocateAndSerialize(); StringTable parsed = StringTable.Serializer.Parse(emptyTable, option); - Assert.Null(parsed.ItemDeprecated); - Assert.Null(parsed.ItemStandard); - Assert.Null(parsed.ItemVectorImplicit); - Assert.Null(parsed.ItemVectorReadonly); + Assert.IsNull(parsed.ItemDeprecated); + Assert.IsNull(parsed.ItemStandard); + Assert.IsNull(parsed.ItemVectorImplicit); + Assert.IsNull(parsed.ItemVectorReadonly); } { @@ -108,19 +109,19 @@ public void String(FlatBufferDeserializationOption option) StringTable parsed = template.SerializeAndParse(option); - Assert.Null(parsed.ItemDeprecated); - Assert.Equal("standard", parsed.ItemStandard); + Assert.IsNull(parsed.ItemDeprecated); + Assert.AreEqual("standard", parsed.ItemStandard); IList @implicit = parsed.ItemVectorImplicit; - Assert.Equal(2, @implicit.Count); - Assert.Equal("a", @implicit[0]); - Assert.Equal("b", @implicit[1]); + Assert.AreEqual(2, @implicit.Count); + Assert.AreEqual("a", @implicit[0]); + Assert.AreEqual("b", @implicit[1]); IReadOnlyList rolist = parsed.ItemVectorReadonly; - Assert.Equal(3, rolist.Count); - Assert.Equal("c", rolist[0]); - Assert.Equal("d", rolist[1]); - Assert.Equal("e", rolist[2]); + Assert.AreEqual(3, rolist.Count); + Assert.AreEqual("c", rolist[0]); + Assert.AreEqual("d", rolist[1]); + Assert.AreEqual("e", rolist[2]); } } @@ -133,12 +134,12 @@ private void RunTest(T expectedDefault, FlatBufferDeserializationOpti TTable @default = new(); TTable parsed = @default.Serializer.Parse(emptyTable, option); - Assert.Null(parsed.ItemList); - Assert.Null(parsed.ItemReadonlyList); - Assert.Null(parsed.ItemOptional); - Assert.Equal(default(T), parsed.ItemStandard); - Assert.Equal(expectedDefault, @default.ItemWithDefault); - Assert.Equal(default(T), parsed.ItemDeprecated); + Assert.IsNull(parsed.ItemList); + Assert.IsNull(parsed.ItemReadonlyList); + Assert.IsNull(parsed.ItemOptional); + Assert.AreEqual(default(T), parsed.ItemStandard); + Assert.AreEqual(expectedDefault, @default.ItemWithDefault); + Assert.AreEqual(default(T), parsed.ItemDeprecated); TTable table = new() { @@ -152,20 +153,20 @@ private void RunTest(T expectedDefault, FlatBufferDeserializationOpti parsed = table.SerializeAndParse(option); - Assert.NotNull(parsed.ItemList); - Assert.NotNull(parsed.ItemReadonlyList); - Assert.Equal(default(T), parsed.ItemOptional.Value); - Assert.Equal(expectedDefault, parsed.ItemStandard); - Assert.Equal(default(T), parsed.ItemWithDefault); - Assert.Equal(default(T), parsed.ItemDeprecated); + Assert.IsNotNull(parsed.ItemList); + Assert.IsNotNull(parsed.ItemReadonlyList); + Assert.AreEqual(default(T), parsed.ItemOptional.Value); + Assert.AreEqual(expectedDefault, parsed.ItemStandard); + Assert.AreEqual(default(T), parsed.ItemWithDefault); + Assert.AreEqual(default(T), parsed.ItemDeprecated); - Assert.Equal(2, parsed.ItemList.Count); - Assert.Equal(2, parsed.ItemReadonlyList.Count); + Assert.AreEqual(2, parsed.ItemList.Count); + Assert.AreEqual(2, parsed.ItemReadonlyList.Count); for (int i = 0; i < 2; ++i) { - Assert.Equal(expectedDefault, parsed.ItemReadonlyList[i]); - Assert.Equal(expectedDefault, parsed.ItemList[i]); + Assert.AreEqual(expectedDefault, parsed.ItemReadonlyList[i]); + Assert.AreEqual(expectedDefault, parsed.ItemList[i]); } } } diff --git a/src/Tests/FlatSharpEndToEndTests/Unions/UnionsTestCases.cs b/src/Tests/FlatSharpEndToEndTests/Unions/UnionsTestCases.cs index 777ff371..f5b3cf99 100644 --- a/src/Tests/FlatSharpEndToEndTests/Unions/UnionsTestCases.cs +++ b/src/Tests/FlatSharpEndToEndTests/Unions/UnionsTestCases.cs @@ -19,22 +19,23 @@ namespace FlatSharpEndToEndTests.Unions; +[TestClass] public class UnionsTestCases { - [Fact] + [TestMethod] public void Custom_Union_Accept_Works() { var c = this.Setup(); UnionVisitor visitor = new(); - Assert.Equal(typeof(A), c.Value[0].Accept(visitor)); - Assert.Equal(typeof(B), c.Value[1].Accept(visitor)); - Assert.Equal(typeof(C), c.Value[2].Accept(visitor)); - Assert.Equal(typeof(D), c.Value[3].Accept(visitor)); + Assert.AreEqual(typeof(A), c.Value[0].Accept(visitor)); + Assert.AreEqual(typeof(B), c.Value[1].Accept(visitor)); + Assert.AreEqual(typeof(C), c.Value[2].Accept(visitor)); + Assert.AreEqual(typeof(D), c.Value[3].Accept(visitor)); } - [Fact] + [TestMethod] public void Custom_Union_Match_Works() { var c = this.Setup(); @@ -49,7 +50,7 @@ public void Custom_Union_Match_Works() c => typeof(C), d => typeof(D)); - Assert.Equal(expected[i], result); + Assert.AreEqual(expected[i], result); } } @@ -58,7 +59,7 @@ public void Custom_Union_Match_Works() /// In this test, the FBS file lies about the size of . Depending on the machine, /// the size should be 16 (SSE), 32 (AVX2), or 64 (AVX512). The FBS defines it as 4 bytes. /// - [Fact] + [TestMethod] public void Unsafe_Unions_ExternalStruct_WrongSize() { long[] headerTrailer = new[] { 0L, -1L }; @@ -67,13 +68,13 @@ public void Unsafe_Unions_ExternalStruct_WrongSize() { Wrapper wrapper = new(); Span wrapperBytes = MemoryMarshal.CreateSpan(ref Unsafe.As, byte>(ref wrapper), Unsafe.SizeOf>()); - var ex = Assert.Throws(() => wrapper.Union = new(new System.Numerics.Vector(1))); - Assert.Contains("to have size 4. Unsafe.SizeOf reported size ", ex.Message); + var ex = Assert.ThrowsException(() => wrapper.Union = new(new System.Numerics.Vector(1))); + Assert.IsTrue(ex.Message.Contains("to have size 4. Unsafe.SizeOf reported size ")); } } #endif - [Fact] + [TestMethod] public void Unsafe_Unions_ExternalStruct_CorrectSize() { long[] headerTrailer = new[] { 0L, -1L }; @@ -86,16 +87,16 @@ public void Unsafe_Unions_ExternalStruct_CorrectSize() wrapper.Trailer = guard; wrapper.Union = new(new System.Numerics.Vector3(1, 2, 3)); - Assert.Equal(UnsafeUnion.ItemKind.ExtCorrect, wrapper.Union.Kind); - Assert.Equal(1.0f, wrapper.Union.ExtCorrect.X); - Assert.Equal(2.0f, wrapper.Union.ExtCorrect.Y); - Assert.Equal(3.0f, wrapper.Union.ExtCorrect.Z); - Assert.Equal(guard, wrapper.Header); - Assert.Equal(guard, wrapper.Trailer); + Assert.AreEqual(UnsafeUnion.ItemKind.ExtCorrect, wrapper.Union.Kind); + Assert.AreEqual(1.0f, wrapper.Union.ExtCorrect.X); + Assert.AreEqual(2.0f, wrapper.Union.ExtCorrect.Y); + Assert.AreEqual(3.0f, wrapper.Union.ExtCorrect.Z); + Assert.AreEqual(guard, wrapper.Header); + Assert.AreEqual(guard, wrapper.Trailer); } } - [Fact] + [TestMethod] public void Unsafe_Unions_DefinedStruct() { long[] headerTrailer = new[] { 0L, -1L }; @@ -108,13 +109,13 @@ public void Unsafe_Unions_DefinedStruct() wrapper.Trailer = guard; wrapper.Union = new(new ValueStructVec3 { X = 1, Y = 2, Z = 3 }); - Assert.Equal(UnsafeUnion.ItemKind.ValueStructVec3, wrapper.Union.Kind); + Assert.AreEqual(UnsafeUnion.ItemKind.ValueStructVec3, wrapper.Union.Kind); - Assert.Equal(1.0f, wrapper.Union.ValueStructVec3.X); - Assert.Equal(2.0f, wrapper.Union.ValueStructVec3.Y); - Assert.Equal(3.0f, wrapper.Union.ValueStructVec3.Z); - Assert.Equal(guard, wrapper.Header); - Assert.Equal(guard, wrapper.Trailer); + Assert.AreEqual(1.0f, wrapper.Union.ValueStructVec3.X); + Assert.AreEqual(2.0f, wrapper.Union.ValueStructVec3.Y); + Assert.AreEqual(3.0f, wrapper.Union.ValueStructVec3.Z); + Assert.AreEqual(guard, wrapper.Header); + Assert.AreEqual(guard, wrapper.Trailer); } } diff --git a/src/Tests/FlatSharpEndToEndTests/ValueStructs/ValueStructTests.cs b/src/Tests/FlatSharpEndToEndTests/ValueStructs/ValueStructTests.cs index b7678e99..77064414 100644 --- a/src/Tests/FlatSharpEndToEndTests/ValueStructs/ValueStructTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/ValueStructs/ValueStructTests.cs @@ -19,9 +19,10 @@ namespace FlatSharpEndToEndTests.ValueStructs; +[TestClass] public class ValueStructTestCases { - [Fact] + [TestMethod] public void WriteThrough_ValueStruct_InVector() { WriteThroughTable t = new WriteThroughTable @@ -40,14 +41,14 @@ public void WriteThrough_ValueStruct_InVector() var parsed = WriteThroughTable.Serializer.Parse(data); var parsed2 = WriteThroughTable.Serializer.Parse(data); - Assert.Equal(1f, parsed2.Points[0].X); + Assert.AreEqual(1f, parsed2.Points[0].X); parsed.Points[0] = new Vec3 { X = -1, Y = -1, Z = -1 }; // triggers writethrough - Assert.Equal(-1f, parsed2.Points[0].X); + Assert.AreEqual(-1f, parsed2.Points[0].X); } - [Fact] + [TestMethod] public void WriteThrough_ValueStruct_InTable() { WriteThroughTable t = new WriteThroughTable @@ -61,29 +62,29 @@ public void WriteThrough_ValueStruct_InTable() var parsed = WriteThroughTable.Serializer.Parse(data); var parsed2 = WriteThroughTable.Serializer.Parse(data); - Assert.Equal(1f, parsed2.Point.X); - Assert.Equal(2f, parsed2.Point.Y); - Assert.Equal(3f, parsed2.Point.Z); + Assert.AreEqual(1f, parsed2.Point.X); + Assert.AreEqual(2f, parsed2.Point.Y); + Assert.AreEqual(3f, parsed2.Point.Z); parsed.Point = new Vec3 { X = -1, Y = -1, Z = -1 }; // triggers writethrough - Assert.Equal(-1f, parsed2.Point.X); - Assert.Equal(-1f, parsed2.Point.Y); - Assert.Equal(-1f, parsed2.Point.Z); + Assert.AreEqual(-1f, parsed2.Point.X); + Assert.AreEqual(-1f, parsed2.Point.Y); + Assert.AreEqual(-1f, parsed2.Point.Z); } - [Fact] + [TestMethod] public void Basics() { - Assert.Equal(36, Unsafe.SizeOf()); + Assert.AreEqual(36, Unsafe.SizeOf()); } - [Fact] + [TestMethod] public void ExtensionMethod_WorksForVectors() { ValueStruct v = default; - Assert.Equal(16, v.D_Length); + Assert.AreEqual(16, v.D_Length); for (int i = 0; i < v.D_Length; ++i) { @@ -92,12 +93,12 @@ public void ExtensionMethod_WorksForVectors() for (int i = 0; i < v.D_Length; ++i) { - Assert.Equal((byte)i, v.D(i)); + Assert.AreEqual((byte)i, v.D(i)); } } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SerializeAndParse_Full(FlatBufferDeserializationOption option) { ValueStruct vs = new ValueStruct @@ -135,16 +136,16 @@ public void SerializeAndParse_Full(FlatBufferDeserializationOption option) int written = serializer.Write(buffer, table); RootTable parsed = serializer.Parse(buffer.AsMemory().Slice(0, written), option); - Assert.NotNull(parsed.RefStruct); - Assert.NotNull(parsed.ValueStruct); - Assert.NotNull(parsed.ValueStructVector); - Assert.NotNull(parsed.Union); - Assert.NotNull(parsed.VectorOfUnion); + Assert.IsNotNull(parsed.RefStruct); + Assert.IsNotNull(parsed.ValueStruct); + Assert.IsNotNull(parsed.ValueStructVector); + Assert.IsNotNull(parsed.Union); + Assert.IsNotNull(parsed.VectorOfUnion); - Assert.Equal(table.VectorOfUnion.Count, parsed.VectorOfUnion.Count); - Assert.Equal(table.ValueStructVector.Count, parsed.ValueStructVector.Count); + Assert.AreEqual(table.VectorOfUnion.Count, parsed.VectorOfUnion.Count); + Assert.AreEqual(table.ValueStructVector.Count, parsed.ValueStructVector.Count); - Assert.Equal(table.RefStruct.A, parsed.RefStruct.A); + Assert.AreEqual(table.RefStruct.A, parsed.RefStruct.A); AssertStructsEqual(table.RefStruct.VS, parsed.RefStruct.VS); AssertStructsEqual(table.ValueStruct.Value, parsed.ValueStruct.Value); @@ -165,8 +166,8 @@ public void SerializeAndParse_Full(FlatBufferDeserializationOption option) } } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ValueStructs_UnityNative_WellAligned_Serialize(FlatBufferDeserializationOption option) { int count = 10; @@ -182,13 +183,13 @@ public void ValueStructs_UnityNative_WellAligned_Serialize(FlatBufferDeserializa for (int i = 0; i < count; ++i) { - Assert.Equal(source.WellAligned[i].X, parsed.WellAligned[i].X); - Assert.Equal(source.WellAligned[i].Y, parsed.WellAligned[i].Y); - Assert.Equal(source.WellAligned[i].Z, parsed.WellAligned[i].Z); + Assert.AreEqual(source.WellAligned[i].X, parsed.WellAligned[i].X); + Assert.AreEqual(source.WellAligned[i].Y, parsed.WellAligned[i].Y); + Assert.AreEqual(source.WellAligned[i].Z, parsed.WellAligned[i].Z); } } - [Fact] + [TestMethod] public void ValueStructs_UnityNative_PoorlyAligned_Serialize() { int count = 10; @@ -199,12 +200,12 @@ public void ValueStructs_UnityNative_PoorlyAligned_Serialize() PoorlyAligned = new(Enumerable.Range(0, count).Select(x => new PoorlyAligned { X = x, Y = 1, }).ToArray(), default), }; - var ex = Assert.Throws(() => source.AllocateAndSerialize()); - Assert.Equal("Type 'FlatSharpEndToEndTests.ValueStructs.PoorlyAligned' does not support Unsafe Span operations because the size (5) is not a multiple of the alignment (4).", ex.Message); + var ex = Assert.ThrowsException(() => source.AllocateAndSerialize()); + Assert.AreEqual("Type 'FlatSharpEndToEndTests.ValueStructs.PoorlyAligned' does not support Unsafe Span operations because the size (5) is not a multiple of the alignment (4).", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ValueStructs_UnityNative_WellAligned_Parse(FlatBufferDeserializationOption option) { int count = 10; @@ -223,9 +224,9 @@ public void ValueStructs_UnityNative_WellAligned_Parse(FlatBufferDeserialization for (int i = 0; i < count; ++i) { - Assert.Equal(source.WellAligned[i].X, parsed.WellAligned[i].X); - Assert.Equal(source.WellAligned[i].Y, parsed.WellAligned[i].Y); - Assert.Equal(source.WellAligned[i].Z, parsed.WellAligned[i].Z); + Assert.AreEqual(source.WellAligned[i].X, parsed.WellAligned[i].X); + Assert.AreEqual(source.WellAligned[i].Y, parsed.WellAligned[i].Y); + Assert.AreEqual(source.WellAligned[i].Z, parsed.WellAligned[i].Z); } } finally @@ -234,8 +235,8 @@ public void ValueStructs_UnityNative_WellAligned_Parse(FlatBufferDeserialization } } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ValueStructs_UnityNative_PoorlyAligned_Parse(FlatBufferDeserializationOption option) { int count = 10; @@ -250,13 +251,13 @@ public void ValueStructs_UnityNative_PoorlyAligned_Parse(FlatBufferDeserializati GCHandle handle = GCHandle.Alloc(data); try { - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var parsed = UnityVectors_Native.Serializer.Parse(new MemoryInputBuffer(data, true), option); float f = parsed.PoorlyAligned.Value[0].X; }); - Assert.Equal( + Assert.AreEqual( "Type 'FlatSharpEndToEndTests.ValueStructs.PoorlyAligned' does not support Unsafe Span operations because the size (5) is not a multiple of the alignment (4).", ex.Message); } @@ -266,157 +267,157 @@ public void ValueStructs_UnityNative_PoorlyAligned_Parse(FlatBufferDeserializati } } - [Fact] + [TestMethod] public void ValueStructs_OutOfRange() { ValueUnsafeStructVector_Byte v = default; - Assert.Throws(() => v.Vector(v.Vector_Length)); - Assert.Throws(() => v.Vector(-1)); + Assert.ThrowsException(() => v.Vector(v.Vector_Length)); + Assert.ThrowsException(() => v.Vector(-1)); ValueStruct safe = default; - Assert.Throws(() => safe.D(safe.D_Length)); - Assert.Throws(() => safe.D(-1)); + Assert.ThrowsException(() => safe.D(safe.D_Length)); + Assert.ThrowsException(() => safe.D(-1)); } - [Fact] + [TestMethod] public void ValueStructVector_Unsafe_Byte() { ValueUnsafeStructVector_Byte v = default; - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { v.Vector(i) = byte.MaxValue; } - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { - Assert.Equal(byte.MaxValue, v.Vector(i)); + Assert.AreEqual(byte.MaxValue, v.Vector(i)); } ValidateGuardedSpan(v); } - [Fact] + [TestMethod] public void ValueStructVector_Unsafe_UShort() { ValueUnsafeStructVector_UShort v = default; - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { v.Vector(i) = ushort.MaxValue; } - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { - Assert.Equal(ushort.MaxValue, v.Vector(i)); + Assert.AreEqual(ushort.MaxValue, v.Vector(i)); } ValidateGuardedSpan(v); } - [Fact] + [TestMethod] public void ValueStructVector_Unsafe_UInt() { ValueUnsafeStructVector_UInt v = default; - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { v.Vector(i) = uint.MaxValue; } - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { - Assert.Equal(uint.MaxValue, v.Vector(i)); + Assert.AreEqual(uint.MaxValue, v.Vector(i)); } ValidateGuardedSpan(v); } - [Fact] + [TestMethod] public void ValueStructVector_Unsafe_ULong() { ValueUnsafeStructVector_ULong v = default; - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { v.Vector(i) = ulong.MaxValue; } - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { - Assert.Equal(ulong.MaxValue, v.Vector(i)); + Assert.AreEqual(ulong.MaxValue, v.Vector(i)); } ValidateGuardedSpan(v); } - [Fact] + [TestMethod] public void ValueStructVector_Unsafe_Float() { ValueUnsafeStructVector_Float v = default; - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { v.Vector(i) = float.MaxValue; } - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { - Assert.Equal(float.MaxValue, v.Vector(i)); + Assert.AreEqual(float.MaxValue, v.Vector(i)); } ValidateGuardedSpan(v); } - [Fact] + [TestMethod] public void ValueStructVector_Unsafe_Double() { ValueUnsafeStructVector_Double v = default; - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { v.Vector(i) = double.MaxValue; } - Assert.Equal(0ul, v.GuardLower); - Assert.Equal(0ul, v.GuardHigher); + Assert.AreEqual(0ul, v.GuardLower); + Assert.AreEqual(0ul, v.GuardHigher); for (int i = 0; i < v.Vector_Length; ++i) { - Assert.Equal(double.MaxValue, v.Vector(i)); + Assert.AreEqual(double.MaxValue, v.Vector(i)); } ValidateGuardedSpan(v); @@ -435,26 +436,26 @@ private void ValidateGuardedSpan(T item) where T : struct int count = 0; for (int i = 0; i < guardLow.Length; ++i) { - Assert.Equal(0, guardLow[i]); + Assert.AreEqual(0, guardLow[i]); count++; } for (int i = 0; i < mid.Length; ++i) { - Assert.NotEqual(0, mid[i]); + Assert.AreNotEqual(0, mid[i]); count++; } for (int i = 0; i < guardHigh.Length; ++i) { - Assert.Equal(0, guardHigh[i]); + Assert.AreEqual(0, guardHigh[i]); count++; } - Assert.Equal(count, Unsafe.SizeOf()); + Assert.AreEqual(count, Unsafe.SizeOf()); } - [Fact] + [TestMethod] public void SerializeAndParse_Empty() { RootTable t = new() @@ -462,7 +463,7 @@ public void SerializeAndParse_Empty() RequiredValueStruct = default, }; - Assert.Null(t.ValueStruct); + Assert.IsNull(t.ValueStruct); ISerializer serializer = RootTable.Serializer; int maxBytes = serializer.GetMaxSize(t); @@ -470,20 +471,20 @@ public void SerializeAndParse_Empty() int written = serializer.Write(buffer, t); RootTable parsed = serializer.Parse(buffer.AsMemory().Slice(0, written)); - Assert.Null(parsed.RefStruct); - Assert.Null(parsed.ValueStruct); + Assert.IsNull(parsed.RefStruct); + Assert.IsNull(parsed.ValueStruct); } private static void AssertStructsEqual(ValueStruct a, ValueStruct b) { - Assert.Equal(a.A, b.A); - Assert.Equal(a.B, b.B); - Assert.Equal(a.C, b.C); - Assert.Equal(a.Inner.A, b.Inner.A); + Assert.AreEqual(a.A, b.A); + Assert.AreEqual(a.B, b.B); + Assert.AreEqual(a.C, b.C); + Assert.AreEqual(a.Inner.A, b.Inner.A); for (int i = 0; i < a.D_Length; ++i) { - Assert.Equal(a.D(i), b.D(i)); + Assert.AreEqual(a.D(i), b.D(i)); } Span scratchA = stackalloc byte[Unsafe.SizeOf()]; @@ -492,6 +493,6 @@ private static void AssertStructsEqual(ValueStruct a, ValueStruct b) MemoryMarshal.Cast(scratchA)[0] = a; MemoryMarshal.Cast(scratchB)[0] = b; - Assert.True(scratchA.SequenceEqual(scratchB)); + Assert.IsTrue(scratchA.SequenceEqual(scratchB)); } } diff --git a/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/IndexedVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/IndexedVectorTests.cs index 8297076b..e0bf064e 100644 --- a/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/IndexedVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/IndexedVectorTests.cs @@ -20,18 +20,13 @@ namespace FlatSharpEndToEndTests.Vectors.Sorted; +[TestClass] public class IndexedVectorTests { private static readonly Random Rng = new(); - private readonly Xunit.Abstractions.ITestOutputHelper outputHelper; - public IndexedVectorTests(Xunit.Abstractions.ITestOutputHelper outputHelper) - { - this.outputHelper = outputHelper; - } - - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Bool(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfBool, @@ -39,8 +34,8 @@ public void Bool(FlatBufferDeserializationOption opt) => this.IndexedVectorTest< () => new BoolKey { Key = Rng.Next() % 2 == 0 }, k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Byte(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfByte, @@ -48,8 +43,8 @@ public void Byte(FlatBufferDeserializationOption opt) => this.IndexedVectorTest< GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SByte(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfSbyte, @@ -57,8 +52,8 @@ public void SByte(FlatBufferDeserializationOption opt) => this.IndexedVectorTest GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Short(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfShort, @@ -66,8 +61,8 @@ public void Short(FlatBufferDeserializationOption opt) => this.IndexedVectorTest GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UShort(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfUshort, @@ -75,8 +70,8 @@ public void UShort(FlatBufferDeserializationOption opt) => this.IndexedVectorTes GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Int(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfInt, @@ -84,8 +79,8 @@ public void Int(FlatBufferDeserializationOption opt) => this.IndexedVectorTest((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UInt(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfUint, @@ -93,8 +88,8 @@ public void UInt(FlatBufferDeserializationOption opt) => this.IndexedVectorTest< GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Long(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfLong, @@ -102,8 +97,8 @@ public void Long(FlatBufferDeserializationOption opt) => this.IndexedVectorTest< GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ULong(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfUlong, @@ -111,8 +106,8 @@ public void ULong(FlatBufferDeserializationOption opt) => this.IndexedVectorTest GetValueFactory((k, v) => k.Key = v), k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Float(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfFloat, @@ -120,8 +115,8 @@ public void Float(FlatBufferDeserializationOption opt) => this.IndexedVectorTest () => new FloatKey { Key = (float)Rng.NextDouble() }, k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Double(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfDouble, @@ -129,8 +124,8 @@ public void Double(FlatBufferDeserializationOption opt) => this.IndexedVectorTes () => new DoubleKey { Key = Rng.NextDouble() }, k => k.Key); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void String(FlatBufferDeserializationOption opt) => this.IndexedVectorTest( opt, x => x.IndexedVectorOfString, @@ -191,15 +186,15 @@ private void IndexedVectorTest( IIndexedVector vector = getVector(parsed); - Assert.Equal(knownKeys.Count, vector.Count); + Assert.AreEqual(knownKeys.Count, vector.Count); foreach (var key in knownKeys) { - Assert.True(vector.TryGetValue(key, out TValue value)); - Assert.True(vector.ContainsKey(key)); - Assert.NotNull(vector[key]); - Assert.NotNull(value); - Assert.Equal(key, getKey(value)); + Assert.IsTrue(vector.TryGetValue(key, out TValue value)); + Assert.IsTrue(vector.ContainsKey(key)); + Assert.IsNotNull(vector[key]); + Assert.IsNotNull(value); + Assert.AreEqual(key, getKey(value)); } for (int i = 0; i < 100; ++i) @@ -208,15 +203,11 @@ private void IndexedVectorTest( if (!knownKeys.Contains(key)) { bool result = vector.TryGetValue(key, out TValue value); - if (result) - { - this.outputHelper.WriteLine($"Unexpected result: Key = {key}. ActualKey = {getKey(value)}"); - } - - Assert.False(result); - Assert.Null(value); - Assert.False(vector.ContainsKey(key)); - Assert.Throws(() => vector[key]); + + Assert.IsFalse(result); + Assert.IsNull(value); + Assert.IsFalse(vector.ContainsKey(key)); + Assert.ThrowsException(() => vector[key]); } } } diff --git a/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/SortedVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/SortedVectorTests.cs index e5d77418..0c790994 100644 --- a/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/SortedVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Vectors/Sorted/SortedVectorTests.cs @@ -20,10 +20,11 @@ namespace FlatSharpEndToEndTests.Vectors.Sorted; +[TestClass] public class SortedVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Bool(FlatBufferDeserializationOption opt) => this.SortedVectorTest( opt, rng => rng.Next() % 2 == 0, @@ -34,8 +35,8 @@ public void Bool(FlatBufferDeserializationOption opt) => this.SortedVectorTest k.Key = v, Comparer.Default); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Byte(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfByte, @@ -43,8 +44,8 @@ public void Byte(FlatBufferDeserializationOption opt) => this.SortedVectorStruct k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SByte(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfSbyte, @@ -52,8 +53,8 @@ public void SByte(FlatBufferDeserializationOption opt) => this.SortedVectorStruc k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Short(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfShort, @@ -61,8 +62,8 @@ public void Short(FlatBufferDeserializationOption opt) => this.SortedVectorStruc k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UShort(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfUshort, @@ -70,8 +71,8 @@ public void UShort(FlatBufferDeserializationOption opt) => this.SortedVectorStru k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Int(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfInt, @@ -79,8 +80,8 @@ public void Int(FlatBufferDeserializationOption opt) => this.SortedVectorStructT k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UInt(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfUint, @@ -88,8 +89,8 @@ public void UInt(FlatBufferDeserializationOption opt) => this.SortedVectorStruct k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Long(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfLong, @@ -97,8 +98,8 @@ public void Long(FlatBufferDeserializationOption opt) => this.SortedVectorStruct k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ULong(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfUlong, @@ -106,8 +107,8 @@ public void ULong(FlatBufferDeserializationOption opt) => this.SortedVectorStruc k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Float(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfFloat, @@ -115,8 +116,8 @@ public void Float(FlatBufferDeserializationOption opt) => this.SortedVectorStruc k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Double(FlatBufferDeserializationOption opt) => this.SortedVectorStructTest( opt, rt => rt.ListVectorOfDouble, @@ -124,8 +125,8 @@ public void Double(FlatBufferDeserializationOption opt) => this.SortedVectorStru k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void String_Base64(FlatBufferDeserializationOption opt) => this.SortedVectorTest( opt, rng => @@ -142,8 +143,8 @@ public void String_Base64(FlatBufferDeserializationOption opt) => this.SortedVec (k, v) => k.Key = v, new Utf8StringComparer()); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Bool_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorTestReadOnly( opt, rng => rng.Next() % 2 == 0, @@ -154,8 +155,8 @@ public void Bool_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVec (k, v) => k.Key = v, Comparer.Default); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Byte_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfByte, @@ -163,8 +164,8 @@ public void Byte_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVec k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void SByte_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfSbyte, @@ -172,8 +173,8 @@ public void SByte_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVe k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Short_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfShort, @@ -181,8 +182,8 @@ public void Short_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVe k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UShort_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfUshort, @@ -190,8 +191,8 @@ public void UShort_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedV k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Int_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfInt, @@ -199,8 +200,8 @@ public void Int_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVect k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UInt_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfUint, @@ -208,8 +209,8 @@ public void UInt_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVec k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Long_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfLong, @@ -217,8 +218,8 @@ public void Long_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVec k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ULong_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfUlong, @@ -226,8 +227,8 @@ public void ULong_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVe k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Float_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfFloat, @@ -235,8 +236,8 @@ public void Float_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVe k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Double_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorStructTestReadOnly( opt, rt => rt.ListVectorOfDouble, @@ -244,8 +245,8 @@ public void Double_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedV k => k.Key, (k, v) => k.Key = v); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void String_Base64_ReadOnly(FlatBufferDeserializationOption opt) => this.SortedVectorTestReadOnly( opt, rng => @@ -262,7 +263,7 @@ public void String_Base64_ReadOnly(FlatBufferDeserializationOption opt) => this. (k, v) => k.Key = v, new Utf8StringComparer()); - [Fact] + [TestMethod] public void String_Null_Key_Is_Required() { RootTable root = new() @@ -270,14 +271,14 @@ public void String_Null_Key_Is_Required() ListVectorOfString = new List { new() { Key = null, }, new() { Key = "a" }, new() { Key = "b" } } }; - Assert.True(typeof(StringKey).GetProperty("Key").GetCustomAttribute().Required); + Assert.IsTrue(typeof(StringKey).GetProperty("Key").GetCustomAttribute().Required); - var ex = Assert.Throws(() => root.AllocateAndSerialize()); - Assert.Equal("Table property 'FlatSharpEndToEndTests.Vectors.Sorted.StringKey.Key' is marked as required, but was not set.", ex.Message); + var ex = Assert.ThrowsException(() => root.AllocateAndSerialize()); + Assert.AreEqual("Table property 'FlatSharpEndToEndTests.Vectors.Sorted.StringKey.Key' is marked as required, but was not set.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Int_Null_Key_OK(FlatBufferDeserializationOption option) { RootTable root = new() @@ -311,15 +312,15 @@ public void Int_Null_Key_OK(FlatBufferDeserializationOption option) 2, 0, 0, 0, }; - Assert.True(buffer.SequenceEqual(expected)); + Assert.IsTrue(buffer.SequenceEqual(expected)); - Assert.NotNull(parsed.ListVectorOfInt.BinarySearchByFlatBufferKey(5)); - Assert.Null(parsed.ListVectorOfInt.BinarySearchByFlatBufferKey(6)); + Assert.IsNotNull(parsed.ListVectorOfInt.BinarySearchByFlatBufferKey(5)); + Assert.IsNull(parsed.ListVectorOfInt.BinarySearchByFlatBufferKey(6)); } - [Theory] - [InlineData(FlatBufferDeserializationOption.Lazy)] - [InlineData(FlatBufferDeserializationOption.Progressive)] + [TestMethod] + [DataRow(FlatBufferDeserializationOption.Lazy)] + [DataRow(FlatBufferDeserializationOption.Progressive)] public void String_Null_Key_Fails_Binary_Search(FlatBufferDeserializationOption option) { RootTable_NonSorted root = new() @@ -330,17 +331,17 @@ public void String_Null_Key_Fails_Binary_Search(FlatBufferDeserializationOption byte[] data = root.AllocateAndSerialize(); RootTable parsed = RootTable.Serializer.Parse(data, option); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var key = parsed.ListVectorOfString.BinarySearchByFlatBufferKey("a"); }); - Assert.Equal("Sorted FlatBuffer vectors may not have null-valued keys.", ex.Message); + Assert.AreEqual("Sorted FlatBuffer vectors may not have null-valued keys.", ex.Message); } - [Theory] - [InlineData(FlatBufferDeserializationOption.Greedy)] - [InlineData(FlatBufferDeserializationOption.GreedyMutable)] + [TestMethod] + [DataRow(FlatBufferDeserializationOption.Greedy)] + [DataRow(FlatBufferDeserializationOption.GreedyMutable)] public void String_Null_Key_Fails_Greedy_Parse(FlatBufferDeserializationOption option) { RootTable_NonSorted root = new() @@ -350,12 +351,12 @@ public void String_Null_Key_Fails_Greedy_Parse(FlatBufferDeserializationOption o byte[] data = root.AllocateAndSerialize(); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { RootTable parsed = RootTable.Serializer.Parse(data, option); }); - Assert.Equal("Table property 'FlatSharpEndToEndTests.Vectors.Sorted.StringKey.Key' is marked as required, but was missing from the buffer.", ex.Message); + Assert.AreEqual("Table property 'FlatSharpEndToEndTests.Vectors.Sorted.StringKey.Key' is marked as required, but was missing from the buffer.", ex.Message); } private void SortedVectorStructTestReadOnly( @@ -491,7 +492,7 @@ private void SortedVectorTestReadOnly( IReadOnlyList vector = getList(parsed); - Assert.Equal(rootList.Count, vector.Count); + Assert.AreEqual(rootList.Count, vector.Count); if (rootList.Count > 0) { @@ -500,15 +501,15 @@ private void SortedVectorTestReadOnly( for (int i = 0; i < rootList.Count; ++i) { var item = vector[i]; - Assert.True(comparer.Compare(getKey(previous), getKey(item)) <= 0); + Assert.IsTrue(comparer.Compare(getKey(previous), getKey(item)) <= 0); previous = item; } foreach (var originalItem in rootList) { var item = vector.BinarySearchByFlatBufferKey(getKey(originalItem)); - Assert.NotNull(item); - Assert.Equal(getKey(originalItem).ToString(), getKey(item).ToString()); + Assert.IsNotNull(item); + Assert.AreEqual(getKey(originalItem).ToString(), getKey(item).ToString()); } } } @@ -528,7 +529,7 @@ private void SortedVectorTest( IList vector = getList(parsed); - Assert.Equal(rootList.Count, vector.Count); + Assert.AreEqual(rootList.Count, vector.Count); if (rootList.Count > 0) { @@ -537,15 +538,15 @@ private void SortedVectorTest( for (int i = 0; i < rootList.Count; ++i) { var item = vector[i]; - Assert.True(comparer.Compare(getKey(previous), getKey(item)) <= 0); + Assert.IsTrue(comparer.Compare(getKey(previous), getKey(item)) <= 0); previous = item; } foreach (var originalItem in rootList) { var item = vector.BinarySearchByFlatBufferKey(getKey(originalItem)); - Assert.NotNull(item); - Assert.Equal(getKey(originalItem).ToString(), getKey(item).ToString()); + Assert.IsNotNull(item); + Assert.AreEqual(getKey(originalItem).ToString(), getKey(item).ToString()); } } } diff --git a/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs b/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs index 0d2fe65c..f939e99f 100644 --- a/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Vectors/Standard/StandardVectorTests.cs @@ -20,6 +20,7 @@ namespace FlatSharpEndToEndTests.Vectors.Standard; +[TestClass] public class StandardVectorTests { private static readonly string[] Strings = new[] { string.Empty, "a", "ab", "abc", "abcd", "abcde" }; @@ -28,546 +29,546 @@ public class StandardVectorTests #region Lazy - [Fact] + [TestMethod] public void Lazy_String_IList_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out _); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); IList list = table.ImplicitStringList; //Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); // lazy returns unique instances. - Assert.False(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); - Assert.False(object.ReferenceEquals(list[5], list[5])); + Assert.IsFalse(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); + Assert.IsFalse(object.ReferenceEquals(list[5], list[5])); - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Throws(() => list[0] = "foobar"); - Assert.Throws(() => list.Clear()); + Assert.ThrowsException(() => list[0] = "foobar"); + Assert.ThrowsException(() => list.Clear()); } - [Fact] + [TestMethod] public void Lazy_String_IList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out _); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); IList list = table.ExplicitStringList; //Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); // lazy returns unique instances. - Assert.False(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); - Assert.False(object.ReferenceEquals(list[5], list[5])); + Assert.IsFalse(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); + Assert.IsFalse(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); - Assert.Throws(() => list[0] = "foobar"); - Assert.Throws(() => list.Clear()); + Assert.AreEqual(Strings.Length, list.Count); + Assert.ThrowsException(() => list[0] = "foobar"); + Assert.ThrowsException(() => list.Clear()); } - [Fact] + [TestMethod] public void Lazy_String_IReadOnlyList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out _); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; //Assert.Contains("FlatBufferVectorBase", list.GetType().FullName); // lazy returns unique instances. - Assert.False(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); - Assert.False(object.ReferenceEquals(list[5], list[5])); + Assert.IsFalse(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); + Assert.IsFalse(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); } - [Fact] + [TestMethod] public void Lazy_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); Memory? nullableMemory = table.ExplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.True(memory.Span.Overlaps(inputBuffer)); + Assert.IsTrue(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Lazy_Memory_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); Memory? nullableMemory = table.ImplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.True(memory.Span.Overlaps(inputBuffer)); + Assert.IsTrue(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Lazy_ReadOnly_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Lazy, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); ReadOnlyMemory? nullableMemory = table.ReadOnlyMemory; ReadOnlyMemory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.True(memory.Span.Overlaps(inputBuffer)); + Assert.IsTrue(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Lazy_Unity_Pinned() => this.ValidateUnity(FlatBufferDeserializationOption.Lazy, true, true); - [Fact] + [TestMethod] public void Lazy_Unity_NotPinned() => this.ValidateUnity_ExpectPinningError(FlatBufferDeserializationOption.Lazy); #endregion #region Progressive - [Fact] + [TestMethod] public void Progressive_String_IList_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); IList list = table.ImplicitStringList; //Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); - Assert.True(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Throws(() => list[0] = "foobar"); - Assert.Throws(() => list.Clear()); + Assert.ThrowsException(() => list[0] = "foobar"); + Assert.ThrowsException(() => list.Clear()); } - [Fact] + [TestMethod] public void Progressive_String_IList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); IList list = table.ExplicitStringList; //Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); // Progressive returns the same instance. - Assert.True(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); - Assert.Throws(() => list[0] = "foobar"); - Assert.Throws(() => list.Clear()); + Assert.AreEqual(Strings.Length, list.Count); + Assert.ThrowsException(() => list[0] = "foobar"); + Assert.ThrowsException(() => list.Clear()); } - [Fact] + [TestMethod] public void Progressive_String_IReadOnlyList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; //Assert.Contains("FlatBufferProgressiveVector", list.GetType().FullName); - Assert.True(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); } - [Fact] + [TestMethod] public void Progressive_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); Memory? nullableMemory = table.ExplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.True(memory.Span.Overlaps(inputBuffer)); + Assert.IsTrue(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Progressive_Memory_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); Memory? nullableMemory = table.ImplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.True(memory.Span.Overlaps(inputBuffer)); + Assert.IsTrue(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Progressive_ReadOnly_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out var obj, out var inputBuffer); - Assert.NotNull(obj.InputBuffer); + Assert.IsNotNull(obj.InputBuffer); ReadOnlyMemory? nullableMemory = table.ReadOnlyMemory; ReadOnlyMemory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.True(memory.Span.Overlaps(inputBuffer)); + Assert.IsTrue(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Progressive_Unity_Pinned() => this.ValidateUnity(FlatBufferDeserializationOption.Progressive, true, true); - [Fact] + [TestMethod] public void Progressive_Unity_NotPinned() => this.ValidateUnity_ExpectPinningError(FlatBufferDeserializationOption.Progressive); #endregion #region Greedy - [Fact] + [TestMethod] public void Greedy_String_IList_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); IList list = table.ImplicitStringList; //Assert.Contains("ImmutableList", list.GetType().FullName); - Assert.True(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Throws(() => list[0] = "foobar"); - Assert.Throws(() => list.Clear()); + Assert.ThrowsException(() => list[0] = "foobar"); + Assert.ThrowsException(() => list.Clear()); } - [Fact] + [TestMethod] public void Greedy_String_IList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); IList list = table.ExplicitStringList; //Assert.Contains("ImmutableList", list.GetType().FullName); // Progressive returns the same instance. - Assert.True(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); - Assert.Throws(() => list[0] = "foobar"); - Assert.Throws(() => list.Clear()); + Assert.AreEqual(Strings.Length, list.Count); + Assert.ThrowsException(() => list[0] = "foobar"); + Assert.ThrowsException(() => list.Clear()); } - [Fact] + [TestMethod] public void Greedy_String_IReadOnlyList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; //Assert.Contains("ImmutableList", list.GetType().FullName); - Assert.True(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); } - [Fact] + [TestMethod] public void Greedy_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out var inputBuffer); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); Memory? nullableMemory = table.ExplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.False(memory.Span.Overlaps(inputBuffer)); + Assert.IsFalse(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Greedy_Memory_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out var inputBuffer); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); Memory? nullableMemory = table.ImplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.False(memory.Span.Overlaps(inputBuffer)); + Assert.IsFalse(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Greedy_ReadOnly_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.Greedy, out var obj, out var inputBuffer); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); ReadOnlyMemory? nullableMemory = table.ReadOnlyMemory; ReadOnlyMemory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.False(memory.Span.Overlaps(inputBuffer)); + Assert.IsFalse(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void Greedy_Unity_Pinned() => this.ValidateUnity(FlatBufferDeserializationOption.Greedy, true, false); - [Fact] + [TestMethod] public void Greedy_Unity_NotPinned() => this.ValidateUnity(FlatBufferDeserializationOption.Greedy, false, false); #endregion #region GreedyMutable - [Fact] + [TestMethod] public void GreedyMutable_String_IList_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); IList list = table.ImplicitStringList; //Assert.Contains("PoolableList", list.GetType().FullName); - Assert.True(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ImplicitStringList, table.ImplicitStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } list[0] = "foobar"; list.Clear(); } - [Fact] + [TestMethod] public void GreedyMutable_String_IList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); IList list = table.ExplicitStringList; //Assert.Contains("PoolableList", list.GetType().FullName); // Progressive returns the same instance. - Assert.True(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ExplicitStringList, table.ExplicitStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); list[0] = "foobar"; list.Clear(); } - [Fact] + [TestMethod] public void GreedyMutable_String_IReadOnlyList_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out _); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); IReadOnlyList list = table.ReadOnlyStringList; //Assert.Contains("PoolableList", list.GetType().FullName); - Assert.True(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); - Assert.True(object.ReferenceEquals(list[5], list[5])); + Assert.IsTrue(object.ReferenceEquals(table.ReadOnlyStringList, table.ReadOnlyStringList)); + Assert.IsTrue(object.ReferenceEquals(list[5], list[5])); for (int i = 0; i < Strings.Length; ++i) { - Assert.Equal(Strings[i], list[i]); + Assert.AreEqual(Strings[i], list[i]); } - Assert.Equal(Strings.Length, list.Count); + Assert.AreEqual(Strings.Length, list.Count); } - [Fact] + [TestMethod] public void GreedyMutable_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out var inputBuffer); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); Memory? nullableMemory = table.ExplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.False(memory.Span.Overlaps(inputBuffer)); + Assert.IsFalse(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void GreedyMutable_Memory_Implicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out var inputBuffer); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); Memory? nullableMemory = table.ImplicitMemory; Memory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.False(memory.Span.Overlaps(inputBuffer)); + Assert.IsFalse(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void GreedyMutable_ReadOnly_Memory_Explicit() { var table = this.SerializeAndParse(FlatBufferDeserializationOption.GreedyMutable, out var obj, out var inputBuffer); - Assert.Null(obj.InputBuffer); + Assert.IsNull(obj.InputBuffer); ReadOnlyMemory? nullableMemory = table.ReadOnlyMemory; ReadOnlyMemory memory = nullableMemory.Value; // Each span overlaps the input buffer. Means we are not eagerly copying out. - Assert.False(memory.Span.Overlaps(inputBuffer)); + Assert.IsFalse(memory.Span.Overlaps(inputBuffer)); for (int i = 0; i < Bytes.Length; ++i) { - Assert.Equal(Bytes[i], memory.Span[i]); + Assert.AreEqual(Bytes[i], memory.Span[i]); } - Assert.Equal(Bytes.Length, memory.Length); + Assert.AreEqual(Bytes.Length, memory.Length); } - [Fact] + [TestMethod] public void GreedyMutable_Unity_Pinned() => this.ValidateUnity(FlatBufferDeserializationOption.GreedyMutable, true, false); - [Fact] + [TestMethod] public void GreedyMutable_Unity_NotPinned() => this.ValidateUnity(FlatBufferDeserializationOption.GreedyMutable, false, false); #endregion @@ -582,17 +583,17 @@ private void ValidateUnity(FlatBufferDeserializationOption option, bool pin, boo MemoryInputBuffer inputBuffer = new MemoryInputBuffer(buffer, isPinned: pin); var result = StandardVectorTable.Serializer.Parse(inputBuffer, option); - Assert.NotNull(result.UnityNative); + Assert.IsNotNull(result.UnityNative); var nativeArray = result.UnityNative.Value; - Assert.Equal(Ints.Length, nativeArray.Length); + Assert.AreEqual(Ints.Length, nativeArray.Length); for (int i = 0; i < Ints.Length; ++i) { - Assert.Equal(Ints[i], nativeArray[i]); + Assert.AreEqual(Ints[i], nativeArray[i]); } - Assert.Equal( + Assert.AreEqual( expectOverlap, MemoryMarshal.Cast(nativeArray.AsSpan()).Overlaps(buffer.AsSpan())); } @@ -604,8 +605,8 @@ private void ValidateUnity(FlatBufferDeserializationOption option, bool pin, boo private void ValidateUnity_ExpectPinningError(FlatBufferDeserializationOption option) { - var ex = Assert.Throws(() => this.ValidateUnity(option, false, false)); - Assert.Equal("Non-greedy parsing of a NativeArray requires a pinned buffer.", ex.Message); + var ex = Assert.ThrowsException(() => this.ValidateUnity(option, false, false)); + Assert.AreEqual("Non-greedy parsing of a NativeArray requires a pinned buffer.", ex.Message); } private StandardVectorTable SerializeAndParse(FlatBufferDeserializationOption option, out IFlatBufferDeserializedObject obj, out byte[] inputBuffer) @@ -627,8 +628,8 @@ private StandardVectorTable SerializeAndParse(FlatBufferDeserializationOption op obj = table as IFlatBufferDeserializedObject; - Assert.NotNull(obj); - Assert.Equal(option, obj.DeserializationContext.DeserializationOption); + Assert.IsNotNull(obj); + Assert.AreEqual(option, obj.DeserializationContext.DeserializationOption); return table; } } From 104c97605c172c8f6297bbd6f1f1321cad40150c Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sat, 2 Mar 2024 22:25:41 -0800 Subject: [PATCH 02/14] Update dotnet.yml --- .github/workflows/dotnet.yml | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml index e1ad9aab..dd7681fd 100644 --- a/.github/workflows/dotnet.yml +++ b/.github/workflows/dotnet.yml @@ -11,7 +11,13 @@ jobs: build: strategy: matrix: - os: [ windows-latest, ubuntu-latest, macos-latest ] + include: + - os: windows-latest + rid: win-x64 + - os: ubuntu-latest + rid: linux-x64 + - os: macos-latest + rid: osx-x64 runs-on: ${{ matrix.os }} env: AppVeyorBuild: true @@ -65,10 +71,16 @@ jobs: working-directory: src run: dotnet build -c Release /p:SignAssembly=true - - name: E2E Test + - name: E2E Test (JIT) working-directory: src/Tests/FlatSharpEndToEndTests run: dotnet test -c Release /p:SignAssembly=true --verbosity normal + - name: E2E Test (AOT) + working-directory: src/Tests/FlatSharpEndToEndTests + run: | + dotnet publish -c Release -f net8.0 -r ${{ matrix.rid }} -p:BuildAot=true + ./bin/Release/net8.0/${{ matrix.rid }}/publish/FlatSharpEndToEndTests + - name: Poolable E2E Test working-directory: src/Tests/FlatSharpPoolableEndToEndTests run: dotnet test -c Release /p:SignAssembly=true --verbosity normal From af936fe3df58862dbafb81fb82d362502c9ec300 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sat, 2 Mar 2024 23:38:11 -0800 Subject: [PATCH 03/14] Revert to net8 --- src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj index cc91e62d..8dc07e44 100644 --- a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj +++ b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj @@ -2,10 +2,9 @@ false true - net6.0;net7.0;net8.0 + net8.0 net472;net6.0;net7.0;net8.0 net6.0;net7.0;net8.0 - net8.0 false FlatSharpEndToEndTests FlatSharpTests From 33a71ee24f1520dc1761d8de320caf0eb080d2b3 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 02:16:24 -0800 Subject: [PATCH 04/14] Fix missing tests --- src/Directory.Packages.props | 4 +++- src/NuGet.config | 4 ++-- .../FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj | 5 +++-- src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs | 2 ++ .../FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs | 2 +- .../FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs | 2 +- src/Tests/FlatSharpEndToEndTests/Program.cs | 4 ++++ .../FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs | 2 +- 8 files changed, 17 insertions(+), 8 deletions(-) diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props index cdbc8314..4ed22db6 100644 --- a/src/Directory.Packages.props +++ b/src/Directory.Packages.props @@ -15,8 +15,10 @@ + - + + diff --git a/src/NuGet.config b/src/NuGet.config index 5430a707..47600df5 100644 --- a/src/NuGet.config +++ b/src/NuGet.config @@ -10,8 +10,8 @@ - - + + diff --git a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj index 8dc07e44..94959d03 100644 --- a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj +++ b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj @@ -29,8 +29,9 @@ - - + + + diff --git a/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs b/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs index 0fbc5784..b275bff6 100644 --- a/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs +++ b/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs @@ -29,3 +29,5 @@ global using FlatSharp; global using FlatSharp.Attributes; global using Microsoft.VisualStudio.TestTools.UnitTesting; + +[assembly: Parallelize(Scope = ExecutionScope.ClassLevel)] \ No newline at end of file diff --git a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs index cfec4b3d..58127912 100644 --- a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleDeserializeTests.cs @@ -25,7 +25,7 @@ namespace FlatSharpEndToEndTests.Oracle; /// Can we parse data we created using the official Google library? /// [TestClass] -public partial class OracleDeserializeTests +public class OracleDeserializeTests { [TestMethod] public void SimpleTypes() diff --git a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs index d480e5f0..4ca44dec 100644 --- a/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/Oracle/OracleSerializeTests.cs @@ -24,7 +24,7 @@ namespace FlatSharpEndToEndTests.Oracle; /// Can the Google Flatbuffer code parse data we generated? /// [TestClass] -public partial class OracleSerializeTests +public class OracleSerializeTests { [TestMethod] public void SimpleTypes_WithValues() diff --git a/src/Tests/FlatSharpEndToEndTests/Program.cs b/src/Tests/FlatSharpEndToEndTests/Program.cs index e7042097..ebe536de 100644 --- a/src/Tests/FlatSharpEndToEndTests/Program.cs +++ b/src/Tests/FlatSharpEndToEndTests/Program.cs @@ -20,6 +20,7 @@ using Microsoft.Testing.Platform.Builder; using System.Threading.Tasks; using Microsoft.Testing.Extensions; +using Microsoft.Testing.Framework.Configurations; namespace FlatSharpEndToEndTests; @@ -32,7 +33,10 @@ public static int Main(string[] args) var builder = TestApplication.CreateBuilderAsync(args).GetAwaiter().GetResult(); // Registers TestFramework, with tree of test nodes // that are generated into your project by source generator. + builder.AddTestFramework(new SourceGeneratedTestNodesBuilder()); + builder.AddTrxReportProvider(); + var app = builder.BuildAsync().GetAwaiter().GetResult(); return app.RunAsync().GetAwaiter().GetResult(); } diff --git a/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs b/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs index 27127ce1..60e2b705 100644 --- a/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs +++ b/src/Tests/FlatSharpEndToEndTests/TableMembers/TableMembersTests.cs @@ -17,7 +17,7 @@ namespace FlatSharpEndToEndTests.TableMembers; [TestClass] -public partial class TableMemberTests +public class TableMemberTests { [TestMethod] [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] From a3b133625dcd1db9b646025f7ebb645b6b8c4e4f Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 02:17:32 -0800 Subject: [PATCH 05/14] Delete .github/workflows/NativeAotTest.yml --- .github/workflows/NativeAotTest.yml | 64 ----------------------------- 1 file changed, 64 deletions(-) delete mode 100644 .github/workflows/NativeAotTest.yml diff --git a/.github/workflows/NativeAotTest.yml b/.github/workflows/NativeAotTest.yml deleted file mode 100644 index 3d9448d7..00000000 --- a/.github/workflows/NativeAotTest.yml +++ /dev/null @@ -1,64 +0,0 @@ -name: NativeAot Validation - -on: - push: - branches: [ main ] - pull_request: - branches: [ main ] - workflow_dispatch: - -jobs: - build: - strategy: - max-parallel: 1 - matrix: - include: - - os: windows-latest - rid: win-x64 - - os: ubuntu-latest - rid: linux-x64 - - os: macos-latest - rid: osx-x64 - - runs-on: ${{ matrix.os }} - env: - AppVeyorBuild: true - steps: - - uses: actions/checkout@v2 - - - name: Setup .NET 8 - uses: actions/setup-dotnet@v1 - with: - dotnet-version: 8.0.x - - - name: Restore dependencies - working-directory: src - run: dotnet restore - - - name: Build FlatSharp.Compiler - working-directory: src/FlatSharp.Compiler - run: dotnet build -c Release - - - name: Run FlatSharp.Compiler - # You may pin to the exact commit or the version. - # uses: Amadevus/pwsh-script@97a8b211a5922816aa8a69ced41fa32f23477186 - uses: Amadevus/pwsh-script@v2.0.3 - with: - # PowerShell script to execute in Actions-hydrated context - script: | - $fbs = (gci -r src/Tests/CompileTests/NativeAot/*.fbs) -join ";" - dotnet src/FlatSharp.Compiler/bin/Release/net8.0/FlatSharp.Compiler.dll --nullable-warnings false --normalize-field-names true --input "$fbs" -o src/Tests/CompileTests/NativeAot - - - name: Build - working-directory: src/Tests/CompileTests/NativeAot - run: dotnet publish -c Release -r ${{ matrix.rid }} -f net8.0 - - - name: Run - working-directory: src/Tests/CompileTests/NativeAot/bin/Release/net8.0/${{ matrix.rid }}/publish - run: ./NativeAot - - - name: Upload Files - uses: actions/upload-artifact@v3 - with: - name: assembly - path: src/Tests/CompileTests/NativeAot/bin/**/*.* From 28e6d8df298df0fafeb3321f758e01affef749e7 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 02:21:26 -0800 Subject: [PATCH 06/14] Fix nuget.config --- src/NuGet.config | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/NuGet.config b/src/NuGet.config index 47600df5..0401ce52 100644 --- a/src/NuGet.config +++ b/src/NuGet.config @@ -4,15 +4,15 @@ - - - - - - - - - - + + + + + + + + + + From 3d50241ec1b8b9074830e5e74f26baf334db6601 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 02:27:16 -0800 Subject: [PATCH 07/14] Fix build --- src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs b/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs index b275bff6..46eefb10 100644 --- a/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs +++ b/src/Tests/FlatSharpEndToEndTests/GlobalUsings.cs @@ -30,4 +30,4 @@ global using FlatSharp.Attributes; global using Microsoft.VisualStudio.TestTools.UnitTesting; -[assembly: Parallelize(Scope = ExecutionScope.ClassLevel)] \ No newline at end of file +[assembly: Parallelize(Scope = global::Microsoft.VisualStudio.TestTools.UnitTesting.ExecutionScope.ClassLevel)] From 46f2758bd4006a0deb44529d2b5f592899354e66 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 11:11:58 -0800 Subject: [PATCH 08/14] Rename nuget config --- .../FlatSharpEndToEndTests/AlphaPackages.config} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{NuGet.config => Tests/FlatSharpEndToEndTests/AlphaPackages.config} (100%) diff --git a/src/NuGet.config b/src/Tests/FlatSharpEndToEndTests/AlphaPackages.config similarity index 100% rename from src/NuGet.config rename to src/Tests/FlatSharpEndToEndTests/AlphaPackages.config From 64f230970e096ac6f5f66453ce12643473621c13 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 11:15:10 -0800 Subject: [PATCH 09/14] Update dotnet.yml --- .github/workflows/dotnet.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml index dd7681fd..a9403d81 100644 --- a/.github/workflows/dotnet.yml +++ b/.github/workflows/dotnet.yml @@ -77,8 +77,11 @@ jobs: - name: E2E Test (AOT) working-directory: src/Tests/FlatSharpEndToEndTests + env: + BuildAot: 'true' run: | - dotnet publish -c Release -f net8.0 -r ${{ matrix.rid }} -p:BuildAot=true + dotnet restore --configFile AlphaPackages.config + dotnet publish --no-restore -c Release -f net8.0 -r ${{ matrix.rid }} ./bin/Release/net8.0/${{ matrix.rid }}/publish/FlatSharpEndToEndTests - name: Poolable E2E Test From b07ae82332d74ca28a7ba75c5a603eca2c2a1b19 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 11:20:21 -0800 Subject: [PATCH 10/14] Update dotnet.yml --- .github/workflows/dotnet.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml index a9403d81..eeef2c4a 100644 --- a/.github/workflows/dotnet.yml +++ b/.github/workflows/dotnet.yml @@ -80,7 +80,7 @@ jobs: env: BuildAot: 'true' run: | - dotnet restore --configFile AlphaPackages.config + dotnet restore --configfile AlphaPackages.config -r ${{ matrix.rid }} dotnet publish --no-restore -c Release -f net8.0 -r ${{ matrix.rid }} ./bin/Release/net8.0/${{ matrix.rid }}/publish/FlatSharpEndToEndTests From 4249a408070a9ae419ec48d6d326677f9d7bf835 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 11:24:51 -0800 Subject: [PATCH 11/14] Move NuGet.config back --- .../FlatSharpEndToEndTests/AlphaPackages.config => NuGet.config} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{Tests/FlatSharpEndToEndTests/AlphaPackages.config => NuGet.config} (100%) diff --git a/src/Tests/FlatSharpEndToEndTests/AlphaPackages.config b/src/NuGet.config similarity index 100% rename from src/Tests/FlatSharpEndToEndTests/AlphaPackages.config rename to src/NuGet.config From 34da3d7ae6abea49ccbb287125ef87a36a74660a Mon Sep 17 00:00:00 2001 From: James Courtney Date: Sun, 3 Mar 2024 11:25:27 -0800 Subject: [PATCH 12/14] Update dotnet.yml --- .github/workflows/dotnet.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/dotnet.yml b/.github/workflows/dotnet.yml index eeef2c4a..9739810d 100644 --- a/.github/workflows/dotnet.yml +++ b/.github/workflows/dotnet.yml @@ -80,8 +80,7 @@ jobs: env: BuildAot: 'true' run: | - dotnet restore --configfile AlphaPackages.config -r ${{ matrix.rid }} - dotnet publish --no-restore -c Release -f net8.0 -r ${{ matrix.rid }} + dotnet publish -c Release -f net8.0 -r ${{ matrix.rid }} ./bin/Release/net8.0/${{ matrix.rid }}/publish/FlatSharpEndToEndTests - name: Poolable E2E Test From 921c906ff87a1dc1f6e47757c43ca45768fd2256 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Mon, 4 Mar 2024 21:00:18 -0800 Subject: [PATCH 13/14] Update FlatSharpEndToEndTests.csproj --- src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj index 94959d03..2809b75a 100644 --- a/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj +++ b/src/Tests/FlatSharpEndToEndTests/FlatSharpEndToEndTests.csproj @@ -23,7 +23,6 @@ true net8.0 FlatSharpEndToEndTests.Program - true exe $(DefineConstants);AOT From f21ff1bef9efce9a04e90f344e7d4679c2c1bee7 Mon Sep 17 00:00:00 2001 From: James Courtney Date: Tue, 5 Mar 2024 23:22:32 -0800 Subject: [PATCH 14/14] Convert stryker to mstest --- .../DeserializationOptionClassData.cs | 1 - src/Tests/Stryker/Tests/FullTreeTests.cs | 123 ++++++------- src/Tests/Stryker/Tests/GlobalUsings.cs | 5 +- src/Tests/Stryker/Tests/IndexedVectorTests.cs | 83 ++++----- src/Tests/Stryker/Tests/MemoryVectorTests.cs | 19 +- .../Stryker/Tests/PrimitivesFieldsTests.cs | 37 ++-- .../Stryker/Tests/RefStructVectorTests.cs | 41 ++--- src/Tests/Stryker/Tests/RootObjectTests.cs | 9 +- src/Tests/Stryker/Tests/ScalarFieldTests.cs | 7 +- src/Tests/Stryker/Tests/StringVectorTests.cs | 38 ++-- src/Tests/Stryker/Tests/StructFieldTests.cs | 135 ++++++++------- src/Tests/Stryker/Tests/StrykerTests.csproj | 9 +- src/Tests/Stryker/Tests/TableVectorTests.cs | 45 ++--- src/Tests/Stryker/Tests/UnionFieldTests.cs | 163 +++++++++--------- src/Tests/Stryker/Tests/UnionVectorTests.cs | 121 ++++++------- .../Stryker/Tests/ValueStructVectorTests.cs | 65 +++---- 16 files changed, 454 insertions(+), 447 deletions(-) diff --git a/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs b/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs index f46d4f2f..f8861052 100644 --- a/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs +++ b/src/Tests/FlatSharpEndToEndTests/DeserializationOptionClassData.cs @@ -32,4 +32,3 @@ public static IEnumerable DeserializationModes } } } - diff --git a/src/Tests/Stryker/Tests/FullTreeTests.cs b/src/Tests/Stryker/Tests/FullTreeTests.cs index df438800..76cfd9b4 100644 --- a/src/Tests/Stryker/Tests/FullTreeTests.cs +++ b/src/Tests/Stryker/Tests/FullTreeTests.cs @@ -5,10 +5,11 @@ namespace FlatSharpStrykerTests; +[TestClass] public class FullTreeTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void RootMutations(FlatBufferDeserializationOption option) { Root root = this.CreateRoot().SerializeAndParse(option); @@ -17,13 +18,13 @@ public void RootMutations(FlatBufferDeserializationOption option) Helpers.AssertMutationWorks(option, root, false, r => r.Vectors, new Vectors()); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void VectorFieldMutations(FlatBufferDeserializationOption option) { static void AssertMemoryEqual(Memory? a, Memory? b) { - Assert.Equal(a is null, b is null); + Assert.AreEqual(a is null, b is null); if (a is null) { return; @@ -43,7 +44,7 @@ static void AssertMemoryEqual(Memory? a, Memory? b) Helpers.AssertMutationWorks(option, vectors, false, r => r.ValueStruct, null); } - [Fact] + [TestMethod] public void VectorFieldTests_ProgressiveClear() { Vectors vectors = this.CreateRoot().SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] data).Vectors; @@ -54,42 +55,42 @@ public void VectorFieldTests_ProgressiveClear() Helpers.AssertSequenceEqual(new byte[] { 0, 0, 0, 0, }, vectors.Memory.Value.Span); } - [Fact] + [TestMethod] public void GetMaxSize() { Root root = this.CreateRoot(); int maxSize = Root.Serializer.GetMaxSize(root); - Assert.Equal(898, maxSize); + Assert.AreEqual(898, maxSize); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Clone(FlatBufferDeserializationOption option) { Root root = this.CreateRoot().SerializeAndParse(option); Root copy = new Root(root); - Assert.True(root.IsInitialized); - Assert.True(copy.IsInitialized); + Assert.IsTrue(root.IsInitialized); + Assert.IsTrue(copy.IsInitialized); - Assert.NotSame(root, copy); - Assert.Equal(typeof(Root), copy.GetType()); - Assert.NotEqual(typeof(Root), root.GetType()); + Assert.AreNotSame(root, copy); + Assert.AreEqual(typeof(Root), copy.GetType()); + Assert.AreNotEqual(typeof(Root), root.GetType()); { Vectors rv = root.Vectors; Vectors cv = copy.Vectors; - Assert.NotSame(rv, cv); - Assert.NotSame(rv.GetType(), cv.GetType()); - Assert.Equal(typeof(Vectors), cv.GetType()); - Assert.True(rv.IsInitialized); - Assert.True(cv.IsInitialized); + Assert.AreNotSame(rv, cv); + Assert.AreNotSame(rv.GetType(), cv.GetType()); + Assert.AreEqual(typeof(Vectors), cv.GetType()); + Assert.IsTrue(rv.IsInitialized); + Assert.IsTrue(cv.IsInitialized); Verify(rv.RefStruct, cv.RefStruct, Verify); Verify(rv.ValueStruct, cv.ValueStruct, Verify); - Verify(rv.Str, cv.Str, Assert.Equal); + Verify(rv.Str, cv.Str, Assert.AreEqual); Verify(rv.Union, cv.Union, Verify); Verify(rv.Indexed, cv.Indexed, Verify); Verify(rv.Memory, cv.Memory, Verify); @@ -100,42 +101,42 @@ public void Clone(FlatBufferDeserializationOption option) Fields rf = root.Fields; Fields cf = copy.Fields; - Assert.NotSame(rf, cf); - Assert.True(rf.IsInitialized); - Assert.True(cf.IsInitialized); - Assert.NotSame(rf.GetType(), cf.GetType()); - Assert.Equal(typeof(Fields), cf.GetType()); + Assert.AreNotSame(rf, cf); + Assert.IsTrue(rf.IsInitialized); + Assert.IsTrue(cf.IsInitialized); + Assert.AreNotSame(rf.GetType(), cf.GetType()); + Assert.AreEqual(typeof(Fields), cf.GetType()); - Assert.Equal(rf.Memory, cf.Memory); - Assert.Equal(rf.ScalarWithDefault, cf.ScalarWithDefault); - Assert.Equal(rf.Str, cf.Str); + Assert.AreEqual(rf.Memory, cf.Memory); + Assert.AreEqual(rf.ScalarWithDefault, cf.ScalarWithDefault); + Assert.AreEqual(rf.Str, cf.Str); Verify(rf.RefStruct, cf.RefStruct); Verify(rf.ValueStruct, cf.ValueStruct, Verify); Verify(rf.Union, cf.Union, Verify); - Assert.Equal(rf.Memory, cf.Memory); + Assert.AreEqual(rf.Memory, cf.Memory); } } private static void Verify(IIndexedVector a, IIndexedVector b, Action verify) where T : class { - Assert.NotSame(a, b); - Assert.Equal(a.Count, b.Count); + Assert.AreNotSame(a, b); + Assert.AreEqual(a.Count, b.Count); foreach (var kvp in a) { TKey key = kvp.Key; T value = kvp.Value; - Assert.True(b.TryGetValue(key, out T? bValue)); + Assert.IsTrue(b.TryGetValue(key, out T? bValue)); verify(value, bValue); } } private static void Verify(IList a, IList b, Action comparer) { - Assert.NotSame(a, b); - Assert.Equal(a.Count, b.Count); + Assert.AreNotSame(a, b); + Assert.AreEqual(a.Count, b.Count); for (int i = 0; i < a.Count; ++i) { @@ -145,7 +146,7 @@ private static void Verify(IList a, IList b, Action comparer) private static void Verify(T? a, T? b, Action action) where T : struct { - Assert.Equal(a.HasValue, b.HasValue); + Assert.AreEqual(a.HasValue, b.HasValue); if (a.HasValue) { action(a.Value, b.Value); @@ -154,20 +155,20 @@ private static void Verify(T? a, T? b, Action action) where T : struct private static void Verify(Memory a, Memory b) { - Assert.True(a.Span.SequenceEqual(b.Span)); + Assert.IsTrue(a.Span.SequenceEqual(b.Span)); } private static void Verify(ValueStruct a, ValueStruct b) { - Assert.Equal(a.A, b.A); - Assert.Equal(a.B, b.B); - Assert.Equal(a.C(0), b.C(0)); - Assert.Equal(a.C(1), b.C(1)); + Assert.AreEqual(a.A, b.A); + Assert.AreEqual(a.B, b.B); + Assert.AreEqual(a.C(0), b.C(0)); + Assert.AreEqual(a.C(1), b.C(1)); } private static void Verify(FunUnion a, FunUnion b) { - Assert.Equal(a.Discriminator, b.Discriminator); + Assert.AreEqual(a.Discriminator, b.Discriminator); switch (a.Kind) { @@ -180,7 +181,7 @@ private static void Verify(FunUnion a, FunUnion b) return; case FunUnion.ItemKind.str: - Assert.Equal(a.str, b.str); + Assert.AreEqual(a.str, b.str); return; case FunUnion.ItemKind.ValueStruct: @@ -188,34 +189,34 @@ private static void Verify(FunUnion a, FunUnion b) return; default: - Assert.False(true); + Assert.IsFalse(true); return; } } private static void Verify(Key a, Key b) { - Assert.NotSame(a, b); - Assert.True(a.IsInitialized); - Assert.True(b.IsInitialized); - Assert.Equal(a.Name, b.Name); - Assert.Equal(a.Value, b.Value); + Assert.AreNotSame(a, b); + Assert.IsTrue(a.IsInitialized); + Assert.IsTrue(b.IsInitialized); + Assert.AreEqual(a.Name, b.Name); + Assert.AreEqual(a.Value, b.Value); } private static void Verify(RefStruct a, RefStruct b) { - Assert.NotSame(a, b); - Assert.True(a.IsInitialized); - Assert.True(b.IsInitialized); - Assert.Equal(a.A, b.A); - Assert.Equal(a.B, b.B); - Assert.Equal(a.C[0], b.C[0]); - Assert.Equal(a.C[1], b.C[1]); - Assert.Equal(a.D[0], b.D[0]); - Assert.Equal(a.D[1], b.D[1]); - - Assert.Equal(new[] { a.C[0], a.C[1] }, b.C); - Assert.Equal(new[] { a.D[0], a.D[1] }, b.D); + Assert.AreNotSame(a, b); + Assert.IsTrue(a.IsInitialized); + Assert.IsTrue(b.IsInitialized); + Assert.AreEqual(a.A, b.A); + Assert.AreEqual(a.B, b.B); + Assert.AreEqual(a.C[0], b.C[0]); + Assert.AreEqual(a.C[1], b.C[1]); + Assert.AreEqual(a.D[0], b.D[0]); + Assert.AreEqual(a.D[1], b.D[1]); + + Assert.IsTrue(Enumerable.SequenceEqual(new[] { a.C[0], a.C[1] }, b.C)); + Assert.IsTrue(Enumerable.SequenceEqual(new[] { a.D[0], a.D[1] }, b.D)); Verify(a.E, b.E); } diff --git a/src/Tests/Stryker/Tests/GlobalUsings.cs b/src/Tests/Stryker/Tests/GlobalUsings.cs index 723f7c0a..41ab2f10 100644 --- a/src/Tests/Stryker/Tests/GlobalUsings.cs +++ b/src/Tests/Stryker/Tests/GlobalUsings.cs @@ -28,5 +28,6 @@ global using System.Runtime.CompilerServices; global using FlatSharp; global using FlatSharp.Attributes; -global using Xunit; -global using FlatSharpEndToEndTests; \ No newline at end of file +global using FlatSharpEndToEndTests; + +global using Microsoft.VisualStudio.TestTools.UnitTesting; \ No newline at end of file diff --git a/src/Tests/Stryker/Tests/IndexedVectorTests.cs b/src/Tests/Stryker/Tests/IndexedVectorTests.cs index 5a76c37a..833ef4f8 100644 --- a/src/Tests/Stryker/Tests/IndexedVectorTests.cs +++ b/src/Tests/Stryker/Tests/IndexedVectorTests.cs @@ -5,22 +5,23 @@ namespace FlatSharpStrykerTests; +[TestClass] public class IndexedVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Present(FlatBufferDeserializationOption option) { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); IIndexedVector vector = vectors.Indexed; - Assert.Equal(option != FlatBufferDeserializationOption.GreedyMutable, vector.IsReadOnly); + Assert.AreEqual(option != FlatBufferDeserializationOption.GreedyMutable, vector.IsReadOnly); var expected = root.Vectors.Indexed.ToArray(); @@ -29,40 +30,40 @@ public void Present(FlatBufferDeserializationOption option) Fruit f = pair.Value.Value; string name = pair.Value.Name; - Assert.True(vector.TryGetValue(name, out Key key)); - Assert.Equal(f, key.Value); - Assert.Equal(name, key.Name); + Assert.IsTrue(vector.TryGetValue(name, out Key key)); + Assert.AreEqual(f, key.Value); + Assert.AreEqual(name, key.Name); key = vector[name]; - Assert.Equal(f, key.Value); + Assert.AreEqual(f, key.Value); - Assert.True(vector.ContainsKey(name)); + Assert.IsTrue(vector.ContainsKey(name)); } - Assert.False(vector.ContainsKey("z")); - Assert.False(vector.TryGetValue("z", out _)); + Assert.IsFalse(vector.ContainsKey("z")); + Assert.IsFalse(vector.TryGetValue("z", out _)); Helpers.AssertMutationWorks(option, vectors, false, v => v.Indexed, new IndexedVector()); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Missing(FlatBufferDeserializationOption option) { Root root = CreateRoot_Missing(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); - Assert.Null(vectors.Indexed); + Assert.IsNull(vectors.Indexed); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void KeyNotSet_Serialize(FlatBufferDeserializationOption option) { Key key = new Key { Name = "fred", Value = Fruit.Apple }; @@ -80,11 +81,11 @@ public void KeyNotSet_Serialize(FlatBufferDeserializationOption option) key.Name = null!; - var ex = Assert.Throws(() => root.SerializeAndParse(option)); - Assert.Equal("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was not set.", ex.Message); + var ex = Assert.ThrowsException(() => root.SerializeAndParse(option)); + Assert.AreEqual("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was not set.", ex.Message); } - [Fact] + [TestMethod] public void NullItem_Serialize() { Root root = new() @@ -99,15 +100,15 @@ public void NullItem_Serialize() var backingDictionary = (Dictionary)typeof(IndexedVector).GetField("backingDictionary", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(root.Vectors.Indexed); backingDictionary["foo"] = null; - var ex = Assert.Throws(() => Root.Serializer.GetMaxSize(root)); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + var ex = Assert.ThrowsException(() => Root.Serializer.GetMaxSize(root)); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); - ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + ex = Assert.ThrowsException(() => Root.Serializer.Write(new byte[1024], root)); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void KeyNotSet_Parse(FlatBufferDeserializationOption option) { // missing required field. @@ -138,17 +139,17 @@ public void KeyNotSet_Parse(FlatBufferDeserializationOption option) 0, 0, 4, 0, }; - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var root = Root.Serializer.Parse(data, option); string name = root.Fields.Union.Value.Key.Name; }); - Assert.Equal("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was missing from the buffer.", ex.Message); + Assert.AreEqual("Table property 'FlatSharpStrykerTests.Key.Name' is marked as required, but was missing from the buffer.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Big(FlatBufferDeserializationOption option) { Root root = new Root @@ -173,21 +174,21 @@ public void Big(FlatBufferDeserializationOption option) for (int i = 0; i < expectedKeys.Count; ++i) { - Assert.True(parsedIndexed.ContainsKey(expectedKeys[i])); - Assert.NotNull(parsedIndexed[expectedKeys[i]]); - Assert.True(parsedIndexed.TryGetValue(expectedKeys[i], out Key key)); - Assert.NotNull(key); - Assert.Equal(expectedKeys[i], key.Name); + Assert.IsTrue(parsedIndexed.ContainsKey(expectedKeys[i])); + Assert.IsNotNull(parsedIndexed[expectedKeys[i]]); + Assert.IsTrue(parsedIndexed.TryGetValue(expectedKeys[i], out Key key)); + Assert.IsNotNull(key); + Assert.AreEqual(expectedKeys[i], key.Name); } for (int i = 0; i < expectedKeys.Count; ++i) { string unexpectedKey = Guid.NewGuid().ToString("n"); - Assert.False(parsedIndexed.ContainsKey(unexpectedKey)); - Assert.Throws(() => parsedIndexed[unexpectedKey]); - Assert.False(parsedIndexed.TryGetValue(unexpectedKey, out Key key)); - Assert.Null(key); + Assert.IsFalse(parsedIndexed.ContainsKey(unexpectedKey)); + Assert.ThrowsException(() => parsedIndexed[unexpectedKey]); + Assert.IsFalse(parsedIndexed.TryGetValue(unexpectedKey, out Key key)); + Assert.IsNull(key); } } diff --git a/src/Tests/Stryker/Tests/MemoryVectorTests.cs b/src/Tests/Stryker/Tests/MemoryVectorTests.cs index f555c386..75354df2 100644 --- a/src/Tests/Stryker/Tests/MemoryVectorTests.cs +++ b/src/Tests/Stryker/Tests/MemoryVectorTests.cs @@ -4,38 +4,39 @@ namespace FlatSharpStrykerTests; +[TestClass] public class MemoryVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void MemoryVector(FlatBufferDeserializationOption option) { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); Memory vector = vectors.Memory.Value; - Assert.Equal(5, vector.Length); + Assert.AreEqual(5, vector.Length); for (int i = 0; i < vector.Length; ++i) { - Assert.Equal(i + 1, vector.Span[i]); + Assert.AreEqual(i + 1, vector.Span[i]); } Helpers.AssertMutationWorks(option, vectors, false, s => s.Memory, new byte[0]); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void MemoryVector_NotPresent(FlatBufferDeserializationOption option) { Root root = new Root() { Vectors = new() }; Root parsed = root.SerializeAndParse(option, out byte[] buffer); - Assert.Null(parsed.Vectors.Memory); + Assert.IsNull(parsed.Vectors.Memory); } private Root CreateRoot(out byte[] expectedData) diff --git a/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs b/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs index ec8ba39c..9a9bd411 100644 --- a/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs +++ b/src/Tests/Stryker/Tests/PrimitivesFieldsTests.cs @@ -3,87 +3,88 @@ namespace FlatSharpStrykerTests; +[TestClass] public class PrimitivesFieldsTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void StringTableField(FlatBufferDeserializationOption option) { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal("hello", fields.Str); + Assert.AreEqual("hello", fields.Str); Helpers.AssertMutationWorks(option, fields, false, s => s.Str, string.Empty); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ScalarTableField(FlatBufferDeserializationOption option) { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal(3, fields.Memory); + Assert.AreEqual(3, fields.Memory); Helpers.AssertMutationWorks(option, fields, false, s => s.Memory, (byte)0); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ScalarTableField_WithDefaultValue(FlatBufferDeserializationOption option) { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal(3, fields.ScalarWithDefault); + Assert.AreEqual(3, fields.ScalarWithDefault); Helpers.AssertMutationWorks(option, fields, false, s => s.ScalarWithDefault, 8); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ScalarTableField_WithoutDefaultValue(FlatBufferDeserializationOption option) { Root root = CreateRoot_NotDefault(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal(root.Fields.ScalarWithDefault, fields.ScalarWithDefault); + Assert.AreEqual(root.Fields.ScalarWithDefault, fields.ScalarWithDefault); Helpers.AssertMutationWorks(option, fields, false, s => s.ScalarWithDefault, 8); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Fact] + [TestMethod] public void ProgressiveStringTableField() { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal("hello", Helpers.TestProgressiveFieldLoad(3, true, fields, f => f.Str)); + Assert.AreEqual("hello", Helpers.TestProgressiveFieldLoad(3, true, fields, f => f.Str)); } - [Fact] + [TestMethod] public void ProgressiveScalarTableField() { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal(3, Helpers.TestProgressiveFieldLoad(2, true, fields, f => f.Memory)); + Assert.AreEqual(3, Helpers.TestProgressiveFieldLoad(2, true, fields, f => f.Memory)); } - [Fact] + [TestMethod] public void ProgressiveScalarTableFieldWithDefaultValue() { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); Fields fields = parsed.Fields; - Assert.Equal(3, Helpers.TestProgressiveFieldLoad(6, false, fields, f => f.ScalarWithDefault)); + Assert.AreEqual(3, Helpers.TestProgressiveFieldLoad(6, false, fields, f => f.ScalarWithDefault)); } private Root CreateRoot(out byte[] expectedData) diff --git a/src/Tests/Stryker/Tests/RefStructVectorTests.cs b/src/Tests/Stryker/Tests/RefStructVectorTests.cs index 2d3aec2b..3b68fff9 100644 --- a/src/Tests/Stryker/Tests/RefStructVectorTests.cs +++ b/src/Tests/Stryker/Tests/RefStructVectorTests.cs @@ -5,39 +5,40 @@ namespace FlatSharpStrykerTests; +[TestClass] public class RefStructVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] actualData); - Assert.NotNull(root.Vectors.RefStruct); + Assert.IsNotNull(root.Vectors.RefStruct); var vsr = root.Vectors.RefStruct; var vsp = parsed.Vectors.RefStruct; - Assert.Equal(vsr.Count, vsp.Count); + Assert.AreEqual(vsr.Count, vsp.Count); for (int i = 0; i < vsr.Count; ++i) { var r = vsr[i]; var p = vsp[i]; - Assert.Equal(r.A, p.A); - Assert.Equal(r.B, p.B); - Assert.Equal(r.C[0], p.C[0]); - Assert.Equal(r.C[1], p.C[1]); - Assert.Equal(r.D[0], p.D[0]); - Assert.Equal(r.D[1], p.D[1]); + Assert.AreEqual(r.A, p.A); + Assert.AreEqual(r.B, p.B); + Assert.AreEqual(r.C[0], p.C[0]); + Assert.AreEqual(r.C[1], p.C[1]); + Assert.AreEqual(r.D[0], p.D[0]); + Assert.AreEqual(r.D[1], p.D[1]); - Assert.Equal(r.C.ToArray()[0], p.C.ToArray()[0]); - Assert.Equal(r.D.ToArray()[0], p.D.ToArray()[0]); + Assert.AreEqual(r.C.ToArray()[0], p.C.ToArray()[0]); + Assert.AreEqual(r.D.ToArray()[0], p.D.ToArray()[0]); - Assert.Same(p.D, p.D); - Assert.Same(p.C, p.C); + Assert.AreSame(p.D, p.D); + Assert.AreSame(p.C, p.C); } Helpers.AssertSequenceEqual(expectedData, actualData); @@ -45,18 +46,18 @@ public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() Helpers.ValidateListVector(option, false, vsp, new RefStruct()); }); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Missing(FlatBufferDeserializationOption option) { Root root = CreateRoot_Missing(out byte[] expectedData); root.SerializeAndParse(option, out byte[] actualData); - Assert.Null(root.Vectors.RefStruct); + Assert.IsNull(root.Vectors.RefStruct); Helpers.AssertSequenceEqual(expectedData, actualData); } - [Fact] + [TestMethod] public void WithNull() => Helpers.Repeat(() => { Root root = new() @@ -67,8 +68,8 @@ public void WithNull() => Helpers.Repeat(() => } }; - var ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + var ex = Assert.ThrowsException(() => Root.Serializer.Write(new byte[1024], root)); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); // no exception here. Reason is that structs are constant size, so we don't traverse the vector to figure out the max size. int maxSize = Root.Serializer.GetMaxSize(root); diff --git a/src/Tests/Stryker/Tests/RootObjectTests.cs b/src/Tests/Stryker/Tests/RootObjectTests.cs index 178e0684..186fec99 100644 --- a/src/Tests/Stryker/Tests/RootObjectTests.cs +++ b/src/Tests/Stryker/Tests/RootObjectTests.cs @@ -1,12 +1,13 @@ namespace FlatSharpStrykerTests; +[TestClass] public class RootObjectTests { - [Fact] + [TestMethod] public void InvalidConstructors() { - Assert.Throws(() => new FunUnion((string)null)); - Assert.Throws(() => new FunUnion((RefStruct)null)); - Assert.Throws(() => new FunUnion((Key)null)); + Assert.ThrowsException(() => new FunUnion((string)null)); + Assert.ThrowsException(() => new FunUnion((RefStruct)null)); + Assert.ThrowsException(() => new FunUnion((Key)null)); } } diff --git a/src/Tests/Stryker/Tests/ScalarFieldTests.cs b/src/Tests/Stryker/Tests/ScalarFieldTests.cs index ccb5bb1e..79610294 100644 --- a/src/Tests/Stryker/Tests/ScalarFieldTests.cs +++ b/src/Tests/Stryker/Tests/ScalarFieldTests.cs @@ -3,16 +3,17 @@ namespace FlatSharpStrykerTests; +[TestClass] public class ScalarFieldTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ValueStructTableField(FlatBufferDeserializationOption option) { Root r = CreateTableWithScalarField(out byte[] buffer); Root parsed = r.SerializeAndParse(option, out byte[] actual); - Assert.Equal(r.Fields.Memory, parsed.Fields.Memory); + Assert.AreEqual(r.Fields.Memory, parsed.Fields.Memory); Helpers.AssertSequenceEqual(buffer, actual); } diff --git a/src/Tests/Stryker/Tests/StringVectorTests.cs b/src/Tests/Stryker/Tests/StringVectorTests.cs index a2731845..5918954c 100644 --- a/src/Tests/Stryker/Tests/StringVectorTests.cs +++ b/src/Tests/Stryker/Tests/StringVectorTests.cs @@ -2,35 +2,35 @@ using System.IO; using System.Linq.Expressions; using System.Threading; -using Xunit.Sdk; namespace FlatSharpStrykerTests; +[TestClass] public class StringVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void StringTableField(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); IList theBoys = vectors.Str; - Assert.Equal(3, theBoys.Count); - Assert.Equal("billy", theBoys[0]); - Assert.Equal("mm", theBoys[1]); - Assert.Equal("frenchie", theBoys[2]); + Assert.AreEqual(3, theBoys.Count); + Assert.AreEqual("billy", theBoys[0]); + Assert.AreEqual("mm", theBoys[1]); + Assert.AreEqual("frenchie", theBoys[2]); Helpers.AssertMutationWorks(option, vectors, false, s => s.Str, new string[0]); Helpers.ValidateListVector(option, false, theBoys, string.Empty); Helpers.AssertSequenceEqual(expectedData, buffer); }); - [Fact] + [TestMethod] public void WithNull() => Helpers.Repeat(() => { Root root = new() @@ -41,15 +41,15 @@ public void WithNull() => Helpers.Repeat(() => } }; - var ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + var ex = Assert.ThrowsException(() => Root.Serializer.Write(new byte[1024], root)); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); - ex = Assert.Throws(() => Root.Serializer.GetMaxSize(root)); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + ex = Assert.ThrowsException(() => Root.Serializer.GetMaxSize(root)); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); }); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Big(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = new Root { Vectors = new() { Str = new List() } }; @@ -64,12 +64,12 @@ public void Big(FlatBufferDeserializationOption option) => Helpers.Repeat(() => for (int i = 0; i < 1000; ++i) { - Assert.Equal(root.Vectors.Str[i], parsedList[i]); + Assert.AreEqual(root.Vectors.Str[i], parsedList[i]); Action assert = option switch { - FlatBufferDeserializationOption.Lazy => Assert.NotSame, - _ => Assert.Same, + FlatBufferDeserializationOption.Lazy => Assert.AreNotSame, + _ => Assert.AreSame, }; assert(parsedList[i], parsedList[i]); diff --git a/src/Tests/Stryker/Tests/StructFieldTests.cs b/src/Tests/Stryker/Tests/StructFieldTests.cs index 0bf5c01d..fe28f656 100644 --- a/src/Tests/Stryker/Tests/StructFieldTests.cs +++ b/src/Tests/Stryker/Tests/StructFieldTests.cs @@ -3,10 +3,11 @@ namespace FlatSharpStrykerTests; +[TestClass] public class StructFieldTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ValueStructTableField(FlatBufferDeserializationOption option) { try @@ -24,8 +25,8 @@ public void ValueStructTableField(FlatBufferDeserializationOption option) vs.C(0) = 1; vs.C(1) = 2; - Assert.Throws(() => vs.C(2) = 4); - Assert.Throws(() => vs.C(-1) = 4); + Assert.ThrowsException(() => vs.C(2) = 4); + Assert.ThrowsException(() => vs.C(-1) = 4); Root root = new Root { @@ -38,17 +39,17 @@ public void ValueStructTableField(FlatBufferDeserializationOption option) Root parsed = root.SerializeAndParse(option, out byte[] buffer); Fields fields = parsed.Fields; - Assert.NotNull(fields); - Assert.Null(parsed.Vectors); + Assert.IsNotNull(fields); + Assert.IsNull(parsed.Vectors); - Assert.NotNull(parsed.Fields.ValueStruct); + Assert.IsNotNull(parsed.Fields.ValueStruct); ValueStruct vsParsed = parsed.Fields.ValueStruct.Value; - Assert.Equal(vs.A, vsParsed.A); - Assert.Equal(vs.B, vsParsed.B); - Assert.Equal(vs.C(0), vsParsed.C(0)); - Assert.Equal(vs.C(1), vsParsed.C(1)); + Assert.AreEqual(vs.A, vsParsed.A); + Assert.AreEqual(vs.B, vsParsed.B); + Assert.AreEqual(vs.C(0), vsParsed.C(0)); + Assert.AreEqual(vs.C(1), vsParsed.C(1)); byte[] expectedBytes = { @@ -78,10 +79,10 @@ public void ValueStructTableField(FlatBufferDeserializationOption option) var av = a.Value; var bv = b.Value; - Assert.Equal(av.A, bv.A); - Assert.Equal(av.B, bv.B); - Assert.Equal(av.C(0), bv.C(0)); - Assert.Equal(av.C(1), bv.C(1)); + Assert.AreEqual(av.A, bv.A); + Assert.AreEqual(av.B, bv.B); + Assert.AreEqual(av.C(0), bv.C(0)); + Assert.AreEqual(av.C(1), bv.C(1)); }); } } @@ -91,62 +92,62 @@ public void ValueStructTableField(FlatBufferDeserializationOption option) } } - [Fact] + [TestMethod] public void ValueStructTableField_ProgressiveClear() { Root root = new Root() { Fields = new() { ValueStruct = new ValueStruct { A = 5 } } }.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); var fields = root.Fields; - Assert.Equal(5, fields.ValueStruct.Value.A); + Assert.AreEqual(5, fields.ValueStruct.Value.A); buffer.AsSpan().Clear(); - Assert.Equal(5, fields.ValueStruct.Value.A); + Assert.AreEqual(5, fields.ValueStruct.Value.A); } - [Fact] + [TestMethod] public void ValueStructStructField_ProgressiveClear() { Root root = new Root() { Fields = new() { RefStruct = new() { E = new ValueStruct { A = 5 } } } }.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); var fields = root.Fields.RefStruct; - Assert.Equal(5, fields.E.A); + Assert.AreEqual(5, fields.E.A); buffer.AsSpan().Clear(); - Assert.Equal(5, fields.E.A); + Assert.AreEqual(5, fields.E.A); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ReferenceStructTableField(FlatBufferDeserializationOption option) { Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); Root parsed = root.SerializeAndParse(option, out byte[] buffer); - Assert.Throws(() => rs.C[-1] = 4); - Assert.Throws(() => rs.D[3] = 4); + Assert.ThrowsException(() => rs.C[-1] = 4); + Assert.ThrowsException(() => rs.D[3] = 4); - Assert.NotNull(parsed.Fields); - Assert.Null(parsed.Vectors); - Assert.NotNull(parsed.Fields.RefStruct); + Assert.IsNotNull(parsed.Fields); + Assert.IsNull(parsed.Vectors); + Assert.IsNotNull(parsed.Fields.RefStruct); RefStruct rsParsed = parsed.Fields.RefStruct; - Assert.Equal(rs.A, rsParsed.A); - Assert.Equal(rs.B, rsParsed.B); - Assert.Equal(rs.C[0], rsParsed.C[0]); - Assert.Equal(rs.C[1], rsParsed.C[1]); - Assert.Equal(rs.D[0], rsParsed.D[0]); - Assert.Equal(rs.D[1], rsParsed.D[1]); + Assert.AreEqual(rs.A, rsParsed.A); + Assert.AreEqual(rs.B, rsParsed.B); + Assert.AreEqual(rs.C[0], rsParsed.C[0]); + Assert.AreEqual(rs.C[1], rsParsed.C[1]); + Assert.AreEqual(rs.D[0], rsParsed.D[0]); + Assert.AreEqual(rs.D[1], rsParsed.D[1]); ValueStruct vsParsed = rsParsed.E; - Assert.Equal(vs.A, vsParsed.A); - Assert.Equal(vs.B, vsParsed.B); - Assert.Equal(vs.C(0), vsParsed.C(0)); - Assert.Equal(vs.C(1), vsParsed.C(1)); + Assert.AreEqual(vs.A, vsParsed.A); + Assert.AreEqual(vs.B, vsParsed.B); + Assert.AreEqual(vs.C(0), vsParsed.C(0)); + Assert.AreEqual(vs.C(1), vsParsed.C(1)); Helpers.AssertSequenceEqual(expectedBytes, buffer); Helpers.AssertMutationWorks(option, parsed.Fields, false, p => p.RefStruct, new RefStruct()); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ReferenceStructWriteThrough(FlatBufferDeserializationOption option) { Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); @@ -162,20 +163,20 @@ public void ReferenceStructWriteThrough(FlatBufferDeserializationOption option) Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.__flatsharp__D_1, (sbyte)6); Helpers.AssertMutationWorks(option, rsp, false, rsp => rsp.E, new ValueStruct(), (a, b) => { - Assert.Equal(a.A, b.A); - Assert.Equal(a.B, b.B); - Assert.Equal(a.C(0), b.C(0)); - Assert.Equal(a.C(1), b.C(1)); + Assert.AreEqual(a.A, b.A); + Assert.AreEqual(a.B, b.B); + Assert.AreEqual(a.C(0), b.C(0)); + Assert.AreEqual(a.C(1), b.C(1)); }); var parsed2 = Root.Serializer.Parse(buffer, option); - Assert.Equal(rsp.A, parsed2.Fields.RefStruct.A); - Assert.Equal(rsp.C[0], parsed2.Fields.RefStruct.C[0]); - Assert.Equal(rsp.C[1], parsed2.Fields.RefStruct.C[1]); + Assert.AreEqual(rsp.A, parsed2.Fields.RefStruct.A); + Assert.AreEqual(rsp.C[0], parsed2.Fields.RefStruct.C[0]); + Assert.AreEqual(rsp.C[1], parsed2.Fields.RefStruct.C[1]); } - [Fact] + [TestMethod] public void ReferenceStructWriteThrough_Progressive() { Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); @@ -192,13 +193,13 @@ public void ReferenceStructWriteThrough_Progressive() buffer.AsSpan().Clear(); // now read. Expect the same values back. - Assert.Equal(4, rsp.A); - Assert.Equal(6, rsp.C[0]); - Assert.Equal(7, rsp.C[1]); + Assert.AreEqual(4, rsp.A); + Assert.AreEqual(6, rsp.C[0]); + Assert.AreEqual(7, rsp.C[1]); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ReferenceStructOnDeserialized(FlatBufferDeserializationOption option) { Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); @@ -207,33 +208,33 @@ public void ReferenceStructOnDeserialized(FlatBufferDeserializationOption option Fields fields = parsed.Fields; RefStruct rsp = fields.RefStruct; - Assert.True(parsed.IsInitialized); - Assert.True(Root.IsStaticInitialized); + Assert.IsTrue(parsed.IsInitialized); + Assert.IsTrue(Root.IsStaticInitialized); - Assert.True(fields.IsInitialized); - Assert.True(Fields.IsStaticInitialized); + Assert.IsTrue(fields.IsInitialized); + Assert.IsTrue(Fields.IsStaticInitialized); - Assert.True(rsp.IsInitialized); - Assert.True(RefStruct.IsStaticInitialized); + Assert.IsTrue(rsp.IsInitialized); + Assert.IsTrue(RefStruct.IsStaticInitialized); } - [Fact] + [TestMethod] public void ProgressiveFieldLoads() { Root root = CreateRootReferenceStruct(out RefStruct rs, out ValueStruct vs, out byte[] expectedBytes); Root parsed = root.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); Fields fields = Helpers.TestProgressiveFieldLoad(0, true, parsed, p => p.Fields); - Assert.NotNull(fields); + Assert.IsNotNull(fields); { RefStruct @ref = Helpers.TestProgressiveFieldLoad(0, true, fields, f => f.RefStruct); - Assert.Equal(root.Fields.RefStruct.A, Helpers.TestProgressiveFieldLoad(0, true, @ref, r => r.A)); - Assert.Equal(root.Fields.RefStruct.B, Helpers.TestProgressiveFieldLoad(1, true, @ref, r => r.B)); - Assert.Equal(root.Fields.RefStruct.C[0], Helpers.TestProgressiveFieldLoad(2, true, @ref, r => r.__flatsharp__C_0)); - Assert.Equal(root.Fields.RefStruct.C[1], Helpers.TestProgressiveFieldLoad(3, true, @ref, r => r.__flatsharp__C_1)); - Assert.Equal(root.Fields.RefStruct.D[0], Helpers.TestProgressiveFieldLoad(4, true, @ref, r => r.__flatsharp__D_0)); - Assert.Equal(root.Fields.RefStruct.D[1], Helpers.TestProgressiveFieldLoad(5, true, @ref, r => r.__flatsharp__D_1)); + Assert.AreEqual(root.Fields.RefStruct.A, Helpers.TestProgressiveFieldLoad(0, true, @ref, r => r.A)); + Assert.AreEqual(root.Fields.RefStruct.B, Helpers.TestProgressiveFieldLoad(1, true, @ref, r => r.B)); + Assert.AreEqual(root.Fields.RefStruct.C[0], Helpers.TestProgressiveFieldLoad(2, true, @ref, r => r.__flatsharp__C_0)); + Assert.AreEqual(root.Fields.RefStruct.C[1], Helpers.TestProgressiveFieldLoad(3, true, @ref, r => r.__flatsharp__C_1)); + Assert.AreEqual(root.Fields.RefStruct.D[0], Helpers.TestProgressiveFieldLoad(4, true, @ref, r => r.__flatsharp__D_0)); + Assert.AreEqual(root.Fields.RefStruct.D[1], Helpers.TestProgressiveFieldLoad(5, true, @ref, r => r.__flatsharp__D_1)); Helpers.TestProgressiveFieldLoad(6, true, @ref, r => r.E); } } diff --git a/src/Tests/Stryker/Tests/StrykerTests.csproj b/src/Tests/Stryker/Tests/StrykerTests.csproj index 2ceb2fd8..619dbd19 100644 --- a/src/Tests/Stryker/Tests/StrykerTests.csproj +++ b/src/Tests/Stryker/Tests/StrykerTests.csproj @@ -18,13 +18,8 @@ - - - - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - + + diff --git a/src/Tests/Stryker/Tests/TableVectorTests.cs b/src/Tests/Stryker/Tests/TableVectorTests.cs index 613b47a1..4ff81dde 100644 --- a/src/Tests/Stryker/Tests/TableVectorTests.cs +++ b/src/Tests/Stryker/Tests/TableVectorTests.cs @@ -5,63 +5,64 @@ namespace FlatSharpStrykerTests; +[TestClass] public class TableVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); IList vector = vectors.Table; IList expected = root.Vectors.Table; - Assert.Equal(expected.Count, vector.Count); + Assert.AreEqual(expected.Count, vector.Count); for (int i = 0; i < expected.Count; ++i) { var item = vector[i]; var e = expected[i]; - Assert.Equal(e.Name, item.Name); - Assert.Equal(e.Value, item.Value); + Assert.AreEqual(e.Name, item.Name); + Assert.AreEqual(e.Value, item.Value); } Helpers.AssertSequenceEqual(expectedData, buffer); Helpers.ValidateListVector(option, false, vector, new Key { Name = "johnny" }); }); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Missing(FlatBufferDeserializationOption option) { Root root = CreateRoot_Missing(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); - Assert.Null(vectors.Table); + Assert.IsNull(vectors.Table); Helpers.AssertSequenceEqual(expectedData, buffer); } - [Fact] + [TestMethod] public void WithNull() => Helpers.Repeat(() => { - var ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], CreateRoot_WithNullItem())); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + var ex = Assert.ThrowsException(() => Root.Serializer.Write(new byte[1024], CreateRoot_WithNullItem())); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); - ex = Assert.Throws(() => Root.Serializer.GetMaxSize(CreateRoot_WithNullItem())); - Assert.Equal("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); + ex = Assert.ThrowsException(() => Root.Serializer.GetMaxSize(CreateRoot_WithNullItem())); + Assert.AreEqual("FlatSharp encountered a null reference in an invalid context, such as a vector. Vectors are not permitted to have null objects.", ex.Message); }); - [Fact] + [TestMethod] public void ProgressiveSingleRead() => Helpers.Repeat(() => { Root root = new() { Vectors = new() { Table = new[] { new Key() { Name = "foo", Value = Fruit.Strawberry } } } }; @@ -69,13 +70,13 @@ public void ProgressiveSingleRead() => Helpers.Repeat(() => Key item = parsed.Vectors.Table[0]; - Assert.Equal("foo", item.Name); - Assert.Same(item.Name, item.Name); - Assert.Equal(Fruit.Strawberry, item.Value); + Assert.AreEqual("foo", item.Name); + Assert.AreSame(item.Name, item.Name); + Assert.AreEqual(Fruit.Strawberry, item.Value); buffer.AsSpan().Clear(); - Assert.Equal(Fruit.Strawberry, item.Value); + Assert.AreEqual(Fruit.Strawberry, item.Value); }); private Root CreateRoot(out byte[] expectedData) diff --git a/src/Tests/Stryker/Tests/UnionFieldTests.cs b/src/Tests/Stryker/Tests/UnionFieldTests.cs index d4cc29f9..de52224d 100644 --- a/src/Tests/Stryker/Tests/UnionFieldTests.cs +++ b/src/Tests/Stryker/Tests/UnionFieldTests.cs @@ -4,50 +4,51 @@ namespace FlatSharpStrykerTests; +[TestClass] public class UnionFieldTests { - [Fact] + [TestMethod] public void InvalidConstructors() { - Assert.Throws(() => new FunUnion((string)null)); - Assert.Throws(() => new FunUnion((RefStruct)null)); - Assert.Throws(() => new FunUnion((Key)null)); + Assert.ThrowsException(() => new FunUnion((string)null)); + Assert.ThrowsException(() => new FunUnion((RefStruct)null)); + Assert.ThrowsException(() => new FunUnion((Key)null)); } - [Fact] + [TestMethod] public void InvalidGetters() { FunUnion a = new FunUnion(new RefStruct()); - var ex = Assert.Throws(() => a.ValueStruct); - Assert.Equal("The union is not of the requested type.", ex.Message); + var ex = Assert.ThrowsException(() => a.ValueStruct); + Assert.AreEqual("The union is not of the requested type.", ex.Message); - ex = Assert.Throws(() => a.str); - Assert.Equal("The union is not of the requested type.", ex.Message); + ex = Assert.ThrowsException(() => a.str); + Assert.AreEqual("The union is not of the requested type.", ex.Message); - ex = Assert.Throws(() => a.Key); - Assert.Equal("The union is not of the requested type.", ex.Message); + ex = Assert.ThrowsException(() => a.Key); + Assert.AreEqual("The union is not of the requested type.", ex.Message); a = new FunUnion(new ValueStruct()); - ex = Assert.Throws(() => a.RefStruct); - Assert.Equal("The union is not of the requested type.", ex.Message); + ex = Assert.ThrowsException(() => a.RefStruct); + Assert.AreEqual("The union is not of the requested type.", ex.Message); } - [Fact] + [TestMethod] public void ProgressiveClear() { Root parsed = new Root { Fields = new() { Union = new FunUnion("hi") } }.SerializeAndParse(FlatBufferDeserializationOption.Progressive, out byte[] buffer); Fields f = parsed.Fields; - Assert.Equal("hi", f.Union.Value.str); + Assert.AreEqual("hi", f.Union.Value.str); buffer.AsSpan().Clear(); - Assert.Equal("hi", f.Union.Value.str); + Assert.AreEqual("hi", f.Union.Value.str); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void StringMember(FlatBufferDeserializationOption option) { Root root = this.CreateRoot_StringMember(out var expectedData); @@ -56,43 +57,43 @@ public void StringMember(FlatBufferDeserializationOption option) Helpers.AssertSequenceEqual(expectedData, actualData); FunUnion union = parsed.Fields.Union.Value; - Assert.Equal(FunUnion.ItemKind.str, union.Kind); - Assert.Equal(3, union.Discriminator); - Assert.Equal("hello", union.str); - Assert.Equal("hello", union.Item3); - Assert.True(union.TryGet(out string str)); - Assert.Equal("hello", str); + Assert.AreEqual(FunUnion.ItemKind.str, union.Kind); + Assert.AreEqual(3, union.Discriminator); + Assert.AreEqual("hello", union.str); + Assert.AreEqual("hello", union.Item3); + Assert.IsTrue(union.TryGet(out string str)); + Assert.AreEqual("hello", str); Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, new FunUnion(string.Empty), (a, b) => { var av = a.Value; var bv = b.Value; - Assert.Equal(av.Discriminator, bv.Discriminator); - Assert.Equal(av.str, bv.str); + Assert.AreEqual(av.Discriminator, bv.Discriminator); + Assert.AreEqual(av.str, bv.str); }); } - [Fact] + [TestMethod] public void BrokenUnion() { string message = $"Unexpected union discriminator value '0' for Union {typeof(FunUnion).FullName}"; Root root = new() { Fields = new() { Union = new FunUnion() } }; - var ex = Assert.Throws(() => Root.Serializer.GetMaxSize(root)); - Assert.Equal(message, ex.Message); + var ex = Assert.ThrowsException(() => Root.Serializer.GetMaxSize(root)); + Assert.AreEqual(message, ex.Message); - ex = Assert.Throws(() => Root.Serializer.Write(new byte[1024], root)); - Assert.Equal(message, ex.Message); + ex = Assert.ThrowsException(() => Root.Serializer.Write(new byte[1024], root)); + Assert.AreEqual(message, ex.Message); - ex = Assert.Throws(() => new FunUnion().Accept(new Visitor())); - Assert.Equal(message, ex.Message); + ex = Assert.ThrowsException(() => new FunUnion().Accept(new Visitor())); + Assert.AreEqual(message, ex.Message); - ex = Assert.Throws(() => new FunUnion().Match(null!, null!, null!, null!)); - Assert.Equal(message, ex.Message); + ex = Assert.ThrowsException(() => new FunUnion().Match(null!, null!, null!, null!)); + Assert.AreEqual(message, ex.Message); - ex = Assert.Throws(() => new Root(root)); - Assert.Equal(message, ex.Message); + ex = Assert.ThrowsException(() => new Root(root)); + Assert.AreEqual(message, ex.Message); } private struct Visitor : FunUnion.Visitor @@ -103,16 +104,16 @@ private struct Visitor : FunUnion.Visitor public bool Visit(Key item) => true; } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void ValueStructMember(FlatBufferDeserializationOption option) { void VerifyVs(ValueStruct expected, ValueStruct actual) { - Assert.Equal(expected.A, actual.A); - Assert.Equal(expected.B, actual.B); - Assert.Equal(expected.C(0), actual.C(0)); - Assert.Equal(expected.C(1), actual.C(1)); + Assert.AreEqual(expected.A, actual.A); + Assert.AreEqual(expected.B, actual.B); + Assert.AreEqual(expected.C(0), actual.C(0)); + Assert.AreEqual(expected.C(1), actual.C(1)); } Root root = this.CreateRoot_ValueStructMember(out var expectedData); @@ -123,29 +124,29 @@ void VerifyVs(ValueStruct expected, ValueStruct actual) FunUnion sourceUnion = root.Fields.Union.Value; FunUnion union = parsed.Fields.Union.Value; - Assert.Equal(FunUnion.ItemKind.ValueStruct, union.Kind); - Assert.Equal(2, union.Discriminator); + Assert.AreEqual(FunUnion.ItemKind.ValueStruct, union.Kind); + Assert.AreEqual(2, union.Discriminator); VerifyVs(sourceUnion.ValueStruct, union.ValueStruct); VerifyVs(sourceUnion.Item2, union.Item2); - Assert.True(union.TryGet(out ValueStruct test)); + Assert.IsTrue(union.TryGet(out ValueStruct test)); VerifyVs(sourceUnion.Item2, test); Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void RefStructMember(FlatBufferDeserializationOption option) { void VerifyVs(RefStruct expected, RefStruct actual) { - Assert.Equal(expected.A, actual.A); - Assert.Equal(expected.B, actual.B); - Assert.Equal(expected.C[0], actual.C[0]); - Assert.Equal(expected.C[1], actual.C[1]); - Assert.Equal(expected.D[0], actual.D[0]); - Assert.Equal(expected.D[1], actual.D[1]); + Assert.AreEqual(expected.A, actual.A); + Assert.AreEqual(expected.B, actual.B); + Assert.AreEqual(expected.C[0], actual.C[0]); + Assert.AreEqual(expected.C[1], actual.C[1]); + Assert.AreEqual(expected.D[0], actual.D[0]); + Assert.AreEqual(expected.D[1], actual.D[1]); } Root root = this.CreateRoot_RefStructMember(out var expectedData); @@ -156,25 +157,25 @@ void VerifyVs(RefStruct expected, RefStruct actual) FunUnion sourceUnion = root.Fields.Union.Value; FunUnion union = parsed.Fields.Union.Value; - Assert.Equal(FunUnion.ItemKind.RefStruct, union.Kind); - Assert.Equal(1, union.Discriminator); + Assert.AreEqual(FunUnion.ItemKind.RefStruct, union.Kind); + Assert.AreEqual(1, union.Discriminator); VerifyVs(sourceUnion.RefStruct, union.RefStruct); VerifyVs(sourceUnion.Item1, union.Item1); - Assert.True(union.TryGet(out RefStruct test)); + Assert.IsTrue(union.TryGet(out RefStruct test)); VerifyVs(sourceUnion.Item1, test); Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void KeyTableMember(FlatBufferDeserializationOption option) { void VerifyVs(Key expected, Key actual) { - Assert.Equal(expected.Name, actual.Name); - Assert.Equal(expected.Value, actual.Value); + Assert.AreEqual(expected.Name, actual.Name); + Assert.AreEqual(expected.Value, actual.Value); } Root root = this.CreateRoot_KeyMember(out var expectedData); @@ -185,77 +186,77 @@ void VerifyVs(Key expected, Key actual) FunUnion sourceUnion = root.Fields.Union.Value; FunUnion union = parsed.Fields.Union.Value; - Assert.Equal(FunUnion.ItemKind.Key, union.Kind); - Assert.Equal(4, union.Discriminator); + Assert.AreEqual(FunUnion.ItemKind.Key, union.Kind); + Assert.AreEqual(4, union.Discriminator); VerifyVs(sourceUnion.Key, union.Key); VerifyVs(sourceUnion.Item4, union.Item4); - Assert.True(union.TryGet(out Key test)); + Assert.IsTrue(union.TryGet(out Key test)); VerifyVs(sourceUnion.Item4, test); Helpers.AssertMutationWorks(option, test, false, k => k.Name, string.Empty); Helpers.AssertMutationWorks(option, test, false, k => k.Value, Fruit.Apple); Helpers.AssertMutationWorks(option, parsed.Fields, false, f => f.Union, default); - Assert.True(test.IsInitialized); - Assert.True(Key.IsStaticInitialized); + Assert.IsTrue(test.IsInitialized); + Assert.IsTrue(Key.IsStaticInitialized); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void InvalidUnion_NoOffset(FlatBufferDeserializationOption option) { this.Create_InvalidUnion_NoOffset(out byte[] data); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { Root root = Root.Serializer.Parse(data, option); FunUnion union = root.Fields.Union.Value; }); - Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Fields.Union' was only partially included in the buffer.", ex.Message); + Assert.AreEqual("FlatBuffer table property 'FlatSharpStrykerTests.Fields.Union' was only partially included in the buffer.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void InvalidUnion_NoDiscriminator(FlatBufferDeserializationOption option) { this.Create_InvalidUnion_NoDiscriminator(out byte[] data); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { Root root = Root.Serializer.Parse(data, option); FunUnion union = root.Fields.Union.Value; }); - Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Fields.Union' was only partially included in the buffer.", ex.Message); + Assert.AreEqual("FlatBuffer table property 'FlatSharpStrykerTests.Fields.Union' was only partially included in the buffer.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void InvalidUnion_InvalidDiscriminator(FlatBufferDeserializationOption option) { this.Create_InvalidUnion_InvalidDiscriminator(out byte[] data); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { Root root = Root.Serializer.Parse(data, option); FunUnion union = root.Fields.Union.Value; }); - Assert.Equal( + Assert.AreEqual( $"Unexpected union discriminator value '10' for Union {typeof(FunUnion).FullName}", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionNotPresent(FlatBufferDeserializationOption option) { Root source = this.CreateRoot_UnionNotPresent(out byte[] expectedData); Root parsed = source.SerializeAndParse(option, out byte[] buffer); - Assert.Null(parsed.Fields.Union); + Assert.IsNull(parsed.Fields.Union); Helpers.AssertSequenceEqual(expectedData, buffer); } diff --git a/src/Tests/Stryker/Tests/UnionVectorTests.cs b/src/Tests/Stryker/Tests/UnionVectorTests.cs index 5e25cef8..010c6b13 100644 --- a/src/Tests/Stryker/Tests/UnionVectorTests.cs +++ b/src/Tests/Stryker/Tests/UnionVectorTests.cs @@ -5,90 +5,91 @@ namespace FlatSharpStrykerTests; +[TestClass] public class UnionVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionVector(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] buffer); Vectors vectors = parsed.Vectors; - Assert.True(vectors.IsInitialized); - Assert.True(Vectors.IsStaticInitialized); + Assert.IsTrue(vectors.IsInitialized); + Assert.IsTrue(Vectors.IsStaticInitialized); IList sourceUnions = root.Vectors.Union; IList unions = vectors.Union; - Assert.NotNull(unions); - Assert.Equal(sourceUnions.Count, unions.Count); + Assert.IsNotNull(unions); + Assert.AreEqual(sourceUnions.Count, unions.Count); for (int i = 0; i < unions.Count; ++i) { FunUnion left = sourceUnions[i]; FunUnion right = unions[i]; - Assert.Equal(sourceUnions[i].Discriminator, unions[i].Discriminator); - Assert.Equal(sourceUnions[i].Kind, unions[i].Kind); + Assert.AreEqual(sourceUnions[i].Discriminator, unions[i].Discriminator); + Assert.AreEqual(sourceUnions[i].Kind, unions[i].Kind); { object li = left.Accept(new()); object ri = right.Accept(new()); - Assert.IsAssignableFrom(li.GetType(), ri); + Assert.IsInstanceOfType(ri, li.GetType()); li = left.Match(a => a, b => b, c => c, d => d); ri = right.Match(a => a, b => b, c => c, d => d); - Assert.IsAssignableFrom(li.GetType(), ri); + Assert.IsInstanceOfType(ri, li.GetType()); } switch (left.Kind) { case FunUnion.ItemKind.Key: { - Assert.Equal(left.Key.Name, right.Key.Name); - Assert.Equal(left.Item4.Value, right.Item4.Value); + Assert.AreEqual(left.Key.Name, right.Key.Name); + Assert.AreEqual(left.Item4.Value, right.Item4.Value); - Assert.True(left.TryGet(out Key _)); - Assert.True(right.TryGet(out Key _)); - Assert.False(left.TryGet(out RefStruct _)); - Assert.False(right.TryGet(out RefStruct _)); + Assert.IsTrue(left.TryGet(out Key _)); + Assert.IsTrue(right.TryGet(out Key _)); + Assert.IsFalse(left.TryGet(out RefStruct _)); + Assert.IsFalse(right.TryGet(out RefStruct _)); } break; case FunUnion.ItemKind.RefStruct: { - Assert.Equal(left.RefStruct.A, right.RefStruct.A); - Assert.Equal(left.Item1.B, right.Item1.B); - Assert.True(left.TryGet(out RefStruct _)); - Assert.True(right.TryGet(out RefStruct _)); - Assert.False(left.TryGet(out Key _)); - Assert.False(right.TryGet(out Key _)); + Assert.AreEqual(left.RefStruct.A, right.RefStruct.A); + Assert.AreEqual(left.Item1.B, right.Item1.B); + Assert.IsTrue(left.TryGet(out RefStruct _)); + Assert.IsTrue(right.TryGet(out RefStruct _)); + Assert.IsFalse(left.TryGet(out Key _)); + Assert.IsFalse(right.TryGet(out Key _)); } break; case FunUnion.ItemKind.str: { - Assert.Equal(left.str, right.str); - Assert.Equal(left.Item3, right.Item3); - Assert.True(left.TryGet(out string _)); - Assert.True(right.TryGet(out string _)); - Assert.False(left.TryGet(out ValueStruct _)); - Assert.False(right.TryGet(out ValueStruct _)); + Assert.AreEqual(left.str, right.str); + Assert.AreEqual(left.Item3, right.Item3); + Assert.IsTrue(left.TryGet(out string _)); + Assert.IsTrue(right.TryGet(out string _)); + Assert.IsFalse(left.TryGet(out ValueStruct _)); + Assert.IsFalse(right.TryGet(out ValueStruct _)); } break; case FunUnion.ItemKind.ValueStruct: { - Assert.Equal(left.ValueStruct.A, right.ValueStruct.A); - Assert.Equal(left.Item2.B, right.Item2.B); - Assert.True(left.TryGet(out ValueStruct _)); - Assert.True(right.TryGet(out ValueStruct _)); - Assert.False(left.TryGet(out string _)); - Assert.False(right.TryGet(out string _)); + Assert.AreEqual(left.ValueStruct.A, right.ValueStruct.A); + Assert.AreEqual(left.Item2.B, right.Item2.B); + Assert.IsTrue(left.TryGet(out ValueStruct _)); + Assert.IsTrue(right.TryGet(out ValueStruct _)); + Assert.IsFalse(left.TryGet(out string _)); + Assert.IsFalse(right.TryGet(out string _)); } break; } @@ -98,8 +99,8 @@ public void UnionVector(FlatBufferDeserializationOption option) => Helpers.Repea Helpers.ValidateListVector(option, false, unions, new FunUnion("foo")); }); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Big(FlatBufferDeserializationOption option) { const int ChunkSize = 8; // this test needs to exercise some edge scenarios that require knowing the chunk size of the union vectors. @@ -127,100 +128,100 @@ public void Big(FlatBufferDeserializationOption option) Root root = new Root { Vectors = new() { Union = expected } }.SerializeAndParse(option); IList parsed = root.Vectors.Union; - Assert.Equal(expected.Count, parsed.Count); + Assert.AreEqual(expected.Count, parsed.Count); for (int i = 0; i < expected.Count; ++i) { FunUnion e = expected[i]; FunUnion p = parsed[i]; - Assert.Equal(e.Discriminator, p.Discriminator); + Assert.AreEqual(e.Discriminator, p.Discriminator); } } } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionVector_Invalid_MissingOffset(FlatBufferDeserializationOption option) { CreateInvalid_MissingOffset(out byte[] buffer); - Assert.Throws(() => + Assert.ThrowsException(() => { var item = Root.Serializer.Parse(buffer, option); var x = item.Vectors.Union[0]; }); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionVector_Invalid_InvalidDiscriminator(FlatBufferDeserializationOption option) { CreateInvalid_InvalidDiscriminator(out byte[] buffer); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var item = Root.Serializer.Parse(buffer, option); var x = item.Vectors.Union[0]; }); - Assert.Equal( + Assert.AreEqual( $"Unexpected union discriminator value '7' for Union {typeof(FunUnion).FullName}", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionVector_Invalid_MismatchedCounts(FlatBufferDeserializationOption option) { CreateInvalid_MismatchedCounts(out byte[] buffer); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var item = Root.Serializer.Parse(buffer, option); var x = item.Vectors.Union[0]; }); - Assert.Equal("Union vector had mismatched number of discriminators and offsets.", ex.Message); + Assert.AreEqual("Union vector had mismatched number of discriminators and offsets.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionVector_Invalid_NoOffsetVector(FlatBufferDeserializationOption option) { CreateInvalid_NoOffsetVector(out byte[] buffer); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var item = Root.Serializer.Parse(buffer, option); var x = item.Vectors.Union[0]; }); - Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Vectors.Union' was only partially included in the buffer.", ex.Message); + Assert.AreEqual("FlatBuffer table property 'FlatSharpStrykerTests.Vectors.Union' was only partially included in the buffer.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void UnionVector_Invalid_NoDiscriminatorVector(FlatBufferDeserializationOption option) { CreateInvalid_NoOffsetVector(out byte[] buffer); - var ex = Assert.Throws(() => + var ex = Assert.ThrowsException(() => { var item = Root.Serializer.Parse(buffer, option); var x = item.Vectors.Union[0]; }); - Assert.Equal("FlatBuffer table property 'FlatSharpStrykerTests.Vectors.Union' was only partially included in the buffer.", ex.Message); + Assert.AreEqual("FlatBuffer table property 'FlatSharpStrykerTests.Vectors.Union' was only partially included in the buffer.", ex.Message); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void NotPresent(FlatBufferDeserializationOption option) { Root root = new Root() { Vectors = new() }; Root parsed = root.SerializeAndParse(option, out byte[] buffer); - Assert.Null(parsed.Vectors.Union); + Assert.IsNull(parsed.Vectors.Union); } private struct Visitor : FunUnion.Visitor diff --git a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs index 24b8674a..20d7280a 100644 --- a/src/Tests/Stryker/Tests/ValueStructVectorTests.cs +++ b/src/Tests/Stryker/Tests/ValueStructVectorTests.cs @@ -5,31 +5,32 @@ namespace FlatSharpStrykerTests; +[TestClass] public class ValueStructVectorTests { - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = CreateRoot(out byte[] expectedData); Root parsed = root.SerializeAndParse(option, out byte[] actualData); - Assert.NotNull(parsed.Vectors.ValueStruct); + Assert.IsNotNull(parsed.Vectors.ValueStruct); var vsr = root.Vectors.ValueStruct; var vsp = parsed.Vectors.ValueStruct; - Assert.Equal(vsr.Count, vsp.Count); + Assert.AreEqual(vsr.Count, vsp.Count); for (int i = 0; i < vsr.Count; ++i) { var r = vsr[i]; var p = vsp[i]; - Assert.Equal(r.A, p.A); - Assert.Equal(r.B, p.B); - Assert.Equal(r.C(0), p.C(0)); - Assert.Equal(r.C(1), p.C(1)); + Assert.AreEqual(r.A, p.A); + Assert.AreEqual(r.B, p.B); + Assert.AreEqual(r.C(0), p.C(0)); + Assert.AreEqual(r.C(1), p.C(1)); } Helpers.AssertSequenceEqual(expectedData, actualData); @@ -37,8 +38,8 @@ public void Present(FlatBufferDeserializationOption option) => Helpers.Repeat(() Helpers.ValidateListVector(option, true, vsp, new ValueStruct()); }); - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void WriteThroughDisabled(FlatBufferDeserializationOption option) { if (option == FlatBufferDeserializationOption.Greedy) @@ -55,26 +56,26 @@ public void WriteThroughDisabled(FlatBufferDeserializationOption option) FieldInfo field = list.GetType().GetField("fieldContext", BindingFlags.NonPublic | BindingFlags.Instance); TableFieldContext context = (TableFieldContext)field.GetValue(list); - Assert.True(context.WriteThrough); + Assert.IsTrue(context.WriteThrough); context = new TableFieldContext(context.FullName, context.SharedString, writeThrough: false); field.SetValue(list, context); Helpers.ValidateListVector(option, false, list, new ValueStruct()); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Missing(FlatBufferDeserializationOption option) { Root root = CreateRoot_Missing(out byte[] expectedData); root.SerializeAndParse(option, out byte[] actualData); - Assert.Null(root.Vectors.ValueStruct); + Assert.IsNull(root.Vectors.ValueStruct); Helpers.AssertSequenceEqual(expectedData, actualData); } - [Theory] - [ClassData(typeof(DeserializationOptionClassData))] + [TestMethod] + [DynamicData(nameof(DynamicDataHelper.DeserializationModes), typeof(DynamicDataHelper))] public void Big(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = new Root { Vectors = new() { ValueStruct = new List() } }; @@ -89,35 +90,35 @@ public void Big(FlatBufferDeserializationOption option) => Helpers.Repeat(() => for (int i = 0; i < 1000; ++i) { - Assert.Equal(root.Vectors.ValueStruct[i].A, parsedList[i].A); + Assert.AreEqual(root.Vectors.ValueStruct[i].A, parsedList[i].A); } }); - [Theory] - [InlineData(FlatBufferDeserializationOption.Lazy)] - [InlineData(FlatBufferDeserializationOption.Progressive)] + [TestMethod] + [DataRow(FlatBufferDeserializationOption.Lazy)] + [DataRow(FlatBufferDeserializationOption.Progressive)] public void WriteThroughValidation(FlatBufferDeserializationOption option) => Helpers.Repeat(() => { Root root = new Root { Vectors = new() { ValueStruct = new List { new ValueStruct { A = 1 }, new ValueStruct { A = 2 } } } }; Root parsed1 = root.SerializeAndParse(option, out byte[] rawData); - Assert.Equal(1, parsed1.Vectors.ValueStruct[0].A); - Assert.Equal(2, parsed1.Vectors.ValueStruct[1].A); + Assert.AreEqual(1, parsed1.Vectors.ValueStruct[0].A); + Assert.AreEqual(2, parsed1.Vectors.ValueStruct[1].A); parsed1.Vectors.ValueStruct[0] = new() { A = 5 }; parsed1.Vectors.ValueStruct[1] = new() { A = 10 }; - Assert.Throws(() => parsed1.Vectors.ValueStruct[-1] = default); + Assert.ThrowsException(() => parsed1.Vectors.ValueStruct[-1] = default); - Assert.Equal(5, parsed1.Vectors.ValueStruct[0].A); - Assert.Equal(10, parsed1.Vectors.ValueStruct[1].A); + Assert.AreEqual(5, parsed1.Vectors.ValueStruct[0].A); + Assert.AreEqual(10, parsed1.Vectors.ValueStruct[1].A); Root parsed2 = Root.Serializer.Parse(rawData, option); - Assert.Equal(5, parsed2.Vectors.ValueStruct[0].A); - Assert.Equal(10, parsed2.Vectors.ValueStruct[1].A); + Assert.AreEqual(5, parsed2.Vectors.ValueStruct[0].A); + Assert.AreEqual(10, parsed2.Vectors.ValueStruct[1].A); }); - [Fact] + [TestMethod] public void ProgressiveClear() { Root root = new Root { Vectors = new() { ValueStruct = new[] { new ValueStruct { A = 1, B = 2 } } } }; @@ -127,15 +128,15 @@ public void ProgressiveClear() var vectors = parsed.Vectors.ValueStruct; // Load item 0 into memory. - Assert.Equal(1, vectors[0].A); - Assert.Equal(2, vectors[0].B); + Assert.AreEqual(1, vectors[0].A); + Assert.AreEqual(2, vectors[0].B); // Clear the span. buffer.AsSpan().Clear(); // Verify item 0 is still cached. - Assert.Equal(1, vectors[0].A); - Assert.Equal(2, vectors[0].B); + Assert.AreEqual(1, vectors[0].A); + Assert.AreEqual(2, vectors[0].B); } private Root CreateRoot(out byte[] expectedData)