How to use ImplementationOverrideBehavior class of Telerik.JustMock.Core.Behaviors package

Best JustMockLite code snippet using Telerik.JustMock.Core.Behaviors.ImplementationOverrideBehavior

CommonExpectation.cs

Source:CommonExpectation.cs

...28	public partial class CommonExpectation<TContainer> : IAction<TContainer>, IInstanceScope<TContainer>, IMethodMock29	{30		private readonly List<IBehavior> behaviors = new List<IBehavior>();31		private readonly InvocationOccurrenceBehavior occurences;32		private ImplementationOverrideBehavior acceptCondition;33		MocksRepository IMethodMock.Repository { get; set; }34		IMockMixin IMethodMock.Mock { get; set; }35		bool IMethodMock.IsSequential { get; set; }36        bool IMethodMock.IsInOrder { get; set; }37        bool IMethodMock.IsUsed { get; set; }38		CallPattern IMethodMock.CallPattern { get; set; }39		ICollection<IBehavior> IMethodMock.Behaviors { get { return this.behaviors; } }40		InvocationOccurrenceBehavior IMethodMock.OccurencesBehavior { get { return this.occurences; } }41		string IMethodMock.ArrangementExpression { get; set; }42		ImplementationOverrideBehavior IMethodMock.AcceptCondition43		{44			get { return this.acceptCondition; }45			set46			{47				if (value == null)48					throw new ArgumentNullException("value");49				if (this.acceptCondition != null)50					throw new MockException("Condition already specified.");51				this.acceptCondition = value;52			}53		}54		private MocksRepository Repository55		{56			get { return ((IMethodMock)this).Repository; }57		}58		private CallPattern CallPattern59		{60			get { return ((IMethodMock)this).CallPattern; }61		}62		internal IMockMixin Mock63		{64			get { return ((IMethodMock)this).Mock; }65		}66		internal CommonExpectation()67		{68			this.occurences = new InvocationOccurrenceBehavior(this);69			this.behaviors.Add(this.occurences);70		}71		#region Implementation from ICommon<TContainer>72		/// <summary>73		/// Implementation detail.74		/// </summary>75		/// <param name="delg"></param>76		/// <param name="ignoreDelegateReturnValue"></param>77		protected void ProcessDoInstead(Delegate delg, bool ignoreDelegateReturnValue)78		{79			if (delg == null)80			{81				var returnType = CallPattern.Method.GetReturnType();82				if (returnType == typeof(void))83					returnType = typeof(object);84				if (returnType.IsValueType && Nullable.GetUnderlyingType(returnType) == null)85					throw new MockException(String.Format("Cannot return null value for non-nullable return type '{0}'.", returnType));86				delg = Expression.Lambda(typeof(Func<>).MakeGenericType(returnType),87					Expression.Constant(null, returnType)).Compile();88			}89			this.behaviors.Add(new ImplementationOverrideBehavior(delg, ignoreDelegateReturnValue));90		}91		/// <summary>92		/// Defines the body of the expected method that will be executed instead of the orginal method body.93		/// </summary>94		/// <param name="action">delegate the method body</param>95		/// <returns></returns>96		public TContainer DoInstead(Action action)97		{98			return ProfilerInterceptor.GuardInternal(() =>99				{100					ProcessDoInstead(action, true);101					return (TContainer)(object)this;102				});103		}104		/// <summary>105		/// Specifies the delegate that will execute for the expected method.106		/// </summary>107		/// <param name="delegate">Target delegate to evaluate.</param>108		public TContainer DoInstead(Delegate @delegate)109		{110			return ProfilerInterceptor.GuardInternal(() =>111				{112					ProcessDoInstead(@delegate, true);113					return (TContainer)(object)this;114				});115		}116		private void ProcessRaises(Action eventExpression, Func<object, Delegate> eventArgumentsFactoryFactory)117		{118			object instance = null;119			var evt = Repository.ParseAddHandlerAction(eventExpression, out instance);120			this.behaviors.Add(new RaiseEventBehavior(instance, evt, eventArgumentsFactoryFactory(instance)));121		}122		///<summary>123		/// Raises the expected with sepecic arguments124		///</summary>125		public TContainer Raises(Action eventExpression, params object[] args)126		{127			return ProfilerInterceptor.GuardInternal(() =>128				{129#if !PORTABLE130					IWaitDuration wait = args.OfType<IWaitDuration>().FirstOrDefault();131					if (wait != null)132					{133						args = args.Where(obj => obj != wait).ToArray();134					}135#endif136					this.ProcessRaises(eventExpression, instance => new Func<object[]>(() =>137						{138#if !PORTABLE139							if (wait != null)140								Thread.Sleep(wait.Miliseconds);141#endif142							return args;143						}));144					return (TContainer)(object)this;145				});146		}147		///<summary>148		/// Raises the expected event with provided <see cref="EventArgs"/>.149		///</summary>150		///<param name="eventExpression"></param>151		///<param name="args">Event arguments</param>152		///<returns></returns>153		///<exception cref="InvalidOperationException"></exception>154		public TContainer Raises(Action eventExpression, EventArgs args)155		{156			return ProfilerInterceptor.GuardInternal(() =>157				{158					this.ProcessRaises(eventExpression, instance => new Func<object[]>(() => new object[] { instance, args }));159					return (TContainer)(object)this;160				});161		}162		///<summary>163		/// Raises the expected event for the setup.164		///</summary>165		///<param name="eventExpression"></param>166		///<param name="func">Function that will be used to construct event arguments</param>167		///<returns></returns>168		///<exception cref="InvalidOperationException"></exception>169		public TContainer Raises<T1>(Action eventExpression, Func<T1, EventArgs> func)170		{171			return ProfilerInterceptor.GuardInternal(() =>172				{173					this.ProcessRaises(eventExpression, instance => new Func<T1, object[]>(t1 => new object[] { instance, func(t1) }));174					return (TContainer)(object)this;175				});176		}177		///<summary>178		/// Raises the expected event for the setup.179		///</summary>180		///<param name="eventExpression"></param>181		///<param name="func">An function that will be used to construct event arguments</param>182		///<returns></returns>183		///<exception cref="InvalidOperationException"></exception>184		public TContainer Raises<T1, T2>(Action eventExpression, Func<T1, T2, EventArgs> func)185		{186			return ProfilerInterceptor.GuardInternal(() =>187				{188					this.ProcessRaises(eventExpression, instance => new Func<T1, T2, object[]>((t1, t2) => new object[] { instance, func(t1, t2) }));189					return (TContainer)(object)this;190				});191		}192		///<summary>193		/// Raises the expected event for the setup.194		///</summary>195		///<param name="eventExpression"></param>196		///<param name="func">An function that will be used to construct event arguments</param>197		///<returns></returns>198		///<exception cref="InvalidOperationException"></exception>199		public TContainer Raises<T1, T2, T3>(Action eventExpression, Func<T1, T2, T3, EventArgs> func)200		{201			return ProfilerInterceptor.GuardInternal(() =>202				{203					this.ProcessRaises(eventExpression, instance => new Func<T1, T2, T3, object[]>((t1, t2, t3) => new object[] { instance, func(t1, t2, t3) }));204					return (TContainer)(object)this;205				});206		}207		///<summary>208		/// Raises the expected event for the setup.209		///</summary>210		///<param name="eventExpression"></param>211		///<param name="func">An function that will be used to construct event arguments</param>212		///<returns></returns>213		///<exception cref="InvalidOperationException"></exception>214		public TContainer Raises<T1, T2, T3, T4>(Action eventExpression, Func<T1, T2, T3, T4, EventArgs> func)215		{216			return ProfilerInterceptor.GuardInternal(() =>217				{218					this.ProcessRaises(eventExpression, instance => new Func<T1, T2, T3, T4, object[]>((t1, t2, t3, t4) => new object[] { instance, func(t1, t2, t3, t4) }));219					return (TContainer)(object)this;220				});221		}222		/// <summary>223		/// Throws a the specified expection for target call.224		/// </summary>225		/// <param name="exception"></param>226		/// <returns></returns>227		public IAssertable Throws(Exception exception)228		{229			return ProfilerInterceptor.GuardInternal(() =>230				{231					this.behaviors.Add(new ThrowExceptionBehavior(exception));232					return this;233				});234		}235		/// <summary>236		/// Throws a the specified expection for target call.237		/// </summary>238		/// <returns></returns>239		public IAssertable Throws<T>() where T : Exception240		{241			return ProfilerInterceptor.GuardInternal(() =>242				{243					this.behaviors.Add(new ThrowExceptionBehavior((T)MockingUtil.CreateInstance(typeof(T))));244					return this;245				});246		}247		/// <summary>248		/// Throws a the specified expection for target call.249		/// </summary>250		/// <returns></returns>251		public IAssertable Throws<T>(params object[] args) where T : Exception252		{253			return ProfilerInterceptor.GuardInternal(() =>254				{255					this.behaviors.Add(new ThrowExceptionBehavior((T)MockingUtil.CreateInstance(typeof(T), args)));256					return this;257				});258		}259#if !LITE_EDITION260		/// <summary>261		/// Throws a the specified exception for the target async call causing returned task to fail.262		/// </summary>263		/// <param name="exception"></param>264		/// <returns></returns>265		public IAssertable ThrowsAsync(Exception exception)266		{267			return ProfilerInterceptor.GuardInternal(() =>268			{269				this.behaviors.Add(new ThrowAsyncExceptionBehavior(exception));270				return this;271			});272		}273		/// <summary>274		/// Throws a the specified exception for the target async call causing returned task to fail.275		/// </summary>276		/// <returns></returns>277		public IAssertable ThrowsAsync<T>() where T : Exception278		{279			return ProfilerInterceptor.GuardInternal(() =>280			{281				this.behaviors.Add(new ThrowAsyncExceptionBehavior((T)MockingUtil.CreateInstance(typeof(T))));282				return this;283			});284		}285		/// <summary>286		/// Throws a the specified exception for the target async call causing returned task to fail.287		/// </summary>288		/// <returns></returns>289		public IAssertable ThrowsAsync<T>(params object[] args) where T : Exception290		{291			return ProfilerInterceptor.GuardInternal(() =>292			{293				this.behaviors.Add(new ThrowAsyncExceptionBehavior((T)MockingUtil.CreateInstance(typeof(T), args)));294				return this;295			});296		}297#endif298		/// <summary>299		/// Use it to call the real implementation.300		/// </summary>301		/// <returns></returns>302		public IAssertable CallOriginal()303		{304			return ProfilerInterceptor.GuardInternal(() =>305				{306					this.behaviors.Add(new CallOriginalBehavior());307					return this;308				});309		}310		/// <summary>311		///  Specfies call a to step over.312		/// </summary>313		/// <remarks>314		/// For loose mocks by default the behavior is step over.315		/// </remarks>316		/// <returns>Refarence to <see cref="IAssertable"/></returns>317		public IAssertable DoNothing()318		{319			return ProfilerInterceptor.GuardInternal(() =>320				{321					ProcessDoInstead(new Action(() => { }), true);322					return this;323				});324		}325		#endregion326		#region Implementation of IAssertable327		/// <summary>328		/// Specifies that the arranged member must be called. Asserting the mock will throw if the expectation is not fulfilled.329		/// </summary>330		public IDisposable MustBeCalled(string message = null)331		{332			return ProfilerInterceptor.GuardInternal(() => SetOccurrenceBounds(1, null, message));333		}334		#endregion335		#region Occurrence336		/// <summary>337		/// Specifies how many times the call should occur.338		/// </summary>339		/// <param name="numberOfTimes">Specified number of times</param>340		public IDisposable Occurs(int numberOfTimes, string message = null)341		{342			return ProfilerInterceptor.GuardInternal(() => SetOccurrenceBounds(numberOfTimes, numberOfTimes, message));343		}344		/// <summary>345		/// Specifies how many times atleast the call should occur.346		/// </summary>347		/// <param name="numberOfTimes">Specified number of times</param>348		public IDisposable OccursAtLeast(int numberOfTimes, string message = null)349		{350			return ProfilerInterceptor.GuardInternal(() => SetOccurrenceBounds(numberOfTimes, null, message));351		}352		/// <summary>353		/// Specifies how many times maximum the call can occur.354		/// </summary>355		/// <param name="numberOfTimes">Specified number of times</param>356		public IDisposable OccursAtMost(int numberOfTimes, string message = null)357		{358			return ProfilerInterceptor.GuardInternal(() => SetOccurrenceBounds(null, numberOfTimes, message));359		}360		/// <summary>361		/// Specifies that the call must occur once.362		/// </summary>363		public IDisposable OccursOnce(string message = null)364		{365			return ProfilerInterceptor.GuardInternal(() => SetOccurrenceBounds(1, 1, message));366		}367		/// <summary>368		/// Specifies that the call must never occur.369		/// </summary>370		public IDisposable OccursNever(string message = null)371		{372			return ProfilerInterceptor.GuardInternal(() => SetOccurrenceBounds(0, 0, message));373		}374		#endregion375		/// <summary>376		/// Specifies that JustMock should invoke different mock instance for each setup.377		/// </summary>378		/// <remarks>379		/// When this modifier is applied380		/// for similar type call, the flow of setups will be maintained.381		/// </remarks>382		public IAssertable InSequence()383		{384			return ProfilerInterceptor.GuardInternal(() =>385				{386					(this as IMethodMock).IsSequential = true;387					return this;388				});389		}390		/// <summary>391		/// Specifies a call should occur in a specific order.392		/// </summary>393		public IOccurrence InOrder(string message = null)394		{395			return ProfilerInterceptor.GuardInternal(() =>396				{397                    (this as IMethodMock).IsInOrder = true;398                    this.behaviors.Add(new InOrderBehavior(this.Repository, this.Mock, message));399					return this;400				});401		}402		/// <summary>403		/// Determines whether prerequisite is met404		/// </summary>405		public bool IsMet406		{407			get408			{409				return ProfilerInterceptor.GuardInternal(() => ((IMethodMock)this).IsUsed);410			}411		}412		/// <summary>413		/// Specifies that a call should occur only after all of the given prerequisites have been met.414		/// </summary>415		public IAssertable AfterAll(params IPrerequisite[] prerequisites)416		{417			return ProfilerInterceptor.GuardInternal(() =>418			{419				this.behaviors.Add(new AfterAllBehavior(prerequisites));420				return this;421			});422		}423		/// <summary>424		/// Defines that the expectation should occur for all instance.425		/// </summary>426		public TContainer IgnoreInstance()427		{428			return ProfilerInterceptor.GuardInternal(() =>429				{430					this.CallPattern.InstanceMatcher = new AnyMatcher();431					this.CallPattern.MethodMockNode.ReattachMethodMock();432					return (TContainer)(object)this;433				});434		}435		/// <summary>436		/// Specifies that the arrangement will be respected regardless of the thread437		/// on which the call to the arranged member happens.438		/// </summary>439		/// <remarks>440		/// This is only needed for arrangements of static members. Arrangements on441		/// instance members are always respected, regardless of the current thread.442		/// 443		/// Cross-thread arrangements are active as long as the current context444		/// (test method) is on the call stack. Be careful when arranging445		/// static members cross-thread because the effects of the arrangement may446		/// affect and even crash the testing framework.447		/// </remarks>448		public IAssertable OnAllThreads()449		{450			return ProfilerInterceptor.GuardInternal(() =>451				{452					this.Repository.InterceptGlobally(this.CallPattern.Method);453					return this;454				});455		}456		/// <summary>457		/// Specifies an additional condition that must be true for this arrangement to be458		/// considered when the arranged member is called. This condition is evaluated in addition459		/// to the conditions imposed by any argument matchers in the arrangement.460		/// 461		/// This method allows a more general way of matching arrangements than argument matchers do.462		/// </summary>463		/// <param name="condition">A function that should return 'true' when this464		/// arrangement should be considered and 'false' if this arrangement doesn't match the user criteria.</param>465		public TContainer When(Func<bool> condition)466		{467			return ProfilerInterceptor.GuardInternal(() =>468			{469				this.SetAcceptCondition(condition);470				return (TContainer)(object)this;471			});472		}473		private void SetAcceptCondition(Delegate condition)474		{475			((IMethodMock)this).AcceptCondition = new ImplementationOverrideBehavior(condition, false);476		}477		/// <summary>478		/// Specifies to ignore any argument for the target call.479		/// </summary>480		/// <returns>Func or Action Container</returns>481		public TContainer IgnoreArguments()482		{483			return ProfilerInterceptor.GuardInternal(() =>484			{485				var callPattern = this.CallPattern;486				for (int i = 0; i < callPattern.ArgumentMatchers.Count; i++)487				{488					callPattern.ArgumentMatchers[i] = new AnyMatcher();489				}...

ImplementationOverrideBehavior.cs

Source:ImplementationOverrideBehavior.cs

...17using System.Reflection;18#endif19namespace Telerik.JustMock.Core.Behaviors20{21	internal class ImplementationOverrideBehavior : IBehavior22	{23		private static readonly object[] Empty = new object[0];24		private readonly Delegate implementationOverride;25		private readonly bool ignoreDelegateReturnValue;26		private readonly Func<object[], Delegate, object> overrideInvoker;27		public ImplementationOverrideBehavior(Delegate implementationOverride, bool ignoreDelegateReturnValue)28		{29			this.ignoreDelegateReturnValue = ignoreDelegateReturnValue;30			this.implementationOverride = implementationOverride;31			this.overrideInvoker = MockingUtil.MakeFuncCaller(implementationOverride);32		}33		public object CallOverride(Invocation invocation)34		{35			var args = implementationOverride.Method.GetParameters().Length > 0 && invocation.Args != null ? invocation.Args : Empty;36			var paramsCount = invocation.Method.GetParameters().Length;37			var implementationParamsCount = implementationOverride.Method.GetParameters().Length;38			if (invocation.Method.IsExtensionMethod() && paramsCount - 1 == implementationParamsCount)39			{40				args = args.Skip(1).ToArray();41			}...

IMethodMock.cs

Source:IMethodMock.cs

...26		string ArrangementExpression { get; set; }27		bool IsSequential { get; set; }28		bool IsInOrder { get; set; }29		bool IsUsed { get; set; }30		ImplementationOverrideBehavior AcceptCondition { get; set; }31	}32}...