[Core.Yaml] Add tests to improve coverage

Author: Kryptos-FR

sources/core/Stride.Core.Yaml.Tests/Stride.Core.Yaml.Tests.csproj

@@ -10,6 +10,10 @@
     <StrideBuildTags>LinuxTools;WindowsTools</StrideBuildTags>
   </PropertyGroup>
   <ItemGroup>
+    <PackageReference Include="coverlet.collector">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio">
       <PrivateAssets>all</PrivateAssets>

sources/core/Stride.Core.Yaml.Tests/TestInsertionQueue.cs

@@ -0,0 +1,196 @@
+// Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net)
+// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
+
+using Xunit;
+
+namespace Stride.Core.Yaml.Tests;
+
+public class TestInsertionQueue
+{
+    [Fact]
+    public void TestInsertionQueueInitiallyEmpty()
+    {
+        var queue = new InsertionQueue<int>();
+
+        Assert.Equal(0, queue.Count);
+    }
+
+    [Fact]
+    public void TestInsertionQueueEnqueue()
+    {
+        var queue = new InsertionQueue<int>();
+
+        queue.Enqueue(1);
+        queue.Enqueue(2);
+        queue.Enqueue(3);
+
+        Assert.Equal(3, queue.Count);
+    }
+
+    [Fact]
+    public void TestInsertionQueueDequeue()
+    {
+        var queue = new InsertionQueue<int>();
+        queue.Enqueue(1);
+        queue.Enqueue(2);
+        queue.Enqueue(3);
+
+        Assert.Equal(1, queue.Dequeue());
+        Assert.Equal(2, queue.Count);
+        Assert.Equal(2, queue.Dequeue());
+        Assert.Equal(1, queue.Count);
+        Assert.Equal(3, queue.Dequeue());
+        Assert.Equal(0, queue.Count);
+    }
+
+    [Fact]
+    public void TestInsertionQueueDequeueEmptyThrows()
+    {
+        var queue = new InsertionQueue<int>();
+
+        Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueDequeueAfterEmptyThrows()
+    {
+        var queue = new InsertionQueue<int>();
+        queue.Enqueue(1);
+        queue.Dequeue();
+
+        Assert.Throws<InvalidOperationException>(() => queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueInsertAtBeginning()
+    {
+        var queue = new InsertionQueue<int>();
+        queue.Enqueue(1);
+        queue.Enqueue(3);
+
+        queue.Insert(0, 0);
+
+        Assert.Equal(3, queue.Count);
+        Assert.Equal(0, queue.Dequeue());
+        Assert.Equal(1, queue.Dequeue());
+        Assert.Equal(3, queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueInsertInMiddle()
+    {
+        var queue = new InsertionQueue<int>();
+        queue.Enqueue(1);
+        queue.Enqueue(3);
+
+        queue.Insert(1, 2);
+
+        Assert.Equal(3, queue.Count);
+        Assert.Equal(1, queue.Dequeue());
+        Assert.Equal(2, queue.Dequeue());
+        Assert.Equal(3, queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueInsertAtEnd()
+    {
+        var queue = new InsertionQueue<int>();
+        queue.Enqueue(1);
+        queue.Enqueue(2);
+
+        queue.Insert(2, 3);
+
+        Assert.Equal(3, queue.Count);
+        Assert.Equal(1, queue.Dequeue());
+        Assert.Equal(2, queue.Dequeue());
+        Assert.Equal(3, queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueWithStrings()
+    {
+        var queue = new InsertionQueue<string>();
+        queue.Enqueue("a");
+        queue.Enqueue("b");
+        queue.Enqueue("c");
+
+        Assert.Equal(3, queue.Count);
+        Assert.Equal("a", queue.Dequeue());
+        Assert.Equal("b", queue.Dequeue());
+        Assert.Equal("c", queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueMixedOperations()
+    {
+        var queue = new InsertionQueue<int>();
+
+        queue.Enqueue(1);
+        queue.Enqueue(2);
+        Assert.Equal(1, queue.Dequeue());
+        queue.Enqueue(3);
+        queue.Insert(0, 0);
+
+        Assert.Equal(3, queue.Count);
+        Assert.Equal(0, queue.Dequeue());
+        Assert.Equal(2, queue.Dequeue());
+        Assert.Equal(3, queue.Dequeue());
+    }
+
+    [Fact]
+    public void TestInsertionQueueCountAfterOperations()
+    {
+        var queue = new InsertionQueue<int>();
+
+        Assert.Equal(0, queue.Count);
+        queue.Enqueue(1);
+        Assert.Equal(1, queue.Count);
+        queue.Enqueue(2);
+        Assert.Equal(2, queue.Count);
+        queue.Dequeue();
+        Assert.Equal(1, queue.Count);
+        queue.Insert(0, 0);
+        Assert.Equal(2, queue.Count);
+        queue.Dequeue();
+        Assert.Equal(1, queue.Count);
+        queue.Dequeue();
+        Assert.Equal(0, queue.Count);
+    }
+
+    [Fact]
+    public void TestInsertionQueueWithNullValues()
+    {
+#nullable enable
+        var queue = new InsertionQueue<string?>();
+        queue.Enqueue(null);
+        queue.Enqueue("test");
+        queue.Enqueue(null);
+
+        Assert.Equal(3, queue.Count);
+        Assert.Null(queue.Dequeue());
+        Assert.Equal("test", queue.Dequeue());
+        Assert.Null(queue.Dequeue());
+#nullable disable
+    }
+
+    [Fact]
+    public void TestInsertionQueueLargeNumberOfItems()
+    {
+        var queue = new InsertionQueue<int>();
+        const int count = 1000;
+
+        for (int i = 0; i < count; i++)
+        {
+            queue.Enqueue(i);
+        }
+
+        Assert.Equal(count, queue.Count);
+
+        for (int i = 0; i < count; i++)
+        {
+            Assert.Equal(i, queue.Dequeue());
+        }
+
+        Assert.Equal(0, queue.Count);
+    }
+}

sources/core/Stride.Core.Yaml.Tests/TestMark.cs

@@ -0,0 +1,140 @@
+// Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net)
+// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
+
+using Xunit;
+
+namespace Stride.Core.Yaml.Tests;
+
+public class TestMark
+{
+    [Fact]
+    public void TestMarkDefaultValues()
+    {
+        var mark = new Mark();
+
+        Assert.Equal(0, mark.Index);
+        Assert.Equal(0, mark.Line);
+        Assert.Equal(0, mark.Column);
+    }
+
+    [Fact]
+    public void TestMarkSetProperties()
+    {
+        var mark = new Mark
+        {
+            Index = 10,
+            Line = 5,
+            Column = 3
+        };
+
+        Assert.Equal(10, mark.Index);
+        Assert.Equal(5, mark.Line);
+        Assert.Equal(3, mark.Column);
+    }
+
+    [Fact]
+    public void TestMarkIndexNegativeThrows()
+    {
+        var mark = new Mark();
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => mark.Index = -1);
+    }
+
+    [Fact]
+    public void TestMarkLineNegativeThrows()
+    {
+        var mark = new Mark();
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => mark.Line = -1);
+    }
+
+    [Fact]
+    public void TestMarkColumnNegativeThrows()
+    {
+        var mark = new Mark();
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => mark.Column = -1);
+    }
+
+    [Fact]
+    public void TestMarkZeroValuesAreValid()
+    {
+        var mark = new Mark
+        {
+            Index = 0,
+            Line = 0,
+            Column = 0
+        };
+
+        Assert.Equal(0, mark.Index);
+        Assert.Equal(0, mark.Line);
+        Assert.Equal(0, mark.Column);
+    }
+
+    [Fact]
+    public void TestMarkToString()
+    {
+        var mark = new Mark
+        {
+            Index = 100,
+            Line = 10,
+            Column = 5
+        };
+
+        var result = mark.ToString();
+
+        Assert.Contains("Lin: 10", result);
+        Assert.Contains("Col: 5", result);
+        Assert.Contains("Chr: 100", result);
+    }
+
+    [Fact]
+    public void TestMarkToStringWithZeroValues()
+    {
+        var mark = new Mark();
+
+        var result = mark.ToString();
+
+        Assert.Contains("Lin: 0", result);
+        Assert.Contains("Col: 0", result);
+        Assert.Contains("Chr: 0", result);
+    }
+
+    [Fact]
+    public void TestMarkEmpty()
+    {
+        var empty = Mark.Empty;
+
+        Assert.Equal(0, empty.Index);
+        Assert.Equal(0, empty.Line);
+        Assert.Equal(0, empty.Column);
+    }
+
+    [Fact]
+    public void TestMarkLargeValues()
+    {
+        var mark = new Mark
+        {
+            Index = int.MaxValue,
+            Line = int.MaxValue,
+            Column = int.MaxValue
+        };
+
+        Assert.Equal(int.MaxValue, mark.Index);
+        Assert.Equal(int.MaxValue, mark.Line);
+        Assert.Equal(int.MaxValue, mark.Column);
+    }
+
+    [Fact]
+    public void TestMarkStructValueSemantics()
+    {
+        var mark1 = new Mark { Index = 10, Line = 5, Column = 3 };
+        var mark2 = mark1; // Copy
+
+        mark2.Index = 20;
+
+        // Original should be unchanged (value semantics)
+        Assert.Equal(10, mark1.Index);
+        Assert.Equal(20, mark2.Index);
+    }
+}