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