internal static IStringAssertion DoesNotEndWith(this StringAssertion source, string text) { source.Extend(x => AssertResult.New(!x.EndsWith(text, StringComparison.CurrentCultureIgnoreCase), Resources.DoesNotEndWith, text)); return(source); }
public IMixedTypeAssertion <T, U> IsEqualTo <S>(S comparedTo) { Extend((x, t) => { if (t == typeof(U)) { if (_newType == null) { return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo)); } return(AssertResult.New(_newType.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString())); } else { if (x == null) { return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo)); } return(AssertResult.New(x.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString())); } }); return(this); }
public IClassAssertion <T> PropertyValuesMatch <S>(S item, bool throwExceptionOnPropertyMismatch = false, string[] ignoreProperties = null) { Extend(x => { return(AssertResult.New(PropertiesMatch(x, item, throwExceptionOnPropertyMismatch: throwExceptionOnPropertyMismatch, ignoreProperties: ignoreProperties), "Property values do not match")); }); return(this); }
public IClassAssertion <T> PropertyValuesDoNotMatch <S>(S item, bool throwExceptionOnPropertyMismatch = false, Func <string, object, object, bool> propertyChanged = null, string[] ignoreProperties = null) { Extend(x => { return(AssertResult.New(!PropertiesMatch(x, item, throwExceptionOnPropertyMismatch: throwExceptionOnPropertyMismatch, propertyChanged: propertyChanged, ignoreProperties: ignoreProperties), "Property values match")); }); return(this); }
public IClassAssertion <T> PropertyValuesDoNotMatch <S>(S item, Func <string, object, object, bool> propertyChanged = null) { Extend(x => { return(AssertResult.New(!PropertiesMatch(x, item, propertyChanged), "Property values match")); }); return(this); }
public IClassAssertion <T> PropertyValuesMatch <S>(S item) { Extend(x => { return(AssertResult.New(PropertiesMatch(x, item), "Property values do not match")); }); return(this); }
private static IStringAssertion IsValidISBN10(this IStringAssertionU source) { source.Extend(x => { return(AssertResult.New(ValidIsbn10(x), Resources.IsValidISBN)); }); return((IStringAssertion)source); }
public IDictionaryAssertion <T1, T2> ContainsKey(T1 key) { Extend(x => { return(AssertResult.New(x.ContainsKey(key), Resources.ContainsKey, key)); }); return(this); }
public static IStringAssertion IsValidPersonalNumber(this IStringAssertionU source) { source.Extend(x => { return(AssertResult.New(Luhn.IsValid(x.ToIntArray()), Resources.IsValidPersonalNumber)); }); return((IStringAssertion)source); }
public static IStringAssertion IsNotValidImoNr(this IStringAssertionU source) { source.Extend(x => { return(AssertResult.New(!ImoValidator.IsValid(x), Resources.IsNotValidImoNr)); }); return((IStringAssertion)source); }
public INumberAssertion <T> IsNotWithin(T min, T max) { Extend(x => { dynamic d = x; return(AssertResult.New(d < min || d > max, Resources.IsNotWithin, min, max)); }); return(this); }
internal static EnumerableAssertion ContainsMoreThan(this EnumerableAssertion source, int nElements) { source.Extend(x => { var count = GetCount(x); return(AssertResult.New(count > nElements, Resources.ContainsMoreThan, nElements)); }); return(source); }
internal static EnumerableAssertion IsEmpty(this EnumerableAssertion source) { source.Extend(x => { var c = GetCount(x); return(AssertResult.New(c == 0, Resources.IsEmpty)); }); return(source); }
public IDateTimeAssertion SameMinuteAs(DateTime date) { Extend(x => { var diff = (Item - date).TotalMinutes; return(AssertResult.New(diff >= 0 && diff <= 1.0, Resources.SameMinuteAs, date.ToString("yyyy-MM-dd HH:mm"))); }); return(this); }
internal static StringAssertion DoesNotContainDigit(this StringAssertion source) { source.Extend(x => { bool isValid = Regex.IsMatch(x, @"\d"); return(AssertResult.New(!isValid, Resources.DoesNotContainDigit)); }); return(source); }
public IDateTimeAssertion SameYearAs(DateTime date) { Extend(x => { var sameYear = x.Date.Year == date.Year; return(AssertResult.New(sameYear, Resources.SameYearAs, date.ToString("yyyy"))); }); return(this); }
public static IStringAssertion IsValidSocialSecurityNumber(this IStringAssertionU source) { source.Extend(x => { var isValid = Regex.IsMatch(x, _regex); return(AssertResult.New(isValid, Resources.IsValidSocialSecurityNumber)); }); return((IStringAssertion)source); }
public static IStringAssertion IsValidZipCode(this IStringAssertionU source) { source.Extend(x => { var isValid = Regex.IsMatch(x, _regex); return(AssertResult.New(isValid, Resources.IsValidZipCode)); }); return((IStringAssertion)source); }
public IEnumerableAssertion <T> ContainsLessThan(int nElements) { Extend(x => { var count = x.Count(); return(AssertResult.New(count < nElements, Resources.ContainsLessThan, nElements)); }); return(this); }
public IDateTimeAssertion IsWithin(DateTime min, DateTime max) { Extend(x => { dynamic d = x; return(AssertResult.New(d >= min && d <= max, Resources.IsWithin, min, max)); }); return(this); }
public IDateTimeAssertion IsNotWithin(DateTime min, DateTime max) { Extend(x => { dynamic d = Item; return(AssertResult.New(d < min || d > max, Resources.IsNotWithin, min, max)); }); return(this); }
public IDateTimeAssertion NotSameSecondAs(DateTime date) { Extend(x => { var diff = (x - date).TotalSeconds; return(AssertResult.New(diff < 0 || diff > 1.0, Resources.NotSameSecondAs, date.ToString("yyyy-MM-dd HH:mm:ss"))); }); return(this); }
public IStringAssertion DoesNotMatch(string regex, RegexOptions options = RegexOptions.None) { Extend(x => { _previousMatch = Regex.Match(x, regex, options); return(AssertResult.New(!_previousMatch.Success, Resources.DoesNotMatch, regex)); }); return(this); }
public static IStringAssertion IsNotValidPhoneNumber(this IStringAssertionU source) { source.Extend(x => { var isValid = Regex.IsMatch(x, _regex); return(AssertResult.New(!isValid, Resources.IsNotValidPhoneNumber)); }); return((IStringAssertion)source); }
public IEnumerableAssertion <T> Contains(params T[] items) { Extend(x => { var containsItems = items.All(y => x.Contains(y)); return(AssertResult.New(containsItems, Resources.ContainsItems, String.Join(",", items.Select(y => y.ToString()).ToArray()))); }); return(this); }
public IDateTimeAssertion NotSameMonthAs(DateTime date) { Extend(x => { var sameYear = x.Date.Year == date.Year; var sameMonth = x.Date.Month == date.Month; return(AssertResult.New(!(sameYear && sameMonth), Resources.NotSameMonthAs, date.ToString("yyyy-MM"))); }); return(this); }
internal static IAssertion <T> IsEqualTo <T>(this Assertion <T> source, T comparedTo) { source.Extend(x => { if (x == null) { return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo)); } return(AssertResult.New(x.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString())); }); return(source); }
public IClassAssertion <T> IsNotPartOf(IEnumerable <T> enumerable) { Extend(x => { if (enumerable == null || x == null) { return(AssertResult.New(true, Resources.IsNotPartOf)); } return(AssertResult.New(!enumerable.Contains(x), Resources.IsNotPartOf)); }); return(this); }
public IClassAssertion <T> IsEqualTo <S>(S comparedTo) { Extend(x => { if (x == null) { return(AssertResult.New(comparedTo == null, Resources.IsEqualTo, comparedTo)); } return(AssertResult.New(x.Equals(comparedTo), Resources.IsEqualTo, comparedTo == null ? "null" : comparedTo.ToString())); }); return(this); }
internal static StringAssertion IsNotValidEmail(this StringAssertion source) { source.Extend(x => { //bool isEmail = Regex.IsMatch(x, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z"); RegexHelper helper = new RegexHelper(); var isEmail = helper.IsValidEmail(x); return(AssertResult.New(string.IsNullOrWhiteSpace(x) || !isEmail, Resources.IsNotValidEmail)); }); return(source); }