public void ChangingInvocationTargetSucceeds()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
IService service = (IService)
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IService), new AlwaysThrowsServiceImpl(), new ChangeTargetInterceptor(new ServiceImpl()),
logger);
Assert.AreEqual(20, service.Sum(10, 10));
}
public void VirtualMethodCallsFromTheConstructor()
{
var logging = new LogInvocationInterceptor();
var o = (MakeVirtualCallFromCtor)generator.CreateClassProxy(
typeof(MakeVirtualCallFromCtor),
new Type[0],
logging
);
Assert.AreEqual(1, logging.Invocations.Count);
Assert.IsNotNull(o);
}
public void ProxyInternalMethod()
{
var logging = new LogInvocationInterceptor();
var o = (WithInternalMethod)generator.CreateClassProxy(
typeof(WithInternalMethod),
new Type[0],
logging
);
o.Foo();
Assert.AreEqual("Foo ", logging.LogContents);
}
public void ProtectedMethods()
{
var logger = new LogInvocationInterceptor();
var proxy = (NonPublicMethodsClass)
generator.CreateClassProxy(typeof(NonPublicMethodsClass), logger);
proxy.DoSomething();
Assert.AreEqual(2, logger.Invocations.Count);
Assert.AreEqual("DoSomething", logger.Invocations[0]);
Assert.AreEqual("DoOtherThing", logger.Invocations[1]);
}
public void BasicInterfaceProxyWithValidTarget2()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
IService2 service = (IService2)
generator.CreateInterfaceProxyWithTarget(
typeof(IService2), new Service2(), logger);
service.DoOperation2();
Assert.AreEqual("DoOperation2 ", logger.LogContents);
}
public void InterfaceInheritance()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
IService service = (IExtendedService)
generator.CreateInterfaceProxyWithTarget(
typeof(IExtendedService), new ServiceImpl(), logger);
Assert.AreEqual(3, service.Sum(1, 2));
Assert.AreEqual("Sum ", logger.LogContents);
}
public void Indexer()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
InterfaceWithIndexer service = (InterfaceWithIndexer)
generator.CreateInterfaceProxyWithTarget(
typeof(InterfaceWithIndexer), new ClassWithIndexer(), logger);
Assert.AreEqual(1, service[1]);
Assert.AreEqual("get_Item ", logger.LogContents);
}
public void GenericClassWithGenericMethod()
{
var logger = new LogInvocationInterceptor();
var proxy =
(IDoubleGeneric <int>)generator.CreateInterfaceProxyWithTarget(
typeof(IDoubleGeneric <int>),
new DoubleGenericImpl <int>(),
logger
);
proxy.Call(1, "");
Assert.AreEqual("Call", logger.Invocations[0]);
}
public void InterfaceTargetTypeProducesInvocationsThatCanChangeTarget()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
AssertCanChangeTargetInterceptor invocationChecker = new AssertCanChangeTargetInterceptor();
IService2 service = (IService2)
generator.CreateInterfaceProxyWithTargetInterface(
typeof(IService2), new Service2(), invocationChecker, logger);
service.DoOperation2();
Assert.AreEqual("DoOperation2 ", logger.LogContents);
}
public void Mixin_same_as_proxied_class_forwards_to_base()
{
var interceptor = new LogInvocationInterceptor();
var mixin = new ClassImplementingISimpleMixin();
object proxy = generator.CreateClassProxy(
typeof(SimpleMixin),
MixIn(mixin),
interceptor
);
Assert.AreEqual(1, (proxy as ISimpleMixin).DoSomething());
Assert.IsEmpty(interceptor.Invocations);
}
public void InternalClassWithInternalMethodAndProperty()
{
var logging = new LogInvocationInterceptor();
var o =
(InternalClassWithInternalMembers)generator.CreateClassProxy(typeof(InternalClassWithInternalMembers),
new Type[0], logging);
Assert.IsNotNull(o);
o.TestMethod();
Assert.AreEqual(1, logging.Invocations.Count);
var t = o.TestProperty;
Assert.AreEqual(2, logging.Invocations.Count);
}
public void Mixin_with_derived_base_forwards_to_mixin()
{
var interceptor = new LogInvocationInterceptor();
var mixin = new ClassImplementingIDerivedSimpleMixin();
object proxy = generator.CreateClassProxy(
typeof(SimpleMixin),
new[] { typeof(IDerivedSimpleMixin) },
MixIn(mixin),
interceptor
);
Assert.AreEqual(2, (proxy as IDerivedSimpleMixin).DoSomethingDerived());
Assert.IsNotEmpty(interceptor.Invocations);
}
public void ProxyInternalMethod()
{
var logging = new LogInvocationInterceptor();
var o = (WithInternalMethod)generator.CreateClassProxy(typeof(WithInternalMethod),
new Type[0], logging);
o.Foo();
#if SILVERLIGHT
Assert.IsNullOrEmpty(logging.LogContents);
#else
Assert.AreEqual("Foo ", logging.LogContents);
#endif
}
public void ClassWithDifferentAccessLevelOnProperties()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
object proxy = generator.CreateClassProxy(typeof(DiffAccessLevelOnProperties), logger);
Assert.IsNotNull(proxy);
Assert.IsInstanceOf(typeof(DiffAccessLevelOnProperties), proxy);
DiffAccessLevelOnProperties type = (DiffAccessLevelOnProperties)proxy;
type.SetProperties();
Assert.AreEqual("10 11 12 13 name", type.ToString());
}
public void UsingEvents_Class()
{
var logger = new LogInvocationInterceptor();
var proxy = (FakeWithEvents)generator.CreateClassProxy(
typeof(FakeWithEvents),
ProxyGenerationOptions.Default,
logger);
Assert.IsNotNull(proxy);
proxy.Foo += null;
proxy.Foo -= null;
Assert.AreEqual(2, logger.Invocations.Count);
}
public void UsingEvents_Interface()
{
var logger = new LogInvocationInterceptor();
var proxy = (IWithEvents)generator.CreateInterfaceProxyWithTarget(typeof(IWithEvents),
new FakeWithEvents(),
logger);
Assert.IsNotNull(proxy);
proxy.Foo += null;
proxy.Foo -= null;
Assert.AreEqual(2, logger.Invocations.Count);
}
public void ProxyTypeWithMultiDimentionalArrayAsParameters()
{
LogInvocationInterceptor log = new LogInvocationInterceptor();
ClassWithMultiDimentionalArray proxy =
generator.CreateClassProxy <ClassWithMultiDimentionalArray>(log);
int[,] x = new int[1, 2];
proxy.Do(new int[] { 1 });
proxy.Do2(x);
proxy.Do3(new string[] { "1", "2" });
Assert.AreEqual("Do Do2 Do3 ", log.LogContents);
}
public void ClassWithInheritance()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
object proxy = generator.CreateClassProxy(typeof(ExtendedServiceClass), logger);
Assert.IsNotNull(proxy);
ExtendedServiceClass extended = (ExtendedServiceClass)proxy;
extended.Sum2(1, 2);
extended.Sum(1, 2);
Assert.AreEqual("Sum2 Sum ", logger.LogContents);
}
public void ExplicitInterfaceMethods_AreIgnored_OnClassProxy()
{
LogInvocationInterceptor interceptor = new LogInvocationInterceptor();
ClassWithExplicitInterface instance = generator.CreateClassProxy <ClassWithExplicitInterface>(interceptor);
instance.DoVirtual();
int result = ((ISimpleInterface)instance).Do();
instance.DoVirtual();
Assert.AreEqual(2, interceptor.Invocations.Count);
Assert.AreEqual("DoVirtual", interceptor.Invocations[0]);
Assert.AreEqual("DoVirtual", interceptor.Invocations[1]);
Assert.AreEqual(5, result);
}
public void ProxyForClassWithIndexer()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
object proxy = generator.CreateClassProxy(typeof(ClassWithIndexer), logger);
Assert.IsNotNull(proxy);
Assert.IsInstanceOf(typeof(ClassWithIndexer), proxy);
ClassWithIndexer type = (ClassWithIndexer)proxy;
type["name"] = 10;
Assert.AreEqual(10, type["name"]);
Assert.AreEqual("set_Item get_Item ", logger.LogContents);
}
public void HookIsUsedForConcreteClassProxy()
{
var logger = new LogInvocationInterceptor();
var hook = new LogHook(typeof(ServiceClass), true);
var options = new ProxyGenerationOptions(hook);
var proxy = (ServiceClass)generator.CreateClassProxy(typeof(ServiceClass), options, logger);
Assert.IsTrue(hook.Completed);
Assert.AreEqual(13, hook.AskedMembers.Count, "Asked members");
Assert.AreEqual(2, hook.NonVirtualMembers.Count, "Non-virtual members");
proxy.Sum(1, 2);
Assert.IsFalse(proxy.Valid);
Assert.AreEqual("get_Valid ", logger.LogContents);
}
public void HookIsUsedForConcreteClassProxy()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
LogHook hook = new LogHook(typeof(ServiceClass), true);
ProxyGenerationOptions options = new ProxyGenerationOptions(hook);
ServiceClass proxy = (ServiceClass)generator.CreateClassProxy(typeof(ServiceClass), options, logger);
Assert.IsTrue(hook.Completed);
Assert.AreEqual(10, hook.AskedMembers.Count, "Asked members");
Assert.AreEqual(2, hook.NonVirtualMembers.Count, "Non-virtual members"); // <-- this would fail due to superfulous method check
proxy.Sum(1, 2);
Assert.IsFalse(proxy.Valid);
Assert.AreEqual("get_Valid ", logger.LogContents);
}
public void HookIsUsedForInterfaceProxy()
{
var logger = new LogInvocationInterceptor();
var hook = new LogHook(typeof(IService), false);
var options = new ProxyGenerationOptions(hook);
var proxy = (IService)
generator.CreateInterfaceProxyWithTarget(
typeof(IService), new ServiceImpl(), options, logger);
Assert.IsTrue(hook.Completed);
Assert.AreEqual(10, hook.AskedMembers.Count);
Assert.AreEqual(0, hook.NonVirtualMembers.Count);
Assert.AreEqual(3, proxy.Sum(1, 2));
Assert.IsFalse(proxy.Valid);
Assert.AreEqual("Sum get_Valid ", logger.LogContents);
}
public void HookDetectsNonVirtualAlthoughInterfaceImplementation()
{
var logger = new LogInvocationInterceptor();
var hook = new LogHook(typeof(ServiceImpl), true);
var options = new ProxyGenerationOptions(hook);
// we are creating a class proxy although the creation of an interface proxy is possible too...
// since the members of our implementation are not explicitly marked as virtual, the runtime
// marks them as virtual but final --> not good for us, but intended by .net :-(
//
// see: https://msdn.microsoft.com/library/system.reflection.methodbase.isvirtual
//
// thus, a non virtual notification for this particular situation is appropriate
generator.CreateClassProxy(typeof(ServiceImpl), options, logger);
Assert.IsTrue(hook.Completed);
Assert.AreEqual(3, hook.AskedMembers.Count);
Assert.AreEqual(11, hook.NonVirtualMembers.Count);
}
public void ProtectedMethods()
{
LogInvocationInterceptor logger = new LogInvocationInterceptor();
NonPublicMethodsClass proxy = (NonPublicMethodsClass)
generator.CreateClassProxy(typeof(NonPublicMethodsClass), logger);
try
{
proxy.DoSomething();
}
catch (Exception e)
{
Console.WriteLine(e);
}
Assert.AreEqual(2, logger.Invocations.Count);
Assert.AreEqual("DoSomething", logger.Invocations[0]);
Assert.AreEqual("DoOtherThing", logger.Invocations[1]);
}
public void ExplicitInterface_AsAdditionalInterfaceToProxy_OnClassProxy_WithoutBaseCalls()
{
LogInvocationInterceptor interceptor = new LogInvocationInterceptor();
interceptor.Proceed = false;
ClassWithExplicitInterface instance = (ClassWithExplicitInterface)generator.CreateClassProxy(typeof(ClassWithExplicitInterface),
new[] { typeof(ISimpleInterface) }, interceptor);
instance.DoVirtual();
int result = ((ISimpleInterface)instance).Do();
instance.DoVirtual();
Assert.AreEqual(3, interceptor.Invocations.Count);
Assert.AreEqual("DoVirtual", interceptor.Invocations[0]);
Assert.AreEqual("Do", interceptor.Invocations[1]);
Assert.AreEqual("DoVirtual", interceptor.Invocations[2]);
Assert.AreEqual(0, result); // indicates that original method was not called
}
public override void Init()
{
base.Init();
interceptor = new LogInvocationInterceptor();
}
public void Mixin_same_as_proxied_class_and_additional_interface_forwards_to_base_interceptable()
{
var interceptor = new LogInvocationInterceptor();
var mixin = new ClassImplementingISimpleMixin();
object proxy = generator.CreateClassProxy(typeof(SimpleMixin), new[] { typeof(ISimpleMixin) }, MixIn(mixin),
interceptor);
Assert.AreEqual(1, (proxy as ISimpleMixin).DoSomething());
Assert.IsNotEmpty(interceptor.Invocations);
}
public void Mixin_with_derived_base_forwards_to_mixin()
{
var interceptor = new LogInvocationInterceptor();
var mixin = new ClassImplementingIDerivedSimpleMixin();
object proxy = generator.CreateClassProxy(typeof(SimpleMixin), new[] { typeof(IDerivedSimpleMixin) }, MixIn(mixin),
interceptor);
Assert.AreEqual(2, (proxy as IDerivedSimpleMixin).DoSomethingDerived());
Assert.IsNotEmpty(interceptor.Invocations);
}
public void Init()
{
LogInvocationInterceptor.Clear();
}
