public override void AfterCall(ICallContext callContext)
		{
			Console.WriteLine("> Leaving {0}", callContext.Method.Name);
			if (callContext.CallFailed) {
				Console.WriteLine("  Exception: {0}", callContext.Exception);
			}
		}

        /// <summary>
        /// Method called after a call is issued.
        /// </summary>
        public override void AfterCall(ICallContext callContext)
        {
            // Should happen only on constructor methods which are not supported:
            if (callContext.Instance == null)
                return;

            // Call IInterceptible.AfterCall method, or throw exception:
            var instance = callContext.Instance as IInterceptible;
            if (instance != null)
                instance.AfterCall(callContext);
            else
                throw new InvalidOperationException(String.Format("{0} should implement IInterceptible.", callContext.Instance.GetType()));
        }

        public InterceptionAction HandleIntercept(ICallContext invocation, InterceptorContext ctx, CurrentInterceptContext localctx)
        {
            this.ctx = ctx;
            if (!FluentMockContext.IsActive)
            {
                //Special case for events
                if (invocation.Method.IsEventAttach())
                {
                    var delegateInstance = (Delegate)invocation.Arguments[0];
                    // TODO: validate we can get the event?
                    var eventInfo = this.GetEventFromName(invocation.Method.Name.Substring(4));

                    if (ctx.Mock.CallBase && !eventInfo.DeclaringType.IsInterface)
                    {
                        invocation.InvokeBase();
                    }
                    else if (delegateInstance != null)
                    {
                        ctx.AddEventHandler(eventInfo, (Delegate)invocation.Arguments[0]);
                    }

                    return InterceptionAction.Stop;
                }
                else if (invocation.Method.IsEventDetach())
                {
                    var delegateInstance = (Delegate)invocation.Arguments[0];
                    // TODO: validate we can get the event?
                    var eventInfo = this.GetEventFromName(invocation.Method.Name.Substring(7));

                    if (ctx.Mock.CallBase && !eventInfo.DeclaringType.IsInterface)
                    {
                        invocation.InvokeBase();
                    }
                    else if (delegateInstance != null)
                    {
                        ctx.RemoveEventHandler(eventInfo, (Delegate)invocation.Arguments[0]);
                    }

                    return InterceptionAction.Stop;
                }

                // Save to support Verify[expression] pattern.
                // In a fluent invocation context, which is a recorder-like
                // mode we use to evaluate delegates by actually running them,
                // we don't want to count the invocation, or actually run
                // previous setups.
                ctx.AddInvocation(invocation);
            }
            return InterceptionAction.Continue;
        }

		/// <summary>
		/// Will search the index using the specified query.
		/// </summary>
		/// <param name="callContext"></param>
		/// <param name="query"></param>
        public IndexResponse Search( ICallContext callContext, IQuery query, UUID accessPointGUID )
        {
			if( accessPointGUID != null )
                query.Query = string.Format("({0})+AND+(ap{1}_PubStart:[*+TO+NOW]+AND+ap{1}_PubEnd:[NOW+TO+*])", query.Query, accessPointGUID);
            else
            {
				var folders = callContext.PortalApplication.GetModule<MCM.Module.FolderModule>().Get( callContext, null, null, null, (uint) FolderPermission.Read );

                query.Query = string.Format( "({0})+AND+({1})", query.Query, string.Join( "+OR+", folders.Select( folder => string.Format( "FolderTree:{0}", folder.ID ) ) ) );
            }

            var response = callContext.IndexManager.GetIndex( "CHAOS.MCM.Module.AMCMModule" ).Get<UUIDResult>( query );

            return new IndexResponse( response );
        }

 private void ThrowIfReturnValueRequired(IProxyCall call, ICallContext invocation)
 {
     if (ctx.Behavior != MockBehavior.Loose &&
         invocation.Method != null &&
         invocation.Method.ReturnType != null &&
         invocation.Method.ReturnType != typeof(void))
     {
         var methodCall = call as MethodCallReturn;
         if (methodCall == null || !methodCall.HasReturnValue)
         {
             throw new MockException(
                 MockException.ExceptionReason.ReturnValueRequired,
                 ctx.Behavior,
                 invocation);
         }
     }
 }

		public InterceptionAction HandleIntercept(ICallContext invocation, InterceptorContext ctx, CurrentInterceptContext localctx)
        {
			if (invocation.Method != null && invocation.Method.ReturnType != null &&
                    invocation.Method.ReturnType != typeof(void))
            {
                Mock recursiveMock;
                if (ctx.Mock.InnerMocks.TryGetValue(invocation.Method, out recursiveMock))
                {
                    invocation.ReturnValue = recursiveMock.Object;
                }
                else
                {
                    invocation.ReturnValue = ctx.Mock.DefaultValueProvider.ProvideDefault(invocation.Method);
                }
                return InterceptionAction.Stop;
            }
            return InterceptionAction.Continue;
        }

        public InterceptionAction HandleIntercept(ICallContext invocation, InterceptStrategyContext ctx)
        {
            this.ctx = ctx;
            if (ctx.CurrentCall != null)
            {
                ctx.CurrentCall.SetOutParameters(invocation);

                // We first execute, as there may be a Throws 
                // and therefore we might never get to the 
                // next line.
                ctx.CurrentCall.Execute(invocation);
                ThrowIfReturnValueRequired(ctx.CurrentCall, invocation);
                return InterceptionAction.Stop;
            }
            else
            {
                return InterceptionAction.Continue;
            }
        }

 public override void AfterCall(ICallContext callContext)
 {
     System.Current.DateTime = (IDateTimeFactory)callContext.GetProperty("datetimefactory", null);
 }

 public override void BeforeCall(ICallContext callContext)
 {
     callContext.SetProperty("datetimefactory", System.Current.DateTime);
     System.Current.DateTime = mock;
 }

 /// <summary>
 /// Method called after a call is issued.
 /// </summary>
 public abstract void AfterCall(ICallContext callContext);

		public void Intercept(ICallContext invocation)
		{
			if (invocation.Method.IsDestructor())
			{
				return;
			}

			// Track current invocation if we're in "record" mode in a fluent invocation context.
			if (FluentMockContext.IsActive)
			{
				FluentMockContext.Current.Add(this.Mock, invocation);
			}

			// TODO: too many ifs in this method.
			// see how to refactor with strategies.
			if (invocation.Method.DeclaringType.IsGenericType() &&
			  invocation.Method.DeclaringType.GetGenericTypeDefinition() == typeof(IMocked<>))
			{
				// "Mixin" of IMocked<T>.Mock
				invocation.ReturnValue = this.Mock;
				return;
			}
			else if (invocation.Method.DeclaringType == typeof(IMocked))
			{
				// "Mixin" of IMocked.Mock
				invocation.ReturnValue = this.Mock;
				return;
			}

			// Special case for events.
			if (!FluentMockContext.IsActive)
			{
				if (invocation.Method.IsEventAttach())
				{
					var delegateInstance = (Delegate)invocation.Arguments[0];
					// TODO: validate we can get the event?
					var eventInfo = this.GetEventFromName(invocation.Method.Name.Substring(4));

					if (this.Mock.CallBase)
					{
						invocation.InvokeBase();
					}
					else if (delegateInstance != null)
					{
						this.AddEventHandler(eventInfo, (Delegate)invocation.Arguments[0]);
					}

					return;
				}
				else if (invocation.Method.IsEventDetach())
				{
					var delegateInstance = (Delegate)invocation.Arguments[0];
					// TODO: validate we can get the event?
					var eventInfo = this.GetEventFromName(invocation.Method.Name.Substring(7));

					if (this.Mock.CallBase)
					{
						invocation.InvokeBase();
					}
					else if (delegateInstance != null)
					{
						this.RemoveEventHandler(eventInfo, (Delegate)invocation.Arguments[0]);
					}

					return;
				}

				// Save to support Verify[expression] pattern.
				// In a fluent invocation context, which is a recorder-like 
				// mode we use to evaluate delegates by actually running them, 
				// we don't want to count the invocation, or actually run 
				// previous setups.
				actualInvocations.Add(invocation);
			}

			var call = FluentMockContext.IsActive ? (IProxyCall)null : orderedCalls.LastOrDefault(c => c.Matches(invocation));
			if (call == null && !FluentMockContext.IsActive && behavior == MockBehavior.Strict)
			{
				throw new MockException(MockException.ExceptionReason.NoSetup, behavior, invocation);
			}

			if (call != null)
			{
				call.SetOutParameters(invocation);

				// We first execute, as there may be a Throws 
				// and therefore we might never get to the 
				// next line.
				call.Execute(invocation);
				ThrowIfReturnValueRequired(call, invocation);
			}
			else if (invocation.Method.DeclaringType == typeof(object))
			{
				// Invoke underlying implementation.
				invocation.InvokeBase();
			}
			else if (invocation.Method.DeclaringType.IsClass() && !invocation.Method.IsAbstract && this.Mock.CallBase)
			{
				// For mocked classes, if the target method was not abstract, 
				// invoke directly.
//.........这里部分代码省略.........

		internal void AddInvocation(ICallContext invocation)
		{
			lock (actualInvocations)
			{
				actualInvocations.Add(invocation);
			}
		}

        internal void AddInvocation(ICallContext invocation)
        {
            lock (actualInvocations)
            {
                actualInvocations.Add(invocation);
            }

            lock (Mock.CallSequence)
            {
                Mock.CallSequence.Add(invocation, Mock);
            }
        }

		public void Intercept(ICallContext invocation)
		{

            lock (Mock) // this solves issue #249
            {
                var interceptionContext = new InterceptStrategyContext(Mock
                                                                    , targetType
                                                                    , invocationLists
                                                                    , actualInvocations
                                                                    , behavior
                                                                    , orderedCalls
                                                                    );
                foreach (var strategy in InterceptionStrategies())
                {
                    if (InterceptionAction.Stop == strategy.HandleIntercept(invocation, interceptionContext))
                    {
                        break;
                    }
                }
            }
		}

			public MockInvocation(Mock mock, ICallContext invocation, Match matcher)
			{
				this.Mock = mock;
				this.Invocation = invocation;
				this.Match = matcher;
				defaultValue = mock.DefaultValue;
				// Temporarily set mock default value to Mock so that recursion works.
				mock.DefaultValue = DefaultValue.Mock;
			}

		internal MockException(ExceptionReason reason, MockBehavior behavior,
			ICallContext invocation)
			: this(reason, behavior, invocation,
				Properties.Resources.ResourceManager.GetString(reason.ToString()))
		{
		}

 internal void Add(ICallContext invocation, Mock target)
 {
     recordedCalls.Add(invocation, target);
 }

		private static string GetMessage(
			MockBehavior behavior,
			ICallContext invocation,
			string message)
		{
			return string.Format(
				CultureInfo.CurrentCulture,
				Resources.MockExceptionMessage,
				invocation.Format(),
				behavior,
				message
			);
		}

 public void Intercept(ICallContext invocation)
 {
     CurrentInterceptContext localCtx = new CurrentInterceptContext();
     foreach (var strategy in InterceptionStrategies())
     {
         if (InterceptionAction.Stop == strategy.HandleIntercept(invocation, InterceptionContext, localCtx))
         {
             break;
         }
     }
 }

		public void Add(Mock mock, ICallContext invocation)
		{
			invocations.Add(new MockInvocation(mock, invocation, LastMatch));
		}