Release 5.25.0

Author: sakno

src/DotNext.IO/DotNext.IO.csproj

@@ -11,7 +11,7 @@
     <Authors>.NET Foundation and Contributors</Authors>
     <Company />
     <Product>.NEXT Family of Libraries</Product>
-    <VersionPrefix>5.24.0</VersionPrefix>
+    <VersionPrefix>5.25.0</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <AssemblyName>DotNext.IO</AssemblyName>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/DotNext.Metaprogramming/DotNext.Metaprogramming.csproj

@@ -8,7 +8,7 @@
     <ImplicitUsings>true</ImplicitUsings>
     <IsAotCompatible>false</IsAotCompatible>
     <Features>nullablePublicOnly</Features>
-    <VersionPrefix>5.24.0</VersionPrefix>
+    <VersionPrefix>5.25.0</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <Authors>.NET Foundation</Authors>
     <Product>.NEXT Family of Libraries</Product>

src/DotNext.Metaprogramming/Runtime/CompilerServices/AsyncStateMachineBuilder.cs

@@ -560,7 +560,7 @@ private static MemberExpression[] CreateStateHolderType(Type returnType, bool us
                 builder.Add(type);
             }
 
-            slots = builder.Build(sm.Build, out _);
+            slots = builder.Build<MemberExpression>(sm.Build, out _);
         }
 
         Debug.Assert(sm.StateMachine is not null);

src/DotNext.Tests/Buffers/BufferWriterSlimTests.cs

@@ -1,7 +1,6 @@
 using System.Collections.Immutable;
 using System.Numerics;
 using System.Text;
-using DotNext.Buffers.Binary;
 using static System.Globalization.CultureInfo;
 
 namespace DotNext.Buffers;

src/DotNext.Tests/DelegateHelpersTests.cs

@@ -21,8 +21,8 @@ public static void ContravarianceTest()
     [Fact]
     public static void ChangeDelegateType()
     {
-        WaitCallback callback = static obj => { };
-        callback += static obj => { };
+        WaitCallback callback = static _ => { };
+        callback += static _ => { };
         var result = callback.ChangeType<SendOrPostCallback>();
         NotNull(result);
         var list1 = callback.GetInvocationList().Select(static d => d.Method);
@@ -603,4 +603,39 @@ public static void HideReturnValue2()
 
         int ChangeValue(int value) => box.Value = value;
     }
+    
+    [Fact]
+    public static void TryInvokeAction()
+    {
+        static MethodInfo GetMethod(int argCount)
+        {
+            const BindingFlags flags = BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly;
+            return Single(typeof(DelegateHelpers).GetMethods(flags),
+                candidate => candidate.Name == nameof(DelegateHelpers.TryInvoke) && candidate.GetParameters().Length == argCount + 1);
+        }
+
+        var successValue = Expression.Empty();
+        var failedValue = Expression.Throw(Expression.New(typeof(ArithmeticException)), typeof(void));
+        for (var argCount = 0; argCount <= 10; argCount++)
+        {
+            var types = new Type[argCount];
+            Array.Fill(types, typeof(string));
+            var actionType = Expression.GetActionType(types);
+            var parameters = new ParameterExpression[argCount];
+            parameters.AsSpan().ForEach(static (ref ParameterExpression p, int _) => p = Expression.Parameter(typeof(string)));
+            //prepare args
+            var args = new object[parameters.LongLength + 1];
+            Array.Fill(args, string.Empty);
+            //find method to test
+            var method = types is [] ? GetMethod(argCount) : GetMethod(argCount).MakeGenericMethod(types);
+            //check success scenario
+            args[0] = Expression.Lambda(actionType, successValue, parameters).Compile();
+            var result = (Exception)method.Invoke(null, args);
+            Null(result);
+            //check failure
+            args[0] = Expression.Lambda(actionType, failedValue, parameters).Compile();
+            result = (Exception)method.Invoke(null, args);
+            IsType<ArithmeticException>(result);
+        }
+    }
 }

src/DotNext.Tests/DotNext.Tests.csproj

@@ -56,8 +56,4 @@
       <Generator></Generator>
     </EmbeddedResource>
   </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Threading\Concurrent\" />
-  </ItemGroup>
 </Project>

src/DotNext.Tests/Net/Cluster/Consensus/Raft/StateMachine/WriteAheadLogTests.cs

@@ -20,7 +20,7 @@ public sealed class WriteAheadLogTests : Test
     [Fact]
     public static async Task LockManager()
     {
-        await using var lockManager = new WriteAheadLog.LockManager(3);
+        await using var lockManager = new WriteAheadLog.LockManager();
         await lockManager.AcquireReadLockAsync();
 
         var readBarrierTask = lockManager.AcquireReadBarrierAsync().AsTask();
@@ -35,7 +35,7 @@ public static async Task StateManipulations()
         IPersistentState state;
         var member = ClusterMemberId.FromEndPoint(new IPEndPoint(IPAddress.IPv6Loopback, 3232));
 
-        var options = new WriteAheadLog.Options()
+        var options = new WriteAheadLog.Options
         {
             Location = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()),
         };

src/DotNext.Tests/Runtime/SoftReferenceTests.cs

@@ -37,12 +37,12 @@ public static void WithOptions()
     {
         var reference = CreateReference();
 
-        for (var i = 0; i < 30; i++)
+        do
         {
-            new object();
+            GC.KeepAlive(new());
             GC.Collect();
             GC.WaitForPendingFinalizers();
-        }
+        } while (reference.As<IOptionMonad<Target>>().HasValue);
 
         Null((Target)reference);
 

src/DotNext.Tests/Threading/AsyncCountdownEventTests.cs

@@ -68,7 +68,17 @@ public static async Task AbortSuspendedCallers()
     {
         using var countdown = new AsyncCountdownEvent(4);
         var task = countdown.WaitAsync().AsTask();
-        countdown.Reset();
+        False(countdown.Reset());
+        await ThrowsAsync<PendingTaskInterruptedException>(Func.Constant(task));
+    }
+    
+    [Fact]
+    public static async Task AbortSuspendedCallersAndSetCounter()
+    {
+        const long initialCount = 4;
+        using var countdown = new AsyncCountdownEvent(initialCount);
+        var task = countdown.WaitAsync().AsTask();
+        False(countdown.Reset(initialCount));
         await ThrowsAsync<PendingTaskInterruptedException>(Func.Constant(task));
     }
 }

src/DotNext.Tests/Threading/AsyncCounterTests.cs

@@ -77,7 +77,7 @@ public static async Task DecrementTwice()
     public static void IncrementWithUpperBound()
     {
         const long maxValue = 2L;
-        using var counter = new AsyncCounter(0);
+        using var counter = new AsyncCounter();
         True(counter.TryIncrement(maxValue));
         True(counter.TryIncrement(maxValue));
         False(counter.TryIncrement(maxValue));