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