Add NullOrEmpty and NullOrWhiteSpace overloads for ReadOnlySpan<char> -

ardalis#220 Related to ardalis#220
KonH · Oct 9, 2022 · 6d95f6e · 6d95f6e
1 parent 63cd557
commit 6d95f6e
Show file tree

Hide file tree

Showing 3 changed files with 63 additions and 0 deletions.
diff --git a/src/GuardClauses/GuardAgainstNullExtensions.cs b/src/GuardClauses/GuardAgainstNullExtensions.cs
@@ -79,6 +79,29 @@ public static partial class GuardClauseExtensions
             return input;
         }
 
+#if NET5_0_OR_GREATER
+        /// <summary>
+        /// Throws an <see cref="ArgumentException" /> if <paramref name="input" /> is an empty string.
+        /// </summary>
+        /// <param name="guardClause"></param>
+        /// <param name="input"></param>
+        /// <param name="parameterName"></param>
+        /// <param name="message">Optional. Custom error message</param>
+        /// <returns><paramref name="input" /> if the value is not an empty string.</returns>
+        /// <exception cref="ArgumentException"></exception>
+        public static ReadOnlySpan<char> NullOrEmpty(this IGuardClause guardClause,
+            ReadOnlySpan<char> input,
+            string parameterName,
+            string? message = null)
+        {
+            if (input == string.Empty)
+            {
+                throw new ArgumentException(message ?? $"Required input {parameterName} was empty.", parameterName);
+            }
+            return input;
+        }
+#endif
+
         /// <summary>
         /// Throws an <see cref="ArgumentNullException" /> if <paramref name="input" /> is null.
         /// Throws an <see cref="ArgumentException" /> if <paramref name="input" /> is an empty guid.
@@ -175,6 +198,30 @@ public static partial class GuardClauseExtensions
             return input;
         }
 
+#if NET5_0_OR_GREATER
+        /// <summary>
+        /// Throws an <see cref="ArgumentException" /> if <paramref name="input" /> is an empty or white space string.
+        /// </summary>
+        /// <param name="guardClause"></param>
+        /// <param name="input"></param>
+        /// <param name="parameterName"></param>
+        /// <param name="message">Optional. Custom error message</param>
+        /// <returns><paramref name="input" /> if the value is not an empty or whitespace string.</returns>
+        /// <exception cref="ArgumentException"></exception>
+        public static ReadOnlySpan<char> NullOrWhiteSpace(this IGuardClause guardClause,
+            ReadOnlySpan<char> input,
+            string parameterName,
+            string? message = null)
+        {
+            if (input.IsWhiteSpace())
+            {
+                throw new ArgumentException(message ?? $"Required input {parameterName} was empty.", parameterName);
+            }
+
+            return input;
+        }
+#endif
+
         /// <summary>
         /// Throws an <see cref="ArgumentException" /> if <paramref name="input" /> is default for that type.
         /// </summary>

diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrEmpty.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrEmpty.cs
@@ -12,6 +12,7 @@ public class GuardAgainstNullOrEmpty
     public void DoesNothingGivenNonEmptyStringValue()
     {
         Guard.Against.NullOrEmpty("a", "string");
+        Guard.Against.NullOrEmpty("a".AsSpan(), "stringSpan");
         Guard.Against.NullOrEmpty("1", "aNumericString");
     }
 
@@ -41,6 +42,12 @@ public void ThrowsGivenEmptyString()
         Assert.Throws<ArgumentException>(() => Guard.Against.NullOrEmpty("", "emptyString"));
     }
 
+    [Fact]
+    public void ThrowsGivenEmptyStringSpan()
+    {
+        Assert.Throws<ArgumentException>(() => Guard.Against.NullOrEmpty("".AsSpan(), "emptyStringSpan"));
+    }
+
     [Fact]
     public void ThrowsGivenNullGuid()
     {

diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs
@@ -15,6 +15,7 @@ public class GuardAgainstNullOrWhiteSpace
     public void DoesNothingGivenNonEmptyStringValue(string nonEmptyString)
     {
         Guard.Against.NullOrWhiteSpace(nonEmptyString, "string");
+        Guard.Against.NullOrWhiteSpace(nonEmptyString.AsSpan(), "stringSpan");
         Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString");
     }
 
@@ -30,12 +31,19 @@ public void ThrowsGivenEmptyString()
         Assert.Throws<ArgumentException>(() => Guard.Against.NullOrWhiteSpace("", "emptystring"));
     }
 
+    [Fact]
+    public void ThrowsGivenEmptyStringSpan()
+    {
+        Assert.Throws<ArgumentException>(() => Guard.Against.NullOrWhiteSpace("".AsSpan(), "emptyStringSpan"));
+    }
+
     [Theory]
     [InlineData(" ")]
     [InlineData("   ")]
     public void ThrowsGivenWhiteSpaceString(string whiteSpaceString)
     {
         Assert.Throws<ArgumentException>(() => Guard.Against.NullOrWhiteSpace(whiteSpaceString, "whitespacestring"));
+        Assert.Throws<ArgumentException>(() => Guard.Against.NullOrWhiteSpace(whiteSpaceString.AsSpan(), "whiteSpaceStringSpan"));
     }
 
     [Theory]
@@ -47,6 +55,7 @@ public void ThrowsGivenWhiteSpaceString(string whiteSpaceString)
     public void ReturnsExpectedValueGivenNonEmptyStringValue(string nonEmptyString, string expected)
     {
         Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "string"));
+        Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString.AsSpan(), "stringSpan").ToString());
         Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString"));
     }