public void FailureExcludesOptionalMessageWhenOmitted()
{
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => true, false, null);
Assert.IsNotNull(failure);
Assert.IsNull(failure.Message);
}
public void Accept(AssertionFailure failure)
{
_inner.Accept(new AssertionFailure(
failure,
"{0}", new object[] { Render(failure) }
));
}
public void FailureIncludesStackTrace()
{
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => true, false, null);
Assert.IsNotNull(failure);
Assert.Contains(failure.StackTrace.ToString(), "FailureIncludesStackTrace");
}
public void FailureIncludesOptionalMessageWhenProvided()
{
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => true, false, "Expected {0}", "true");
Assert.IsNotNull(failure);
Assert.AreEqual("Expected true", failure.Message);
}
private static void AssertCommonFailureLabeledValues(AssertionFailure failure, string target, string attribute)
{
Assert.AreEqual("Target Object", failure.LabeledValues[0].Label);
Assert.AreEqual("MbUnit.Tests.Framework.AssertTest_HasAttribute." + target, failure.LabeledValues[0].FormattedValue.ToString());
Assert.AreEqual("Attribute Type", failure.LabeledValues[1].Label);
Assert.AreEqual("MbUnit.Tests.Framework.AssertTest_HasAttribute." + attribute, failure.LabeledValues[1].FormattedValue.ToString());
}
public void Accept(AssertionFailure failure)
{
foreach (var tool in _tools)
{
tool.Accept(failure);
}
}
public void AssertionFailure()
{
var ex = new AssertionFailure();
Assert.That(
() => SerializationHelper.Deserialize(SerializationHelper.Serialize(ex)),
Throws.Nothing);
}
private void ActiveRunner_OnTestComplete(Test test, AssertionFailure failure)
{
var e2etest = test.UserData as E2ETest;
e2etest.IsCompleted = true;
completionCount++;
e2etest.ErrorMessage = failure?.ToString();
NotifyListeners(test, failure);
}
public void Accept(AssertionFailure failure)
{
Trace.Write("Assertion Failure - ");
Trace.WriteLine(failure.Message);
if (failure.CombinedException != null)
{
Trace.WriteLine(failure.CombinedException.ToString());
}
}
public void FailureDescribesExpectedResultAndConditionAndParameters(bool expectedResult)
{
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => !expectedResult, expectedResult, null);
Assert.IsNotNull(failure);
Assert.AreEqual(String.Format("Expected the condition to evaluate to {0}.", expectedResult.ToString().ToLowerInvariant()), failure.Description);
Assert.AreElementsEqual(new[] {
new AssertionFailure.LabeledValue("Condition", "! expectedResult"),
new AssertionFailure.LabeledValue("expectedResult", Formatter.Instance.Format(expectedResult)),
}, failure.LabeledValues);
}
/// <summary>
/// Verifies that a particular condition holds true.
/// </summary>
/// <remarks>
/// <para>
/// If the condition evaluates to false, the assertion failure message will
/// describe in detail the intermediate value of relevant sub-expressions within
/// the condition. Consequently the assertion failure will include more diagnostic
/// information than if <see cref="Assert.IsTrue(bool, string, object[])" /> were used instead.
/// </para>
/// </remarks>
/// <param name="condition">The conditional expression to evaluate.</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="ArgumentNullException">Thrown if <paramref name="condition"/> is null.</exception>
/// <exception cref="AssertionException">Thrown if the verification failed unless the current <see cref="AssertionContext.AssertionFailureBehavior" /> indicates otherwise.</exception>
public static void That(Expression <System.Func <bool> > condition, string messageFormat, params object[] messageArgs)
{
if (condition == null)
{
throw new ArgumentNullException("condition");
}
AssertionFailure failure = AssertionConditionEvaluator.Eval(condition, true, messageFormat, messageArgs);
AssertionHelper.Fail(failure);
}
public void FailureMessageIgnoresValueOfTopLevelNotExpression()
{
int x = 42;
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => !(x.ToString() == "42"), true, null);
Assert.IsNotNull(failure);
Assert.AreElementsEqual(new[] {
new AssertionFailure.LabeledValue("Condition", "! (x.ToString() == \"42\")"),
new AssertionFailure.LabeledValue("x.ToString()", "\"42\""),
new AssertionFailure.LabeledValue("x", "42"),
}, failure.LabeledValues);
}
/// <summary>
/// Notifies all listeners of a test update
/// </summary>
/// <param name="test">The test to notify for, or null to indicate that all tests have completed</param>
/// <param name="failure">The failure (or null if the test succeeded)</param>
private static void NotifyListeners(Test test, AssertionFailure failure)
{
List <TaskCompletionSource <Tuple <Test, AssertionFailure> > > list = null;
lock (listeners)
{
list = listeners.ToList();
listeners.Clear();
}
foreach (var listener in list)
{
listener.SetResult(new Tuple <Test, AssertionFailure>(test, failure));
}
}
public void FailureDescribesException()
{
object x = null;
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => x.Equals(null), true, null);
Assert.IsNotNull(failure);
Assert.AreEqual("Expected the condition to evaluate to true but it threw an exception.", failure.Description);
Assert.AreElementsEqual(new[] {
new AssertionFailure.LabeledValue("Condition", "x.Equals(null)"),
new AssertionFailure.LabeledValue("x", "null"),
}, failure.LabeledValues);
Assert.Count(1, failure.Exceptions);
Assert.Contains(failure.Exceptions[0].ToString(), "NullReferenceException");
}
public void FailureMessageIgnoresRepeatedOccurrencesOfAVariable()
{
int x = 42;
AssertionFailure failure = AssertionConditionEvaluator.Eval(() => x * 2 == x + 1, true, null);
Assert.IsNotNull(failure);
Assert.AreElementsEqual(new[] {
new AssertionFailure.LabeledValue("Condition", "x * 2 == x + 1"),
new AssertionFailure.LabeledValue("x * 2", "84"),
new AssertionFailure.LabeledValue("x + 1", "43"),
new AssertionFailure.LabeledValue("x", "42")
}, failure.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 Accept(AssertionSuccess assertionSuccess)
{
var inverted = new AssertionFailure(assertionSuccess);
_inner.Accept(inverted);
}
public void Accept(AssertionFailure failure)
{
var inverted = new AssertionSuccess(failure);
_inner.Accept(inverted);
}
public void Accept(AssertionFailure failure)
{
}
public void Accept(AssertionFailure failure)
{
var next = Dequeue(failure);
next.Check(_inner, failure);
}
public void Accept(AssertionFailure failure)
{
_inner.Accept(failure);
}
public void Accept(AssertionFailure failure)
{
throw new Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException(failure.Message, failure.CombinedException);
}
public void Accept(AssertionFailure failure)
{
_memory.Add(failure);
failureCount++;
}