tests

Author: KSemenenko

AGENTS.md

@@ -32,7 +32,7 @@ For any code modification task: run dotnet build before applying changes to capt
 Target `net9.0` with C# 13, `Nullable` and `ImplicitUsings` enabled; favour modern language features when they improve clarity. Stick to four-space indentation, braces on new lines, PascalCase for types, methods, and public properties, camelCase for locals and parameters, and ALL_CAPS only for constants. Keep namespaces aligned with folder paths under `ManagedCode.TimeSeries`.
 
 ## Testing Guidelines
-Use xUnit `[Fact]` and `[Theory]` patterns with FluentAssertions for expectations; prefer descriptive test method names (`MethodUnderTest_State_Expectation`). Ensure new logic includes coverage and leaves no skipped tests behind; if a skip is unavoidable, document the unblocker in-code. Generate fresh coverage via the command above before opening a PR and verify lcov output lands under `ManagedCode.TimeSeries.Tests/`.
+Use xUnit `[Fact]` and `[Theory]` patterns with Shouldly for assertions; prefer descriptive test method names (`MethodUnderTest_State_Expectation`). Ensure new logic includes coverage and leaves no skipped tests behind; if a skip is unavoidable, document the unblocker in-code. Generate fresh coverage via the command above before opening a PR and verify lcov output lands under `ManagedCode.TimeSeries.Tests/`.
 
 ## Commit & Pull Request Guidelines
 Follow the repo’s concise commit style (`scope summary` or short imperative lines under ~60 characters, e.g., `bench improve queue path`). Each PR should describe the change, reference related issues, and call out API or serialization impacts. Include evidence of local `dotnet test` runs (and benchmarks when relevant) plus screenshots for user-facing changes. Highlight breaking changes or version bumps so release automation remains accurate.

Directory.Packages.props

@@ -7,7 +7,7 @@
         <PackageVersion Include="coverlet.collector" Version="6.0.4" />
         <PackageVersion Include="coverlet.msbuild" Version="6.0.4" />
         <PackageVersion Include="DotNet.ReproducibleBuilds" Version="1.2.39" />
-        <PackageVersion Include="FluentAssertions" Version="8.7.1" />
+        <PackageVersion Include="Shouldly" Version="4.2.1" />
         <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="9.0.10" />
         <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
         <PackageVersion Include="Microsoft.Orleans.Sdk" Version="9.2.1" />

ManagedCode.TimeSeries.Orleans/Accumulators/Converters/DoubleTimeSeriesAccumulatorConverter.cs

@@ -1,6 +1,6 @@
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using ManagedCode.TimeSeries.Accumulators;
 using Orleans;
 
@@ -12,18 +12,27 @@ public sealed class DoubleTimeSeriesAccumulatorConverter<T> : IConverter<DoubleT
     public DoubleTimeSeriesAccumulator ConvertFromSurrogate(in TimeSeriesAccumulatorsSurrogate<double> surrogate)
     {
         var series = new DoubleTimeSeriesAccumulator(surrogate.SampleInterval, surrogate.MaxSamplesCount);
-        var converted = surrogate.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => new ConcurrentQueue<double>(kvp.Value));
+        var converted = new Dictionary<DateTimeOffset, ConcurrentQueue<double>>(surrogate.Samples.Count);
+
+        foreach (var pair in surrogate.Samples)
+        {
+            converted[pair.Key] = new ConcurrentQueue<double>(pair.Value);
+        }
+
         series.InitInternal(converted, surrogate.Start, surrogate.End, surrogate.LastDate, surrogate.DataCount);
         return series;
     }
 
     public TimeSeriesAccumulatorsSurrogate<double> ConvertToSurrogate(in DoubleTimeSeriesAccumulator value)
     {
-        var converted = value.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => new Queue<double>(kvp.Value));
+        var samples = value.Samples;
+        var converted = new Dictionary<DateTimeOffset, Queue<double>>(samples.Count);
+
+        foreach (var pair in samples)
+        {
+            converted[pair.Key] = new Queue<double>(pair.Value);
+        }
+
         return new TimeSeriesAccumulatorsSurrogate<double>(converted, value.Start, value.End,
             value.SampleInterval, value.MaxSamplesCount, value.LastDate, value.DataCount);
     }

ManagedCode.TimeSeries.Orleans/Accumulators/Converters/FloatTimeSeriesAccumulatorConverter.cs

@@ -1,6 +1,6 @@
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using ManagedCode.TimeSeries.Accumulators;
 using Orleans;
 
@@ -12,18 +12,27 @@ public sealed class FloatTimeSeriesAccumulatorConverter<T> : IConverter<FloatTim
     public FloatTimeSeriesAccumulator ConvertFromSurrogate(in TimeSeriesAccumulatorsSurrogate<float> surrogate)
     {
         var series = new FloatTimeSeriesAccumulator(surrogate.SampleInterval, surrogate.MaxSamplesCount);
-        var converted = surrogate.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => new ConcurrentQueue<float>(kvp.Value));
+        var converted = new Dictionary<DateTimeOffset, ConcurrentQueue<float>>(surrogate.Samples.Count);
+
+        foreach (var pair in surrogate.Samples)
+        {
+            converted[pair.Key] = new ConcurrentQueue<float>(pair.Value);
+        }
+
         series.InitInternal(converted, surrogate.Start, surrogate.End, surrogate.LastDate, surrogate.DataCount);
         return series;
     }
 
     public TimeSeriesAccumulatorsSurrogate<float> ConvertToSurrogate(in FloatTimeSeriesAccumulator value)
     {
-        var converted = value.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => new Queue<float>(kvp.Value));
+        var samples = value.Samples;
+        var converted = new Dictionary<DateTimeOffset, Queue<float>>(samples.Count);
+
+        foreach (var pair in samples)
+        {
+            converted[pair.Key] = new Queue<float>(pair.Value);
+        }
+
         return new TimeSeriesAccumulatorsSurrogate<float>(converted, value.Start, value.End,
             value.SampleInterval, value.MaxSamplesCount, value.LastDate, value.DataCount);
     }

ManagedCode.TimeSeries.Orleans/Accumulators/Converters/IntTimeSeriesAccumulatorConverter.cs

@@ -1,6 +1,6 @@
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using ManagedCode.TimeSeries.Abstractions;
 using ManagedCode.TimeSeries.Accumulators;
 using ManagedCode.TimeSeries.Summers;
@@ -15,18 +15,27 @@ public sealed class IntTimeSeriesAccumulatorConverter<T> : IConverter<IntTimeSer
     public IntTimeSeriesAccumulator ConvertFromSurrogate(in TimeSeriesAccumulatorsSurrogate<int> surrogate)
     {
         var series = new IntTimeSeriesAccumulator(surrogate.SampleInterval, surrogate.MaxSamplesCount);
-        var converted = surrogate.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => new ConcurrentQueue<int>(kvp.Value));
+        var converted = new Dictionary<DateTimeOffset, ConcurrentQueue<int>>(surrogate.Samples.Count);
+
+        foreach (var pair in surrogate.Samples)
+        {
+            converted[pair.Key] = new ConcurrentQueue<int>(pair.Value);
+        }
+
         series.InitInternal(converted, surrogate.Start, surrogate.End, surrogate.LastDate, surrogate.DataCount);
         return series;
     }
 
     public TimeSeriesAccumulatorsSurrogate<int> ConvertToSurrogate(in IntTimeSeriesAccumulator value)
     {
-        var converted = value.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => new Queue<int>(kvp.Value));
+        var samples = value.Samples;
+        var converted = new Dictionary<DateTimeOffset, Queue<int>>(samples.Count);
+
+        foreach (var pair in samples)
+        {
+            converted[pair.Key] = new Queue<int>(pair.Value);
+        }
+
         return new TimeSeriesAccumulatorsSurrogate<int>(converted, value.Start, value.End,
             value.SampleInterval, value.MaxSamplesCount, value.LastDate, value.DataCount);
     }

ManagedCode.TimeSeries.Orleans/Summers/Converters/DoubleTimeSeriesSummerConverter.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using ManagedCode.TimeSeries.Summers;
 using Orleans;
 
@@ -13,18 +11,27 @@ public sealed class DoubleTimeSeriesSummerConverter<T> : IConverter<DoubleTimeSe
     public DoubleTimeSeriesSummer ConvertFromSurrogate(in TimeSeriesSummerSurrogate<double> surrogate)
     {
         var series = new DoubleTimeSeriesSummer(surrogate.SampleInterval, surrogate.MaxSamplesCount, surrogate.Strategy);
-        var converted = surrogate.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => kvp.Value);
+        var converted = new Dictionary<DateTimeOffset, double>(surrogate.Samples.Count);
+
+        foreach (var pair in surrogate.Samples)
+        {
+            converted[pair.Key] = pair.Value;
+        }
+
         series.InitInternal(converted, surrogate.Start, surrogate.End, surrogate.LastDate, surrogate.DataCount);
         return series;
     }
 
     public TimeSeriesSummerSurrogate<double> ConvertToSurrogate(in DoubleTimeSeriesSummer value)
     {
-        var converted = value.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => kvp.Value);
+        var samples = value.Samples;
+        var converted = new Dictionary<DateTimeOffset, double>(samples.Count);
+
+        foreach (var pair in samples)
+        {
+            converted[pair.Key] = pair.Value;
+        }
+
         return new TimeSeriesSummerSurrogate<double>(converted, value.Start, value.End,
             value.SampleInterval, value.MaxSamplesCount, value.LastDate, value.DataCount, value.Strategy);
     }

ManagedCode.TimeSeries.Orleans/Summers/Converters/FloatTimeSeriesSummerConverter.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using ManagedCode.TimeSeries.Summers;
 using Orleans;
 
@@ -13,18 +11,27 @@ public sealed class FloatTimeSeriesSummerConverter<T> : IConverter<FloatTimeSeri
     public FloatTimeSeriesSummer ConvertFromSurrogate(in TimeSeriesSummerSurrogate<float> surrogate)
     {
         var series = new FloatTimeSeriesSummer(surrogate.SampleInterval, surrogate.MaxSamplesCount, surrogate.Strategy);
-        var converted = surrogate.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => kvp.Value);
+        var converted = new Dictionary<DateTimeOffset, float>(surrogate.Samples.Count);
+
+        foreach (var pair in surrogate.Samples)
+        {
+            converted[pair.Key] = pair.Value;
+        }
+
         series.InitInternal(converted, surrogate.Start, surrogate.End, surrogate.LastDate, surrogate.DataCount);
         return series;
     }
 
     public TimeSeriesSummerSurrogate<float> ConvertToSurrogate(in FloatTimeSeriesSummer value)
     {
-        var converted = value.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => kvp.Value);
+        var samples = value.Samples;
+        var converted = new Dictionary<DateTimeOffset, float>(samples.Count);
+
+        foreach (var pair in samples)
+        {
+            converted[pair.Key] = pair.Value;
+        }
+
         return new TimeSeriesSummerSurrogate<float>(converted, value.Start, value.End,
             value.SampleInterval, value.MaxSamplesCount, value.LastDate, value.DataCount, value.Strategy);
     }

ManagedCode.TimeSeries.Orleans/Summers/Converters/IntTimeSeriesSummerConverter.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Linq;
 using ManagedCode.TimeSeries.Summers;
 using Orleans;
 
@@ -14,18 +12,27 @@ public sealed class IntTimeSeriesSummerConverter<T> : IConverter<IntTimeSeriesSu
     public IntTimeSeriesSummer ConvertFromSurrogate(in TimeSeriesSummerSurrogate<int> surrogate)
     {
         var series = new IntTimeSeriesSummer(surrogate.SampleInterval, surrogate.MaxSamplesCount, surrogate.Strategy);
-        var converted = surrogate.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => kvp.Value);
+        var converted = new Dictionary<DateTimeOffset, int>(surrogate.Samples.Count);
+
+        foreach (var pair in surrogate.Samples)
+        {
+            converted[pair.Key] = pair.Value;
+        }
+
         series.InitInternal(converted, surrogate.Start, surrogate.End, surrogate.LastDate, surrogate.DataCount);
         return series;
     }
 
     public TimeSeriesSummerSurrogate<int> ConvertToSurrogate(in IntTimeSeriesSummer value)
     {
-        var converted = value.Samples.ToDictionary(
-            static kvp => kvp.Key,
-            static kvp => kvp.Value);
+        var samples = value.Samples;
+        var converted = new Dictionary<DateTimeOffset, int>(samples.Count);
+
+        foreach (var pair in samples)
+        {
+            converted[pair.Key] = pair.Value;
+        }
+
         return new TimeSeriesSummerSurrogate<int>(converted, value.Start, value.End,
             value.SampleInterval, value.MaxSamplesCount, value.LastDate, value.DataCount, value.Strategy);
     }