/// <summary>
/// Verifies that an actual value is not an instance of some unexpected type.
/// </summary>
/// <remarks>
/// <para>
/// This assertion will fail if the object is null.
/// </para>
/// </remarks>
/// <param name="unexpectedType">The unexpected type.</param>
/// <param name="actualValue">The actual value.</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="unexpectedType"/> is null.</exception>
public static void IsNotInstanceOfType(Type unexpectedType, object actualValue, string messageFormat, params object[] messageArgs)
{
AssertionHelper.Verify(() =>
{
bool isNullValue = Object.ReferenceEquals(null, actualValue);
if (!isNullValue && (unexpectedType == null || !unexpectedType.IsInstanceOfType(actualValue)))
{
return(null);
}
var builder = new AssertionFailureBuilder("Expected value to not be an instance of a particular type.")
.SetMessage(messageFormat, messageArgs)
.AddRawLabeledValue("Unexpected Type", unexpectedType);
if (!isNullValue)
{
builder.AddRawLabeledValue("Actual Type", actualValue.GetType());
}
return(builder
.AddRawActualValue(actualValue)
.ToAssertionFailure());
});
}
/// <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 CanSetStackTraceToNullToOmit()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetStackTrace(null);
Assert.IsNull(builder.ToAssertionFailure().StackTrace);
}
public void CanSetStackTrace()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.SetStackTrace(new StackTraceData("Stack"));
Assert.AreEqual("Stack", builder.ToAssertionFailure().StackTrace.ToString());
}
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 ToStringBareBones()
{
AssertionFailure failure = new AssertionFailureBuilder("Description")
.SetStackTrace(null)
.ToAssertionFailure();
Assert.AreEqual("Description\n", failure.ToString());
}
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");
}
/// <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 CanAddRawExpectedValue()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddRawExpectedValue("Abc");
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Expected Value", "\"Abc\"")
}, builder.ToAssertionFailure().LabeledValues);
}
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 Fail_WhenFailureIsNotNull_SubmitsTheFailure()
{
var failure = new AssertionFailureBuilder("Boom").ToAssertionFailure();
var failures = AssertionHelper.Eval(() =>
{
AssertionHelper.Fail(failure);
});
Assert.AreElementsEqual(new[] { failure }, failures);
}
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 CanAddFormattedLabeledValueAsPlainTextString()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
builder.AddLabeledValue("Abc", "123");
Assert.AreElementsEqual(new[]
{
new AssertionFailure.LabeledValue("Abc", "123")
}, builder.ToAssertionFailure().LabeledValues);
}
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 WhenCaptureExceptionIsTrueANonSilentAssertionFailureExceptionIsReifiedAsAnAssertionFailure(bool captureExceptionAsAssertionFailure)
{
AssertionFailure assertionFailure = new AssertionFailureBuilder("Boom").ToAssertionFailure();
AssertionFailure[] failures = AssertionContext.CurrentContext.CaptureFailures(delegate
{
throw new AssertionFailureException(assertionFailure, false);
}, AssertionFailureBehavior.LogAndThrow, captureExceptionAsAssertionFailure);
Assert.AreElementsEqual(new[] { assertionFailure }, failures);
}
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 TruncatesLabelsAndFormattedValues()
{
AssertionFailure failure = new AssertionFailureBuilder("Description")
.SetStackTrace(null)
.AddLabeledValue(new string('x', AssertionFailure.MaxLabelLengthBeforeTruncation + 1),
new string('y', AssertionFailure.MaxFormattedValueLength + 1))
.ToAssertionFailure();
Assert.AreEqual("Description\n\n"
+ new string('x', AssertionFailure.MaxLabelLengthBeforeTruncation) + "... : "
+ new string('y', AssertionFailure.MaxFormattedValueLength) + "...\n", failure.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);
}
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);
}
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 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());
}
/// <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);
});
}
private static T XmlDeserialize <T>(Type type, string xml, string messageFormat, object[] messageArgs, GallioFunc <T> originalValueProvider)
{
T deserializedValue = default(T);
AssertionHelper.Verify(delegate
{
if (xml == null)
{
return(new AssertionFailureBuilder("Could not deserialize the value because the xml is null.")
.SetMessage(messageFormat, messageArgs)
.ToAssertionFailure());
}
// TODO: Allow the user to specify Xml serialization options.
using (XmlReader reader = XmlReader.Create(new StringReader(xml), new XmlReaderSettings()
{
CheckCharacters = false,
CloseInput = false,
ProhibitDtd = true
}))
{
try
{
var serializer = new XmlSerializer(type);
deserializedValue = (T)serializer.Deserialize(reader);
return(null);
}
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
.AddRawLabeledValue("Xml", xml)
.ToAssertionFailure());
}
}
});
return(deserializedValue);
}
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 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);
}
/// <summary>
/// Verifies that the specified sequence, collection, or array contains the expected number of elements.
/// </summary>
/// <remarks>
/// <para>
/// The assertion counts the elements according to the underlying type of the sequence.
/// <list type="bullet">
/// <item>Uses <see cref="Array.Length"/> if the sequence is an array.</item>
/// <item>Uses <see cref="ICollection.Count"/> or <see cref="ICollection{T}.Count"/> if the sequence is a collection such as <see cref="List{T}"/> or <see cref="Dictionary{K,V}"/>. It enumerates and counts the elements as well.</item>
/// <item>Enumerates and counts the elements if the sequence is a simple <see cref="IEnumerable"/>.</item>
/// </list>
/// </para>
/// </remarks>
/// <param name="expectedCount">The expected number of elements.</param>
/// <param name="values">The enumeration of elements to count.</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="ArgumentOutOfRangeException">Thrown if <paramref name="expectedCount"/> is negative.</exception>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="values"/> is null.</exception>
public static void Count(int expectedCount, IEnumerable values, string messageFormat, params object[] messageArgs)
{
if (expectedCount < 0)
{
throw new ArgumentOutOfRangeException("expectedCount", "The expected count value must be greater than or equal to 0.");
}
AssertionHelper.Verify(() =>
{
var counter = new EnumerableCounter(values);
var failures = new List <ICountingStrategy>();
foreach (ICountingStrategy strategy in counter.Count())
{
if (strategy.Count != expectedCount)
{
failures.Add(strategy);
}
}
if (failures.Count == 0)
{
return(null);
}
var builder = new AssertionFailureBuilder(String.Format(
"Expected the sequence to contain a certain number of elements but {0} counting strateg{1} failed.", failures.Count, failures.Count > 1 ? "ies have" : "y has"))
.AddRawExpectedValue(expectedCount);
foreach (var failure in failures)
{
builder.AddRawLabeledValue(String.Format("Actual Value ({0})", failure.Description), failure.Count);
}
return(builder
.SetMessage(messageFormat, messageArgs)
.ToAssertionFailure());
});
}
