/// <summary>
/// Wraps a matcher in a proxy that checks assertion results, formats
/// error messages, and performs other housekeeping.
/// </summary>
/// <typeparam name="TActual">
/// The type of object tested by the wrapped matcher.
/// </typeparam>
/// <typeparam name="TMatcher">
/// The type of matcher to be wrapped.
/// </typeparam>
/// <param name="actual">
/// The actual value being tested.
/// </param>
/// <returns>
/// Returns a wrapped matcher that tests the <paramref name="actual"/>
/// value given.
/// </returns>
public static TMatcher Wrap <TActual, TMatcher>(TActual actual)
where TMatcher : BaseMatcher <TActual, TMatcher>
{
var matcher = (TMatcher)ProxyGenerator.CreateClassProxy(
typeof(TMatcher),
ProxyGenerationOptions,
new NullActualInterceptor <TActual, TMatcher>(),
new ErrorInterceptor <TActual, TMatcher>());
var inverted = (TMatcher)ProxyGenerator.CreateClassProxy(
typeof(TMatcher),
ProxyGenerationOptions,
new NullActualInterceptor <TActual, TMatcher>(),
new ErrorInterceptor <TActual, TMatcher>(),
new InversionInterceptor <TActual, TMatcher>());
matcher.Not = inverted;
matcher.actual = actual;
inverted.Not = matcher;
inverted.actual = actual;
inverted.inverted = true;
matcher.InvokeInitializer();
inverted.InvokeInitializer();
return(matcher);
}
public object Read(object id, Type type)
{
ValidateId(id);
var result = SqlQuery(command =>
{
command.CommandText = "SELECT Value, Type FROM KeyValueStore WHERE Id = @id AND type = @type";
command.Parameters.AddWithValue("@id", id);
command.Parameters.AddWithValue("@type", GetDefinition(type).Name);
var reader = command.ExecuteReader();
if (!reader.Read())
{
return(null);
}
return(new Tuple <string, string>(
reader.GetString(reader.GetOrdinal("Value")),
reader.GetString(reader.GetOrdinal("Type"))));
});
if (result == null)
{
return(null);
}
var instance = Deserialize(result.Item1, type);
return(ProxyGenerator.CreateClassProxy(type, new[] { typeof(IProxy) }, new CallInterceptor(instance, this, id)));
}
/// <summary>
/// Creates a proxy instance of the specified proxy type using the specified target.
/// </summary>
/// <typeparam name="TProxy">The type of the proxy.</typeparam>
/// <param name="target">The target.</param>
/// <param name="interceptor">The interceptor.</param>
/// <param name="interfaces">The interfaces.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">The <paramref name="target" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="interceptor" /> is <c>null</c>.</exception>
public TProxy Create <TProxy>(TProxy target, IInterceptor interceptor, params Type[] interfaces)
{
Argument.IsNotNull("target", target);
Argument.IsNotNull("interceptor", interceptor);
var interceptorAdapter = new InterceptorAdapter(interceptor, target);
var proxyType = typeof(TProxy);
if (!proxyType.IsInterfaceEx())
{
return
((TProxy)
_proxyGenerator.CreateClassProxy(proxyType, interfaces, new Castle.DynamicProxy.IInterceptor[]
{
interceptorAdapter
}));
}
return
((TProxy)
_proxyGenerator.CreateInterfaceProxyWithoutTarget(proxyType, interfaces,
new Castle.DynamicProxy.IInterceptor[]
{
interceptorAdapter
}));
}
internal static T ToEntity <T>(SPListItem listItem, bool reloadLookupItem = true)
{
if (listItem == null)
{
return(default(T));
}
var itemType = typeof(T);
var props = itemType.GetProperties();
foreach (var prop in props)
{
if (CommonHelper.IsPropertyNotMapped(prop))
{
continue;
}
Assert.IsPropertyVirtual(prop);
}
var entity = _proxyGenerator.CreateClassProxy(
itemType,
new DocumentAccessInterceptor(listItem),
new ItemAccessInterceptor(listItem, reloadLookupItem));
return((T)entity);
}
public static T Get <T>(params object[] parameters)
{
Init();
T proxiedObject = default(T);
try
{
if (null == parameters || 0 == parameters.Length)
{
proxiedObject =
(T)_generator.CreateClassProxy(
typeof(T),
new LoggingAspect(), new ErrorHandlingAspect());
}
else
{
proxiedObject =
(T)_generator.CreateClassProxy(
typeof(T),
parameters,
new LoggingAspect(), new ErrorHandlingAspect());
}
}
catch (Exception eProxification)
{
var logger = LogManager.GetLogger(Tmx_Core_Resources.LogName);
logger.Error("Failed to proxify type {0}", typeof(T).Name);
logger.Error(eProxification);
}
return(proxiedObject);
}
public object Create(Type mixinType, object[] args, IEnumerable <object> implementations)
{
var options = new ProxyGenerationOptions();
if (implementations != null)
{
foreach (var impl in implementations)
{
options.AddMixinInstance(impl);
}
}
try
{
if (!options.HasMixins && !mixinType.IsAbstract)
{
return(Activator.CreateInstance(mixinType, args));
}
return(Generator.CreateClassProxy(mixinType, options, args));
}
catch (MissingMethodException mme)
{
throw new FrameworkException(
"Can't create instance of an {0}. Arguments: ({1})".With(
mixinType.Name,
string.Join(", ", args.Select(it => "{0}: {1}".With(
it != null ? it.GetType().Name : "<unknown>",
it != null ? it.ToString() : "<null>")))),
mme);
}
}
public TProxy Create <TProxy>(TProxy target, IInterceptor interceptor, params Type[] interfaces)
{
var adapter = new CastleInterceptorAdapter(interceptor, target);
return(typeof(TProxy).IsInterface ?
(TProxy)factory.CreateInterfaceProxyWithoutTarget(typeof(TProxy), interfaces, adapter) :
(TProxy)factory.CreateClassProxy(typeof(TProxy), interfaces, adapter));
}
public void CreateSerializable()
{
ProxyObjectReference.ResetScope();
MySerializableClass proxy = (MySerializableClass)
generator.CreateClassProxy(typeof(MySerializableClass), new StandardInterceptor());
Assert.IsTrue(proxy.GetType().IsSerializable);
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
var type = binder.Type;
result = type.IsInterface
? _generator.CreateInterfaceProxyWithoutTarget(type, _interceptor)
: _generator.CreateClassProxy(type, _interceptor);
return(true);
}
public void RunCreationTests()
{
var time = Run("new", TimeSpan.Zero, () => new Model());
Run("activator", time, () => Activator.CreateInstance <Model>());
Run("castle", time, () => _proxyGenerator.CreateClassProxy <Model>());
Run("castle.interface", time, () => _proxyGenerator.CreateInterfaceProxyWithTarget <IHello>(new Model()));
Run("cob", time, () => new CBO());
}
public static void Test()
{
var generator = new ProxyGenerator();
var myObject = generator.CreateClassProxy <CastleDynamicProxy>(new MyInterceptorAspect());
var myOtherObject = generator.CreateClassProxy <MyOtherClass>(new MyInterceptorAspect());
myObject.DoStuff();
Console.WriteLine();
myOtherObject.DoOtherStuff();
}
/// <summary>Creates user defined page.</summary>
/// <param name="webDriver">The web driver. </param>
/// <param name="javaScriptExecutor">The js executor. </param>
/// <typeparam name="TPage">The page type. </typeparam>
/// <returns>The new instance of user defined page. </returns>
public static TPage Page <TPage>(IWebDriver webDriver, IJavaScriptExecutor javaScriptExecutor) where TPage : BasePage, new()
{
var page = proxyGenerator.CreateClassProxy <TPage>(proxyGenerationOptions,
new PropertyInterceptor(),
new CollectionPropertyInterceptor(),
new InvalidWriteOperationInterceptor());
page.Initialize(webDriver, javaScriptExecutor);
return(page);
}
private object CreateLazyLoadingProxy(
ProxiesOptionsExtension options,
IEntityType entityType,
ILazyLoader loader,
object[] constructorArguments)
=> _generator.CreateClassProxy(
entityType.ClrType,
GetInterfacesToProxy(options, entityType),
ProxyGenerationOptions.Default,
constructorArguments,
GetNotifyChangeInterceptors(options, entityType, new LazyLoadingInterceptor(entityType, loader)));
public object Create(Type t, Type asType, object glassModel)
{
// Return proxy with inner item
if (t.GetConstructors(ConstructorFlags).FirstOrDefault(info => info.GetParameters().FirstOrDefault(pi => pi.ParameterType.IsInstanceOfType(glassModel)) != null) != null)
{
return(ProxyGenerator.CreateClassProxy(t, new[] { glassModel }, _interceptorFactory(asType, glassModel)));
}
// Return proxy with default constructor
return(ProxyGenerator.CreateClassProxy(t, _interceptorFactory(asType, glassModel)));
}
public Object CreateProxy(Type type, params IInterceptor[] interceptors)
{
if (interceptors.Length == 0)
{
interceptors = emptyCallbacks;
}
if (type.IsInterface)
{
return(proxyGenerator.CreateInterfaceProxyWithoutTarget(type, ProxyOptionsFactory.CreateProxyGenerationOptions(), interceptors));
}
return(proxyGenerator.CreateClassProxy(type, ProxyOptionsFactory.CreateProxyGenerationOptions(), interceptors));
}
public object CreateProxyClass(Type type, params object[] paramObjects)
{
var args = OnAgentPreparation(type);
if (paramObjects.Length == 0)
{
return(_proxyGenerator.CreateClassProxy(args.ToProxyType, args.AdditionalInterfacesToProxy.ToArray(),
args.GenerationOptions, args.Interceptors.ToArray()));
}
return(_proxyGenerator.CreateClassProxy(args.ToProxyType, args.AdditionalInterfacesToProxy.ToArray(),
args.GenerationOptions, paramObjects, args.Interceptors.ToArray()));
}
protected virtual void MakeProxy(ProxyGenerator p)
{
if (typeof(T).IsClass)
{
Send = p.CreateClassProxy <T>(new HubConnectionProxy(this, SendType.Send));
Invoke = p.CreateClassProxy <T>(new HubConnectionProxy(this, SendType.Invoke));
}
else if (typeof(T).IsInterface)
{
Send = p.CreateInterfaceProxyWithoutTarget <T>(new HubConnectionProxy(this, SendType.Send));
Invoke = p.CreateInterfaceProxyWithoutTarget <T>(new HubConnectionProxy(this, SendType.Invoke));
}
}
static async Task Main(string[] args)
{
var proxyGenerator = new ProxyGenerator();
Console.WriteLine("First example: Without interceptors");
await RunFoo(new SampleClass());
Console.WriteLine("Second example: With classic interceptor");
await RunFoo(proxyGenerator.CreateClassProxy <SampleClass>(new SampleSyncTracingInterceptor()));
Console.WriteLine("Third example: With async interceptor");
await RunFoo(proxyGenerator.CreateClassProxy <SampleClass>(new AsyncToSyncInterceptorAdapter(new SampleAsyncTracingInterceptor())));
}
public void CachedClassProxies()
{
object proxy = _generator.CreateClassProxy(
typeof(ServiceClass), new StandardInterceptor( ));
Assert.IsNotNull(proxy);
Assert.IsTrue(typeof(ServiceClass).IsAssignableFrom(proxy.GetType()));
proxy = _generator.CreateClassProxy(
typeof(ServiceClass), new StandardInterceptor( ));
Assert.IsNotNull(proxy);
Assert.IsTrue(typeof(ServiceClass).IsAssignableFrom(proxy.GetType()));
}
public void CacheHitClassProxy()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
generator.CreateClassProxy<EmptyClass>();
generator.CreateClassProxy<EmptyClass>();
// Assert
Assert.True(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.EmptyClassProxy " +
"for target type CastleTests.DynamicProxy.Tests.Classes.EmptyClass."));
}
public void CacheHitClassProxy()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
generator.CreateClassProxy<EmptyClass>();
generator.CreateClassProxy<EmptyClass>();
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Found cached proxy type Castle.Proxies.EmptyClassProxy " +
"for target type CastleTests.DynamicProxy.Tests.Classes.EmptyClass."));
}
/// <summary>
/// 지정된 객체 생성 메소드를 통해 원본 객체를 생성하고, Interceptor를 가지는 Proxy를 생성하여 반환합니다.
/// </summary>
/// <param name="classToProxy"></param>
/// <param name="additionalInterfaces"></param>
/// <param name="interceptors"></param>
/// <returns></returns>
public static object Create(Type classToProxy, Type[] additionalInterfaces, params IInterceptor[] interceptors)
{
classToProxy.ShouldNotBeNull("classToProxy");
if (IsDebugEnabled)
{
log.Debug("대상 수형[{0}]의 Proxy를 생성합니다. additionalInterfaces=[{1}], interceptors=[{2}]",
classToProxy.FullName, additionalInterfaces.CollectionToString(), interceptors.CollectionToString());
}
return(proxyGenerator.CreateClassProxy(classToProxy,
additionalInterfaces,
interceptors));
}
private static object BuildProxy <T>(IPublishedContent node)
{
var ops = new ProxyGenerationOptions();
ops.AddMixinInstance(new LazyResolverMixin(node));
var classToProxy = typeof(T);
// Determine whether to use constructor that takes IPublishedContent
var useContentConstructor = classToProxy.GetConstructors().Any(c => c.GetParameters().Any(p => p.ParameterType == typeof(IPublishedContent)));
return(useContentConstructor
? _generator.CreateClassProxy(classToProxy, ops, new object[] { node }, _interceptor)
: _generator.CreateClassProxy(classToProxy, ops, _interceptor));
}
public static T Create <T>(object[] args = null) where T : Device
{
var interceptor = new SetterInterceptor();
var proxy = (T)_generator.CreateClassProxy(typeof(T), args, interceptor);
return(proxy);
}
public override INHibernateProxy GetProxy(object id, ISessionImplementor session)
{
INHibernateProxy proxy;
try
{
var behaviorInfo = _behaviorConfigurator.GetProxyInformation(PersistentClass);
var initializer = new LazyInitializer(EntityName, PersistentClass, id, GetIdentifierMethod,
SetIdentifierMethod, ComponentIdType, session);
IInterceptor[] interceptors = behaviorInfo.Interceptors
.Select(i => _kernel.Resolve(i))
.OfType <IInterceptor>()
.Union(new[] { initializer }).ToArray();
Type[] interfaces = Interfaces.Union(behaviorInfo.AdditionalInterfaces).ToArray();
object obj2 = IsClassProxy
? ProxyGenerator.CreateClassProxy(PersistentClass, interfaces, interceptors)
: ProxyGenerator.CreateInterfaceProxyWithoutTarget(interfaces[0], interfaces,
new IInterceptor[] { initializer });
initializer._constructed = true;
proxy = (INHibernateProxy)obj2;
}
catch (Exception exception)
{
log.Error("Creating a proxy instance failed", exception);
throw new HibernateException("Creating a proxy instance failed", exception);
}
return(proxy);
}
private void InjectPageObjects(List <FieldInfo> fields, IInterceptor proxy)
{
foreach (FieldInfo field in fields)
{
field.SetValue(this, ProxyGenerator.CreateClassProxy(field.FieldType, proxy));
}
}
public void Async_Test()
{
var proxy = ProxyGenerator.CreateClassProxy <FakeAsyncClass>();
var result = proxy.Async(100);
Assert.IsAssignableFrom <Task <int> >(result);
}
public static ProxyGeneratorResult GenerateProxy(
Type typeOfProxy,
IFakeCallProcessorProvider fakeCallProcessorProvider)
{
Guard.AgainstNull(typeOfProxy, nameof(typeOfProxy));
var invokeMethod = typeOfProxy.GetMethod("Invoke") !;
if (!IsAccessibleToDynamicProxy(typeOfProxy))
{
try
{
// This is the only way to get the proper error message.
// The need for this will go away when we start really using DynamicProxy to generate delegate proxies.
ProxyGenerator.CreateClassProxy(typeOfProxy);
}
catch (Exception ex)
{
return(new ProxyGeneratorResult(ex.Message));
}
}
var eventRaiser = new DelegateCallInterceptedEventRaiser(fakeCallProcessorProvider, invokeMethod, typeOfProxy);
fakeCallProcessorProvider.EnsureInitialized(eventRaiser.Instance);
return(new ProxyGeneratorResult(eventRaiser.Instance));
}
public T Build <T>() where T : BaseModel, new()
{
var item = (T)_generator.CreateClassProxy(typeof(T), GetInterceptor <T>());
item.Repository = _repository;
return(item);
}
private static T GenerateProxy <T>(IServiceProvider serviceProvider, IInterceptor[] interceptors)
{
var proxyGenerator = new ProxyGenerator();
var ctrParams = ResolveTypeConstructorParameters(serviceProvider, typeof(T));
return((T)proxyGenerator.CreateClassProxy(typeof(T), ctrParams, interceptors.ToArray()));
}
public static TEntity MakeTrackable <TEntity>(TEntity entity) where TEntity : class
{
var trackableInterceptor = new DirtyPropertiesTrackerInterceptor();
var options = new ProxyGenerationOptions(_generationHook);
options.AddMixinInstance(new DirtyPropertiesTracker());
var proxy = (TEntity)_generator.CreateClassProxy <TEntity>(
options,
trackableInterceptor);
if (entity == null)
{
return(proxy);
}
var result = EntityPatcher <TEntity> .Patch(entity, proxy);
if (result.IsSuccess)
{
return(result.Value);
}
else
{
return(proxy);
}
}
public void CreateProxyOfTypeWithMixinCausingDiamondWhenMethodIsNonVirtual()
{
ProxyGenerator generator = new ProxyGenerator();
object proxy = generator.CreateClassProxy(typeof(FirstImpl), new Type[]{typeof(ISecond)},
new StandardInterceptor(), false);
Assert.IsTrue(proxy is FirstImpl);
Assert.IsTrue(proxy is IFirst);
Assert.IsTrue(proxy is ISecond);
}
public void ProxyAnAbstractClass()
{
ProxyGenerator generator = new ProxyGenerator();
LoginInterceptor interceptor = new LoginInterceptor();
AbsCls ac = (AbsCls)generator.CreateClassProxy(typeof(AbsCls),interceptor, false);
ac.Method();
Assert.AreEqual("Method", interceptor.Methods[0]);
}
private void TryLoggingViaProxy()
{
var generator = new ProxyGenerator();
var testLogger2 =
generator.CreateClassProxy<TestLogger2>(
ServiceLocator.Current.GetInstance<IInterceptor>("LogInterceptor"));
testLogger2.GetMessage("message1");
testLogger2.GetMessageVirtual("message2");
testLogger2.GetMessageNotLogged("message3");
}
public void CreateSerializable()
{
MySerializableClass myClass = new MySerializableClass();
ProxyGenerator generator = new ProxyGenerator();
MySerializableClass proxy = (MySerializableClass)
generator.CreateClassProxy( typeof(MySerializableClass), new StandardInvocationHandler(myClass) );
Assert.IsTrue( proxy.GetType().IsSerializable );
}
public void ParametersAreCopiedToProxiedObject()
{
ProxyGenerator pg = new ProxyGenerator();
ClassWithAttributesOnMethodParameters requiredObj = (ClassWithAttributesOnMethodParameters)
pg.CreateClassProxy(
typeof(ClassWithAttributesOnMethodParameters),
new RequiredParamInterceptor());
requiredObj.MethodOne(-1);
}
public void CanGetParameterAttributeFromProxiedObject()
{
ProxyGenerator pg = new ProxyGenerator();
ClassWithAttributesOnMethodParameters requiredObj = (ClassWithAttributesOnMethodParameters)
pg.CreateClassProxy(
typeof(ClassWithAttributesOnMethodParameters),
new RequiredParamInterceptor());
requiredObj.MethodTwo(null);
}
public void WithNullableDynamicProxyObject()
{
ProxyGenerator generator = new ProxyGenerator();
SimpleProxy proxy = (SimpleProxy)generator.CreateClassProxy(typeof(SimpleProxy), new StandardInterceptor());
PropertyBag["src"] = proxy;
ProcessView_StripRailsExtension("home/WithNullableDynamicProxyObject.rails");
string expected = @"BarBaz
foo
what?
there";
AssertReplyEqualTo(expected);
}
public void CacheMiss()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
generator.CreateClassProxy<EmptyClass>();
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "No cached proxy type was found for target type " +
"Castle.DynamicProxy.Tests.LoggingTestCase+EmptyClass."));
}
public void ProtectedConstructor()
{
ProxyGenerator generator = new ProxyGenerator();
NonPublicConstructorClass proxy =
generator.CreateClassProxy(
typeof(NonPublicConstructorClass), new StandardInterceptor() )
as NonPublicConstructorClass;
Assert.IsNotNull(proxy);
proxy.DoSomething();
}
public void EnsureProxyHasAttributesOnClassAndMethods()
{
ProxyGenerator generator = new ProxyGenerator();
AttributedClass instance = (AttributedClass)
generator.CreateClassProxy(typeof(AttributedClass), new StandardInterceptor());
object[] attributes = instance.GetType().GetCustomAttributes(typeof(NonInheritableAttribute), false);
Assert.AreEqual(1, attributes.Length);
Assert.IsInstanceOfType(typeof(NonInheritableAttribute), attributes[0]);
attributes = instance.GetType().GetMethod("Do1").GetCustomAttributes(typeof(NonInheritableAttribute), false);
Assert.AreEqual(1, attributes.Length);
Assert.IsInstanceOfType(typeof(NonInheritableAttribute), attributes[0]);
}
public void ProtectedMethods()
{
ProxyGenerator generator = new ProxyGenerator();
LogInvocationInterceptor logger = new LogInvocationInterceptor();
NonPublicMethodsClass proxy = (NonPublicMethodsClass)
generator.CreateClassProxy( typeof(NonPublicMethodsClass), logger );
proxy.DoSomething();
Assert.AreEqual( 2, logger.Invocations.Length );
Assert.AreEqual( "DoSomething", logger.Invocations[0] );
Assert.AreEqual( "DoOtherThing", logger.Invocations[1] );
}
public void ProxyGenerationOptionsEqualsAndGetHashCodeNotOverriden()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
ProxyGenerationOptions options = new ProxyGenerationOptions {
Hook = new EmptyHook()
};
generator.CreateClassProxy(typeof(EmptyClass), options);
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Warn, "The IProxyGenerationHook type " +
"Castle.DynamicProxy.Tests.LoggingTestCase+EmptyHook does not override both Equals and GetHashCode. " +
"If these are not correctly overridden caching will fail to work causing performance problems."));
}
public void ProxyIsXmlSerializable()
{
ProxyGenerator gen = new ProxyGenerator();
ClassToSerialize proxy = (ClassToSerialize)
gen.CreateClassProxy(typeof(ClassToSerialize), new StandardInterceptor());
XmlSerializer serializer = new XmlSerializer(proxy.GetType());
StringWriter writer = new StringWriter();
serializer.Serialize(writer, proxy);
StringReader reader = new StringReader(writer.GetStringBuilder().ToString());
object newObj = serializer.Deserialize(reader);
Assert.IsNotNull(newObj);
Assert.IsInstanceOfType(typeof(ClassToSerialize), newObj);
}
public void CanHandleDynamicProxyObjects()
{
ProxyGenerator generator = new ProxyGenerator();
object o = generator.CreateClassProxy(typeof(HomeController.SimpleProxy), new StandardInterceptor());
try
{
o.GetType().GetProperty("Text");
}
catch(AmbiguousMatchException)
{
}
PropertyBag["src"] = o;
string expected = "<?xml version=\"1.0\" ?>\r\n" +
@"<html>
<h1>BarBaz</h1>
</html>";
// should not raise ambigious match exception
ProcessView_StripRailsExtension("Home/withDynamicProxyObject.rails");
AssertReplyEqualTo(expected);
}
public void AttributesOnTargetClasses()
{
ProxyGenerator _generator = new ProxyGenerator();
AttributeCheckerInterceptor interceptor = new AttributeCheckerInterceptor();
object proxy = _generator.CreateClassProxy(typeof (MyInterfaceImpl), interceptor);
IMyInterface inter = (IMyInterface) proxy;
Assert.AreEqual(45, inter.Calc(20, 25));
Assert.IsTrue(interceptor.LastTargethasAttribute);
Assert.IsTrue(interceptor.LastMethodHasAttribute);
Assert.AreEqual(48, inter.Calc(20, 25, 1, 2));
Assert.IsTrue(interceptor.LastMethodHasAttribute);
Assert.IsTrue(interceptor.LastTargethasAttribute);
inter.Name = "hammett";
Assert.IsFalse(interceptor.LastMethodHasAttribute);
Assert.IsTrue(interceptor.LastTargethasAttribute);
}
public void EnsureProxyHasAttributesOnClassAndMethods_ComplexAttributes()
{
ProxyGenerator generator = new ProxyGenerator();
AttributedClass2 instance = (AttributedClass2)
generator.CreateClassProxy(typeof(AttributedClass2), new StandardInterceptor());
object[] attributes = instance.GetType().GetCustomAttributes(typeof(ComplexNonInheritableAttribute), false);
Assert.AreEqual(1, attributes.Length);
Assert.IsInstanceOfType(typeof(ComplexNonInheritableAttribute), attributes[0]);
ComplexNonInheritableAttribute att = (ComplexNonInheritableAttribute) attributes[0];
// (1, 2, true, "class", FileAccess.Write)
Assert.AreEqual(1, att.Id);
Assert.AreEqual(2, att.Num);
Assert.AreEqual(true, att.IsSomething);
Assert.AreEqual("class", att.Name);
Assert.AreEqual(FileAccess.Write, att.Access);
attributes = instance.GetType().GetMethod("Do1").GetCustomAttributes(typeof(ComplexNonInheritableAttribute), false);
Assert.AreEqual(1, attributes.Length);
Assert.IsInstanceOfType(typeof(ComplexNonInheritableAttribute), attributes[0]);
att = (ComplexNonInheritableAttribute) attributes[0];
// (2, 3, "Do1", Access = FileAccess.ReadWrite)
Assert.AreEqual(2, att.Id);
Assert.AreEqual(3, att.Num);
Assert.AreEqual(false, att.IsSomething);
Assert.AreEqual("Do1", att.Name);
Assert.AreEqual(FileAccess.ReadWrite, att.Access);
attributes = instance.GetType().GetMethod("Do2").GetCustomAttributes(typeof(ComplexNonInheritableAttribute), false);
Assert.AreEqual(1, attributes.Length);
Assert.IsInstanceOfType(typeof(ComplexNonInheritableAttribute), attributes[0]);
att = (ComplexNonInheritableAttribute) attributes[0];
// (3, 4, "Do2", IsSomething=true)
Assert.AreEqual(3, att.Id);
Assert.AreEqual(4, att.Num);
Assert.AreEqual(true, att.IsSomething);
Assert.AreEqual("Do2", att.Name);
}
public void FoundExplicitlyImplementedInterfaceMethods()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
generator.CreateClassProxy<ClassWithInterfaceMethodExplicitlyImplemented>();
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Excluded explicitly implemented interface method " +
"Castle.DynamicProxy.Tests.LoggingTestCase.ISingleMethodInterface.InterfaceMethod on type " +
"Castle.DynamicProxy.Tests.LoggingTestCase+ClassWithInterfaceMethodExplicitlyImplemented " +
"because it cannot be intercepted."));
}
public void ProxyArrayListICollectionCtor()
{
ProxyGenerator generator = new ProxyGenerator();
ArrayList list = (ArrayList)generator.CreateClassProxy(typeof(ArrayList),new StandardInterceptor(), (ICollection)new int[]{1,2,3});
Assert.AreEqual(3,list.Count);
}
public void ExcludedNonVirtualMethods()
{
// Arrange
CollectingLogger logger = new CollectingLogger();
ProxyGenerator generator = new ProxyGenerator { Logger = logger };
// Act
generator.CreateClassProxy<NonVirtualMethodClass>();
// Assert
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Excluded non-virtual method ClassMethod on " +
"Castle.DynamicProxy.Tests.LoggingTestCase+NonVirtualMethodClass because it cannot be intercepted."));
Assert.That(logger.RecordedMessage(LoggerLevel.Debug, "Excluded sealed method InterfaceMethod on " +
"Castle.DynamicProxy.Tests.LoggingTestCase+NonVirtualMethodClass because it cannot be intercepted."));
}
public void CanCreateClassProxy()
{
var proxyGenerator = new ProxyGenerator();
proxyGenerator.CreateClassProxy<ClassWithMethodsWithAllKindsOfOptionalParameters>();
}
public void ProxySynchronizationContext()
{
var proxyGenerator = new ProxyGenerator();
proxyGenerator.CreateClassProxy<SynchronizationContext>();
}
