From 6d95f6eb088cf9a240addce1725dad4f66cab967 Mon Sep 17 00:00:00 2001
From: KonH <konh@yandex.ru>
Date: Sun, 9 Oct 2022 19:48:22 +0200
Subject: [PATCH] Add NullOrEmpty and NullOrWhiteSpace overloads for
 ReadOnlySpan<char> - #220

Related to https://github.com/ardalis/GuardClauses/issues/220
---
 .../GuardAgainstNullExtensions.cs             | 47 +++++++++++++++++++
 .../GuardAgainstNullOrEmpty.cs                |  7 +++
 .../GuardAgainstNullOrWhiteSpace.cs           |  9 ++++
 3 files changed, 63 insertions(+)

diff --git a/src/GuardClauses/GuardAgainstNullExtensions.cs b/src/GuardClauses/GuardAgainstNullExtensions.cs
index b21617f1..11f34253 100644
--- a/src/GuardClauses/GuardAgainstNullExtensions.cs
+++ b/src/GuardClauses/GuardAgainstNullExtensions.cs
@@ -79,6 +79,29 @@ public static string NullOrEmpty(this IGuardClause guardClause,
             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 string NullOrWhiteSpace(this IGuardClause guardClause,
             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
index 98297c8c..ba9df60f 100644
--- 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
index 609d93f0..99bf4105 100644
--- 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"));
     }