From a96be57e64614592e742a4e66ddd1fa02416c42f Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 15:18:00 -0700 Subject: [PATCH 01/25] Rename File and Class --- ...parable.cs => GuardAgainstOutOfRangeForStructIComparable.cs} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename test/GuardClauses.UnitTests/{GuardAgainstOutOfRangeForIComparable.cs => GuardAgainstOutOfRangeForStructIComparable.cs} (97%) diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs similarity index 97% rename from test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForIComparable.cs rename to test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs index 0cf2848f..03b743cb 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForIComparable.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs @@ -8,7 +8,7 @@ namespace GuardClauses.UnitTests /// Every type that implements IComparable and IComparable can use OutOfRange. /// Here for example tuples are used. /// - public class GuardAgainstOutOfRangeForIComparable + public class GuardAgainstOutOfRangeForStructIComparable { [Theory] [InlineData(1, 1, 1, 1, 10, 10)] From 71917fca8d6a338ac292a4586690e4a787676bfd Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 15:18:29 -0700 Subject: [PATCH 02/25] Add Tests for Class that Implements IComparable --- ...ardAgainstOutOfRangeForClassIComparable.cs | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs new file mode 100644 index 00000000..3e919d06 --- /dev/null +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs @@ -0,0 +1,82 @@ +using System; +using System.Diagnostics.CodeAnalysis; +using Ardalis.GuardClauses; +using Xunit; + +namespace GuardClauses.UnitTests +{ + /// + /// Every type that implements IComparable and IComparable can use OutOfRange. + /// Here for example tuples are used. + /// + public class GuardAgainstOutOfRangeForClassIComparable + { + private class TestObj : IComparable, IEquatable + { + private readonly int _internalValue; + + public TestObj(int internalValue) + { + _internalValue = internalValue; + } + + public int CompareTo([AllowNull] TestObj? other) => _internalValue.CompareTo(other?._internalValue); + + public bool Equals([AllowNull] TestObj? other) => _internalValue == other?._internalValue; + + public override int GetHashCode() => _internalValue.GetHashCode(); + } + + [Fact] + public void DoesNothingGivenInRangeValue() + { + Guard.Against.NullOrOutOfRange(new TestObj(1), "index", new TestObj(1), new TestObj(1)); + Guard.Against.NullOrOutOfRange(new TestObj(2), "index", new TestObj(1), new TestObj(3)); + Guard.Against.NullOrOutOfRange(new TestObj(3), "index", new TestObj(1), new TestObj(3)); + } + + [Fact] + public void ThrowsGivenOutOfRangeValue() + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(-1), "index", new TestObj(1), new TestObj(3))); + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(0), "index", new TestObj(1), new TestObj(3))); + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(4), "index", new TestObj(1), new TestObj(3))); + } + + [Fact] + public void ThrowsGivenInvalidArgumentValue() + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(-1), "index", new TestObj(3), new TestObj(1))); + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(0), "index", new TestObj(3), new TestObj(1))); + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(4), "index", new TestObj(3), new TestObj(1))); + } + + [Fact] + public void ThrowsGivenInvalidNullArgumentValue() + { +#pragma warning disable CS8634 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint. +#pragma warning disable CS8631 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match constraint type. + + Assert.Throws(() => Guard.Against.NullOrOutOfRange(null, "index", new TestObj(3), new TestObj(1))); + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(0), "index", null, new TestObj(1))); + Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(4), "index", new TestObj(3), null)); + +#pragma warning restore CS8634 +#pragma warning restore CS8631 + } + + //[Theory] + //[InlineData(1, 1, 1, 1)] + //[InlineData(1, 1, 3, 1)] + //[InlineData(2, 1, 3, 2)] + //[InlineData(3, 1, 3, 3)] + [Fact] + public void ReturnsExpectedValueGivenInRangeValue() + { + Assert.Equal(new TestObj(1), Guard.Against.NullOrOutOfRange(new TestObj(1), "index", new TestObj(1), new TestObj(1))); + Assert.Equal(new TestObj(1), Guard.Against.NullOrOutOfRange(new TestObj(1), "index", new TestObj(1), new TestObj(3))); + Assert.Equal(new TestObj(2), Guard.Against.NullOrOutOfRange(new TestObj(2), "index", new TestObj(1), new TestObj(3))); + Assert.Equal(new TestObj(3), Guard.Against.NullOrOutOfRange(new TestObj(3), "index", new TestObj(1), new TestObj(3))); + } + } +} From 165255e843606488c974029e2118f7393ef6e324 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 15:19:41 -0700 Subject: [PATCH 03/25] Bump C# Version to 9, for better Nullable Checks with Generics --- Directory.Build.props | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Directory.Build.props b/Directory.Build.props index f4cdb5c7..fb9d31a6 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -1,7 +1,7 @@ - 8 + 9 enable From 3bb9e776e71eb43179cae41b4372a537efb3e714 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 15:34:58 -0700 Subject: [PATCH 04/25] Add NullOrOutOfRange to Check for Null or OutOfRange for References Types Add Missing JetBrains.Annotations and Other Attribute to OutOfRange methods Add More Documentation to OutOfRange methods --- src/GuardClauses/GuardClauseExtensions.cs | 39 +++++++++++++++++++++-- 1 file changed, 36 insertions(+), 3 deletions(-) diff --git a/src/GuardClauses/GuardClauseExtensions.cs b/src/GuardClauses/GuardClauseExtensions.cs index b8cbf229..40ba32f3 100644 --- a/src/GuardClauses/GuardClauseExtensions.cs +++ b/src/GuardClauses/GuardClauseExtensions.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.ComponentModel; using System.Diagnostics.CodeAnalysis; @@ -6,6 +6,7 @@ using System.Text.RegularExpressions; using JetBrainsNoEnumerationAttribute = JetBrains.Annotations.NoEnumerationAttribute; using JetBrainsNotNullAttribute = JetBrains.Annotations.NotNullAttribute; +using JetBrainsCanBeNullAttribute = JetBrains.Annotations.CanBeNullAttribute; namespace Ardalis.GuardClauses { @@ -157,8 +158,40 @@ public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause gu /// Optional. Custom error message /// if the value is not out of range. /// - public static T OutOfRange(this IGuardClause guardClause, T input, string parameterName, T rangeFrom, T rangeTo, string? message = null) where T : IComparable, IComparable + /// + public static T OutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsNotNull][ValidatedNotNull] T input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : struct, IComparable { + return OutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + } + + /// + /// Throws an if is null. + /// Throws an if is less than or greater than . + /// + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is not not null or out of range. + /// + /// + /// + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : class, IComparable? + { + return OutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + } + + /// + /// + /// + private static T OutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, string? message = null) where T : IComparable? + { + guardClause.Null(input, nameof(input)); + Guard.Against.Null(rangeFrom, nameof(rangeFrom)); + Guard.Against.Null(rangeTo, nameof(rangeTo)); + if (rangeFrom.CompareTo(rangeTo) > 0) { throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}"); @@ -599,7 +632,7 @@ public static T InvalidInput([JetBrainsNotNull] this IGuardClause guardClause /// if any item is not out of range. /// /// - public static IEnumerable OutOfRange(this IGuardClause guardClause, IEnumerable input, string parameterName, T rangeFrom, T rangeTo, string? message = null) where T : IComparable, IComparable + public static IEnumerable OutOfRange([JetBrainsNotNull] this IGuardClause guardClause, IEnumerable input, string parameterName, T rangeFrom, T rangeTo, string? message = null) where T : IComparable, IComparable { if (rangeFrom.CompareTo(rangeTo) > 0) { From 0dd488fee39c7744d3f328c6b8b38d826363143f Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 16:44:41 -0700 Subject: [PATCH 05/25] Fix Test class implementation --- .../GuardAgainstOutOfRangeForClassIComparable.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs index 3e919d06..2ac605ca 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs @@ -11,7 +11,7 @@ namespace GuardClauses.UnitTests /// public class GuardAgainstOutOfRangeForClassIComparable { - private class TestObj : IComparable, IEquatable + private class TestObj : IComparable, IEquatable { private readonly int _internalValue; From 9bafa7d19577632f157d4bc973d0338df9a62e5d Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 16:45:46 -0700 Subject: [PATCH 06/25] Add Support to Nullable for OutOfRange --- src/GuardClauses/GuardClauseExtensions.cs | 25 +++++++++- .../GuardAgainstOutOfRangeForNullableInt.cs | 47 +++++++++++++++++++ 2 files changed, 70 insertions(+), 2 deletions(-) create mode 100644 test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs diff --git a/src/GuardClauses/GuardClauseExtensions.cs b/src/GuardClauses/GuardClauseExtensions.cs index 40ba32f3..53c5ae05 100644 --- a/src/GuardClauses/GuardClauseExtensions.cs +++ b/src/GuardClauses/GuardClauseExtensions.cs @@ -178,11 +178,32 @@ public static T OutOfRange([JetBrainsNotNull] this IGuardClause guardClause, /// /// /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : class, IComparable? + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable? { return OutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } - + + /// + /// Throws an if is null. + /// Throws an if is less than or greater than . + /// + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is not not null or out of range. + /// + /// + /// + public static int NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] int? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] int rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] int rangeTo, string? message = null) + { + guardClause.Null(input, nameof(input)); + + return OutOfRangeInternal(guardClause, (int) input, parameterName, rangeFrom, rangeTo, message); + } + /// /// /// diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs new file mode 100644 index 00000000..c9313999 --- /dev/null +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs @@ -0,0 +1,47 @@ +using Ardalis.GuardClauses; +using System; +using Xunit; + +namespace GuardClauses.UnitTests +{ + public class GuardAgainstOutOfRangeForNullableInt + { + [Theory] + [InlineData(1, 1, 1)] + [InlineData(1, 1, 3)] + [InlineData(2, 1, 3)] + [InlineData(3, 1, 3)] + public void DoesNothingGivenInRangeValue(int? input, int rangeFrom, int rangeTo) + { + Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo); + } + + [Theory] + [InlineData(-1, 1, 3)] + [InlineData(0, 1, 3)] + [InlineData(4, 1, 3)] + public void ThrowsGivenOutOfRangeValue(int? input, int rangeFrom, int rangeTo) + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); + } + + [Theory] + [InlineData(-1, 3, 1)] + [InlineData(0, 3, 1)] + [InlineData(4, 3, 1)] + public void ThrowsGivenInvalidArgumentValue(int? input, int rangeFrom, int rangeTo) + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); + } + + [Theory] + [InlineData(1, 1, 1, 1)] + [InlineData(1, 1, 3, 1)] + [InlineData(2, 1, 3, 2)] + [InlineData(3, 1, 3, 3)] + public void ReturnsExpectedValueGivenInRangeValue(int? input, int rangeFrom, int rangeTo, int expected) + { + Assert.Equal(expected, Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); + } + } +} From 73f1db48b5e7afd18b705fb0f39a2b9860f9489e Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 22:22:16 -0700 Subject: [PATCH 07/25] Better Nullable Implementation for NullOrOutOfRange Rename Internal Method --- src/GuardClauses/GuardClauseExtensions.cs | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/GuardClauses/GuardClauseExtensions.cs b/src/GuardClauses/GuardClauseExtensions.cs index 53c5ae05..79b70324 100644 --- a/src/GuardClauses/GuardClauseExtensions.cs +++ b/src/GuardClauses/GuardClauseExtensions.cs @@ -144,7 +144,7 @@ public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause gu const long sqlMinDateTicks = 552877920000000000; const long sqlMaxDateTicks = 3155378975999970000; - return OutOfRange(guardClause, input, parameterName, new DateTime(sqlMinDateTicks), new DateTime(sqlMaxDateTicks), message); + return NullOrOutOfRangeInternal(guardClause, input, parameterName, new DateTime(sqlMinDateTicks), new DateTime(sqlMaxDateTicks), message); } /// @@ -161,7 +161,7 @@ public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause gu /// public static T OutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsNotNull][ValidatedNotNull] T input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : struct, IComparable { - return OutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } /// @@ -178,9 +178,10 @@ public static T OutOfRange([JetBrainsNotNull] this IGuardClause guardClause, /// /// /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable? + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable { - return OutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + guardClause.Null(input, nameof(input)); + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } /// @@ -197,19 +198,18 @@ public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardCl /// /// /// - public static int NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] int? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] int rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] int rangeTo, string? message = null) + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : struct, IComparable { guardClause.Null(input, nameof(input)); - - return OutOfRangeInternal(guardClause, (int) input, parameterName, rangeFrom, rangeTo, message); + return NullOrOutOfRangeInternal(guardClause, input.Value, parameterName, rangeFrom, rangeTo, message); } /// /// /// - private static T OutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, string? message = null) where T : IComparable? + private static T NullOrOutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, string? message = null) where T : IComparable? { - guardClause.Null(input, nameof(input)); + Guard.Against.Null(input, nameof(input)); Guard.Against.Null(rangeFrom, nameof(rangeFrom)); Guard.Against.Null(rangeTo, nameof(rangeTo)); From 78e42c8085a197a68381ae14f61d02842b62b3da Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 22:36:55 -0700 Subject: [PATCH 08/25] Add NullOrOutOfSQLDateRange Supporting DateTime? was input --- src/GuardClauses/GuardClauseExtensions.cs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/GuardClauses/GuardClauseExtensions.cs b/src/GuardClauses/GuardClauseExtensions.cs index 79b70324..2d57408b 100644 --- a/src/GuardClauses/GuardClauseExtensions.cs +++ b/src/GuardClauses/GuardClauseExtensions.cs @@ -129,6 +129,23 @@ public static string NullOrWhiteSpace([JetBrainsNotNull] this IGuardClause guard return input; } + /// + /// Throws an if is null. + /// Throws an if is not in the range of valid SqlDateTime values. + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is in the range of valid SqlDateTime values. + /// + /// + public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, DateTime? input, [JetBrainsNotNull] string parameterName, string? message = null) + { + guardClause.Null(input, nameof(input)); + return OutOfSQLDateRange(guardClause, input.Value, parameterName, message); + } + /// /// Throws an if is not in the range of valid SqlDateTime values. /// From 667a045e8bb6c0eca9561ed563b6ef33cea41d21 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 24 Oct 2021 22:37:59 -0700 Subject: [PATCH 09/25] Add More Nullable Unit Tests for NullOrOutOfRange Rename Some TestFiles --- ...nstNullOrOutOfRangeForClassIComparable.cs} | 4 +- .../GuardAgainstNullOrOutOfRangeForInt.cs | 58 ++++++++++ ...dAgainstNullOrOutOfRangeForNullableInt.cs} | 8 +- .../GuardAgainstNullOrOutOfSQLDateRange.cs | 104 ++++++++++++++++++ .../GuardAgainstOutOfSQLDateRange.cs | 2 +- 5 files changed, 171 insertions(+), 5 deletions(-) rename test/GuardClauses.UnitTests/{GuardAgainstOutOfRangeForClassIComparable.cs => GuardAgainstNullOrOutOfRangeForClassIComparable.cs} (93%) create mode 100644 test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForInt.cs rename test/GuardClauses.UnitTests/{GuardAgainstOutOfRangeForNullableInt.cs => GuardAgainstNullOrOutOfRangeForNullableInt.cs} (84%) create mode 100644 test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfSQLDateRange.cs diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs similarity index 93% rename from test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs rename to test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs index 2ac605ca..7ccac725 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForClassIComparable.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs @@ -9,7 +9,7 @@ namespace GuardClauses.UnitTests /// Every type that implements IComparable and IComparable can use OutOfRange. /// Here for example tuples are used. /// - public class GuardAgainstOutOfRangeForClassIComparable + public class GuardAgainstNullOrOutOfRangeForClassIComparable { private class TestObj : IComparable, IEquatable { @@ -54,14 +54,12 @@ public void ThrowsGivenInvalidArgumentValue() [Fact] public void ThrowsGivenInvalidNullArgumentValue() { -#pragma warning disable CS8634 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match 'class' constraint. #pragma warning disable CS8631 // The type cannot be used as type parameter in the generic type or method. Nullability of type argument doesn't match constraint type. Assert.Throws(() => Guard.Against.NullOrOutOfRange(null, "index", new TestObj(3), new TestObj(1))); Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(0), "index", null, new TestObj(1))); Assert.Throws(() => Guard.Against.NullOrOutOfRange(new TestObj(4), "index", new TestObj(3), null)); -#pragma warning restore CS8634 #pragma warning restore CS8631 } diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForInt.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForInt.cs new file mode 100644 index 00000000..abaa972a --- /dev/null +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForInt.cs @@ -0,0 +1,58 @@ +using Ardalis.GuardClauses; +using System; +using Xunit; + +namespace GuardClauses.UnitTests +{ + public class GuardAgainstNullOrOutOfRangeForInt + { + [Theory] + [InlineData(1, 1, 1)] + [InlineData(1, 1, 3)] + [InlineData(2, 1, 3)] + [InlineData(3, 1, 3)] + public void DoesNothingGivenInRangeValue(int input, int rangeFrom, int rangeTo) + { + Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo); + } + + [Theory] + [InlineData(-1, 1, 3)] + [InlineData(0, 1, 3)] + [InlineData(4, 1, 3)] + public void ThrowsGivenOutOfRangeValue(int input, int rangeFrom, int rangeTo) + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); + } + + [Theory] + [InlineData(-1, 3, 1)] + [InlineData(0, 3, 1)] + [InlineData(4, 3, 1)] + public void ThrowsGivenInvalidArgumentValue(int input, int rangeFrom, int rangeTo) + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); + } + + [Theory] + [InlineData(1, 1, 1, 1)] + [InlineData(1, 1, 3, 1)] + [InlineData(2, 1, 3, 2)] + [InlineData(3, 1, 3, 3)] + public void ReturnsExpectedValueGivenInRangeValue(int input, int rangeFrom, int rangeTo, int expected) + { + Assert.Equal(expected, Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); + } + + [Theory] + [InlineData(null, "Input parameterName was out of range (Parameter 'parameterName')")] + [InlineData("Int range", "Int range")] + public void ErrorMessageMatchesExpected(string customMessage, string expectedMessage) + { + var exception = Assert.Throws(() => Guard.Against.NullOrOutOfRange(3, "parameterName", 0, 1, customMessage)); + Assert.NotNull(exception); + Assert.NotNull(exception.Message); + Assert.Equal(expectedMessage, exception.Message); + } + } +} diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForNullableInt.cs similarity index 84% rename from test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs rename to test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForNullableInt.cs index c9313999..d8ef2f2b 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForNullableInt.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForNullableInt.cs @@ -4,7 +4,7 @@ namespace GuardClauses.UnitTests { - public class GuardAgainstOutOfRangeForNullableInt + public class GuardAgainstNullOrOutOfRangeForNullableInt { [Theory] [InlineData(1, 1, 1)] @@ -43,5 +43,11 @@ public void ReturnsExpectedValueGivenInRangeValue(int? input, int rangeFrom, int { Assert.Equal(expected, Guard.Against.NullOrOutOfRange(input, "index", rangeFrom, rangeTo)); } + + [Fact] + public void ThrowsGivenInvalidNullArgumentValue() + { + Assert.Throws(() => Guard.Against.NullOrOutOfRange(null, "index", -10, 10)); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfSQLDateRange.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfSQLDateRange.cs new file mode 100644 index 00000000..117d9685 --- /dev/null +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfSQLDateRange.cs @@ -0,0 +1,104 @@ +using Ardalis.GuardClauses; +using System; +using System.Collections.Generic; +using System.Data.SqlTypes; +using Xunit; + +namespace GuardClauses.UnitTests +{ + public class GuardAgainstNullOrOutOfSQLDateRange + { + [Theory] + [InlineData(1)] + [InlineData(60)] + [InlineData(60 * 60)] + [InlineData(60 * 60 * 24)] + [InlineData(60 * 60 * 24 * 30)] + [InlineData(60 * 60 * 24 * 30 * 365)] + public void ThrowsGivenValueBelowMinDate(int offsetInSeconds) + { + DateTime date = SqlDateTime.MinValue.Value.AddSeconds(-offsetInSeconds); + + Assert.Throws(() => Guard.Against.NullOrOutOfSQLDateRange(date, nameof(date))); + } + + [Fact] + public void DoNothingGivenCurrentDate() + { + Guard.Against.NullOrOutOfSQLDateRange(DateTime.Today, "Today"); + Guard.Against.NullOrOutOfSQLDateRange(DateTime.Now, "Now"); + Guard.Against.NullOrOutOfSQLDateRange(DateTime.UtcNow, "UTC Now"); + } + + [Theory] + [InlineData(0)] + [InlineData(1)] + [InlineData(60)] + [InlineData(60 * 60)] + [InlineData(60 * 60 * 24)] + [InlineData(60 * 60 * 24 * 30)] + [InlineData(60 * 60 * 24 * 30 * 365)] + public void DoNothingGivenSqlMinValue(int offsetInSeconds) + { + DateTime date = SqlDateTime.MinValue.Value.AddSeconds(offsetInSeconds); + + Guard.Against.NullOrOutOfSQLDateRange(date, nameof(date)); + } + + [Theory] + [InlineData(0)] + [InlineData(1)] + [InlineData(60)] + [InlineData(60 * 60)] + [InlineData(60 * 60 * 24)] + [InlineData(60 * 60 * 24 * 30)] + [InlineData(60 * 60 * 24 * 30 * 365)] + public void DoNothingGivenSqlMaxValue(int offsetInSeconds) + { + DateTime date = SqlDateTime.MaxValue.Value.AddSeconds(-offsetInSeconds); + + Guard.Against.NullOrOutOfSQLDateRange(date, nameof(date)); + } + + [Theory] + [MemberData(nameof(GetSqlDateTimeTestVectors))] + public void ReturnsExpectedValueWhenGivenValidSqlDateTime(DateTime input, string name, DateTime expected) + { + Assert.Equal(expected, Guard.Against.NullOrOutOfSQLDateRange(input, name)); + } + + [Theory] + [InlineData(null, "Input date was out of range (Parameter 'date')")] + [InlineData("SQLDate range", "SQLDate range")] + public void ErrorMessageMatchesExpected(string customMessage, string expectedMessage) + { + DateTime date = SqlDateTime.MinValue.Value.AddSeconds(-1); + var exception = Assert.Throws(() => Guard.Against.NullOrOutOfSQLDateRange(date, nameof(date), customMessage)); + + Assert.NotNull(exception); + Assert.NotNull(exception.Message); + Assert.Equal(expectedMessage, exception.Message); + } + + [Fact] + public void ThrowsGivenInvalidNullArgumentValue() + { + Assert.Throws(() => Guard.Against.NullOrOutOfSQLDateRange(null, "index")); + } + + private static IEnumerable GetSqlDateTimeTestVectors() + { + var now = DateTime.Now; + var utc = DateTime.UtcNow; + var yesterday = DateTime.Now.AddDays(-1); + var min = SqlDateTime.MinValue.Value; + var max = SqlDateTime.MaxValue.Value; + + yield return new object[] {now, "now", now}; + yield return new object[] {utc, "utc", utc}; + yield return new object[] {yesterday, "yesterday", yesterday}; + yield return new object[] {min, "min", min}; + yield return new object[] {max, "max", max}; + } + } +} diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs index f5f80fcd..8fc27d2b 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs @@ -80,7 +80,7 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes Assert.Equal(expectedMessage, exception.Message); } - public static IEnumerable GetSqlDateTimeTestVectors() + private static IEnumerable GetSqlDateTimeTestVectors() { var now = DateTime.Now; var utc = DateTime.UtcNow; From b9fa68e118b23c4eeede09ee297c2151b96707bc Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 31 Oct 2021 16:15:48 -0700 Subject: [PATCH 10/25] Update to CI/CD use Net5 with C#9 --- .github/workflows/build.yml | 2 +- .github/workflows/publish.yml | 2 +- global.json | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 2cd4405f..a381704f 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -18,7 +18,7 @@ jobs: - name: Setup .NET Core uses: actions/setup-dotnet@v1 with: - dotnet-version: 3.1.402 + dotnet-version: 5.0.402 - name: Install dependencies run: dotnet restore - name: Build diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 6815a8a9..edc4e444 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -17,7 +17,7 @@ jobs: - name: Setup dotnet uses: actions/setup-dotnet@v1 with: - dotnet-version: 3.1.402 + dotnet-version: 5.0.402 # Publish - name: publish on version change diff --git a/global.json b/global.json index 79a3415e..a1b5bba3 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "3.1.402", + "version": "5.0.402", "rollForward": "latestPatch" } } \ No newline at end of file From 055513bc4304164c33e99da72da00d50717305fa Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 31 Oct 2021 16:20:08 -0700 Subject: [PATCH 11/25] Update Test to use Net5 --- test/GuardClauses.UnitTests/GuardClauses.UnitTests.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/GuardClauses.UnitTests/GuardClauses.UnitTests.csproj b/test/GuardClauses.UnitTests/GuardClauses.UnitTests.csproj index 3927e9ef..d677bf81 100644 --- a/test/GuardClauses.UnitTests/GuardClauses.UnitTests.csproj +++ b/test/GuardClauses.UnitTests/GuardClauses.UnitTests.csproj @@ -1,7 +1,7 @@  - netcoreapp3.1 + net5 false From 74334f36a6063abd715d2a549caa718402f99623 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Sun, 31 Oct 2021 16:34:14 -0700 Subject: [PATCH 12/25] Fix QA Errors --- .../GuardAgainstNullOrOutOfRangeForClassIComparable.cs | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs index 7ccac725..76c65931 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs @@ -22,7 +22,15 @@ public TestObj(int internalValue) public int CompareTo([AllowNull] TestObj? other) => _internalValue.CompareTo(other?._internalValue); - public bool Equals([AllowNull] TestObj? other) => _internalValue == other?._internalValue; + + public override bool Equals(object? obj) + { + if (obj is null) return false; + if (ReferenceEquals(this, obj)) return true; + if (obj.GetType() != typeof(TestObj)) return false; + return Equals((TestObj)obj); + } + public bool Equals([AllowNull] TestObj? other) => ReferenceEquals(this, other) || _internalValue == other?._internalValue; public override int GetHashCode() => _internalValue.GetHashCode(); } From 95215905184875133f2daf3b2d6fcd6bbe0c212f Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Mon, 14 Mar 2022 23:13:44 -0700 Subject: [PATCH 13/25] Fix Compilation --- src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index 47ac0546..ef634601 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -2,10 +2,11 @@ using System.Collections.Generic; using System.ComponentModel; using System.Linq; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; using JetBrainsInvokerParameterNameAttribute = JetBrains.Annotations.InvokerParameterNameAttribute; using JetBrainsNotNullAttribute = JetBrains.Annotations.NotNullAttribute; using JetBrainsCanBeNull = JetBrains.Annotations.CanBeNullAttribute; -using System.Diagnostics.CodeAnalysis; namespace Ardalis.GuardClauses { From 1076a73d463d9d31d75ab803c98aad6d38d93086 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Mon, 14 Mar 2022 23:41:01 -0700 Subject: [PATCH 14/25] Update --- .../GuardAgainstOutOfRangeExtensions.cs | 18 ++---------------- 1 file changed, 2 insertions(+), 16 deletions(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index ef634601..609d9da3 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -155,21 +155,7 @@ public static T OutOfRange(this IGuardClause guardClause, T input, T rangeTo, string? message = null) where T : IComparable, IComparable { - if (rangeFrom.CompareTo(rangeTo) > 0) - { - throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); - } - - if (input.CompareTo(rangeFrom) < 0 || input.CompareTo(rangeTo) > 0) - { - if (string.IsNullOrEmpty(message)) - { - throw new ArgumentOutOfRangeException(parameterName, $"Input {parameterName} was out of range"); - } - throw new ArgumentOutOfRangeException(parameterName, message); - } - - return input; + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } /// @@ -203,7 +189,7 @@ public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardCla /// /// /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable { guardClause.Null(input, nameof(input)); return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); From adc991cee2e578d682e373c92af67ff966938f3c Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Mon, 14 Mar 2022 23:50:50 -0700 Subject: [PATCH 15/25] Update --- .../GuardAgainstOutOfRangeExtensions.cs | 118 +++++++++++------- 1 file changed, 70 insertions(+), 48 deletions(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index 609d9da3..0db30a74 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -81,35 +81,25 @@ public static T EnumOutOfRange([JetBrainsNotNull] this IGuardClause guardClau } /// - /// Throws an if any 's item is less than or greater than . + /// Throws an if is null. + /// Throws an if is not in the range of valid SqlDateTime values. /// /// /// /// - /// - /// /// Optional. Custom error message - /// if any item is not out of range. - /// + /// if the value is in the range of valid SqlDateTime values. + /// /// - public static IEnumerable OutOfRange(this IGuardClause guardClause, IEnumerable input, string parameterName, T rangeFrom, T rangeTo, string? message = null) where T : IComparable, IComparable + public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, + DateTime? input, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, + string? message = null) { - if (rangeFrom.CompareTo(rangeTo) > 0) - { - throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); - } - - if (input.Any(x => x.CompareTo(rangeFrom) < 0 || x.CompareTo(rangeTo) > 0)) - { - if (string.IsNullOrEmpty(message)) - { - throw new ArgumentOutOfRangeException(parameterName, message ?? $"Input {parameterName} had out of range item(s)"); - } - throw new ArgumentOutOfRangeException(parameterName, message); - } - - return input; + guardClause.Null(input, nameof(input)); + return OutOfSQLDateRange(guardClause, input.Value, parameterName, message); } + /// /// Throws an if is not in the range of valid SqlDateTime values. /// @@ -139,6 +129,7 @@ public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause gu } /// + /// Throws an if is null. /// Throws an if is less than or greater than . /// /// @@ -147,36 +138,47 @@ public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause gu /// /// /// Optional. Custom error message - /// if the value is not out of range. + /// if the value is not not null or out of range. + /// + /// /// - public static T OutOfRange(this IGuardClause guardClause, T input, - [JetBrainsInvokerParameterName] string parameterName, - T rangeFrom, - T rangeTo, - string? message = null) where T : IComparable, IComparable + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, + [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, + string? message = null) where T : IComparable { - return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + guardClause.Null(input, nameof(input)); + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } /// /// Throws an if is null. - /// Throws an if is not in the range of valid SqlDateTime values. + /// Throws an if is less than or greater than . /// /// /// /// + /// + /// /// Optional. Custom error message - /// if the value is in the range of valid SqlDateTime values. + /// if the value is not not null or out of range. /// + /// /// - public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, DateTime? input, [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, string? message = null) + public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, + [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, + string? message = null) where T : struct, IComparable { guardClause.Null(input, nameof(input)); - return OutOfSQLDateRange(guardClause, input.Value, parameterName, message); + return NullOrOutOfRangeInternal(guardClause, input.Value, parameterName, rangeFrom, rangeTo, message); } /// - /// Throws an if is null. /// Throws an if is less than or greater than . /// /// @@ -185,19 +187,20 @@ public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardCla /// /// /// Optional. Custom error message - /// if the value is not not null or out of range. - /// - /// + /// if the value is not out of range. /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable + public static T OutOfRange(this IGuardClause guardClause, + T input, + [JetBrainsInvokerParameterName] string parameterName, + T rangeFrom, + T rangeTo, + string? message = null) where T : IComparable, IComparable { - guardClause.Null(input, nameof(input)); - return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } /// - /// Throws an if is null. - /// Throws an if is less than or greater than . + /// Throws an if any 's item is less than or greater than . /// /// /// @@ -205,20 +208,40 @@ public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardCl /// /// /// Optional. Custom error message - /// if the value is not not null or out of range. - /// + /// if any item is not out of range. /// /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : struct, IComparable + public static IEnumerable OutOfRange(this IGuardClause guardClause, IEnumerable input, + string parameterName, + T rangeFrom, T rangeTo, + string? message = null) where T : IComparable, IComparable { - guardClause.Null(input, nameof(input)); - return NullOrOutOfRangeInternal(guardClause, input.Value, parameterName, rangeFrom, rangeTo, message); + if (rangeFrom.CompareTo(rangeTo) > 0) + { + throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); + } + + if (input.Any(x => x.CompareTo(rangeFrom) < 0 || x.CompareTo(rangeTo) > 0)) + { + if (string.IsNullOrEmpty(message)) + { + throw new ArgumentOutOfRangeException(parameterName, message ?? $"Input {parameterName} had out of range item(s)"); + } + throw new ArgumentOutOfRangeException(parameterName, message); + } + + return input; } /// /// /// - private static T NullOrOutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? input, [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, string? message = null) where T : IComparable? + private static T NullOrOutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T? input, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, + string? message = null) where T : IComparable? { Guard.Against.Null(input, nameof(input)); Guard.Against.Null(rangeFrom, nameof(rangeFrom)); @@ -240,6 +263,5 @@ private static T NullOrOutOfRangeInternal([JetBrainsNotNull] this IGuardClaus return input; } - } } From 9332d462a2a2405e05f34a0b64948492ecf93356 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Tue, 15 Mar 2022 00:04:11 -0700 Subject: [PATCH 16/25] Fix Warning --- src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index 0db30a74..f951c944 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -238,12 +238,13 @@ public static IEnumerable OutOfRange(this IGuardClause guardClause, IEnume /// private static T NullOrOutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string? parameterName, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, string? message = null) where T : IComparable? { Guard.Against.Null(input, nameof(input)); + Guard.Against.Null(parameterName, nameof(parameterName)); Guard.Against.Null(rangeFrom, nameof(rangeFrom)); Guard.Against.Null(rangeTo, nameof(rangeTo)); From a9a8a061970a47f7bd253eb856187aadeef8b0a8 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Tue, 15 Mar 2022 21:59:03 -0700 Subject: [PATCH 17/25] Fix Warnings --- .../GuardAgainstNullOrInvalidInput.cs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrInvalidInput.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrInvalidInput.cs index 0c50a975..70d44f21 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstNullOrInvalidInput.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrInvalidInput.cs @@ -71,11 +71,11 @@ public IEnumerator GetEnumerator() IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } - public class ArgumentNullExceptionClassData : IEnumerable + public class ArgumentNullExceptionClassData : IEnumerable { - public IEnumerator GetEnumerator() + public IEnumerator GetEnumerator() { - yield return new object[] { null, (Func)(x => x.Length > 10) }; + yield return new object?[] { null, (Func)(x => x.Length > 10) }; } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } From 1c751bb5187e87a9ced3dd27f4fe18e535872294 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Tue, 15 Mar 2022 22:23:16 -0700 Subject: [PATCH 18/25] Add Mising Attributes --- .../GuardAgainstOutOfRangeExtensions.cs | 22 +++++++++++++------ 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index f951c944..396a9943 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -91,10 +91,17 @@ public static T EnumOutOfRange([JetBrainsNotNull] this IGuardClause guardClau /// if the value is in the range of valid SqlDateTime values. /// /// - public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, - DateTime? input, +#if NETSTANDARD || NETFRAMEWORK + public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, + [NotNull][ValidatedNotNull] DateTime? input, [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, string? message = null) +#else + public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, + [NotNull, JetBrainsCanBeNull][ValidatedNotNull] DateTime? input, + [JetBrainsNotNull][JetBrainsInvokerParameterName][CallerArgumentExpression("input")] string parameterName = null, + string? message = null) +#endif { guardClause.Null(input, nameof(input)); return OutOfSQLDateRange(guardClause, input.Value, parameterName, message); @@ -191,9 +198,9 @@ public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardCl /// public static T OutOfRange(this IGuardClause guardClause, T input, - [JetBrainsInvokerParameterName] string parameterName, - T rangeFrom, - T rangeTo, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, + [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, string? message = null) where T : IComparable, IComparable { return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); @@ -211,8 +218,9 @@ public static T OutOfRange(this IGuardClause guardClause, /// if any item is not out of range. /// /// - public static IEnumerable OutOfRange(this IGuardClause guardClause, IEnumerable input, - string parameterName, + public static IEnumerable OutOfRange(this IGuardClause guardClause, + [JetBrainsNotNull] IEnumerable input, + [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, T rangeFrom, T rangeTo, string? message = null) where T : IComparable, IComparable { From ed9bd595abaec804eb09a3afe172ff99d3dc35b2 Mon Sep 17 00:00:00 2001 From: Rafael Sliveira Cordeiro Date: Tue, 15 Mar 2022 22:42:20 -0700 Subject: [PATCH 19/25] Update Tests --- .../GuardAgainstOutOfRangeForDateTime.cs | 13 ++++++-- .../GuardAgainstOutOfRangeForDecimal.cs | 12 +++++-- .../GuardAgainstOutOfRangeForDouble.cs | 12 +++++-- .../GuardAgainstOutOfRangeForFloat.cs | 12 +++++-- .../GuardAgainstOutOfRangeForInt.cs | 12 +++++-- .../GuardAgainstOutOfRangeForShort.cs | 12 +++++-- ...rdAgainstOutOfRangeForStructIComparable.cs | 12 +++++-- .../GuardAgainstOutOfRangeForTimeSpan.cs | 32 ++++++++++++++++--- .../GuardAgainstOutOfRangeForUint.cs | 12 +++++-- .../GuardAgainstOutOfSQLDateRange.cs | 13 ++++++-- 10 files changed, 120 insertions(+), 22 deletions(-) diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs index d04617a3..5656499d 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs @@ -68,8 +68,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -79,5 +77,16 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange(DateTime.Today.AddDays(-1), expectedParamName, + DateTime.Today, DateTime.Today.AddDays(1), customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDecimal.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDecimal.cs index 106fb73f..3b00702d 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDecimal.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDecimal.cs @@ -56,8 +56,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -66,5 +64,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange(3.0, expectedParamName, 0.0, 1.0, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDouble.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDouble.cs index 3ca0293d..29b9f47d 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDouble.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDouble.cs @@ -56,8 +56,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -66,5 +64,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange(3.0d, expectedParamName, 0.0d, 1.0d, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForFloat.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForFloat.cs index e1982902..6f3a710c 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForFloat.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForFloat.cs @@ -56,8 +56,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -66,5 +64,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange(3.0f, expectedParamName, 0.0f, 1.0f, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForInt.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForInt.cs index 2ceba29c..e69d21b1 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForInt.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForInt.cs @@ -56,8 +56,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -66,5 +64,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange(3, expectedParamName, 0, 1, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForShort.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForShort.cs index f1899553..7a9ed768 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForShort.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForShort.cs @@ -56,8 +56,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -66,5 +64,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange((short)3, expectedParamName, (short)0, (short)1, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs index cc25e3a4..a61efed8 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForStructIComparable.cs @@ -62,8 +62,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -72,5 +70,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange((1, 2), expectedParamName, (3, 3), (9, 9), customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForTimeSpan.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForTimeSpan.cs index c4b21429..4ff24b8f 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForTimeSpan.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForTimeSpan.cs @@ -77,8 +77,6 @@ public void ErrorMessageMatchesExpectedWhenRangeIsInvalid(string customMessage, } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpectedRangeIsInvalid(string expectedParamName, string customMessage) @@ -92,6 +90,20 @@ public void ExceptionParamNameMatchesExpectedRangeIsInvalid(string expectedParam Assert.Equal(expectedParamName, exception.ParamName); } + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var inputTimeSpan = TimeSpan.FromSeconds(-1); + var rangeFromTimeSpan = TimeSpan.FromSeconds(3); + var rangeToTimeSpan = TimeSpan.FromSeconds(1); + + var exception = Assert.Throws(() => Guard.Against.OutOfRange(inputTimeSpan, expectedParamName, rangeFromTimeSpan, rangeToTimeSpan, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } + [Theory] [InlineData(null, "Input parameterName was out of range (Parameter 'parameterName')")] [InlineData("Timespan range", "Timespan range (Parameter 'parameterName')")] @@ -108,8 +120,6 @@ public void ErrorMessageMatchesExpectedWhenInputIsInvalid(string customMessage, } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpectedInputIsInvalid(string expectedParamName, string customMessage) @@ -122,5 +132,19 @@ public void ExceptionParamNameMatchesExpectedInputIsInvalid(string expectedParam Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull2(string? expectedParamName, string? customMessage) + { + var inputTimeSpan = TimeSpan.FromSeconds(-1); + var rangeFromTimeSpan = TimeSpan.FromSeconds(0); + var rangeToTimeSpan = TimeSpan.FromSeconds(1); + + var exception = Assert.Throws(() => Guard.Against.OutOfRange(inputTimeSpan, expectedParamName, rangeFromTimeSpan, rangeToTimeSpan, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForUint.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForUint.cs index 676834c6..78bbc39e 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForUint.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForUint.cs @@ -55,8 +55,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -65,5 +63,15 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.NotNull(exception); Assert.Equal(expectedParamName, exception.ParamName); } + + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + var exception = Assert.Throws(() => Guard.Against.OutOfRange((uint)3.0d, expectedParamName, (uint)0.0d, (uint)1.0d, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } } } diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs index c4b90141..f4755345 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfSQLDateRange.cs @@ -94,8 +94,6 @@ public void ErrorMessageMatchesExpectedWhenNameNotExplicitlyProvided(string cust } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) @@ -106,6 +104,17 @@ public void ExceptionParamNameMatchesExpected(string expectedParamName, string c Assert.Equal(expectedParamName, exception.ParamName); } + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + public void ExceptionParamNameNull(string? expectedParamName, string? customMessage) + { + DateTime date = SqlDateTime.MinValue.Value.AddSeconds(-1); + var exception = Assert.Throws(() => Guard.Against.OutOfSQLDateRange(date, expectedParamName, customMessage)); + Assert.NotNull(exception); + Assert.Equal("parameterName", exception.ParamName); + } + public static IEnumerable GetSqlDateTimeTestVectors() { var now = DateTime.Now; From 48b90d4280db7a160db957fa779f5ac115ff19ea Mon Sep 17 00:00:00 2001 From: Rafael Cordeiro Date: Tue, 21 Feb 2023 23:38:40 -0800 Subject: [PATCH 20/25] Format --- .../GuardAgainstOutOfRangeExtensions.cs | 424 +++++++++--------- src/GuardClauses/GuardClauses.csproj | 4 +- .../GuardAgainstNullOrWhiteSpace.cs | 191 ++++---- 3 files changed, 308 insertions(+), 311 deletions(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index 396a9943..8fc6d430 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -4,273 +4,269 @@ using System.Linq; using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; -using JetBrainsInvokerParameterNameAttribute = JetBrains.Annotations.InvokerParameterNameAttribute; -using JetBrainsNotNullAttribute = JetBrains.Annotations.NotNullAttribute; -using JetBrainsCanBeNull = JetBrains.Annotations.CanBeNullAttribute; -namespace Ardalis.GuardClauses +namespace Ardalis.GuardClauses; + +public static partial class GuardClauseExtensions { - public static partial class GuardClauseExtensions - { - /// - /// Throws an if is not a valid enum value. - /// - /// - /// - /// - /// - /// Optional. Custom error message - /// if the value is not out of range. - /// + /// + /// Throws an if is not a valid enum value. + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is not out of range. + /// #if NETSTANDARD || NETFRAMEWORK - public static int EnumOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, - int input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - string? message = null) where T : struct, Enum + public static int EnumOutOfRange(this IGuardClause guardClause, + int input, + string parameterName, + string? message = null) where T : struct, Enum #else - public static int EnumOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, + public static int EnumOutOfRange(this IGuardClause guardClause, int input, [JetBrainsNotNull][JetBrainsInvokerParameterName][CallerArgumentExpression("input")] string? parameterName = null, string? message = null) where T : struct, Enum #endif + { + if (!Enum.IsDefined(typeof(T), input)) { - if (!Enum.IsDefined(typeof(T), input)) + if (string.IsNullOrEmpty(message)) { - if (string.IsNullOrEmpty(message)) - { - throw new InvalidEnumArgumentException(parameterName, input, typeof(T)); - } - throw new InvalidEnumArgumentException(message); + throw new InvalidEnumArgumentException(parameterName, input, typeof(T)); } - - return input; + throw new InvalidEnumArgumentException(message); } - /// - /// Throws an if is not a valid enum value. - /// - /// - /// - /// - /// - /// /// Optional. Custom error message - /// if the value is not out of range. - /// + return input; + } + + /// + /// Throws an if is not a valid enum value. + /// + /// + /// + /// + /// + /// /// Optional. Custom error message + /// if the value is not out of range. + /// #if NETSTANDARD || NETFRAMEWORK - public static T EnumOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, - T input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - string? message = null) where T : struct, Enum + public static T EnumOutOfRange(this IGuardClause guardClause, + T input, + string parameterName, + string? message = null) where T : struct, Enum #else - public static T EnumOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, + public static T EnumOutOfRange(this IGuardClause guardClause, T input, [JetBrainsNotNull][JetBrainsInvokerParameterName][CallerArgumentExpression("input")] string? parameterName = null, string? message = null) where T : struct, Enum #endif + { + if (!Enum.IsDefined(typeof(T), input)) { - if (!Enum.IsDefined(typeof(T), input)) + if (string.IsNullOrEmpty(message)) { - if (string.IsNullOrEmpty(message)) - { - throw new InvalidEnumArgumentException(parameterName, Convert.ToInt32(input), typeof(T)); - } - throw new InvalidEnumArgumentException(message); + throw new InvalidEnumArgumentException(parameterName, Convert.ToInt32(input), typeof(T)); } - - return input; + throw new InvalidEnumArgumentException(message); } - /// - /// Throws an if is null. - /// Throws an if is not in the range of valid SqlDateTime values. - /// - /// - /// - /// - /// Optional. Custom error message - /// if the value is in the range of valid SqlDateTime values. - /// - /// + return input; + } + + /// + /// Throws an if is null. + /// Throws an if is not in the range of valid SqlDateTime values. + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is in the range of valid SqlDateTime values. + /// + /// #if NETSTANDARD || NETFRAMEWORK - public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, - [NotNull][ValidatedNotNull] DateTime? input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - string? message = null) + public static DateTime NullOrOutOfSQLDateRange(this IGuardClause guardClause, + [NotNull][ValidatedNotNull] DateTime? input, + string parameterName, + string? message = null) #else - public static DateTime NullOrOutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, - [NotNull, JetBrainsCanBeNull][ValidatedNotNull] DateTime? input, + public static DateTime NullOrOutOfSQLDateRange(this IGuardClause guardClause, + [NotNull][ValidatedNotNull] DateTime? input, [JetBrainsNotNull][JetBrainsInvokerParameterName][CallerArgumentExpression("input")] string parameterName = null, string? message = null) #endif - { - guardClause.Null(input, nameof(input)); - return OutOfSQLDateRange(guardClause, input.Value, parameterName, message); - } + { + guardClause.Null(input, nameof(input)); + return OutOfSQLDateRange(guardClause, input.Value, parameterName, message); + } - /// - /// Throws an if is not in the range of valid SqlDateTime values. - /// - /// - /// - /// - /// Optional. Custom error message - /// if the value is in the range of valid SqlDateTime values. - /// + /// + /// Throws an if is not in the range of valid SqlDateTime values. + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is in the range of valid SqlDateTime values. + /// #if NETSTANDARD || NETFRAMEWORK - public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, - DateTime input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - string? message = null) + public static DateTime OutOfSQLDateRange(this IGuardClause guardClause, + DateTime input, + string parameterName, + string? message = null) #else - public static DateTime OutOfSQLDateRange([JetBrainsNotNull] this IGuardClause guardClause, + public static DateTime OutOfSQLDateRange(this IGuardClause guardClause, DateTime input, [JetBrainsNotNull][JetBrainsInvokerParameterName][CallerArgumentExpression("input")] string? parameterName = null, string? message = null) #endif - { - // System.Data is unavailable in .NET Standard so we can't use SqlDateTime. - const long sqlMinDateTicks = 552877920000000000; - const long sqlMaxDateTicks = 3155378975999970000; + { + // System.Data is unavailable in .NET Standard so we can't use SqlDateTime. + const long sqlMinDateTicks = 552877920000000000; + const long sqlMaxDateTicks = 3155378975999970000; - return NullOrOutOfRangeInternal(guardClause, input, parameterName, new DateTime(sqlMinDateTicks), new DateTime(sqlMaxDateTicks), message); - } + return NullOrOutOfRangeInternal(guardClause, input, parameterName, new DateTime(sqlMinDateTicks), new DateTime(sqlMaxDateTicks), message); + } - /// - /// Throws an if is null. - /// Throws an if is less than or greater than . - /// - /// - /// - /// - /// - /// - /// Optional. Custom error message - /// if the value is not not null or out of range. - /// - /// - /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, - [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, - string? message = null) where T : IComparable - { - guardClause.Null(input, nameof(input)); - return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); - } + /// + /// Throws an if is null. + /// Throws an if is less than or greater than . + /// + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is not not null or out of range. + /// + /// + /// + public static T NullOrOutOfRange(this IGuardClause guardClause, + [NotNull][ValidatedNotNull] T? input, + string parameterName, + [NotNull][ValidatedNotNull] T rangeFrom, + [NotNull][ValidatedNotNull] T rangeTo, + string? message = null) where T : IComparable + { + guardClause.Null(input, nameof(input)); + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + } - /// - /// Throws an if is null. - /// Throws an if is less than or greater than . - /// - /// - /// - /// - /// - /// - /// Optional. Custom error message - /// if the value is not not null or out of range. - /// - /// - /// - public static T NullOrOutOfRange([JetBrainsNotNull] this IGuardClause guardClause, - [NotNull, JetBrainsCanBeNull][ValidatedNotNull] T? input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, - string? message = null) where T : struct, IComparable - { - guardClause.Null(input, nameof(input)); - return NullOrOutOfRangeInternal(guardClause, input.Value, parameterName, rangeFrom, rangeTo, message); - } + /// + /// Throws an if is null. + /// Throws an if is less than or greater than . + /// + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is not not null or out of range. + /// + /// + /// + public static T NullOrOutOfRange(this IGuardClause guardClause, + [NotNull][ValidatedNotNull] T? input, + string parameterName, + [NotNull][ValidatedNotNull] T rangeFrom, + [NotNull][ValidatedNotNull] T rangeTo, + string? message = null) where T : struct, IComparable + { + guardClause.Null(input, nameof(input)); + return NullOrOutOfRangeInternal(guardClause, input.Value, parameterName, rangeFrom, rangeTo, message); + } - /// - /// Throws an if is less than or greater than . - /// - /// - /// - /// - /// - /// - /// Optional. Custom error message - /// if the value is not out of range. - /// - public static T OutOfRange(this IGuardClause guardClause, - T input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeFrom, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T rangeTo, - string? message = null) where T : IComparable, IComparable + /// + /// Throws an if is less than or greater than . + /// + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if the value is not out of range. + /// + public static T OutOfRange(this IGuardClause guardClause, + T input, + string parameterName, + [NotNull][ValidatedNotNull] T rangeFrom, + [NotNull][ValidatedNotNull] T rangeTo, + string? message = null) where T : IComparable, IComparable + { + return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + } + + /// + /// Throws an if any 's item is less than or greater than . + /// + /// + /// + /// + /// + /// + /// Optional. Custom error message + /// if any item is not out of range. + /// + /// + public static IEnumerable OutOfRange(this IGuardClause guardClause, + IEnumerable input, + string parameterName, + T rangeFrom, T rangeTo, + string? message = null) where T : IComparable, IComparable + { + if (rangeFrom.CompareTo(rangeTo) > 0) { - return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); + throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); } - /// - /// Throws an if any 's item is less than or greater than . - /// - /// - /// - /// - /// - /// - /// Optional. Custom error message - /// if any item is not out of range. - /// - /// - public static IEnumerable OutOfRange(this IGuardClause guardClause, - [JetBrainsNotNull] IEnumerable input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string parameterName, - T rangeFrom, T rangeTo, - string? message = null) where T : IComparable, IComparable + if (input.Any(x => x.CompareTo(rangeFrom) < 0 || x.CompareTo(rangeTo) > 0)) { - if (rangeFrom.CompareTo(rangeTo) > 0) + if (string.IsNullOrEmpty(message)) { - throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); + throw new ArgumentOutOfRangeException(parameterName, message ?? $"Input {parameterName} had out of range item(s)"); } + throw new ArgumentOutOfRangeException(parameterName, message); + } - if (input.Any(x => x.CompareTo(rangeFrom) < 0 || x.CompareTo(rangeTo) > 0)) - { - if (string.IsNullOrEmpty(message)) - { - throw new ArgumentOutOfRangeException(parameterName, message ?? $"Input {parameterName} had out of range item(s)"); - } - throw new ArgumentOutOfRangeException(parameterName, message); - } + return input; + } - return input; - } + /// + /// + /// + private static T NullOrOutOfRangeInternal(this IGuardClause guardClause, + [NotNull][ValidatedNotNull] T? input, + string? parameterName, + [NotNull][ValidatedNotNull] T? rangeFrom, + [NotNull][ValidatedNotNull] T? rangeTo, + string? message = null) where T : IComparable? + { + Guard.Against.Null(input, nameof(input)); + Guard.Against.Null(parameterName, nameof(parameterName)); + Guard.Against.Null(rangeFrom, nameof(rangeFrom)); + Guard.Against.Null(rangeTo, nameof(rangeTo)); - /// - /// - /// - private static T NullOrOutOfRangeInternal([JetBrainsNotNull] this IGuardClause guardClause, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T? input, - [JetBrainsNotNull][JetBrainsInvokerParameterName] string? parameterName, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeFrom, - [NotNull, JetBrainsNotNull][ValidatedNotNull] T? rangeTo, - string? message = null) where T : IComparable? + if (rangeFrom.CompareTo(rangeTo) > 0) { - Guard.Against.Null(input, nameof(input)); - Guard.Against.Null(parameterName, nameof(parameterName)); - Guard.Against.Null(rangeFrom, nameof(rangeFrom)); - Guard.Against.Null(rangeTo, nameof(rangeTo)); - - if (rangeFrom.CompareTo(rangeTo) > 0) - { - throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); - } + throw new ArgumentException(message ?? $"{nameof(rangeFrom)} should be less or equal than {nameof(rangeTo)}", parameterName); + } - if (input.CompareTo(rangeFrom) < 0 || input.CompareTo(rangeTo) > 0) + if (input.CompareTo(rangeFrom) < 0 || input.CompareTo(rangeTo) > 0) + { + if (string.IsNullOrEmpty(message)) { - if (string.IsNullOrEmpty(message)) - { - throw new ArgumentOutOfRangeException(parameterName, $"Input {parameterName} was out of range"); - } - throw new ArgumentOutOfRangeException(parameterName, message); + throw new ArgumentOutOfRangeException(parameterName, $"Input {parameterName} was out of range"); } - - return input; + throw new ArgumentOutOfRangeException(parameterName, message); } + + return input; } } diff --git a/src/GuardClauses/GuardClauses.csproj b/src/GuardClauses/GuardClauses.csproj index 0eb1d064..9fdfcced 100644 --- a/src/GuardClauses/GuardClauses.csproj +++ b/src/GuardClauses/GuardClauses.csproj @@ -2,7 +2,9 @@ netstandard2.0;net451;net60 - Ardalis.GuardClauses + 10 + + Ardalis.GuardClauses Ardalis.GuardClauses true Steve Smith (@ardalis) diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs index 4bd5adb3..609d93f0 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrWhiteSpace.cs @@ -2,112 +2,111 @@ using Ardalis.GuardClauses; using Xunit; -namespace GuardClauses.UnitTests +namespace GuardClauses.UnitTests; + +public class GuardAgainstNullOrWhiteSpace { - public class GuardAgainstNullOrWhiteSpace + [Theory] + [InlineData("a")] + [InlineData("1")] + [InlineData("some text")] + [InlineData(" leading whitespace")] + [InlineData("trailing whitespace ")] + public void DoesNothingGivenNonEmptyStringValue(string nonEmptyString) { - [Theory] - [InlineData("a")] - [InlineData("1")] - [InlineData("some text")] - [InlineData(" leading whitespace")] - [InlineData("trailing whitespace ")] - public void DoesNothingGivenNonEmptyStringValue(string nonEmptyString) - { - Guard.Against.NullOrWhiteSpace(nonEmptyString, "string"); - Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString"); - } + Guard.Against.NullOrWhiteSpace(nonEmptyString, "string"); + Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString"); + } - [Fact] - public void ThrowsGivenNullValue() - { - Assert.Throws(() => Guard.Against.NullOrWhiteSpace(null, "null")); - } + [Fact] + public void ThrowsGivenNullValue() + { + Assert.Throws(() => Guard.Against.NullOrWhiteSpace(null, "null")); + } - [Fact] - public void ThrowsGivenEmptyString() - { - Assert.Throws(() => Guard.Against.NullOrWhiteSpace("", "emptystring")); - } + [Fact] + public void ThrowsGivenEmptyString() + { + Assert.Throws(() => Guard.Against.NullOrWhiteSpace("", "emptystring")); + } - [Theory] - [InlineData(" ")] - [InlineData(" ")] - public void ThrowsGivenWhiteSpaceString(string whiteSpaceString) - { - Assert.Throws(() => Guard.Against.NullOrWhiteSpace(whiteSpaceString, "whitespacestring")); - } + [Theory] + [InlineData(" ")] + [InlineData(" ")] + public void ThrowsGivenWhiteSpaceString(string whiteSpaceString) + { + Assert.Throws(() => Guard.Against.NullOrWhiteSpace(whiteSpaceString, "whitespacestring")); + } - [Theory] - [InlineData("a", "a")] - [InlineData("1", "1")] - [InlineData("some text", "some text")] - [InlineData(" leading whitespace", " leading whitespace")] - [InlineData("trailing whitespace ", "trailing whitespace ")] - public void ReturnsExpectedValueGivenNonEmptyStringValue(string nonEmptyString, string expected) - { - Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "string")); - Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString")); - } + [Theory] + [InlineData("a", "a")] + [InlineData("1", "1")] + [InlineData("some text", "some text")] + [InlineData(" leading whitespace", " leading whitespace")] + [InlineData("trailing whitespace ", "trailing whitespace ")] + public void ReturnsExpectedValueGivenNonEmptyStringValue(string nonEmptyString, string expected) + { + Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "string")); + Assert.Equal(expected, Guard.Against.NullOrWhiteSpace(nonEmptyString, "aNumericString")); + } - [Theory] - [InlineData(null, "Required input parameterName was empty. (Parameter 'parameterName')")] - [InlineData("Value is empty", "Value is empty (Parameter 'parameterName')")] - public void ErrorMessageMatchesExpectedWhenInputIsWhiteSpace(string customMessage, string expectedMessage) - { - var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(" ", "parameterName", customMessage)); - Assert.NotNull(exception); - Assert.NotNull(exception.Message); - Assert.Equal(expectedMessage, exception.Message); - } + [Theory] + [InlineData(null, "Required input parameterName was empty. (Parameter 'parameterName')")] + [InlineData("Value is empty", "Value is empty (Parameter 'parameterName')")] + public void ErrorMessageMatchesExpectedWhenInputIsWhiteSpace(string customMessage, string expectedMessage) + { + var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(" ", "parameterName", customMessage)); + Assert.NotNull(exception); + Assert.NotNull(exception.Message); + Assert.Equal(expectedMessage, exception.Message); + } - [Theory] - [InlineData(null, "Value cannot be null. (Parameter 'parameterName')")] - [InlineData("Value is null", "Value is null (Parameter 'parameterName')")] - public void ErrorMessageMatchesExpectedWhenInputIsNull(string customMessage, string expectedMessage) - { - string? nullString = null; - var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(nullString, "parameterName", customMessage)); - Assert.NotNull(exception); - Assert.NotNull(exception.Message); - Assert.Equal(expectedMessage, exception.Message); - } + [Theory] + [InlineData(null, "Value cannot be null. (Parameter 'parameterName')")] + [InlineData("Value is null", "Value is null (Parameter 'parameterName')")] + public void ErrorMessageMatchesExpectedWhenInputIsNull(string customMessage, string expectedMessage) + { + string? nullString = null; + var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(nullString, "parameterName", customMessage)); + Assert.NotNull(exception); + Assert.NotNull(exception.Message); + Assert.Equal(expectedMessage, exception.Message); + } - [Theory] - [InlineData(null, "Value cannot be null. (Parameter 'xyz')")] - [InlineData("Value is null", "Value is null (Parameter 'xyz')")] - public void ErrorMessageMatchesExpectedWhenNameNotExplicitlyProvided(string customMessage, string expectedMessage) - { - string? xyz = null; - var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(xyz, message: customMessage)); - Assert.NotNull(exception); - Assert.NotNull(exception.Message); - Assert.Equal(expectedMessage, exception.Message); - } + [Theory] + [InlineData(null, "Value cannot be null. (Parameter 'xyz')")] + [InlineData("Value is null", "Value is null (Parameter 'xyz')")] + public void ErrorMessageMatchesExpectedWhenNameNotExplicitlyProvided(string customMessage, string expectedMessage) + { + string? xyz = null; + var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(xyz, message: customMessage)); + Assert.NotNull(exception); + Assert.NotNull(exception.Message); + Assert.Equal(expectedMessage, exception.Message); + } - [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] - [InlineData("SomeParameter", null)] - [InlineData("SomeOtherParameter", "Value must be correct")] - public void ExceptionParamNameMatchesExpectedWhenInputIsWhiteSpace(string expectedParamName, string customMessage) - { - var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(" ", expectedParamName, customMessage)); - Assert.NotNull(exception); - Assert.Equal(expectedParamName, exception.ParamName); - } + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + [InlineData("SomeParameter", null)] + [InlineData("SomeOtherParameter", "Value must be correct")] + public void ExceptionParamNameMatchesExpectedWhenInputIsWhiteSpace(string expectedParamName, string customMessage) + { + var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(" ", expectedParamName, customMessage)); + Assert.NotNull(exception); + Assert.Equal(expectedParamName, exception.ParamName); + } - [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] - [InlineData("SomeParameter", null)] - [InlineData("SomeOtherParameter", "Value must be correct")] - public void ExceptionParamNameMatchesExpectedWhenInputIsNull(string expectedParamName, string customMessage) - { - string? nullString = null; - var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(nullString, expectedParamName, customMessage)); - Assert.NotNull(exception); - Assert.Equal(expectedParamName, exception.ParamName); - } + [Theory] + [InlineData(null, null)] + [InlineData(null, "Please provide correct value")] + [InlineData("SomeParameter", null)] + [InlineData("SomeOtherParameter", "Value must be correct")] + public void ExceptionParamNameMatchesExpectedWhenInputIsNull(string expectedParamName, string customMessage) + { + string? nullString = null; + var exception = Assert.Throws(() => Guard.Against.NullOrWhiteSpace(nullString, expectedParamName, customMessage)); + Assert.NotNull(exception); + Assert.Equal(expectedParamName, exception.ParamName); } } From e5c412f61eb0011eb960c51f7934482a7d80360e Mon Sep 17 00:00:00 2001 From: Rafael Cordeiro Date: Wed, 22 Feb 2023 00:13:08 -0800 Subject: [PATCH 21/25] Update --- src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index 1151a804..c16feed9 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -183,7 +183,7 @@ public static T OutOfRange(this IGuardClause guardClause, string parameterName, [NotNull][ValidatedNotNull] T rangeFrom, [NotNull][ValidatedNotNull] T rangeTo, - string? message = null) where T : IComparable, IComparable + string? message = null) where T : struct, IComparable { return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } From edf9b130cb574e9ae4e0760cf8058e2d715f2002 Mon Sep 17 00:00:00 2001 From: Rafael Cordeiro Date: Wed, 22 Feb 2023 00:15:15 -0800 Subject: [PATCH 22/25] Fix Tests --- .../GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs index 17ed23dc..a0033430 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstOutOfRangeForDateTime.cs @@ -68,8 +68,6 @@ public void ErrorMessageMatchesExpected(string customMessage, string expectedMes } [Theory] - [InlineData(null, null)] - [InlineData(null, "Please provide correct value")] [InlineData("SomeParameter", null)] [InlineData("SomeOtherParameter", "Value must be correct")] public void ExceptionParamNameMatchesExpected(string expectedParamName, string customMessage) From 8e3fbd22b42d8bbedbb2e1ce61e244a88c80e93f Mon Sep 17 00:00:00 2001 From: Rafael Cordeiro Date: Wed, 22 Feb 2023 00:22:29 -0800 Subject: [PATCH 23/25] Rollback Change --- src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index c16feed9..22116068 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -183,7 +183,7 @@ public static T OutOfRange(this IGuardClause guardClause, string parameterName, [NotNull][ValidatedNotNull] T rangeFrom, [NotNull][ValidatedNotNull] T rangeTo, - string? message = null) where T : struct, IComparable + string? message = null) where T : IComparable, IComparable { return NullOrOutOfRangeInternal(guardClause, input, parameterName, rangeFrom, rangeTo, message); } @@ -239,7 +239,6 @@ public static T NullOrOutOfRange(this IGuardClause guardClause, return NullOrOutOfRangeInternal(guardClause, input.Value, parameterName, rangeFrom, rangeTo, message); } - /// /// /// From 16fe4c9433fe0bb3f89bc46890f639c57d151803 Mon Sep 17 00:00:00 2001 From: Rafael Cordeiro Date: Wed, 22 Feb 2023 23:16:47 -0800 Subject: [PATCH 24/25] CleanUp --- .../GuardAgainstNullOrOutOfRangeForClassIComparable.cs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs index 76c65931..855e97f2 100644 --- a/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs +++ b/test/GuardClauses.UnitTests/GuardAgainstNullOrOutOfRangeForClassIComparable.cs @@ -70,12 +70,7 @@ public void ThrowsGivenInvalidNullArgumentValue() #pragma warning restore CS8631 } - - //[Theory] - //[InlineData(1, 1, 1, 1)] - //[InlineData(1, 1, 3, 1)] - //[InlineData(2, 1, 3, 2)] - //[InlineData(3, 1, 3, 3)] + [Fact] public void ReturnsExpectedValueGivenInRangeValue() { From 14890a4d9faaa346d080c90db568f933179b7208 Mon Sep 17 00:00:00 2001 From: Rafael Cordeiro Date: Wed, 22 Feb 2023 23:26:17 -0800 Subject: [PATCH 25/25] Format --- .../GuardAgainstOutOfRangeExtensions.cs | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs index 22116068..27bdc359 100644 --- a/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs +++ b/src/GuardClauses/GuardAgainstOutOfRangeExtensions.cs @@ -20,9 +20,9 @@ public static partial class GuardClauseExtensions /// if the value is not out of range. /// #if NETSTANDARD || NETFRAMEWORK - public static int EnumOutOfRange(this IGuardClause guardClause, - int input, - string parameterName, + public static int EnumOutOfRange(this IGuardClause guardClause, + int input, + string parameterName, string? message = null) where T : struct, Enum #else public static int EnumOutOfRange(this IGuardClause guardClause, @@ -54,9 +54,9 @@ public static int EnumOutOfRange(this IGuardClause guardClause, /// if the value is not out of range. /// #if NETSTANDARD || NETFRAMEWORK - public static T EnumOutOfRange(this IGuardClause guardClause, - T input, - string parameterName, + public static T EnumOutOfRange(this IGuardClause guardClause, + T input, + string parameterName, string? message = null) where T : struct, Enum #else public static T EnumOutOfRange(this IGuardClause guardClause, @@ -125,8 +125,8 @@ public static IEnumerable OutOfRange(this IGuardClause guardClause, /// #if NETSTANDARD || NETFRAMEWORK public static DateTime NullOrOutOfSQLDateRange(this IGuardClause guardClause, - [NotNull][ValidatedNotNull] DateTime? input, - string parameterName, + [NotNull][ValidatedNotNull] DateTime? input, + string parameterName, string? message = null) #else public static DateTime NullOrOutOfSQLDateRange(this IGuardClause guardClause,