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);
}
/// <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>
/// 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);
}
}
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);
}
/// <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);
});
}
/// <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());
});
}
private static T Deserialize <T>(Stream stream, IFormatter formatter, string messageFormat, object[] messageArgs, GallioFunc <T> originalValueProvider)
{
if (formatter == null)
{
throw new ArgumentNullException("formatter");
}
T deserializedValue = default(T);
AssertionHelper.Verify(delegate
{
if (stream == null)
{
return(new AssertionFailureBuilder("Could not deserialize the value because the stream is null.")
.SetMessage(messageFormat, messageArgs)
.ToAssertionFailure());
}
try
{
deserializedValue = (T)formatter.Deserialize(stream);
}
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.ToAssertionFailure());
}
return(null);
});
return(deserializedValue);
}
public void AddRawLabeledValueThrowsIfLabelIsNull()
{
AssertionFailureBuilder builder = new AssertionFailureBuilder("Description");
Assert.Throws <ArgumentNullException>(() => builder.AddRawLabeledValue(null, "abc"));
}
