How to use Expr class of Telerik.JustMock package

...68		{69			var foo = Mock.Create<Foo>(Behavior.CallOriginal);70			bool called = false;71			Mock.NonPublic72				.Arrange(foo, "ExecuteProtected", Arg.Expr.IsAny<int>(), Arg.Expr.IsNull<Foo>())73				.DoInstead(() => called = true);74			foo.Execute(10, null);75			Assert.True(called);76		}77		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]78		public void ShouldMockOverloadUsingConcreteValues()79		{80			var foo = Mock.Create<Foo>(Behavior.CallOriginal);81			bool called = false, called2 = false;82			Mock.NonPublic83				.Arrange(foo, "ExecuteProtected", 10, Arg.Expr.IsNull<FooDerived>())84				.DoInstead(() => called = true);85			Mock.NonPublic86				.Arrange(foo, "ExecuteProtected", Arg.Expr.IsNull<FooDerived>(), 10)87				.DoInstead(() => called2 = true);88			foo.Execute(10, null);89			foo.Execute(null, 10);90			Assert.True(called);91			Assert.True(called2);92		}93		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]94		public void ShouldThrowArgumentExpectionForNullArguments()95		{96			var foo = Mock.Create<Foo>(Behavior.CallOriginal);97			Assert.Throws<ArgumentException>(() => Mock.NonPublic.Arrange(foo, "ExecuteProtected", 0, null));98		}99		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]100		public void ShouldAssertNonPublicActions()101		{102			var foo = Mock.Create<Foo>(Behavior.CallOriginal);103			Mock.NonPublic.Arrange(foo, "ExecuteProtected", 10);104			foo.Execute(10);105			// assert if called as expected.106			Mock.NonPublic.Assert(foo, "ExecuteProtected", 10);107		}108		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]109		public void ShouldAssertNonPublicFunctions()110		{111			var foo = Mock.Create<Foo>(Behavior.CallOriginal);112			Mock.NonPublic.Arrange<int>(foo, "IntValue").Returns(10);113			foo.GetMultipleOfIntValue();114			Mock.NonPublic.Assert<int>(foo, "IntValue");115		}116		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]117		public void ShouldThrowForAssertingCallsThatWereNotInvoked()118		{119			var foo = Mock.Create<Foo>(Behavior.CallOriginal);120			Mock.NonPublic.Arrange(foo, "ExecuteProtected", 10);121			// assert if called as expected.122			Assert.Throws<AssertionException>(() => Mock.NonPublic.Assert(foo, "ExecuteProtected", 10));123		}124		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]125		public void ShouldAssertOccrenceForNonPublicFunction()126		{127			var foo = Mock.Create<Foo>(Behavior.CallOriginal);128			Mock.NonPublic.Assert<int>(foo, "IntValue", Occurs.Never());129		}130		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]131		public void ShouldAssertOccurenceForNonPublicAction()132		{133			var foo = Mock.Create<Foo>(Behavior.CallOriginal);134			Mock.NonPublic.Arrange(foo, "ExecuteProtected", 10);135			foo.Execute(10);136			Mock.NonPublic.Assert(foo, "ExecuteProtected", Occurs.Exactly(1), 10);137		}138		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]139		public void ShouldThrowMissingMethodExceptionForMethodSpecification()140		{141			var foo = Mock.Create<Foo>(Behavior.CallOriginal);142			Assert.Throws<MissingMemberException>(() => Mock.NonPublic.Arrange(foo, "ExecuteProtected"));143		}144#if !SILVERLIGHT145		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]146		public void ShouldCreateMockFromClassHavingAbstractInternalMethodInBase()147		{148			var foo = Mock.Create<FooAbstract2>();149			foo.TryCreateToken(string.Empty);150		}151		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]152		public void ShouldMockTypeWithInternalCtorWhenInternalVisibleToIsApplied()153		{154			// Provided that InternalsVisibleTo attribute is included in assemblyinfo.cs.155			var foo = Mock.Create<FooInternal>(Behavior.CallOriginal);156			Assert.NotNull(foo.Builder);157		}158		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]159		public void ShouldAssertNonPublicMethodFromBase()160		{161			var baz = Mock.Create<Baz>(Behavior.CallOriginal);162			const string targetMethod = "MethodToMock";163			Mock.NonPublic.Arrange(baz, targetMethod).DoNothing();164			baz.MethodToTest();165			Mock.NonPublic.Assert(baz, targetMethod);166		}167#if !PORTABLE168		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]169		public void ShouldAssertNonPublicCallWhenOccurrenceIsApplied()170		{171			var baz = Mock.Create<Bar>(Behavior.CallOriginal);172			const string targetMethod = "MethodToMock";173			Mock.NonPublic.Arrange(baz, targetMethod).OccursOnce();174			baz.GetType().GetMethod(targetMethod, BindingFlags.NonPublic | BindingFlags.Instance).Invoke(baz, null);175			Mock.NonPublic.Assert(baz, targetMethod);176		}177		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic"), TestCategory("Assertion")]178		public void ShouldGetTimesCalledOfNonPublicMethod()179		{180			var mock = Mock.Create<Bar>();181			Mock.NonPublic.MakePrivateAccessor(mock).CallMethod("MethodToMock");182			Assert.Equal(1, Mock.NonPublic.GetTimesCalled(mock, "MethodToMock"));183			Assert.Equal(1, Mock.NonPublic.GetTimesCalled(mock, typeof(Bar).GetMethod("MethodToMock", BindingFlags.NonPublic | BindingFlags.Instance)));184		}185#endif186		public class Bar187		{188			protected virtual void MethodToMock()189			{190				throw new ArgumentException("Base method Invoked");191			}192		}193		public class Baz : Bar194		{195			public virtual void MethodToTest()196			{197				MethodToMock();198			}199		}200		internal class FooInternal201		{202			internal FooInternal()203			{204				builder = new StringBuilder();205			}206			public StringBuilder Builder207			{208				get209				{210					return builder;211				}212			}213			private StringBuilder builder;214		}215#endif216		internal abstract class FooAbstract217		{218			protected internal abstract bool TryCreateToken(string literal);219		}220		internal abstract class FooAbstract2 : FooAbstract221		{222		}223		public class Foo224		{225			protected virtual void ExecuteProtected(Foo foo, int arg1)226			{227				throw new NotImplementedException();228			}229			protected virtual void ExecuteProtected(int arg1, Foo foo)230			{231				throw new NotImplementedException();232			}233			protected virtual void ExecuteProtected(int arg1)234			{235				throw new NotImplementedException();236			}237			public virtual void Execute(int arg1)238			{239				ExecuteProtected(arg1);240			}241			public virtual void Execute(int arg1, Foo foo)242			{243				ExecuteProtected(arg1, foo);244			}245			public virtual void Execute(Foo foo, int arg1)246			{247				ExecuteProtected(foo, arg1);248			}249			protected virtual void Load()250			{251				throw new NotImplementedException();252			}253			protected virtual int IntValue254			{255				get256				{257					throw new NotImplementedException();258				}259			}260			public virtual void Init()261			{262				Load();263			}264			public virtual int GetMultipleOfIntValue()265			{266				return IntValue * 2;267			}268		}269		public class FooDerived : Foo270		{271		}272		public class RefTest273		{274			protected virtual void Test(string arg1, ref string asd)275			{276			}277			public void ExecuteTest(ref string asd)278			{279				this.Test("test1", ref asd);280			}281		}282		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]283		public void ShouldArrangeNonPublicUsingByRefArgumentWithMatcher()284		{285			var foo = Mock.Create<RefTest>(Behavior.CallOriginal);286			Mock.NonPublic.Arrange(foo, "Test", Arg.Expr.IsAny<string>(), Arg.Expr.Ref(Arg.Expr.IsAny<string>())).MustBeCalled();287			string asd = "asd";288			foo.ExecuteTest(ref asd);289			Mock.Assert(foo);290		}291		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]292		public void ShouldArrangeNonPublicUsingByRefArgumentWithConstant()293		{294			int call = 1;295			int callA = 0, callB = 0;296			var foo = Mock.Create<RefTest>(Behavior.CallOriginal);297			Mock.NonPublic.Arrange(foo, "Test", Arg.Expr.IsAny<string>(), Arg.Expr.Ref(Arg.Expr.IsAny<string>())).DoInstead(() => callB = call++);298			Mock.NonPublic.Arrange(foo, "Test", Arg.Expr.IsAny<string>(), Arg.Expr.Ref("asd")).DoInstead(() => callA = call++);299			string input = "asd";300			foo.ExecuteTest(ref input);301			input = "foo";302			foo.ExecuteTest(ref input);303			Assert.Equal(1, callA);304			Assert.Equal(2, callB);305		}306		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]307		public void ShouldArrangeNonPublicUsingByRefArgumentAsOutputParameter()308		{309			var foo = Mock.Create<RefTest>(Behavior.CallOriginal);310			Mock.NonPublic.Arrange(foo, "Test", Arg.Expr.IsAny<string>(), Arg.Expr.Out("asd"));311			string input = "";312			foo.ExecuteTest(ref input);313			Assert.Equal("asd", input);314		}315		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]316		public void ShouldNotArrangeNonPublicUsingConstantArgumentWhereByRefIsExpected()317		{318			var foo = Mock.Create<RefTest>(Behavior.CallOriginal);319			Assert.Throws<MissingMemberException>(() => Mock.NonPublic.Arrange(foo, "Test", Arg.Expr.IsAny<string>(), "asd"));320		}321		public abstract class WeirdSignature322		{323			protected abstract int Do(int a, string b, ref object c, IEnumerable<int> d);324			protected abstract void Do(bool b);325			protected abstract DateTime Do(DateTime dateTime);326			protected static void Do(int d) { }327			protected static int Do(char e) { return 0; }328		}329		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]330		public void ShouldProvideHelpfulExceptionMessageWhenNonPublicMethodIsMissing()331		{332			var foo = Mock.Create<WeirdSignature>();333			var exception = Assert.Throws<MissingMemberException>(() => Mock.NonPublic.Arrange(foo, "Do"));334			var message = exception.Message;335			Assert.Equal(("Method 'Do' with the given signature was not found on type Telerik.JustMock.Tests.NonPublicFixture+WeirdSignature\r\n" +336"Review the available methods in the message below and optionally paste the appropriate arrangement snippet.\r\n" +337"----------\r\n" +338"Method 1: Int32 Do(Int32, System.String, System.Object ByRef, System.Collections.Generic.IEnumerable`1[System.Int32])\r\n" +339"C#: Mock.NonPublic.Arrange<int>(mock, \"Do\", Arg.Expr.IsAny<int>(), Arg.Expr.IsAny<string>(), Arg.Expr.Ref(Arg.Expr.IsAny<object>()), Arg.Expr.IsAny<IEnumerable<int>>());\r\n" +340"VB: Mock.NonPublic.Arrange(Of Integer)(mock, \"Do\", Arg.Expr.IsAny(Of Integer)(), Arg.Expr.IsAny(Of String)(), Arg.Expr.Ref(Arg.Expr.IsAny(Of Object)()), Arg.Expr.IsAny(Of IEnumerable(Of Integer))())\r\n" +341"----------\r\n" +342"Method 2: Void Do(Boolean)\r\n" +343"C#: Mock.NonPublic.Arrange(mock, \"Do\", Arg.Expr.IsAny<bool>());\r\n" +344"VB: Mock.NonPublic.Arrange(mock, \"Do\", Arg.Expr.IsAny(Of Boolean)())\r\n" +345"----------\r\n" +346"Method 3: System.DateTime Do(System.DateTime)\r\n" +347"C#: Mock.NonPublic.Arrange<DateTime>(mock, \"Do\", Arg.Expr.IsAny<DateTime>());\r\n" +348"VB: Mock.NonPublic.Arrange(Of Date)(mock, \"Do\", Arg.Expr.IsAny(Of Date)())\r\n" +349"----------\r\n" +350"Method 4: Void Do(Int32)\r\n" +351"C#: Mock.NonPublic.Arrange(\"Do\", Arg.Expr.IsAny<int>());\r\n" +352"VB: Mock.NonPublic.Arrange(\"Do\", Arg.Expr.IsAny(Of Integer)())\r\n" +353"----------\r\n" +354"Method 5: Int32 Do(Char)\r\n" +355"C#: Mock.NonPublic.Arrange<int>(\"Do\", Arg.Expr.IsAny<char>());\r\n" +356"VB: Mock.NonPublic.Arrange(Of Integer)(\"Do\", Arg.Expr.IsAny(Of Char)())\r\n").Replace("\r\n", Environment.NewLine), message);357			var exception2 = Assert.Throws<MissingMemberException>(() => Mock.NonPublic.Arrange(foo, "Dont"));358			var message2 = exception2.Message;359			Assert.Equal(("Method 'Dont' with the given signature was not found on type Telerik.JustMock.Tests.NonPublicFixture+WeirdSignature\r\n" +360				"No methods or properties found with the given name.\r\n").Replace("\r\n", Environment.NewLine), message2);361		}362		public abstract class NonPublicOverloads363		{364			protected abstract int NotOverloaded(int a, out object b);365			protected abstract int Overloaded(int a);366			protected abstract int Overloaded(string a);367			protected abstract int Prop { set; }368			public int CallNotOverloaded(int a, out object b)369			{370				return NotOverloaded(a, out b);371			}372			public int SetProp373			{374				set { Prop = value; }375			}376		}377		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]378		public void ShouldQuickArrangeNonPublicNonOverloadedMethod()379		{380			var mock = Mock.Create<NonPublicOverloads>(Behavior.CallOriginal);381			Mock.NonPublic.Arrange<int>(mock, "NotOverloaded").Returns(5);382			object b;383			var result = mock.CallNotOverloaded(5, out b);384			Assert.Equal(5, result);385		}386		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]387		public void ShouldQuickArrangeNonPublicSetter()388		{389			var mock = Mock.Create<NonPublicOverloads>(Behavior.CallOriginal);390			bool called = false;391			Mock.NonPublic.Arrange(mock, "Prop").DoInstead(() => called = true);392			mock.SetProp = 5;393			Assert.True(called);394		}395		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]396		public void ShouldFailToQuickArrangeNonPublicOverloadedMethods()397		{398			var mock = Mock.Create<NonPublicOverloads>();399			Assert.Throws<MissingMemberException>(() => Mock.NonPublic.Arrange<int>(mock, "Overloaded"));400		}401		public abstract class GenericTest402		{403			protected abstract T Do<T>(T x);404			protected abstract IEnumerable<T> Enumerate<T>();405			public int TestDo()406			{407				return Do(10);408			}409			public IEnumerable<int> TestEnumerate()410			{411				return Enumerate<int>();412			}413		}414		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]415		public void ShouldArrangeNonPublicMethodReturningGenericValue()416		{417			var mock = Mock.Create<GenericTest>(Behavior.CallOriginal);418			Mock.NonPublic.Arrange<int>(mock, "Do", Arg.Expr.IsAny<int>()).Returns(123);419			Assert.Equal(123, mock.TestDo());420		}421		[TestMethod, TestCategory("Lite"), TestCategory("NonPublic")]422		public void ShouldArrangeNonPublicMethodReturningGenericValueComplexType()423		{424			var mock = Mock.Create<GenericTest>(Behavior.CallOriginal);425			Mock.NonPublic.Arrange<IEnumerable<int>>(mock, "Enumerate").Returns(new[] { 123 });426			var actual = mock.TestEnumerate().ToArray();427			Assert.Equal(1, actual.Length);428			Assert.Equal(123, actual[0]);429		}430	}431}...

...12   limitations under the License.13*/14using System;15using System.ComponentModel;16using System.Linq.Expressions;17using Telerik.JustMock.Core;18using Telerik.JustMock.Core.MatcherTree;19namespace Telerik.JustMock20{21	/// <summary>22	/// Allows specification of a matching condition for an argument for a non-public method, rather23	/// a specific value.24	/// </summary>25#if !PORTABLE26	[Browsable(false)]27	[EditorBrowsable(EditorBrowsableState.Never)]28#endif29	public partial class ArgExpr30	{31		internal ArgExpr() { }32		/// <summary>33		/// Matches argument for any value.34		/// </summary>35		/// <typeparam name="T">Type for the argument</typeparam>36		/// <returns>Argument type</returns>37		public static Expression IsAny<T>()38		{39			return ProfilerInterceptor.GuardInternal(() =>40			{41				Expression<Func<T>> expr = () => Arg.IsAny<T>();42				return expr.Body;43			});44		}45		/// <summary>46		/// Matches argument for any value of a given type.47		/// </summary>48		/// <param name="type">Type for the argument</param>49		/// <param name="args">Constructor arguments</param>50		/// <returns>Argument type</returns>51		public static Expression IsAny(Type type, params object[] args)52		{53			return ProfilerInterceptor.GuardInternal(() =>54			{55				Expression<Func<object>> expr = () => Arg.IsAny(type, args);56				return expr.Body;57			});58		}59		/// <summary>60		/// Matches argument for the expected condition.61		/// </summary>62		/// <typeparam name="T">63		/// Contains the type of the argument.64		/// </typeparam>65		/// <param name="match">Matcher expression</param>66		/// <returns>Argument type</returns>67		public static Expression Matches<T>(Expression<Predicate<T>> match)68		{69			return ProfilerInterceptor.GuardInternal(() =>70			{71				Expression<Func<T>> expr = () => Arg.Matches<T>(match);72				return expr.Body;73			});74		}75		/// <summary>76		/// Matches argument for null value.77		/// </summary>78		/// <typeparam name="T">Type for the argument</typeparam>79		/// <returns>Argument type</returns>80		public static Expression IsNull<T>()81		{82			return ProfilerInterceptor.GuardInternal(() =>83			{84				Expression<Func<T>> expr = () => Arg.IsNull<T>();85				return expr.Body;86			});87		}88		/// <summary>89		/// Returns a value from a ref or out argument90		/// </summary>91		/// <typeparam name="T">Type for the argument</typeparam>92		/// <param name="value">Value to match.</param>93		/// <returns>Argument type</returns>94		public static Expression Out<T>(T value)95		{96			return ProfilerInterceptor.GuardInternal(() =>97			{98				Expression<Func<T>> expr = () => OutArg(value);99				return expr.Body;100			});101		}102		[OutArg]103		private static T OutArg<T>(T value)104		{105			return value;106		}107	108		/// <summary>109		/// Matches a value for ref argument110		/// </summary>111		/// <typeparam name="T">Type for the argument</typeparam>112		/// <param name="value">Value to match.</param>113		/// <returns>Argument type</returns>114		public static Expression Ref<T>(T value)115		{116			return ProfilerInterceptor.GuardInternal(() =>117			{118				Expression<Func<T>> expr = () => Arg.Ref<T>(value).Value;119				return expr.Body;120			});121		}122	}123}...

...12   limitations under the License.13*/14using System;15using System.Linq;16using System.Linq.Expressions;17using Telerik.JustMock.Core;18namespace Telerik.JustMock.Expectations19{20	internal class ReturnArranger : FunctionalSpecParser.IReturnArranger21	{22		private ReturnArranger()23		{24		}25		public static readonly ReturnArranger Instance = new ReturnArranger();26		public void ArrangeReturn<T>(Expression<Func<T>> callPattern, LambdaExpression returnValueExpr)27		{28			var noParams = returnValueExpr as Expression<Func<T>>;29			if (noParams != null)30			{31				Telerik.JustMock.Mock.Arrange(callPattern).Returns((T)noParams.Body.EvaluateExpression());32				return;33			}34			var method = typeof(FuncExpectation<T>).GetMethods()35												   .Single(m => m.Name == "Returns" && m.GetGenericArguments().Length == returnValueExpr.Parameters.Count);36			method = method.MakeGenericMethod(returnValueExpr.Parameters.Select(param => param.Type).ToArray());37			var expectation = Telerik.JustMock.Mock.Arrange(callPattern);38			method.Invoke(expectation, new object[] { returnValueExpr.Compile() });39		}40	}41}...

1using System;2using Telerik.JustMock;3using Telerik.JustMock.Helpers;4{5    public static void Main()6    {7        var mock = Mock.Create<Expr>();8        Mock.Arrange(() => mock.Eval()).Returns(10);9        Console.WriteLine(mock.Eval());10    }11}12using System;13using Telerik.JustMock;14using Telerik.JustMock.Helpers;15{16    public static void Main()17    {18        var mock = Mock.Create<Expr>();19        Mock.Arrange(() => mock.Eval()).Returns(10);20        Console.WriteLine(mock.Eval());21    }22}23using System;24using Telerik.JustMock;25using Telerik.JustMock.Helpers;26{27    public static void Main()28    {29        var mock = Mock.Create<Expr>();30        Mock.Arrange(() => mock.Eval()).Returns(10);31        Console.WriteLine(mock.Eval());32    }33}34using System;35using Telerik.JustMock;36using Telerik.JustMock.Helpers;37{38    public static void Main()39    {40        var mock = Mock.Create<Expr>();41        Mock.Arrange(() => mock.Eval()).Returns(10);42        Console.WriteLine(mock.Eval());43    }44}45using System;46using Telerik.JustMock;47using Telerik.JustMock.Helpers;48{49    public static void Main()50    {51        var mock = Mock.Create<Expr>();52        Mock.Arrange(() => mock.Eval()).Returns(10);53        Console.WriteLine(mock.Eval());54    }55}56using System;57using Telerik.JustMock;58using Telerik.JustMock.Helpers;59{60    public static void Main()61    {62        var mock = Mock.Create<Expr>();63        Mock.Arrange(() => mock.Eval()).Returns(10);64        Console.WriteLine(mock.Eval());65    }66}

1using Telerik.JustMock;2using System;3using System.Collections.Generic;4using System.Linq;5using System.Text;6using System.Threading.Tasks;7using System.Diagnostics;8{9    {10        static void Main(string[] args)11        {12            var mock = Mock.Create<Expr>();13            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(1);14            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(2);15            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(3);16            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(4);17            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(5);18            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(6);19            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(7);20            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(8);21            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(9);22            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(10);23            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(11);24            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(12);25            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(13);26            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(14);27            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(15);28            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(16);29            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(17);30            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(18);31            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(19);32            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(20);33            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(21);34            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns(22);35            Mock.Arrange(() => mock.Eval(null)).IgnoreArguments().Returns

1using Telerik.JustMock;2using Telerik.JustMock.Helpers;3using System;4using System.Collections.Generic;5using System.Linq;6using System.Text;7using System.Threading.Tasks;8using System.Linq.Expressions;9{10    {11        public static Expression<Func<T, bool>> Is<T>(T value)12        {13            return x => x.Equals(value);14        }15    }16}

1using Telerik.JustMock;2using System;3using System.Linq.Expressions;4{5    {6        static void Main(string[] args)7        {8            var expr = Expr.New(() => new TestClass());9            Console.WriteLine(expr);10            Console.ReadLine();11        }12    }13    {14        public string TestMethod(string a)15        {16            return a;17        }18    }19}20using System;21using System.Linq.Expressions;22{23    {24        static void Main(string[] args)25        {26            Expression<Func<TestClass>> expr = () => new TestClass();27            Console.WriteLine(expr);28            Console.ReadLine();29        }30    }31    {32        public string TestMethod(string a)33        {34            return a;35        }36    }37}38Telerik.JustMock.Expr`1[Test.TestClass] New()

1using Telerik.JustMock;2using Telerik.JustMock.Helpers;3using System.Linq.Expressions;4using System;5{6    {7        public static Expression<Func<T, bool>> Is<T>(T value)8        {9            return Arg.Is<T>(value);10        }11    }12}13using Telerik.JustMock;14using Telerik.JustMock.Helpers;15using System.Linq.Expressions;16using System;17{18    {19        public static Expression<Func<T, bool>> Is<T>(T value)20        {21            return Arg.Is<T>(value);22        }23    }24}

1{2  public void TestMethod()3  {4    var mock = Mock.Create<Expr>();5    Mock.Arrange(() => mock.Eval(null)).Returns(1);6  }7}8{9  public void TestMethod()10  {11    var mock = Mock.Create<Expr>();12    Mock.Arrange(() => mock.Eval(null)).Returns(2);13  }14}15{16  public void TestMethod()17  {18    var mock = Mock.Create<Expr>();19    Mock.Arrange(() => mock.Eval(null)).Returns(3);20  }21}22{23  public void TestMethod()24  {25    var mock = Mock.Create<Expr>();26    Mock.Arrange(() => mock.Eval(null)).Returns(4);27  }28}29{30  public void TestMethod()31  {32    var mock = Mock.Create<Expr>();33    Mock.Arrange(() => mock.Eval(null)).Returns(5);34  }35}36{37  public void TestMethod()38  {39    var mock = Mock.Create<Expr>();40    Mock.Arrange(() => mock.Eval(null)).Returns(6);41  }42}43{44  public void TestMethod()45  {46    var mock = Mock.Create<Expr>();47    Mock.Arrange(() => mock.Eval(null)).Returns(7);48  }49}50{51  public void TestMethod()52  {53    var mock = Mock.Create<Expr>();54    Mock.Arrange(() => mock.Eval(null)).Returns(8);

1using System;2using Telerik.JustMock;3using Telerik.JustMock.Helpers;4{5    {6        private readonly IInterface _interface;7        public Expr(IInterface @interface)8        {9            _interface = @interface;10        }11        public void Method()12        {13            _interface.Method();14            Mock.Assert(() => _interface.Method(), Occurs.Once());15        }16    }17}18using System;19using Moq;20{21    {22        private readonly IInterface _interface;23        public Moq(IInterface @interface)24        {25            _interface = @interface;26        }27        public void Method()28        {29            _interface.Method();30            Mock.Get(_interface).Verify(x => x.Method(), Times.Once());31        }32    }33}34using System;35using NSubstitute;36{37    {38        private readonly IInterface _interface;39        public NSubstitute(IInterface @interface)40        {41            _interface = @interface;42        }43        public void Method()44        {45            _interface.Method();46            _interface.Received().Method();47        }48    }49}50using System;51using Telerik.JustMock;52{53    {54        private readonly IInterface _interface;55        public Telerik(IInterface @interface)56        {57            _interface = @interface;58        }59        public void Method()60        {61            _interface.Method();62            Mock.Assert(() => _interface.Method(), Occurs.Once());63        }64    }65}66using System;67using Telerik.JustMock;68{69    {