public static void IsLessThanOrEqualTo <T>(T greaterOrEqualValue, T propertyValue, string propertyName, string errorLocation, string customMessage = null)
where T : IComparable <T>
{
InternalContract.RequireNotNull(propertyName, nameof(propertyName));
var message = customMessage ?? $"Expected property {propertyName} ({propertyValue}) to be less than or equal to ({greaterOrEqualValue}).";
GenericAssert <ValidationException> .IsLessThanOrEqualTo(greaterOrEqualValue, propertyValue, errorLocation, message);
}
public static void RequireAreEqual <T>(T expectedValue, T parameterValue, string parameterName, string customMessage = null)
{
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
GenericContract <FulcrumServiceContractException> .RequireAreEqual(expectedValue, parameterValue, parameterName, customMessage);
}
public static void IsGreaterThanOrEqualTo <T>(T lesserOrEqualValue, T actualValue, string errorLocation = null, string customMessage = null)
where T : IComparable <T>
{
InternalContract.RequireNotNull(lesserOrEqualValue, nameof(lesserOrEqualValue));
InternalContract.RequireNotNull(actualValue, nameof(actualValue));
var message = customMessage ?? $"Expected ({actualValue}) to be greater than or equal to ({lesserOrEqualValue}).";
IsTrue(actualValue.CompareTo(lesserOrEqualValue) >= 0, errorLocation, message);
}
/// <summary>
/// Verify that <paramref name="actualValue"/> is less than to <paramref name="greaterValue"/>.
/// </summary>
public static void IsLessThan <T>(T greaterValue, T actualValue, string errorLocation = null, string customMessage = null)
where T : IComparable <T>
{
InternalContract.RequireNotNull(greaterValue, nameof(greaterValue));
InternalContract.RequireNotNull(actualValue, nameof(actualValue));
var message = customMessage ?? $"Expected ({actualValue}) to be less than ({greaterValue}).";
IsTrue(actualValue.CompareTo(greaterValue) < 0, errorLocation, message);
}
public static void RequireMatchesRegExp(string regularExpression, string parameterValue, string parameterName, string customMessage = null)
{
RequireNotNullOrWhiteSpace(regularExpression, nameof(regularExpression));
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
GenericContract <FulcrumServiceContractException> .RequireMatchesRegExp(regularExpression, parameterValue, parameterName, customMessage);
}
public static void RequireAreEqual <T>(T expectedValue, T parameterValue, string parameterName, string customMessage = null)
{
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must be equal to ({expectedValue}).";
Require(Equals(expectedValue, parameterValue), message);
}
public static void RequireGreaterThanOrEqualTo <T>(T lesserOrEqualValue, T parameterValue, string parameterName, string customMessage = null)
where T : IComparable <T>
{
InternalContract.RequireNotNull(lesserOrEqualValue, nameof(lesserOrEqualValue));
InternalContract.RequireNotNull(parameterValue, nameof(parameterValue));
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
GenericContract <FulcrumServiceContractException> .RequireGreaterThanOrEqualTo(lesserOrEqualValue, parameterValue, parameterName, customMessage);
}
public static void MatchesNotRegExp(string regularExpression, string value, string errorLocation = null, string customMessage = null)
{
if (value == null)
{
return;
}
InternalContract.RequireNotNull(regularExpression, nameof(regularExpression));
var message = customMessage ?? $"Expected ({value}) to not match regular expression ({regularExpression}).";
IsTrue(!Regex.IsMatch(value, regularExpression), errorLocation, message);
}
public static void RequireInEnumeration(Type enumerationType, string parameterValue, string parameterName, string customMessage = null)
{
InternalContract.RequireNotNull(enumerationType, nameof(enumerationType));
InternalContract.Require(enumerationType.IsEnum, $"Parameter {nameof(enumerationType)} must be of type enum.");
if (parameterValue == null)
{
return;
}
var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must represent one of the enumeration values for ({enumerationType.FullName}).";
Require(Enum.IsDefined(enumerationType, parameterValue), message);
}
public static void RequireMatchesNotRegExp(string regularExpression, string parameterValue, string parameterName, string customMessage = null)
{
InternalContract.RequireNotNull(regularExpression, nameof(regularExpression));
InternalContract.RequireNotNull(parameterValue, nameof(parameterValue));
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must not match regular expression ({regularExpression}).";
Require(!Regex.IsMatch(parameterValue, regularExpression), message);
}
public static void InEnumeration(Type enumerationType, string value, string errorLocation = null, string customMessage = null)
{
InternalContract.RequireNotNull(enumerationType, nameof(enumerationType));
InternalContract.Require(enumerationType.IsEnum, $"Parameter {nameof(enumerationType)} must be of type enum.");
if (value == null)
{
return;
}
var message = customMessage ?? $"Expected ({value}) to represent one of the enumeration values for ({enumerationType.FullName}).";
IsTrue(Enum.IsDefined(enumerationType, value), errorLocation, message);
}
public static void RequireGreaterThanOrEqualTo <T>(T lesserOrEqualValue, T parameterValue, string parameterName, string customMessage = null)
where T : IComparable <T>
{
InternalContract.RequireNotNull(lesserOrEqualValue, nameof(lesserOrEqualValue));
InternalContract.RequireNotNull(parameterValue, nameof(parameterValue));
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must be greater than or equal to ({lesserOrEqualValue}).";
Require(parameterValue.CompareTo(lesserOrEqualValue) >= 0, message);
}
public static void RequireLessThan <T>(T greaterValue, T parameterValue, string parameterName, string customMessage = null)
where T : IComparable <T>
{
InternalContract.RequireNotNull(greaterValue, nameof(greaterValue));
InternalContract.RequireNotNull(parameterValue, nameof(parameterValue));
if (customMessage == null)
{
InternalContract.RequireNotNull(parameterName, nameof(parameterName));
}
var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must be less than ({greaterValue}).";
Require(parameterValue.CompareTo(greaterValue) < 0, message);
}
public static void Fail(string message)
{
InternalContract.RequireNotNullOrWhiteSpace(message, nameof(message));
GenericBase <TException> .ThrowException(message);
}
private static string GetErrorMessageIfFalse(bool mustBeTrue, string message)
{
InternalContract.RequireNotNullOrWhiteSpace(message, nameof(message));
return(mustBeTrue ? null : message);
}
public static void Fail(string message)
{
InternalContract.RequireNotNull(message, nameof(message));
GenericAssert <ValidationException> .Fail(message);
}
public static void InEnumeration(Type enumerationType, string value, string errorLocation = null, string customMessage = null)
{
InternalContract.RequireNotNull(enumerationType, nameof(enumerationType));
GenericAssert <FulcrumAssertionFailedException> .InEnumeration(enumerationType, value, errorLocation, customMessage);
}
public static void Require(bool mustBeTrue, string message)
{
InternalContract.RequireNotNullOrWhiteSpace(message, nameof(message));
GenericContract <FulcrumServiceContractException> .Require(mustBeTrue, message);
}
public static void Fail(string message)
{
InternalContract.RequireNotNullOrWhiteSpace(message, nameof(message));
GenericAssert <FulcrumAssertionFailedException> .Fail(null, message);
}
public static void IsTrue(bool mustBeTrue, string errorLocation, string message)
{
InternalContract.RequireNotNullOrWhiteSpace(message, nameof(message));
GenericAssert <ValidationException> .IsTrue(mustBeTrue, errorLocation, message);
}
public static void MatchesNotRegExp(string regularExpression, string value, string errorLocation = null, string customMessage = null)
{
InternalContract.RequireNotNullOrWhiteSpace(regularExpression, nameof(regularExpression));
GenericAssert <FulcrumAssertionFailedException> .MatchesNotRegExp(regularExpression, value, errorLocation, customMessage);
}
