/// <summary>
        /// Verify that <paramref name="value"/> is not null, not empty and contains other characters than white space.
        /// </summary>
        public static void IsNotNullOrWhiteSpace(string value, string propertyName, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            InternalContract.RequireNotNull(propertyName, nameof(propertyName));
            var message = customMessage ?? $"Property {propertyName} ({value}) must not be null or empty and it must contain other characters than white space.";

            GenericAssert <FulcrumAssertionFailedException> .IsNotNullOrWhiteSpace(value, errorLocation, message);
        }
        /// <summary>
        /// Verify that <paramref name="value"/> is not null.
        /// </summary>
        public static void IsNotNull(object value, string propertyName, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            InternalContract.RequireNotNull(propertyName, nameof(propertyName));
            var message = customMessage ?? $"Property {propertyName} ({value}) must not be null.";

            GenericAssert <FulcrumAssertionFailedException> .IsNotNull(value, errorLocation, message);
        }
        /// <summary>
        /// Verify that <paramref name="value"/> is not the default mustBeTrue for that type.
        /// </summary>
        public static void IsNotDefaultValue <T>(T value, string propertyName, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            InternalContract.RequireNotNull(propertyName, nameof(propertyName));
            var message = customMessage ?? $"Property {propertyName} ({value}) must not have the default propertyValue ({default(T)}.";

            GenericAssert <FulcrumAssertionFailedException> .IsNotDefaultValue(value, 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, string customMessage = null)
     where T : IComparable <T>
 {
     InternalContract.RequireNotNull(greaterValue, nameof(greaterValue));
     InternalContract.RequireNotNull(actualValue, nameof(actualValue));
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     GenericAssert <FulcrumAssertionFailedException> .IsLessThan(greaterValue, actualValue, errorLocation, customMessage);
 }
Esempio n. 5
0
 /// <summary>
 /// Verify that <paramref name="parameterValue"/> is greater than or equal to <paramref name="lesserOrEqualValue"/>.
 /// </summary>
 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));
     InternalContract.RequireNotNull(parameterName, nameof(parameterName));
     GenericContract <FulcrumServiceContractException> .RequireGreaterThanOrEqualTo(lesserOrEqualValue, parameterValue, parameterName, customMessage);
 }
        /// <summary>
        /// Verify that <paramref name="propertyValue"/> is null or not matches the regular expression <paramref name="regularExpression"/>.
        /// </summary>
        public static void MatchesNotRegExp(string regularExpression, string propertyValue, string propertyName, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNullOrWhitespace(regularExpression, nameof(regularExpression));
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var message = customMessage ?? $"Expected property {propertyName} ({propertyValue}) to not match ({regularExpression}).";

            GenericAssert <FulcrumAssertionFailedException> .MatchesNotRegExp(regularExpression, propertyValue, errorLocation, message);
        }
        /// <summary>
        /// Verify that <paramref name="propertyValue"/> is equal to <paramref name="expectedValue"/>.
        /// </summary>
        public static void AreEqual(object expectedValue, object propertyValue, string propertyName, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            InternalContract.RequireNotNull(propertyName, nameof(propertyName));
            var message = customMessage ?? $"Expected property {propertyName} ({propertyValue}) to be equal to ({expectedValue}).";

            GenericAssert <FulcrumAssertionFailedException> .AreEqual(expectedValue, propertyValue, errorLocation, message);
        }
        /// <summary>
        /// Verify that <paramref name="propertyValue"/> is greater than or equal to <paramref name="lesserOrEqualValue"/>.
        /// </summary>
        public static void IsGreaterThanOrEqualTo <T>(T lesserOrEqualValue, T propertyValue, string propertyName, string errorLocation, string customMessage = null)
            where T : IComparable <T>
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            InternalContract.RequireNotNull(propertyName, nameof(propertyName));
            var message = customMessage ?? $"Expected property {propertyName} ({propertyValue}) to be less than ({lesserOrEqualValue}).";

            GenericAssert <FulcrumAssertionFailedException> .IsGreaterThanOrEqualTo(lesserOrEqualValue, propertyValue, errorLocation, message);
        }
        /// <summary>
        /// Verify that <paramref name="parameterValue"/> matches the regular expression <paramref name="regularExpression"/>.
        /// </summary>
        public static void RequireMatchesNotRegExp(string regularExpression, string parameterValue, string parameterName, string customMessage = null)
        {
            InternalContract.RequireNotNull(regularExpression, nameof(regularExpression));
            InternalContract.RequireNotNull(parameterValue, nameof(parameterValue));
            InternalContract.RequireNotNull(parameterName, nameof(parameterName));
            var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must not match regular expression ({regularExpression}).";

            Require(!Regex.IsMatch(parameterValue, regularExpression), message);
        }
Esempio n. 10
0
 /// <summary>
 /// Verify that <paramref name="value"/> is not the default value for that type.
 /// </summary>
 public static void IsNotDefaultValue <T>(T value, string errorLocation, string customMessage = null)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     if (!value.Equals(default(T)))
     {
         return;
     }
     ThrowException(errorLocation, customMessage ?? $"Did not expect value to be default value ({default(T)}).");
 }
Esempio n. 11
0
 /// <summary>
 /// Verify that <paramref name="value"/> is null.
 /// </summary>
 public static void IsNull(object value, string errorLocation, string customMessage = null)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     if (value == null)
     {
         return;
     }
     ThrowException(errorLocation, customMessage ?? $"Expected value ({value}) to be null.");
 }
Esempio n. 12
0
 /// <summary>
 /// Verify that <paramref name="value"/> is true.
 /// </summary>
 public static void IsTrue(bool value, string errorLocation, string customMessage = null)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     if (value)
     {
         return;
     }
     ThrowException(errorLocation, customMessage ?? "Expected value to be true.");
 }
Esempio n. 13
0
 /// <summary>
 /// Verify that <paramref name="actualValue"/> is not equal to <paramref name="expectedValue"/>.
 /// </summary>
 public static void AreNotEqual(object expectedValue, object actualValue, string errorLocation, string customMessage = null)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     if (!Equals(expectedValue, actualValue))
     {
         return;
     }
     ThrowException(errorLocation, customMessage ?? $"Expected ({actualValue}) to not be equal to ({expectedValue}).");
 }
Esempio n. 14
0
 /// <summary>
 /// Verify that <paramref name="value"/> is not null, not empty and has other characters than white space.
 /// </summary>
 public static void IsNotNullOrWhiteSpace(string value, string errorLocation, string customMessage = null)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     if (!string.IsNullOrWhiteSpace(value))
     {
         return;
     }
     ThrowException(errorLocation, customMessage ?? $"Did not expect value ({value}) to be null, empty or only contain whitespace.");
 }
Esempio n. 15
0
        /// <summary>
        /// Verify that <paramref name="actualValue"/> is greater than or equal to <paramref name="lesserOrEqualValue"/>.
        /// </summary>
        public static void IsGreaterThanOrEqualTo <T>(T lesserOrEqualValue, T actualValue, string errorLocation, string customMessage = null)
            where T : IComparable <T>
        {
            InternalContract.RequireNotNull(lesserOrEqualValue, nameof(lesserOrEqualValue));
            InternalContract.RequireNotNull(actualValue, nameof(actualValue));
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var message = customMessage ?? $"Expected ({actualValue}) to be greater than or equal to ({lesserOrEqualValue}).";

            IsTrue(actualValue.CompareTo(lesserOrEqualValue) >= 0, errorLocation, message);
        }
Esempio n. 16
0
        /// <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, string customMessage = null)
            where T : IComparable <T>
        {
            InternalContract.RequireNotNull(greaterValue, nameof(greaterValue));
            InternalContract.RequireNotNull(actualValue, nameof(actualValue));
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var message = customMessage ?? $"Expected ({actualValue}) to be less than ({greaterValue}).";

            IsTrue(actualValue.CompareTo(greaterValue) < 0, errorLocation, message);
        }
        /// <summary>
        /// Verify that <paramref name="parameterValue"/> is greater than or equal to <paramref name="lesserOrEqualValue"/>.
        /// </summary>
        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));
            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);
        }
        /// <summary>
        /// Verify that <paramref name="parameterValue"/> is less than to <paramref name="greaterValue"/>.
        /// </summary>
        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));
            InternalContract.RequireNotNull(parameterName, nameof(parameterName));
            var message = customMessage ?? $"ContractViolation: {parameterName} ({parameterValue}) must be less than ({greaterValue}).";

            Require(parameterValue.CompareTo(greaterValue) < 0, message);
        }
Esempio n. 19
0
        public static void IsTrue(Expression <Func <bool> > expression, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var value = expression.Compile()();

            if (value)
            {
                return;
            }
            ThrowException(errorLocation, customMessage ?? $"Expected '{expression.Body} to be true.");
        }
Esempio n. 20
0
        public static void AreEqual(object expectedValue, Expression <Func <string> > expression, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var actualValue = expression.Compile()();

            if (Equals(expectedValue, actualValue))
            {
                return;
            }
            ThrowException(errorLocation, customMessage ?? $"Expected '{expression.Body}' ({actualValue}) to be equal to ({expectedValue}).");
        }
Esempio n. 21
0
        public static void IsNotNullOrWhiteSpace(Expression <Func <string> > expression, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var value = expression.Compile()();

            if (!string.IsNullOrWhiteSpace(value))
            {
                return;
            }
            ThrowException(errorLocation, customMessage ?? $"Did not expect '{expression.Body}' ({value}) to be null, empty or only contain whitespace.");
        }
Esempio n. 22
0
        public static void IsNotNull(Expression <Func <object> > expression, string errorLocation, string customMessage = null)
        {
            InternalContract.RequireNotNull(expression, nameof(expression));
            var value = expression.Compile()();

            if (value != null)
            {
                return;
            }
            ThrowException(errorLocation, customMessage ?? $"Did not expect '{expression.Body}' to be null.");
        }
Esempio n. 23
0
        /// <summary>
        /// Verify that <paramref name="value"/> is null or matches the regular expression <paramref name="regularExpression"/>.
        /// </summary>
        public static void MatchesNotRegExp(string regularExpression, string value, string errorLocation, string customMessage = null)
        {
            if (value == null)
            {
                return;
            }
            InternalContract.RequireNotNull(regularExpression, nameof(regularExpression));
            InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
            var message = customMessage ?? $"Expected ({value}) to not match regular expression ({regularExpression}).";

            IsTrue(!Regex.IsMatch(value, regularExpression), errorLocation, message);
        }
 /// <summary>
 /// Will always fail. Used in parts of the errorLocation where we should never end up. E.g. a default case in a switch statement where all cases should be covered, so we should never end up in the default case.
 /// </summary>
 /// <param name="errorLocation">A unique errorLocation for the part of errorLocation where the validation didn't hold.</param>
 /// <param name="message">A message that documents/explains this failure. This message should normally start with "Expected ...".</param>
 public static void Fail(string errorLocation, string message)
 {
     InternalContract.RequireNotNull(message, nameof(message));
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     GenericAssert <FulcrumAssertionFailedException> .Fail(errorLocation, message);
 }
Esempio n. 25
0
 public static void Require(Expression <Func <bool> > expression, string message)
 {
     InternalContract.RequireNotNullOrWhitespace(message, nameof(message));
     GenericContract <FulcrumContractException> .Require(expression, message);
 }
 private static string GetErrorMessageIfFalse(bool mustBeTrue, string message)
 {
     InternalContract.RequireNotNullOrWhitespace(message, nameof(message));
     return(mustBeTrue ? null : message);
 }
Esempio n. 27
0
 /// <summary>
 /// Will always fail. Used in parts of the errorLocation where we should never end up. E.g. a default case in a switch statement where all cases should be covered, so we should never end up in the default case.
 /// </summary>
 /// <param name="errorLocation">A unique errorLocation for this exact assertion.</param>
 /// <param name="message">A message that documents/explains this failure. This message should normally start with "Expected ...".</param>
 public static void Fail(string errorLocation, string message)
 {
     InternalContract.RequireNotNullOrWhitespace(message, nameof(message));
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     ThrowException(errorLocation, message);
 }
 /// <summary>
 /// Verify that <paramref name="mustBeTrue"/> is true.
 /// </summary>
 /// <param name="mustBeTrue">The value that must be true.</param>
 /// <param name="message">A message that documents/explains this failure. This message should normally start with "Expected ...".</param>
 /// <param name="errorLocation">A unique errorLocation for the part of errorLocation where the validation didn't hold.</param>
 public static void IsTrue(bool mustBeTrue, string errorLocation, string message)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     InternalContract.RequireNotNullOrWhitespace(message, nameof(message));
     GenericAssert <FulcrumAssertionFailedException> .IsTrue(mustBeTrue, errorLocation, message);
 }
Esempio n. 29
0
 /// <summary>
 /// Verify that <paramref name="mustBeTrue"/> really is true.
 /// </summary>
 public static void Require(bool mustBeTrue, string message)
 {
     InternalContract.RequireNotNullOrWhitespace(message, nameof(message));
     GenericContract <FulcrumContractException> .Require(mustBeTrue, message);
 }
 /// <summary>
 /// Verify that <paramref name="actualValue"/> is not equal to <paramref name="expectedValue"/>.
 /// </summary>
 public static void AreNotEqual(object expectedValue, object actualValue, string errorLocation, string customMessage = null)
 {
     InternalContract.RequireNotNull(errorLocation, nameof(errorLocation));
     GenericAssert <FulcrumAssertionFailedException> .AreNotEqual(expectedValue, actualValue, errorLocation, customMessage);
 }