fix: add IsDefault check into MustNotContain for ImmutableArray<T>

feO2x · feO2x · commit f4c6da1cca60 · 2025-07-21T07:59:28.000+02:00
Signed-off-by: Kenny Pflug &lt;kenny.pflug@live.de&gt;
diff --git a/Code/Light.GuardClauses.Tests/CollectionAssertions/MustNotContainTests.cs b/Code/Light.GuardClauses.Tests/CollectionAssertions/MustNotContainTests.cs
@@ -140,4 +140,51 @@ public static void ImmutableArrayCallerArgumentExpression()
         act.Should().Throw<ExistingItemException>()
            .WithParameterName(nameof(array));
     }
+
+    [Fact]
+    public static void ImmutableArrayDefaultInstanceDoesNotContainItem()
+    {
+        var defaultArray = default(ImmutableArray<int>);
+
+        // Default instance should not throw for any item since it cannot contain anything
+        var result = defaultArray.MustNotContain(42);
+
+        result.IsDefault.Should().BeTrue();
+    }
+
+    [Fact]
+    public static void ImmutableArrayDefaultInstanceCustomException()
+    {
+        var defaultArray = default(ImmutableArray<string>);
+
+        // Default instance should not throw even with custom exception factory
+        var result = defaultArray.MustNotContain(
+            "test",
+            (_, _) => new InvalidOperationException("Should not be called")
+        );
+
+        result.IsDefault.Should().BeTrue();
+    }
+
+    [Fact]
+    public static void ImmutableArrayDefaultInstanceCustomMessage()
+    {
+        var defaultArray = default(ImmutableArray<object>);
+
+        // Default instance should not throw even with custom message
+        var result = defaultArray.MustNotContain(new object(), message: "Custom message");
+
+        result.IsDefault.Should().BeTrue();
+    }
+
+    [Fact]
+    public static void ImmutableArrayDefaultInstanceCallerArgumentExpression()
+    {
+        var defaultArray = default(ImmutableArray<char>);
+
+        // Default instance should not throw, so no exception to check parameter name
+        var result = defaultArray.MustNotContain('x');
+
+        result.IsDefault.Should().BeTrue();
+    }
 }
diff --git a/Code/Light.GuardClauses/Check.MustNotContain.cs b/Code/Light.GuardClauses/Check.MustNotContain.cs
@@ -207,6 +207,9 @@ public static string MustNotContain(
     /// <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="ExistingItemException">Thrown when <paramref name="parameter" /> contains <paramref name="item" />.</exception>
+    /// <remarks>
+    /// The default instance of <see cref="ImmutableArray{T}" /> cannot contain any items, so this method will not throw for default instances.
+    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ImmutableArray<T> MustNotContain<T>(
         this ImmutableArray<T> parameter,
@@ -215,7 +218,7 @@ public static ImmutableArray<T> MustNotContain<T>(
         string? message = null
     )
     {
-        if (parameter.Contains(item))
+        if (!parameter.IsDefault && parameter.Contains(item))
         {
             Throw.ExistingItem(parameter, item, parameterName, message);
         }
@@ -230,6 +233,9 @@ public static ImmutableArray<T> MustNotContain<T>(
     /// <param name="item">The item that must not be part of the <see cref="ImmutableArray{T}" />.</param>
     /// <param name="exceptionFactory">The delegate that creates your custom exception. <paramref name="parameter" /> and <paramref name="item" /> are passed to this delegate.</param>
     /// <exception cref="Exception">Your custom exception thrown when <paramref name="parameter" /> contains <paramref name="item" />.</exception>
+    /// <remarks>
+    /// The default instance of <see cref="ImmutableArray{T}" /> cannot contain any items, so this method will not throw for default instances.
+    /// </remarks>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     [ContractAnnotation("exceptionFactory:null => halt")]
     public static ImmutableArray<T> MustNotContain<T>(
@@ -238,7 +244,7 @@ public static ImmutableArray<T> MustNotContain<T>(
         Func<ImmutableArray<T>, T, Exception> exceptionFactory
     )
     {
-        if (parameter.Contains(item))
+        if (!parameter.IsDefault && parameter.Contains(item))
         {
             Throw.CustomException(exceptionFactory, parameter, item);
         }

Original file line number	Diff line number	Diff line change
`@@ -207,6 +207,9 @@ public static string MustNotContain(`
`207`	`207`	`/// <param name="parameterName">The name of the parameter (optional).</param>`
`208`	`208`	`/// <param name="message">The message that will be passed to the resulting exception (optional).</param>`
`209`	`209`	`/// <exception cref="ExistingItemException">Thrown when <paramref name="parameter" /> contains <paramref name="item" />.</exception>`
	`210`	`+ /// <remarks>`
	`211`	`+ /// The default instance of <see cref="ImmutableArray{T}" /> cannot contain any items, so this method will not throw for default instances.`
	`212`	`+ /// </remarks>`
`210`	`213`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`211`	`214`	`public static ImmutableArray<T> MustNotContain<T>(`
`212`	`215`	`this ImmutableArray<T> parameter,`
`@@ -215,7 +218,7 @@ public static ImmutableArray<T> MustNotContain<T>(`
`215`	`218`	`string? message = null`
`216`	`219`	`)`
`217`	`220`	`{`
`218`		`- if (parameter.Contains(item))`
	`221`	`+ if (!parameter.IsDefault && parameter.Contains(item))`
`219`	`222`	`{`
`220`	`223`	`Throw.ExistingItem(parameter, item, parameterName, message);`
`221`	`224`	`}`
`@@ -230,6 +233,9 @@ public static ImmutableArray<T> MustNotContain<T>(`
`230`	`233`	`/// <param name="item">The item that must not be part of the <see cref="ImmutableArray{T}" />.</param>`
`231`	`234`	`/// <param name="exceptionFactory">The delegate that creates your custom exception. <paramref name="parameter" /> and <paramref name="item" /> are passed to this delegate.</param>`
`232`	`235`	`/// <exception cref="Exception">Your custom exception thrown when <paramref name="parameter" /> contains <paramref name="item" />.</exception>`
	`236`	`+ /// <remarks>`
	`237`	`+ /// The default instance of <see cref="ImmutableArray{T}" /> cannot contain any items, so this method will not throw for default instances.`
	`238`	`+ /// </remarks>`
`233`	`239`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`234`	`240`	`[ContractAnnotation("exceptionFactory:null => halt")]`
`235`	`241`	`public static ImmutableArray<T> MustNotContain<T>(`
`@@ -238,7 +244,7 @@ public static ImmutableArray<T> MustNotContain<T>(`
`238`	`244`	`Func<ImmutableArray<T>, T, Exception> exceptionFactory`
`239`	`245`	`)`
`240`	`246`	`{`
`241`		`- if (parameter.Contains(item))`
	`247`	`+ if (!parameter.IsDefault && parameter.Contains(item))`
`242`	`248`	`{`
`243`	`249`	`Throw.CustomException(exceptionFactory, parameter, item);`
`244`	`250`	`}`