How to use MetaEvent class of Telerik.JustMock.Core.Castle.DynamicProxy.Generators package

...25		private const BindingFlags Flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;26		private ILogger logger = NullLogger.Instance;27		private ICollection<MethodInfo> checkedMethods = new HashSet<MethodInfo>();28		private readonly IDictionary<PropertyInfo, MetaProperty> properties = new Dictionary<PropertyInfo, MetaProperty>();29		private readonly IDictionary<EventInfo, MetaEvent> events = new Dictionary<EventInfo, MetaEvent>();30		private readonly IDictionary<MethodInfo, MetaMethod> methods = new Dictionary<MethodInfo, MetaMethod>();31		protected readonly Type type;32		protected MembersCollector(Type type)33		{34			this.type = type;35		}36		public ILogger Logger37		{38			get { return logger; }39			set { logger = value; }40		}41		public IEnumerable<MetaMethod> Methods42		{43			get { return methods.Values; }44		}45		public IEnumerable<MetaProperty> Properties46		{47			get { return properties.Values; }48		}49		public IEnumerable<MetaEvent> Events50		{51			get { return events.Values; }52		}53		public virtual void CollectMembersToProxy(IProxyGenerationHook hook)54		{55			if (checkedMethods == null) // this method was already called!56			{57				throw new InvalidOperationException(58					string.Format("Can't call 'CollectMembersToProxy' method twice. This usually signifies a bug in custom {0}.",59					              typeof(ITypeContributor)));60			}61			CollectProperties(hook);62			CollectEvents(hook);63			// Methods go last, because properties and events have methods too (getters/setters add/remove)64			// and we don't want to get duplicates, so we collect property and event methods first65			// then we collect methods, and add only these that aren't there yet66			CollectMethods(hook);67			checkedMethods = null; // this is ugly, should have a boolean flag for this or something68		}69		private void CollectProperties(IProxyGenerationHook hook)70		{71			var propertiesFound = type.GetProperties(Flags);72			foreach (var property in propertiesFound)73			{74				AddProperty(property, hook);75			}76		}77		private void CollectEvents(IProxyGenerationHook hook)78		{79			var eventsFound = type.GetEvents(Flags);80			foreach (var @event in eventsFound)81			{82				AddEvent(@event, hook);83			}84		}85		private void CollectMethods(IProxyGenerationHook hook)86		{87			var methodsFound = MethodFinder.GetAllInstanceMethods(type, Flags);88			foreach (var method in methodsFound)89			{90				AddMethod(method, hook, true);91			}92		}93		private void AddProperty(PropertyInfo property, IProxyGenerationHook hook)94		{95			MetaMethod getter = null;96			MetaMethod setter = null;97			if (property.CanRead)98			{99				var getMethod = property.GetGetMethod(true);100				getter = AddMethod(getMethod, hook, false);101			}102			if (property.CanWrite)103			{104				var setMethod = property.GetSetMethod(true);105				setter = AddMethod(setMethod, hook, false);106			}107			if (setter == null && getter == null)108			{109				return;110			}111			var nonInheritableAttributes = property.GetNonInheritableAttributes();112			var arguments = property.GetIndexParameters();113			properties[property] = new MetaProperty(property.Name,114			                                        property.PropertyType,115			                                        property.DeclaringType,116			                                        getter,117			                                        setter,118			                                        nonInheritableAttributes.Select(a => a.Builder),119			                                        arguments.Select(a => a.ParameterType).ToArray());120		}121		private void AddEvent(EventInfo @event, IProxyGenerationHook hook)122		{123			var addMethod = @event.GetAddMethod(true);124			var removeMethod = @event.GetRemoveMethod(true);125			MetaMethod adder = null;126			MetaMethod remover = null;127			if (addMethod != null)128			{129				adder = AddMethod(addMethod, hook, false);130			}131			if (removeMethod != null)132			{133				remover = AddMethod(removeMethod, hook, false);134			}135			if (adder == null && remover == null)136			{137				return;138			}139			events[@event] = new MetaEvent(@event.Name,140			                               @event.DeclaringType, @event.EventHandlerType, adder, remover, EventAttributes.None);141		}142		private MetaMethod AddMethod(MethodInfo method, IProxyGenerationHook hook, bool isStandalone)143		{144			if (checkedMethods.Contains(method))145			{146				return null;147			}148			checkedMethods.Add(method);149			if (methods.ContainsKey(method))150			{151				return null;152			}153			var methodToGenerate = GetMethodToGenerate(method, hook, isStandalone);...

...27		protected readonly ICollection<Type> interfaces = new HashSet<Type>();28		29		private ILogger logger = NullLogger.Instance;30		private readonly ICollection<MetaProperty> properties = new TypeElementCollection<MetaProperty>();31		private readonly ICollection<MetaEvent> events = new TypeElementCollection<MetaEvent>();32		private readonly ICollection<MetaMethod> methods = new TypeElementCollection<MetaMethod>();33		protected CompositeTypeContributor(INamingScope namingScope)34		{35			this.namingScope = namingScope;36		}37		public ILogger Logger38		{39			get { return logger; }40			set { logger = value; }41		}42		public void CollectElementsToProxy(IProxyGenerationHook hook, MetaType model)43		{44			foreach (var collector in CollectElementsToProxyInternal(hook))45			{46				foreach (var method in collector.Methods)47				{48					model.AddMethod(method);49					methods.Add(method);50				}51				foreach (var @event in collector.Events)52				{53					model.AddEvent(@event);54					events.Add(@event);55				}56				foreach (var property in collector.Properties)57				{58					model.AddProperty(property);59					properties.Add(property);60				}61			}62		}63		protected abstract IEnumerable<MembersCollector> CollectElementsToProxyInternal(IProxyGenerationHook hook);64		public virtual void Generate(ClassEmitter @class, ProxyGenerationOptions options)65		{66			foreach (var method in methods)67			{68				if (!method.Standalone)69				{70					continue;71				}72				ImplementMethod(method,73				                @class,74				                options,75				                @class.CreateMethod);76			}77			foreach (var property in properties)78			{79				ImplementProperty(@class, property, options);80			}81			foreach (var @event in events)82			{83				ImplementEvent(@class, @event, options);84			}85		}86		public void AddInterfaceToProxy(Type @interface)87		{88			Debug.Assert(@interface != null, "@interface == null", "Shouldn't be adding empty interfaces...");89			Debug.Assert(@interface.GetTypeInfo().IsInterface, "@interface.IsInterface", "Should be adding interfaces only...");90			Debug.Assert(!interfaces.Contains(@interface), "!interfaces.ContainsKey(@interface)",91			             "Shouldn't be adding same interface twice...");92			interfaces.Add(@interface);93		}94		private void ImplementEvent(ClassEmitter emitter, MetaEvent @event, ProxyGenerationOptions options)95		{96			@event.BuildEventEmitter(emitter);97			ImplementMethod(@event.Adder, emitter, options, @event.Emitter.CreateAddMethod);98			ImplementMethod(@event.Remover, emitter, options, @event.Emitter.CreateRemoveMethod);99		}100		private void ImplementProperty(ClassEmitter emitter, MetaProperty property, ProxyGenerationOptions options)101		{102			property.BuildPropertyEmitter(emitter);103			if (property.CanRead)104			{105				ImplementMethod(property.Getter, emitter, options, property.Emitter.CreateGetMethod);106			}107			if (property.CanWrite)108			{...

...15{16	using System;17	using System.Reflection;18	using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;19	internal class MetaEvent : MetaTypeElement, IEquatable<MetaEvent>20	{21		private readonly MetaMethod adder;22		private readonly MetaMethod remover;23		private readonly Type type;24		private EventEmitter emitter;25		private string name;26		/// <summary>27		///   Initializes a new instance of the <see cref = "MetaEvent" /> class.28		/// </summary>29		/// <param name = "name">The name.</param>30		/// <param name = "declaringType">Type declaring the original event being overridden, or null.</param>31		/// <param name = "eventDelegateType"></param>32		/// <param name = "adder">The add method.</param>33		/// <param name = "remover">The remove method.</param>34		/// <param name = "attributes">The attributes.</param>35		public MetaEvent(string name, Type declaringType, Type eventDelegateType, MetaMethod adder, MetaMethod remover,36		                 EventAttributes attributes)37			: base(declaringType)38		{39			if (adder == null)40			{41				throw new ArgumentNullException("adder");42			}43			if (remover == null)44			{45				throw new ArgumentNullException("remover");46			}47			this.name = name;48			type = eventDelegateType;49			this.adder = adder;50			this.remover = remover;51			Attributes = attributes;52		}53		public MetaMethod Adder54		{55			get { return adder; }56		}57		public EventAttributes Attributes { get; private set; }58		public EventEmitter Emitter59		{60			get61			{62				if (emitter != null)63				{64					return emitter;65				}66				throw new InvalidOperationException(67					"Emitter is not initialized. You have to initialize it first using 'BuildEventEmitter' method");68			}69		}70		public MetaMethod Remover71		{72			get { return remover; }73		}74		public void BuildEventEmitter(ClassEmitter classEmitter)75		{76			if (emitter != null)77			{78				throw new InvalidOperationException();79			}80			emitter = classEmitter.CreateEvent(name, Attributes, type);81		}82		public override bool Equals(object obj)83		{84			if (ReferenceEquals(null, obj))85			{86				return false;87			}88			if (ReferenceEquals(this, obj))89			{90				return true;91			}92			if (obj.GetType() != typeof(MetaEvent))93			{94				return false;95			}96			return Equals((MetaEvent)obj);97		}98		public override int GetHashCode()99		{100			unchecked101			{102				var result = (adder.Method != null ? adder.Method.GetHashCode() : 0);103				result = (result*397) ^ (remover.Method != null ? remover.Method.GetHashCode() : 0);104				result = (result*397) ^ Attributes.GetHashCode();105				return result;106			}107		}108		public bool Equals(MetaEvent other)109		{110			if (ReferenceEquals(null, other))111			{112				return false;113			}114			if (ReferenceEquals(this, other))115			{116				return true;117			}118			if (!type.Equals(other.type))119			{120				return false;121			}122			if (!StringComparer.OrdinalIgnoreCase.Equals(name, other.name))...

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters;3using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST;4using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.CodeDom;5using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.CodeDom.CodeStatements;6using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.CodeDom.CodeStatements.Interfaces;7using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces;8using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements;9using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces;10using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces;11using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces;12using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces.Interfaces;13using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces;14using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces;15using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces;16using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces;17using Telerik.JustMock.Core.Castle.DynamicProxy.Generators.Emitters.SimpleAST.Interfaces.CodeStatements.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces.Interfaces;

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7{8    {9        static void Main(string[] args)10        {11            var metaEvent = new MetaEvent();12            metaEvent.Name = "EventName";13            metaEvent.Type = typeof(EventHandler);14            Console.WriteLine(metaEvent.Name);15            Console.WriteLine(metaEvent.Type);16            Console.ReadLine();17        }18    }19}

1using System;2using System.Collections.Generic;3using System.Linq;4using System.Text;5using System.Threading.Tasks;6using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;7using Telerik.JustMock.Core;8using Telerik.JustMock;9using Telerik.JustMock.Helpers;10using Telerik.JustMock.Core.Context;11using Telerik.JustMock.Core.Behaviors;12using Telerik.JustMock.Core.Castle.DynamicProxy;13using Telerik.JustMock.Core.Castle.Core.Internal;14using System.Reflection;15using Telerik.JustMock.Core.Castle.Core;16{17    {18        public Class1()19        {20            var metaEvent = new MetaEvent(typeof(IEventSource), "Event");21            var eventSource = Mock.Create<IEventSource>();22            var eventHandler = Mock.Create<Action<int>>();23            Mock.Arrange(() => eventSource.Event += eventHandler).DoInstead(() => metaEvent.AddEventHandler(eventSource, eventHandler));24            Mock.Arrange(() => eventSource.Event -= eventHandler).DoInstead(() => metaEvent.RemoveEventHandler(eventSource, eventHandler));25            eventSource.Event += eventHandler;26            eventSource.Event -= eventHandler;27            Mock.Assert(() => eventSource.Event += eventHandler);28            Mock.Assert(() => eventSource.Event -= eventHandler);29        }30    }31    {32        event Action<int> Event;33    }34}35using System;36using System.Collections.Generic;37using System.Linq;38using System.Text;39using System.Threading.Tasks;40using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;41using Telerik.JustMock.Core;42using Telerik.JustMock;43using Telerik.JustMock.Helpers;44using Telerik.JustMock.Core.Context;45using Telerik.JustMock.Core.Behaviors;46using Telerik.JustMock.Core.Castle.DynamicProxy;47using Telerik.JustMock.Core.Castle.Core.Internal;48using System.Reflection;49using Telerik.JustMock.Core.Castle.Core;50{51    {52        public Class1()53        {54            var metaEvent = new MetaEvent(typeof(IEventSource), "Event");55            var eventSource = Mock.Create<IEventSource>();56            var eventHandler = Mock.Create<Action<int>>();57            Mock.Arrange(() => event

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7using Telerik.JustMock;8using Telerik.JustMock.Core;9{10    {11        public event EventHandler MyEvt;12        public void Raise()13        {14            MyEvt(this, EventArgs.Empty);15        }16    }17    {18        public event EventHandler MyEvt;19        public void Raise()20        {21            MyEvt(this, EventArgs.Empty);22        }23    }24    {25        public event EventHandler MyEvt;26        public void Raise()27        {28            MyEvt(this, EventArgs.Empty);29        }30    }31    {32        public event EventHandler MyEvt;33        public void Raise()34        {35            MyEvt(this, EventArgs.Empty);36        }37    }38    {39        public event EventHandler MyEvt;40        public void Raise()41        {42            MyEvt(this, EventArgs.Empty);43        }44    }45    {46        public event EventHandler MyEvt;47        public void Raise()48        {49            MyEvt(this, EventArgs.Empty);50        }51    }52    {53        public event EventHandler MyEvt;54        public void Raise()55        {56            MyEvt(this, EventArgs.Empty);57        }58    }59    {60        public event EventHandler MyEvt;61        public void Raise()62        {63            MyEvt(this, EventArgs.Empty);64        }65    }66    {67        public event EventHandler MyEvt;68        public void Raise()69        {70            MyEvt(this, EventArgs.Empty);71        }72    }73    {74        public event EventHandler MyEvt;75        public void Raise()76        {77            MyEvt(this, EventArgs.Empty);78        }79    }80    {81        public event EventHandler MyEvt;82        public void Raise()83        {84            MyEvt(this, EventArgs.Empty);85        }86    }87    {88        public event EventHandler MyEvt;89        public void Raise()90        {91            MyEvt(this, EventArgs.Empty);92        }93    }94    {95        public event EventHandler MyEvt;96        public void Raise()97        {

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using Telerik.JustMock.Core;3using Telerik.JustMock.Helpers;4using System;5using System.Collections.Generic;6using System.Linq;7using System.Text;8using System.Threading.Tasks;9using System.Reflection;10using System.Runtime.CompilerServices;11{12    {13        private EventInfo _event;14        private object _target;15        private object _sender;16        private object[] _args;17        private object _returnValue;18        private Exception _exception;19        private bool _hasReturnValue;20        private bool _hasException;21        private bool _isAsync;22        public MetaEvent(EventInfo @event, object target, object sender, object[] args, object returnValue, Exception exception, bool hasReturnValue, bool hasException, bool isAsync)23        {24            _event = @event;25            _target = target;26            _sender = sender;27            _args = args;28            _returnValue = returnValue;29            _exception = exception;30            _hasReturnValue = hasReturnValue;31            _hasException = hasException;32            _isAsync = isAsync;33        }34        {35            {36                return _event;37            }38        }39        {40            {41                return _target;42            }43        }44        {45            {46                return _sender;47            }48        }49        {50            {51                return _args;52            }53        }54        {55            {56                return _returnValue;57            }58        }59        {60            {61                return _exception;62            }63        }64        {65            {66                return _hasReturnValue;67            }68        }69        {70            {71                return _hasException;72            }73        }74        {75            {76                return _isAsync;77            }78        }79    }80}81using Telerik.JustMock;82using Telerik.JustMock.Helpers;83using System;84using System.Collections.Generic;85using System.Linq;86using System.Text;87using System.Threading.Tasks;88using System.Reflection;89using System.Runtime.CompilerServices;

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using Telerik.JustMock.Core;3using Telerik.JustMock;4using System;5using System.Collections.Generic;6using System.Linq;7using System.Text;8using System.Threading.Tasks;9{10    {11        public virtual int Add(int a, int b)12        {13            return a + b;14        }15    }16    {17        public virtual int Add(int a, int b)18        {19            return a + b;20        }21    }22    {23        public virtual int Add(int a, int b)24        {25            return a + b;26        }27    }28    {29        public virtual int Add(int a, int b)30        {31            return a + b;32        }33    }34    {35        public virtual int Add(int a, int b)36        {37            return a + b;38        }39    }40    {41        public virtual int Add(int a, int b)42        {43            return a + b;44        }45    }46    {47        public virtual int Add(int a, int b)48        {49            return a + b;50        }51    }52    {53        public virtual int Add(int a, int b)54        {55            return a + b;56        }57    }58    {59        public virtual int Add(int a, int b)60        {61            return a + b;62        }63    }64    {65        public virtual int Add(int a, int b)66        {67            return a + b;68        }69    }70    {71        public virtual int Add(int a, int b)72        {73            return a + b;74        }75    }76    {77        public virtual int Add(int a, int b)78        {79            return a + b;80        }81    }82    {83        public virtual int Add(int a, int b)84        {85            return a + b;86        }87    }88    {89        public virtual int Add(int a, int b)90        {91            return a + b;92        }93    }94    {

1using Telerik.JustMock.Core;2using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;3using System;4using System.Collections.Generic;5using System.Linq;6using System.Text;7using System.Threading.Tasks;8{9    {10        static void Main(string[] args)11        {12            var mock = Mock.Create<ICustomer>();13            var eventInfo = typeof(ICustomer).GetEvent("CustomerEvent");14            var metaEvent = new MetaEvent(eventInfo);15            metaEvent.AddEventHandler(mock, new EventHandler((s, e) => Console.WriteLine("Event fired")));16            mock.CustomerEvent += (s, e) => Console.WriteLine("Event fired");17            mock.CustomerEvent += (s, e) => Console.WriteLine("Event fired");18            mock.CustomerEvent += (s, e) => Console.WriteLine("Event fired");19            mock.Raise(x => x.CustomerEvent += null, EventArgs.Empty);20            Console.ReadLine();21        }22    }23    {24        event EventHandler CustomerEvent;25    }26}27{28    event EventHandler CustomerEvent;29}

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2{3    public static void Main()4    {5        var metaEvent = new MetaEvent();6    }7}8using Telerik.JustMock.Core.Castle.DynamicProxy;9{10    public static void Main()11    {12        var metaEvent = new MetaEvent();13    }14}

1using Telerik.JustMock.Core.Castle.DynamicProxy.Generators;2using Telerik.JustMock.Core.Castle.DynamicProxy;3{4    public MetaEvent(EventInfo @event)5    {6        this.@event = @event;7    }8    {9        {10            return @event;11        }12    }13    public override int GetHashCode()14    {15        return this.@event.GetHashCode();16    }17    public override bool Equals(object obj)18    {19        MetaEvent other = obj as MetaEvent;20        if (other == null)21        {22            return false;23        }24        return this.@event.Equals(other.@event);25    }26    private EventInfo @event;27}28using Telerik.JustMock.Core.Castle.DynamicProxy;29{30    public MetaEvent(EventInfo @event)31    {32        this.@event = @event;33    }34    {35        {36            return @event;37        }38    }39    public override int GetHashCode()40    {41        return this.@event.GetHashCode();42    }43    public override bool Equals(object obj)44    {45        MetaEvent other = obj as MetaEvent;46        if (other == null)47        {48            return false;49        }50        return this.@event.Equals(other.@event);51    }52    private EventInfo @event;53}