Modernize into 0.4.3

Author: Rekkonnect

.editorconfig

@@ -1,3 +1,17 @@
-[*.cs]
+root = true
+
+[*.cs]
 spelling_languages = en-us
 spelling_exclusion_path = exclusion.dic
+
+# CS1591: Missing XML comment for publicly visible type or member
+dotnet_diagnostic.CS1591.severity = silent
+
+# CS1573: Parameter has no matching param tag in the XML comment (but other parameters do)
+dotnet_diagnostic.CS1573.severity = silent
+
+# IDE0028: Collection initialization can be simplified
+dotnet_diagnostic.IDE0028.severity = silent
+
+# IDE0305: Collection initialization can be simplified
+dotnet_diagnostic.IDE0305.severity = silent

FrameworkCapabilities.Generated.props

@@ -16,6 +16,7 @@
       HAS_SPAN;
       HAS_SLICES;
       HAS_HASH_CODE;
+      HAS_MATHF;
       HAS_INTERFACE_DIMS;
       HAS_ASYNC_ENUMERABLE;
       HAS_NULLABLE_ANNOTATION_ATTRIBUTES;
@@ -32,10 +33,22 @@
       HAS_STRING_JOIN_CHAR;
       HAS_KVP_DECONSTRUCT;
       HAS_CONCURRENT_BAG_CLEAR;
+      HAS_ASYNC_FILE_IO;
+      HAS_DATA_ROW_FIELD_METHOD;
+      HAS_NUMBER_PARSE_SPANSTRING;
     </DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="
+    '$(TargetFramework)' == 'net45' Or
+    '$(TargetFramework)' == 'net472' Or
+    '$(TargetFramework)' == 'net46' Or
+    '$(TargetFramework)' == 'net48' Or
+    '$(TargetFramework)' == 'netstandard1.0' Or
+    '$(TargetFramework)' == 'netstandard2.0' Or
     '$(TargetFramework)' == 'netstandard2.1' Or
+    '$(TargetFramework)' == 'netcoreapp1.0' Or
+    '$(TargetFramework)' == 'netcoreapp2.0' Or
+    '$(TargetFramework)' == 'netcoreapp3.0' Or
     '$(TargetFramework)' == 'netcoreapp3.1' Or
     '$(TargetFramework)' == 'net5.0'">
     <DefineConstants>
@@ -56,10 +69,15 @@
       HAS_IMMUTABLE;
       HAS_CALLER_INFORMATION_ATTRIBUTES;
       HAS_INTRINSICS;
+      HAS_UNSAFE;
       HAS_SIMD;
+      HAS_BIT_OPERATIONS;
+      HAS_CHANNELS;
       HAS_GET_CHUNKS;
       HAS_AVX;
       HAS_DYNAMIC_INVOCATION;
+      HAS_MATH_LOG2;
+      HAS_MATH_ILOGB;
     </DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="
@@ -110,6 +128,15 @@
       HAS_STATIC_ABSTRACTS;
     </DefineConstants>
   </PropertyGroup>
+  <PropertyGroup Condition="
+    '$(TargetFramework)' == 'net9.0' Or
+    '$(TargetFramework)' == 'net10.0'">
+    <DefineConstants>
+      $(DefineConstants)
+      HAS_INTERLOCKED_COMPARE_EXCHANGE_UNCONSTRAINED;
+      HAS_SPAN_BASED_FILE_IO;
+    </DefineConstants>
+  </PropertyGroup>
   <PropertyGroup Condition="
     '$(TargetFramework)' == 'net10.0'">
     <DefineConstants>

Garyon.FrameworkCapabilityGenerator/FrameworkCapabilities/KnownFrameworkCapabilities.cs

@@ -4,6 +4,11 @@ namespace Garyon.FrameworkCapabilityGenerator.FrameworkCapabilities;
 
 internal static class KnownFrameworkCapabilities
 {
+    // As polyfills were introduced, some of these capabilities are not being evaluated
+    // to conditionally define helpful extensions, extending them to more versions than
+    // the official framework versions support.
+    // They are defined here for reference and documentation purposes.
+
     public static IReadOnlyList<FrameworkCapabilityRange> Capabilities =>
         [
             new(
@@ -14,6 +19,7 @@ internal static class KnownFrameworkCapabilities
                     "HAS_SPAN",
                     "HAS_SLICES",
                     "HAS_HASH_CODE",
+                    "HAS_MATHF",
                     "HAS_INTERFACE_DIMS",
                     "HAS_ASYNC_ENUMERABLE",
                     "HAS_NULLABLE_ANNOTATION_ATTRIBUTES",
@@ -30,11 +36,14 @@ internal static class KnownFrameworkCapabilities
                     "HAS_STRING_JOIN_CHAR",
                     "HAS_KVP_DECONSTRUCT",
                     "HAS_CONCURRENT_BAG_CLEAR",
+                    "HAS_ASYNC_FILE_IO",
+                    "HAS_DATA_ROW_FIELD_METHOD",
+                    "HAS_NUMBER_PARSE_SPANSTRING",
                 ]),
 
             new(
-                Range(KnownFrameworkVersions.NetStandard21, null)
-                | Range(KnownFrameworkVersions.NetCore31, KnownFrameworkVersions.Net5),
+                Range(null, KnownFrameworkVersions.NetStandard21)
+                | Range(null, KnownFrameworkVersions.Net5),
                 [
                     "REQUIRES_IEQUATABLE_FOR_SPAN_SEQUENCE_EQUALS",
                 ]),
@@ -45,10 +54,15 @@ internal static class KnownFrameworkCapabilities
                     "HAS_IMMUTABLE",
                     "HAS_CALLER_INFORMATION_ATTRIBUTES",
                     "HAS_INTRINSICS",
+                    "HAS_UNSAFE",
                     "HAS_SIMD",
+                    "HAS_BIT_OPERATIONS",
+                    "HAS_CHANNELS",
                     "HAS_GET_CHUNKS",
                     "HAS_AVX",
                     "HAS_DYNAMIC_INVOCATION",
+                    "HAS_MATH_LOG2",
+                    "HAS_MATH_ILOGB",
                 ]),
 
             new(
@@ -84,6 +98,13 @@ internal static class KnownFrameworkCapabilities
                     "HAS_STATIC_ABSTRACTS",
                 ]),
 
+            new(
+                Range(KnownFrameworkVersions.Net9, null),
+                [
+                    "HAS_INTERLOCKED_COMPARE_EXCHANGE_UNCONSTRAINED",
+                    "HAS_SPAN_BASED_FILE_IO",
+                ]),
+
             new(
                 Range(KnownFrameworkVersions.Net10, null),
                 [

Garyon.Tests/DataStructures/BaseSetLinearCollectionTests.cs

@@ -1,82 +1,84 @@
 using Garyon.DataStructures;
 using Garyon.Extensions;
-using NUnit.Framework;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
+using TUnit.Assertions;
+using TUnit.Assertions.Extensions;
+using TUnit.Core;
 
 namespace Garyon.Tests.DataStructures;
 
-[Parallelizable(ParallelScope.Children)]
 public abstract class BaseSetLinearCollectionTests
 {
     protected static readonly int[] SampleNumbers = { 1, 2, 4, 5, 7 };
 
     [Test]
-    public void ContainsTest()
+    public async Task ContainsTest()
     {
         var instance = CreateSampleInstance();
         for (int i = 0; i < 10; i++)
-            Assert.AreEqual(SampleNumbers.Contains(i), instance.Contains(i));
+            await Assert.That(instance.Contains(i)).IsEqualTo(SampleNumbers.Contains(i));
     }
     [Test]
-    public void AddTest()
+    public async Task AddTest()
     {
         var instance = InitializeInstance<int>();
-        Assert.IsTrue(instance.Add(2));
-        Assert.IsFalse(instance.Add(2));
-        Assert.AreEqual(1, instance.Count);
+        await Assert.That(instance.Add(2)).IsTrue();
+        await Assert.That(instance.Add(2)).IsFalse();
+        await Assert.That(instance.Count).IsEqualTo(1);
 
         instance.AddRange(new[] { 1, 2, 2, 2, 4 });
-        Assert.AreEqual(3, instance.Count);
-        Assert.IsTrue(instance.Contains(1));
-        Assert.IsTrue(instance.Contains(4));
+        await Assert.That(instance.Count).IsEqualTo(3);
+        await Assert.That(instance.Contains(1)).IsTrue();
+        await Assert.That(instance.Contains(4)).IsTrue();
     }
     [Test]
-    public void RemoveTest()
+    public async Task RemoveTest()
     {
         var instance = CreateSampleInstance();
 
-        AssertRemove(instance, 0);
-        AssertRemove(instance, 1);
+        await AssertRemove(instance, 0);
+        await AssertRemove(instance, 1);
 
         var removedRange = instance.RemoveRange(instance.Count + 5).ToArray();
-        Assert.AreEqual(SampleNumbers.Length - 2, removedRange.Length);
+        await Assert.That(removedRange.Length).IsEqualTo(SampleNumbers.Length - 2);
 
-        void AssertRemove(BaseSetLinearCollection<int> instance, int index)
+        async Task AssertRemove(BaseSetLinearCollection<int> instance, int index)
         {
             int removed = instance.Remove();
-            Assert.AreEqual(SampleNumbers[ProjectToCollectionIndex(index)], removed);
-            Assert.AreEqual(SampleNumbers.Length - index - 1, instance.Count);
+            await Assert.That(removed).IsEqualTo(SampleNumbers[ProjectToCollectionIndex(index)]);
+            await Assert.That(instance.Count).IsEqualTo(SampleNumbers.Length - index - 1);
         }
     }
     [Test]
-    public void PeekTest()
+    public async Task PeekTest()
     {
         var instance = CreateSampleInstance();
-        Assert.AreEqual(SampleNumbers[ProjectToCollectionIndex(0)], instance.Peek());
+        await Assert.That(instance.Peek()).IsEqualTo(SampleNumbers[ProjectToCollectionIndex(0)]);
     }
     [Test]
-    public void ClearTest()
+    public async Task ClearTest()
     {
         var instance = CreateSampleInstance();
         instance.Clear();
-        Assert.IsTrue(instance.IsEmpty);
-        Assert.AreEqual(0, instance.Count);
+        await Assert.That(instance.IsEmpty).IsTrue();
+        await Assert.That(instance).IsEmpty();
     }
 
     [Test]
-    public void CopyToTest()
+    public async Task CopyToTest()
     {
         var instance = CreateSampleInstance();
         var array = new int[SampleNumbers.Length];
         instance.CopyTo(array, 0);
-        Assert.That(array, Is.EquivalentTo(TransformForExpectedEnumerationOrder(SampleNumbers)));
+        await Assert.That(array).IsEquivalentTo(TransformForExpectedEnumerationOrder(SampleNumbers));
     }
     [Test]
-    public void EnumerationTest()
+    public async Task EnumerationTest()
     {
-        Assert.That(CreateSampleInstance(), Is.EquivalentTo(TransformForExpectedEnumerationOrder(SampleNumbers)));
+        await Assert.That(CreateSampleInstance()).IsEquivalentTo(TransformForExpectedEnumerationOrder(SampleNumbers));
     }
 
     protected abstract Index ProjectToCollectionIndex(Index index);
@@ -90,4 +92,4 @@ private BaseSetLinearCollection<int> CreateSampleInstance()
         instance.AddRange(SampleNumbers);
         return instance;
     }
-}
+}