public void BuildProxyType_VirtualPublicProperty_WithSetter()
{
var knownBaseTypes = new[] { typeof(ProxiedChild) };
//var knownInterfaceTypes = new[] { typeof (IProperty) };
var knownTypes = knownBaseTypes; //knownBaseTypes.Union (knownInterfaceTypes).ToArray ();
var typeFilter = new TypeLevelTypeFilter(knownTypes);
var proxiedType = typeof(ProxiedChildChildChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_PublicProperty"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
// Create proxy instance, initializing it with class to be proxied
var proxied = new ProxiedChildChildChild("PC");
object proxy = Activator.CreateInstance(proxyType, proxied);
Assert.That(proxied.MutableNamePropertyVirtual, Is.EqualTo("ProxiedChildChild::MutableNamePropertyVirtual PC"));
//To.ConsoleLine.e ("proxyType.GetAllProperties()", proxyType.GetAllProperties ()).nl ().e (proxyType.GetAllProperties ().Select (pi => pi.Attributes)).nl (2).e ("proxyType.GetAllMethods()", proxyType.GetAllMethods ());
var proxyPropertyInfo = proxyType.GetProperty("MutableNamePropertyVirtual", _publicInstanceFlags);
// Note: Virtual properties remain virtual, so the proxy calls go to ProxiedChildChild, not the first known base type of ProxiedChild
// (ProxiedChildChildChild does not override MutableNamePropertyVirtual).
Assert.That(proxyPropertyInfo, Is.Not.Null);
Assert.That(proxyPropertyInfo.CanRead, Is.True);
Assert.That(proxyPropertyInfo.CanWrite, Is.True);
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo("ProxiedChildChild::MutableNamePropertyVirtual PC"));
proxyPropertyInfo.SetValue(proxy, "XXyyZZ", null);
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo("ProxiedChildChild::MutableNamePropertyVirtual XXyyZZ-ProxiedChildChild::MutableNamePropertyVirtual"));
}
private void Assert_BuildProxyType_GenericClassesAndMethods(
Type knownBaseType, Type[] knownInterfaceTypes, Type proxiedType)
{
var knownTypes = knownInterfaceTypes.Concat(new[] { knownBaseType }).ToArray();
var typeFilter = new TypeLevelTypeFilter(knownTypes);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_MultipleKnownInterfaces_PublicAndExplicitInterfaceImplementation"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var knownBaseTypeMethods = knownBaseType.GetMethods().Where(m => m.IsSpecialName == false);
var proxyMethods = proxyType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where(m => m.IsSpecialName == false && m.DeclaringType != typeof(Object)).ToArray();
var interfaceMethods = knownInterfaceTypes.SelectMany(t => t.GetMethods(BindingFlags.Instance | BindingFlags.Public));
//To.ConsoleLine.e (knownBaseTypeMethods).nl (3).e (interfaceMethods).nl (3).e (proxyMethods).nl (3);
var numberKnownBaseTypeMethods = knownBaseTypeMethods.Count();
var numberInterfaceMethods = interfaceMethods.Count();
var numberProxyMethods = proxyMethods.Count();
#if (true)
Assert.That(numberKnownBaseTypeMethods + numberInterfaceMethods + typeof(IProxy).GetMethods().Length, // + typeof (IProxy).GetMethods ().Length,
Is.EqualTo(numberProxyMethods));
#endif
AssertHasSameMethod(knownBaseType, proxyType, "ProxiedChildGenericToString", typeof(int), typeof(string));
}
private void AssertGetFirstKnownBaseType(Type proxiedType, TypeLevelTypeFilter typeFilter, Type expectedType)
{
var moduleScopeStub = MockRepository.GenerateStub <ModuleScope>();
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, moduleScopeStub);
Assert.That(stableBindingProxyBuilder.GetFirstKnownBaseType(), Is.EqualTo(expectedType));
}
public void BuildProxyType_ComplexGenericArguments_Virtual()
{
var knownBaseType = typeof(ProxiedChildGeneric <Proxied, Document>);
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType });
var proxiedType = typeof(ProxiedChildChildGeneric <Proxied, Document>);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_CheckInterfaceMembers"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
const string methodName = "ProxiedChildGeneric_ComplexGenericArguments_Virtual";
AssertHasSameGenericMethod(knownBaseType, proxyType, methodName, 2);
var proxied = new ProxiedChildChildGeneric <Proxied, Document> ();
var proxyMethodGeneric = GetGenericMethod(proxyType, methodName, 2);
Assert.That(proxyMethodGeneric.IsGenericMethod, Is.True);
var proxyMethod = proxyMethodGeneric.MakeGenericMethod(typeof(string), typeof(int));
var proxy = Activator.CreateInstance(proxyType, proxied);
var p0 = new Proxied("Hello");
var p1 = new Document("Doc");
const string p2 = "xyz";
const int p3 = 1234567;
var methodArguments = Create_ProxiedChildGeneric_ComplexGenericArguments_Parameters(p0, p1, p2, p3);
var proxyResult = (string)proxyMethod.Invoke(proxy, methodArguments);
StringAssert.StartsWith("ProxiedChildGeneric::ProxiedChildGeneric_ComplexGenericArguments_Virtual", proxyResult);
}
public void IsMethodEqualToBaseTypeMethod()
{
var moduleScopeStub = MockRepository.GenerateStub <ModuleScope> ();
var baseType = typeof(ProxiedChildGeneric <int, string>);
var proxiedType = typeof(ProxiedChildChildGeneric <int, string>);
var typeFilter = new TypeLevelTypeFilter(new[] { baseType });
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, moduleScopeStub);
var methodFromBaseType = ScriptingHelper.GetInstanceMethod(baseType, "ProxiedChildGenericToString", new[] { typeof(int), typeof(string) });
var method = ScriptingHelper.GetInstanceMethod(proxiedType, "ProxiedChildGenericToString", new[] { typeof(int), typeof(string) });
Assert.That(methodFromBaseType, Is.Not.EqualTo(method));
// Shows methodInfo.GetBaseDefinition()-bug: Results should be equal.
Assert.That(methodFromBaseType.GetBaseDefinition(), Is.Not.EqualTo(method.GetBaseDefinition()));
Assert.That(methodFromBaseType.ReflectedType, Is.EqualTo(baseType));
Assert.That(stableBindingProxyBuilder.IsMethodEqualToBaseTypeMethod(method, method), Is.True);
Assert.That(stableBindingProxyBuilder.IsMethodEqualToBaseTypeMethod(method, methodFromBaseType), Is.True);
var sumMethod = proxiedType.GetMethod("Sum", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
Assert.That(stableBindingProxyBuilder.IsMethodEqualToBaseTypeMethod(sumMethod, methodFromBaseType), Is.False);
}
public void BuildClassMethodToInterfaceMethodsMap_TwoInterfaceMethodsImplementedAsOnePublicMethod()
{
var typeIProcessText1 = typeof(IProcessText1);
var typeIProcessText2 = typeof(IProcessText2);
var typeFilter = new TypeLevelTypeFilter(new[] { typeIProcessText2, typeof(Proxied), typeIProcessText1 });
// Note: ProxiedChildChild implements IProcessText1 and IProcessText2 through one public member
var proxiedType = typeof(ProxiedChildChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildClassMethodToInterfaceMethodsMap_TwoInterfaceMethodsImplementedAsOnePublicMethod"));
var classMethodToInterfaceMethodsMap = stableBindingProxyBuilder.GetClassMethodToInterfaceMethodsMap();
var stringTimesIProcessText1ClassMethod = GetAnyInstanceMethod(proxiedType, "ProcessText");
Assert.That(stringTimesIProcessText1ClassMethod, Is.Not.Null);
var stringTimesIProcessText1InterfaceMethod = GetAnyInstanceMethod(typeIProcessText1, "ProcessText");
Assert.That(stringTimesIProcessText1InterfaceMethod, Is.Not.Null);
var stringTimesIProcessText2InterfaceMethod = GetAnyInstanceMethod(typeIProcessText2, "ProcessText");
Assert.That(stringTimesIProcessText2InterfaceMethod, Is.Not.Null);
Assert.That(classMethodToInterfaceMethodsMap.Count, Is.EqualTo(1));
Assert.That(classMethodToInterfaceMethodsMap[stringTimesIProcessText1ClassMethod].ToList(), Is.EquivalentTo(ListObjectMother.New(stringTimesIProcessText1InterfaceMethod, stringTimesIProcessText2InterfaceMethod)));
}
public void BuildProxyType_PublicProperty_WithSetter()
{
var knownBaseTypes = new[] { typeof(ProxiedChild) };
var knownTypes = knownBaseTypes; //knownBaseTypes.Union (knownInterfaceTypes).ToArray ();
var typeFilter = new TypeLevelTypeFilter(knownTypes);
var proxiedType = typeof(ProxiedChildChildChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_PublicProperty"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
// Create proxy instance, initializing it with class to be proxied
var proxied = new ProxiedChildChildChild("PC");
object proxy = Activator.CreateInstance(proxyType, proxied);
Assert.That(proxied.NameProperty, Is.EqualTo("ProxiedChildChildChild::NameProperty PC"));
//To.ConsoleLine.e ("proxyType.GetAllProperties()", proxyType.GetAllProperties ()).nl ().e (proxyType.GetAllProperties ().Select (pi => pi.Attributes)).nl (2).e ("proxyType.GetAllMethods()", proxyType.GetAllMethods ());
var proxyPropertyInfo = proxyType.GetProperty("NameProperty", _publicInstanceFlags);
Assert.That(proxyPropertyInfo, Is.Not.Null);
Assert.That(proxyPropertyInfo.CanRead, Is.True);
Assert.That(proxyPropertyInfo.CanWrite, Is.True);
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo("ProxiedChild::NameProperty PC"));
proxyPropertyInfo.SetValue(proxy, "XXyyZZ", null);
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo("ProxiedChild::NameProperty XXyyZZ-ProxiedChild::NameProperty"));
}
public void BuildClassMethodToInterfaceMethodsMap_TwoExplicitInterfaceMethods()
{
var typeIAmbigous1 = typeof(IAmbigous1);
var typeIAmbigous2 = typeof(IAmbigous2);
var typeFilter = new TypeLevelTypeFilter(new[] { typeIAmbigous2, typeof(Proxied), typeIAmbigous1 });
// Note: ProxiedChild implements IAmbigous1 and IAmbigous2
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildClassMethodToInterfaceMethodsMap_TwoExplicitInterfaceMethods"));
var classMethodToInterfaceMethodsMap = stableBindingProxyBuilder.GetClassMethodToInterfaceMethodsMap();
var stringTimesIAmbigous1ClassMethod = GetAnyInstanceMethod(proxiedType, "Remotion.Scripting.UnitTests.TestDomain.IAmbigous1.StringTimes");
Assert.That(stringTimesIAmbigous1ClassMethod, Is.Not.Null);
var stringTimesIAmbigous1InterfaceMethod = GetAnyInstanceMethod(typeIAmbigous1, "StringTimes");
Assert.That(stringTimesIAmbigous1InterfaceMethod, Is.Not.Null);
var stringTimesIAmbigous2ClassMethod = GetAnyInstanceMethod(proxiedType, "Remotion.Scripting.UnitTests.TestDomain.IAmbigous2.StringTimes");
Assert.That(stringTimesIAmbigous2ClassMethod, Is.Not.Null);
var stringTimesIAmbigous2InterfaceMethod = GetAnyInstanceMethod(typeIAmbigous2, "StringTimes");
Assert.That(stringTimesIAmbigous2InterfaceMethod, Is.Not.Null);
Assert.That(classMethodToInterfaceMethodsMap.Count, Is.EqualTo(2));
Assert.That(classMethodToInterfaceMethodsMap[stringTimesIAmbigous1ClassMethod].ToList(), Is.EquivalentTo(ListObjectMother.New(stringTimesIAmbigous1InterfaceMethod)));
Assert.That(classMethodToInterfaceMethodsMap[stringTimesIAmbigous2ClassMethod].ToList(), Is.EquivalentTo(ListObjectMother.New(stringTimesIAmbigous2InterfaceMethod)));
}
private void Assert_BuildProxyType_MultipleKnownInterfaces_PublicAndExplicitInterfaceImplementation(
Type[] knownBaseTypes, Type[] knownInterfaceTypes, Type proxiedType)
{
var knownTypes = knownBaseTypes.Union(knownInterfaceTypes).ToArray();
var typeFilter = new TypeLevelTypeFilter(knownTypes);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_MultipleKnownInterfaces_PublicAndExplicitInterfaceImplementation"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var knownBaseTypeMethods = knownBaseTypes.SelectMany(t => t.GetMethods()).Where(m => m.IsSpecialName == false);
var proxyMethods = proxyType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where(m => m.IsSpecialName == false && m.DeclaringType != typeof(Object));
var interfaceMethods = knownInterfaceTypes.SelectMany(t => t.GetMethods(BindingFlags.Instance | BindingFlags.Public));
//To.ConsoleLine.e (knownBaseTypeMethods).nl (3).e (interfaceMethods).nl (3).e (proxyMethods).nl (3);
Assert.That(knownBaseTypeMethods.Count() + interfaceMethods.Count() + typeof(IProxy).GetMethods().Length, // + typeof (IProxy).GetMethods ().Length,
Is.EqualTo(proxyMethods.Count()));
AssertHasSameExplicitInterfaceMethod(typeof(IAmbigous3), proxiedType, proxyType, "StringTimes2", typeof(String), typeof(Int32));
AssertHasSameExplicitInterfaceMethod(typeof(IAmbigous4), proxiedType, proxyType, "StringTimes2", typeof(String), typeof(Int32));
AssertHasSameMethod(typeof(ProxiedChild), proxyType, "StringTimes2", typeof(String), typeof(Int32));
AssertHasSameExplicitInterfaceMethod(typeof(IAmbigous3), proxiedType, proxyType, "AnotherMethod", typeof(String), typeof(Int32));
AssertHasSameExplicitInterfaceMethod(typeof(IAmbigous4), proxiedType, proxyType, "AnotherMethod", typeof(String), typeof(Int32));
AssertHasSameMethod(typeof(ProxiedChild), proxyType, "AnotherMethod", typeof(String), typeof(Int32));
AssertHasSameExplicitInterfaceMethod(typeof(IAmbigous1), proxiedType, proxyType, "StringTimes", typeof(String), typeof(Int32));
AssertHasSameExplicitInterfaceMethod(typeof(IAmbigous2), proxiedType, proxyType, "StringTimes", typeof(String), typeof(Int32));
}
public void Ctor()
{
var typeFilter = new TypeLevelTypeFilter(new Type[0]);
var proxiedType = typeof(string);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("Ctor"));
Assert.That(stableBindingProxyBuilder.ProxiedType, Is.EqualTo(proxiedType));
Assert.That(stableBindingProxyBuilder.GetTypeFilter(), Is.EqualTo(typeFilter));
}
public void BuildProxyType_NoKnownBaseType()
{
var typeFilter = new TypeLevelTypeFilter(new[] { typeof(IAmbigous1) });
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_NoKnownBaseType"));
// Having no known base type must not throw
stableBindingProxyBuilder.BuildProxyType();
}
public void BuildProxyType_NoKnownBaseTypeAndNoKnownInterfaces()
{
var typeFilter = new TypeLevelTypeFilter(new Type[0]);
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_NoKnownBaseType"));
// Having no known base type and no known interfaces must not throw
stableBindingProxyBuilder.BuildProxyType();
}
public void ParamsCtor()
{
var typeFilter = new TypeLevelTypeFilter(typeof(string), this.GetType());
Assert.That(typeFilter.IsTypeValid(typeof(string)), Is.True);
Assert.That(typeFilter.IsTypeValid(typeof(TypeLevelTypeFilterTest)), Is.True);
Assert.That(typeFilter.IsTypeValid(typeof(TypeLevelTypeFilter)), Is.False);
Assert.That(typeFilter.IsTypeValid(typeof(object)), Is.False);
}
public void BuildProxyType_AmbigousExplicitInterfaceProperties_With_PublicInterfaceImplementation()
{
var knownBaseTypes = new[] { typeof(ProxiedChildChild) };
var knownInterfaceTypes = new[] { typeof(IProperty), typeof(IPropertyAmbigous2) };
var knownTypes = knownBaseTypes.Union(knownInterfaceTypes).ToArray();
var typeFilter = new TypeLevelTypeFilter(knownTypes);
var proxiedType = typeof(ProxiedChildChildChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_ExplicitInterfaceProperty"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
Assert.That(proxyType.GetInterface("IPropertyAmbigous2"), Is.Not.Null);
Assert.That(proxyType.GetInterface("IPropertyAmbigous1"), Is.Null);
// Create proxy instance, initializing it with class to be proxied
var proxied = new ProxiedChildChildChild("PC");
object proxy = Activator.CreateInstance(proxyType, proxied);
const string expectedPropertyValue = "ProxiedChildChild::IPropertyAmbigous2::PropertyAmbigous PC";
Assert.That(((IPropertyAmbigous2)proxied).PropertyAmbigous, Is.EqualTo(expectedPropertyValue));
//To.ConsoleLine.e ("proxyType.GetAllProperties()", proxyType.GetAllProperties ()).nl ().e (proxyType.GetAllProperties ().Select(pi => pi.Attributes)).nl (2).e ("proxyType.GetAllMethods()", proxyType.GetAllMethods ());
var proxyPropertyInfoPublicProperty = proxyType.GetProperty("PropertyAmbigous", _publicInstanceFlags);
Assert.That(proxyPropertyInfoPublicProperty, Is.Not.Null);
Assert.That(ScriptingHelper.ExecuteScriptExpression <string> ("p0.PropertyAmbigous", proxy), Is.EqualTo("ProxiedChildChild::PropertyAmbigous PC"));
var proxyPropertyInfo = proxyType.GetProperty(
"Remotion.Scripting.UnitTests.TestDomain.ProxiedChild.Remotion.Scripting.UnitTests.TestDomain.IPropertyAmbigous2.PropertyAmbigous", _nonPublicInstanceFlags);
Assert.That(proxyPropertyInfo, Is.Not.Null);
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo(expectedPropertyValue));
//AssertPropertyInfoEqual (proxyPropertyInfo, propertyInfo);
((IPropertyAmbigous2)proxied).PropertyAmbigous = "aBc";
const string expectedPropertyValue2 = "ProxiedChildChild::IPropertyAmbigous2::PropertyAmbigous aBc-ProxiedChildChild::IPropertyAmbigous2::PropertyAmbigous";
Assert.That(((IPropertyAmbigous2)proxied).PropertyAmbigous, Is.EqualTo(expectedPropertyValue2));
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo(expectedPropertyValue2));
proxyPropertyInfo.SetValue(proxy, "XXyyZZ", null);
const string expectedPropertyValue3 = "ProxiedChildChild::IPropertyAmbigous2::PropertyAmbigous XXyyZZ-ProxiedChildChild::IPropertyAmbigous2::PropertyAmbigous";
Assert.That(((IPropertyAmbigous2)proxied).PropertyAmbigous, Is.EqualTo(expectedPropertyValue3));
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo(expectedPropertyValue3));
var proxyPropertyInfo2 = proxyType.GetProperty(
"Remotion.Scripting.UnitTests.TestDomain.ProxiedChild.Remotion.Scripting.UnitTests.TestDomain.IPropertyAmbigous1.PropertyAmbigous", _nonPublicInstanceFlags);
Assert.That(proxyPropertyInfo2, Is.Null);
}
private void AssertBuildProxyType_MethodHiddenWithNew(Type knownBaseType, Type proxiedType, bool expectProxiedCallDifferent, string methodName)
{
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType });
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("AssertBuildProxyType_MethodHiddenWithNew"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var proxiedTypeInstance = Activator.CreateInstance(proxiedType, "Peter");
var proxy = Activator.CreateInstance(proxyType, proxiedTypeInstance);
const string argument = "Fox";
// Test that call to proxy method is not ambigous
PrivateInvoke.InvokePublicMethod(proxy, methodName, argument);
}
public void GetInterfaceMethodsToClassMethod()
{
var typeIAmbigous2 = typeof(IAmbigous2);
var typeFilter = new TypeLevelTypeFilter(new[] { typeIAmbigous2 });
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("GetInterfaceMethodsToClassMethod"));
var stringTimesIAmbigous1ClassMethod = GetAnyInstanceMethod(proxiedType, "Remotion.Scripting.UnitTests.TestDomain.IAmbigous1.StringTimes");
var stringTimesIAmbigous2ClassMethod = GetAnyInstanceMethod(proxiedType, "Remotion.Scripting.UnitTests.TestDomain.IAmbigous2.StringTimes");
var stringTimesIAmbigous2InterfaceMethod = GetAnyInstanceMethod(typeIAmbigous2, "StringTimes");
Assert.That(stableBindingProxyBuilder.GetInterfaceMethodsToClassMethod(stringTimesIAmbigous1ClassMethod).ToList(), Is.Empty);
Assert.That(stableBindingProxyBuilder.GetInterfaceMethodsToClassMethod(stringTimesIAmbigous2ClassMethod).ToList(), Is.EquivalentTo(ListObjectMother.New(stringTimesIAmbigous2InterfaceMethod)));
}
public void BuildProxyType()
{
var typeFilter = new TypeLevelTypeFilter(new[] { typeof(ProxiedChild) });
var provider = new StableBindingProxyProvider(
typeFilter, CreateModuleScope("GetTypeMemberProxy"));
Assert.That(provider.TypeFilter, Is.SameAs(typeFilter));
var proxied = new ProxiedChildChildChild("abrakadava");
const string attributeName = "PrependName";
var proxyType = provider.BuildProxyType(proxied.GetType());
var proxyMethod = proxyType.GetAllInstanceMethods(attributeName, typeof(string)).Single();
Assert.That(proxyMethod, Is.Not.Null);
}
public void BuildProxyType_ObjectMethods()
{
var knownBaseType = typeof(Proxied);
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType });
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_ObjectMethods"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var proxied = new ProxiedChild();
var proxy = Activator.CreateInstance(proxyType, proxied);
Assert.That(InvokeMethod(proxy, "ToString"), Is.EqualTo(proxied.ToString()));
Assert.That(InvokeMethod(proxy, "GetType"), Is.EqualTo(proxied.GetType()));
Assert.That(InvokeMethod(proxy, "GetHashCode"), Is.EqualTo(proxied.GetHashCode()));
Assert.That(InvokeMethod(proxy, "Equals", proxied), Is.True);
Assert.That(InvokeMethod(proxy, "Equals", proxy), Is.False);
}
private void AssertBuildProxyType_MethodOverridden(Type knownBaseType, Type proxiedType, string methodName, bool expectKnownBaseTypeCallDifferent)
{
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType });
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("AssertBuildProxyType_MethodOverridden_ProxiedTypeIsKnownBaseType"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var proxiedTypeInstance = Activator.CreateInstance(proxiedType, "Peter");
var knownBaseTypeInstance = Activator.CreateInstance(knownBaseType, "Peter");
var proxy = Activator.CreateInstance(proxyType, proxiedTypeInstance);
const string argument = "Fox";
var proxyResult = InvokeMethod(proxy, methodName, argument);
// We expect the call to be virtual.
Assert.That(proxyResult, Is.EqualTo(InvokeMethod(proxiedTypeInstance, methodName, argument)));
if (expectKnownBaseTypeCallDifferent)
{
Assert.That(proxyResult, Is.Not.EqualTo(InvokeMethod(knownBaseTypeInstance, methodName, argument)));
}
}
public void BuildProxyType_PublicProperty()
{
var knownBaseTypes = new[] { typeof(ProxiedChildChild) };
var knownTypes = knownBaseTypes; //knownBaseTypes.Union (knownInterfaceTypes).ToArray ();
var typeFilter = new TypeLevelTypeFilter(knownTypes);
var proxiedType = typeof(ProxiedChildChildChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_PublicProperty"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
// Create proxy instance, initializing it with class to be proxied
var proxied = new ProxiedChildChildChild("PC");
object proxy = Activator.CreateInstance(proxyType, proxied);
Assert.That(proxied.NameProperty, Is.EqualTo("ProxiedChildChildChild::NameProperty PC"));
var proxyPropertyInfo = proxyType.GetProperty("NameProperty", _publicInstanceFlags);
Assert.That(proxyPropertyInfo, Is.Not.Null);
Assert.That(proxyPropertyInfo.CanRead, Is.True);
Assert.That(proxyPropertyInfo.CanWrite, Is.False);
Assert.That(proxyPropertyInfo.GetValue(proxy, null), Is.EqualTo("ProxiedChildChild::NameProperty PC"));
}
public void BuildProxyType_CheckMembers()
{
var knownBaseType = typeof(Proxied);
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType });
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var knownBaseTypeMethods = knownBaseType.GetMethods().Where(m => m.IsSpecialName == false);
var proxyMethods = proxyType.GetMethods().Where(m => m.IsSpecialName == false && m.DeclaringType != typeof(Object));
Assert.That(knownBaseTypeMethods.Count(), Is.EqualTo(proxyMethods.Count()));
AssertHasSameMethod(knownBaseType, proxyType, "GetName");
AssertHasSameMethod(knownBaseType, proxyType, "Sum", typeof(Int32[]));
AssertHasSameMethod(knownBaseType, proxyType, "PrependName", typeof(String));
AssertHasSameMethod(knownBaseType, proxyType, "SumMe", typeof(Int32[]));
AssertHasSameMethod(knownBaseType, proxyType, "OverrideMe", typeof(String));
AssertHasSameGenericMethod(knownBaseType, proxyType, "GenericToString", 2);
AssertHasSameGenericMethod(knownBaseType, proxyType, "OverloadedGenericToString", 1);
AssertHasSameGenericMethod(knownBaseType, proxyType, "OverloadedGenericToString", 2);
}
public void BuildProxyType_CheckInterfaceMembers()
{
var knownBaseType = typeof(Proxied);
var knownInterfaceType = typeof(IAmbigous2);
var typeFilter = new TypeLevelTypeFilter(new[] { knownBaseType, knownInterfaceType });
var proxiedType = typeof(ProxiedChild);
var stableBindingProxyBuilder = new StableBindingProxyBuilder(proxiedType, typeFilter, CreateModuleScope("BuildProxyType_CheckInterfaceMembers"));
var proxyType = stableBindingProxyBuilder.BuildProxyType();
var knownBaseTypeMethods = knownBaseType.GetMethods().Where(m => m.IsSpecialName == false);
var proxyMethods = proxyType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where(m => m.IsSpecialName == false && m.DeclaringType != typeof(Object));
var interfaceMethods = knownInterfaceType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
//To.ConsoleLine.e (knownBaseTypeMethods).nl (3).e (proxyMethods).nl (4);
//To.ConsoleLine.e (knownInterfaceType.GetMethods()).nl (3).e (interfaceProxyMethods).nl (3);
Assert.That(knownBaseTypeMethods.Count() + interfaceMethods.Count() + typeof(IProxy).GetMethods().Length, Is.EqualTo(proxyMethods.Count()));
//---------------------------------------------------------------------------------------------------------------------------------
// Adding IAmbigous2 interface adds StringTimes(string,int) explicit interface implementation.
// Note: StringTimes(string,int) exists 3x in ProxiedChild, as a regular member and as an explicit interface implementation from
// IAmbigous1 and IAmbigous2. Since the first is private and the second is not known, only the StringTimes coming from
// IAmbigous2 is exposed.
//---------------------------------------------------------------------------------------------------------------------------------
AssertHasSameExplicitInterfaceMethod(knownInterfaceType, proxiedType, proxyType, "StringTimes", typeof(String), typeof(Int32));
// Methods coming from knownBaseType Proxied are still here:
AssertHasSameMethod(knownBaseType, proxyType, "GetName");
AssertHasSameMethod(knownBaseType, proxyType, "Sum", typeof(Int32[]));
AssertHasSameMethod(knownBaseType, proxyType, "PrependName", typeof(String));
AssertHasSameMethod(knownBaseType, proxyType, "SumMe", typeof(Int32[]));
AssertHasSameMethod(knownBaseType, proxyType, "OverrideMe", typeof(String));
AssertHasSameGenericMethod(knownBaseType, proxyType, "GenericToString", 2);
AssertHasSameGenericMethod(knownBaseType, proxyType, "OverloadedGenericToString", 1);
AssertHasSameGenericMethod(knownBaseType, proxyType, "OverloadedGenericToString", 2);
}
