public AssertionFailure[] CaptureFailures(GallioAction action, bool captureExceptionAsAssertionFailure)
{
try
{
action();
}
catch (ThreadAbortException)
{
throw;
}
catch (AssertionFailureException ex)
{
if (!ex.IsSilent)
{
SubmitFailure(ex.Failure, true);
}
}
catch (TestException)
{
throw;
}
catch (Exception ex)
{
if (!captureExceptionAsAssertionFailure)
{
throw;
}
SubmitFailure(AssertionFailureBuilder.WrapExceptionAsAssertionFailure(ex), true);
}
return(GetSavedFailuresAsArray());
}
public void ToStringBareBones()
{
AssertionFailure failure = new AssertionFailureBuilder("Description")
.SetStackTrace(null)
.ToAssertionFailure();
Assert.AreEqual("Description\n", failure.ToString());
}
public void Verify_WhenAssertionFuncReturnsNonNull_SubmitsTheFailure()
{
var failure = new AssertionFailureBuilder("Boom").ToAssertionFailure();
var failures = AssertionHelper.Eval(() =>
{
AssertionHelper.Verify(() => failure);
});
Assert.AreElementsEqual(new[] { failure }, failures);
}
public void WriteToBareBones()
{
AssertionFailure failure = new AssertionFailureBuilder("Description")
.SetStackTrace(null)
.ToAssertionFailure();
TestLog.Write(failure);
StringMarkupDocumentWriter writer = new StringMarkupDocumentWriter(true);
failure.WriteTo(writer.Failures);
Assert.AreEqual("[Marker \'AssertionFailure\'][Section \'Description\']\n[End]\n[End]", writer.ToString());
}
public void Verify_WhenAssertionFuncThrowsAssertionFailureException_ResubmitsTheFailure()
{
var failure = new AssertionFailureBuilder("Boom").ToAssertionFailure();
var failures = AssertionHelper.Eval(() =>
{
AssertionHelper.Verify(() =>
{
throw new AssertionFailureException(failure, false);
});
});
Assert.AreElementsEqual(new[] { failure }, failures);
}
private AssertionFailure DescribeAssertionFailure(Trace trace)
{
// Skip trivial nodes in the trace tree that are not of much interest.
while (IsTrivialExpression(trace.Expression) && trace.Children.Count == 1 && trace.Exception == null)
{
trace = trace.Children[0];
}
string expectedResultString = expectedResult ? "true" : "false";
AssertionFailureBuilder failureBuilder;
if (trace.Exception != null)
{
failureBuilder = new AssertionFailureBuilder(
String.Format("Expected the condition to evaluate to {0} but it threw an exception.", expectedResultString))
.AddException(trace.Exception);
}
else
{
failureBuilder = new AssertionFailureBuilder(
String.Format("Expected the condition to evaluate to {0}.", expectedResultString));
}
failureBuilder.SetMessage(messageFormat, messageArgs);
failureBuilder.AddRawLabeledValue("Condition", condition.Body);
var labeledTraces = new List <Trace>();
AddLabeledTraces(labeledTraces, trace);
var addedLabels = new System.Collections.Generic.HashSet <string>();
foreach (Trace labeledTrace in labeledTraces)
{
// Only include the first value associated with a unique label so if a variable
// appears multiple times in an expression, only its value from the outermost
// expression it appears is displayed.
string label = Formatter.Instance.Format(labeledTrace.Expression);
if (!addedLabels.Contains(label))
{
addedLabels.Add(label);
failureBuilder.AddRawLabeledValue(label, labeledTrace.Result);
}
}
return(failureBuilder.ToAssertionFailure());
}
public void ToStringEverything()
{
AssertionFailure failure = new AssertionFailureBuilder("Description")
.SetMessage("Message goes here")
.SetStackTrace(new StackTraceData("Stack goes here"))
.AddRawExpectedValue("Expected value")
.AddRawActualValue("Actual value")
.AddRawLabeledValue("Very Long Label That Will Not Be Padded", "")
.AddRawLabeledValue("x", 42)
.AddException(new Exception("Boom"))
.AddException(new Exception("Kaput"))
.AddInnerFailure(new AssertionFailureBuilder("Inner").SetStackTrace(null).ToAssertionFailure())
.ToAssertionFailure();
Assert.AreEqual("Description\nMessage goes here\n\nExpected Value : \"Expected value\"\nActual Value : \"Actual value\"\nVery Long Label That Will Not Be Padded : \"\"\nx : 42\n\nSystem.Exception: Boom\n\nSystem.Exception: Kaput\n\nStack goes here\nInner\n", failure.ToString());
}
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);
}
/// <summary>
/// Verifies that an assertion succeeded.
/// </summary>
/// <remarks>
/// <para>
/// The assertion function should return null to indicate that the assertion has passed
/// or <see cref="AssertionFailure" /> to indicate that it has failed.
/// </para>
/// <para>
/// If the assertion function throws an exception it is reported as an assertion failure
/// unless the exception is a <see cref="TestException"/> (except <see cref="AssertionFailureException"/>)
/// in which case the exception is rethrown by this method. This behavior enables special
/// test exceptions such as <see cref="TestTerminatedException" /> to be used to terminate
/// the test at any point instead of being reported as assertion failures.
/// </para>
/// <para>
/// When an assertion failure is detected, it is submitted to <see cref="AssertionContext.SubmitFailure"/>
/// which may choose to throw a <see cref="AssertionFailureException" /> or do something else.
/// </para>
/// <para>
/// Using this method enables the system to track statistics about assertions
/// and to ensure that assertion failures are reported uniformly.
/// </para>
/// <para>
/// It is important to note that not all failures will result in a <see cref="AssertionFailureException"/>
/// being thrown. Refer to <see cref="AssertionContext.SubmitFailure"/> for details.
/// </para>
/// </remarks>
/// <param name="assertionFunc">The assertion function to evaluate.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="assertionFunc"/> is null.</exception>
public static void Verify(Func <AssertionFailure> assertionFunc)
{
if (assertionFunc == null)
{
throw new ArgumentNullException("assertionFunc");
}
TestContext context = TestContext.CurrentContext;
if (context != null)
{
context.IncrementAssertCount();
}
AssertionFailure failure;
try
{
failure = assertionFunc();
}
catch (ThreadAbortException)
{
throw;
}
catch (AssertionFailureException ex)
{
failure = ex.Failure;
}
catch (TestException)
{
throw;
}
catch (Exception ex)
{
failure = new AssertionFailureBuilder("An exception occurred while verifying an assertion.")
.AddException(ex)
.ToAssertionFailure();
}
Fail(failure);
}
/// <summary>
/// Performs an action and returns an array containing the assertion failures
/// that were observed within the block.
/// </summary>
/// <remarks>
/// <para>
/// If the action throws an exception it is reported as an assertion failure
/// unless the exception is a <see cref="TestException"/> (except <see cref="AssertionFailureException"/>)
/// in which case the exception is rethrown by this method. This behavior enables special
/// test exceptions such as <see cref="TestTerminatedException" /> to be used to terminate
/// the test at any point instead of being reported as assertion failures.
/// </para>
/// </remarks>
/// <param name="action">The action to invoke.</param>
/// <param name="assertionFailureBehavior">The assertion failure behavior to use while the action runs.</param>
/// <returns>The array of failures, may be empty if none.</returns>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="action"/> is null.</exception>
/// <exception cref="InvalidOperationException">Thrown if there is no current assertion context.</exception>
public static AssertionFailure[] Eval(Action action, AssertionFailureBehavior assertionFailureBehavior)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
AssertionContext context = AssertionContext.CurrentContext;
if (context != null)
{
return(context.CaptureFailures(action, assertionFailureBehavior, true));
}
else
{
try
{
action();
}
catch (ThreadAbortException)
{
throw;
}
catch (AssertionFailureException ex)
{
return(new[] { ex.Failure });
}
catch (TestException)
{
throw;
}
catch (Exception ex)
{
return(new[] { AssertionFailureBuilder.WrapExceptionAsAssertionFailure(ex) });
}
return(EmptyArray <AssertionFailure> .Instance);
}
}
/// <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);
}
}
public void Conditionally_builds_true()
{
var failure = new AssertionFailureBuilder("Description")
.If(true, builder => builder.AddLabeledValue("Label", "Value"))
.ToAssertionFailure();
Assert.Exists(failure.LabeledValues, x => x.Label == "Label");
}
public void ConstructorSetsDescription()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.AreEqual("Description", builder.ToAssertionFailure().Description);
}
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);
}
public void Conditionally_builds_false()
{
var failure = new AssertionFailureBuilder("Description")
.If(false, builder => builder.AddLabeledValue("Label", "Value"))
.ToAssertionFailure();
Assert.ForAll(failure.LabeledValues, x => x.Label != "Label");
}
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_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 AddLabeledValueWithStructuredTextThrowsIfLabelIsNull()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Throws<ArgumentNullException>(() => builder.AddLabeledValue(null, new StructuredText("abc")));
}
public void CanSetStackTraceToNullToOmit()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetStackTrace(null);
Assert.IsNull(builder.ToAssertionFailure().StackTrace);
}
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 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 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);
}
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 WriteToEverything()
{
AssertionFailure failure = new AssertionFailureBuilder("Description")
.SetMessage("Message goes here")
.SetStackTrace(new StackTraceData("Stack goes here"))
.AddRawExpectedValue("Expected value")
.AddRawActualValue("Actual value")
.AddRawLabeledValue("Very Long Label That Will Not Be Padded", "")
.AddRawLabeledValue("x", 42)
.AddException(new Exception("Boom"))
.AddException(new Exception("Kaput"))
.AddInnerFailure(new AssertionFailureBuilder("Inner").SetStackTrace(null).ToAssertionFailure())
.ToAssertionFailure();
TestLog.Write(failure);
StringMarkupDocumentWriter writer = new StringMarkupDocumentWriter(true);
failure.WriteTo(writer.Failures);
Assert.AreEqual("[Marker \'AssertionFailure\'][Section \'Description\']\nMessage goes here\n\n[Marker \'Monospace\'][Marker \'Label\']Expected Value : [End]\"Expected value\"\n[Marker \'Label\']Actual Value : [End]\"Actual value\"\n[Marker \'Label\']Very Long Label That Will Not Be Padded : [End]\"\"\n[Marker \'Label\']x : [End]42\n[End]\n[Marker \'Exception\'][Marker \'ExceptionType\']System.Exception[End]: [Marker \'ExceptionMessage\']Boom[End][End]\n\n[Marker \'Exception\'][Marker \'ExceptionType\']System.Exception[End]: [Marker \'ExceptionMessage\']Kaput[End][End]\n\n[Marker \'StackTrace\']Stack goes here[End]\n[Marker \'AssertionFailure\'][Section \'Inner\']\n[End]\n[End][End]\n[End]", writer.ToString());
}
public void AddLabeledValueWithStructuredTextThrowsIfFormattedValueIsNull()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Throws<ArgumentNullException>(() => builder.AddLabeledValue("xxx", (StructuredText)null));
}
public void CanSetStackTrace()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetStackTrace(new StackTraceData("Stack"));
Assert.AreEqual("Stack", builder.ToAssertionFailure().StackTrace.ToString());
}
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 AutomaticStackTraceUsedIfNotSet()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Contains(builder.ToAssertionFailure().StackTrace.ToString(), "AutomaticStackTraceUsedIfNotSet");
}
public void AddInnerFailuresThrowsIfArgumentIsNull()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Throws<ArgumentNullException>(() => builder.AddInnerFailures(null));
}
public void AddRawLabeledValuesWithDiffsThrowsIfRightLabelIsNull()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Throws<ArgumentNullException>(() => builder.AddRawLabeledValuesWithDiffs("xxx", "abc", null, "def"));
}
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);
}
/// <summary>
/// Asserts that the XML fragment contains the searched element or attribute, that it has the expected value, and that this element or attribute is unique in the entire fragment.
/// </summary>
/// <remarks>
/// <para>
/// If <paramref name="expectedValue"/> is set to <c>null</c>, the assertion behaves like <see cref="Assert.Xml.Exists(string, IXmlPathLoose, XmlOptions, string, object[])"/>.
/// </para>
/// </remarks>
/// <param name="actualXml">The actual XML fragment.</param>
/// <param name="searchedPath">The path of the searched element or attribute in the XML fragment.</param>
/// <param name="options">Options for the search.</param>
/// <param name="expectedValue">The expected value of the searched item (element or attribute).</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>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="actualXml"/>, <paramref name="searchedPath"/>, or <paramref name="options"/> is null.</exception>
public static void IsUnique(string actualXml, IXmlPathLoose searchedPath, XmlOptions options, string expectedValue, string messageFormat, params object[] messageArgs)
{
if (actualXml == null)
throw new ArgumentNullException("actualXml");
if (searchedPath == null)
throw new ArgumentNullException("searchedPath");
if (options == null)
throw new ArgumentNullException("options");
AssertionHelper.Verify(() =>
{
NodeFragment actual;
try
{
actual = Parser.Run(actualXml, options.Value);
}
catch (XmlException exception)
{
return new AssertionFailureBuilder("Cannot parse the actual XML fragment.")
.SetMessage(messageFormat, messageArgs)
.AddException(exception)
.ToAssertionFailure();
}
int count = actual.CountAt(searchedPath, expectedValue, options.Value);
if (count == 1)
return null;
var builder = new AssertionFailureBuilder("Expected the XML fragment to contain only once the searched XML element or attribute, " +
(count == 0 ? "but none was found." : "But several were found."))
.SetMessage(messageFormat, messageArgs)
.AddLabeledValue("Item searched", searchedPath.ToString())
.AddRawLabeledValue("Number of items found", count);
if (expectedValue != null)
{
builder.AddLabeledValue("Expected value", expectedValue);
}
return builder.ToAssertionFailure();
});
}
public void AddRawLabeledValueThrowsIfLabelIsNull()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Throws<ArgumentNullException>(() => builder.AddRawLabeledValue(null, "abc"));
}
