public void Test_MethodOfDerivedClass()
{
var methodInformation = _resolver.GetMethodInformation(typeof(DerivedSecurableObject), "Show", MemberAffiliation.Instance);
var expectedMethodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Show"));
Assert.That(methodInformation, Is.Not.Null);
Assert.That(methodInformation, Is.EqualTo(expectedMethodInformation));
}
public void Test_OverriddenMethodFromBaseMethod()
{
var methodInformation = _resolver.GetMethodInformation(typeof(DerivedSecurableObject), "Record", MemberAffiliation.Instance);
var expectedMethodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Record"));
Assert.That(methodInformation, Is.Not.Null);
Assert.That(methodInformation, Is.EqualTo(expectedMethodInformation));
}
public void Test_OverloadedMethodWithOneAttribute()
{
var methodInformation = _resolver.GetMethodInformation(typeof(SecurableObject), "Delete", MemberAffiliation.Instance);
var expectedMethodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Delete", new [] { typeof(int) }));
Assert.That(methodInformation, Is.Not.Null);
Assert.That(methodInformation, Is.EqualTo(expectedMethodInformation));
}
public void GetSetMethod_PublicProperty()
{
var setMethod = _adapter.GetSetMethod(false);
var expectedMethod = MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("set_NotVisibleAttributeScalar"));
Assert.That(setMethod, Is.Not.Null);
Assert.That(setMethod, Is.EqualTo(expectedMethod));
}
public void FindInterfaceDeclaration_NoImplementation()
{
var methodInfo = typeof(ClassWithReferenceType <object>).GetMethod("TestMethod");
var adapter = MethodInfoAdapter.Create(methodInfo);
var result = adapter.FindInterfaceDeclarations();
Assert.That(result, Is.Empty);
}
public void FindDeclaringProperty_PropertyFound()
{
var methodInfo = typeof(ClassWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(methodInfo);
var result = adapter.FindDeclaringProperty();
CheckProperty(TypeAdapter.Create(typeof(ClassWithReferenceType <object>)), "ImplicitInterfaceScalar", result);
}
public void Equals()
{
Assert.That(_adapter.Equals(null), Is.False);
Assert.That(_adapter.Equals("test"), Is.False);
Assert.That(_adapter.Equals(MethodInfoAdapter.Create(typeof(ClassWithOverridingMember).GetMethod("BaseMethod"))), Is.False);
Assert.That(_adapter.Equals(MethodInfoAdapter.Create(_method)), Is.True);
Assert.That(_adapter.Equals(MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("TestMethod"))), Is.True);
}
public void FilterMultipleAccessTypes()
{
IMethodInformation methodInformation = MethodInfoAdapter.Create(typeof(SecurableObject).GetMethod("Close"));
var requiredAccessTypes = _permissionReflector.GetRequiredMethodPermissions(typeof(SecurableObject), methodInformation);
Assert.That(requiredAccessTypes.Count, Is.EqualTo(2));
Assert.That(requiredAccessTypes, Has.Member(GeneralAccessTypes.Edit));
Assert.That(requiredAccessTypes, Has.Member(GeneralAccessTypes.Find));
}
public void GetHashcode()
{
Assert.That(
_adapter.GetHashCode(),
Is.EqualTo(MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("TestMethod")).GetHashCode()));
Assert.That(
MethodInfoAdapter.Create(typeof(int[]).GetMethod("ToString")).GetHashCode(),
Is.EqualTo(MethodInfoAdapter.Create(typeof(int[]).GetMethod("ToString")).GetHashCode()));
}
public void FindInterfaceImplementation_ImplementationIsNotAssignableToTheInterface()
{
var methodInfo = typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(methodInfo);
var result = adapter.FindInterfaceImplementation(typeof(object));
Assert.That(result, Is.Null);
}
public void CanBeSetFromOutside_IsBasedOnGetSetMethod_TrueForInterfaceImplementationPropertySetter()
{
var methodInfoAdapter = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString"));
_implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(methodInfoAdapter);
_declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(false)).Return(methodInfoAdapter);
Assert.That(_mixinIntroducedPropertyInformation.CanBeSetFromOutside, Is.True);
}
public void FindDeclaringProperty_NoPropertyCanBeFound()
{
var methodInfo = typeof(ClassWithBaseMember).GetMethod("BaseMethod");
var adapter = MethodInfoAdapter.Create(methodInfo);
var result = adapter.FindDeclaringProperty();
Assert.That(result, Is.Null);
}
public void Invoke()
{
var methodInfoAdapter = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString"));
_declarationMethodInformationStub.Stub(stub => stub.Invoke("Test", new object[] { })).Return(methodInfoAdapter);
var result = _mixinIntroducedMethodInformation.Invoke("Test", new object[] { });
Assert.That(result, Is.SameAs(methodInfoAdapter));
}
public void GetOriginalDeclaration_NoBaseDefinition()
{
var method = typeof(object).GetMethod("GetType");
var adapter = MethodInfoAdapter.Create(method);
var result = adapter.GetOriginalDeclaration();
Assert.That(result, Is.TypeOf(typeof(MethodInfoAdapter)));
CheckMethodInfo(method, (MethodInfoAdapter)result);
}
public void GetSetMethod_PrivateProperty_NonPublicTrue()
{
var setMethod = _explicitInterfaceAdapter.GetSetMethod(true);
var expectedMethod = MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod(
"Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.set_ExplicitInterfaceScalar",
BindingFlags.Instance | BindingFlags.NonPublic));
Assert.That(setMethod, Is.Not.Null);
Assert.That(setMethod, Is.EqualTo(expectedMethod));
}
public void FindInterfaceDeclaration_ImplicitImplementation()
{
var methodInfo = typeof(ClassWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(methodInfo);
var result = adapter.FindInterfaceDeclarations();
var expectedMethodInfos = new[] { typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar") };
CheckUnorderedMethodInfos(expectedMethodInfos, result.Cast <MethodInfoAdapter> ());
}
public void FindInterfaceImplementation_ImplicitImplementation()
{
var methodInfo = typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(methodInfo);
var implementation = adapter.FindInterfaceImplementation(typeof(ClassWithReferenceType <object>));
var expectedPropertyGetter = typeof(ClassWithReferenceType <object>).GetMethod("get_ImplicitInterfaceScalar");
CheckMethodInfo(expectedPropertyGetter, (MethodInfoAdapter)implementation);
}
public override void SetUp()
{
base.SetUp();
_testHelper = new TestHelper();
_extension = new SecurityClientTransactionExtension();
_propertyInfo = typeof(SecurableObject).GetProperty("Parent");
_getMethodInformation = MethodInfoAdapter.Create(_propertyInfo.GetGetMethod());
_testHelper.SetupSecurityIoCConfiguration();
}
public void FindInterfaceDeclaration()
{
IMethodInformation methodInformation = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString"));
_declarationMethodInformationStub
.Stub(stub => stub.FindInterfaceDeclarations())
.Return(EnumerableUtility.Singleton(methodInformation).AsOneTime());
Assert.That(_mixinIntroducedMethodInformation.FindInterfaceDeclarations(), Is.EqualTo(new[] { _declarationMethodInformationStub }));
Assert.That(_mixinIntroducedMethodInformation.FindInterfaceDeclarations(), Is.EqualTo(new[] { _declarationMethodInformationStub }));
}
public void SetValue_ImplementationAddsSetAccessor()
{
var instance = new ClassWithReferenceType <SimpleReferenceType>();
var value = new SimpleReferenceType();
_declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(null);
_implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(
MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("ImplicitInterfaceScalar").GetSetMethod(true)));
_interfaceImplementationPropertyInformation.SetValue(instance, value, null);
Assert.That(instance.ImplicitInterfaceScalar, Is.SameAs(value));
}
public void SetValue_ImplementationAddsSetAccessor_IndexedProperty()
{
var instance = new ClassWithReferenceType <SimpleReferenceType>();
var value = new SimpleReferenceType();
_declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(null);
_implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(
MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("Item", new[] { typeof(int) }).GetSetMethod(true)));
_interfaceImplementationPropertyInformation.SetValue(instance, value, new object[] { 0 });
Assert.That(instance[0], Is.SameAs(value));
}
public void GetSetMethod()
{
var methodInfoAdapter = MethodInfoAdapter.Create(typeof(object).GetMethod("ToString"));
_implementationPropertyInformationStub.Stub(stub => stub.GetSetMethod(true)).Return(methodInfoAdapter);
_declarationPropertyInformationStub.Stub(stub => stub.GetSetMethod(false)).Return(methodInfoAdapter);
var result = _mixinIntroducedPropertyInformation.GetSetMethod(false);
Assert.That(result, Is.TypeOf(typeof(MixinIntroducedMethodInformation)));
Assert.That(result.Name, Is.EqualTo("ToString"));
}
public void GetFastInvoker_PublicMethod()
{
var methodInfo = typeof(ClassWithReferenceType <string>).GetMethod("get_ImplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(methodInfo);
var instance = new ClassWithReferenceType <string>();
instance.ImplicitInterfaceScalar = "Test";
var result = adapter.GetFastInvoker <Func <ClassWithReferenceType <string>, string> >();
Assert.That(result(instance), Is.EqualTo("Test"));
}
public void GetFastInvoker_PrivateMethod()
{
var methodInfo = typeof(ClassWithReferenceType <string>).GetMethod("get_PrivateProperty", BindingFlags.Instance | BindingFlags.NonPublic);
var adapter = MethodInfoAdapter.Create(methodInfo);
var instance = new ClassWithReferenceType <string>();
PrivateInvoke.SetNonPublicProperty(instance, "PrivateProperty", "Test");
var result = adapter.GetFastInvoker <Func <ClassWithReferenceType <string>, string> >();
Assert.That(result(instance), Is.EqualTo("Test"));
}
public void GetValue()
{
var instance = new ClassWithReferenceType <SimpleReferenceType>();
var value = new SimpleReferenceType();
instance.ImplicitInterfaceScalar = value;
_declarationPropertyInformationStub.Stub(stub => stub.GetGetMethod(true)).Return(null);
_implementationPropertyInformationStub.Stub(stub => stub.GetGetMethod(true)).Return(
MethodInfoAdapter.Create(typeof(ClassWithReferenceType <SimpleReferenceType>).GetProperty("ImplicitInterfaceScalar").GetGetMethod(true)));
Assert.That(_mixinIntroducedPropertyInformation.GetValue(instance, null), Is.SameAs(value));
}
public override void SetUp()
{
base.SetUp();
_testHelper = new TestHelper();
_extension = new SecurityClientTransactionExtension();
_propertyInfo = typeof(SecurableObject).GetProperty("StringProperty");
_setMethodInformation = MethodInfoAdapter.Create(_propertyInfo.GetSetMethod());
_stringPropertyDefinition = PropertyDefinitionObjectMother.CreatePropertyDefinition(_propertyInfo);
_testHelper.SetupSecurityIoCConfiguration();
}
public void FindInterfaceImplementation_ExplicitImplementation()
{
var methodInfo = typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ExplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(methodInfo);
var implementation = adapter.FindInterfaceImplementation(typeof(ClassWithReferenceType <object>));
var expectedPropertyGetter = typeof(ClassWithReferenceType <object>).GetMethod(
"Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.get_ExplicitInterfaceScalar",
BindingFlags.Instance | BindingFlags.NonPublic);
CheckMethodInfo(expectedPropertyGetter, (MethodInfoAdapter)implementation);
}
public void FindInterfaceDeclaration_ExplicitImplementation_FromBaseType()
{
var methodInfo = typeof(DerivedClassWithReferenceType <object>).GetMethod(
"Remotion.Reflection.UnitTests.TestDomain.MemberInfoAdapter.IInterfaceWithReferenceType<T>.get_ExplicitInterfaceScalar",
BindingFlags.Instance | BindingFlags.NonPublic);
var adapter = MethodInfoAdapter.Create(methodInfo);
var result = adapter.FindInterfaceDeclarations();
var expectedMethodInfos = new[] { typeof(IInterfaceWithReferenceType <object>).GetMethod("get_ExplicitInterfaceScalar") };
CheckUnorderedMethodInfos(expectedMethodInfos, result.Cast <MethodInfoAdapter> ());
}
public void FindInterfaceDeclaration_ComparesMethodsWithoutReflectedTypes()
{
var methodInfo = typeof(DerivedClassWithReferenceType <object>).GetMethod("ImplicitInterfaceMethod");
var adapter = MethodInfoAdapter.Create(methodInfo);
Assert.That(methodInfo.ReflectedType, Is.Not.SameAs(methodInfo.DeclaringType));
var result = adapter.FindInterfaceDeclarations();
var expectedMethodInfos = new[] { typeof(IInterfaceWithReferenceType <object>).GetMethod("ImplicitInterfaceMethod") };
CheckUnorderedMethodInfos(expectedMethodInfos, result.Cast <MethodInfoAdapter> ());
}
public void GetOriginalDeclaration_WithBaseDefinition()
{
var method = typeof(DerivedClassWithReferenceType <SimpleReferenceType>).GetMethod("get_ImplicitInterfaceScalar");
var adapter = MethodInfoAdapter.Create(method);
var result = adapter.GetOriginalDeclaration();
Assert.That(result, Is.TypeOf(typeof(MethodInfoAdapter)));
var expectedMethodInfo = typeof(ClassWithReferenceType <SimpleReferenceType>).GetMethod("get_ImplicitInterfaceScalar");
CheckMethodInfo(expectedMethodInfo, (MethodInfoAdapter)result);
}
