Repository: aweXpect/aweXpect
Pull request #624: feat: add `IsNotBetween` for numbers
Author: login: vbreuss
Labels: name: enhancement
description: New feature or request
name: state: released
description: The issue is released
Created: 2025-05-20T15:46:34Z | Merged: 2025-05-20T15:58:52Z

Adds “IsNotBetween” assertion methods to the aweXpect API so callers can verify a value is outside a given range.

- Introduces `IsNotBetween` overloads for each built-in numeric type


Diff:
diff --git a/Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs b/Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs
index 537855df0..e781f65d6 100644
--- a/Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs
+++ b/Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs
@@ -12,7 +12,7 @@ public static partial class ThatNumber
 {
 #if NET8_0_OR_GREATER
 	/// <summary>
-	///     Verifies that the subject is between <paramref name="minimum" />…
+	///     Verifies that the subject is between the <paramref name="minimum" />…
 	/// </summary>
 	public static BetweenResult<AndOrResult<TNumber, IThat<TNumber>>, TNumber?> IsBetween<TNumber>(
 		this IThat<TNumber> source, TNumber? minimum)
@@ -32,6 +32,28 @@ public static partial class ThatNumber
 			source.Get().ExpectationBuilder.AddConstraint((it, grammars) =>
 				new NullableIsInRangeConstraint<TNumber>(it, grammars, minimum, maximum)),
 			source));
+	
+	/// <summary>
+	///     Verifies that the subject is not between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<TNumber, IThat<TNumber>>, TNumber?> IsNotBetween<TNumber>(
+		this IThat<TNumber> source, TNumber? minimum)
+		where TNumber : struct, INumber<TNumber>
+		=> new(maximum => new AndOrResult<TNumber, IThat<TNumber>>(
+			source.Get().ExpectationBuilder.AddConstraint((it, grammars) =>
+				new IsInRangeConstraint<TNumber>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<TNumber?, IThat<TNumber?>>, TNumber?> IsNotBetween<TNumber>(
+		this IThat<TNumber?> source, TNumber? minimum)
+		where TNumber : struct, INumber<TNumber>
+		=> new(maximum => new AndOrResult<TNumber?, IThat<TNumber?>>(
+			source.Get().ExpectationBuilder.AddConstraint((it, grammars) =>
+				new NullableIsInRangeConstraint<TNumber>(it, grammars, minimum, maximum).Invert()),
+			source));
 
 	private sealed class IsInRangeConstraint<TNumber> : ConstraintResult.WithValue<TNumber>,
 			IValueConstraint<TNumber>
@@ -395,6 +417,248 @@ protected override void AppendNegatedResult(StringBuilder stringBuilder, string?
 					new NullableIsInRangeConstraint<decimal>(it, grammars, minimum, maximum)),
 			source));
 
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<byte, IThat<byte>>, byte?> IsNotBetween(
+		this IThat<byte> source,
+		byte? minimum)
+		=> new(maximum => new AndOrResult<byte, IThat<byte>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<byte>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<sbyte, IThat<sbyte>>, sbyte?> IsNotBetween(
+		this IThat<sbyte> source,
+		sbyte? minimum)
+		=> new(maximum => new AndOrResult<sbyte, IThat<sbyte>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<sbyte>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<short, IThat<short>>, short?> IsNotBetween(
+		this IThat<short> source,
+		short? minimum)
+		=> new(maximum => new AndOrResult<short, IThat<short>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<short>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<ushort, IThat<ushort>>, ushort?> IsNotBetween(
+		this IThat<ushort> source,
+		ushort? minimum)
+		=> new(maximum => new AndOrResult<ushort, IThat<ushort>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<ushort>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<int, IThat<int>>, int?> IsNotBetween(
+		this IThat<int> source,
+		int? minimum)
+		=> new(maximum => new AndOrResult<int, IThat<int>>(source.Get().ExpectationBuilder.AddConstraint((it, grammars)
+				=>
+				new IsInRangeConstraint<int>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<uint, IThat<uint>>, uint?> IsNotBetween(
+		this IThat<uint> source,
+		uint? minimum)
+		=> new(maximum => new AndOrResult<uint, IThat<uint>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<uint>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<long, IThat<long>>, long?> IsNotBetween(
+		this IThat<long> source,
+		long? minimum)
+		=> new(maximum => new AndOrResult<long, IThat<long>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<long>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<ulong, IThat<ulong>>, ulong?> IsNotBetween(
+		this IThat<ulong> source,
+		ulong? minimum)
+		=> new(maximum => new AndOrResult<ulong, IThat<ulong>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<ulong>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<float, IThat<float>>, float?> IsNotBetween(
+		this IThat<float> source,
+		float? minimum)
+		=> new(maximum => new AndOrResult<float, IThat<float>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<float>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<double, IThat<double>>, double?> IsNotBetween(
+		this IThat<double> source,
+		double? minimum)
+		=> new(maximum => new AndOrResult<double, IThat<double>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<double>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<decimal, IThat<decimal>>, decimal?> IsNotBetween(
+		this IThat<decimal> source,
+		decimal? minimum)
+		=> new(maximum => new AndOrResult<decimal, IThat<decimal>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new IsInRangeConstraint<decimal>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<byte?, IThat<byte?>>, byte?> IsNotBetween(
+		this IThat<byte?> source,
+		byte? minimum)
+		=> new(maximum => new AndOrResult<byte?, IThat<byte?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<byte>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<sbyte?, IThat<sbyte?>>, sbyte?> IsNotBetween(
+		this IThat<sbyte?> source,
+		sbyte? minimum)
+		=> new(maximum => new AndOrResult<sbyte?, IThat<sbyte?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<sbyte>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<short?, IThat<short?>>, short?> IsNotBetween(
+		this IThat<short?> source,
+		short? minimum)
+		=> new(maximum => new AndOrResult<short?, IThat<short?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<short>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<ushort?, IThat<ushort?>>, ushort?> IsNotBetween(
+		this IThat<ushort?> source,
+		ushort? minimum)
+		=> new(maximum => new AndOrResult<ushort?, IThat<ushort?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<ushort>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<int?, IThat<int?>>, int?> IsNotBetween(
+		this IThat<int?> source,
+		int? minimum)
+		=> new(maximum => new AndOrResult<int?, IThat<int?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<int>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<uint?, IThat<uint?>>, uint?> IsNotBetween(
+		this IThat<uint?> source,
+		uint? minimum)
+		=> new(maximum => new AndOrResult<uint?, IThat<uint?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<uint>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<long?, IThat<long?>>, long?> IsNotBetween(
+		this IThat<long?> source,
+		long? minimum)
+		=> new(maximum => new AndOrResult<long?, IThat<long?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<long>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<ulong?, IThat<ulong?>>, ulong?> IsNotBetween(
+		this IThat<ulong?> source,
+		ulong? minimum)
+		=> new(maximum => new AndOrResult<ulong?, IThat<ulong?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<ulong>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<float?, IThat<float?>>, float?> IsNotBetween(
+		this IThat<float?> source,
+		float? minimum)
+		=> new(maximum => new AndOrResult<float?, IThat<float?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<float>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<double?, IThat<double?>>, double?> IsNotBetween(
+		this IThat<double?> source,
+		double? minimum)
+		=> new(maximum => new AndOrResult<double?, IThat<double?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<double>(it, grammars, minimum, maximum).Invert()),
+			source));
+
+	/// <summary>
+	///     Verifies that the subject is not in the range between the <paramref name="minimum" />…
+	/// </summary>
+	public static BetweenResult<AndOrResult<decimal?, IThat<decimal?>>, decimal?> IsNotBetween(
+		this IThat<decimal?> source,
+		decimal? minimum)
+		=> new(maximum => new AndOrResult<decimal?, IThat<decimal?>>(source.Get().ExpectationBuilder
+				.AddConstraint((it, grammars) =>
+					new NullableIsInRangeConstraint<decimal>(it, grammars, minimum, maximum).Invert()),
+			source));
+
 	private sealed class IsInRangeConstraint<TNumber> : ConstraintResult.WithValue<TNumber>,
 		IValueConstraint<TNumber>
 		where TNumber : struct, IComparable<TNumber>
diff --git a/Tests/aweXpect.Api.Tests/Expected/aweXpect_net8.0.txt b/Tests/aweXpect.Api.Tests/Expected/aweXpect_net8.0.txt
index 1189b4733..5e64049d1 100644
--- a/Tests/aweXpect.Api.Tests/Expected/aweXpect_net8.0.txt
+++ b/Tests/aweXpect.Api.Tests/Expected/aweXpect_net8.0.txt
@@ -724,6 +724,10 @@ namespace aweXpect
             where TNumber :  struct, System.Numerics.INumber<TNumber> { }
         public static aweXpect.Results.AndOrResult<TNumber?, aweXpect.Core.IThat<TNumber?>> IsNegative<TNumber>(this aweXpect.Core.IThat<TNumber?> source)
             where TNumber :  struct, System.Numerics.INumber<TNumber> { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<TNumber, aweXpect.Core.IThat<TNumber>>, TNumber?> IsNotBetween<TNumber>(this aweXpect.Core.IThat<TNumber> source, TNumber? minimum)
+            where TNumber :  struct, System.Numerics.INumber<TNumber> { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<TNumber?, aweXpect.Core.IThat<TNumber?>>, TNumber?> IsNotBetween<TNumber>(this aweXpect.Core.IThat<TNumber?> source, TNumber? minimum)
+            where TNumber :  struct, System.Numerics.INumber<TNumber> { }
         public static aweXpect.Results.NumberToleranceResult<TNumber, aweXpect.Core.IThat<TNumber>> IsNotEqualTo<TNumber>(this aweXpect.Core.IThat<TNumber> source, TNumber? unexpected)
             where TNumber :  struct, System.Numerics.INumber<TNumber> { }
         public static aweXpect.Results.NullableNumberToleranceResult<TNumber, aweXpect.Core.IThat<TNumber?>> IsNotEqualTo<TNumber>(this aweXpect.Core.IThat<TNumber?> source, TNumber? unexpected)
diff --git a/Tests/aweXpect.Api.Tests/Expected/aweXpect_netstandard2.0.txt b/Tests/aweXpect.Api.Tests/Expected/aweXpect_netstandard2.0.txt
index 938dd8f57..70550e098 100644
--- a/Tests/aweXpect.Api.Tests/Expected/aweXpect_netstandard2.0.txt
+++ b/Tests/aweXpect.Api.Tests/Expected/aweXpect_netstandard2.0.txt
@@ -652,6 +652,28 @@ namespace aweXpect
         public static aweXpect.Results.AndOrResult<sbyte?, aweXpect.Core.IThat<sbyte?>> IsNegative(this aweXpect.Core.IThat<sbyte?> source) { }
         public static aweXpect.Results.AndOrResult<short, aweXpect.Core.IThat<short>> IsNegative(this aweXpect.Core.IThat<short> source) { }
         public static aweXpect.Results.AndOrResult<short?, aweXpect.Core.IThat<short?>> IsNegative(this aweXpect.Core.IThat<short?> source) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<byte, aweXpect.Core.IThat<byte>>, byte?> IsNotBetween(this aweXpect.Core.IThat<byte> source, byte? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<byte?, aweXpect.Core.IThat<byte?>>, byte?> IsNotBetween(this aweXpect.Core.IThat<byte?> source, byte? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<decimal, aweXpect.Core.IThat<decimal>>, decimal?> IsNotBetween(this aweXpect.Core.IThat<decimal> source, decimal? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<decimal?, aweXpect.Core.IThat<decimal?>>, decimal?> IsNotBetween(this aweXpect.Core.IThat<decimal?> source, decimal? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<double, aweXpect.Core.IThat<double>>, double?> IsNotBetween(this aweXpect.Core.IThat<double> source, double? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<double?, aweXpect.Core.IThat<double?>>, double?> IsNotBetween(this aweXpect.Core.IThat<double?> source, double? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<float, aweXpect.Core.IThat<float>>, float?> IsNotBetween(this aweXpect.Core.IThat<float> source, float? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<float?, aweXpect.Core.IThat<float?>>, float?> IsNotBetween(this aweXpect.Core.IThat<float?> source, float? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<int, aweXpect.Core.IThat<int>>, int?> IsNotBetween(this aweXpect.Core.IThat<int> source, int? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<int?, aweXpect.Core.IThat<int?>>, int?> IsNotBetween(this aweXpect.Core.IThat<int?> source, int? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<long, aweXpect.Core.IThat<long>>, long?> IsNotBetween(this aweXpect.Core.IThat<long> source, long? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<long?, aweXpect.Core.IThat<long?>>, long?> IsNotBetween(this aweXpect.Core.IThat<long?> source, long? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<sbyte, aweXpect.Core.IThat<sbyte>>, sbyte?> IsNotBetween(this aweXpect.Core.IThat<sbyte> source, sbyte? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<sbyte?, aweXpect.Core.IThat<sbyte?>>, sbyte?> IsNotBetween(this aweXpect.Core.IThat<sbyte?> source, sbyte? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<short, aweXpect.Core.IThat<short>>, short?> IsNotBetween(this aweXpect.Core.IThat<short> source, short? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<short?, aweXpect.Core.IThat<short?>>, short?> IsNotBetween(this aweXpect.Core.IThat<short?> source, short? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<uint, aweXpect.Core.IThat<uint>>, uint?> IsNotBetween(this aweXpect.Core.IThat<uint> source, uint? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<uint?, aweXpect.Core.IThat<uint?>>, uint?> IsNotBetween(this aweXpect.Core.IThat<uint?> source, uint? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<ulong, aweXpect.Core.IThat<ulong>>, ulong?> IsNotBetween(this aweXpect.Core.IThat<ulong> source, ulong? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<ulong?, aweXpect.Core.IThat<ulong?>>, ulong?> IsNotBetween(this aweXpect.Core.IThat<ulong?> source, ulong? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<ushort, aweXpect.Core.IThat<ushort>>, ushort?> IsNotBetween(this aweXpect.Core.IThat<ushort> source, ushort? minimum) { }
+        public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<ushort?, aweXpect.Core.IThat<ushort?>>, ushort?> IsNotBetween(this aweXpect.Core.IThat<ushort?> source, ushort? minimum) { }
         public static aweXpect.Results.NumberToleranceResult<byte, aweXpect.Core.IThat<byte>> IsNotEqualTo(this aweXpect.Core.IThat<byte> source, byte? unexpected) { }
         public static aweXpect.Results.NullableNumberToleranceResult<byte, aweXpect.Core.IThat<byte?>> IsNotEqualTo(this aweXpect.Core.IThat<byte?> source, byte? unexpected) { }
         public static aweXpect.Results.NumberToleranceResult<decimal, aweXpect.Core.IThat<decimal>> IsNotEqualTo(this aweXpect.Core.IThat<decimal> source, decimal? unexpected) { }
diff --git a/Tests/aweXpect.Tests/Numbers/ThatNumber.IsNotBetween.Tests.cs b/Tests/aweXpect.Tests/Numbers/ThatNumber.IsNotBetween.Tests.cs
new file mode 100644
index 000000000..7cbfd8781
--- /dev/null
+++ b/Tests/aweXpect.Tests/Numbers/ThatNumber.IsNotBetween.Tests.cs
@@ -0,0 +1,1268 @@
+﻿namespace aweXpect.Tests;
+
+public sealed partial class ThatNumber
+{
+	public sealed class IsNotBetween
+	{
+		public sealed class Tests
+		{
+			[Theory]
+			[InlineData(null, (byte)1)]
+			[InlineData((byte)1, null)]
+			public async Task ForByte_WhenMinimumOrMaximumIsNull_ShouldSucceed(byte? minimum, byte? maximum)
+			{
+				byte subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((byte)2, (byte)1, (byte)3)]
+			[InlineData((byte)2, (byte)2, (byte)4)]
+			[InlineData((byte)2, (byte)1, (byte)2)]
+			public async Task ForByte_WhenValueIsInRangeExpected_ShouldFail(byte subject,
+				byte? minimum, byte? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((byte)2, (byte)0, (byte)1)]
+			[InlineData((byte)0, (byte)1, (byte)2)]
+			public async Task ForByte_WhenValueIsOutsideTheRange_ShouldSucceed(byte subject,
+				byte? minimum, byte? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, 1.1)]
+			[InlineData(1.1, null)]
+			public async Task ForDecimal_WhenMinimumOrMaximumIsNull_ShouldSucceed(double? minimumValue,
+				double? maximumValue)
+			{
+				decimal subject = 2;
+				decimal? minimum = minimumValue is null ? null : new decimal(minimumValue.Value);
+				decimal? maximum = maximumValue is null ? null : new decimal(maximumValue.Value);
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2.0, 1.0, 3.0)]
+			[InlineData(2.0, 2.0, 4.0)]
+			[InlineData(2.0, 1.0, 2.0)]
+			public async Task ForDecimal_WhenValueIsInRangeExpected_ShouldFail(
+				double subjectValue, double expectedMinimum, double expectedMaximum)
+			{
+				decimal subject = new(subjectValue);
+				decimal? minimum = new(expectedMinimum);
+				decimal? maximum = new(expectedMaximum);
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData(2.0, 0.0, 1.9)]
+			[InlineData(0.0, 0.1, 2.0)]
+			public async Task ForDecimal_WhenValueIsOutsideTheRange_ShouldSucceed(
+				double subjectValue, double minimumValue, double maximumValue)
+			{
+				decimal subject = new(subjectValue);
+				decimal minimum = new(minimumValue);
+				decimal maximum = new(maximumValue);
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, 1.1)]
+			[InlineData(1.1, null)]
+			public async Task ForDouble_WhenMinimumOrMaximumIsNull_ShouldSucceed(double? minimum, double? maximum)
+			{
+				double subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2.0, 1.0, 3.0)]
+			[InlineData(2.0, 2.0, 4.0)]
+			[InlineData(2.0, 1.0, 2.0)]
+			public async Task ForDouble_WhenValueIsInRangeExpected_ShouldFail(
+				double subject, double minimum, double maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData(2.0, 0.0, 1.9)]
+			[InlineData(0.0, 0.1, 2.0)]
+			public async Task ForDouble_WhenValueIsOutsideTheRange_ShouldSucceed(
+				double subject, double minimum, double maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, 1.0F)]
+			[InlineData(1.0F, null)]
+			public async Task ForFloat_WhenMinimumOrMaximumIsNull_ShouldSucceed(float? minimum, float? maximum)
+			{
+				float subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((float)2.0, (float)1.0, (float)3.0)]
+			[InlineData((float)2.0, (float)2.0, (float)4.0)]
+			[InlineData((float)2.0, (float)1.0, (float)2.0)]
+			public async Task ForFloat_WhenValueIsInRangeExpected_ShouldFail(
+				float subject, float minimum, float maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((float)2.0, (float)0.0, (float)1.9)]
+			[InlineData((float)0.0, (float)0.1, (float)2.0)]
+			public async Task ForFloat_WhenValueIsOutsideTheRange_ShouldSucceed(
+				float subject, float minimum, float maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Fact]
+			public async Task ForInt_WhenMaximumIsSmallerThanMinimum_ShouldThrowArgumentOutOfRangeException()
+			{
+				int subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(2).And(1);
+
+				await That(Act).Throws<ArgumentOutOfRangeException>()
+					.WithParamName("maximum").And
+					.WithMessage("The maximum must be greater than or equal to the minimum.").AsPrefix();
+			}
+
+			[Theory]
+			[InlineData(null, 1)]
+			[InlineData(1, null)]
+			public async Task ForInt_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				int? minimum, int? maximum)
+			{
+				int subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2, 1, 3)]
+			[InlineData(2, 2, 4)]
+			[InlineData(2, 1, 2)]
+			public async Task ForInt_WhenValueIsInRangeExpected_ShouldFail(int subject,
+				int? minimum, int maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData(2, 0, 1)]
+			[InlineData(0, 1, 2)]
+			public async Task ForInt_WhenValueIsOutsideTheRange_ShouldSucceed(int subject,
+				int? minimum, int maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+#if NET8_0_OR_GREATER
+			[Theory]
+			[InlineData(null, 1)]
+			[InlineData(1, null)]
+			public async Task ForInt128_WhenMinimumOrMaximumIsNull_ShouldSucceed(int? minimumValue, int? maximumValue)
+			{
+				Int128 subject = 2;
+				Int128? minimum = minimumValue;
+				Int128? maximum = maximumValue;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+#endif
+
+#if NET8_0_OR_GREATER
+			[Theory]
+			[InlineData(2, 1, 3)]
+			[InlineData(2, 2, 4)]
+			[InlineData(2, 1, 2)]
+			public async Task ForInt128_WhenValueIsInRangeExpected_ShouldFail(
+				int subjectValue, int minimumValue, int maximumValue)
+			{
+				Int128 subject = subjectValue;
+				Int128? minimum = minimumValue;
+				Int128? maximum = maximumValue;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {Formatter.Format(minimum)} and {Formatter.Format(maximum)},
+					              but it was {Formatter.Format(subject)}
+					              """);
+			}
+#endif
+
+#if NET8_0_OR_GREATER
+			[Theory]
+			[InlineData(2, 0, 1)]
+			[InlineData(0, 1, 2)]
+			public async Task ForInt128_WhenValueIsOutsideTheRange_ShouldSucceed(
+				int subjectValue, int minimumValue, int maximumValue)
+			{
+				Int128 subject = subjectValue;
+				Int128? minimum = minimumValue;
+				Int128? maximum = maximumValue;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+#endif
+
+			[Theory]
+			[InlineData(null, (long)1)]
+			[InlineData((long)1, null)]
+			public async Task ForLong_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				long? minimum, long? maximum)
+			{
+				long subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((long)2, (long)1, (long)3)]
+			[InlineData((long)2, (long)2, (long)4)]
+			[InlineData((long)2, (long)1, (long)2)]
+			public async Task ForLong_WhenValueIsInRangeExpected_ShouldFail(long subject,
+				long? minimum, long maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((long)2, (long)0, (long)1)]
+			[InlineData((long)0, (long)1, (long)2)]
+			public async Task ForLong_WhenValueIsOutsideTheRange_ShouldSucceed(long subject,
+				long? minimum, long maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((byte)2, (byte)1, (byte)3)]
+			[InlineData((byte)2, (byte)2, (byte)4)]
+			[InlineData((byte)2, (byte)1, (byte)2)]
+			public async Task ForNullableByte_WhenValueIsInRangeExpected_ShouldFail(
+				byte? subject, byte? minimum, byte? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableByte_WhenValueIsNull_ShouldSucceed()
+			{
+				byte? subject = null;
+				byte minimum = 1;
+				byte maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((byte)2, (byte)0, (byte)1)]
+			[InlineData((byte)0, (byte)1, (byte)2)]
+			public async Task ForNullableByte_WhenValueIsOutsideTheRange_ShouldSucceed(
+				byte? subject, byte? minimum, byte? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, 1.1)]
+			[InlineData(1.1, null)]
+			public async Task ForNullableDecimal_WhenMinimumOrMaximumIsNull_ShouldSucceed(double? minimumValue,
+				double? maximumValue)
+			{
+				decimal subject = 2;
+				decimal? minimum = minimumValue == null ? null : new decimal(minimumValue.Value);
+				decimal? maximum = maximumValue == null ? null : new decimal(maximumValue.Value);
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2.0, 1.0, 3.0)]
+			[InlineData(2.0, 2.0, 4.0)]
+			[InlineData(2.0, 1.0, 2.0)]
+			public async Task ForNullableDecimal_WhenValueIsInRangeExpected_ShouldFail(
+				double? subjectValue, double? minimumValue, double? maximumValue)
+			{
+				decimal? subject = subjectValue == null ? null : new decimal(subjectValue.Value);
+				decimal? minimum = minimumValue == null ? null : new decimal(minimumValue.Value);
+				decimal? maximum = maximumValue == null ? null : new decimal(maximumValue.Value);
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData(2.0, 0.0, 1.9)]
+			[InlineData(0.0, 0.1, 2.0)]
+			public async Task ForNullableDecimal_WhenValueIsOutsideTheRange_ShouldSucceed(
+				double? subjectValue, double? minimumValue, double? maximumValue)
+			{
+				decimal? subject = subjectValue == null ? null : new decimal(subjectValue.Value);
+				decimal? minimum = minimumValue == null ? null : new decimal(minimumValue.Value);
+				decimal? maximum = maximumValue == null ? null : new decimal(maximumValue.Value);
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, 1.1)]
+			[InlineData(1.1, null)]
+			public async Task ForNullableDouble_WhenMinimumOrMaximumIsNull_ShouldSucceed(double? minimum,
+				double? maximum)
+			{
+				double subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2.0, 1.0, 3.0)]
+			[InlineData(2.0, 2.0, 4.0)]
+			[InlineData(2.0, 1.0, 2.0)]
+			public async Task ForNullableDouble_WhenValueIsInRangeExpected_ShouldFail(
+				double? subject, double? minimum, double? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData(2.0, 0.0, 1.9)]
+			[InlineData(0.0, 0.1, 2.0)]
+			public async Task ForNullableDouble_WhenValueIsOutsideTheRange_ShouldSucceed(
+				double? subject, double? minimum, double? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, 1.1F)]
+			[InlineData(1.1F, null)]
+			public async Task ForNullableFloat_WhenMinimumOrMaximumIsNull_ShouldSucceed(float? minimum, float? maximum)
+			{
+				float subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((float)2.0, (float)1.0, (float)3.0)]
+			[InlineData((float)2.0, (float)2.0, (float)4.0)]
+			[InlineData((float)2.0, (float)1.0, (float)2.0)]
+			public async Task ForNullableFloat_WhenValueIsInRangeExpected_ShouldFail(
+				float? subject, float? minimum, float? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((float)2.0, (float)0.0, (float)1.9)]
+			[InlineData((float)0.0, (float)0.1, (float)2.0)]
+			public async Task ForNullableFloat_WhenValueIsOutsideTheRange_ShouldSucceed(
+				float? subject, float? minimum, float? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Fact]
+			public async Task ForNullableInt_WhenMaximumIsSmallerThanMinimum_ShouldThrowArgumentOutOfRangeException()
+			{
+				int? subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(2).And(1);
+
+				await That(Act).Throws<ArgumentOutOfRangeException>()
+					.WithParamName("maximum").And
+					.WithMessage("The maximum must be greater than or equal to the minimum.").AsPrefix();
+			}
+
+			[Theory]
+			[InlineData(null, 1)]
+			[InlineData(1, null)]
+			public async Task ForNullableInt_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				int? minimum, int? maximum)
+			{
+				int? subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2, 1, 3)]
+			[InlineData(2, 2, 4)]
+			[InlineData(2, 1, 2)]
+			public async Task ForNullableInt_WhenValueIsInRangeExpected_ShouldFail(
+				int? subject, int? minimum, int? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableInt_WhenValueIsNull_ShouldSucceed()
+			{
+				int? subject = null;
+				int minimum = 1;
+				int maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2, 0, 1)]
+			[InlineData(0, 1, 2)]
+			public async Task ForNullableInt_WhenValueIsOutsideTheRange_ShouldSucceed(
+				int? subject, int? minimum, int? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+#if NET8_0_OR_GREATER
+			[Theory]
+			[InlineData(null, 1)]
+			[InlineData(1, null)]
+			public async Task ForNullableInt128_WhenMinimumOrMaximumIsNull_ShouldSucceed(int? minimumValue,
+				int? maximumValue)
+			{
+				Int128? subject = 2;
+				Int128? minimum = minimumValue;
+				Int128? maximum = maximumValue;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+#endif
+
+#if NET8_0_OR_GREATER
+			[Theory]
+			[InlineData(2, 1, 3)]
+			[InlineData(2, 2, 4)]
+			[InlineData(2, 1, 2)]
+			public async Task ForNullableInt128_WhenValueIsInRangeExpected_ShouldFail(
+				int? subjectValue, int? minimumValue, int? maximumValue)
+			{
+				Int128? subject = subjectValue;
+				Int128? minimum = minimumValue;
+				Int128? maximum = maximumValue;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {Formatter.Format(minimum)} and {Formatter.Format(maximum)},
+					              but it was {Formatter.Format(subject)}
+					              """);
+			}
+#endif
+
+#if NET8_0_OR_GREATER
+			[Theory]
+			[InlineData(2, 0, 1)]
+			[InlineData(0, 1, 2)]
+			public async Task ForNullableInt128_WhenValueIsOutsideTheRange_ShouldSucceed(
+				int? subjectValue, int? minimumValue, int? maximumValue)
+			{
+				Int128? subject = subjectValue;
+				Int128? minimum = minimumValue;
+				Int128? maximum = maximumValue;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+#endif
+
+			[Theory]
+			[InlineData(null, (long)1)]
+			[InlineData((long)1, null)]
+			public async Task ForNullableLong_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				long? minimum, long? maximum)
+			{
+				long? subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((long)2, (long)1, (long)3)]
+			[InlineData((long)2, (long)2, (long)4)]
+			[InlineData((long)2, (long)1, (long)2)]
+			public async Task ForNullableLong_WhenValueIsInRangeExpected_ShouldFail(
+				long? subject, long? minimum, long? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableLong_WhenValueIsNull_ShouldSucceed()
+			{
+				long? subject = null;
+				long minimum = 1;
+				long maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((long)2, (long)0, (long)1)]
+			[InlineData((long)0, (long)1, (long)2)]
+			public async Task ForNullableLong_WhenValueIsOutsideTheRange_ShouldSucceed(
+				long? subject, long? minimum, long? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((sbyte)2, (sbyte)1, (sbyte)3)]
+			[InlineData((sbyte)2, (sbyte)2, (sbyte)4)]
+			[InlineData((sbyte)2, (sbyte)1, (sbyte)2)]
+			public async Task ForNullableSbyte_WhenValueIsInRangeExpected_ShouldFail(
+				sbyte? subject, sbyte? minimum, sbyte? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableSbyte_WhenValueIsNull_ShouldSucceed()
+			{
+				sbyte? subject = null;
+				sbyte minimum = 1;
+				sbyte maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((sbyte)2, (sbyte)0, (sbyte)1)]
+			[InlineData((sbyte)0, (sbyte)1, (sbyte)2)]
+			public async Task ForNullableSbyte_WhenValueIsOutsideTheRange_ShouldSucceed(
+				sbyte? subject, sbyte? minimum, sbyte? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((short)2, (short)1, (short)3)]
+			[InlineData((short)2, (short)2, (short)4)]
+			[InlineData((short)2, (short)1, (short)2)]
+			public async Task ForNullableShort_WhenValueIsInRangeExpected_ShouldFail(
+				short? subject, short? minimum, short? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableShort_WhenValueIsNull_ShouldSucceed()
+			{
+				short? subject = null;
+				short minimum = 1;
+				short maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((short)2, (short)0, (short)1)]
+			[InlineData((short)0, (short)1, (short)2)]
+			public async Task ForNullableShort_WhenValueIsOutsideTheRange_ShouldSucceed(
+				short? subject, short? minimum, short? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((uint)2, (uint)1, (uint)3)]
+			[InlineData((uint)2, (uint)2, (uint)4)]
+			[InlineData((uint)2, (uint)1, (uint)2)]
+			public async Task ForNullableUint_WhenValueIsInRangeExpected_ShouldFail(
+				uint? subject, uint? minimum, uint maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableUint_WhenValueIsNull_ShouldSucceed()
+			{
+				uint? subject = null;
+				uint minimum = 1;
+				uint maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((uint)2, (uint)0, (uint)1)]
+			[InlineData((uint)0, (uint)1, (uint)2)]
+			public async Task ForNullableUint_WhenValueIsOutsideTheRange_ShouldSucceed(
+				uint? subject, uint? minimum, uint maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((ulong)2, (ulong)1, (ulong)3)]
+			[InlineData((ulong)2, (ulong)2, (ulong)4)]
+			[InlineData((ulong)2, (ulong)1, (ulong)2)]
+			public async Task ForNullableUlong_WhenValueIsInRangeExpected_ShouldFail(
+				ulong? subject, ulong? minimum, ulong? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableUlong_WhenValueIsNull_ShouldSucceed()
+			{
+				ulong? subject = null;
+				ulong minimum = 1;
+				ulong maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((ulong)2, (ulong)0, (ulong)1)]
+			[InlineData((ulong)0, (ulong)1, (ulong)2)]
+			public async Task ForNullableUlong_WhenValueIsOutsideTheRange_ShouldSucceed(
+				ulong? subject, ulong? minimum, ulong? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((ushort)2, (ushort)1, (ushort)3)]
+			[InlineData((ushort)2, (ushort)2, (ushort)4)]
+			[InlineData((ushort)2, (ushort)1, (ushort)2)]
+			public async Task ForNullableUshort_WhenValueIsInRangeExpected_ShouldFail(
+				ushort? subject, ushort? minimum, ushort? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Fact]
+			public async Task ForNullableUshort_WhenValueIsNull_ShouldSucceed()
+			{
+				ushort? subject = null;
+				ushort minimum = 1;
+				ushort maximum = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((ushort)2, (ushort)0, (ushort)1)]
+			[InlineData((ushort)0, (ushort)1, (ushort)2)]
+			public async Task ForNullableUshort_WhenValueIsOutsideTheRange_ShouldSucceed(
+				ushort? subject, ushort? minimum, ushort? maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, (sbyte)1)]
+			[InlineData((sbyte)1, null)]
+			public async Task ForSbyte_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				sbyte? minimum, sbyte? maximum)
+			{
+				sbyte subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((sbyte)2, (sbyte)1, (sbyte)3)]
+			[InlineData((sbyte)2, (sbyte)2, (sbyte)4)]
+			[InlineData((sbyte)2, (sbyte)1, (sbyte)2)]
+			public async Task ForSbyte_WhenValueIsInRangeExpected_ShouldFail(sbyte subject,
+				sbyte? minimum, sbyte maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((sbyte)2, (sbyte)0, (sbyte)1)]
+			[InlineData((sbyte)0, (sbyte)1, (sbyte)2)]
+			public async Task ForSbyte_WhenValueIsOutsideTheRange_ShouldSucceed(sbyte subject,
+				sbyte? minimum, sbyte maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, (short)1)]
+			[InlineData((short)1, null)]
+			public async Task ForShort_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				short? minimum, short? maximum)
+			{
+				short subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((short)2, (short)1, (short)3)]
+			[InlineData((short)2, (short)2, (short)4)]
+			[InlineData((short)2, (short)1, (short)2)]
+			public async Task ForShort_WhenValueIsInRangeExpected_ShouldFail(short subject,
+				short? minimum, short maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((short)2, (short)0, (short)1)]
+			[InlineData((short)0, (short)1, (short)2)]
+			public async Task ForShort_WhenValueIsOutsideTheRange_ShouldSucceed(short subject,
+				short? minimum, short maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, (uint)1)]
+			[InlineData((uint)1, null)]
+			public async Task ForUint_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				uint? minimum, uint? maximum)
+			{
+				uint subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((uint)2, (uint)1, (uint)3)]
+			[InlineData((uint)2, (uint)2, (uint)4)]
+			[InlineData((uint)2, (uint)1, (uint)2)]
+			public async Task ForUint_WhenValueIsInRangeExpected_ShouldFail(uint subject,
+				uint? minimum, uint maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((uint)2, (uint)0, (uint)1)]
+			[InlineData((uint)0, (uint)1, (uint)2)]
+			public async Task ForUint_WhenValueIsOutsideTheRange_ShouldSucceed(uint subject,
+				uint? minimum, uint maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, (ulong)1)]
+			[InlineData((ulong)1, null)]
+			public async Task ForUlong_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				ulong? minimum, ulong? maximum)
+			{
+				ulong subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((ulong)2, (ulong)1, (ulong)3)]
+			[InlineData((ulong)2, (ulong)2, (ulong)4)]
+			[InlineData((ulong)2, (ulong)1, (ulong)2)]
+			public async Task ForUlong_WhenValueIsInRangeExpected_ShouldFail(ulong subject,
+				ulong? minimum, ulong maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((ulong)2, (ulong)0, (ulong)1)]
+			[InlineData((ulong)0, (ulong)1, (ulong)2)]
+			public async Task ForUlong_WhenValueIsOutsideTheRange_ShouldSucceed(ulong subject,
+				ulong? minimum, ulong maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(null, (ushort)1)]
+			[InlineData((ushort)1, null)]
+			public async Task ForUshort_WhenMinimumOrMaximumIsNull_ShouldSucceed(
+				ushort? minimum, ushort? maximum)
+			{
+				ushort subject = 2;
+
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData((ushort)2, (ushort)1, (ushort)3)]
+			[InlineData((ushort)2, (ushort)2, (ushort)4)]
+			[InlineData((ushort)2, (ushort)1, (ushort)2)]
+			public async Task ForUshort_WhenValueIsInRangeExpected_ShouldFail(
+				ushort subject,
+				ushort? minimum, ushort maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is not between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData((ushort)2, (ushort)0, (ushort)1)]
+			[InlineData((ushort)0, (ushort)1, (ushort)2)]
+			public async Task ForUshort_WhenValueIsOutsideTheRange_ShouldSucceed(ushort subject,
+				ushort? minimum, ushort maximum)
+			{
+				async Task Act()
+					=> await That(subject).IsNotBetween(minimum).And(maximum);
+
+				await That(Act).DoesNotThrow();
+			}
+		}
+
+		public sealed class NegatedTests
+		{
+			[Theory]
+			[InlineData(null, 1)]
+			[InlineData(1, null)]
+			public async Task ForInt_WhenMinimumOrMaximumIsNull_ShouldFail(
+				int? minimum, int? maximum)
+			{
+				int subject = 2;
+
+				async Task Act()
+					=> await That(subject).DoesNotComplyWith(it
+						=> it.IsNotBetween(minimum).And(maximum));
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+
+			[Theory]
+			[InlineData(2, 1, 3)]
+			[InlineData(2, 2, 4)]
+			[InlineData(2, 1, 2)]
+			public async Task ForInt_WhenValueIsInRangeExpected_ShouldSucceed(int subject,
+				int? minimum, int maximum)
+			{
+				async Task Act()
+					=> await That(subject).DoesNotComplyWith(it
+						=> it.IsNotBetween(minimum).And(maximum));
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2, 0, 1)]
+			[InlineData(0, 1, 2)]
+			public async Task ForInt_WhenValueIsOutsideTheRange_ShouldFail(int subject,
+				int? minimum, int maximum)
+			{
+				async Task Act()
+					=> await That(subject).DoesNotComplyWith(it
+						=> it.IsNotBetween(minimum).And(maximum));
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+			[Theory]
+			[InlineData(null, 1)]
+			[InlineData(1, null)]
+			public async Task ForNullableInt_WhenMinimumIsNull_ShouldFail(
+				int? minimum, int? maximum)
+			{
+				int subject = 2;
+
+				async Task Act()
+					=> await That(subject).DoesNotComplyWith(it
+						=> it.IsNotBetween(minimum).And(maximum));
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+
+
+			[Theory]
+			[InlineData(2, 1, 3)]
+			[InlineData(2, 2, 4)]
+			[InlineData(2, 1, 2)]
+			public async Task ForNullableInt_WhenValueIsInRangeExpected_ShouldSucceed(int? subject,
+				int? minimum, int maximum)
+			{
+				async Task Act()
+					=> await That(subject).DoesNotComplyWith(it
+						=> it.IsNotBetween(minimum).And(maximum));
+
+				await That(Act).DoesNotThrow();
+			}
+
+			[Theory]
+			[InlineData(2, 0, 1)]
+			[InlineData(0, 1, 2)]
+			public async Task ForNullableInt_WhenValueIsOutsideTheRange_ShouldFail(int? subject,
+				int? minimum, int maximum)
+			{
+				async Task Act()
+					=> await That(subject).DoesNotComplyWith(it
+						=> it.IsNotBetween(minimum).And(maximum));
+
+				await That(Act).Throws<XunitException>()
+					.WithMessage($"""
+					              Expected that subject
+					              is between {ValueFormatters.Format(Formatter, minimum)} and {ValueFormatters.Format(Formatter, maximum)},
+					              but it was {ValueFormatters.Format(Formatter, subject)}
+					              """);
+			}
+		}
+	}
+}


Reviews:
user: login: copilot-pull-request-reviewer[bot]
body: ## Pull Request Overview

Adds “IsNotBetween” assertion methods to the aweXpect API so callers can verify a value is outside a given range.

- Introduces `IsNotBetween` overloads for each built-in numeric type in the .NET Standard 2.0 build
- Adds generic `IsNotBetween<TNumber>` extensions for any `INumber<TNumber>` in the .NET 8.0 build
- Tweaks the XML summary on the existing `IsBetween` method for a minor grammar improvement

### Reviewed Changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 3 comments.

| File                                            | Description                                                      |
| ----------------------------------------------- | ---------------------------------------------------------------- |
| Tests/.../aweXpect_netstandard2.0.txt           | Updated expected API surface to include `IsNotBetween` overloads |
| Tests/.../aweXpect_net8.0.txt                   | Added generic `IsNotBetween<TNumber>` to the .NET 8.0 expected API|
| Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs | Added both generic and concrete `IsNotBetween` implementations; minor XML doc change|


<details>
<summary>Comments suppressed due to low confidence (1)</summary>

**Tests/aweXpect.Api.Tests/Expected/aweXpect_netstandard2.0.txt:655**
* The expected API surface now includes `IsNotBetween`, but there are no new unit tests verifying its behavior. Add tests to cover both boundary conditions and typical usage for each overload.
```
public static aweXpect.Results.BetweenResult<aweXpect.Results.AndOrResult<byte, aweXpect.Core.IThat<byte>>, byte?> IsNotBetween(this aweXpect.Core.IThat<byte> source, byte? minimum) { }
```
</details>


state: COMMENTED
author_association: NONE
submitted_at: 2025-05-20T15:48:30Z

Review comments:
diff_hunk: @@ -32,6 +32,28 @@ public static partial class ThatNumber
 			source.Get().ExpectationBuilder.AddConstraint((it, grammars) =>
 				new NullableIsInRangeConstraint<TNumber>(it, grammars, minimum, maximum)),
 			source));
+	
+	/// <summary>
+	///     Verifies that the subject is not between the <paramref name="minimum" />…
path: Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs
user: login: Copilot
body: The `<summary>` for `IsNotBetween` only mentions the `minimum` parameter. It should also reference `maximum` so both bounds are documented, matching the generic `IsBetween` summary pattern.
```suggestion
	///     Verifies that the subject is not between the <paramref name="minimum" /> and <paramref name="maximum" />.
```
created_at: 2025-05-20T15:48:30Z
author_association: NONE
diff_hunk: @@ -395,6 +417,249 @@ protected override void AppendNegatedResult(StringBuilder stringBuilder, string?
 					new NullableIsInRangeConstraint<decimal>(it, grammars, minimum, maximum)),
 			source));
 
+	
path: Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs
user: login: Copilot
body: [nitpick] There’s a large block of repeated `IsNotBetween` overloads for each primitive type. Consider using conditional compilation to include these only on pre-.NET 8 targets (or remove them entirely when the generic `INumber<T>` overload is available) to reduce duplication and avoid potential overload ambiguities.
```suggestion
	
#if !NET8_0_OR_GREATER
```
created_at: 2025-05-20T15:48:30Z
author_association: NONE
diff_hunk: @@ -12,7 +12,7 @@ public static partial class ThatNumber
 {
 #if NET8_0_OR_GREATER
 	/// <summary>
-	///     Verifies that the subject is between <paramref name="minimum" />…
+	///     Verifies that the subject is between the <paramref name="minimum" />…
path: Source/aweXpect/That/Numbers/ThatNumber.IsBetween.cs
user: login: Copilot
body: [nitpick] The XML comment was edited to insert “the” before `<paramref>`—either remove the extra article or apply it consistently across all similar summaries to maintain style consistency.
created_at: 2025-05-20T15:48:30Z
author_association: NONE

PR comments:
user: login: sonarqubecloud[bot]
created_at: 2025-05-20T15:53:40Z
body: ## [![Quality Gate Passed](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/checks/QualityGateBadge/qg-passed-20px.png 'Quality Gate Passed')](https://sonarcloud.io/dashboard?id=aweXpect_aweXpect&pullRequest=624) **Quality Gate passed**  
Issues  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0 New issues](https://sonarcloud.io/project/issues?id=aweXpect_aweXpect&pullRequest=624&issueStatuses=OPEN,CONFIRMED&sinceLeakPeriod=true)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/accepted-16px.png '') [0 Accepted issues](https://sonarcloud.io/project/issues?id=aweXpect_aweXpect&pullRequest=624&issueStatuses=ACCEPTED)

Measures  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0 Security Hotspots](https://sonarcloud.io/project/security_hotspots?id=aweXpect_aweXpect&pullRequest=624&issueStatuses=OPEN,CONFIRMED&sinceLeakPeriod=true)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [100.0% Coverage on New Code](https://sonarcloud.io/component_measures?id=aweXpect_aweXpect&pullRequest=624&metric=new_coverage&view=list)  
![](https://sonarsource.github.io/sonarcloud-github-static-resources/v2/common/passed-16px.png '') [0.0% Duplication on New Code](https://sonarcloud.io/component_measures?id=aweXpect_aweXpect&pullRequest=624&metric=new_duplicated_lines_density&view=list)  
  
[See analysis details on SonarQube Cloud](https://sonarcloud.io/dashboard?id=aweXpect_aweXpect&pullRequest=624)


author_association: NONE
user: login: github-actions[bot]
created_at: 2025-05-20T15:54:44Z
body: ## Test Results
    14 files   -  24      14 suites   - 24   2m 25s ⏱️ -1s
10 908 tests +156  10 906 ✅ +156  2 💤 ±0  0 ❌ ±0 
29 766 runs  +468  29 764 ✅ +468  2 💤 ±0  0 ❌ ±0 

Results for commit 6982f276. ± Comparison against base commit 9006a8c5.

<details>
  <summary>This pull request <b>removes</b> 1370 and <b>adds</b> 1526 tests. <i>Note that renamed tests count towards both.</i></summary>

```
aweXpect.Core.Tests.Core.Exceptions.FailExceptionTests ‑ Message_ShouldBeSet(message: "message5f01a3f0-17ed-423e-b9d2-93c37513a518")
aweXpect.Core.Tests.Core.Exceptions.FailExceptionTests ‑ Message_ShouldBeSet(message: "message7f5bf581-2ce4-4d8c-b4d2-5cfe4a7fcb07")
aweXpect.Core.Tests.Core.Exceptions.FailExceptionTests ‑ Message_ShouldBeSet(message: "message816c43c4-96a9-44f8-ab0c-14fcd821dcdd")
aweXpect.Core.Tests.Core.Exceptions.SkipExceptionTests ‑ Message_ShouldBeSet(message: "message3ff47db4-a61b-46bc-9731-0f416417d0b1")
aweXpect.Core.Tests.Core.Exceptions.SkipExceptionTests ‑ Message_ShouldBeSet(message: "message5acae9b3-8c2c-46c7-be8f-ebfc2c9f02c9")
aweXpect.Core.Tests.Core.Exceptions.SkipExceptionTests ‑ Message_ShouldBeSet(message: "messaged664b51d-1ef8-4ae8-9b22-0de8b74e36a1")
aweXpect.Core.Tests.Equivalency.EquivalencyOptionsExtensionsTests ‑ Generic_For_IgnoringMember_ShouldSetOptionForType(memberToIgnore: "memberToIgnore2a14e39b-8e99-47e8-b4fd-88233ce0df8b")
aweXpect.Core.Tests.Equivalency.EquivalencyOptionsExtensionsTests ‑ Generic_For_IgnoringMember_ShouldSetOptionForType(memberToIgnore: "memberToIgnoreec175666-9cd8-40a6-a557-2932cca54a60")
aweXpect.Core.Tests.Equivalency.EquivalencyOptionsExtensionsTests ‑ Generic_For_IgnoringMember_ShouldSetOptionForType(memberToIgnore: "memberToIgnorefb58df76-8778-4fa7-9fc3-3ac0032dd760")
aweXpect.Core.Tests.FailTests ‑ Test_ShouldThrowException(reason: "reason1387fe69-3cc0-4405-9618-a4257c50ab41")
…
```

```
aweXpect.Core.Tests.Core.Exceptions.FailExceptionTests ‑ Message_ShouldBeSet(message: "message39f3bc08-4103-4bf2-84fb-fe3d340b510e")
aweXpect.Core.Tests.Core.Exceptions.FailExceptionTests ‑ Message_ShouldBeSet(message: "message6f398b2f-87cc-4bad-b374-ca31f78339a7")
aweXpect.Core.Tests.Core.Exceptions.FailExceptionTests ‑ Message_ShouldBeSet(message: "message97f99942-d0a3-4b2e-885f-bd5bd97f73c2")
aweXpect.Core.Tests.Core.Exceptions.SkipExceptionTests ‑ Message_ShouldBeSet(message: "message019912e2-3973-4d2e-9cca-acdac140fd32")
aweXpect.Core.Tests.Core.Exceptions.SkipExceptionTests ‑ Message_ShouldBeSet(message: "messageca0d11d2-bc9b-4a34-b7bb-7a42933673b6")
aweXpect.Core.Tests.Core.Exceptions.SkipExceptionTests ‑ Message_ShouldBeSet(message: "messagee3a95444-a6f0-4862-8b35-7403e36d54c2")
aweXpect.Core.Tests.Equivalency.EquivalencyOptionsExtensionsTests ‑ Generic_For_IgnoringMember_ShouldSetOptionForType(memberToIgnore: "memberToIgnore76e43cb3-5c07-48d7-a954-8e86b621ec90")
aweXpect.Core.Tests.Equivalency.EquivalencyOptionsExtensionsTests ‑ Generic_For_IgnoringMember_ShouldSetOptionForType(memberToIgnore: "memberToIgnored1c4b72f-7bdb-4f18-8bdc-4426f337f978")
aweXpect.Core.Tests.Equivalency.EquivalencyOptionsExtensionsTests ‑ Generic_For_IgnoringMember_ShouldSetOptionForType(memberToIgnore: "memberToIgnorefd140f1a-2212-4c17-ae3a-ab1c11cb2b91")
aweXpect.Core.Tests.FailTests ‑ Test_ShouldThrowException(reason: "reason1c09baa7-6e8a-47ed-be46-bed34aa52097")
…
```
</details>

[test-results]:data:application/gzip;base64,H4sIAMGlLGgC/03MSw6DIBSF4a0Yxh3AFS7QzTSIkJD6aBBGTfdeJCoO/+8k50t8mNxGnh3jj45sOaRWY44mhXWpLQqULdWVaqrOfm3Z2gOx4Tt8CsIF3oSpAL3AxbjGQ2Je9l/QEvHI83Y3fll7rX07rX3/tOs8h1SCoFbgQaLlrncMJVPCGw2jE6YXINVAOR9gRPL7AyOksh0PAQAA

author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-05-20T15:57:05Z
body: ## :rocket: Benchmark Results
<details>
<summary>Details</summary>
<pre>

BenchmarkDotNet v0.14.0, Ubuntu 24.04.2 LTS (Noble Numbat)
AMD EPYC 7763, 1 CPU, 4 logical and 2 physical cores
.NET SDK 8.0.409
  [Host] : .NET 8.0.16 (8.0.1625.21506), X64 RyuJIT AVX2

Job=InProcess  Toolchain=InProcessEmitToolchain  IterationCount=15  
LaunchCount=1  WarmupCount=10  

</pre>
</details>

| Method                                 | Mean           | Error        | StdDev       | Gen0     | Gen1    | Allocated |
|--------------------------------------- |---------------:|-------------:|-------------:|---------:|--------:|----------:|
| **Bool_aweXpect** | **174.6 ns** | **0.86 ns** | **0.72 ns** | **0.0281** | **-** | **472 B** |
| Bool_FluentAssertions                  |       244.9 ns |      3.66 ns |      3.24 ns |   0.0567 |       - |     952 B |
| Bool_TUnit                             |       901.2 ns |      2.72 ns |      2.27 ns |   0.1440 |       - |    2416 B |
| **Equivalency_aweXpect** | **288,300.8 ns** | **862.08 ns** | **764.21 ns** | **16.6016** | **0.4883** | **284940 B** |
| Equivalency_FluentAssertions           | 2,182,485.7 ns | 15,898.05 ns | 14,093.21 ns | 273.4375 | 46.8750 | 4584416 B |
| Equivalency_TUnit                      |   669,329.1 ns |  3,386.61 ns |  3,167.84 ns |  51.7578 |  2.9297 |  866777 B |
| **Int_GreaterThan_aweXpect** | **214.2 ns** | **1.28 ns** | **1.19 ns** | **0.0467** | **-** | **784 B** |
| Int_GreaterThan_FluentAssertions       |       251.5 ns |      3.23 ns |      3.02 ns |   0.0730 |       - |    1224 B |
| Int_GreaterThan_TUnit                  |     1,251.0 ns |      7.19 ns |      6.72 ns |   0.1774 |       - |    2992 B |
| **ItemsCount_AtLeast_aweXpect** | **434.2 ns** | **1.63 ns** | **1.44 ns** | **0.0830** | **-** | **1392 B** |
| ItemsCount_AtLeast_FluentAssertions    |       473.9 ns |      2.86 ns |      2.39 ns |   0.1197 |       - |    2008 B |
| ItemsCount_AtLeast_TUnit               |    21,545.1 ns |     92.20 ns |     86.24 ns |   1.6174 |       - |   27488 B |
| **String_aweXpect** | **343.4 ns** | **2.47 ns** | **2.31 ns** | **0.0672** | **-** | **1128 B** |
| String_FluentAssertions                |       473.1 ns |      2.93 ns |      2.45 ns |   0.1292 |       - |    2168 B |
| String_TUnit                           |     1,294.0 ns |      9.90 ns |      9.26 ns |   0.1850 |       - |    3096 B |
| **StringArray_aweXpect** | **1,132.5 ns** | **5.42 ns** | **4.80 ns** | **0.1202** | **-** | **2024 B** |
| StringArray_FluentAssertions           |     1,269.3 ns |      4.59 ns |      4.07 ns |   0.2480 |       - |    4152 B |
| StringArray_TUnit                      |     2,793.0 ns |     14.85 ns |     13.89 ns |   0.2708 |       - |    4576 B |
| **StringArrayInAnyOrder_aweXpect** | **1,249.7 ns** | **5.60 ns** | **5.24 ns** | **0.1297** | **-** | **2184 B** |
| StringArrayInAnyOrder_FluentAssertions |   151,708.0 ns |    912.98 ns |    854.00 ns |   3.4180 |       - |   64323 B |
| StringArrayInAnyOrder_TUnit            |     4,567.5 ns |     34.77 ns |     32.52 ns |   0.3967 |       - |    6744 B |

author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-05-20T15:57:26Z
body: ## :alien: Mutation Results
[![Mutation testing badge](https://img.shields.io/endpoint?style=flat&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2FaweXpect%2FaweXpect%2Fpull/624/merge)](https://dashboard.stryker-mutator.io/reports/github.com/aweXpect/aweXpect/pull/624/merge)

### aweXpect
<details>
<summary>Details</summary>

| File                                                                | Score  | Killed | Survived | Timeout | No Coverage | Ignored | Compile Errors | Total Detected | Total Undetected | Total Mutants |
| ------------------------------------------------------------------- | ------ | ------ | -------- | ------- | ----------- | ------- | -------------- | -------------- | ---------------- | ------------- |
| That\/Numbers\/ThatNumber.IsBetween.cs                              | 90.16% | 55     | 6        | 0       | 0           | 12      | 0              | 55             | 6                | 73            |

</details>

#### The final mutation score is 90.16%
##### *Coverage Thresholds: high:80 low:60 break:0*

### aweXpect.Core
<details>
<summary>Details</summary>

| File                                                                          | Score | Killed | Survived | Timeout | No Coverage | Ignored | Compile Errors | Total Detected | Total Undetected | Total Mutants |
| ----------------------------------------------------------------------------- | ----- | ------ | -------- | ------- | ----------- | ------- | -------------- | -------------- | ---------------- | ------------- |

</details>

#### The final mutation score is NaN%
##### *Coverage Thresholds: high:80 low:60 break:0*

author_association: CONTRIBUTOR
user: login: github-actions[bot]
created_at: 2025-05-21T04:05:37Z
body: This is addressed in release [v2.14.0](https://github.com/aweXpect/aweXpect/releases/tag/v2.14.0).
author_association: CONTRIBUTOR