public SelectedMemberInfo Match(SelectedMemberInfo expectedMember, object subject, string memberPath, IEquivalencyAssertionOptions config)
        {
            SelectedMemberInfo compareeSelectedMemberInfoInfo = null;

            if (config.IncludeProperties)
            {
                compareeSelectedMemberInfoInfo = SelectedMemberInfo.Create(subject.GetType()
                                                                           .FindProperty(expectedMember.Name, expectedMember.MemberType));
            }

            if ((compareeSelectedMemberInfoInfo is null) && config.IncludeFields)
            {
                compareeSelectedMemberInfoInfo = SelectedMemberInfo.Create(subject.GetType()
                                                                           .FindField(expectedMember.Name, expectedMember.MemberType));
            }

            if ((compareeSelectedMemberInfoInfo is null || !config.UseRuntimeTyping) && ExpectationImplementsMemberExplicitly(subject, expectedMember))
            {
                compareeSelectedMemberInfoInfo = expectedMember;
            }

            if (compareeSelectedMemberInfoInfo is null)
            {
                string path = (memberPath.Length > 0) ? memberPath + "." : "member ";

                Execute.Assertion.FailWith(
                    "Expectation has " + path + expectedMember.Name + " that the other object does not have.");
            }

            return(compareeSelectedMemberInfoInfo);
        }
        public static SelectedMemberInfo GetSelectedMemberInfo <T, TValue>(this Expression <Func <T, TValue> > expression)
        {
            if (ReferenceEquals(expression, null))
            {
                throw new ArgumentNullException(nameof(expression), "Expected an expression, but found <null>.");
            }

            MemberInfo memberInfo = AttemptToGetMemberInfoFromCastExpression(expression) ??
                                    AttemptToGetMemberInfoFromMemberExpression(expression);

            if (memberInfo != null)
            {
                var propertyInfo = memberInfo as PropertyInfo;
                if (propertyInfo != null)
                {
                    return(SelectedMemberInfo.Create(propertyInfo));
                }

                var fieldInfo = memberInfo as FieldInfo;
                if (fieldInfo != null)
                {
                    return(SelectedMemberInfo.Create(fieldInfo));
                }
            }

            throw new ArgumentException(
                      string.Format("Expression <{0}> cannot be used to select a member.", expression.Body),
                      nameof(expression));
        }
            public SelectedMemberInfo Match(SelectedMemberInfo subjectMember, object expectation, string memberPath, IEquivalencyAssertionOptions config)
            {
                string name = subjectMember.Name;
                if (name.EndsWith("Id"))
                {
                    name = name.Replace("Id", "");
                }

                return SelectedMemberInfo.Create(expectation.GetType().GetRuntimeProperty(name));
            }
Exemple #4
0
        public SelectedMemberInfo Match(SelectedMemberInfo subjectMember, object expectation, string memberPath,
                                        IEquivalencyAssertionOptions config)
        {
            var propertySelectedMemberInfo = subjectMember as PropertySelectedMemberInfo;

            if (propertySelectedMemberInfo != null)
            {
                return
                    (SelectedMemberInfo.Create(obsoleteMatchingRule.Match(propertySelectedMemberInfo.PropertyInfo,
                                                                          expectation, memberPath)));
            }

            return(null);
        }
        public static SelectedMemberInfo GetSelectedMemberInfo <T, TValue>(this Expression <Func <T, TValue> > expression)
        {
            Guard.ThrowIfArgumentIsNull(expression, nameof(expression), "Expected an expression, but found <null>.");

            MemberInfo memberInfo = AttemptToGetMemberInfoFromCastExpression(expression) ??
                                    AttemptToGetMemberInfoFromMemberExpression(expression);

            if (memberInfo != null)
            {
                if (memberInfo is PropertyInfo propertyInfo)
                {
                    return(SelectedMemberInfo.Create(propertyInfo));
                }

                if (memberInfo is FieldInfo fieldInfo)
                {
                    return(SelectedMemberInfo.Create(fieldInfo));
                }
            }

            throw new ArgumentException(
                      string.Format("Expression <{0}> cannot be used to select a member.", expression.Body),
                      nameof(expression));
        }
Exemple #6
0
 /// <summary>
 ///     Finds a member by its case-sensitive name.
 /// </summary>
 /// <returns>
 ///     Returns <c>null</c> if no such member exists.
 /// </returns>
 public static SelectedMemberInfo FindMember(this Type type, string memberName, Type preferredType)
 {
     return(SelectedMemberInfo.Create(FindProperty(type, memberName, preferredType)) ??
            SelectedMemberInfo.Create(FindField(type, memberName, preferredType)));
 }