/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return ((subjectType != null) && subjectType.IsEnum()) ||
((context.Expectation != null) && context.Expectation.GetType().IsEnum());
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return(((subjectType != null) && subjectType.IsEnum()) ||
((context.Expectation != null) && context.Expectation.GetType().IsEnum()));
}
private static void AssertDictionaryEquivalence(
IEquivalencyValidationContext context,
IEquivalencyValidator parent,
IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
string methodName =
ExpressionExtensions.GetMethodName(
() => AssertDictionaryEquivalence <object, object, object, object>(null, null, null, null, null));
var assertDictionaryEquivalence = Expression.Call(
typeof(GenericDictionaryEquivalencyStep),
methodName,
GetDictionaryTypeArguments(subjectType)
.Concat(GetDictionaryTypeArguments(context.Expectation.GetType()))
.ToArray(),
Expression.Constant(context),
Expression.Constant(parent),
Expression.Constant(config),
Expression.Constant(context.Subject, GetIDictionaryInterface(subjectType)),
Expression.Constant(context.Expectation, GetIDictionaryInterface(context.Expectation.GetType())));
Expression.Lambda(assertDictionaryEquivalence).Compile().DynamicInvoke();
}
private static bool PreconditionsAreMet(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return(AssertImplementsOnlyOneDictionaryInterface(context.Subject) &&
AssertIsCompatiblyTypedDictionary(subjectType, context.Expectation) &&
AssertSameLength(context.Subject, subjectType, context.Expectation));
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type type = config.GetSubjectType(context);
return
((type != null) &&
(type != typeof(object)) &&
config.IsValueType(type) &&
!type.IsArray);
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type type = config.GetSubjectType(context);
return
(type != null) &&
(type != typeof (object)) &&
config.IsValueType(type) &&
!type.IsArray;
}
public IEnumerable <SelectedMemberInfo> SelectMembers(
IEnumerable <SelectedMemberInfo> selectedMembers,
ISubjectInfo context,
IEquivalencyAssertionOptions config)
{
return(selectedMembers.Except(
config.GetSubjectType(context)
.GetNonPrivateProperties()
.Where(p => p.GetMethod.IsAssembly)
.Select(SelectedMemberInfo.Create)));
}
/// <summary>
/// Applies a step as part of the task to compare two objects for structural equality.
/// </summary>
/// <value>
/// Should return <c>true</c> if the subject matches the expectation or if no additional assertions
/// have to be executed. Should return <c>false</c> otherwise.
/// </value>
/// <remarks>
/// May throw when preconditions are not met or if it detects mismatching data.
/// </remarks>
public bool Handle(IEquivalencyValidationContext context, IEquivalencyValidator parent, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
Type[] interfaces = GetIEnumerableInterfaces(subjectType);
bool multipleInterfaces = (interfaces.Count() > 1);
if (multipleInterfaces)
{
IEnumerable<Type> enumerableTypes = interfaces.Select(
type => type.GetGenericArguments().Single());
AssertionScope.Current.FailWith(
String.Format(
"{{context:Subject}} is enumerable for more than one type. " +
"It is not known which type should be use for equivalence.{0}" +
"IEnumerable is implemented for the following types: {1}",
Environment.NewLine,
String.Join(", ", enumerableTypes)));
}
if (AssertExpectationIsCollection(context.Expectation))
{
var validator = new EnumerableEquivalencyValidator(parent, context)
{
Recursive = context.IsRoot || config.IsRecursive,
OrderingRules = config.OrderingRules
};
Type typeOfEnumeration = GetTypeOfEnumeration(subjectType);
Expression subjectToArray = ToArray(context.Subject, typeOfEnumeration);
Expression expectationToArray =
Expression.Constant(EnumerableEquivalencyStep.ToArray(context.Expectation));
MethodCallExpression executeExpression = Expression.Call(
Expression.Constant(validator),
ExpressionExtensions.GetMethodName(() => validator.Execute<object>(null,null)),
new Type[] { typeOfEnumeration },
subjectToArray,
expectationToArray);
Expression.Lambda(executeExpression).Compile().DynamicInvoke();
}
return true;
}
/// <summary>
/// Applies a step as part of the task to compare two objects for structural equality.
/// </summary>
/// <value>
/// Should return <c>true</c> if the subject matches the expectation or if no additional assertions
/// have to be executed. Should return <c>false</c> otherwise.
/// </value>
/// <remarks>
/// May throw when preconditions are not met or if it detects mismatching data.
/// </remarks>
public bool Handle(IEquivalencyValidationContext context, IEquivalencyValidator parent, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
Type[] interfaces = GetIEnumerableInterfaces(subjectType);
bool multipleInterfaces = (interfaces.Count() > 1);
if (multipleInterfaces)
{
IEnumerable <Type> enumerableTypes = interfaces.Select(
type => type.GetGenericArguments().Single());
AssertionScope.Current.FailWith(
String.Format(
"{{context:Subject}} is enumerable for more than one type. " +
"It is not known which type should be use for equivalence.{0}" +
"IEnumerable is implemented for the following types: {1}",
Environment.NewLine,
String.Join(", ", enumerableTypes)));
}
if (AssertExpectationIsCollection(context.Expectation))
{
var validator = new EnumerableEquivalencyValidator(parent, context)
{
Recursive = context.IsRoot || config.IsRecursive,
OrderingRules = config.OrderingRules
};
Type typeOfEnumeration = GetTypeOfEnumeration(subjectType);
Expression subjectToArray = ToArray(context.Subject, typeOfEnumeration);
Expression expectationToArray =
Expression.Constant(EnumerableEquivalencyStep.ToArray(context.Expectation));
MethodCallExpression executeExpression = Expression.Call(
Expression.Constant(validator),
ExpressionExtensions.GetMethodName(() => validator.Execute <object>(null, null)),
new Type[] { typeOfEnumeration },
subjectToArray,
expectationToArray);
Expression.Lambda(executeExpression).Compile().DynamicInvoke();
}
return(true);
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type type = config.GetSubjectType(context);
bool canHandle =
(type != null) &&
(type != typeof(object)) &&
config.IsValueType(type) &&
!type.IsArray;
if (canHandle)
{
context.TraceSingle(path => $"Treating {path} as a value type");
}
return(canHandle);
}
/// <summary>
/// Applies a step as part of the task to compare two objects for structural equality.
/// </summary>
/// <value>
/// Should return <c>true</c> if the subject matches the expectation or if no additional assertions
/// have to be executed. Should return <c>false</c> otherwise.
/// </value>
/// <remarks>
/// May throw when preconditions are not met or if it detects mismatching data.
/// </remarks>
public bool Handle(IEquivalencyValidationContext context, IEquivalencyValidator parent,
IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
var interfaceTypes = GetIEnumerableInterfaces(subjectType)
.Select(type => "IEnumerable<" + type.GetGenericArguments().Single() + ">")
.ToList();
AssertionScope.Current
.ForCondition(interfaceTypes.Count() == 1)
.FailWith("{context:Subject} implements {0}, so cannot determine which one " +
"to use for asserting the equivalency of the collection. ", interfaceTypes);
if (AssertExpectationIsCollection(context.Expectation, context.Subject))
{
var validator = new EnumerableEquivalencyValidator(parent, context)
{
Recursive = context.IsRoot || config.IsRecursive,
OrderingRules = config.OrderingRules
};
Type typeOfEnumeration = GetTypeOfEnumeration(subjectType);
Expression subjectToArray = ToArray(context.Subject, typeOfEnumeration);
Expression expectationToArray =
Expression.Constant(EnumerableEquivalencyStep.ToArray(context.Expectation));
MethodCallExpression executeExpression = Expression.Call(
Expression.Constant(validator),
ExpressionExtensions.GetMethodName(() => validator.Execute<object>(null, null)),
new[] {typeOfEnumeration},
subjectToArray,
expectationToArray);
Expression.Lambda(executeExpression).Compile().DynamicInvoke();
}
return true;
}
/// <summary>
/// Applies a step as part of the task to compare two objects for structural equality.
/// </summary>
/// <value>
/// Should return <c>true</c> if the subject matches the expectation or if no additional assertions
/// have to be executed. Should return <c>false</c> otherwise.
/// </value>
/// <remarks>
/// May throw when preconditions are not met or if it detects mismatching data.
/// </remarks>
public bool Handle(IEquivalencyValidationContext context, IEquivalencyValidator parent,
IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
var interfaceTypes = GetIEnumerableInterfaces(subjectType)
.Select(type => "IEnumerable<" + type.GetGenericArguments().Single() + ">")
.ToList();
AssertionScope.Current
.ForCondition(interfaceTypes.Count() == 1)
.FailWith("{context:Subject} implements {0}, so cannot determine which one " +
"to use for asserting the equivalency of the collection. ", interfaceTypes);
if (AssertExpectationIsCollection(context.Expectation, context.Subject))
{
var validator = new EnumerableEquivalencyValidator(parent, context)
{
Recursive = context.IsRoot || config.IsRecursive,
OrderingRules = config.OrderingRules
};
Type typeOfEnumeration = GetTypeOfEnumeration(subjectType);
Expression subjectToArray = ToArray(context.Subject, typeOfEnumeration);
Expression expectationToArray =
Expression.Constant(EnumerableEquivalencyStep.ToArray(context.Expectation));
MethodCallExpression executeExpression = Expression.Call(
Expression.Constant(validator),
ExpressionExtensions.GetMethodName(() => validator.Execute <object>(null, null)),
new[] { typeOfEnumeration },
subjectToArray,
expectationToArray);
Expression.Lambda(executeExpression).Compile().DynamicInvoke();
}
return(true);
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return(subjectType != null && subjectType.IsEnum);
}
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
var subjectType = config.GetSubjectType(context);
return(subjectType != null && subjectType == _enumType && context.Expectation is string);
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return typeof(IDictionary).IsAssignableFrom(subjectType);
}
/// <summary>
/// Gets a value indicating whether this step can handle the verificationScope subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
var subjectType = config.GetSubjectType(context);
return (context.Subject != null) && IsGenericCollection(subjectType);
}
/// <summary>
/// Gets a value indicating whether this step can handle the verificationScope subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return(IsCollection(subjectType));
}
/// <summary>
/// Gets a value indicating whether this step can handle the verificationScope subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
var subjectType = config.GetSubjectType(context);
return((context.Subject != null) && IsGenericCollection(subjectType));
}
/// <summary>
/// Gets a value indicating whether this step can handle the verificationScope subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return IsCollection(subjectType);
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return subjectType != null && subjectType.IsEnum;
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return
selectedMembers.Union(
config.GetSubjectType(context).GetNonPrivateProperties().Select(SelectedMemberInfo.Create));
}
public IEnumerable <SelectedMemberInfo> SelectMembers(IEnumerable <SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return
(selectedMembers.Union(
config.GetSubjectType(context).GetNonPrivateProperties().Select(SelectedMemberInfo.Create)));
}
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return((context.Subject != null) && GetIDictionaryInterfaces(subjectType).Any());
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return(typeof(IDictionary).IsAssignableFrom(subjectType));
}
/// <summary>
/// Gets a value indicating whether this step can handle the current subject and/or expectation.
/// </summary>
public bool CanHandle(IEquivalencyValidationContext context, IEquivalencyAssertionOptions config)
{
Type subjectType = config.GetSubjectType(context);
return((subjectType != null) && (subjectType == typeof(string)));
}