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