/// <summary>
/// Verifies that the given collection contains only a single
/// element of the given type which matches the given predicate. The
/// collection may or may not contain other values which do not
/// match the given predicate.
/// </summary>
/// <typeparam name="T">The collection type.</typeparam>
/// <param name="collection">The collection.</param>
/// <param name="predicate">The item matching predicate.</param>
/// <returns>The single item in the filtered collection.</returns>
/// <exception cref="SingleException">Thrown when the filtered collection does
/// not contain exactly one element.</exception>
public static T Single <T>(this IAssert assert, IEnumerable <T> collection, Predicate <T> predicate)
{
Guard.ArgumentNotNull("collection", collection);
Guard.ArgumentNotNull("predicate", predicate);
int count = 0;
T result = default(T);
foreach (T item in collection)
{
if (predicate(item))
{
result = item;
++count;
}
}
if (count != 1)
{
assert.Fail(new SingleException(count));
}
assert.Okay();
return(result);
}
/// <summary>
/// Verifies that the provided object raised INotifyPropertyChanged.PropertyChanged
/// as a result of executing the given test code.
/// </summary>
/// <param name="object">The object which should raise the notification</param>
/// <param name="propertyName">The property name for which the notification should be raised</param>
/// <param name="testCode">The test code which should cause the notification to be raised</param>
/// <exception cref="PropertyChangedException">Thrown when the notification is not raised</exception>
public static void PropertyChanged(this IAssert assert, INotifyPropertyChanged @object, string propertyName, Action testCode)
{
Guard.ArgumentNotNull("object", @object);
Guard.ArgumentNotNull("testCode", testCode);
bool propertyChangeHappened = false;
PropertyChangedEventHandler handler = (sender, args) =>
{
if (propertyName.Equals(args.PropertyName, StringComparison.OrdinalIgnoreCase))
{
propertyChangeHappened = true;
}
};
@object.PropertyChanged += handler;
try
{
testCode();
if (!propertyChangeHappened)
{
assert.Fail(new PropertyChangedException(propertyName));
}
assert.Okay();
}
finally
{
@object.PropertyChanged -= handler;
}
}
/// <summary>
/// Verifies that two objects are the same instance.
/// </summary>
/// <param name="expected">The expected object instance</param>
/// <param name="actual">The actual object instance</param>
/// <exception cref="SameException">Thrown when the objects are not the same instance</exception>
public static void Same(this IAssert assert, object expected, object actual)
{
if (!object.ReferenceEquals(expected, actual))
{
assert.Fail(new SameException(expected, actual));
}
assert.Okay();
}
/// <summary>
/// Verifies that a string does not contain a given sub-string, using the current culture.
/// </summary>
/// <param name="expectedSubstring">The sub-string which is expected not to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="DoesNotContainException">Thrown when the sub-string is present inside the given string</exception>
public static void DoesNotContain(this IAssert assert, string expectedSubstring, string actualString, StringComparison comparisonType)
{
if (actualString != null && actualString.IndexOf(expectedSubstring, comparisonType) >= 0)
{
assert.Fail(new DoesNotContainException(expectedSubstring));
}
assert.Okay();
}
/// <summary>
/// Verifies that a string contains a given sub-string, using the given comparison type.
/// </summary>
/// <param name="expectedSubstring">The sub-string expected to be in the string</param>
/// <param name="actualString">The string to be inspected</param>
/// <param name="comparisonType">The type of string comparison to perform</param>
/// <exception cref="ContainsException">Thrown when the sub-string is not present inside the string</exception>
public static void Contains(this IAssert assert, string expectedSubstring, string actualString, StringComparison comparisonType)
{
if (actualString == null || actualString.IndexOf(expectedSubstring, comparisonType) < 0)
{
assert.Fail(new ContainsException(expectedSubstring, actualString));
}
assert.Okay();
}
/// <summary>
/// Verifies that an object reference is null.
/// </summary>
/// <param name="object">The object to be inspected</param>
/// <exception cref="NullException">Thrown when the object reference is not null</exception>
public static void Null(this IAssert assert, object @object)
{
if (@object != null)
{
assert.Fail(new NullException(@object));
}
assert.Okay();
}
/// <summary>
/// Verifies that a value is not within a given range, using a comparer.
/// </summary>
/// <typeparam name="T">The type of the value to be compared</typeparam>
/// <param name="actual">The actual value to be evaluated</param>
/// <param name="low">The (inclusive) low value of the range</param>
/// <param name="high">The (inclusive) high value of the range</param>
/// <param name="comparer">The comparer used to evaluate the value's range</param>
/// <exception cref="NotInRangeException">Thrown when the value is in the given range</exception>
public static void NotInRange <T>(this IAssert assert, T actual, T low, T high, IComparer <T> comparer)
{
Guard.ArgumentNotNull("comparer", comparer);
if (comparer.Compare(low, actual) <= 0 && comparer.Compare(actual, high) <= 0)
{
assert.Fail(new NotInRangeException(actual, low, high));
}
assert.Okay();
}
/// <summary>
/// Verifies that two objects are not equal, using a custom equality comparer.
/// </summary>
/// <typeparam name="T">The type of the objects to be compared</typeparam>
/// <param name="expected">The expected object</param>
/// <param name="actual">The actual object</param>
/// <param name="comparer">The comparer used to examine the objects</param>
/// <exception cref="NotEqualException">Thrown when the objects are equal</exception>
public static void NotEqual <T>(this IAssert assert, T expected, T actual, IEqualityComparer <T> comparer)
{
Guard.ArgumentNotNull("comparer", comparer);
if (comparer.Equals(expected, actual))
{
assert.Fail(new NotEqualException());
}
assert.Okay();
}
/// <summary>
/// Verifies that an object is exactly the given type (and not a derived type).
/// </summary>
/// <param name="expectedType">The type the object should be</param>
/// <param name="object">The object to be evaluated</param>
/// <exception cref="IsTypeException">Thrown when the object is not the given type</exception>
public static void IsType(this IAssert assert, Type expectedType, object @object)
{
Guard.ArgumentNotNull("expectedType", expectedType);
if (@object == null || !expectedType.Equals(@object.GetType()))
{
assert.Fail(new IsTypeException(expectedType, @object));
}
assert.Okay();
}
/// <summary>
/// Verifies that a block of code does not throw any exceptions.
/// </summary>
/// <param name="testCode">A delegate to the code to be tested</param>
public static void DoesNotThrow(this IAssert assert, Func <object> testCode)
{
Exception ex = Record.Exception(testCode);
if (ex != null)
{
assert.Fail(new DoesNotThrowException(ex));
}
assert.Okay();
}
public static void Empty(this IAssert assert, IEnumerable collection)
{
Guard.ArgumentNotNull("collection", collection);
#pragma warning disable 168
foreach (object @object in collection)
{
assert.Fail(new EmptyException());
}
#pragma warning restore 168
assert.Okay();
}
/// <summary>
/// Verifies that two <see cref="decimal"/> values are equal, within the number of decimal
/// places given by <paramref name="precision"/>.
/// </summary>
/// <param name="expected">The expected value</param>
/// <param name="actual">The value to be compared against</param>
/// <param name="precision">The number of decimal places (valid values: 0-15)</param>
/// <exception cref="EqualException">Thrown when the values are not equal</exception>
public static void Equal(this IAssert assert, decimal expected, decimal actual, int precision)
{
var expectedRounded = Math.Round(expected, precision);
var actualRounded = Math.Round(actual, precision);
if (!GetEqualityComparer <decimal>().Equals(expectedRounded, actualRounded))
{
assert.Fail(new EqualException(
String.Format(CultureInfo.CurrentCulture, "{0} (rounded from {1})", expectedRounded, expected),
String.Format(CultureInfo.CurrentCulture, "{0} (rounded from {1})", actualRounded, actual)
));
}
assert.Okay();
}
public static void That(this IAssert assert, ActualValueDelegate actual, IResolveConstraint expression, string message = null)
{
Constraint constraint = expression.Resolve();
if (constraint.Matches(actual))
{
assert.Okay();
return;
}
using (MessageWriter writer = new TextMessageWriter(message))
{
constraint.WriteMessageTo(writer);
assert.Fail(writer.ToString(), ExcludeFromStack);
}
}
/// <summary>
/// Verifies that a collection does not contain a given object, using an equality comparer.
/// </summary>
/// <typeparam name="T">The type of the object to be compared</typeparam>
/// <param name="expected">The object that is expected not to be in the collection</param>
/// <param name="collection">The collection to be inspected</param>
/// <param name="comparer">The comparer used to equate objects in the collection with the expected object</param>
/// <exception cref="DoesNotContainException">Thrown when the object is present inside the container</exception>
public static void DoesNotContain <T>(this IAssert assert, T expected, IEnumerable <T> collection, IEqualityComparer <T> comparer)
{
Guard.ArgumentNotNull("comparer", comparer);
if (collection != null)
{
foreach (T item in collection)
{
if (comparer.Equals(expected, item))
{
assert.Fail(new DoesNotContainException(expected));
}
}
}
assert.Okay();
}
/// <summary>
/// Verifies that the exact exception is thrown (and not a derived exception type).
/// Generally used to test property accessors.
/// </summary>
/// <param name="exceptionType">The type of the exception expected to be thrown</param>
/// <param name="testCode">A delegate to the code to be tested</param>
/// <returns>The exception that was thrown, when successful</returns>
/// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
public static Exception Throws(this IAssert assert, Type exceptionType, Func <object> testCode)
{
Guard.ArgumentNotNull("exceptionType", exceptionType);
Exception exception = Record.Exception(testCode);
if (exception == null)
{
assert.Fail(new ThrowsException(exceptionType));
}
if (!exceptionType.Equals(exception.GetType()))
{
assert.Fail(new ThrowsException(exceptionType, exception));
}
assert.Okay();
return(exception);
}
/// <summary>
/// Verifies that the given collection contains only a single
/// element of the given value. The collection may or may not
/// contain other values.
/// </summary>
/// <param name="collection">The collection.</param>
/// <param name="expected">The value to find in the collection.</param>
/// <returns>The single item in the collection.</returns>
/// <exception cref="SingleException">Thrown when the collection does not contain
/// exactly one element.</exception>
public static void Single(this IAssert assert, IEnumerable collection, object expected)
{
Guard.ArgumentNotNull("collection", collection);
int count = 0;
foreach (object item in collection)
{
if (Object.Equals(item, expected))
{
++count;
}
}
if (count != 1)
{
assert.Fail(new SingleException(count, expected));
}
assert.Okay();
}
/// <summary>
/// Verifies that the given collection contains only a single
/// element of the given type.
/// </summary>
/// <param name="collection">The collection.</param>
/// <returns>The single item in the collection.</returns>
/// <exception cref="SingleException">Thrown when the collection does not contain
/// exactly one element.</exception>
public static object Single(this IAssert assert, IEnumerable collection)
{
Guard.ArgumentNotNull("collection", collection);
int count = 0;
object result = null;
foreach (object item in collection)
{
result = item;
++count;
}
if (count != 1)
{
assert.Fail(new SingleException(count));
}
assert.Okay();
return(result);
}
/// <summary>
/// Verifies that two strings are equivalent.
/// </summary>
/// <param name="expected">The expected string value.</param>
/// <param name="actual">The actual string value.</param>
/// <param name="ignoreCase">If set to <c>true</c>, ignores cases differences. The invariant culture is used.</param>
/// <param name="ignoreLineEndingDifferences">If set to <c>true</c>, treats \r\n, \r, and \n as equivalent.</param>
/// <param name="ignoreWhiteSpaceDifferences">If set to <c>true</c>, treats spaces and tabs (in any non-zero quantity) as equivalent.</param>
/// <exception cref="EqualException">Thrown when the strings are not equivalent.</exception>
public static void Equal(this IAssert assert, string expected, string actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false)
{
// Start out assuming the one of the values is null
int expectedIndex = -1;
int actualIndex = -1;
int expectedLength = 0;
int actualLength = 0;
if (expected == null)
{
if (actual == null)
{
return;
}
}
else if (actual != null)
{
// Walk the string, keeping separate indices since we can skip variable amounts of
// data based on ignoreLineEndingDifferences and ignoreWhiteSpaceDifferences.
expectedIndex = 0;
actualIndex = 0;
expectedLength = expected.Length;
actualLength = actual.Length;
while (expectedIndex < expectedLength && actualIndex < actualLength)
{
char expectedChar = expected[expectedIndex];
char actualChar = actual[actualIndex];
if (ignoreLineEndingDifferences && IsLineEnding(expectedChar) && IsLineEnding(actualChar))
{
expectedIndex = SkipLineEnding(expected, expectedIndex);
actualIndex = SkipLineEnding(actual, actualIndex);
}
else if (ignoreWhiteSpaceDifferences && IsWhiteSpace(expectedChar) && IsWhiteSpace(actualChar))
{
expectedIndex = SkipWhitespace(expected, expectedIndex);
actualIndex = SkipWhitespace(actual, actualIndex);
}
else
{
if (ignoreCase)
{
expectedChar = Char.ToUpperInvariant(expectedChar);
actualChar = Char.ToUpperInvariant(actualChar);
}
if (expectedChar != actualChar)
{
break;
}
expectedIndex++;
actualIndex++;
}
}
}
if (expectedIndex < expectedLength || actualIndex < actualLength)
{
assert.Fail(new EqualException(expected, actual, expectedIndex, actualIndex));
}
assert.Okay();
}