public static RangeClusivity Combine(Clusivity min, Clusivity max)
{
switch (min)
{
case Clusivity.Exclusive:
switch (max)
{
case Clusivity.Exclusive: return(RangeClusivity.Exclusive);
case Clusivity.Inclusive: return(RangeClusivity.InclusiveMax);
default: throw InvalidEnumArgument.CreateException(nameof(max), max);
}
case Clusivity.Inclusive:
switch (max)
{
case Clusivity.Exclusive: return(RangeClusivity.InclusiveMin);
case Clusivity.Inclusive: return(RangeClusivity.Inclusive);
default: throw InvalidEnumArgument.CreateException(nameof(max), max);
}
default: throw InvalidEnumArgument.CreateException(nameof(min), min);
}
}
public bool Contains(float value, Clusivity clusivity = Clusivity.Inclusive)
{
if (clusivity == Clusivity.Inclusive)
{
return(value >= minimum && value <= maximum);
}
return(value > minimum && value < maximum);
}
public ApproximationConstraint(
object expectedValue,
object threshold,
Clusivity clusivity = Clusivity.Inclusive
) : this(
expectedValue,
threshold,
clusivity,
clusivity
)
{
}
public ApproximationConstraint(
object expectedValue,
object threshold,
Clusivity minClusivity,
Clusivity maxClusivity
) : base(
(IComparable)Coercively.Subtract(expectedValue, threshold),
(IComparable)Coercively.Add(expectedValue, threshold)
)
{
ExpectedValue = expectedValue;
Threshold = threshold;
MinValue = Coercively.Subtract(ExpectedValue, Threshold);
MaxValue = Coercively.Add(ExpectedValue, Threshold);
MinClusivity = minClusivity;
MaxClusivity = maxClusivity;
}
public void ApproximationConstraint(
[ValueSource(typeof(PrimitiveUtils), nameof(PrimitiveUtils.NumericTypes))]
Type actualType,
[ValueSource(typeof(PrimitiveUtils), nameof(PrimitiveUtils.NumericTypes))]
Type expectedType,
[ValueSource(typeof(PrimitiveUtils), nameof(PrimitiveUtils.NumericTypes))]
Type thresholdType,
[Values] Clusivity clusivity
)
{
var exp = new ApproximationExpectation(actualType, expectedType, thresholdType);
Console.WriteLine(exp);
AssertAll.Of(
() => Assert.That(exp.Actual, Is.Approximately(exp.Expected_ToPass(clusivity), exp.Threshold, clusivity), $"{nameof(exp.Expected_ToPass)}, {clusivity}"),
() => Assert.That(exp.Actual, Is.Not.Approximately(exp.Expected_ToFail(clusivity), exp.Threshold, clusivity), $"{nameof(exp.Expected_ToFail)}, {clusivity}")
);
}
public bool Includes(IRange <Instant> range, Clusivity clusivity = Clusivity.Exclusive)
{
switch (clusivity)
{
case Clusivity.Inclusive:
return((Start <= range.Start) && (range.End <= End));
case Clusivity.Exclusive:
return((Start < range.Start) && (range.End < End));
case Clusivity.LowerInclusive:
return((Start <= range.Start) && (range.End < End));
case Clusivity.UpperInclusive:
return((Start < range.Start) && (range.End <= End));
default:
throw new ArgumentOutOfRangeException(nameof(clusivity), clusivity, null);
}
}
public bool Includes(Instant value, Clusivity clusivity = Clusivity.Exclusive)
{
switch (clusivity)
{
case Clusivity.Inclusive:
return((Start <= value) && (value <= End));
case Clusivity.Exclusive:
return((Start < value) && (value < End));
case Clusivity.LowerInclusive:
return((Start <= value) && (value < End));
case Clusivity.UpperInclusive:
return((Start < value) && (value <= End));
default:
throw new ArgumentOutOfRangeException(nameof(clusivity), clusivity, null);
}
}
public static bool IsInRange(this sbyte value, sbyte min, sbyte max, Clusivity clusivity = Clusivity.Inclusive) => value.IsBetween(min, max, clusivity);
public static bool IsInRange(this ulong value, ulong min, ulong max, Clusivity clusivity = Clusivity.Inclusive) => value.IsBetween(min, max, clusivity);
public static bool IsInRange(this decimal value, decimal min, decimal max, Clusivity clusivity = Clusivity.Inclusive) => value.IsBetween(min, max, clusivity);
public static bool IsInRange(this float value, float min, float max, Clusivity clusivity = Clusivity.Inclusive) => value.IsBetween(min, max, clusivity);
public ApproximationConstraint(DateTime expectedValue, TimeSpan?threshold = default, Clusivity clusivity = Clusivity.Inclusive) : this((object)expectedValue, threshold)
{
}
public static string MaxSymbol(this Clusivity clusivity)
{
return(clusivity == Clusivity.Exclusive ? ")" : "]");
}
public static string FormatRange(object min, Clusivity minClusivity, object max, Clusivity maxClusivity)
{
return($"{minClusivity.MinSymbol()}{min}, {max}{maxClusivity.MaxSymbol()}");
}
public static ApproximationConstraint Approximately(DateTime expectedValue, TimeSpan threshold, Clusivity clusivity = Clusivity.Inclusive)
{
return(new ApproximationConstraint(expectedValue, threshold));
}
public static ApproximationConstraint Approximately(this ConstraintExpression constraintExpression, object expectedValue, object threshold, Clusivity clusivity = Clusivity.Inclusive)
{
return(constraintExpression.Append(new ApproximationConstraint(expectedValue, threshold, clusivity)) as ApproximationConstraint);
}
public static bool IsBetween(this int value, int min, int max, Clusivity clusivity = Clusivity.Inclusive) => clusivity == Clusivity.Inclusive ? value >= min && value <= max : clusivity == Clusivity.Exclusive ? value > min && value < max : throw BEnum.InvalidEnumArgumentException(nameof(clusivity), clusivity);
public object Expected_ToFail(Clusivity clusivity)
{
var value = _actual + (clusivity == Clusivity.Inclusive ? _threshold * 1.5 : _threshold);
return(Convert.ChangeType(value, Expected_Type));
}
public Range(T min, T max, Clusivity minBounds, Clusivity maxBounds)
: this(min, max, RangeClusivityUtilities.Combine(minBounds, maxBounds))
{
}
public static Range <T> New <T>(T min, T max, Clusivity minBounds, Clusivity maxBounds)
where T : IComparable <T>, IEquatable <T> => new Range <T>(min, max, minBounds, maxBounds);
public bool Includes(ZonedDateTime value, Clusivity clusivity = Clusivity.Exclusive)
{
return(Includes(value.ToInstant(), clusivity));
}
public static ApproximationConstraint CloseTo(object expectedValue, object threshold, Clusivity clusivity = Clusivity.Inclusive)
{
return(Approximately(expectedValue, threshold, clusivity));
}
public bool Includes(IRange <ZonedDateTime> range, Clusivity clusivity = Clusivity.Exclusive)
{
return(Includes(new InstantRange(range.Start.ToInstant(), range.End.ToInstant()), clusivity));
}
public static ApproximationConstraint CloseTo(DateTime expectedValue, TimeSpan threshold, Clusivity clusivity = Clusivity.Inclusive)
{
return(Approximately(expectedValue, threshold, clusivity));
}
public static string MinSymbol(this Clusivity clusivity)
{
return(clusivity == Clusivity.Exclusive ? "(" : "[");
}
