fix: MustHaveMaximumLength for ImmutableArray<T> if block is now correct, adjusted default exception message

Signed-off-by: Kenny Pflug <kenny.pflug@live.de>

Author: feO2x

Code/Light.GuardClauses.Tests/CollectionAssertions/MustHaveMaximumLengthTests.cs

@@ -19,7 +19,7 @@ public static void ImmutableArrayMoreItems(int[] items, int length)
 
         var assertion = act.Should().Throw<InvalidCollectionCountException>().Which;
         assertion.Message.Should().Contain(
-            $"{nameof(immutableArray)} must have at most count {length}, but it actually has count {immutableArray.Length}."
+            $"{nameof(immutableArray)} must have at most a length of {length}, but it actually has a length of {immutableArray.Length}."
         );
         assertion.ParamName.Should().BeSameAs(nameof(immutableArray));
     }
@@ -87,4 +87,54 @@ public static void ImmutableArrayCallerArgumentExpression()
         act.Should().Throw<InvalidCollectionCountException>()
            .WithParameterName(nameof(myImmutableArray));
     }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(5)]
+    public static void
+        DefaultImmutableArrayInstanceShouldNotThrowWhenLengthIsGreaterThanOrEqualToZero(int validLength) =>
+        default(ImmutableArray<int>).MustHaveMaximumLength(validLength).IsDefault.Should().BeTrue();
+
+    [Theory]
+    [InlineData(-1)]
+    [InlineData(-5)]
+    [InlineData(-12)]
+    public static void DefaultImmutableArrayInstanceShouldNotThrowWhenLengthIsNegative(int negativeLength)
+    {
+        var act = () => default(ImmutableArray<int>).MustHaveMaximumLength(negativeLength);
+
+        act.Should().Throw<InvalidCollectionCountException>()
+           .WithParameterName("default(ImmutableArray<int>)")
+           .WithMessage(
+                $"default(ImmutableArray<int>) must have at most a length of {negativeLength}, but it actually has no length because it is the default instance.*"
+            );
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(5)]
+    public static void DefaultImmutableArrayInstanceCustomExceptionShouldNotThrow(int validLength)
+    {
+        var result = default(ImmutableArray<int>).MustHaveMaximumLength(validLength, (_, _) => new Exception());
+        result.IsDefault.Should().BeTrue();
+    }
+
+    [Theory]
+    [InlineData(-1)]
+    [InlineData(-5)]
+    [InlineData(-12)]
+    public static void DefaultImmutableArrayInstanceCustomExceptionShouldThrow(int negativeLength)
+    {
+        var act = () => default(ImmutableArray<int>).MustHaveMaximumLength(
+            negativeLength,
+            (array, length) => new ArgumentException(
+                $"Custom: Array length {(array.IsDefault ? 0 : array.Length)} exceeds maximum {length}"
+            )
+        );
+
+        act.Should().Throw<ArgumentException>()
+           .WithMessage("Custom: Array length 0 exceeds maximum *");
+    }
 }

Code/Light.GuardClauses/Check.MustHaveMaximumLength.cs

@@ -16,6 +16,7 @@ public static partial class Check
     /// <param name="parameterName">The name of the parameter (optional).</param>
     /// <param name="message">The message that will be passed to the resulting exception (optional).</param>
     /// <exception cref="InvalidCollectionCountException">Thrown when <paramref name="parameter" /> has more than the specified length.</exception>
+    /// <remarks>The default instance of <see cref="ImmutableArray{T}"/> will be treated as having length 0.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ImmutableArray<T> MustHaveMaximumLength<T>(
         this ImmutableArray<T> parameter,
@@ -24,9 +25,10 @@ public static ImmutableArray<T> MustHaveMaximumLength<T>(
         string? message = null
     )
     {
-        if (parameter.IsDefault && length < 0 || parameter.Length > length)
+        var parameterLength = parameter.IsDefault ? 0 : parameter.Length;
+        if (parameterLength > length)
         {
-            Throw.InvalidMaximumCollectionCount(parameter, length, parameterName, message);
+            Throw.InvalidMaximumImmutableArrayLength(parameter, length, parameterName, message);
         }
 
         return parameter;
@@ -39,14 +41,16 @@ public static ImmutableArray<T> MustHaveMaximumLength<T>(
     /// <param name="length">The maximum length the <see cref="ImmutableArray{T}" /> should have.</param>
     /// <param name="exceptionFactory">The delegate that creates your custom exception. <paramref name="parameter" /> and <paramref name="length" /> are passed to this delegate.</param>
     /// <exception cref="Exception">Your custom exception thrown when <paramref name="parameter" /> has more than the specified length.</exception>
+    /// <remarks>The default instance of <see cref="ImmutableArray{T}"/> will be treated as having length 0.</remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ImmutableArray<T> MustHaveMaximumLength<T>(
         this ImmutableArray<T> parameter,
         int length,
         Func<ImmutableArray<T>, int, Exception> exceptionFactory
     )
     {
-        if (parameter.IsDefault && length < 0 || parameter.Length > length)
+        var parameterLength = parameter.IsDefault ? 0 : parameter.Length;
+        if (parameterLength > length)
         {
             Throw.CustomException(exceptionFactory, parameter, length);
         }

Code/Light.GuardClauses/ExceptionFactory/Throw.InvalidMaximumImmutableArrayLength.cs

@@ -0,0 +1,30 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using JetBrains.Annotations;
+using Light.GuardClauses.Exceptions;
+
+namespace Light.GuardClauses.ExceptionFactory;
+
+public static partial class Throw
+{
+    /// <summary>
+    /// Throws the default <see cref="InvalidCollectionCountException" /> indicating that an <see cref="ImmutableArray{T}" /> has more than a
+    /// maximum number of items, using the optional parameter name and message.
+    /// </summary>
+    [ContractAnnotation("=> halt")]
+    [DoesNotReturn]
+    public static void InvalidMaximumImmutableArrayLength<T>(
+        ImmutableArray<T> parameter,
+        int length,
+        [CallerArgumentExpression("parameter")] string? parameterName = null,
+        string? message = null
+    )
+    {
+        throw new InvalidCollectionCountException(
+            parameterName,
+            message ??
+            $"{parameterName ?? "The immutable array"} must have at most a length of {length}, but it actually {(parameter.IsDefault ? "has no length because it is the default instance" : $"has a length of {parameter.Length}")}."
+        );
+    }
+}