.

Author: SimonCropp

src/Tests/ArgumentExceptions/ArgumentOutOfRangeExceptionTests.cs

@@ -4,6 +4,24 @@ public class ArgumentOutOfRangeExceptionTests
 {
     #region ThrowIfZero Tests
 
+    [Test]
+    public async Task ThrowIfZero_SetsActualValueAndParamName()
+    {
+        ArgumentOutOfRangeException? captured = null;
+        try
+        {
+            ArgumentOutOfRangeException.ThrowIfZero(0, "count");
+        }
+        catch (ArgumentOutOfRangeException exception)
+        {
+            captured = exception;
+        }
+
+        await Assert.That(captured).IsNotNull();
+        await Assert.That(captured!.ActualValue).IsEqualTo((object) 0);
+        await Assert.That(captured.ParamName).IsEqualTo("count");
+    }
+
     [Test]
     public async Task ThrowIfZero_WithZeroInt_ThrowsArgumentOutOfRangeException()
     {

src/Tests/ConvertPolyfillTests.cs

@@ -1,5 +1,38 @@
+using System.Buffers;
+
 public class ConvertPolyfillTests
 {
+    [Test]
+    public async Task FromHexString_ConsumedOnInvalidData()
+    {
+        var destination = new byte[8];
+
+        // A valid leading nibble is counted as consumed; consumed stops at i unless the low nibble is valid.
+        await AssertConsumed("4G", 1); // hi valid, lo invalid
+        await AssertConsumed("G4", 0); // hi invalid, lo valid
+        await AssertConsumed("GG", 1); // both invalid
+        await AssertConsumed("444G", 3); // failure mid-span
+
+        // The UTF-8 byte overload shares the same consumed semantics.
+        var bytesStatus = Convert.FromHexString("4G"u8, destination, out var bytesConsumed, out _);
+        await Assert.That(bytesStatus).IsEqualTo(OperationStatus.InvalidData);
+        await Assert.That(bytesConsumed).IsEqualTo(1);
+
+        // DestinationTooSmall takes priority over InvalidData when the buffer is already full.
+        var smallDestination = new byte[2];
+        var fullStatus = Convert.FromHexString("a1F6CG".AsSpan(), smallDestination, out var fullConsumed, out var fullWritten);
+        await Assert.That(fullStatus).IsEqualTo(OperationStatus.DestinationTooSmall);
+        await Assert.That(fullConsumed).IsEqualTo(4);
+        await Assert.That(fullWritten).IsEqualTo(2);
+
+        async Task AssertConsumed(string source, int expectedConsumed)
+        {
+            var status = Convert.FromHexString(source.AsSpan(), destination, out var consumed, out _);
+            await Assert.That(status).IsEqualTo(OperationStatus.InvalidData);
+            await Assert.That(consumed).IsEqualTo(expectedConsumed);
+        }
+    }
+
     [Test]
     public async Task ToHexString_ValidInput()
     {

src/Tests/EqualityComparerPolyfillTests.cs

@@ -3,6 +3,21 @@
 
 public class EqualityComparerPolyfillTests
 {
+    [Test]
+    public async Task Create_NullDelegates_Throw()
+    {
+        await Assert.That(() => EqualityComparer<int>.Create(null!)).Throws<ArgumentNullException>();
+
+        // The keySelector overload's delegate signature differs in nullability between the
+        // polyfill (Func<T?, TKey?>) and the .NET 11 BCL (Func<T?, TKey>); adapt accordingly.
+#if NET11_0_OR_GREATER
+        Func<string?, int> keySelector = null!;
+#else
+        Func<string?, int?> keySelector = null!;
+#endif
+        await Assert.That(() => EqualityComparer<string>.Create(keySelector)).Throws<ArgumentNullException>();
+    }
+
     [Test]
     public async Task Create_WithEqualsAndGetHashCode()
     {

src/Tests/FilePolyfillTests.cs

@@ -27,6 +27,31 @@ public void TearDown()
         File.Delete(hardLinkFilePath);
     }
 
+    [Test]
+    public async Task GetSetUnixFileMode_SetUser_RoundTrip()
+    {
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            // GetUnixFileMode/SetUnixFileMode are not supported on Windows.
+            return;
+        }
+
+        var path = Path.GetTempFileName();
+        try
+        {
+            File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.SetUser);
+            var mode = File.GetUnixFileMode(path);
+
+            // setuid is octal 4 (SetUser); it must not be read/written as setgid (octal 2).
+            await Assert.That(mode.HasFlag(UnixFileMode.SetUser)).IsTrue();
+            await Assert.That(mode.HasFlag(UnixFileMode.SetGroup)).IsFalse();
+        }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
+
 #if FeatureMemory
     [Test]
     public async Task AppendAllBytes()

src/Tests/Numbers/DoublePolyfillTests.cs

@@ -1,5 +1,17 @@
 public class DoublePolyfillTest
 {
+    [Test]
+    public async Task TryParse_AllowsThousands()
+    {
+        var invariant = CultureInfo.InvariantCulture;
+
+        await Assert.That(double.TryParse("1,234.5", invariant, out var value)).IsTrue();
+        await Assert.That(value).IsEqualTo(1234.5);
+
+        await Assert.That(double.TryParse("1,234.5".AsSpan(), invariant, out var spanValue)).IsTrue();
+        await Assert.That(spanValue).IsEqualTo(1234.5);
+    }
+
     [Test]
     public async Task TryParse()
     {

src/Tests/Numbers/SinglePolyfillTests.cs

@@ -1,5 +1,17 @@
 public class SinglePolyfillTest
 {
+    [Test]
+    public async Task TryParse_AllowsThousands()
+    {
+        var invariant = CultureInfo.InvariantCulture;
+
+        await Assert.That(float.TryParse("1,234.5", invariant, out var value)).IsTrue();
+        await Assert.That(value).IsEqualTo(1234.5f);
+
+        await Assert.That(float.TryParse("1,234.5".AsSpan(), invariant, out var spanValue)).IsTrue();
+        await Assert.That(spanValue).IsEqualTo(1234.5f);
+    }
+
     [Test]
     public async Task TryParse()
     {

src/Tests/PolyfillTests_ArraySegment.cs

@@ -1,6 +1,14 @@
 
 partial class PolyfillTests
 {
+    [Test]
+    public async Task ArraySegment_CopyTo_DefaultDestination_Throws()
+    {
+        var source = new ArraySegment<int>(new[] {1, 2, 3});
+        ArraySegment<int> destination = default;
+        await Assert.That(() => source.CopyTo(destination)).Throws<InvalidOperationException>();
+    }
+
     [Test]
     public async Task CopyTo_ArraySegment_CopiesElements()
     {

src/Tests/PolyfillTests_Compression.cs

@@ -3,6 +3,38 @@
 
 partial class PolyfillTests
 {
+    [Test]
+    public async Task ZipFile_ExtractToDirectory_Overwrite_PreservesExistingFiles()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "polyfill_zip_" + Guid.NewGuid().ToString("N"));
+        var zipPath = Path.Combine(root, "archive.zip");
+        var destination = Path.Combine(root, "dest");
+        Directory.CreateDirectory(root);
+        Directory.CreateDirectory(destination);
+        try
+        {
+            using (var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create))
+            using (var writer = new StreamWriter(archive.CreateEntry("a.txt").Open()))
+            {
+                writer.Write("from-archive");
+            }
+
+            File.WriteAllText(Path.Combine(destination, "preexisting.txt"), "keep-me");
+            File.WriteAllText(Path.Combine(destination, "a.txt"), "old");
+
+            await ZipFile.ExtractToDirectoryAsync(zipPath, destination, overwriteFiles: true);
+
+            // Pre-existing file not in the archive is preserved; archive file is overwritten.
+            await Assert.That(File.Exists(Path.Combine(destination, "preexisting.txt"))).IsTrue();
+            await Assert.That(File.ReadAllText(Path.Combine(destination, "preexisting.txt"))).IsEqualTo("keep-me");
+            await Assert.That(File.ReadAllText(Path.Combine(destination, "a.txt"))).IsEqualTo("from-archive");
+        }
+        finally
+        {
+            Directory.Delete(root, true);
+        }
+    }
+
     [Test]
     public async Task ZipArchiveEntry_Open_WithFileAccess()
     {

src/Tests/PolyfillTests_ConcurrentDictionary.cs

@@ -1,5 +1,17 @@
 partial class PolyfillTests
 {
+    [Test]
+    public async Task ConcurrentDictionary_GetOrAdd_NullFactory_Throws()
+    {
+        var dictionary = new ConcurrentDictionary<string, int>();
+        dictionary.TryAdd("a", 1);
+        Func<string, int, int> factory = null!;
+
+        // Eager validation: throws for both present and absent keys.
+        await Assert.That(() => dictionary.GetOrAdd("a", factory, 5)).Throws<ArgumentNullException>();
+        await Assert.That(() => dictionary.GetOrAdd("b", factory, 5)).Throws<ArgumentNullException>();
+    }
+
     [Test]
     public async Task ConcurrentDictionaryGetOrAddFunc()
     {

src/Tests/PolyfillTests_List.cs

@@ -1,5 +1,26 @@
 partial class PolyfillTests
 {
+    [Test]
+    public async Task List_CopyTo_TooShort_Throws_AndLeavesDestinationUntouched()
+    {
+        var list = new List<int> {10, 20, 30, 40, 50};
+
+        var destination = new int[3];
+        await Assert.That(() => list.CopyTo(new Span<int>(destination))).Throws<ArgumentException>();
+        await Assert.That(destination.All(_ => _ == 0)).IsTrue();
+
+        var ok = new int[5];
+        list.CopyTo(new Span<int>(ok));
+        await Assert.That(string.Join(",", ok)).IsEqualTo("10,20,30,40,50");
+    }
+
+    [Test]
+    public async Task List_InsertRange_InvalidIndex_Throws()
+    {
+        var list = new List<int> {1, 2, 3};
+        await Assert.That(() => list.InsertRange(10, ReadOnlySpan<int>.Empty)).Throws<ArgumentOutOfRangeException>();
+    }
+
     [Test]
     public async Task IListAsReadOnly()
     {