/// <summary>
/// Returns the diff as an assertion failure.
/// </summary>
/// <param name="expected">The expected fragment used to format the diff.</param>
/// <param name="actual">The actual fragment used to format the diff.</param>
/// <returns>The resulting assertion failure.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="expected"/> or <paramref name="actual"/> is null.</exception>
public AssertionFailure ToAssertionFailure(NodeFragment expected, NodeFragment actual)
{
bool showActual = ((targets & DiffTargets.Actual) != 0);
bool showExpected = ((targets & DiffTargets.Expected) != 0);
var builder = new AssertionFailureBuilder(diffType.Description, new NullFormatter());
const XmlPathRenderingOptions options = XmlPathRenderingOptions.UseIndentation;
if (showActual && showExpected)
{
var actualFormatted = XmlPathRenderer.Run(path, actual, options);
var expectedFormatted = XmlPathRenderer.Run(path, expected, options);
builder.AddRawExpectedAndActualValuesWithDiffs(expectedFormatted, actualFormatted);
}
else if (showActual)
{
var actualFormatted = XmlPathRenderer.Run(path, actual, options);
builder.AddRawActualValue(actualFormatted);
}
else if (showExpected)
{
var expectedFormatted = XmlPathRenderer.Run(path, expected, options);
builder.AddRawExpectedValue(expectedFormatted);
}
return(builder.ToAssertionFailure());
}
public void CanSetStackTrace()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetStackTrace(new StackTraceData("Stack"));
Assert.AreEqual("Stack", builder.ToAssertionFailure().StackTrace.ToString());
}
public void CanSetStackTraceToNullToOmit()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetStackTrace(null);
Assert.IsNull(builder.ToAssertionFailure().StackTrace);
}
/// <summary>
/// Throws an exception if the condition is false
/// </summary>
/// <param name="condition">Condition to check</param>
/// <param name="message">message to use</param>
/// <param name="args">Arguments for the message</param>
private static void ThrowIf(bool condition, string message, params object[] args)
{
if (condition)
{
var builder = new AssertionFailureBuilder(string.Format(message, args));
throw new AssertionFailureException(builder.ToAssertionFailure(), false);
}
}
public void CanAddExceptions()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddException(new InvalidOperationException("Boom 1"));
builder.AddException(new InvalidOperationException("Boom 2"));
Assert.Over.Pairs(new[] { "Boom 1", "Boom 2" }, builder.ToAssertionFailure().Exceptions,
(expectedSubstring, actual) => Assert.Contains(actual.ToString(), expectedSubstring));
}
public void CanSetMessage()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetMessage("Message");
Assert.AreEqual("Message", builder.ToAssertionFailure().Message);
builder.SetMessage(null);
Assert.IsNull(builder.ToAssertionFailure().Message);
builder.SetMessage("New Message", null);
Assert.AreEqual("New Message", builder.ToAssertionFailure().Message);
builder.SetMessage("New Message: {0}", "Hello!");
Assert.AreEqual("New Message: Hello!", builder.ToAssertionFailure().Message);
builder.SetMessage(null, null);
Assert.IsNull(builder.ToAssertionFailure().Message);
}
public void CanAddFormattedLabeledValueAsLabeledValueStruct()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddLabeledValue(new AssertionFailure.LabeledValue("Abc", new StructuredText("123")));
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Abc", new StructuredText("123"))
}, builder.ToAssertionFailure().LabeledValues);
}
public void CanAddFormattedLabeledValueAsPlainTextString()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddLabeledValue("Abc", "123");
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Abc", "123")
}, builder.ToAssertionFailure().LabeledValues);
}
public void CanAddRawExpectedValue()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddRawExpectedValue("Abc");
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Expected Value", "\"Abc\"")
}, builder.ToAssertionFailure().LabeledValues);
}
public void ShowsExpectedAndActualValueWithDiffs_RepresentationalEquality()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("description");
builder.AddRawExpectedAndActualValuesWithDiffs(1, 1u);
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Expected Value & Actual Value", new StructuredText("1")),
new AssertionFailure.LabeledValue("Remark", "Both values look the same when formatted but they are distinct instances.")
}, builder.ToAssertionFailure().LabeledValues);
}
public void CanAddRawLabeledValue()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddRawLabeledValue("Abc", 123);
builder.AddRawLabeledValue("Def", 3.0m);
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Abc", "123"),
new AssertionFailure.LabeledValue("Def", "3.0m")
}, builder.ToAssertionFailure().LabeledValues);
}
public void ShowsExpectedAndActualValueWithDiffs_ReferentialEquality()
{
const string str = "123";
AssertionFailureBuilder builder = new AssertionFailureBuilder("description");
builder.AddRawExpectedAndActualValuesWithDiffs(str, str);
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Expected Value & Actual Value", new StructuredText("\"123\"")),
new AssertionFailure.LabeledValue("Remark", "Both values are the same instance.")
}, builder.ToAssertionFailure().LabeledValues);
}
public void CanAddInnerFailures()
{
AssertionFailure inner1 = new AssertionFailureBuilder("Inner1").ToAssertionFailure();
AssertionFailure inner2 = new AssertionFailureBuilder("Inner2").ToAssertionFailure();
AssertionFailure inner3 = new AssertionFailureBuilder("Inner3").ToAssertionFailure();
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddInnerFailures(new[] { inner1, inner2 });
builder.AddInnerFailure(inner3);
Assert.Over.Pairs(new[] { inner1, inner2, inner3 }, builder.ToAssertionFailure().InnerFailures,
Assert.AreEqual);
}
/// <summary>
/// Reports an assertion failure.
/// </summary>
/// <param name="testContext"></param>
/// <param name="testInfoData"></param>
/// <param name="testStepResult"></param>
public void Run(ITestContext testContext, TestInfoData testInfoData, TestStepResult testStepResult)
{
if (testStepResult.TestOutcome == TestOutcome.Failed)
{
MbUnitCppAssertionFailure failure = testStepResult.Failure;
var builder = new AssertionFailureBuilder(failure.Description);
if (failure.HasExpectedValue && failure.HasActualValue && failure.Diffing)
{
builder.AddRawExpectedAndActualValuesWithDiffs(failure.ExpectedValue, failure.ActualValue);
}
else if (failure.HasUnexpectedValue && failure.HasActualValue && failure.Diffing)
{
builder.AddRawLabeledValuesWithDiffs("Unexpected Value", failure.UnexpectedValue, "Actual Value", failure.ActualValue);
}
else
{
if (failure.HasExpectedValue)
{
builder.AddRawExpectedValue(failure.ExpectedValue);
}
if (failure.HasActualValue)
{
builder.AddRawActualValue(failure.ActualValue);
}
if (failure.HasUnexpectedValue)
{
builder.AddRawLabeledValue("Unexpected Value", failure.UnexpectedValue);
}
}
foreach (var extra in failure.ExtraLabeledValues)
{
builder.AddRawLabeledValue(extra.First, extra.Second);
}
if (failure.Message.Length > 0)
{
builder.SetMessage(failure.Message);
}
builder.SetStackTrace(testInfoData.GetStackTraceData(failure.Line));
builder.ToAssertionFailure().WriteTo(testContext.LogWriter.Failures);
}
}
/// <summary>
/// Verifies that the sequence of objects contains distinct values.
/// </summary>
/// <typeparam name="T">The type of value.</typeparam>
/// <param name="values">The sequence of values to be tested.</param>
/// <param name="comparer">The comparer to use, or null to use the default one.</param>
/// <param name="messageFormat">The custom assertion message format, or null if none.</param>
/// <param name="messageArgs">The custom assertion message arguments, or null if none.</param>
/// <exception cref="AssertionException">Thrown if the verification failed unless the current <see cref="AssertionContext.AssertionFailureBehavior" /> indicates otherwise.</exception>
public static void Distinct <T>(IEnumerable <T> values, EqualityComparison <T> comparer, string messageFormat, params object[] messageArgs)
{
AssertionHelper.Verify(() =>
{
if (comparer == null)
{
comparer = ComparisonSemantics.Default.Equals;
}
var duplicates = new List <T>();
int i = 0;
foreach (var value1 in values)
{
int j = 0;
foreach (var value2 in values)
{
if ((i != j) && comparer(value1, value2) && !duplicates.Contains(value1))
{
duplicates.Add(value1);
}
j++;
}
i++;
}
if (duplicates.Count > 0)
{
var builder = new AssertionFailureBuilder(
"Expected the elements to be distinct but several instances represents the same value.")
.SetMessage(messageFormat, messageArgs);
foreach (var duplicate in duplicates)
{
builder.AddRawLabeledValue("Duplicated Value", duplicate);
}
return(builder.ToAssertionFailure());
}
return(null);
});
}
public void TruncatesDiffContextWhenTooLong()
{
string expectedValue = "z" + new string('x', AssertionFailure.MaxFormattedValueLength) + "z";
string actualValue = "Z" + new string('x', AssertionFailure.MaxFormattedValueLength) + "Z";
AssertionFailureBuilder builder = new AssertionFailureBuilder("description");
builder.AddRawExpectedAndActualValuesWithDiffs(expectedValue, actualValue);
AssertionFailure failure = builder.ToAssertionFailure();
TestLog.Write(failure);
int split = AssertionFailureBuilder.CompressedDiffContextLength / 2;
Assert.AreEqual("\"z" + new string('x', split) + "..." + new string('x', split) + "z\"",
failure.LabeledValues[0].FormattedValue.ToString());
Assert.AreEqual("\"Z" + new string('x', split) + "..." + new string('x', split) + "Z\"",
failure.LabeledValues[1].FormattedValue.ToString());
}
public void ShowsLabeledValuesWithDiffs_Difference()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("description");
builder.AddRawLabeledValuesWithDiffs("Left", "acde", "Right", "bcef");
DiffSet diffSet = DiffSet.GetDiffSet("\"acde\"", "\"bcef\"").Simplify();
StructuredTextWriter expectedValueWriter = new StructuredTextWriter();
diffSet.WriteTo(expectedValueWriter, DiffStyle.LeftOnly);
StructuredTextWriter actualValueWriter = new StructuredTextWriter();
diffSet.WriteTo(actualValueWriter, DiffStyle.RightOnly);
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Left", expectedValueWriter.ToStructuredText()),
new AssertionFailure.LabeledValue("Right", actualValueWriter.ToStructuredText())
}, builder.ToAssertionFailure().LabeledValues);
}
private static T Deserialize <T>(Stream stream, IFormatter formatter, string messageFormat, object[] messageArgs, GallioFunc <T> originalValueProvider)
{
if (formatter == null)
{
throw new ArgumentNullException("formatter");
}
T deserializedValue = default(T);
AssertionHelper.Verify(delegate
{
if (stream == null)
{
return(new AssertionFailureBuilder("Could not deserialize the value because the stream is null.")
.SetMessage(messageFormat, messageArgs)
.ToAssertionFailure());
}
try
{
deserializedValue = (T)formatter.Deserialize(stream);
}
catch (Exception ex)
{
var failureBuilder = new AssertionFailureBuilder("Could not deserialize the value.")
.SetMessage(messageFormat, messageArgs)
.AddException(ex);
if (originalValueProvider != null)
{
failureBuilder.AddRawLabeledValue("Value", originalValueProvider());
}
return(failureBuilder.ToAssertionFailure());
}
return(null);
});
return(deserializedValue);
}
public void AutomaticStackTraceUsedIfNotSet()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Contains(builder.ToAssertionFailure().StackTrace.ToString(), "AutomaticStackTraceUsedIfNotSet");
}
public void ConstructorSetsDescription()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.AreEqual("Description", builder.ToAssertionFailure().Description);
}
