How to use FooService class of Telerik.JustMock.Tests package

...73		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]74		public void ShouldReturnServiceFromServiceProvider()75		{76			var provider = Mock.Create<IServiceProvider>();77			Mock.Arrange(() => provider.GetService(typeof(IFooService))).Returns(new FooService());78			Assert.True(provider.GetService(typeof(IFooService)) is FooService);79		}80		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]81		public void ShouldAssertDoInstead()82		{83			var foo = Mock.Create<IFoo>();84			bool called = false;85			Mock.Arrange(() => foo.Execute(Arg.IsAny<string>()))86								  .DoInstead(() => { called = true; })87								  .Returns((string s) => s);88			Assert.Equal(foo.Execute("ping"), "ping");89			Assert.True(called);90		}91		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]92		public void ShouldAssertDoInsteadForOneArgFromMethod()93		{94			int expected = 0;95			var foo = Mock.Create<IFoo>();96			Mock.Arrange(() => foo.Submit(Arg.IsAny<int>()))97				.DoInstead((int arg1) => { expected = arg1; });98			foo.Submit(10);99			Assert.Equal(10, expected);100		}101		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]102		public void ShouldAssertDoInsteadForTwoArgsFromMethod()103		{104			int expected = 0;105			var foo = Mock.Create<IFoo>();106			Mock.Arrange(() => foo.Submit(Arg.IsAny<int>(), Arg.IsAny<int>()))107				.DoInstead((int arg1, int arg2) => { expected = arg1 + arg2; });108			foo.Submit(10, 10);109			Assert.Equal(20, expected);110		}111		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]112		public void ShouldAssertDoInsteadForThreeArgsFromMethod()113		{114			int expected = 0;115			var foo = Mock.Create<IFoo>();116			Mock.Arrange(() => foo.Submit(Arg.IsAny<int>(), Arg.IsAny<int>(), Arg.IsAny<int>()))117				.DoInstead((int arg1, int arg2, int arg3) => { expected = arg1 + arg2 + arg3; });118			foo.Submit(10, 10, 10);119			Assert.Equal(30, expected);120		}121		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]122		public void ShouldAssertDoInsteadForFourArgsFromMethod()123		{124			int expected = 0;125			var foo = Mock.Create<IFoo>();126			Mock.Arrange(() => foo.Submit(Arg.IsAny<int>(), Arg.IsAny<int>(), Arg.IsAny<int>(), Arg.IsAny<int>()))127				.DoInstead((int arg1, int arg2, int arg3, int arg4) => { expected = arg1 + arg2 + arg3 + arg4; });128			foo.Submit(10, 10, 10, 10);129			Assert.Equal(40, expected);130		}131		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]132		public void ShouldAssertDoInsteadForOneArgFromFunc()133		{134			int expected = 0;135			var foo = Mock.Create<IFoo>();136			Mock.Arrange(() => foo.Echo(Arg.IsAny<int>()))137				.DoInstead((int arg1) => { expected = arg1; })138				.Returns(() => expected);139			Assert.Equal(foo.Echo(10), expected);140		}141		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]142		public void ShouldAssertDoInsteadForTwoArgsFromFunc()143		{144			int expected = 0;145			var foo = Mock.Create<IFoo>();146			Mock.Arrange(() => foo.Echo(Arg.IsAny<int>(), Arg.IsAny<int>()))147				.DoInstead((int arg1, int arg2) => { expected = arg1 + arg2; })148				.Returns(() => expected);149			Assert.Equal(foo.Echo(10), expected);150		}151		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]152		public void ShouldAssertDoInsteadForThreeArgsFromFunc()153		{154			int expected = 0;155			var foo = Mock.Create<IFoo>();156			Mock.Arrange(() => foo.Echo(Arg.IsAny<int>(), Arg.IsAny<int>(), Arg.IsAny<int>()))157				.DoInstead((int arg1, int arg2, int arg3) => { expected = arg1 + arg2 + arg3; })158				.Returns(() => expected);159			Assert.Equal(foo.Echo(10), expected);160		}161		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]162		public void ShouldAssertDoInsteadForFourArgsFromFunc()163		{164			int expected = 0;165			var foo = Mock.Create<IFoo>();166			Mock.Arrange(() => foo.Echo(Arg.IsAny<int>(), Arg.IsAny<int>(), Arg.IsAny<int>(), Arg.IsAny<int>()))167				.DoInstead((int arg1, int arg2, int arg3, int arg4) => { expected = arg1 + arg2 + arg3 + arg4; })168				.Returns(() => expected);169			Assert.Equal(foo.Echo(10), expected);170		}171		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]172		public void ShouldThrowIfArgumentsPassedForInterface()173		{174			Assert.Throws<Exception>(() => Mock.Create<IFoo>(25, true));175		}176		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]177		public void ShouldAssertCallOriginal()178		{179			var foo = Mock.Create<FooBase>();180			Mock.Arrange(() => foo.GetString("x")).CallOriginal();181			Mock.Arrange(() => foo.GetString("y")).Returns("z");182			Assert.Equal("x", foo.GetString("x"));183			Assert.Equal("z", foo.GetString("y"));184		}185		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]186		public void ShouldAssertGuidParam()187		{188			var foo = Mock.Create<IFoo>();189			Guid guid = Guid.NewGuid();190			bool called = false;191			Mock.Arrange(() => foo.Execute(guid)).DoInstead(() => called = true);192			foo.Execute(guid);193			Assert.True(called);194		}195		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]196		public void ShouldAssertCallOriginalForVoid()197		{198			var log = Mock.Create<Log>();199			Mock.Arrange(() => log.Info(Arg.IsAny<string>())).CallOriginal();200			Assert.Throws<Exception>(() => log.Info("test"));201		}202		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]203		public void ShouldPassArgumentToOriginal()204		{205			var log = Mock.Create<Log>();206			Mock.Arrange(() => log.Info("x")).CallOriginal();207			Assert.Equal(Assert.Throws<Exception>(() => log.Info("x")).Message, "x");208		}209		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]210		public void MockObjectShouldBeAssignableToMockedInterface()211		{212			var iFoo = Mock.Create<IFoo>();213			Assert.True(iFoo is IFoo);214		}215		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]216		public void ShouldAssertVoidCall()217		{218			var iFoo = Mock.Create<IFoo>();219			Mock.Arrange(() => iFoo.JustCall()).DoNothing();220			iFoo.JustCall();221		}222		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]223		public void ShouldAssertCallsThatAreMethodCalls()224		{225			const int arg = 2;226			var iBar = Mock.Create<IBar>();227			Mock.Arrange(() => iBar.Echo(Arg.IsAny<int>())).Returns(1);228			Assert.Equal(iBar.Echo(arg + 1), 1);229		}230		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]231		public void ShouldAssertGenericThrowsCall()232		{233			var iFoo = Mock.Create<IFoo>();234			Mock.Arrange(() => iFoo.Execute(Arg.IsAny<string>())).Throws<FormatException>();235			Assert.Throws<FormatException>(() => iFoo.Execute("crash"));236		}237		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]238		public void ShouldAssertThrowsHavingArguments()239		{240			var iFoo = Mock.Create<IFoo>();241			Mock.Arrange(() => iFoo.Execute(Arg.IsAny<string>())).Throws<CustomExepction>("test", true);242			Assert.Throws<CustomExepction>(() => iFoo.Execute("crash"));243		}244		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]245		public void ShouldAssertEqualityRefereces()246		{247			var iFoo1 = Mock.Create<IFoo>();248			var iFoo2 = Mock.Create<IFoo>();249			Assert.True(iFoo1.Equals(iFoo1));250			Assert.False(iFoo1.Equals(iFoo2));251		}252		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]253		public void TwoMockedObjectsShouldHavdDifferentHashCode()254		{255			var iFoo1 = Mock.Create<IFoo>();256			var iFoo2 = Mock.Create<IFoo>();257			Assert.NotEqual(iFoo1.GetHashCode(), iFoo2.GetHashCode());258		}259		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]260		public void ToStringShouldNotbeNullOrEmpty()261		{262			var foo = Mock.Create<IFoo>();263			Assert.False(String.IsNullOrEmpty(foo.ToString()));264		}265		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]266		public void ShouldMockClassWithNonDefaultConstructor()267		{268			var nonDefaultClass = Mock.Create<ClassWithNonDefaultConstructor>("ping", 1);269			Assert.NotNull(nonDefaultClass);270		}271		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]272		public void ShouldMockClassWithNonDefaultConstructorWithoutPassingAnything()273		{274			var nonDefaultClass = Mock.Create<ClassWithNonDefaultConstructor>();275			Assert.NotNull(nonDefaultClass);276		}277		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]278		public void ShouldMockClassWithNoDefaultConstructorWithNull()279		{280			var nonDefaultClass = Mock.Create<ClassWithNonDefaultConstructor>(null, 1);281			Assert.NotNull(nonDefaultClass);282		}283		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]284		public void ShoulsMockClassWithMultipleNonDefaultConstructor()285		{286			var nonDefaultClass = Mock.Create<ClassWithNonDefaultConstructor>(null, 1, true);287			Assert.NotNull(nonDefaultClass);288		}289		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]290		public void ShouldAssertGuidNonDefaultCtorWithDefaultIfNotSpecified()291		{292			var nonDefaultGuidClass = Mock.Create<ClassNonDefaultGuidConstructor>();293			Assert.Equal(nonDefaultGuidClass.guidValue, default(Guid));294		}295		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]296		public void ShouldAssertBaseCallWithGuid()297		{298			var foo = Mock.Create<FooBase>();299			Mock.Arrange(() => foo.GetGuid()).CallOriginal();300			Assert.Equal(foo.GetGuid(), default(Guid));301		}302		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]303		public void ShouldAssertImplementedInterface()304		{305			var implemented = Mock.Create<IFooImplemted>();306			Assert.NotNull(implemented);307		}308		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]309		public void ShouldAssertBaseForImplemetedInterface()310		{311			var implemented = Mock.Create<IFooImplemted>();312			Assert.True(implemented is IFoo);313		}314		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]315		public void SHouldAssertCallsFromBaseInImplemented()316		{317			var implemented = Mock.Create<IFooImplemted>();318			Mock.Arrange(() => implemented.Execute("hello")).Returns("world");319			Assert.Equal(implemented.Execute("hello"), "world");320		}321		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]322		public void ShouldMockObject_GetHashCodeMethod()323		{324			var foo = Mock.Create<FooBase>();325			Mock.Arrange(() => foo.GetHashCode()).Returns(1);326			Assert.Equal(1, foo.GetHashCode());327		}328		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]329		public void ShouldMockObject_ToStringMethod()330		{331			var foo = Mock.Create<FooBase>();332			Mock.Arrange(() => foo.ToString()).Returns("foo");333			Assert.Equal("foo", foo.ToString());334		}335		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]336		public void ShouldMockObject_EqualsMethod()337		{338			var foo = Mock.Create<FooBase>();339			Mock.Arrange(() => foo.Equals(Arg.IsAny<object>())).Returns(true);340			Assert.True(foo.Equals(new object()));341		}342		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]343		public void ShouldCallUnderlyingEquals()344		{345			var foo1 = Mock.Create<FooOverridesEquals>("foo");346			var foo2 = Mock.Create<FooOverridesEquals>("foo");347			Assert.True(foo1.Equals(foo2));348		}349		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]350		public void ShouldNotCallBaseByDefault()351		{352			var foo = Mock.Create<FooBase>();353			// this will not throw exception.354			foo.ThrowException();355		}356		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]357		public void ShouldTakeLatestSetup()358		{359			var foo = Mock.Create<IFoo>();360			Mock.Arrange(() => foo.Execute("ping")).Returns("pong");361			Mock.Arrange(() => foo.Execute(Arg.IsAny<string>())).Returns("pong");362			Assert.Equal(foo.Execute("nothing"), "pong");363		}364		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]365		public void ShouldOverrideBehaviorFromBaseClass()366		{367			var foo = Mock.Create<FooBase>();368			Mock.Arrange(() => foo.GetString("pong")).CallOriginal().InSequence();369			Mock.Arrange(() => foo.GetString(Arg.IsAny<string>())).Returns("ping").InSequence();370			Assert.Equal(foo.GetString("pong"), "pong");371			Assert.Equal(foo.GetString("it"), "ping");372		}373		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]374		public void ShouldAssertDateTimeAsRef()375		{376			var foo = Mock.Create<IFoo>();377			DateTime expected = new DateTime(2009, 11, 26);378			Mock.Arrange(() => foo.Execute(out expected)).DoNothing();379			DateTime acutal = DateTime.Now;380			foo.Execute(out acutal);381			Assert.Equal(expected, acutal);382		}383		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]384		public void ShouldAssertOutputParamPassedViaNested()385		{386			var nested = new Nested();387			nested.expected = 10;388			var foo = Mock.Create<IFoo>();389			Mock.Arrange(() => foo.Execute(out nested.expected));390			int actual = 0;391			foo.Execute(out actual);392			Assert.Equal(actual, 10);393		}394		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]395		public void ShouldNotInvokeOriginalCallWhenInitiatedFromCtor()396		{397			var foo = Mock.Create<FooAbstractCall>(false);398			Assert.NotNull(foo);399		}400		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]401		public void ShouldNotInvokeOriginalActionWhenInitiatedFromCtor()402		{403			var foo = Mock.Create<FooAbstractAction>();404			Assert.NotNull(foo);405		}406		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]407		public void ShouldNotInitalizeAsArgMatcherWhenProcessingMemberAccessArgument()408		{409			var foo = Mock.Create<IFoo>();410			Mock.Arrange(() => foo.Execute(false, BadGuid)).OccursOnce();411			foo.Execute(false, Guid.Empty);412			Mock.Assert(() => foo.Execute(Arg.IsAny<bool>(), Guid.Empty));413		}414		public static readonly Guid BadGuid = Guid.Empty;415		public abstract class FooAbstractCall416		{417			public FooAbstractCall(bool flag)418			{419				// invoke base will throw exception here.420				Initailize();421			}422			public abstract bool Initailize();423		}424		public abstract class FooAbstractAction425		{426			public FooAbstractAction()427			{428				// invoke base will throw exception here.429				Initailize();430			}431			public abstract void Initailize();432		}433#if !COREFX434		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]435		public void ShouldCreateMockClassWithInternalConstructor()436		{437			var foo = Mock.Create<FooWithInternalConstruct>();438			Assert.NotNull(foo);439		}440		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]441		public void ShouldAssertArrangeWithInternalConstructor()442		{443			var foo = Mock.Create<FooWithInternalConstruct>();444			bool called = false;445			Mock.Arrange(() => foo.Execute()).DoInstead(() => called = true);446			foo.Execute();447			Assert.True(called);448		}449#endif450		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]451		public void ShouldAssertGenericFuncCalls()452		{453			var genericClass = Mock.Create<FooGeneric<int>>();454			Mock.Arrange(() => genericClass.Get(1, 1)).Returns(10);455			Assert.Equal(genericClass.Get(1, 1), 10);456		}457		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]458		public void ShouldAssertGenericVoidCalls()459		{460			var genericClass = Mock.Create<FooGeneric<int>>();461			bool called = false;462			Mock.Arrange(() => genericClass.Execute(1)).DoInstead(() => called = true);463			genericClass.Execute(1);464			Assert.True(called);465		}466		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]467		public void ShouldAssertGenricMockWithNoGenericClass()468		{469			var genericClass = Mock.Create<FooGeneric>();470			Mock.Arrange(() => genericClass.Get<int, int>(1)).Returns(10);471			Assert.Equal(genericClass.Get<int, int>(1), 10);472		}473		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]474		public void ShouldAssertFuncWithOccurrence()475		{476			var foo = Mock.Create<IFoo>();477			Mock.Arrange(() => foo.Execute("x")).Returns("x");478			foo.Execute("x");479			Mock.Assert(() => foo.Execute("x"), Occurs.Exactly(1));480		}481		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]482		public void ShouldAssertOutputGenericArgument()483		{484			var fooGen = Mock.Create<FooGeneric>();485			int result = 0;486			fooGen.Execute<int, int>(out result);487			Assert.Equal(result, 0);488		}489		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]490		public void ShouldAssertArrangeForGenricOutArgument()491		{492			var fooGen = Mock.Create<FooGeneric>();493			int expected = 10;494			Mock.Arrange(() => fooGen.Execute<int, int>(out expected)).Returns(0);495			int actual = 0;496			fooGen.Execute<int, int>(out actual);497			Assert.Equal(expected, actual);498		}499		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]500		public void ShouldAssertParamArrayMatchArugments()501		{502			string expected = "bar";503			string argument = "foo";504			var target = Mock.Create<IParams>();505			Mock.Arrange(() => target.ExecuteParams(argument, "baz")).Returns(expected);506			string ret = target.ExecuteParams(argument, "baz");507			Assert.Equal(expected, ret);508		}509		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]510		public void ShouldDistinguiseMethodWithDifferentGenericArgument()511		{512			var foo = Mock.Create<FooGeneric>();513			Mock.Arrange(() => foo.Get<int>()).Returns(10);514			Mock.Arrange(() => foo.Get<string>()).Returns(12);515			Assert.Equal(foo.Get<string>(), 12);516			Assert.Equal(foo.Get<int>(), 10);517		}518		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]519		public void ShouldAssertParamArrayWithMatcherAndConcreteValue()520		{521			string expected = "bar";522			string argument = "foo";523			var target = Mock.Create<IParams>();524			Mock.Arrange(() => target.ExecuteByName(Arg.IsAny<int>(), argument)).Returns(expected);525			string ret = target.ExecuteByName(0, argument);526			Assert.Equal(expected, ret);527		}528		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]529		public void ShouldAssertCallWithMultipleMathers()530		{531			var foo = Mock.Create<IFoo>();532			Mock.Arrange(() => foo.Echo(Arg.Matches<int>(x => x == 10), Arg.Matches<int>(x => x == 10))).Returns(20);533			int ret = foo.Echo(10, 10);534			Assert.Equal(20, ret);535		}536		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]537		public void ShouldAssertArgumentMatherArgumentSetup()538		{539			var foo = Mock.Create<IFoo>();540			Mock.Arrange(() => foo.Echo(10, Arg.Matches<int>(x => x > 10 && x < 20), 21)).Returns(20);541			int ret = foo.Echo(10, 11, 21);542			Assert.Equal(20, ret);543		}544		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]545		public void ShouldAssertCallWithDefaultValues()546		{547			var foo = Mock.Create<IFoo>();548			Mock.Arrange(() => foo.Echo(0, 0)).Returns(2);549			int ret = foo.Echo(0, 0);550			Assert.Equal(2, ret);551		}552		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]553		public void ShouldCreateMockFromRealObject()554		{555			var realItem = Mock.Create(() => new RealItem());556			Assert.NotNull(realItem);557		}558		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]559		public void ShouldCreateMockFromRealObjectForNonDefaultConstructor()560		{561			var realItem = Mock.Create(() => new RealItem(10));562			Assert.NotNull(realItem);563		}564		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]565		public void ShouldCreateMockFromRealObjectThatHasOnlyNonDefaultCtor()566		{567			var realItem = Mock.Create(() => new RealItem2(10, string.Empty));568			Assert.NotNull(realItem);569		}570		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]571		public void ShouldCreateMockFromRealCtorWithParams()572		{573			// the following line should not throw any argument exception.574			var realItem = Mock.Create(() => new RealItem("hello", 10, 20),575				Behavior.CallOriginal);576			Assert.Equal("hello", realItem.Text);577			Assert.Equal(2, realItem.Args.Length);578		}579		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]580		public void ShouldAssertMixins()581		{582			var realItem = Mock.Create<RealItem>(x =>583			{584				x.Implements<IDisposable>();585				x.CallConstructor(() => new RealItem(0));586			});587			var iDispose = realItem as IDisposable;588			iDispose.Dispose();589		}590		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]591		public void ShouldAssertMixinsWithClosure()592		{593			int a = 5;594			var realItem = Mock.Create<RealItem>(x =>595			{596				x.Implements<IDisposable>();597				x.CallConstructor(() => new RealItem(a));598			});599			var iDispose = realItem as IDisposable;600			iDispose.Dispose();601		}602		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]603		public void ShouldImplementDependentInterfacesWhenTopIsSpecified()604		{605			var realItem = Mock.Create<RealItem>(x =>606			{607				x.Implements<IFooImplemted>();608				x.CallConstructor(() => new RealItem(0));609			});610			Assert.NotNull(realItem as IFoo);611		}612		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]613		public void ShouldCloneWhenItemImplementsICloneableAndOneOtherInterface()614		{615			var myMock = Mock.Create<IDisposable>(x => x.Implements<ICloneable>());616			var myMockAsClonable = myMock as ICloneable;617			bool isCloned = false;618			Mock.Arrange(() => myMockAsClonable.Clone()).DoInstead(() => isCloned = true);619			myMockAsClonable.Clone();620			Assert.True(isCloned);621		}622		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]623		public void ShouldCallOriginalMethodForCallsOriginal()624		{625			var foo = Mock.Create<FooBase>(Behavior.CallOriginal);626			//// should call the original.627			Assert.Throws<InvalidOperationException>(() => foo.ThrowException());628		}629		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]630		public void ShouldNotCallOriginalMethodIfThereisASetupForCallsOriginal()631		{632			var foo = Mock.Create<FooBase>(Behavior.CallOriginal);633			Guid expected = Guid.NewGuid();634			Mock.Arrange(() => foo.GetGuid()).Returns(expected);635			Assert.Equal(expected, foo.GetGuid());636		}637		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]638		public void ShouldCallOriginalIfThereIsNoSetupForSimilarTypeForCallsOiginal()639		{640			var foo = Mock.Create<FooBase>(Behavior.CallOriginal);641			Mock.Arrange(() => foo.Echo(1)).Returns(2);642			Assert.Equal(2, foo.Echo(1));643			Assert.Equal(2, foo.Echo(2));644		}645		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]646		public void ShouldBeAbleToIgnoreArgumentsIfSpecified()647		{648			var foo = Mock.Create<IFoo>();649			Mock.Arrange(() => foo.Echo(10, 9)).IgnoreArguments().Returns(11);650			Assert.Equal(11, foo.Echo(1, 1));651		}652		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]653		public void ShouldInterceptVirtualsFromBaseClass()654		{655			var foo = Mock.Create<FooChild>();656			Mock.Arrange(() => foo.ThrowException()).Throws<ArgumentException>();657			Assert.Throws<ArgumentException>(() => foo.ThrowException());658		}659		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]660		public void ShouldAssertSetupWithArgAnyMatcherForArray()661		{662			var foo = Mock.Create<IFoo>();663			Mock.Arrange(() => foo.Submit(Arg.IsAny<byte[]>())).MustBeCalled();664			foo.Submit(new byte[10]);665			Mock.Assert(foo);666		}667		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]668		public void ShouldAssertDictionaryArgumentForIsAny()669		{670			var param = Mock.Create<IParams>();671			Mock.Arrange(() =>672				param.ExecuteArrayWithString(Arg.AnyString, Arg.IsAny<Dictionary<string, object>>()))673				.MustBeCalled();674			param.ExecuteArrayWithString("xxx", new Dictionary<string, object>());675			Mock.Assert(param);676		}677		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]678		public void ShouldAssertSetupWithCallHavingParamsAndPassedWithMatcher()679		{680			var foo = Mock.Create<IFoo>();681			Mock.Arrange(() => foo.FindOne(Arg.IsAny<ICriteria>())).Returns(true);682			var criteria = Mock.Create<ICriteria>();683			Assert.True(foo.FindOne(criteria));684		}685		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]686		public void ShouldThrowNotImplementedExceptionForBaseInovocationOnAbstract()687		{688			var node = Mock.Create<ExpressionNode>(Behavior.CallOriginal);689			Assert.Throws<NotImplementedException>(() => { var expected = node.NodeType; });690		}691		[TestMethod, TestCategory("Lite"), TestCategory("Behavior"), TestCategory("CallOriginal")]692		public void CallOriginalClause_AbstractMethod_ThrowsNotImplemented()693		{694			var mock = Mock.Create<IFoo>();695			Mock.Arrange(() => mock.JustCall()).CallOriginal();696			Assert.Throws<NotImplementedException>(() => mock.JustCall());697		}698		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]699		public void ShouldSetupMockWithParamsWhenNoParamIsPassed()700		{701			var fooParam = Mock.Create<FooParam>();702			var expected = "hello";703			Mock.Arrange(() => fooParam.FormatWith(expected)).Returns(expected);704			Assert.Equal(expected, fooParam.FormatWith(expected));705		}706		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]707		public void ShouldBeAbleToPassSingleArgIsAnyForParamsTypeArgument()708		{709			var fooParam = Mock.Create<FooParam>();710			Mock.Arrange(() => fooParam.GetDevicesInLocations(0, false, Arg.IsAny<MesssageBox>())).Returns(10);711			int result = fooParam.GetDevicesInLocations(0, false, new MesssageBox());712			Assert.Equal(10, result);713		}714		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]715		public void ShouldBeAbleToPassMultipleArgIsAnyForParamsTypeArgument()716		{717			var fooParam = Mock.Create<FooParam>();718			Mock.Arrange(() => fooParam719				.GetDevicesInLocations(0, false, Arg.IsAny<MesssageBox>(), Arg.IsAny<MesssageBox>()))720				.Returns(10);721			var box = new MesssageBox();722			int result = fooParam.GetDevicesInLocations(0, false, box, box);723			Assert.Equal(10, result);724		}725		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]726		public void ShouldCreateMockFromInterfaceWithSimilarGenericOverloads()727		{728			var session = Mock.Create<ISession>();729			Assert.NotNull(session);730		}731		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]732		public void ShouldDisposeArrangementEffects()733		{734			var mock = Mock.Create<IBar>();735			using (Mock.Arrange(() => mock.Value).Returns(123))736			{737				Assert.Equal(123, mock.Value);738			}739			Assert.Equal(0, mock.Value);740		}741		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]742		public void ShouldDisposeArrangementExpectations()743		{744			var mock = Mock.Create<IBar>();745			using (Mock.Arrange(() => mock.Value).MustBeCalled())746			{747				Assert.Throws<AssertionException>(() => Mock.Assert(mock));748			}749			Mock.Assert(mock);750		}751		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]752		public void ShouldAssertExpectedWithDynamicQuery()753		{754			var bookRepo = Mock.Create<IBookRepository>();755			var expected = new Book();756			Mock.Arrange(() => bookRepo.GetWhere(book => book.Id > 1))757					.Returns(expected)758					.MustBeCalled();759			var actual = bookRepo.GetWhere(book => book.Id > 1);760			Assert.Equal(expected, actual);761			Mock.Assert(bookRepo);762		}763		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]764		public void ShouldAssertMockExpressionDeleteArgumentForCompoundQuery()765		{766			var bookRepo = Mock.Create<IBookRepository>();767			var expected = new Book();768			string expectedTitle = "Telerik";769			Mock.Arrange(() => bookRepo.GetWhere(book => book.Id > 1 && book.Title == expectedTitle))770					.Returns(expected)771					.MustBeCalled();772			var actual = bookRepo.GetWhere(book => book.Id > 1 && book.Title == expectedTitle);773			Assert.Equal(expected, actual);774			Mock.Assert(bookRepo);775		}776		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]777		public void ShouldAssertMockForDynamicQueryWhenComparedUsingAVariable()778		{779			var repository = Mock.Create<IBookRepository>();780			var expected = new Book { Title = "Adventures" };781			var service = new BookService(repository);782			Mock.Arrange(() => repository.GetWhere(book => book.Id == 1))783				.Returns(expected)784				.MustBeCalled();785			var actual = service.GetSingleBook(1);786			Assert.Equal(actual.Title, expected.Title);787		}788		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]789		public void ShouldAssertWithIntValueUsedForLongValuedArgument()790		{791			int number = 5;792			int expectedResult = 42;793			var myClass = Mock.Create<ClassWithLongMethod>();794			Mock.Arrange(() => myClass.AddOne(number)).Returns(expectedResult);795			// Act796			var result = myClass.AddOne(number);797			// Assert798			Assert.Equal(expectedResult, result);799		}800		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]801		public void ShouldAutoArrangePropertySetInConstructor()802		{803			var expected = "name";804			var item = Mock.Create<Item>(() => new Item(expected));805			Assert.Equal(expected, item.Name);806		}807		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]808		public void ShouldTakeOutValueFromDoInteadWhenDefinedWithCustomDelegate()809		{810			int outArg = 1;811			var mock = Mock.Create<DoInsteadWithCustomDelegate>();812			Mock.Arrange(() => mock.Do(0, ref outArg)).DoInstead(new RefAction<int, int>((int i, ref int arg2) => { arg2 = 2; }));813			mock.Do(0, ref outArg);814			Assert.Equal(2, outArg);815		}816		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]817		public void ShouldCheckMethodOverloadsWhenResolvingInterfaceInheritance()818		{819			var project = Mock.Create<IProject>();820			Assert.NotNull(project);821		}822		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]823		public void PropertySetShouldThrowExceptionWhenNameHasSet_Literal()824		{825			var b_object = Mock.Create<B>();826			Mock.ArrangeSet<B>(() => b_object.b_string_set_get = string.Empty).DoNothing().MustBeCalled();827			b_object.b_string_set_get = string.Empty;828			Mock.Assert(b_object);829		}830		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]831		public void ShouldNotAffectAssertionForInvalidAsserts()832		{833			var foo = Mock.Create<IFoo>();834			Guid goodGuid = Guid.NewGuid();835			Guid badGuid = Guid.NewGuid();836			Mock.Arrange(() => foo.CallMeOnce(true, goodGuid)).OccursOnce();837			foo.CallMeOnce(true, goodGuid);838			Mock.Assert(() => foo.CallMeOnce(true, badGuid), Occurs.Never());839			Mock.Assert(() => foo.CallMeOnce(true, Guid.Empty), Occurs.Never());840			Mock.Assert(() => foo.CallMeOnce(true, goodGuid), Occurs.Once());841			Mock.Assert(() => foo.CallMeOnce(false, badGuid), Args.Ignore(), Occurs.Once());842			Mock.Assert(() => foo.CallMeOnce(Arg.AnyBool, badGuid), Occurs.Never());843			Mock.Assert(() => foo.CallMeOnce(Arg.IsAny<bool>(), badGuid), Occurs.Never());844		}845		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]846		public void ShouldEqualityCheckForMockFromAnInterfaceThatHasEquals()847		{848			IRule mockRule1 = Mock.Create<IRule>();849			List<IRule> ruleList = new List<IRule>();850			Assert.False(ruleList.Contains(mockRule1));851			ruleList.Add(mockRule1);852			Assert.True(ruleList.Contains(mockRule1));853		}854		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]855		public void ShouldAssertMethodWithKeyValuePairTypeArgument()856		{857			var presenter = Mock.Create<InteractiveKioskPresenter>(Behavior.CallOriginal);858			var key = Mock.Create<IKioskPart>();859			var val = Mock.Create<IKioskWellInfo>();860			presenter.ShowControl(new KeyValuePair<IKioskPart, IKioskWellInfo>(key, val));861		}862		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]863		public void ShouldAssertMethodWithStructTypeArgument()864		{865			var presenter = Mock.Create<InteractiveKioskPresenter>(Behavior.CallOriginal);866			Size size = new Size();867			presenter.DrawRect(size);868		}869		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]870		public void ShouldParsePrimitiveParamsArrayCorrectly()871		{872			var foo = Mock.Create<IFoo>();873			Mock.Arrange(() => foo.SubmitWithParams(Arg.AnyInt)).MustBeCalled();874			foo.SubmitWithParams(10);875			Mock.Assert(foo);876		}877		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]878		public void ShouldAssertCorrectMethodWhenDifferentArgumentsPassedForParamSetup()879		{880			var foo = Mock.Create<IFoo>();881			Mock.Arrange(() => foo.SubmitWithParams(10)).OccursOnce();882			foo.SubmitWithParams(10);883			foo.SubmitWithParams(10, 11);884			Mock.Assert(foo);885		}886		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]887		public void ShouldAssertOccursForIndexedPropertyWithDifferentArguments()888		{889			var foo = Mock.Create<Foo>();890			string expected = "string";891			Mock.Arrange(() => foo.Baz["Test"]).Returns(expected);892			Mock.Arrange(() => foo.Baz["TestName"]).Returns(expected);893			Assert.Equal(expected, foo.Baz["Test"]);894			Assert.Equal(expected, foo.Baz["TestName"]);895			Mock.Assert(() => foo.Baz["Test"], Occurs.Once());896			Mock.Assert(() => foo.Baz["TestName"], Occurs.Once());897		}898		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]899		public void ShouldNotSkipBaseInterfaceWhenSomeMembersAreSame()900		{901			var loanString = Mock.Create<ILoanStringField>();902			Assert.NotNull(loanString);903		}904		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]905		public void ShouldAssertParamsArrayAsArrayBasedOnArgument()906		{907			string value1 = "Hello";908			string value2 = "World";909			var session = Mock.Create<IMockable>();910			Mock.Arrange(() => session.Get<string>(Arg.Matches<string[]>(v => v.Contains("Lol") &&911													 v.Contains("cakes"))))912				.Returns(new[]913				 {914					 value1,915					 value2,916				 });917			var testValues = new[]{918						 "Lol",919						 "cakes"920					 };921			var result = session.Get<string>(testValues);922			Assert.Equal(value1, result[0]);923			Assert.Equal(value2, result[1]);924		}925		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]926		public void ShouldNotInitRescursiveMockingWithProfilerForProperyThatReturnsMock()927		{928			WorkerHelper helper = new WorkerHelper();929			helper.Arrange();930			helper.Worker.Echo("hello");931		}932		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]933		public void ShouldAssertMockWithEnumArgumentWithUnderlyingTypeOtherThanInt()934		{935			var subdivisionTypeCode = SubdivisionTypeCode.City;936			var subdivisionTypeRepository = Mock.Create<ISubdivisionTypeRepository>();937			Mock.Arrange(() => subdivisionTypeRepository.Get(subdivisionTypeCode)).Returns((SubdivisionTypeCode subDivision) =>938			{939				return subDivision.ToString();940			});941			var result = subdivisionTypeRepository.Get(subdivisionTypeCode);942			Assert.Equal(result, subdivisionTypeCode.ToString());943			Mock.AssertAll(subdivisionTypeRepository);944		}945		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]946		public void ShouldAssertMockWithNullableValueTypeArg()947		{948			FooNullable foo = Mock.Create<FooNullable>();949			var now = DateTime.Now;950			Mock.Arrange(() => foo.ValideDate(now)).MustBeCalled();951			foo.ValideDate(now);952			Mock.Assert(foo);953		}954		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]955		public void ShouldAssertMockWithNullForNullableValueTypeArg()956		{957			FooNullable foo = Mock.Create<FooNullable>();958			Mock.Arrange(() => foo.ValideDate(null)).MustBeCalled();959			foo.ValideDate(null);960			Mock.Assert(foo);961		}962		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]963		public void ShouldAssertCallOriginalForAbstractClass()964		{965			Assert.NotNull(Mock.Create<TestTreeItem>(Behavior.CallOriginal));966		}967		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]968		public void ShouldCallBaseWhenCallOriginalSpecifiedForMock()969		{970			var item = Mock.Create<TestTreeItem>(Behavior.CallOriginal);971			var result = ((IComparable)item).CompareTo(10);972			Assert.Equal(1, result);973		}974		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]975		public void ShouldArrangeBothInterfaceMethodAndImplementation()976		{977			var mock = Mock.Create<FrameworkElement>() as ISupportInitialize;978			bool implCalled = false;979			Mock.Arrange(() => mock.Initialize()).DoInstead(() => implCalled = true).MustBeCalled();980			mock.Initialize();981			Assert.True(implCalled);982			Mock.Assert(() => mock.Initialize());983		}984		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]985		public void ShouldArrangeBothBaseAndOverriddenMethod()986		{987			var mock = Mock.Create<Control>() as FrameworkElement;988			bool implCalled = false;989			Mock.Arrange(() => mock.Initialize()).DoInstead(() => implCalled = true);990			mock.Initialize();991			Assert.True(implCalled);992			Mock.Assert(() => mock.Initialize());993			Mock.Assert(() => ((ISupportInitialize)mock).Initialize());994		}995		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]996		public void ShouldArrangeBaseMethodInManyImplementations()997		{998			var fe = Mock.Create<FrameworkElement>();999			var control = Mock.Create<Control>();1000			int calls = 0;1001			Mock.Arrange(() => (null as ISupportInitialize).Initialize()).DoInstead(() => calls++);1002			fe.Initialize();1003			Assert.Equal(1, calls);1004			control.Initialize();1005			Assert.Equal(2, calls);1006		}1007		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1008		public void ShouldAssertMethodAtAllHierarchyLevels()1009		{1010			var control = Mock.Create<Control>();1011			control.Initialize();1012			Mock.Assert(() => control.Initialize(), Occurs.Once());1013			Mock.Assert(() => (control as FrameworkElement).Initialize(), Occurs.Once());1014			Mock.Assert(() => (control as ISupportInitialize).Initialize(), Occurs.Once());1015		}1016		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1017		public void ShouldArrangeBaseMethodInManyImplementationsForProperty()1018		{1019			var fe = Mock.Create<FrameworkElement>();1020			var control = Mock.Create<Control>();1021			int calls = 0;1022			Mock.Arrange(() => (null as ISupportInitialize).Property).DoInstead(() => calls++);1023			var property = fe.Property;1024			Assert.Equal(1, calls);1025			property = control.Property;1026			Assert.Equal(2, calls);1027		}1028		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1029		public void ShouldAssertMethodAtAllHierarchyLevelsForProperty()1030		{1031			var control = Mock.Create<Control>();1032			var property = control.Property;1033			Mock.Assert(() => control.Property, Occurs.Once());1034			Mock.Assert(() => (control as FrameworkElement).Property, Occurs.Once());1035			Mock.Assert(() => (control as ISupportInitialize).Property, Occurs.Once());1036		}1037		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1038		public void ShouldArrangeInheritableMemberOfExplicitlySpecifiedType()1039		{1040			var ident = Mock.Create<IIdentifiable>();1041			Mock.Arrange<IIdentifiable, int>(new Func<int>(() => ident.Id)).Returns(15);1042			Assert.Equal(15, ident.Id);1043		}1044#if !SILVERLIGHT1045		[TestMethod, TestCategory("Elevated"), TestCategory("Lite"), TestCategory("Mock")]1046		public void ShouldNotCreateProxyIfNotNecessary()1047		{1048			var mock = Mock.Create<Poco>();1049			Mock.Arrange(() => mock.Data).Returns(10);1050			Assert.Equal(10, mock.Data);1051			if (Mock.IsProfilerEnabled)1052				Assert.Same(typeof(Poco), mock.GetType());1053		}1054#elif !LITE_EDITION1055		[TestMethod, TestCategory("Elevated"), TestCategory("Mock")]1056		public void ShouldNotCreateProxyIfNotNecessary()1057		{1058			var mock = Mock.Create<Poco>(Constructor.Mocked);1059			Mock.Arrange(() => mock.Data).Returns(10);1060			Assert.Equal(10, mock.Data);1061			Assert.Same(typeof(Poco), mock.GetType());1062		}1063#endif1064#if LITE_EDITION && !COREFX1065		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1066		public void MockInternalMembersWithoutExplicitlyGivenVisibilitySentinel()1067		{1068			Assert.Throws<MockException>(() => Mock.Create<InvisibleInternal>());1069		}1070#endif1071		public class Poco // should be inheritable but shouldn't be abstract1072		{1073			public virtual int Data { get { return 0; } }1074		}1075		public interface IIdentifiable1076		{1077			int Id { get; }1078		}1079		public interface ISupportInitialize1080		{1081			void Initialize();1082			string Property { get; }1083		}1084		public abstract class FrameworkElement : ISupportInitialize1085		{1086			public abstract void Initialize();1087			public abstract string Property { get; set; }1088		}1089		public abstract class Control : FrameworkElement1090		{1091			public override void Initialize()1092			{1093				throw new NotImplementedException();1094			}1095			public override string Property1096			{1097				get1098				{1099					throw new NotImplementedException();1100				}1101				set1102				{1103					throw new NotImplementedException();1104				}1105			}1106		}1107		public abstract class TestTreeItem : IComparable1108		{1109			int IComparable.CompareTo(object obj)1110			{1111				return 1;1112			}1113		}1114		public class FooNullable1115		{1116			public virtual void ValideDate(DateTime? date)1117			{1118			}1119		}1120		public enum SubdivisionTypeCode : byte1121		{1122			None = 255,1123			State = 0,1124			County = 1,1125			City = 2,1126		}1127		public interface ISubdivisionTypeRepository1128		{1129			string Get(SubdivisionTypeCode subdivisionTypeCode);1130		}1131		public class WorkerHelper1132		{1133			public IWorker TheWorker { get; private set; }1134			public WorkerHelper()1135			{1136				this.TheWorker = Mock.Create<IWorker>(Behavior.Strict);1137			}1138			public IWorker Worker1139			{1140				get1141				{1142					return this.TheWorker;1143				}1144			}1145			public void Arrange()1146			{1147				Mock.Arrange(() => this.TheWorker.Echo(Arg.AnyString)).DoNothing();1148			}1149		}1150		public interface IWorker1151		{1152			void Echo(string value);1153		}1154		public interface IMockable1155		{1156			T[] Get<T>(params string[] values);1157		}1158		public interface ILoanStringField : ILoanField1159		{1160			string Value { get; set; }1161		}1162		public interface ILoanField1163		{1164			void ClearValue();1165			object Value { get; set; }1166		}1167		public interface IKioskPart1168		{1169		}1170		public interface IKioskWellInfo1171		{1172		}1173		public class InteractiveKioskPresenter1174		{1175			public virtual void ShowControl(KeyValuePair<IKioskPart, IKioskWellInfo> kPart)1176			{1177			}1178			public virtual void DrawRect(Size size)1179			{1180			}1181		}1182		public struct Size1183		{1184		}1185		public interface IRule1186		{1187			bool Equals(object obj);1188		}1189		public class B1190		{1191			public string b_string = null;1192			public virtual string b_string_set_get { get { return b_string; } set { b_string = value; } }1193		}1194		public interface IProject : IProjectItemContainer1195		{1196			IEnumerable<IProjectItem> Items { get; }1197			void AddChild();1198		}1199		public interface IProjectItem : IProjectItemContainer1200		{1201		}1202		public interface IProjectItemContainer : IDocumentItemContainer<IProjectItem>1203		{1204			bool CanAddChild { get; }1205		}1206		public interface IDocumentItemContainer : IDocumentItem1207		{1208			IEnumerable<IDocumentItem> Children { get; }1209		}1210		public interface IDocumentItemContainer<T> : IDocumentItemContainer1211		where T : IDocumentItem1212		{1213			IEnumerable<T> Children { get; }1214			void AddChild(T child);1215			void RemoveChild(T child);1216		}1217		public interface IDocumentItem1218		{1219		}1220		public delegate void RefAction<T1, T2>(T1 arg1, ref T2 arg2);1221		public class DoInsteadWithCustomDelegate1222		{1223			public virtual void Do(int k, ref int j)1224			{1225			}1226		}1227		public class ClassWithLongMethod1228		{1229			public virtual long AddOne(long number)1230			{1231				return number + 1;1232			}1233		}1234		public class BookService1235		{1236			private IBookRepository repository;1237			public BookService(IBookRepository repository)1238			{1239				this.repository = repository;1240			}1241			public Book GetSingleBook(int id)1242			{1243				return repository.GetWhere(book => book.Id == id);1244			}1245		}1246		public interface IBookRepository1247		{1248			Book GetWhere(Expression<Func<Book, bool>> expression);1249		}1250		public class Book1251		{1252			public int Id { get; private set; }1253			public string Title { get; set; }1254		}1255		#region Syntax Integrity1256		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1257		public void ShouldBeAbleToInvokeMustBeCalledWithIgnoreArguments()1258		{1259			var foo = Mock.Create<Foo>();1260			Mock.Arrange(() => foo.Execute(0)).IgnoreArguments().MustBeCalled();1261			foo.Execute(10);1262			Mock.Assert(foo);1263		}1264		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1265		public void ShouldBeAbleToUseMuseBeCalledAfterIgnoreFoFunc()1266		{1267			var foo = Mock.Create<Foo>();1268			Mock.Arrange(() => foo.Echo(0)).IgnoreArguments().MustBeCalled();1269			foo.Echo(10);1270			Mock.Assert(foo);1271		}1272		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1273		public void ShouldBeAbleToDoDoNothingForNonVoidCalls()1274		{1275			var foo = Mock.Create<Foo>();1276			Mock.Arrange(() => foo.Echo(Arg.AnyInt)).DoNothing();1277			foo.Echo(10);1278		}1279		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1280		public void ShouldBeAbleToSpecifyOccursAfterReturns()1281		{1282			var foo = Mock.Create<Foo>();1283			Mock.Arrange(() => foo.Echo(Arg.AnyInt))1284				.Returns(10)1285				.Occurs(1);1286			foo.Echo(10);1287			Mock.Assert(foo);1288		}1289		internal abstract class FooAbstract1290		{1291			protected internal abstract bool TryCreateToken(string literal);1292		}1293		internal abstract class FooAbstract2 : FooAbstract1294		{1295		}1296		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1297		public void ShouldAsssertMockHavingInternalAbstractBaseMethod()1298		{1299			var foo = Mock.Create<FooAbstract2>();1300			foo.TryCreateToken(string.Empty);1301		}1302		#endregion1303		public interface ISession1304		{1305			ICriteria CreateCriteria<T>() where T : class;1306			ICriteria CreateCriteria(string entityName);1307			ICriteria CreateCriteria<T>(string alias) where T : class;1308			ICriteria CreateCriteria(System.Type persistentClass);1309			ICriteria CreateCriteria(string entityName, string alias);1310			ICriteria CreateCriteria(System.Type persistentClass, string alias);1311		}1312		[TestMethod, TestCategory("Lite"), TestCategory("Mock")]1313		public void ShouldNotTryToWeaveMethodInSilverlightRuntime()1314		{1315			var foo = Mock.Create<FooSilver>();1316			Assert.NotNull(foo);1317		}1318		public interface ICloneable1319		{1320			object Clone();1321		}1322		public abstract class FooSilver1323		{1324			public void Do()1325			{1326			}1327		}1328#if LITE_EDITION1329		[TestMethod]1330		public void ShouldThrowMockExceptionWhenTryingToMockFinalMethod()1331		{1332			var mock = Mock.Create<Bar>();1333			Assert.Throws<MockException>(() => Mock.Arrange(() => mock.Submit()).DoNothing());1334		}1335		public class Bar1336		{1337			public void Submit()1338			{1339			}1340		}1341#endif1342		#region Test Insfrastructure1343		public class Foo1344		{1345			public virtual void Execute(int arg1)1346			{1347			}1348			public virtual int Echo(int arg1)1349			{1350				return arg1;1351			}1352			public virtual Baz Baz { get; set; }1353		}1354		public class Baz1355		{1356			public virtual string this[string key]1357			{1358				get1359				{1360					return null;1361				}1362			}1363		}1364		public class FooParam1365		{1366			public virtual int GetDevicesInLocations(int arg1, bool bExclude, params MesssageBox[] box)1367			{1368				return default(int);1369			}1370			public virtual string FormatWith(string format, params object[] args)1371			{1372				return string.Empty;1373			}1374		}1375		public class MesssageBox1376		{1377		}1378		public enum ExpressionNodeType1379		{1380			Constant,1381			Binary1382		}1383		public abstract class ExpressionNode1384		{1385			public abstract ExpressionNodeType NodeType { get; }1386		}1387		public class RealItem1388		{1389			public RealItem()1390			{1391			}1392			public RealItem(int num)1393			{1394			}1395			public RealItem(string text, params int[] args)1396			{1397				if (args.Length == 0 || string.IsNullOrEmpty(text))1398				{1399					throw new ArgumentException();1400				}1401				this.text = text;1402				this.args = args;1403			}1404			public string Text1405			{1406				get1407				{1408					return text;1409				}1410			}1411			public int[] Args1412			{1413				get1414				{1415					return args;1416				}1417			}1418			public string text;1419			private int[] args;1420		}1421		public class RealItem21422		{1423			public RealItem2(int num, string str)1424			{1425			}1426		}1427		public class Item1428		{1429			public virtual string Name { get; set; }1430			public Item(string name)1431			{1432				Name = name;1433			}1434		}1435		public class FooGeneric<T>1436		{1437			public virtual T Get<T1, T2>(T1 p1, T2 p2)1438			{1439				return default(T);1440			}1441			public virtual void Execute<T1>(T1 arg)1442			{1443				throw new Exception();1444			}1445		}1446		public class FooGeneric1447		{1448			public virtual TRet Get<T, TRet>(T arg1)1449			{1450				return default(TRet);1451			}1452			public virtual TRet Execute<T1, TRet>(out T1 arg1)1453			{1454				arg1 = default(T1);1455				object[] args = new object[1];1456				args[0] = arg1;1457				return default(TRet);1458			}1459			public virtual int Get<T1>()1460			{1461				throw new NotImplementedException();1462			}1463		}1464		public class FooWithInternalConstruct1465		{1466			internal FooWithInternalConstruct()1467			{1468			}1469			public virtual void Execute()1470			{1471				throw new ArgumentException();1472			}1473		}1474		public class Nested1475		{1476			public int expected;1477			public int expeted1;1478		}1479		class FooService : IFooService { }1480		interface IFooService { }1481		public interface ICriteria1482		{1483		}1484		public interface IFoo1485		{1486			string Execute(string arg);1487			void JustCall();1488			void Execute(Guid guid);1489			void Execute(bool flag, Guid guid);1490			void Execute(out int expected);1491			void Execute(out DateTime date);1492			IFoo GetFoo();1493			int Echo(int arg1);1494			int Echo(int arg1, int arg2);...

1using Telerik.JustMock.Tests;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 mock = Mock.Create<FooService>();12            Mock.Arrange(() => mock.GetFoo()).Returns("Foo");13            Console.WriteLine(mock.GetFoo());14            Console.ReadLine();15        }16    }17}18using Telerik.JustMock.Tests;19using System;20using System.Collections.Generic;21using System.Linq;22using System.Text;23using System.Threading.Tasks;24{25    {26        static void Main(string[] args)27        {28            var mock = Mock.Create<FooService>();29            Mock.Arrange(() => mock.GetFoo()).Returns("Foo");30            Console.WriteLine(mock.GetFoo());31            Console.ReadLine();32        }33    }34}

1using Telerik.JustMock.Tests;2{3    {4        public int GetFoo()5        {6            return 1;7        }8    }9}10using Telerik.JustMock.Tests;11{12    {13        public int GetFoo()14        {15            return 1;16        }17    }18}19using Telerik.JustMock.Tests;20{21    {22        public int GetFoo()23        {24            return 1;25        }26    }27}28using Telerik.JustMock.Tests;29{30    {31        public int GetFoo()32        {33            return 1;34        }35    }36}37using Telerik.JustMock.Tests;38{39    {40        public int GetFoo()41        {42            return 1;43        }44    }45}46using Telerik.JustMock.Tests;47{48    {49        public int GetFoo()50        {51            return 1;52        }53    }54}55using Telerik.JustMock.Tests;56{57    {58        public int GetFoo()59        {60            return 1;61        }62    }63}64using Telerik.JustMock.Tests;65{66    {67        public int GetFoo()68        {69            return 1;70        }71    }72}

1using Telerik.JustMock.Tests;2{3    {4        public virtual int GetFoo()5        {6            return 1;7        }8    }9}10using Telerik.JustMock.Tests;11{12    {13        public virtual int GetFoo()14        {15            return 1;16        }17    }18}19using Telerik.JustMock.Tests;20{21    {22        public virtual int GetFoo()23        {24            return 1;25        }26    }27}28using Telerik.JustMock.Tests;29{30    {31        public virtual int GetFoo()32        {33            return 1;34        }35    }36}37using Telerik.JustMock.Tests;38{39    {40        public virtual int GetFoo()41        {42            return 1;43        }44    }45}46using Telerik.JustMock.Tests;47{48    {49        public virtual int GetFoo()50        {51            return 1;52        }53    }54}55using Telerik.JustMock.Tests;56{57    {58        public virtual int GetFoo()59        {60            return 1;61        }62    }63}64using Telerik.JustMock.Tests;65{66    {67        public virtual int GetFoo()68        {69            return 1;70        }71    }72}

1using Telerik.JustMock.Tests;2{3    public void Bar()4    {5        var service = new FooService();6        service.DoSomething();7    }8}9using Telerik.JustMock.Tests;10{11    public void Bar()12    {13        var service = new FooService();14        service.DoSomething();15    }16}17using Telerik.JustMock.Tests;18{19    public void Bar()20    {21        var service = new FooService();22        service.DoSomething();23    }24}25using Telerik.JustMock.Tests;26{27    public void Bar()28    {29        var service = new FooService();30        service.DoSomething();31    }32}33using Telerik.JustMock.Tests;34{35    public void Bar()36    {37        var service = new FooService();38        service.DoSomething();39    }40}41using Telerik.JustMock.Tests;42{43    public void Bar()44    {45        var service = new FooService();46        service.DoSomething();47    }48}49using Telerik.JustMock.Tests;50{51    public void Bar()52    {53        var service = new FooService();54        service.DoSomething();55    }56}57using Telerik.JustMock.Tests;58{59    public void Bar()60    {61        var service = new FooService();62        service.DoSomething();63    }64}65using Telerik.JustMock.Tests;66{67    public void Bar()68    {69        var service = new FooService();70        service.DoSomething();71    }72}

1using Telerik.JustMock.Tests;2{3    public FooServiceClient()4    {5        this.FooService = new FooService();6    }7    public FooService FooService { get; set; }8    public int GetCount()9    {10        return this.FooService.GetCount();11    }12}13using Telerik.JustMock.Tests;14{15    public FooServiceClient()16    {17        this.FooService = new FooService();18    }19    public FooService FooService { get; set; }20    public int GetCount()21    {22        return this.FooService.GetCount();23    }24}

1using Telerik.JustMock.Tests;2{3    public void Foo()4    {5        var fooService = new FooService();6        fooService.Bar();7    }8}9using Telerik.JustMock.Tests;10{11    public void Foo()12    {13        var fooService = new FooService();14        fooService.Bar();15    }16}17using Telerik.JustMock.Tests;18{19    public void Foo()20    {21        var fooService = new FooService();22        fooService.Bar();23    }24}25using Telerik.JustMock.Tests;26{27    public void Foo()28    {29        var fooService = new FooService();30        fooService.Bar();31    }32}33using Telerik.JustMock.Tests;34{35    public void Foo()36    {37        var fooService = new FooService();38        fooService.Bar();39    }40}41using Telerik.JustMock.Tests;42{43    public void Foo()44    {45        var fooService = new FooService();46        fooService.Bar();47    }48}49using Telerik.JustMock.Tests;50{51    public void Foo()52    {53        var fooService = new FooService();54        fooService.Bar();55    }56}57using Telerik.JustMock.Tests;58{59    public void Foo()60    {61        var fooService = new FooService();62        fooService.Bar();63    }64}65using Telerik.JustMock.Tests;66{

1using Telerik.JustMock.Tests;2{3    static void Main(string[] args)4    {5        var service = new FooService();6        var result = service.GetFoo();7        Console.WriteLine(result);8    }9}10{11    {12        public string GetFoo()13        {14            return "foo";15        }16    }17}

1FooService fooService = new FooService();2fooService.DoSomething();3fooService.DoSomethingElse();4fooService.DoSomething();5fooService.DoSomethingElse();6fooService.DoSomething();7fooService.DoSomethingElse();8FooService fooService = new FooService();9fooService.DoSomething();10fooService.DoSomethingElse();11fooService.DoSomething();12fooService.DoSomethingElse();13fooService.DoSomething();14fooService.DoSomethingElse();15FooService fooService = new FooService();16fooService.DoSomething();17fooService.DoSomethingElse();18fooService.DoSomething();19fooService.DoSomethingElse();20fooService.DoSomething();21fooService.DoSomethingElse();22FooService fooService = new FooService();23fooService.DoSomething();24fooService.DoSomethingElse();25fooService.DoSomething();26fooService.DoSomethingElse();27fooService.DoSomething();28fooService.DoSomethingElse();29FooService fooService = new FooService();30fooService.DoSomething();31fooService.DoSomethingElse();32fooService.DoSomething();33fooService.DoSomethingElse();34fooService.DoSomething();35fooService.DoSomethingElse();36FooService fooService = new FooService();37fooService.DoSomething();38fooService.DoSomethingElse();39fooService.DoSomething();40fooService.DoSomethingElse();41fooService.DoSomething();42fooService.DoSomethingElse();43FooService fooService = new FooService();44fooService.DoSomething();45fooService.DoSomethingElse();46fooService.DoSomething();47fooService.DoSomethingElse();48fooService.DoSomething();49fooService.DoSomethingElse();50FooService fooService = new FooService();51fooService.DoSomething();52fooService.DoSomethingElse();53fooService.DoSomething();54fooService.DoSomethingElse();55fooService.DoSomething();56fooService.DoSomethingElse();