public void ReturnsEventWithGivenName()
{
Assert.Same(selected, members.Event(eventName));
MemberNameFilter <Event, EventInfo> filter = VerifyFilter(selection, eventName);
Assert.Same(events, filter.Source);
}
public void ReturnsFieldWithGivenName()
{
Assert.Same(selected, members.Field(fieldName));
MemberNameFilter <Field, FieldInfo> filter = VerifyFilter(selection, fieldName);
Assert.Same(fields, filter.Source);
}
public static Event Event(this IMembers members, Type handlerType, string eventName)
{
var typed = new EventTypeFilter(members.Events(), handlerType);
var named = new MemberNameFilter <Event, EventInfo>(typed, eventName);
return(named.Single());
}
public static Property Property(this IMembers members, Type propertyType, string propertyName)
{
var typed = new PropertyTypeFilter(members.Properties(), propertyType);
var named = new MemberNameFilter <Property, PropertyInfo>(typed, propertyName);
return(named.Single());
}
public void ReturnsPropertyWithGivenName()
{
Assert.Same(selected, members.Property(propertyName));
MemberNameFilter <Property, PropertyInfo> filter = VerifyFilter(selection, propertyName);
Assert.Same(properties, filter.Source);
}
public void ReturnsMethodWithGivenName()
{
Assert.Same(selected, members.Method(methodName));
MemberNameFilter <Method, MethodInfo> filter = VerifyFilter(selection, methodName);
Assert.Same(methods, filter.Source);
}
public static Field Field(this IMembers members, Type fieldType, string fieldName)
{
var typed = new FieldTypeFilter(members.Fields(), fieldType);
var named = new MemberNameFilter <Field, FieldInfo>(typed, fieldName);
return(named.Single());
}
public static Method Method(this IMembers members, Type methodType, string methodName)
{
var typed = new MethodTypeFilter(members.Methods(), methodType, methodFactory);
var named = new MemberNameFilter <Method, MethodInfo>(typed, methodName);
return(named.Single());
}
public void ReturnsFieldWithGivenName()
{
Assert.Same(selected, instance.Field(fieldName));
MemberNameFilter <Field, FieldInfo> named = VerifyFilter(selection, fieldName);
VerifyInstanceFields(named.Source, instance);
}
public void ReturnsEventWithGivenName()
{
Assert.Same(selected, instance.Event(eventName));
MemberNameFilter <Event, EventInfo> named = VerifyFilter(selection, eventName);
VerifyInstanceEvents(named.Source, instance);
}
public void ReturnsPropertyWithGivenTypeAndName()
{
Assert.Same(selected, members.Property(propertyType, propertyName));
MemberNameFilter <Property, PropertyInfo> nameFilter = VerifyFilter(selection, propertyName);
PropertyTypeFilter typeFilter = VerifyFilter(nameFilter.Source, propertyType);
Assert.Same(properties, typeFilter.Source);
}
public void ReturnsFieldWithGivenTypeAndName()
{
Assert.Same(selected, members.Field(fieldType, fieldName));
MemberNameFilter <Field, FieldInfo> nameFilter = VerifyFilter(selection, fieldName);
FieldTypeFilter typeFilter = VerifyFilter(nameFilter.Source, fieldType);
Assert.Same(fields, typeFilter.Source);
}
public void ReturnsPropertyWithGivenName()
{
Assert.Same(selected, instance.Property(propertyName));
MemberNameFilter <Property, PropertyInfo> named = VerifyFilter(selection, propertyName);
VerifyInstanceProperties(named.Source, instance);
}
public void ReturnsMethodWithGivenName()
{
Assert.Same(selected, instance.Method(methodName));
MemberNameFilter <Method, MethodInfo> named = VerifyFilter(selection, methodName);
VerifyInstanceMethods(named.Source, instance);
}
public void ReturnsMethodWithGivenName()
{
Assert.Same(selected, testType.Method(methodName));
MemberNameFilter <Method, MethodInfo> named = VerifyFilter(selection, methodName);
VerifyStaticMethods(named.Source, testType);
}
public void ReturnsEventWithGivenHandlerTypeAndName()
{
Assert.Same(selected, members.Event(handlerType, eventName));
MemberNameFilter <Event, EventInfo> named = VerifyFilter(selection, eventName);
EventTypeFilter typed = VerifyFilter(named.Source, handlerType);
Assert.Same(events, typed.Source);
}
public void ReturnsFieldWithGivenName()
{
Assert.Same(selected, testType.Field(fieldName));
MemberNameFilter <Field, FieldInfo> named = VerifyFilter(selection, fieldName);
VerifyStaticFields(named.Source, testType);
}
public void ReturnsEventWithGivenName()
{
Assert.Same(selected, testType.Event(eventName));
MemberNameFilter <Event, EventInfo> named = VerifyFilter(selection, eventName);
VerifyStaticEvents(named.Source, testType);
}
public void ReturnsGenericFieldWithGivenTypeAndName()
{
Field <FieldValue> generic = members.Field <FieldValue>(fieldName);
VerifyGenericField(selected, generic);
MemberNameFilter <Field, FieldInfo> nameFilter = VerifyFilter(selection, fieldName);
FieldTypeFilter typeFilter = VerifyFilter(nameFilter.Source, fieldType);
Assert.Same(fields, typeFilter.Source);
}
public void ReturnsGenericMethodWithGivenTypeAndName()
{
Method <MethodType> generic = members.Method <MethodType>(methodName);
VerifyGenericMethod(selected, generic);
MemberNameFilter <Method, MethodInfo> nameFilter = VerifyFilter(selection, methodName);
MethodTypeFilter typeFilter = VerifyFilter(nameFilter.Source, methodType);
Assert.Same(methods, typeFilter.Source);
}
public void ReturnsGenericPropertyWithGivenTypeAndName()
{
Property <PropertyValue> generic = members.Property <PropertyValue>(propertyName);
VerifyGenericProperty(selected, generic);
MemberNameFilter <Property, PropertyInfo> nameFilter = VerifyFilter(selection, propertyName);
PropertyTypeFilter typeFilter = VerifyFilter(nameFilter.Source, propertyType);
Assert.Same(properties, typeFilter.Source);
}
public void ReturnsGenericMethodWithGivenTypeAndName()
{
Method <MethodType> generic = testType.Method <MethodType>(methodName);
VerifyGenericMethod(selected, generic);
MemberNameFilter <Method, MethodInfo> named = VerifyFilter(selection, methodName);
MethodTypeFilter typed = VerifyFilter(named.Source, typeof(MethodType));
VerifyStaticMethods(typed.Source, testType);
}
public void ReturnsGenericFieldWithGivenTypeAndName()
{
Field <FieldValue> generic = testType.Field <FieldValue>(fieldName);
VerifyGenericField(selected, generic);
MemberNameFilter <Field, FieldInfo> named = VerifyFilter(selection, fieldName);
FieldTypeFilter typed = VerifyFilter(named.Source, typeof(FieldValue));
VerifyStaticFields(typed.Source, testType);
}
public void ReturnsGenericEventWithGivenHandlerTypeAndName()
{
Event <TestHandler> generic = testType.Event <TestHandler>(eventName);
VerifyGenericEvent(selected, generic);
MemberNameFilter <Event, EventInfo> named = VerifyFilter(selection, eventName);
EventTypeFilter typed = VerifyFilter(named.Source, handlerType);
VerifyStaticEvents(typed.Source, testType);
}
public void ReturnsGenericPropertyWithGivenTypeAndName()
{
Property <PropertyValue> generic = instance.Property <PropertyValue>(propertyName);
VerifyGenericProperty(selected, generic);
MemberNameFilter <Property, PropertyInfo> named = VerifyFilter(selection, propertyName);
PropertyTypeFilter typed = VerifyFilter(named.Source, typeof(PropertyValue));
VerifyInstanceProperties(typed.Source, instance);
}
