diff --git a/src/SixLabors.Core/Helpers/DebugGuard.cs b/src/SixLabors.Core/Helpers/DebugGuard.cs
index e836a1bba4..4a2ed9473b 100644
--- a/src/SixLabors.Core/Helpers/DebugGuard.cs
+++ b/src/SixLabors.Core/Helpers/DebugGuard.cs
@@ -174,7 +174,7 @@ namespace SixLabors
         {
             if (target.Length != other.Length)
             {
-                throw new ArgumentException("Span-s must be the same size!", parameterName);
+                throw new ArgumentException("Span-s must be the same size.", parameterName);
             }
         }
 
@@ -194,7 +194,7 @@ namespace SixLabors
         {
             if (target.Length != other.Length)
             {
-                throw new ArgumentException("Span-s must be the same size!", parameterName);
+                throw new ArgumentException("Span-s must be the same size.", parameterName);
             }
         }
 
@@ -214,7 +214,7 @@ namespace SixLabors
         {
             if (target.Length < minSpan.Length)
             {
-                throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}!", parameterName);
+                throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}.", parameterName);
             }
         }
 
@@ -234,7 +234,7 @@ namespace SixLabors
         {
             if (target.Length < minSpan.Length)
             {
-                throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}!", parameterName);
+                throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}.", parameterName);
             }
         }
 
diff --git a/src/SixLabors.Core/Helpers/Guard.cs b/src/SixLabors.Core/Helpers/Guard.cs
index 4a738d8b36..ea92a85c02 100644
--- a/src/SixLabors.Core/Helpers/Guard.cs
+++ b/src/SixLabors.Core/Helpers/Guard.cs
@@ -227,6 +227,24 @@ namespace SixLabors
             }
         }
 
+        /// <summary>
+        /// Verifies, that the `target` span has the length of 'minLength', or longer.
+        /// </summary>
+        /// <typeparam name="T">The element type of the spans</typeparam>
+        /// <param name="value">The target span.</param>
+        /// <param name="minLength">The minimum length.</param>
+        /// <param name="parameterName">The name of the parameter that is to be checked.</param>
+        /// <exception cref="ArgumentException">
+        /// The length of <paramref name="value"/> is less than <paramref name="minLength"/>.
+        /// </exception>
+        public static void MustBeSizedAtLeast<T>(T[] value, int minLength, string parameterName)
+        {
+            if (value.Length < minLength)
+            {
+                throw new ArgumentException($"The size must be at least {minLength}.", parameterName);
+            }
+        }
+
         /// <summary>
         /// Verifies, that the `target` span has the length of 'minLength', or longer.
         /// </summary>
diff --git a/tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs b/tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs
index f8b15f3fd5..e1d8b1f220 100644
--- a/tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs
+++ b/tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs
@@ -43,7 +43,6 @@ namespace SixLabors.Helpers.Tests
             });
         }
 
-
         [Fact]
         public void MustBeLessThan_IsLess_ThrowsNoException()
         {
@@ -163,13 +162,13 @@ namespace SixLabors.Helpers.Tests
         [Theory]
         [InlineData(new int[] { 1, 2 }, 1)]
         [InlineData(new int[] { 1, 2 }, 2)]
-        public void MustBeSizedAtLeast_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
+        public void MustBeSizedAtLeast_Array_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
         {
             DebugGuard.MustBeSizedAtLeast<int>(value, minLength, "myParamName");
         }
 
         [Fact]
-        public void MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        public void MustBeSizedAtLeast_Array_LengthIsLess_ThrowsException()
         {
             var exception = Assert.Throws<ArgumentException>(() =>
             {
@@ -181,7 +180,7 @@ namespace SixLabors.Helpers.Tests
         }
 
         [Fact]
-        public void ReadOnlySpan_MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        public void MustBeSizedAtLeast_ReadOnlySpan_LengthIsLess_ThrowsException()
         {
             var exception = Assert.Throws<ArgumentException>(() =>
             {
@@ -189,11 +188,11 @@ namespace SixLabors.Helpers.Tests
             });
 
             Assert.Equal("myParamName", exception.ParamName);
-            Assert.Contains($"Span-s must be at least of length 3!", exception.Message);
+            Assert.Contains($"Span-s must be at least of length 3.", exception.Message);
         }
 
         [Fact]
-        public void Span_MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        public void MustBeSizedAtLeast_Span_LengthIsLess_ThrowsException()
         {
             var exception = Assert.Throws<ArgumentException>(() =>
             {
@@ -201,12 +200,11 @@ namespace SixLabors.Helpers.Tests
             });
 
             Assert.Equal("myParamName", exception.ParamName);
-            Assert.Contains($"Span-s must be at least of length 3!", exception.Message);
+            Assert.Contains($"Span-s must be at least of length 3.", exception.Message);
         }
 
-
         [Fact]
-        public void ReadOnlySpan_MustBeSameSized_LengthIsLess_ThrowsException()
+        public void MustBeSameSized_ReadOnlySpan_LengthIsLess_ThrowsException()
         {
             var exception = Assert.Throws<ArgumentException>(() =>
             {
@@ -214,11 +212,11 @@ namespace SixLabors.Helpers.Tests
             });
 
             Assert.Equal("myParamName", exception.ParamName);
-            Assert.Contains($"Span-s must be the same size!", exception.Message);
+            Assert.Contains($"Span-s must be the same size.", exception.Message);
         }
 
         [Fact]
-        public void Span_MustBeSameSized_LengthIsLess_ThrowsException()
+        public void MustBeSameSized_Span_LengthIsLess_ThrowsException()
         {
             var exception = Assert.Throws<ArgumentException>(() =>
             {
@@ -226,13 +224,13 @@ namespace SixLabors.Helpers.Tests
             });
 
             Assert.Equal("myParamName", exception.ParamName);
-            Assert.Contains($"Span-s must be the same size!", exception.Message);
+            Assert.Contains($"Span-s must be the same size.", exception.Message);
         }
 
         [Theory]
         [InlineData(2, 2)]
         [InlineData(4, 3)]
-        public void ReadOnlySpan_MustBeSizedAtLeast_DoesNotThowException(int leftSize, int rightSize)
+        public void MustBeSizedAtLeast_ReadOnlySpan_DoesNotThowException(int leftSize, int rightSize)
         {
             DebugGuard.MustBeSizedAtLeast(new ReadOnlySpan<int>(new int[leftSize]), new ReadOnlySpan<int>(new int[rightSize]), "myParamName");
         }
@@ -240,19 +238,19 @@ namespace SixLabors.Helpers.Tests
         [Theory]
         [InlineData(2, 2)]
         [InlineData(4, 3)]
-        public void Span_MustBeSizedAtLeast_DoesNotThowException(int leftSize, int rightSize)
+        public void MustBeSizedAtLeast_Span_DoesNotThowException(int leftSize, int rightSize)
         {
             DebugGuard.MustBeSizedAtLeast(new Span<int>(new int[leftSize]), new Span<int>(new int[rightSize]), "myParamName");
         }
 
         [Fact]
-        public void ReadOnlySpan_MustBeSameSized_LengthIsEqual_DoesNotThrowException()
+        public void MustBeSameSized_ReadOnlySpan_LengthIsEqual_DoesNotThrowException()
         {
             DebugGuard.MustBeSameSized(new ReadOnlySpan<int>(new int[2]), new ReadOnlySpan<int>(new int[2]), "myParamName");
         }
 
         [Fact]
-        public void Span_MustBeSameSized_LengthIsEqual_DoesNotThrowException()
+        public void MustBeSameSized_Span_LengthIsEqual_DoesNotThrowException()
         {
             DebugGuard.MustBeSameSized(new Span<int>(new int[2]), new Span<int>(new int[2]), "myParamName");
         }
diff --git a/tests/SixLabors.Core.Tests/Helpers/GuardTests.cs b/tests/SixLabors.Core.Tests/Helpers/GuardTests.cs
index c91ebbcd6f..b7f859f358 100644
--- a/tests/SixLabors.Core.Tests/Helpers/GuardTests.cs
+++ b/tests/SixLabors.Core.Tests/Helpers/GuardTests.cs
@@ -264,15 +264,31 @@ namespace SixLabors.Helpers.Tests
         }
 
         [Theory]
-        [InlineData(new int[] { 1, 2 }, 1)]
-        [InlineData(new int[] { 1, 2 }, 2)]
-        public void MustBeSizedAtLeast_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
+        [InlineData(2, 1)]
+        [InlineData(2, 2)]
+        public void MustBeSizedAtLeast_Array_LengthIsGreaterOrEqual_ThrowsNoException(int valueLength, int minLength)
+        {
+            Guard.MustBeSizedAtLeast<int>(new int[valueLength], minLength, "myParamName");
+        }
+
+        [Theory]
+        [InlineData(2, 1)]
+        [InlineData(2, 2)]
+        public void MustBeSizedAtLeast_Span_LengthIsGreaterOrEqual_ThrowsNoException(int valueLength, int minLength)
+        {
+            Guard.MustBeSizedAtLeast<int>(new Span<int>(new int[valueLength]), minLength, "myParamName");
+        }
+
+        [Theory]
+        [InlineData(2, 1)]
+        [InlineData(2, 2)]
+        public void MustBeSizedAtLeast_ReadOnlySpan_LengthIsGreaterOrEqual_ThrowsNoException(int valueLength, int minLength)
         {
-            Guard.MustBeSizedAtLeast<int>(value, minLength, "myParamName");
+            Guard.MustBeSizedAtLeast<int>(new ReadOnlySpan<int>(new int[valueLength]), minLength, "myParamName");
         }
 
         [Fact]
-        public void MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        public void MustBeSizedAtLeast_Array_LengthIsLess_ThrowsException()
         {
             var exception = Assert.Throws<ArgumentException>(() =>
             {
@@ -282,5 +298,29 @@ namespace SixLabors.Helpers.Tests
             Assert.Equal("myParamName", exception.ParamName);
             Assert.True(exception.Message.Contains($"The size must be at least 3."));
         }
+
+        [Fact]
+        public void MustBeSizedAtLeast_Span_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                Guard.MustBeSizedAtLeast<int>(new Span<int>(new int[2]), 3, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains($"The size must be at least 3."));
+        }
+
+        [Fact]
+        public void MustBeSizedAtLeast_ReadOnlySpan_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                Guard.MustBeSizedAtLeast<int>(new ReadOnlySpan<int>(new int[2]), 3, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains($"The size must be at least 3."));
+        }
     }
 }