public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" Dictionary ""{0}"" should contain key ""{1}"" with value ""{2}"" {3}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); var keyValue = context.Key.ToStringAwesomely(); if (context.HasRelevantKey) { var actualValueString = context.Actual == null ? actualValue : string.Format("\"{0}\"", actualValue.Trim('"')); var valueString = string.Format("but value was {0}", actualValueString); return(String.Format(format, codePart, keyValue.Trim('"'), expectedValue.Trim('"'), valueString)); } else { return(String.Format(format, codePart, actualValue.Trim('"'), expectedValue.Trim('"'), "but the key does not exist")); } }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" {0} should {1}be within {2} of {3} but was {4}"; var codePart = context.CodePart; var tolerance = context.Tolerance.ToStringAwesomely(); var expectedValue = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); var negated = context.ShouldMethod.Contains("Not") ? "not " : string.Empty; var message = string.Format(format, codePart, negated, tolerance, expectedValue, actualValue); if (DifferenceHighlighter.CanHighlightDifferences(context)) { message += string.Format(@" difference {0}", DifferenceHighlighter.HighlightDifferences(context)); } return message; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" Dictionary ""{0}"" should not contain key ""{1}"" with value {2} {3}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); var keyValue = context.Key.ToStringAwesomely(); var expectedValueString = context.Expected == null ? expectedValue : string.Format("\"{0}\"", expectedValue.Trim('"')); if (context.HasRelevantKey) { var valueString = "but does"; return String.Format(format, codePart, keyValue.Trim('"'), expectedValueString, valueString); } else { return String.Format(format, codePart, actualValue.Trim('"'), expectedValueString, "but the key does not exist"); } }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expected = context.Expected.ToStringAwesomely(); var shouldMethod = context.ShouldMethod.PascalToSpaced(); if (context.IsNegatedAssertion) { if (codePart == "null") { codePart = expected; } return ($@"{codePart} {shouldMethod} but was{(context.Expected == null ? " null" : "")}"); } string details; if (context.Expected is IEnumerable enumerable and not string) { var count = enumerable?.Cast <object?>().Count() ?? 0; details = $@" had {count} item{(count == 1 ? string.Empty : "s")} and"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expected = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); string actual; if (context.IsNegatedAssertion) { actual = string.Empty; } else if (codePart == actualValue) { actual = " not"; } else { actual = $"\r\n{actualValue}"; } var message = $@"{codePart} {context.ShouldMethod.PascalToSpaced()} {expected} but was{actual}"; if (DifferenceHighlighter.CanHighlightDifferences(context)) { message += $@" difference {DifferenceHighlighter.HighlightDifferences(context)}"; } return(message); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { string codePart = context.CodePart; string caseSensitivity = context.CaseSensitivity == Case.Insensitive ? " (case insensitive comparison)" : "(case sensitive comparison)"; string format = @" {0} {1} {2}{3} but was {4}"; if (DifferenceHighlighter.CanHighlightDifferences(context)) { format += string.Format(@" difference {0}", DifferenceHighlighter.HighlightDifferences(context)); } return string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), context.Expected.ToStringAwesomely(), caseSensitivity, context.Actual.ToStringAwesomely()); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var tolerance = context.Tolerance.ToStringAwesomely(); var expectedValue = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); string actual; if (codePart == actualValue) actual = " not"; else actual = $@" {actualValue}"; var negated = context.ShouldMethod.Contains("Not") ? "not " : string.Empty; var message = $@"{codePart} should {negated}be within {tolerance} of {expectedValue} but was{actual}"; if (DifferenceHighlighter.CanHighlightDifferences(context)) { message += $@" difference {DifferenceHighlighter.HighlightDifferences(context)}"; } return message; }
public override bool CanProcess(IShouldlyAssertionContext context) { return(context.ShouldMethod.StartsWith("Should") && !context.ShouldMethod.Contains("Contain") && context.UnderlyingShouldMethod != null && context.UnderlyingShouldMethod.GetParameters().Any(p => p.Name == "tolerance")); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var expected = ((IEnumerable)context.Expected).Cast <object>().ToArray(); var actual = ((IEnumerable)context.Actual).Cast <object>().ToArray(); var codePart = context.CodePart; var expectedFormattedValue = expected.ToStringAwesomely(); var missingFromExpected = actual.Where(a => !expected.Any(e => Is.Equal(e, a))).ToArray(); var missingFromActual = expected.Where(e => !actual.Any(a => Is.Equal(e, a))).ToArray(); var actualMissingMessage = missingFromActual.Any() ? string.Format("{0} is missing {1}", codePart, missingFromActual.ToStringAwesomely()) : string.Empty; var expectedMissingMessage = missingFromExpected.Any() ? string.Format("{0} is missing {1}", expectedFormattedValue, missingFromExpected.ToStringAwesomely()) : string.Empty; //"first should be second (ignoring order) but first is missing [4] and second is missing [2]" const string format = @" {0} {1} {2} (ignoring order) but {3}"; string missingMessage = !string.IsNullOrEmpty(actualMissingMessage) && !string.IsNullOrEmpty(expectedMissingMessage) ? string.Format("{0} and {1}", actualMissingMessage, expectedMissingMessage) : string.Format("{0}{1}", actualMissingMessage, expectedMissingMessage); return(string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), expectedFormattedValue, missingMessage)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart == "null" ? context.Actual.ToStringAwesomely() : context.CodePart; var elementPhrase = context.MatchCount.HasValue ? context.MatchCount.Value + " element(s)" : "an element"; var should = context.ShouldMethod.PascalToSpaced(); var expected = context.Expected.ToStringAwesomely(); if (context.IsNegatedAssertion) { return ($@"{codePart} {should} {elementPhrase} satisfying the condition {expected} but does{""}"); } return ($@"{codePart} {should} {elementPhrase} satisfying the condition {expected} but does not"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var throwContext = (ShouldThrowAssertionContext)context; var isExtensionMethod = context.ShouldMethod == "ShouldNotThrow"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); string errorMessage; if (isExtensionMethod && !throwContext.IsAsync) { errorMessage = string.Format("`{0}()` should not throw but threw {1}", codePart, expectedValue); } else if (isExtensionMethod && throwContext.IsAsync) { errorMessage = string.Format("Task `{0}` should not throw but threw {1}", codePart, expectedValue); } else { errorMessage = string.Format("`{0}` should not throw but threw {1}", codePart, expectedValue); } var notThrowAssertionContext = context as ShouldThrowAssertionContext; errorMessage += (notThrowAssertionContext != null) ? string.Format(" with message \"{0}\"", notThrowAssertionContext.ExceptionMessage) : string.Empty; return(errorMessage); }
public override bool CanProcess(IShouldlyAssertionContext context) { return context.ShouldMethod == "ShouldBeginWith" || context.ShouldMethod == "ShouldNotBeginWith" || context.ShouldMethod == "ShouldEndWith" || context.ShouldMethod == "ShouldNotEndWith"; }
public override bool CanProcess(IShouldlyAssertionContext context) { return(context.ShouldMethod == "ShouldBeginWith" || context.ShouldMethod == "ShouldNotBeginWith" || context.ShouldMethod == "ShouldEndWith" || context.ShouldMethod == "ShouldNotEndWith"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" {0} should {1}be within {2} of {3} but was {4}"; var codePart = context.CodePart; var tolerance = context.Tolerance.ToStringAwesomely(); var expectedValue = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); var negated = context.ShouldMethod.Contains("Not") ? "not " : string.Empty; var message = string.Format(format, codePart, negated, tolerance, expectedValue, actualValue); if (DifferenceHighlighter.CanHighlightDifferences(context)) { message += string.Format(@" difference {0}", DifferenceHighlighter.HighlightDifferences(context)); } return(message); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { string codePart = context.CodePart; string caseSensitivity = context.CaseSensitivity == Case.Insensitive ? " (case insensitive comparison)" : "(case sensitive comparison)"; string format = @" {0} {1} {2}{3} but was {4}"; if (DifferenceHighlighter.CanHighlightDifferences(context)) { format += string.Format(@" difference {0}", DifferenceHighlighter.HighlightDifferences(context)); } return(string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), context.Expected.ToStringAwesomely(), caseSensitivity, context.Actual.ToStringAwesomely())); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); string actual; if (codePart == actualValue) { if (context.IsNegatedAssertion) { actual = " did"; } else { actual = " did not"; } } else { actual = $@" was {actualValue}"; } var message = $@"{codePart} {context.ShouldMethod.PascalToSpaced()} {expectedValue} but{actual}"; return(message); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var expected = ((IEnumerable)context.Expected).Cast<object>().ToArray(); var actual = ((IEnumerable)context.Actual).Cast<object>().ToArray(); var codePart = context.CodePart; var expectedFormattedValue = expected.ToStringAwesomely(); var missingFromExpected = actual.Where(a => !expected.Any(e => Is.Equal(e, a))).ToArray(); var missingFromActual = expected.Where(e => !actual.Any(a => Is.Equal(e, a))).ToArray(); var actualMissingMessage = missingFromActual.Any() ? string.Format("{0} is missing {1}", codePart, missingFromActual.ToStringAwesomely()) : string.Empty; var expectedMissingMessage = missingFromExpected.Any() ? string.Format("{0} is missing {1}", expectedFormattedValue, missingFromExpected.ToStringAwesomely()) : string.Empty; //"first should be second (ignoring order) but first is missing [4] and second is missing [2]" const string format = @" {0} {1} {2} (ignoring order) but {3}"; string missingMessage = !string.IsNullOrEmpty(actualMissingMessage) && !string.IsNullOrEmpty(expectedMissingMessage) ? string.Format("{0} and {1}", actualMissingMessage, expectedMissingMessage) : string.Format("{0}{1}", actualMissingMessage, expectedMissingMessage); return string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), expectedFormattedValue, missingMessage); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should contain key {1} with value {2} {3}"; var codePart = context.CodePart; var dictionary = (IDictionary)context.Actual; var keyExists = dictionary.Contains(context.Key); var expectedValue = context.Expected.ToStringAwesomely(); var keyValue = context.Key.ToStringAwesomely(); if (keyExists) { var actualValueString = dictionary[context.Key].ToStringAwesomely(); var valueString = $@" but value was {actualValueString}"; return string.Format(format, codePart, keyValue, expectedValue, valueString); } return string.Format(format, codePart, keyValue, expectedValue, " but the key does not exist"); }
public override bool CanProcess(IShouldlyAssertionContext context) { return context.ShouldMethod.StartsWith("Should") && !context.ShouldMethod.Contains("Contain") && context.UnderlyingShouldMethod != null && context.UnderlyingShouldMethod.GetParameters().Any(p => p.Name == "tolerance"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expected = context.Expected.ToStringAwesomely(); var actualValue = context.Actual.ToStringAwesomely(); string actual; if (context.IsNegatedAssertion) { actual = string.Empty; } else if (codePart == actualValue) { actual = " not"; } else { actual = $"\r\n{actualValue}"; } var message = $@"{codePart} {context.ShouldMethod.PascalToSpaced()} {expected} but was{actual}"; if (DifferenceHighlighter.CanHighlightDifferences(context)) { message += $@" difference {DifferenceHighlighter.HighlightDifferences(context)}"; } return message; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should contain key {1} with value {2} {3}"; var codePart = context.CodePart; var dictionary = (IDictionary)context.Actual; var keyExists = dictionary.Contains(context.Key); var expectedValue = context.Expected.ToStringAwesomely(); var keyValue = context.Key.ToStringAwesomely(); if (keyExists) { var actualValueString = dictionary[context.Key].ToStringAwesomely(); var valueString = $@" but value was {actualValueString}"; return(string.Format(format, codePart, keyValue, expectedValue, valueString)); } return(string.Format(format, codePart, keyValue, expectedValue, " but the key does not exist")); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { Debug.Assert(context.Actual is IDictionary); Debug.Assert(context.Key is object); const string format = @"{0} should not contain key {1} with value {2} {3}"; var codePart = context.CodePart; var dictionary = (IDictionary)context.Actual; var keyExists = dictionary.Contains(context.Key); var expected = context.Expected.ToStringAwesomely(); var keyValue = context.Key.ToStringAwesomely(); if (keyExists) { return(string.Format(format, codePart, keyValue, expected, "but does")); } return(string.Format(format, codePart, keyValue, expected, "but the key does not exist")); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { return string.Format(@" {0} should complete in {1} but did not", context.Expected, context.Timeout); }
public bool CanProcess(IShouldlyAssertionContext context) { return context.Expected != null && context.Actual != null && (context.Expected is IEnumerable) && !(context.Expected is string) && (context.Actual is IEnumerable) && !(context.Actual is string); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { return(string.Format(@" {0} should complete in {1} but did not", context.Expected, context.Timeout)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { return $@" {context.Expected} should complete in {context.Timeout} but did not"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { return ($@"{context.CodePart} should be in {context.SortDirection.ToString().ToLower()} order but was not. The first out-of-order item was found at index {context.OutOfOrderIndex}: {context.OutOfOrderObject}"); }
public bool CanProcess(IShouldlyAssertionContext context) { return context.Expected != null && context.Actual != null && context.Expected is string && context.Actual is string && context.ShouldMethod == "ShouldBe"; }
public bool CanProcess(IShouldlyAssertionContext context) { return(context.Expected != null && context.Actual != null && context.Expected is IEnumerable && !(context.Expected is string) && context.Actual is IEnumerable && !(context.Actual is string)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { return($@" {context.Expected} should complete in {context.Timeout} but did not"); }
public override bool CanProcess(IShouldlyAssertionContext context) { return(context is { ShouldMethod : "ShouldBe", Expected : not Expression, Actual : IEnumerable <string>, });
public bool CanProcess(IShouldlyAssertionContext context) { return(context.Expected != null && context.Actual != null && context.Expected is string && context.Actual is string && context.ShouldMethod == "ShouldBe"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should be {1} but was {2}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); return(string.Format(format, codePart, expectedValue, context.Actual.ToStringAwesomely())); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} {1} but was {2}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); return string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), expectedValue); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} {1} but was {2}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); return(string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), expectedValue)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should not match {1} but did"; var codePart = context.CodePart; var expected = context.Expected.ToStringAwesomely(); return(string.Format(format, codePart, expected)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should not match {1} but did"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); return string.Format(format, codePart, expectedValue); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var expected = context.Expected.ToStringAwesomely(); var codePart = context.CodePart == "null" ? expected : context.CodePart; var expectedValue = context.IsNegatedAssertion || expected == codePart ? string.Empty : $@" {expected}"; return $@"{codePart} {context.ShouldMethod.PascalToSpaced()} but was{expectedValue}"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var expected = context.Expected.ToStringAwesomely(); var codePart = context.CodePart == "null" ? expected : context.CodePart; var expectedValue = context.IsNegatedAssertion || expected == codePart ? string.Empty : $@" {expected}"; return($@"{codePart} {context.ShouldMethod.PascalToSpaced()} but was{expectedValue}"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should be subset of {1} but {2} {3} outside subset"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); var count = (context.Actual ?? Enumerable.Empty<object>()).As<IEnumerable>().Cast<object>().Count(); return string.Format(format, codePart, expectedValue, context.Actual.ToStringAwesomely(), count > 1 ? "are" : "is"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expectedValue = context.Expected.ToString(); return $@"{codePart} should satisfy all the conditions specified, but does not. The following errors were found ... {expectedValue}"; }
/// <summary> /// Compares an actual value against an expected one and creates /// a string with the differences highlighted /// </summary> public static string HighlightDifferencesBetween(IShouldlyAssertionContext context) { var validHighlighter = GetHighlighterFor(context); if (validHighlighter == null) { return(context.Actual.Inspect()); } return(validHighlighter.HighlightDifferences(context)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { return ($@"Comparing object equivalence, at path: {FormatPath(context)} Expected value to be {context.Expected.ToStringAwesomely()} but was {context.Actual.ToStringAwesomely()}"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expectedValue = context.Expected?.ToString(); return ($@"{codePart} should satisfy all the conditions specified, but does not. The following errors were found ... {expectedValue}"); }
/// <summary> /// Compares an actual value against an expected one and creates /// a string with the differences highlighted /// </summary> public static string HighlightDifferences(IShouldlyAssertionContext context) { var validDifferenceHighlighter = GetDifferenceHighlighterFor(context); if (validDifferenceHighlighter == null) { return context.Actual.ToStringAwesomely(); } return validDifferenceHighlighter.HighlightDifferences(context); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @"{0} should be subset of {1} but {2} {3} outside subset"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); var count = (context.Actual ?? Enumerable.Empty <object>()).As <IEnumerable>().Cast <object>().Count(); return(string.Format(format, codePart, expectedValue, context.Actual.ToStringAwesomely(), count > 1 ? "are" : "is")); }
/// <summary> /// Compares an actual value against an expected one and creates /// a string with the differences highlighted /// </summary> public static string?HighlightDifferences(IShouldlyAssertionContext context) { var validDifferenceHighlighter = GetDifferenceHighlighterFor(context); if (validDifferenceHighlighter == null) { return(context.Actual.ToStringAwesomely()); } return(validDifferenceHighlighter.HighlightDifferences(context)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" {0} should satisfy all the conditions specified, but does not. The following errors were found ... {1}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToString(); return String.Format(format, codePart, expectedValue); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" {0} was {1} and {2} but wasn't"; var codePart = context.CodePart; var actual = context.Actual.ToStringAwesomely(); return String.Format(format, codePart, actual, context.ShouldMethod.PascalToSpaced()); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var actual = context.Actual.ToStringAwesomely(); var actualValue = codePart != actual ? $@" {actual} " : " "; return $@"{codePart} {context.ShouldMethod.PascalToSpaced()} but{actualValue}is negative"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" {0} should satisfy all the conditions specified, but does not. The following errors were found ... {1}"; var codePart = context.CodePart; var expectedValue = context.Expected.ToString(); return(String.Format(format, codePart, expectedValue)); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; const string format = @" {0} {1} an element satisfying the condition {2} but does{3}"; if (context.IsNegatedAssertion) return string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), context.Expected.ToStringAwesomely(), ""); return string.Format(format, codePart, context.ShouldMethod.PascalToSpaced(), context.Expected.ToStringAwesomely(), " not"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var actual = context.Actual.ToStringAwesomely(); var actualValue = codePart != actual ? $@" {actual} " : " "; return ($@"{codePart} {context.ShouldMethod.PascalToSpaced()} but{actualValue}is negative"); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var throwContext = (ShouldThrowAssertionContext)context; var isExtensionMethod = context.ShouldMethod == "ShouldNotThrow"; var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); string errorMessage; if (codePart == "null" && !throwContext.IsAsync) { errorMessage = $@"delegate should not throw but threw {expectedValue}"; } else if (codePart == "null" && throwContext.IsAsync) { errorMessage = $@"Task should not throw but threw {expectedValue}"; } else if (isExtensionMethod && !throwContext.IsAsync) { errorMessage = $@"`{codePart}()` should not throw but threw {expectedValue}"; } else if (isExtensionMethod && throwContext.IsAsync) { errorMessage = $@"Task `{codePart}` should not throw but threw {expectedValue}"; } else { errorMessage = $@"`{codePart}` should not throw but threw {expectedValue}"; } errorMessage += $@" with message ""{throwContext.ExceptionMessage}"""; return errorMessage; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { const string format = @" {0} {1}"; var codePart = context.CodePart; var isNegatedAssertion = context.ShouldMethod.Contains("Not"); if (isNegatedAssertion) return String.Format(format, codePart, context.ShouldMethod.PascalToSpaced()); return String.Format(format, codePart, context.ShouldMethod.PascalToSpaced()); }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var caseSensitivity = context.CaseSensitivity == Case.Insensitive ? " (case insensitive comparison)" : string.Empty; var actual = context.Actual.ToStringAwesomely(); var but = codePart == actual ? (context.IsNegatedAssertion ? "did" : "did not") : $@"was actually {actual}"; return $@"{codePart} {context.ShouldMethod.PascalToSpaced()}{caseSensitivity} {context.Expected.ToStringAwesomely()} but {but}"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var actualType = context.Actual?.GetType().FullName; var actualString = codePart == actualType || codePart == "null" ? " not" : $@" {actualType ?? "null"}"; return $@"{codePart} {context.ShouldMethod.PascalToSpaced()} {context.Expected.ToStringAwesomely()} but was{actualString}"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var expectedValue = context.Expected.ToStringAwesomely(); var actual = context.Actual.ToStringAwesomely(); var actualString = codePart == actual ? " had" : $@" it had {actual}"; return $@"{codePart} should not have flag {expectedValue} but{actualString}"; }
public override string GenerateErrorMessage(IShouldlyAssertionContext context) { var codePart = context.CodePart; var actual = context.Actual.ToStringAwesomely(); if (codePart == actual) codePart = context.Expected.ToStringAwesomely(); return $@"{codePart} {context.ShouldMethod.PascalToSpaced()} but {actual} was duplicated"; }
public string HighlightDifferences(IShouldlyAssertionContext context) { var actual = context.Actual as IEnumerable; var expected = context.Expected as IEnumerable; if (CanProcess(context)) { var actualList = actual.Cast<object>(); var expectedList = expected.Cast<object>(); var highestCount = actualList.Count() > expectedList.Count() ? actualList.Count() : expectedList.Count(); return HighlightDifferencesBetweenLists(actualList, expectedList, highestCount); } return actual.ToStringAwesomely(); }