public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
IEnumerable<PropertyInfo> propertyInfos =
selectedMembers.OfType<PropertySelectedMemberInfo>().Select(info => info.PropertyInfo);
return obsoleteSelectionRule.SelectProperties(propertyInfos, context).Select(SelectedMemberInfo.Create);
}
public Result(ICaseInfo @case, IProcedure procedure, ISubjectInfo subject, IResultData data)
{
this.@case = @case;
this.procedure = procedure;
this.subject = subject;
this.data = data;
}
public CollectionMemberSubjectInfo(ISubjectInfo subjectInfo)
{
CompileTimeType = subjectInfo.CompileTimeType;
SelectedMemberDescription = subjectInfo.SelectedMemberDescription;
SelectedMemberInfo = subjectInfo.SelectedMemberInfo;
SelectedMemberPath = GetAdjustedPropertyPath(subjectInfo.SelectedMemberPath);
RuntimeType = subjectInfo.RuntimeType;
}
public NestedSelectionContext(ISubjectInfo context, PropertyInfo propertyInfo)
{
PropertyPath = context.PropertyPath.Combine(propertyInfo.Name);
PropertyDescription = context.PropertyDescription.Combine(propertyInfo.Name);
CompileTimeType = propertyInfo.PropertyType;
RuntimeType = propertyInfo.PropertyType;
PropertyInfo = propertyInfo;
}
public NestedSelectionContext(ISubjectInfo context, SelectedMemberInfo selectedMemberInfo)
{
SelectedMemberPath = context.SelectedMemberPath.Combine(selectedMemberInfo.Name);
SelectedMemberDescription = context.SelectedMemberDescription.Combine(selectedMemberInfo.Name);
CompileTimeType = selectedMemberInfo.MemberType;
RuntimeType = selectedMemberInfo.MemberType;
SelectedMemberInfo = selectedMemberInfo;
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
string path = context.SelectedMemberPath;
if (!ContainsIndexingQualifiers(pathToExclude))
{
path = RemoveInitialIndexQualifier(path);
}
return selectedMembers.Where(memberInfo => (path.Combine(memberInfo.Name) != pathToExclude)).ToArray();
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="selectedProperties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.
/// </param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable<PropertyInfo> SelectProperties(IEnumerable<PropertyInfo> selectedProperties, ISubjectInfo context)
{
string propertyPath = context.PropertyPath;
if (!ContainsIndexingQualifiers(propertyPathToExclude))
{
propertyPath = RemoveInitialIndexQualifier(propertyPath);
}
return selectedProperties.Where(pi => propertyPathToExclude != propertyPath.Combine(pi.Name)).ToArray();
}
/// <summary>
/// Determines if ordering of the property refered to by the current <paramref name="subjectInfo"/> is relevant.
/// </summary>
public bool AppliesTo(ISubjectInfo subjectInfo)
{
string currentPropertyPath = subjectInfo.PropertyPath;
if (!ContainsIndexingQualifiers(propertyPath))
{
currentPropertyPath = RemoveInitialIndexQualifier(currentPropertyPath);
}
return currentPropertyPath.Equals(propertyPath, StringComparison.CurrentCultureIgnoreCase);
}
protected override IEnumerable<SelectedMemberInfo> OnSelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers,
string currentPath, ISubjectInfo context)
{
var matchingMembers =
from member in context.RuntimeType.GetNonPrivateMembers()
where pathToInclude.StartsWith(currentPath.Combine(member.Name))
select member;
return selectedMembers.Concat(matchingMembers).ToArray();
}
public IResultData GetSerializationData(ISubjectInfo subject, ICaseInfo @case)
{
return this.items
.Where(x => x.Subject == subject)
.Where(x => x.Case == @case)
.Where(x => x.Procedure.Name == "Serialize")
.Select(x => x.Data)
.DefaultIfEmpty(new NotSupportedRequirementResult())
.FirstOrDefault();
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="properties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable<PropertyInfo> SelectProperties(IEnumerable<PropertyInfo> properties, ISubjectInfo context)
{
var props = new List<PropertyInfo>(properties);
if (!props.Any(p => p.IsEquivalentTo(propertyInfo)))
{
props.Add(propertyInfo);
}
return props;
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
List<SelectedMemberInfo> members = selectedMembers.ToList();
if (!members.Any(member => member.IsEquivalentTo(selectedMemberInfo)))
{
members.Add(selectedMemberInfo);
}
return members;
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context,
IEquivalencyAssertionOptions config)
{
string path = context.SelectedMemberPath;
if (!ContainsIndexingQualifiers(selectedPath))
{
path = RemoveInitialIndexQualifier(path);
}
return OnSelectMembers(selectedMembers, path, context);
}
protected override IEnumerable<SelectedMemberInfo> OnSelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers,
string currentPath, ISubjectInfo context)
{
List<SelectedMemberInfo> members = selectedMembers.ToList();
foreach (SelectedMemberInfo member in context.RuntimeType.GetNonPrivateMembers())
{
if (pathToInclude.Contains(currentPath.Combine(member.Name)))
{
members.Add(member);
}
}
return members;
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
var members = new List<SelectedMemberInfo>(selectedMembers);
foreach (SelectedMemberInfo selectedMemberInfo in context.RuntimeType.GetNonPrivateMembers())
{
if (predicate(new NestedSelectionContext(context, selectedMemberInfo)))
{
if (!members.Any(p => p.IsEquivalentTo(selectedMemberInfo)))
{
members.Add(selectedMemberInfo);
}
}
}
return members;
}
/// <summary>
/// Determines if ordering of the member referred to by the current <paramref name="subjectInfo"/> is relevant.
/// </summary>
public OrderStrictness Evaluate(ISubjectInfo subjectInfo)
{
string currentPropertyPath = subjectInfo.SelectedMemberPath;
if (!ContainsIndexingQualifiers(path))
{
currentPropertyPath = RemoveInitialIndexQualifier(currentPropertyPath);
}
if (currentPropertyPath.Equals(path, StringComparison.CurrentCultureIgnoreCase))
{
return OrderStrictness.Strict;
}
else
{
return OrderStrictness.Irrelevant;
}
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="selectedProperties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable<PropertyInfo> SelectProperties(IEnumerable<PropertyInfo> selectedProperties, ISubjectInfo context)
{
var properties = new List<PropertyInfo>(selectedProperties);
foreach (PropertyInfo propertyInfo in context.RuntimeType.GetNonPrivateProperties())
{
if (predicate(new NestedSelectionContext(context, propertyInfo)))
{
if (!properties.Any(p => p.IsEquivalentTo(propertyInfo)))
{
properties.Add(propertyInfo);
}
}
}
return properties;
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers,
ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return selectionRule.SelectMembers(selectedMembers, new CollectionMemberSubjectInfo(context), config);
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return selectedMembers.Where(p => !predicate(new NestedSelectionContext(context, p))).ToArray();
}
internal static Type GetSubjectType(this IEquivalencyAssertionOptions config, ISubjectInfo context)
{
bool useRuntimeType = ShouldUseRuntimeType(config);
return useRuntimeType ? context.RuntimeType : context.CompileTimeType;
}
protected override IEnumerable <SelectedMemberInfo> OnSelectMembers(IEnumerable <SelectedMemberInfo> selectedMembers,
string currentPath, ISubjectInfo context)
{
var matchingMembers =
from member in context.RuntimeType.GetNonPrivateMembers()
where pathToInclude.StartsWith(currentPath.Combine(member.Name))
select member;
return(selectedMembers.Concat(matchingMembers).ToArray());
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="properties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable<PropertyInfo> SelectProperties(IEnumerable<PropertyInfo> properties, ISubjectInfo context)
{
return properties.Where(p => !predicate(new NestedSelectionContext(context, p))).ToArray();
}
public bool AppliesTo(ISubjectInfo subjectInfo)
{
return subjectInfo.CompileTimeType.Implements<IEnumerable<byte>>();
}
protected override IEnumerable<SelectedMemberInfo> OnSelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers,
string currentPath, ISubjectInfo context)
{
return selectedMembers.Where(memberInfo => (currentPath.Combine(memberInfo.Name) != pathToExclude)).ToArray();
}
protected abstract IEnumerable<SelectedMemberInfo> OnSelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, string currentPath, ISubjectInfo context);
public OrderStrictness Evaluate(ISubjectInfo subjectInfo)
{
return subjectInfo.CompileTimeType.Implements<IEnumerable<byte>>() ? OrderStrictness.Strict : OrderStrictness.Irrelevant;
}
public IEnumerable <SelectedMemberInfo> SelectMembers(IEnumerable <SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return(selectedMembers.Where(pi => !pi.Name.EndsWith("Id")).ToArray());
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="properties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable <PropertyInfo> SelectProperties(IEnumerable <PropertyInfo> properties, ISubjectInfo context)
{
return(context.RuntimeType.GetNonPrivateProperties());
}
public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return
selectedMembers.Union(
config.GetSubjectType(context).GetNonPrivateProperties().Select(SelectedMemberInfo.Create));
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="selectedProperties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.
/// </param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable <PropertyInfo> SelectProperties(IEnumerable <PropertyInfo> selectedProperties, ISubjectInfo context)
{
string propertyPath = context.PropertyPath;
if (!ContainsIndexingQualifiers(propertyPathToExclude))
{
propertyPath = RemoveInitialIndexQualifier(propertyPath);
}
return(selectedProperties.Where(pi => propertyPathToExclude != propertyPath.Combine(pi.Name)).ToArray());
}
public IEnumerable <PropertyInfo> SelectProperties(IEnumerable <PropertyInfo> selectedProperties, ISubjectInfo context)
{
return(selectedProperties.Where(pi => !pi.Name.EndsWith("Id")).ToArray());
}
public IEnumerable<PropertyInfo> SelectProperties(IEnumerable<PropertyInfo> properties, ISubjectInfo context)
{
return properties.Where(pi => !pi.Name.EndsWith("Id")).ToArray();
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="selectedProperties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable <PropertyInfo> SelectProperties(IEnumerable <PropertyInfo> selectedProperties, ISubjectInfo context)
{
return(context.CompileTimeType.GetNonPrivateProperties());
}
/// <summary>
/// Adds or removes properties to/from the collection of subject properties that must be included while
/// comparing two objects for structural equality.
/// </summary>
/// <param name="properties">
/// A collection of properties that was prepopulated by other selection rules. Can be empty.</param>
/// <returns>
/// The collection of properties after applying this rule. Can contain less or more than was passed in.
/// </returns>
public IEnumerable<PropertyInfo> SelectProperties(IEnumerable<PropertyInfo> properties, ISubjectInfo context)
{
return context.RuntimeType.GetNonPrivateProperties();
}
/// <summary>
/// Determines if ordering of the property refered to by the current <paramref name="subjectInfo"/> is relevant.
/// </summary>
public bool AppliesTo(ISubjectInfo subjectInfo)
{
return predicate(subjectInfo);
}
/// <summary>
/// Determines if ordering of the member referred to by the current <paramref name="subjectInfo"/> is relevant.
/// </summary>
public bool AppliesTo(ISubjectInfo subjectInfo)
{
return true;
}
public IEnumerable <SelectedMemberInfo> SelectMembers(IEnumerable <SelectedMemberInfo> selectedMembers, ISubjectInfo context, IEquivalencyAssertionOptions config)
{
return
(selectedMembers.Union(
config.GetSubjectType(context).GetNonPrivateFields().Select(SelectedMemberInfo.Create)));
}
