public void Initialization()
{
var parameter = ReflectionObjectMother.GetSomeParameter();
var method = CustomMethodInfoObjectMother.Create(_declaringType, parameters: new[] { parameter });
var instantiation = new MethodOnTypeInstantiation(_declaringType, method);
Assert.That(instantiation.DeclaringType, Is.SameAs(_declaringType));
Assert.That(instantiation.Name, Is.EqualTo(method.Name));
Assert.That(instantiation.Attributes, Is.EqualTo(method.Attributes));
Assert.That(instantiation.IsGenericMethod, Is.False);
Assert.That(() => instantiation.GetGenericMethodDefinition(), Throws.InvalidOperationException);
Assert.That(instantiation.GetGenericArguments(), Is.Empty);
Assert.That(instantiation.MethodOnGenericType, Is.SameAs(method));
var returnParameter = instantiation.ReturnParameter;
Assertion.IsNotNull(returnParameter);
Assert.That(returnParameter, Is.TypeOf <MemberParameterOnInstantiation>());
Assert.That(returnParameter.Member, Is.SameAs(instantiation));
Assert.That(returnParameter.As <MemberParameterOnInstantiation>().MemberParameterOnGenericDefinition, Is.SameAs(method.ReturnParameter));
var memberParameter = instantiation.GetParameters().Single();
Assert.That(memberParameter, Is.TypeOf <MemberParameterOnInstantiation>());
Assert.That(memberParameter.Member, Is.SameAs(instantiation));
Assert.That(memberParameter.As <MemberParameterOnInstantiation>().MemberParameterOnGenericDefinition, Is.SameAs(parameter));
}
public void GetAccessors()
{
var nonPublicSetMethod = CustomMethodInfoObjectMother.Create(attributes: MethodAttributes.Private, parameters: new[] { _indexParameter, _valueParameter });
var property = CustomPropertyInfoObjectMother.Create(getMethod: _getMethod, setMethod: nonPublicSetMethod);
Assert.That(property.GetAccessors(true), Is.EquivalentTo(new[] { _getMethod, nonPublicSetMethod }));
Assert.That(property.GetAccessors(false), Is.EquivalentTo(new[] { _getMethod }));
}
public void CallingConvention()
{
var instanceMethod = CustomMethodInfoObjectMother.Create(attributes: 0);
var staticMethod = CustomMethodInfoObjectMother.Create(attributes: MethodAttributes.Static);
Assert.That(instanceMethod.CallingConvention, Is.EqualTo(CallingConventions.Standard | CallingConventions.HasThis));
Assert.That(staticMethod.CallingConvention, Is.EqualTo(CallingConventions.Standard));
}
public void GetCustomAttributeData()
{
var customAttributes = new[] { CustomAttributeDeclarationObjectMother.Create() };
var method = CustomMethodInfoObjectMother.Create(customAttributes: customAttributes);
var methodInstantiation = new MethodOnTypeInstantiation(_declaringType, method);
Assert.That(methodInstantiation.GetCustomAttributeData(), Is.EqualTo(customAttributes));
}
public void GetCustomAttributeData()
{
var customAttributes = new[] { CustomAttributeDeclarationObjectMother.Create() };
var genericMethodDefinition = CustomMethodInfoObjectMother.Create(typeArguments: new[] { _typeArgument }, customAttributes: customAttributes);
var instantiation = MethodInstantiationObjectMother.Create(genericMethodDefinition);
Assert.That(instantiation.GetCustomAttributeData(), Is.EqualTo(customAttributes));
}
public void IsRunetimeMethodInfo()
{
var runtimeMethod = ReflectionObjectMother.GetSomeMethod();
var customMethod = CustomMethodInfoObjectMother.Create();
Assert.That(runtimeMethod.IsRuntimeMethodInfo(), Is.True);
Assert.That(customMethod.IsRuntimeMethodInfo(), Is.False);
}
public new void ToString()
{
var type = ReflectionObjectMother.GetSomeType();
var returnParameter = CustomParameterInfoObjectMother.Create(type: type);
var method = CustomMethodInfoObjectMother.Create(returnParameter: returnParameter);
var name = "MyProperty";
var property = CustomPropertyInfoObjectMother.Create(name: name, getMethod: method);
Assert.That(property.ToString(), Is.EqualTo(type.Name + " MyProperty"));
}
public void SetUp()
{
_typeParameter = MutableGenericParameterObjectMother.Create();
_parameter = CustomParameterInfoObjectMother.Create();
_genericMethodDefinition = CustomMethodInfoObjectMother.Create(parameters: new[] { _parameter }, typeArguments: new[] { _typeParameter });
_typeArgument = CustomTypeObjectMother.Create();
var info = new MethodInstantiationInfo(_genericMethodDefinition, new[] { _typeArgument });
_instantiation = new MethodInstantiation(info);
}
public void Instantiate_CustomGenericMethodDefinition()
{
var typeParameter = ReflectionObjectMother.GetSomeGenericParameter();
var customGenericMethodDefinition = CustomMethodInfoObjectMother.Create(typeArguments: new[] { typeParameter });
var instantiationInfo = new MethodInstantiationInfo(customGenericMethodDefinition, new[] { _runtimeType });
var result = instantiationInfo.Instantiate();
Assert.That(result, Is.TypeOf <MethodInstantiation>());
Assert.That(result.GetGenericMethodDefinition(), Is.EqualTo(instantiationInfo.GenericMethodDefinition));
Assert.That(result.GetGenericArguments(), Is.EqualTo(instantiationInfo.TypeArguments));
}
public void ToDebugString()
{
var method = CustomMethodInfoObjectMother.Create(
declaringType: MutableTypeObjectMother.Create(name: "AbcProxy"),
name: "Xxx",
returnParameter: CustomParameterInfoObjectMother.Create(position: -1, type: typeof(void)),
parameters: new[] { CustomParameterInfoObjectMother.Create(type: typeof(int)) });
var expected = "TestableCustomMethod = \"Void Xxx(Int32)\", DeclaringType = \"AbcProxy\"";
Assert.That(method.ToDebugString(), Is.EqualTo(expected));
}
public new void ToString()
{
var parameters =
new[]
{
CustomParameterInfoObjectMother.Create(type: typeof(int)),
CustomParameterInfoObjectMother.Create(type: typeof(string).MakeByRefType())
};
var returnParameter = CustomParameterInfoObjectMother.Create(type: typeof(string));
var method = CustomMethodInfoObjectMother.Create(name: "Xxx", returnParameter: returnParameter, parameters: parameters);
Assert.That(method.ToString(), Is.EqualTo("String Xxx(Int32, String&)"));
}
public void SetUp()
{
_declaringType = CustomTypeObjectMother.Create();
_type = ReflectionObjectMother.GetSomeType();
_valueParameter = CustomParameterInfoObjectMother.Create(type: _type);
var indexParameterType = ReflectionObjectMother.GetSomeOtherType();
_indexParameter = CustomParameterInfoObjectMother.Create(type: indexParameterType);
_getMethod = CustomMethodInfoObjectMother.Create(attributes: MethodAttributes.Public, parameters: new[] { _indexParameter }, returnParameter: _valueParameter);
_setMethod = CustomMethodInfoObjectMother.Create(attributes: MethodAttributes.Public, parameters: new[] { _indexParameter, _valueParameter });
_readOnlyProperty = CustomPropertyInfoObjectMother.Create(getMethod: _getMethod);
_writeOnlyProperty = CustomPropertyInfoObjectMother.Create(setMethod: _setMethod);
}
public void Initialization_FromGenericMethodDefinition()
{
var typeArguments = new[] { ReflectionObjectMother.GetSomeType() };
var method = CustomMethodInfoObjectMother.Create(_declaringType, typeArguments: typeArguments);
Assert.That(method.IsGenericMethodDefinition, Is.True);
var instantiation = new MethodOnTypeInstantiation(_declaringType, method);
Assert.That(instantiation.IsGenericMethod, Is.True);
Assert.That(instantiation.IsGenericMethodDefinition, Is.True);
Assert.That(instantiation.GetGenericMethodDefinition(), Is.SameAs(instantiation));
Assert.That(instantiation.GetGenericArguments(), Is.EqualTo(typeArguments));
}
public void GetGetMethod()
{
var nonPublicMethod = CustomMethodInfoObjectMother.Create(attributes: MethodAttributes.Private, returnParameter: _valueParameter);
var property1 = CustomPropertyInfoObjectMother.Create(getMethod: nonPublicMethod);
var property2 = CustomPropertyInfoObjectMother.Create(getMethod: _getMethod);
var property3 = CustomPropertyInfoObjectMother.Create(getMethod: null, setMethod: _setMethod);
Assert.That(property1.GetGetMethod(true), Is.SameAs(nonPublicMethod));
Assert.That(property1.GetGetMethod(false), Is.Null);
Assert.That(property2.GetGetMethod(true), Is.SameAs(_getMethod));
Assert.That(property2.GetGetMethod(false), Is.SameAs(_getMethod));
Assert.That(property3.GetGetMethod(true), Is.Null);
Assert.That(property3.GetGetMethod(false), Is.Null);
}
public void ContainsGenericParameters()
{
Assert.That(_customMethod.ContainsGenericParameters, Is.False);
Assert.That(_genericMethod.ContainsGenericParameters, Is.False);
Assert.That(_genericMethodDefinition.ContainsGenericParameters, Is.True);
var typeInstantiation = TypeInstantiationObjectMother.Create(typeof(IList <>), new[] { ReflectionObjectMother.GetSomeGenericParameter() });
var method1 = CustomMethodInfoObjectMother.Create(
genericMethodDefintion: _genericMethodUnderlyingDefinition, typeArguments: new[] { typeInstantiation });
Assert.That(method1.ContainsGenericParameters, Is.True);
var genericTypeDefinition = CustomTypeObjectMother.Create(typeArguments: new[] { ReflectionObjectMother.GetSomeGenericParameter() });
var method2 = CustomMethodInfoObjectMother.Create(declaringType: genericTypeDefinition);
Assert.That(method2.ContainsGenericParameters, Is.True);
}
public void ToDebugString()
{
var declaringType = CustomTypeObjectMother.Create();
var type = ReflectionObjectMother.GetSomeType();
var returnParameter = CustomParameterInfoObjectMother.Create(type: type);
var method = CustomMethodInfoObjectMother.Create(returnParameter: returnParameter);
var name = "MyProperty";
var property = CustomPropertyInfoObjectMother.Create(declaringType, name, getMethod: method);
// Note: ToDebugString is defined in CustomFieldInfo base class.
Assertion.IsNotNull(property.DeclaringType);
var declaringTypeName = property.DeclaringType.Name;
var propertyTypeName = property.PropertyType.Name;
var propertyName = property.Name;
var expected = "TestableCustomProperty = \"" + propertyTypeName + " " + propertyName + "\", DeclaringType = \"" + declaringTypeName + "\"";
Assert.That(property.ToDebugString(), Is.EqualTo(expected));
}
public void SetUp()
{
_declaringType = CustomTypeObjectMother.Create();
_name = "abc";
_attributes = (MethodAttributes)7;
_returnParameter = CustomParameterInfoObjectMother.Create();
_customMethod = new TestableCustomMethodInfo(_declaringType, _name, _attributes, null, Type.EmptyTypes)
{
ReturnParameter_ = _returnParameter
};
_typeArgument = ReflectionObjectMother.GetSomeType();
_genericMethodUnderlyingDefinition = ReflectionObjectMother.GetSomeGenericMethodDefinition();
_genericMethod = CustomMethodInfoObjectMother.Create(
genericMethodDefintion: _genericMethodUnderlyingDefinition, typeArguments: new[] { _typeArgument });
_typeParameter = ReflectionObjectMother.GetSomeGenericParameter();
_genericMethodDefinition = CustomMethodInfoObjectMother.Create(typeArguments: new[] { _typeParameter });
}
