protected virtual string FormatMethod(MethodBase method)
 {
     var sb = new StringBuilder();
     if (method.DeclaringType != null)
     {
         sb.Append(method.DeclaringType.FullName);
         sb.Append(".");
     }
     sb.Append(method.Name);
     if (method.IsGenericMethod)
     {
         sb.Append("<");
         sb.Append(string.Join(", ", method.GetGenericArguments().Select(t => t.Name)));
         sb.Append(">");
     }
     sb.Append("(");
     var f = false;
     foreach (var p in method.GetParameters())
     {
         if (f) sb.Append(", ");
         else f = true;
         sb.Append(p.ParameterType.Name);
         sb.Append(' ');
         sb.Append(p.Name);
     }
     sb.Append(")");
     return sb.ToString();
 }

		public override object Action(object target, MethodBase method, object[] parameters, object result)
		{
			string namePrincipal = Thread.CurrentPrincipal.Identity.Name;
			if (namePrincipal == string.Empty)
			{
				namePrincipal = "Anonymous User";
			}

			namePrincipal = "User: " + namePrincipal;

			string text = "Assambly: " + target.ToString() + "\nMethod: " + method.Name;

			string content = Helper.ReadFile(_pathInternal);

			try
			{
				Helper.SaveToFile(namePrincipal, text, content, _pathInternal);
			}
			catch
			{
				throw;
			}

			return null;
		}

 public ReflectedMethod(Identifier name, MethodBase method, Type targetType)
     : base(name, null, method, targetType)
 {
     DeclaringName = method.DeclaringType != targetType
         ? IdentifierFor.Method(method, method.DeclaringType)
         : name;
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 public MethodTracerItem(TypeEnum itemType, TracerItem.PriorityEnum priority, string message, MethodBase methodInfo, string threadName, string threadId)
     : base(itemType, priority, message)
 {
     _methodBase = methodInfo;
     _threadId = threadId;
     _threadName = threadName;
 }

        // Validate the attribute usage.
        public override bool CompileTimeValidate( MethodBase method )
        {
            // Don't apply to constructors.
            if ( method is ConstructorInfo )
            {
                Message.Write( SeverityType.Error, "CX0001", "Cannot cache constructors." );
                return false;
            }

            MethodInfo methodInfo = (MethodInfo) method;

            // Don't apply to void methods.
            if ( methodInfo.ReturnType.Name == "Void" )
            {
                Message.Write( SeverityType.Error, "CX0002", "Cannot cache void methods." );
                return false;
            }

            // Does not support out parameters.
            ParameterInfo[] parameters = method.GetParameters();
            for ( int i = 0; i < parameters.Length; i++ )
            {
                if ( parameters[i].IsOut )
                {
                    Message.Write( SeverityType.Error, "CX0003", "Cannot cache methods with return values." );
                    return false;
                }
            }

            return true;
        }

		//===========================================================================================
		private bool IsStatic(MethodBase[] methods)
		{
			if (methods.Length != 1)
				return false;

			return IsStatic(methods[0]);
		}

        public void InitialiseProperties(
            Type classUnderTest,
            object instanceUnderTest,
            MethodBase methodUnderTest,
            object[] parameters,
            string nullParameter,
            int nullIndex,
            IExecutionSetup executionSetup)
        {
            // Act
            var sut = new MethodData(
                classUnderTest,
                instanceUnderTest,
                methodUnderTest,
                parameters,
                nullParameter,
                nullIndex,
                executionSetup);

            // Assert
            Assert.Same(classUnderTest, sut.ClassUnderTest);
            Assert.Equal(instanceUnderTest, sut.InstanceUnderTest);
            Assert.Same(methodUnderTest, sut.MethodUnderTest);
            Assert.Same(parameters, sut.Parameters);
            Assert.Same(nullParameter, sut.NullParameter);
            Assert.Equal(nullIndex, sut.NullIndex);
            Assert.Same(executionSetup, sut.ExecutionSetup);
        }

		public MonoMethodMessage (MethodBase method, object [] out_args)
		{
			if (method != null)
				InitMessage ((MonoMethod)method, out_args);
			else
				args = null;
		}

 public override int GetNumberOfStackPushes(MethodBase aMethod)
 {
   switch (OpCode)
   {
     case Code.Initobj:
       return 0;
     case Code.Ldelema:
       return 1;
     case Code.Newarr:
       return 1;
     case Code.Box:
       return 1;
     case Code.Stelem:
       return 0;
     case Code.Ldelem:
       return 1;
     case Code.Isinst:
       return 1;
     case Code.Castclass:
       return 1;
     case Code.Constrained:
       return 0;
     case Code.Unbox_Any:
       return 1;
     case Code.Unbox:
       return 1;
     case Code.Stobj:
       return 0;
     case Code.Ldobj:
       return 1;
     default:
       throw new NotImplementedException("OpCode '" + OpCode + "' not implemented!");
   }
 }

 /// <summary>
 /// Initializes a new instance of the MethodActivationContext class.
 /// </summary>
 /// <param name="target">The object instance that initiated the activation request.</param>
 /// <param name="targetMethod">The method where the activation was invoked.</param>
 /// <param name="concreteType">The type to be constructed.</param>
 /// <param name="additionalArguments">The additional arguments that will be passed to the constructor.</param>
 public TypeActivationContext(object target, MethodBase targetMethod,
     Type concreteType, object[] additionalArguments)
     : base(concreteType, additionalArguments)
 {
     Target = target;
     TargetMethod = targetMethod;
 }

 /// <summary>
 /// Creates a REST call from a given method.
 /// If the method has no marker, a null is returned
 /// </summary>
 /// <param name="methodBase">The method base.</param>
 /// <returns></returns>
 public static RestCall FromMethod(MethodBase methodBase)
 {
     var httpGet = methodBase.GetCustomAttribute<HttpGetAttribute>();
     if (httpGet != null)
         return new RestCall("GET", httpGet.UriTemplate);
     return null;
 }

		public override object Action(object target, MethodBase method, object[] parameters, object result)
		{
			string namePrincipal = Thread.CurrentPrincipal.Identity.Name;
			if (namePrincipal == string.Empty)
			{
				namePrincipal = "Anonymous User";
			}

			namePrincipal = "User: " + namePrincipal;

			string text = new StringBuilder()
				.AppendFormat("Assambly: {0}", target).AppendLine()
				.AppendFormat("Method: {0}", method.Name).AppendLine().AppendLine()
				.AppendFormat("InnerException: {0}" + (result as Exception).InnerException)
				.ToString();

			string content = Helper.ReadFile(_pathInternal);

			try
			{
				Helper.SaveToFile(namePrincipal, text, content, _pathInternal);
			}
			catch
			{
				throw;
			}

			return null;
		}

 protected byte CreateLocalsForByRefParams(byte paramArrayIndex, MethodBase invocationInfo)
 {
     byte numberOfByRefParams = 0;
     ParameterInfo[] parameters = invocationInfo.GetParameters();
     for (int i = 0; i < ParameterTypes.Length; i++)
     {
         Type paramType = ParameterTypes[i];
         if (paramType.IsByRef)
         {
             Type type = paramType.GetElementType();
             Emit.DeclareLocal(type);
             if (!parameters[i].IsOut) // no initialization necessary is 'out' parameter
             {
                 Emit.ldarg(paramArrayIndex)
                     .ldc_i4(i)
                     .ldelem_ref
                     .CastFromObject(type)
                     .stloc(numberOfByRefParams)
                     .end();
             }
             numberOfByRefParams++;
         }
     }
     return numberOfByRefParams;
 }

 public ExceptionThrowingTest(TimeSpan runningTime, MethodBase method, Exception thrownException, IObjectInstance instance = null,
                              IEnumerable<IObjectInstance> arguments = null)
     : base(runningTime, method, instance, arguments)
 {
     if (thrownException == null) throw new ArgumentNullException("thrownException");
     Exception = thrownException;
 }

 internal Method(MethodBase methodBase, UtilityFactory factory)
 {
     if (methodBase == null)
         throw new ArgumentNullException("methodBase");
     this.methodBase = methodBase;
     this.factory = factory;
 }

        private static TestResult RunTest(object instance, MethodBase method)
        {
            var result = new TestResult { Name = method.Name };

            var sw = new Stopwatch();
            sw.Start();
            try
            {
                method.Invoke(instance, null);
                result.WasSuccessful = true;
            }
            catch (Exception ex)
            {
                result.WasSuccessful = false;
                result.Message = ex.ToString();
            }
            finally
            {
                sw.Stop();

                result.Duration = sw.ElapsedMilliseconds;
            }

            return result;
        }

        private static string GetMethodBaseSignaturePrefix(MethodBase methodBase)
        {
            var stringBuilder = new StringBuilder();

            if (methodBase.IsPrivate)
            {
                stringBuilder.Append("private ");
            }
            else if (methodBase.IsPublic)
            {
                stringBuilder.Append("public ");
            }
            if (methodBase.IsAbstract)
            {
                stringBuilder.Append("abstract ");
            }
            if (methodBase.IsStatic)
            {
                stringBuilder.Append("static ");
            }
            if (methodBase.IsVirtual)
            {
                stringBuilder.Append("virtual ");
            }

            return stringBuilder.ToString();
        }

// ReSharper disable UnusedParameter.Local
        private void AssertMethodRule(Func<string, Type, IRegexFilter> addMethod, MethodBase method, Type type, bool expectedInclude)
        {
            IRegexFilter actualFilter = addMethod(method.Name, type);

            int expectedRules = 1;
            if (expectedInclude && type != null) expectedRules++;

            Assert.Same(addMethod.Target, actualFilter);
            Assert.Equal(expectedRules, actualFilter.Rules.Count);
            RegexRule addedRule = actualFilter.MethodRules.Single();
            Assert.Equal(expectedInclude, addedRule.Include);
            Assert.NotNull(addedRule.Method);
            Assert.True(addedRule.MatchMethod(type ?? GetType(), method));
            Assert.Null(addedRule.Parameter);

            if (type == null)
            {
                Assert.Null(addedRule.Type);
            }
            else
            {
                Assert.NotNull(addedRule.Type);
                Assert.True(addedRule.MatchType(type));
            }
        }

		// Messages will be intercepted here and redirected
		// to another object.
		public override IMessage Invoke (IMessage msg)
		{
			try {
				if (msg is IConstructionCallMessage) {
					IActivator remActivator = (IActivator) RemotingServices.Connect (typeof (IActivator), "tcp://localhost:1234/RemoteActivationService.rem");
					IConstructionReturnMessage crm = remActivator.Activate ((IConstructionCallMessage) msg);
					return crm;
				} else {
					methodOverloaded = RemotingServices.IsMethodOverloaded ((IMethodMessage) msg);

					_mthBase = RemotingServices.GetMethodBaseFromMethodMessage ((IMethodMessage) msg);
					MethodCallMessageWrapper mcm = new MethodCallMessageWrapper ((IMethodCallMessage) msg);
					mcm.Uri = RemotingServices.GetObjectUri ((MarshalByRefObject) target);
					MarshalByRefObject objRem = (MarshalByRefObject) Activator.CreateInstance (GetProxiedType ());
					RemotingServices.ExecuteMessage ((MarshalByRefObject) objRem, (IMethodCallMessage) msg);
					IMessage rtnMsg = null;

					try {
						rtnMsg = _sink.SyncProcessMessage (msg);
					} catch (Exception e) {
						Console.WriteLine (e.Message);
					}

					Console.WriteLine ("RR:" + rtnMsg);
					return rtnMsg;
				}
			} catch (Exception ex) {
				Console.WriteLine (ex);
				return null;
			}
		}

 public DynamicStackFrame(CodeContext context, MethodBase method, string funcName, string filename, int line) {
     _context = context;
     _funcName = funcName;
     _filename = filename;
     _lineNo = line;
     _method = method;
 }