[SL.Core] Add test for DebugGuard

src/SixLabors.Core/Helpers/DebugGuard.cs

@@ -178,6 +178,26 @@ namespace SixLabors
             }
         }
 
+        /// <summary>
+        /// Verifies, that the target span is of same size than the 'other' span.
+        /// </summary>
+        /// <typeparam name="T">The element type of the spans</typeparam>
+        /// <param name="target">The target span.</param>
+        /// <param name="other">The 'other' span to compare 'target' to.</param>
+        /// <param name="parameterName">The name of the parameter that is to be checked.</param>
+        /// <exception cref="ArgumentException">
+        /// <paramref name="target"/> is true
+        /// </exception>
+        [Conditional("DEBUG")]
+        public static void MustBeSameSized<T>(Span<T> target, Span<T> other, string parameterName)
+            where T : struct
+        {
+            if (target.Length != other.Length)
+            {
+                throw new ArgumentException("Span-s must be the same size!", parameterName);
+            }
+        }
+
         /// <summary>
         /// Verifies, that the `target` span has the length of 'minSpan', or longer.
         /// </summary>
@@ -197,5 +217,45 @@ namespace SixLabors
                 throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}!", parameterName);
             }
         }
+
+        /// <summary>
+        /// Verifies, that the `target` span has the length of 'minSpan', or longer.
+        /// </summary>
+        /// <typeparam name="T">The element type of the spans</typeparam>
+        /// <param name="target">The target span.</param>
+        /// <param name="minSpan">The 'minSpan' span to compare 'target' to.</param>
+        /// <param name="parameterName">The name of the parameter that is to be checked.</param>
+        /// <exception cref="ArgumentException">
+        /// <paramref name="target"/> is true
+        /// </exception>
+        [Conditional("DEBUG")]
+        public static void MustBeSizedAtLeast<T>(Span<T> target, Span<T> minSpan, string parameterName)
+            where T : struct
+        {
+            if (target.Length < minSpan.Length)
+            {
+                throw new ArgumentException($"Span-s must be at least of length {minSpan.Length}!", parameterName);
+            }
+        }
+
+        /// <summary>
+        /// Verifies, that the `target` array has declared the length  or longer.
+        /// </summary>
+        /// <typeparam name="T">The element type of the spans</typeparam>
+        /// <param name="target">The target array.</param>
+        /// <param name="minLength">The min length the array must have.</param>
+        /// <param name="parameterName">The name of the parameter that is to be checked.</param>
+        /// <exception cref="ArgumentException">
+        /// <paramref name="target"/> is true
+        /// </exception>
+        [Conditional("DEBUG")]
+        public static void MustBeSizedAtLeast<T>(T[] target, int minLength, string parameterName)
+            where T : struct
+        {
+            if (target.Length < minLength)
+            {
+                throw new ArgumentException($"The size must be at least {minLength}.", parameterName);
+            }
+        }
     }
 }

tests/SixLabors.Core.Tests/Helpers/DebugGuardTests.cs

@@ -0,0 +1,260 @@
+// Copyright (c) Six Labors and contributors.
+// Licensed under the Apache License, Version 2.0.
+
+// tell this file to enable debug conditional method calls, i.e. all the debug guard calls
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using Xunit;
+
+namespace SixLabors.Helpers.Tests
+{
+    public class DebugGuardTests
+    {
+        [Fact]
+        public void AllStaticMethodsOnOnDebugGuardHaveDEBUGConditional()
+        {
+            var methods = typeof(DebugGuard).GetTypeInfo().GetMethods()
+                .Where(x => x.IsStatic);
+
+            foreach (var m in methods)
+            {
+                var attribs = m.GetCustomAttributes<ConditionalAttribute>();
+                Assert.True(attribs.Select(x => x.ConditionString).Contains("DEBUG"), $"Method '{m.Name}' does not have [Conditional(\"DEBUG\")] set.");
+            }
+        }
+
+        [Fact]
+        public void NotNull_TargetNotNull_ThrowsNoException()
+        {
+            DebugGuard.NotNull("test", "myParamName");
+        }
+
+        [Fact]
+        public void NotNull_TargetNull_ThrowsException()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+            {
+                DebugGuard.NotNull(null, "myParamName");
+            });
+        }
+
+
+        [Fact]
+        public void MustBeLessThan_IsLess_ThrowsNoException()
+        {
+            DebugGuard.MustBeLessThan(0, 1, "myParamName");
+        }
+
+        [Theory]
+        [InlineData(2, 1)]
+        [InlineData(1, 1)]
+        public void MustBeLessThan_IsGreaterOrEqual_ThrowsNoException(int value, int max)
+        {
+            var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                DebugGuard.MustBeLessThan(value, max, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains($"Value must be less than {max}."));
+        }
+
+        [Theory]
+        [InlineData(0, 1)]
+        [InlineData(1, 1)]
+        public void MustBeLessThanOrEqualTo_IsLessOrEqual_ThrowsNoException(int value, int max)
+        {
+            DebugGuard.MustBeLessThanOrEqualTo(value, max, "myParamName");
+        }
+
+        [Fact]
+        public void MustBeLessThanOrEqualTo_IsGreater_ThrowsNoException()
+        {
+            var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                DebugGuard.MustBeLessThanOrEqualTo(2, 1, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains($"Value must be less than or equal to 1."));
+        }
+
+        [Fact]
+        public void MustBeGreaterThan_IsGreater_ThrowsNoException()
+        {
+            DebugGuard.MustBeGreaterThan(2, 1, "myParamName");
+        }
+
+        [Theory]
+        [InlineData(1, 2)]
+        [InlineData(1, 1)]
+        public void MustBeGreaterThan_IsLessOrEqual_ThrowsNoException(int value, int min)
+        {
+            var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                DebugGuard.MustBeGreaterThan(value, min, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains($"Value must be greater than {min}."));
+        }
+
+        [Theory]
+        [InlineData(2, 1)]
+        [InlineData(1, 1)]
+        public void MustBeGreaterThanOrEqualTo_IsGreaterOrEqual_ThrowsNoException(int value, int min)
+        {
+            DebugGuard.MustBeGreaterThanOrEqualTo(value, min, "myParamName");
+        }
+
+        [Fact]
+        public void MustBeGreaterThanOrEqualTo_IsLess_ThrowsNoException()
+        {
+            var exception = Assert.Throws<ArgumentOutOfRangeException>(() =>
+            {
+                DebugGuard.MustBeGreaterThanOrEqualTo(1, 2, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains($"Value must be greater than or equal to 2."));
+        }
+
+        [Fact]
+        public void IsTrue_IsTrue_ThrowsNoException()
+        {
+            DebugGuard.IsTrue(true, "myParamName", "myTestMessage");
+        }
+
+        [Fact]
+        public void IsTrue_IsFalse_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.IsTrue(false, "myParamName", "myTestMessage");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains("myTestMessage"));
+        }
+
+        [Fact]
+        public void IsFalse_IsFalse_ThrowsNoException()
+        {
+            DebugGuard.IsFalse(false, "myParamName", "myTestMessage");
+        }
+
+        [Fact]
+        public void IsFalse_IsTrue_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.IsFalse(true, "myParamName", "myTestMessage");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.True(exception.Message.Contains("myTestMessage"));
+        }
+
+        [Theory]
+        [InlineData(new int[] { 1, 2 }, 1)]
+        [InlineData(new int[] { 1, 2 }, 2)]
+        public void MustBeSizedAtLeast_LengthIsGreaterOrEqual_ThrowsNoException(int[] value, int minLength)
+        {
+            DebugGuard.MustBeSizedAtLeast<int>(value, minLength, "myParamName");
+        }
+
+        [Fact]
+        public void MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.MustBeSizedAtLeast<int>(new int[] { 1, 2 }, 3, "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.Contains($"The size must be at least 3.", exception.Message);
+        }
+
+        [Fact]
+        public void ReadOnlySpan_MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.MustBeSizedAtLeast(new ReadOnlySpan<int>(new int[2]), new ReadOnlySpan<int>(new int[3]), "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.Contains($"Span-s must be at least of length 3!", exception.Message);
+        }
+
+        [Fact]
+        public void Span_MustBeSizedAtLeast_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.MustBeSizedAtLeast(new Span<int>(new int[2]), new Span<int>(new int[3]), "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.Contains($"Span-s must be at least of length 3!", exception.Message);
+        }
+
+
+        [Fact]
+        public void ReadOnlySpan_MustBeSameSized_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.MustBeSameSized(new ReadOnlySpan<int>(new int[2]), new ReadOnlySpan<int>(new int[3]), "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.Contains($"Span-s must be the same size!", exception.Message);
+        }
+
+        [Fact]
+        public void Span_MustBeSameSized_LengthIsLess_ThrowsException()
+        {
+            var exception = Assert.Throws<ArgumentException>(() =>
+            {
+                DebugGuard.MustBeSameSized(new Span<int>(new int[2]), new Span<int>(new int[3]), "myParamName");
+            });
+
+            Assert.Equal("myParamName", exception.ParamName);
+            Assert.Contains($"Span-s must be the same size!", exception.Message);
+        }
+
+        [Theory]
+        [InlineData(2, 2)]
+        [InlineData(2, 4)]
+        public void ReadOnlySpan_MustBeSizedAtLeast_DoesNotThowException(int leftSize, int rightSize)
+        {
+            DebugGuard.MustBeSizedAtLeast(new ReadOnlySpan<int>(new int[leftSize]), new ReadOnlySpan<int>(new int[rightSize]), "myParamName");
+        }
+
+        [Theory]
+        [InlineData(2, 2)]
+        [InlineData(2, 4)]
+        public void Span_MustBeSizedAtLeast_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()
+        {
+            DebugGuard.MustBeSameSized(new ReadOnlySpan<int>(new int[2]), new ReadOnlySpan<int>(new int[2]), "myParamName");
+        }
+
+        [Fact]
+        public void Span_MustBeSameSized_LengthIsEqual_DoesNotThrowException()
+        {
+            DebugGuard.MustBeSameSized(new Span<int>(new int[2]), new Span<int>(new int[2]), "myParamName");
+        }
+    }
+}