/// <summary>
/// Checks that the enumerable contains only the values of another enumerable and nothing else, in order.
/// This check should only be used with IEnumerable that have a consistent iteration order
/// (i.e. don't use it with Hashtable, prefer <see cref="IsEquivalentTo" /> in that case).
/// </summary>
/// <param name="check">The fluent check to be extended.</param>
/// <param name="otherEnumerable">The other enumerable containing the exact expected values to be found.</param>
/// <returns>
/// A check link.
/// </returns>
/// <exception cref="FluentCheckException">
/// The enumerable does not contains only the exact given values and nothing else,
/// in order.
/// </exception>
public static ICheckLink <ICheck <IEnumerable> > ContainsExactly(
this ICheck <IEnumerable> check, params object[] otherEnumerable)
{
var properExpectedValues = ExtractEnumerableValueFromSingleEntry(otherEnumerable).Cast <object>();
ImplementContainsExactly(ExtensibilityHelper.BeginCheckAs(check, u => u.Cast <object>()), properExpectedValues);
return(ExtensibilityHelper.BuildCheckLink(check));
}
/// <summary>
/// Checks that the checked <see cref="IEnumerable"/> contains items in the expected order.
/// </summary>
/// <param name="check">
/// The chained fluent check.
/// </param>
/// <returns>
/// A check link.
/// </returns>
public static IExtendableCheckLink <ICheck <IEnumerable>, IEnumerable> InThatOrder(this IExtendableCheckLink <ICheck <IEnumerable>, IEnumerable> check)
{
var orderedList = new List <object>(check.OriginalComparand.Cast <object>());
var checker = ExtensibilityHelper.BeginCheckAs(check.AccessCheck, enumerable => enumerable.Cast <object>());
ImplementInThatOrder(checker, orderedList);
return(check);
}
/// <summary>
/// Checks if the sut contains the same element than a given list.
/// </summary>
/// <param name="context">Context for the check</param>
/// <param name="expectedValues">Expected values</param>
/// <returns>A chainable link.</returns>
public static ICheckLink <ICheck <IEnumerable> > IsEquivalentTo(this ICheck <IEnumerable> context,
params object[] expectedValues)
{
var content = ExtractEnumerableValueFromPossibleOneValueArray(expectedValues);
ImplementEquivalentTo(ExtensibilityHelper.BeginCheckAs(context, enumerable => enumerable.Cast <object>()), content);
return(ExtensibilityHelper.BuildCheckLink(context));
}
/// <summary>
/// Checks that the checked <see cref="IEnumerable"/> contains the expected list of items only once.
/// </summary>
/// <param name="check">
/// The chained fluent check.
/// </param>
/// <returns> bv
/// A check link.
/// </returns>
public static ExtendableCheckLink <ICheck <IEnumerable>, IEnumerable> Once(this ExtendableCheckLink <ICheck <IEnumerable>, IEnumerable> check)
{
IExtendableCheckLink <ICheck <IEnumerable>, IEnumerable> chainedCheckLink = check;
ImplementOnce(
ExtensibilityHelper.BeginCheckAs(chainedCheckLink.AccessCheck, enumerable => enumerable.Cast <object>()),
chainedCheckLink.OriginalComparand.Cast <object>());
return(check);
}
/// <summary>
/// Checks that the enumerable contains all the values present in another enumerable, in any order.
/// </summary>
/// <param name="check">The fluent check to be extended.</param>
/// <param name="otherEnumerable">The enumerable containing the expected values to be found.</param>
/// <returns>
/// A check link.
/// </returns>
/// <exception cref="FluentCheckException">
/// The enumerable does not contain all the expected values present in the other enumerable.
/// </exception>
public static ExtendableCheckLink <ICheck <IEnumerable>, IEnumerable> Contains(
this ICheck <IEnumerable> check, params object[] otherEnumerable)
{
var properExpectedValues = ExtractEnumerableValueFromSingleEntry(otherEnumerable).Cast <object>();
var checker = ExtensibilityHelper.BeginCheckAs(check, enumerable => enumerable.Cast <object>());
ImplementContains(checker, properExpectedValues);
return(ExtensibilityHelper.BuildExtendableCheckLink(check, (IEnumerable)properExpectedValues));
}
/// <summary>
/// Checks that the enumerable contains only the given values and nothing else, in any order.
/// Note: this check succeeded with empty value.
/// </summary>
/// <param name="check">The fluent check to be extended.</param>
/// <param name="expectedValues">The expected values to be found.</param>
/// <returns>
/// A check link.
/// </returns>
/// <exception cref="FluentCheckException">The enumerable does not contain only the expected values provided.</exception>
public static ICheckLink <ICheck <IEnumerable> > IsOnlyMadeOf(
this ICheck <IEnumerable> check,
params object[] expectedValues)
{
var properExpectedValues = ExtractEnumerableValueFromSingleEntry(expectedValues);
ImplementIsOnlyMadeOf(ExtensibilityHelper.BeginCheckAs(check, enumerable => enumerable.Cast <object>()), properExpectedValues);
return(ExtensibilityHelper.BuildCheckLink(check));
}
/// <summary>
/// Checks if the sut contains the same element than a given list.
/// </summary>
/// <param name="context">Context for the check</param>
/// <param name="content"></param>
/// <returns>A chainable link.</returns>
public static ICheckLink <ICheck <IEnumerable> > IsEquivalentTo(this ICheck <IEnumerable> context,
params object[] content)
{
ImplementEquivalentTo(ExtensibilityHelper.BeginCheckAs(context, enumerable => enumerable.Cast <object>()), content);
return(ExtensibilityHelper.BuildCheckLink(context));
}