/// <summary>
 /// Perform a string comparison, specifying the desired case sensitivity
 /// </summary>
 public static void ShouldBe(this string actual, string expected, Case caseSensitivity)
 {
     var constraint = (caseSensitivity == Case.Sensitive)
                          ? Is.EqualTo(expected)
                          : Is.EqualTo(expected).IgnoreCase;
     actual.AssertAwesomely(constraint, actual, expected);
 }
 public static void ShouldContain(this string actual, string expected, [InstantHandle] Func<string> customMessage, Case caseSensitivity)
 {
     actual.AssertAwesomely(
         v => (caseSensitivity == Case.Sensitive) ? Is.StringContainingUsingCaseSensitivity(v, expected) : Is.StringContainingIgnoreCase(v, expected), 
         actual.Clip(100, "..."),
         expected,
         caseSensitivity,
         customMessage);
 }
 public static void ShouldBe(this decimal actual, decimal expected, decimal tolerance, [InstantHandle] Func<string> customMessage)
 {
     actual.AssertAwesomely(v => Is.Equal(v, expected, tolerance), actual, expected, tolerance, customMessage);
 } 
 public static void ShouldBe(this IEnumerable<float> actual, IEnumerable<float> expected, double tolerance, [InstantHandle] Func<string> customMessage)
 {
     actual.AssertAwesomely(v => Is.Equal(v, expected, tolerance), actual, expected, tolerance, customMessage);
 }
 public static void ShouldStartWith(this string actual, string expected)
 {
     actual.AssertAwesomely(Is.StringStarting(expected).IgnoreCase, actual, expected);
 }
 /// <summary>
 /// Asserts that a string ends with the <paramref name="endsWith"/> substring.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="endsWith"></param>
 /// <returns></returns>
 public static string ShouldEndWith(this string value, string endsWith)
 {
     return value.AssertAwesomely(Is.StringEnding(endsWith), value, endsWith);
 }
 public static void ShouldStartWith(this string actual, string expected)
 {
     actual.AssertAwesomely(v => Is.StringStartingWithIgnoreCase(v, expected), actual, expected);
 }
 public static void ShouldNotContain(this string actual, string expected)
 {
     actual.AssertAwesomely(v => !Is.StringContainingIgnoreCase(v, expected), actual, expected);
 }
 public static void ShouldBe(this DateTimeOffset actual, DateTimeOffset expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage)
 {
     actual.AssertAwesomely(v => Is.Equal(v, expected, tolerance), actual, expected, tolerance, customMessage);
 }
 public static void ShouldNotEndWith(this string actual, string expected, [InstantHandle] Func<string> customMessage, Case caseSensitivity = Case.Insensitive)
 {
     actual.AssertAwesomely(v => !Is.EndsWithUsingCaseSensitivity(v, expected, caseSensitivity), actual, expected, customMessage);
 }
 public static void ShouldBePositive(this float actual, [InstantHandle] Func<string> customMessage)
 {
     var expected = default(float);
     actual.AssertAwesomely(v => Is.GreaterThan(v, expected), actual, expected, customMessage);
 }
 public static void ShouldBeNegative(this double actual, [InstantHandle] Func<string> customMessage)
 {
     var expected = default(double);
     actual.AssertAwesomely(v => Is.LessThan(v, expected), actual, expected, customMessage);
 }
 /// <summary>
 /// Asserts that a string starts with the <paramref name="startsWith"/> substring.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="startsWith"></param>
 /// <returns></returns>
 public static string ShouldStartWith(this string value, string startsWith)
 {
     return value.AssertAwesomely(Is.StringStarting(startsWith), value, startsWith);
 }
 /// <summary>
 /// Asserts that a string does not match a regular expression.
 /// </summary>
 /// <param name="actual"></param>
 /// <param name="regexPattern"></param>
 /// <returns></returns>
 public static string ShouldNotMatch(this string actual, string regexPattern)
 {
     return actual.AssertAwesomely(Is.Not.StringMatching(regexPattern), actual, regexPattern);
 }
 /// <summary>
 /// Asserts that a string does not contains a given substring.  Matching is case sensitive.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="notContains"></param>
 /// <returns></returns>
 public static string ShouldNotContain(this string value, string notContains)
 {
     return value.AssertAwesomely(Is.Not.StringContaining(notContains), value, notContains);
 }
 /// <summary>
 /// Perform a string comparison, specifying the desired case sensitivity
 /// </summary>
 public static void ShouldBe(this string actual, string expected, Case caseSensitivity)
 {
     actual.AssertAwesomely(v => (caseSensitivity == Case.Sensitive)
         ? Is.Equal(v, expected)
         : Is.StringEqualIgnoreCase(v, expected), actual, expected);
 }
 public static void ShouldMatch(this string actual, string regexPattern)
 {
     actual.AssertAwesomely(v => Is.StringMatchingRegex(v, regexPattern), actual, regexPattern);
 }
 public static void ShouldNotBe(this TimeSpan actual, TimeSpan expected, TimeSpan tolerance, [InstantHandle] Func<string> customMessage)
 {
     actual.AssertAwesomely(v => !Is.Equal(v, expected, tolerance), actual, expected, tolerance, customMessage);
 } 
 public static void ShouldNotEndWith(this string actual, string expected)
 {
     actual.AssertAwesomely(v => !Is.EndsWithIgnoringCase(v, expected), actual, expected);
 }
 public static void ShouldNotMatch(this string actual, string regexPattern, [InstantHandle] Func<string> customMessage)
 {
     actual.AssertAwesomely(v => !Is.StringMatchingRegex(v, regexPattern), actual, regexPattern, customMessage);
 }
 public static void ShouldNotContain(this string actual, string expected)
 {
     actual.AssertAwesomely(Is.Not.StringContaining(expected).IgnoreCase, actual, expected);
 }
 /// <summary>
 /// Asserts that a string contains a given substring.  Matching is case sensitive.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="contains"></param>
 /// <returns></returns>
 public static string ShouldContain(this string value, string contains)
 {
     return value.AssertAwesomely(Is.StringContaining(contains), value, contains);
 }