Tests and docs

Author: eglauko

RoyalCode.SmartValidations.Tests/BuildInPredicatesTests.MinMax.cs

@@ -96,6 +96,84 @@ public void Comparable_Nulls_Max(int? value, int max, bool expected)
         Assert.Equal(expected, result);
     }
 
+    [Theory]
+    [MemberData(nameof(Comparable_MinMax_Data))]
+    public void Comparable_MinMax<T>(T value, T min, T max, bool expected)
+        where T : IComparable<T>
+    {
+        // Arrange
+        // Act
+        var result = BuildInPredicates.MinMax(value, min, max);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [MemberData(nameof(Comparable_MinMax_Data))]
+    [InlineData(null, 0, 0, false)]
+    [InlineData(null, 0, 1, false)]
+    [InlineData(null, 1, 3, false)]
+    public void Comparable_Nulls_MinMax(int? value, int min, int max, bool expected)
+    {
+        // Arrange
+        // Act
+        var result = BuildInPredicates.MinMax(value, min, max);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(null, 0, false)]
+    [InlineData("", 0, true)]
+    [InlineData("a", 0, true)]
+    [InlineData("", 1, false)]
+    [InlineData("a", 1, true)]
+    [InlineData("ab", 1, true)]
+    public void String_MinLength(string? value, int minLength, bool expected)
+    {
+        // Arrange
+        // Act
+        var result = BuildInPredicates.MinLength(value, minLength);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(null, 0, true)]
+    [InlineData("", 0, true)]
+    [InlineData("a", 0, false)]
+    [InlineData("", 1, true)]
+    [InlineData("a", 1, true)]
+    [InlineData("ab", 1, false)]
+    public void String_MaxLength(string? value, int maxLength, bool expected)
+    {
+        // Arrange
+        // Act
+        var result = BuildInPredicates.MaxLength(value, maxLength);
+        // Assert
+        Assert.Equal(expected, result);
+    }
+
+    [Theory]
+    [InlineData(null, 0, 0, false)]
+    [InlineData(null, 0, 1, false)]
+    [InlineData("", 0, 0, true)]
+    [InlineData("", 0, 1, true)]
+    [InlineData("a", 0, 0, false)]
+    [InlineData("a", 0, 1, true)]
+    [InlineData("ab", 0, 1, false)]
+    public void String_Length(string? value, int minLength, int maxLength, bool expected)
+    {
+        // Arrange
+        // Act
+        var result = BuildInPredicates.Length(value, minLength, maxLength);
+
+        // Assert
+        Assert.Equal(expected, result);
+    }
 
     public static IEnumerable<object[]> Nullable_Comparable_Data()
     {
@@ -165,4 +243,13 @@ public static IEnumerable<object[]> Comparable_Data()
         yield return [BigInteger.One, BigInteger.One, 0];
         yield return [new BigInteger(2), BigInteger.One, 1];
     }
+
+    public static IEnumerable<object[]> Comparable_MinMax_Data()
+    {
+        yield return [0, 1, 3, false];
+        yield return [1, 1, 3, true];
+        yield return [2, 1, 3, true];
+        yield return [3, 1, 3, true];
+        yield return [4, 1, 3, false];
+    }
 }

RoyalCode.SmartValidations/BuildInPredicates.cs

@@ -456,34 +456,69 @@ public static bool Max<T>(T? value, T max) where T : struct, IComparable<T>
         return value.HasValue && value.Value.CompareTo(max) <= 0;
     }
 
+    /// <summary>
+    /// Validates whether the specified value is within the specified range (inclusive).
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="value">The value to validate.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <returns>True if the value is within the specified range (inclusive), otherwise false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool MinMax<T>(T value, T min, T max) where T: IComparable<T>
     {
         return value.CompareTo(min) >= 0 && value.CompareTo(max) <= 0;
     }
 
+    /// <summary>
+    /// Validates whether the specified value is within the specified range (inclusive).
+    /// </summary>
+    /// <typeparam name="T">The value type.</typeparam>
+    /// <param name="value">The value to validate.</param>
+    /// <param name="min">The minimum value.</param>
+    /// <param name="max">The maximum value.</param>
+    /// <returns>True if the value is within the specified range (inclusive), otherwise false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool MinMax<T>(T? value, T min, T max) where T : struct, IComparable<T>
     {
         return value.HasValue && value.Value.CompareTo(min) >= 0 && value.Value.CompareTo(max) <= 0;
     }
 
+    /// <summary>
+    /// Validates whether the specified string value has a minimum length.
+    /// </summary>
+    /// <param name="value">The string value to validate.</param>
+    /// <param name="length">The minimum length.</param>
+    /// <returns>True if the string value has a minimum length, otherwise false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool MinLength(string? value, int length)
     {
-        return value?.Length >= length;
+        return value is not null && value.Length >= length;
     }
-    
+
+    /// <summary>
+    /// Validates whether the specified string value has a maximum length.
+    /// </summary>
+    /// <param name="value">The string value to validate.</param>
+    /// <param name="length">The maximum length.</param>
+    /// <returns>True if the string value has a maximum length, otherwise false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool MaxLength(string? value, int length)
     {
-        return value?.Length <= length;
+        return value is null || value.Length <= length;
     }
-    
+
+    /// <summary>
+    /// Validates whether the specified string value has a length within the specified range (inclusive).
+    /// </summary>
+    /// <param name="value">The string value to validate.</param>
+    /// <param name="min">The minimum length.</param>
+    /// <param name="max">The maximum length.</param>
+    /// <returns>True if the string value has a length within the specified range (inclusive), otherwise false.</returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static bool Length(string? value, int min, int max)
     {
-        return value?.Length >= min && value.Length <= max;
+        return value is not null && value.Length >= min && value.Length <= max;
     }
 
     #endregion