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>
/// 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 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();
});
}
