[Dotnetmock-commits] dotnetmock/DotNetMock.Tests/Dynamic AbstractDynamicMockTests.cs,NONE,1.1 DynamicMockTests.cs,1.17,1.18 DynamicOrderedMockTests.cs,1.5,1.6

[Choy R. <ch...@us...>]

Update of /cvsroot/dotnetmock/dotnetmock/DotNetMock.Tests/Dynamic
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv7705/DotNetMock.Tests/Dynamic

Modified Files:
	DynamicMockTests.cs DynamicOrderedMockTests.cs 
Added Files:
	AbstractDynamicMockTests.cs 
Log Message:
Factored out common tests from the two DynamicMock classes.

Index: DynamicMockTests.cs
===================================================================
RCS file: /cvsroot/dotnetmock/dotnetmock/DotNetMock.Tests/Dynamic/DynamicMockTests.cs,v
retrieving revision 1.17
retrieving revision 1.18
diff -C2 -d -r1.17 -r1.18
*** DynamicMockTests.cs	1 Jan 2005 22:57:51 -0000	1.17
--- DynamicMockTests.cs	9 Jan 2005 21:05:05 -0000	1.18
***************
*** 1,4 ****
  #region License
! // need license
  #endregion
  #region Imports
--- 1,4 ----
  #region License
! // Copyright (c) 2004 Griffin Caprio & Choy Rim. All rights reserved.
  #endregion
  #region Imports
***************
*** 14,78 ****
  {
  	[TestFixture]
! 	public class DynamicMockTests
  	{
! 		private IDynamicMock mock;
! 		private MethodInfo myMethod;
! 		private MethodInfo myMethod1;
! 		private MethodInfo myMethod2;
! 		private MethodInfo myMethod3;
! 		private MethodInfo anotherMethod;
! 
! 		interface IBlah 
  		{
! 			object DoStuff(string name);
! 			object DoStuffWithParams( string id, params string[] names );
! 			bool DoStuffBooleanStyle( bool flag );
! 			void MethodWithOutParameter(out string p1);
! 			void MethodWithRefParameter(ref string p1);
! 
! 			void myMethod();
! 			void myMethod1();
! 			void myMethod2();
! 			void myMethod3();
! 			void anotherMethod();
  		}
! 
! 		[SetUp] public void BeforeEachTest() 
  		{
! 			mock = new DynamicMock("mymock");
! 			myMethod = typeof(IBlah).GetMethod("myMethod", new Type[0]);
! 			myMethod1 = typeof(IBlah).GetMethod("myMethod1", new Type[0]);
! 			myMethod2 = typeof(IBlah).GetMethod("myMethod2", new Type[0]);
! 			myMethod3 = typeof(IBlah).GetMethod("myMethod3", new Type[0]);
! 			anotherMethod = typeof(IBlah).GetMethod("anotherMethod", new Type[0]);
  		}
  
  		[Test]
! 		public void SetsRefParameter()
  		{
! 			IDynamicMock mock = new DynamicMock(typeof(IBlah));
! 			IBlah blah = (IBlah) mock.Object;
! 			string p1 = "hello";
! 			mock.Expect("MethodWithRefParameter",
! 				new Assign("goodbye").AndRequire(new IsEqual("hello"))
! 				);
! 
! 			blah.MethodWithRefParameter(ref p1);
! 			Assertion.AssertEquals("goodbye", p1);
  			mock.Verify();
  		}
  
  		[Test]
! 		public void SetsOutParameter()
  		{
! 			IDynamicMock mock = new DynamicMock(typeof(IBlah));
! 			IBlah blah = (IBlah) mock.Object;
! 			string p1 = null;
! 			mock.Expect("MethodWithOutParameter",
! 				new Assign("hello")
! 				);
! 
! 			blah.MethodWithOutParameter(out p1);
! 			Assertion.AssertEquals("hello", p1);
  			mock.Verify();
  		}
--- 14,49 ----
  {
  	[TestFixture]
! 	public class DynamicMockTests : AbstractDynamicMockTests
  	{
! 		protected override IDynamicMock newDynamicMock(Type type, string name)
  		{
! 			return new DynamicMock(type, name);
  		}
! 		protected override IDynamicMock newDynamicMock(Type type)
  		{
! 			return new DynamicMock(type);
! 		}
! 		protected override IDynamicMock newDynamicMock(string name)
! 		{
! 			return new DynamicMock(name);
  		}
  
  		[Test]
! 		public void CallMultipleMethodsInWrongOrder() 
  		{
! 			mock.Expect("myMethod1");
! 			mock.Expect("myMethod2");
! 			mock.Expect("myMethod3");
! 			mock.Call(myMethod1);
! 			mock.Call(myMethod3);
! 			mock.Call(myMethod2);
  			mock.Verify();
  		}
  
  		[Test]
! 		[ExpectedException(typeof(AssertionException), "1 more call(s) were expected for myMethod")]
! 		public void NoCallToVoidMethodWithReason()
  		{
! 			mock.Expect("myMethod");
  			mock.Verify();
  		}
***************
*** 82,86 ****
  		public void ThrowsIfUnexpectedMethodCalled()
  		{
! 			IDynamicMock mock = new DynamicMock(typeof(IBlah));
  			IBlah blah = (IBlah) mock.Object;
  			mock.Strict = true;
--- 53,57 ----
  		public void ThrowsIfUnexpectedMethodCalled()
  		{
! 			IDynamicMock mock = newDynamicMock(typeof(IBlah));
  			IBlah blah = (IBlah) mock.Object;
  			mock.Strict = true;
***************
*** 92,117 ****
  		}
  
- 		[Test]
- 		public void DefaultDynamicMock()
- 		{
- 			IDynamicMock mock = new DynamicMock(typeof(IBlah));
- 			Assertion.AssertEquals("MockBlah", mock.MockName);
- 			
- 			mock.ExpectAndReturn("DoStuff", "world", "hello");
- 			
- 			IBlah blah = (IBlah)mock.Object;
- 			Assertion.AssertEquals("world", blah.DoStuff("hello"));
- 			
- 			mock.Verify();
- 		}
- 
- 		[Test]		
- 		public void NamedDynamicMock()
- 		{
- 			IDynamicMock mock = new DynamicMock(typeof(IBlah), "XBlah");
- 			Assertion.AssertEquals("XBlah", mock.MockName);
- 			mock.Verify();
- 		}
- 
  		[Test]		
  		public void CustomDynamicMock()
--- 63,66 ----
***************
*** 122,157 ****
  			mock.Verify();
  		}
- 		[Test]
- 		public void CustomDynamicMockWithBool()
- 		{
- 			IDynamicMock mock = new DynamicMock( typeof(IBlah), "XBlah" );
- 			mock.ExpectAndReturn( "DoStuffBooleanStyle", false, true );
- 			IBlah blah = (IBlah) mock.Object;
- 			Assertion.AssertEquals( false, blah.DoStuffBooleanStyle( true ) );
- 			mock.Verify();
- 		}
- 		[Test]
- 		public void DynamicMockWithParams() 
- 		{
- 			IDynamicMock mock = new DynamicMock(typeof(IBlah));
- 			mock.ExpectAndReturn( "DoStuffWithParams", "world2", "12345", new string[] {"hello" } );
- 
- 			IBlah blah = (IBlah)mock.Object;
- 
- 			Assertion.AssertEquals( "world2", blah.DoStuffWithParams("12345", "hello") );
- 			mock.Verify();
- 
- 		}
- 		[Test]
- 		public void DynamicMockWithManyParams() 
- 		{
- 			IDynamicMock mock = new DynamicMock(typeof(IBlah));
- 			mock.ExpectAndReturn( "DoStuffWithParams", "world2", "12345", new string[] { "hello", "dotnetmock" } );
- 
- 			IBlah blah = (IBlah)mock.Object;
- 
- 			Assertion.AssertEquals( "world2", blah.DoStuffWithParams("12345", "hello", "dotnetmock") );
- 			mock.Verify();
- 		}
  		private class CustomMock : DynamicMock
  		{
--- 71,74 ----
***************
*** 163,377 ****
  			}
  		}
- 		[Test]
- 		public void Name() 
- 		{
- 			Assertion.AssertEquals("mymock", mock.MockName);
- 		}
- 		
- 		[Test]
- 		public void NewMockVerifies() 
- 		{
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallToVoidMethod() 
- 		{
- 			mock.Expect("myMethod");
- 			mock.Call(myMethod);
- 			mock.Verify();
- 		}
- 		[Test]
- 		[ExpectedException(typeof(AssertionException))]
- 		public void NoCallToVoidMethod() 
- 		{
- 			mock.Expect("myMethod");
- 			mock.Verify();
- 		}
- 		[Test]
- 		[ExpectedException(typeof(AssertionException), "1 more call(s) were expected for myMethod")]
- 		public void NoCallToVoidMethodWithReason()
- 		{
- 			mock.Expect("myMethod");
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		[ExpectedException(typeof(AssertionException))]
- 		public void TooManyCallsToVoidMethod() 
- 		{
- 			mock.Expect("myMethod");
- 			mock.Call(myMethod);
- 			mock.Call(myMethod);
- 		}
- 
- 		[Test]
- 		public void ManyCallsToVoidMethod() 
- 		{
- 			mock.Expect("myMethod");
- 			mock.Expect("myMethod");
- 			mock.Expect("myMethod");
- 			mock.Call(myMethod);
- 			mock.Call(myMethod);
- 			mock.Call(myMethod);
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallToMethodWithParams() 
- 		{
- 			mock.Expect("myMethod", new IsEqual("hello"), new IsAnything());
- 			mock.Call(myMethod, "hello", null);
- 			mock.Verify();
- 		}
- 		[Test]
- 		[ExpectedException(typeof(DotNetMock.AssertionException))]
- 		public void CallToMethodWithInvalidParams() 
- 		{
- 			mock.Expect("myMethod", new IsEqual("hello"), new IsAnything());
- 			mock.Call(myMethod, "world", null);
- 		}
- 
- 		[Test]
- 		public void CallToMethodWithParamsButNotCheckingValues() 
- 		{
- 			mock.Expect("myMethod");
- 			mock.Call(myMethod, "world", null);
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallMultipleMethods() 
- 		{
- 			mock.Expect("myMethod1");
- 			mock.Expect("myMethod2");
- 			mock.Expect("myMethod3");
- 			mock.Call(myMethod1);
- 			mock.Call(myMethod2);
- 			mock.Call(myMethod3);
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallMultipleMethodsInWrongOrder() 
- 		{
- 			mock.Expect("myMethod1");
- 			mock.Expect("myMethod2");
- 			mock.Expect("myMethod3");
- 			mock.Call(myMethod1);
- 			mock.Call(myMethod3);
- 			mock.Call(myMethod2);
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallToNonVoidMethod() 
- 		{
- 			object something = new object();
- 			mock.ExpectAndReturn("myMethod", something);
- 			object result = mock.Call(myMethod);
- 			mock.Verify();
- 			Assertion.AssertEquals(something, result);
- 		}
- 
- 		[Test]
- 		public void CallToNonVoidMethodWithParams() 
- 		{
- 			object something = new object();
- 			mock.ExpectAndReturn("myMethod", something, new IsEqual("hello"));
- 			object result = mock.Call(myMethod, "hello");
- 			mock.Verify();
- 			Assertion.AssertEquals(something, result);
- 		}
- 
- 		[Test]
- 		[ExpectedException(typeof(AssertionException))]
- 		public void CallToNonVoidMethodWithWrongParams() 
- 		{
- 			object something = new object();
- 			mock.ExpectAndReturn("myMethod", something, new IsEqual("hello"));
- 			object result = mock.Call(myMethod, "bye");
- 			mock.Verify();
- 			Assertion.AssertEquals(something, result);
- 		}
- 
- 		[Test]
- 		public void MultipleCallToNonVoidMethod() 
- 		{
- 			object something = new object();
- 			object anotherthing = new object();
- 			int x = 3;
- 			mock.ExpectAndReturn("myMethod", something);
- 			mock.ExpectAndReturn("myMethod", anotherthing);
- 			mock.ExpectAndReturn("myMethod", x);
- 			Assertion.AssertEquals(something, mock.Call(myMethod));
- 			Assertion.AssertEquals(anotherthing, mock.Call(myMethod));
- 			Assertion.AssertEquals(x, mock.Call(myMethod));
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallToNonVoidMethodReturningNull() 
- 		{
- 			mock.ExpectAndReturn("myMethod", null);
- 			Assertion.AssertNull(mock.Call(myMethod));
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void DefaultEqualsPredicates() 
- 		{
- 			object o = new object();
- 			mock.Expect("myMethod", o);
- 			mock.Call(myMethod, o);
- 		}
- 
- 		[Test]
- 		[ExpectedException(typeof(AssertionException))]
- 		public void DefaultEqualsPredicatesFailure() 
- 		{
- 			mock.Expect("myMethod", new object());
- 			mock.Call(myMethod, new object());
- 		}
- 
- 		[Test]
- 		public void DefaultAnythingPredicates() 
- 		{
- 			mock.Expect("myMethod", null, null);
- 			mock.Expect("myMethod", null, "zzz");
- 			mock.Expect("myMethod", "zzz", null);
- 			mock.Call(myMethod, "???", "???");
- 			mock.Call(myMethod, "???", "zzz");
- 			mock.Call(myMethod, "zzz", "???");
- 		}
- 
- 		[Test]
- 		public void FixedValue() 
- 		{
- 			mock.SetValue("myMethod", "hello");
- 			mock.SetValue("anotherMethod", "world");
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("world", mock.Call(anotherMethod));
- 			Assertion.AssertEquals("world", mock.Call(anotherMethod));
- 			mock.SetValue("myMethod", "bye");
- 			Assertion.AssertEquals("bye", mock.Call(myMethod));
- 			Assertion.AssertEquals("bye", mock.Call(myMethod));
- 			Assertion.AssertEquals("world", mock.Call(anotherMethod));
- 			mock.SetValue("myMethod", null);
- 			Assertion.AssertNull(mock.Call(myMethod));
- 			Assertion.AssertNull(mock.Call(myMethod));
- 			mock.Verify();
- 		}
- 		
- 		[Test]
- 		[ExpectedException(typeof(System.IO.IOException))]
- 		public void CallThrowingException()
- 		{
- 			mock.ExpectAndThrow("myMethod", new System.IO.IOException());
- 			mock.Call(myMethod);
- 		}
  	}
  }
--- 80,83 ----

Index: DynamicOrderedMockTests.cs
===================================================================
RCS file: /cvsroot/dotnetmock/dotnetmock/DotNetMock.Tests/Dynamic/DynamicOrderedMockTests.cs,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** DynamicOrderedMockTests.cs	1 Jan 2005 22:57:51 -0000	1.5
--- DynamicOrderedMockTests.cs	9 Jan 2005 21:05:06 -0000	1.6
***************
*** 1,2 ****
--- 1,6 ----
+ #region License
+ // Copyright (c) 2004 Griffin Caprio & Choy Rim. All rights reserved.
+ #endregion
+ #region Imports
  using System;
  using System.Reflection;
***************
*** 4,125 ****
  using NUnit.Framework;
  using DotNetMock.Dynamic;
  
  namespace DotNetMock.Tests.Dynamic
  {
  	[TestFixture]
! 	public class DynamicOrderedMockTest 
  	{
! 		private MethodInfo myMethod;
! 		private MethodInfo myMethod1;
! 		private MethodInfo myMethod2;
! 		private MethodInfo myMethod3;
! 		private MethodInfo anotherMethod;
! 
! 		interface IBlah 
! 		{
! 			object DoStuff(string name);
! 
! 			void myMethod();
! 			void myMethod1();
! 			void myMethod2();
! 			void myMethod3();
! 			void anotherMethod();
! 		}
! 		private IDynamicMock mock;
! 
! 		[SetUp]
! 		public void SetUp() 
! 		{
! 			mock = new DynamicOrderedMock("mymock");
! 			myMethod = typeof(IBlah).GetMethod("myMethod", new Type[0]);
! 			myMethod1 = typeof(IBlah).GetMethod("myMethod1", new Type[0]);
! 			myMethod2 = typeof(IBlah).GetMethod("myMethod2", new Type[0]);
! 			myMethod3 = typeof(IBlah).GetMethod("myMethod3", new Type[0]);
! 			anotherMethod = typeof(IBlah).GetMethod("anotherMethod", new Type[0]);
! 		}
! 
! 		[Test]
! 		public void Name() 
! 		{
! 			Assertion.AssertEquals("mymock", mock.MockName);
! 		}
! 		
! 		[Test]
! 		public void NewMockVerifies() 
! 		{
! 			mock.Verify();
! 		}
! 
! 		[Test]
! 		public void CallToVoidMethod() 
! 		{
! 			mock.Expect("myMethod");
! 			mock.Call(myMethod);
! 			mock.Verify();
! 		}
! 
! 		[Test]
! 		[ExpectedException(typeof(AssertionException))]
! 		public void NoCallToVoidMethod() 
! 		{
! 			mock.Expect("myMethod");
! 			mock.Verify();
! 		}
! 
! 		[Test]
! 		[ExpectedException(typeof(AssertionException))]
! 		public void TooManyCallsToVoidMethod() 
! 		{
! 			mock.Expect("myMethod");
! 			mock.Call(myMethod);
! 			mock.Call(myMethod);
! 		}
! 
! 		[Test]
! 		public void ManyCallsToVoidMethod() 
! 		{
! 			mock.Expect("myMethod");
! 			mock.Expect("myMethod");
! 			mock.Expect("myMethod");
! 			mock.Call(myMethod);
! 			mock.Call(myMethod);
! 			mock.Call(myMethod);
! 			mock.Verify();
! 		}
! 
! 		[Test]
! 		public void CallToMethodWithParams() 
! 		{
! 			mock.Expect("myMethod", new IsEqual("hello"), new IsAnything());
! 			mock.Call(myMethod, "hello", null);
! 			mock.Verify();
! 		}
! 
! 		[Test]
! 		[ExpectedException(typeof(DotNetMock.AssertionException))]
! 		public void CallToMethodWithInvalidParams() 
  		{
! 			mock.Expect("myMethod", new IsEqual("hello"), new IsAnything());
! 			mock.Call(myMethod, "world", null);
  		}
! 
! 		[Test]
! 		public void CallToMethodWithParamsButNotCheckingValues() 
  		{
! 			mock.Expect("myMethod");
! 			mock.Call(myMethod, "world", null);
! 			mock.Verify();
  		}
! 
! 		[Test]
! 		public void CallMultipleMethods() 
  		{
! 			mock.Expect("myMethod1");
! 			mock.Expect("myMethod2");
! 			mock.Expect("myMethod3");
! 			mock.Call(myMethod1);
! 			mock.Call(myMethod2);
! 			mock.Call(myMethod3);
! 			mock.Verify();
  		}
  
--- 8,29 ----
  using NUnit.Framework;
  using DotNetMock.Dynamic;
+ #endregion
  
  namespace DotNetMock.Tests.Dynamic
  {
  	[TestFixture]
! 	public class DynamicOrderedMockTests : AbstractDynamicMockTests
  	{
! 		protected override IDynamicMock newDynamicMock(Type type, string name)
  		{
! 			return new DynamicOrderedMock(type, name);
  		}
! 		protected override IDynamicMock newDynamicMock(Type type)
  		{
! 			return new DynamicOrderedMock(type);
  		}
! 		protected override IDynamicMock newDynamicMock(string name)
  		{
! 			return new DynamicOrderedMock(name);
  		}
  
***************
*** 137,271 ****
  		}
  
- 		[Test]
- 		public void CallToNonVoidMethod() 
- 		{
- 			object something = new object();
- 			mock.ExpectAndReturn("myMethod", something);
- 			object result = mock.Call(myMethod);
- 			mock.Verify();
- 			Assertion.AssertEquals(something, result);
- 		}
- 
- 		[Test]
- 		public void CallToNonVoidMethodWithParams() 
- 		{
- 			object something = new object();
- 			mock.ExpectAndReturn("myMethod", something, new IsEqual("hello"));
- 			object result = mock.Call(myMethod, "hello");
- 			mock.Verify();
- 			Assertion.AssertEquals(something, result);
- 		}
- 
- 		[Test]
- 		[ExpectedException(typeof(AssertionException))]
- 		public void CallToNonVoidMethodWithWrongParams() 
- 		{
- 			object something = new object();
- 			mock.ExpectAndReturn("myMethod", something, new IsEqual("hello"));
- 			object result = mock.Call(myMethod, "bye");
- 			mock.Verify();
- 			Assertion.AssertEquals(something, result);
- 		}
- 
- 		[Test]
- 		public void MultipleCallToNonVoidMethod() 
- 		{
- 			object something = new object();
- 			object anotherthing = new object();
- 			int x = 3;
- 			mock.ExpectAndReturn("myMethod", something);
- 			mock.ExpectAndReturn("myMethod", anotherthing);
- 			mock.ExpectAndReturn("myMethod", x);
- 			Assertion.AssertEquals(something, mock.Call(myMethod));
- 			Assertion.AssertEquals(anotherthing, mock.Call(myMethod));
- 			Assertion.AssertEquals(x, mock.Call(myMethod));
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void CallToNonVoidMethodReturningNull() 
- 		{
- 			mock.ExpectAndReturn("myMethod", null);
- 			Assertion.AssertNull(mock.Call(myMethod));
- 			mock.Verify();
- 		}
- 
- 		[Test]
- 		public void DefaultEqualsPredicates() 
- 		{
- 			object o = new object();
- 			mock.Expect("myMethod", o);
- 			mock.Call(myMethod, o);
- 		}
- 
- 		[Test]
- 		[ExpectedException(typeof(AssertionException))]
- 		public void DefaultEqualsPredicatesFailure() 
- 		{
- 			mock.Expect("myMethod", new object());
- 			mock.Call(myMethod, new object());
- 		}
- 
- 		[Test]
- 		public void DefaultAnythingPredicates() 
- 		{
- 			mock.Expect("myMethod", null, null);
- 			mock.Expect("myMethod", null, "zzz");
- 			mock.Expect("myMethod", "zzz", null);
- 			mock.Call(myMethod, "???", "???");
- 			mock.Call(myMethod, "???", "zzz");
- 			mock.Call(myMethod, "zzz", "???");
- 		}
- 
- 		[Test]
- 		public void FixedValue() 
- 		{
- 			mock.SetValue("myMethod", "hello");
- 			mock.SetValue("anotherMethod", "world");
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("hello", mock.Call(myMethod));
- 			Assertion.AssertEquals("world", mock.Call(anotherMethod));
- 			Assertion.AssertEquals("world", mock.Call(anotherMethod));
- 			mock.SetValue("myMethod", "bye");
- 			Assertion.AssertEquals("bye", mock.Call(myMethod));
- 			Assertion.AssertEquals("bye", mock.Call(myMethod));
- 			Assertion.AssertEquals("world", mock.Call(anotherMethod));
- 			mock.SetValue("myMethod", null);
- 			Assertion.AssertNull(mock.Call(myMethod));
- 			Assertion.AssertNull(mock.Call(myMethod));
- 			mock.Verify();
- 		}
- 		
- 		[Test]
- 		[ExpectedException(typeof(System.IO.IOException))]
- 		public void CallThrowingException()
- 		{
- 			mock.ExpectAndThrow("myMethod", new System.IO.IOException());
- 			mock.Call(myMethod);
- 		}
- 		[Test]
- 		public void DefaultDynamicMock()
- 		{
- 			IDynamicMock mock = new DynamicOrderedMock(typeof(IBlah));
- 			Assertion.AssertEquals("MockBlah", mock.MockName);
- 			
- 			mock.ExpectAndReturn("DoStuff", "world", "hello");
- 			
- 			IBlah blah = (IBlah)mock.Object;
- 			Assertion.AssertEquals("world", blah.DoStuff("hello"));
- 			
- 			mock.Verify();
- 		}
- 
- 		[Test]		
- 		public void NamedDynamicMock()
- 		{
- 			IDynamicMock mock = new DynamicOrderedMock(typeof(IBlah), "XBlah");
- 			Assertion.AssertEquals("XBlah", mock.MockName);
- 			mock.Verify();
- 		}
- 
  		[Test]		
  		public void CustomDynamicMock()
--- 41,44 ----

--- NEW FILE: AbstractDynamicMockTests.cs ---
#region License
// Copyright (c) 2004 Griffin Caprio & Choy Rim. All rights reserved.
#endregion
#region Imports
using System;
using System.Reflection;
using DotNetMock.Dynamic;
using NUnit.Framework;

using DotNetMock.Dynamic.Predicates;
#endregion

namespace DotNetMock.Tests.Dynamic
{
	[TestFixture]
	public abstract class AbstractDynamicMockTests
	{
		protected IDynamicMock mock;
		protected MethodInfo myMethod;
		protected MethodInfo myMethod1;
		protected MethodInfo myMethod2;
		protected MethodInfo myMethod3;
		protected MethodInfo anotherMethod;

		/// <summary>
		/// Create instance of <see cref="IDynamicMock"/> to test.
		/// </summary>
		protected abstract IDynamicMock newDynamicMock(Type type, string name);
		protected abstract IDynamicMock newDynamicMock(Type type);
		protected abstract IDynamicMock newDynamicMock(string name);

		protected interface IBlah 
		{
			object DoStuff(string name);
			object DoStuffWithParams( string id, params string[] names );
			bool DoStuffBooleanStyle( bool flag );
			void MethodWithOutParameter(out string p1);
			void MethodWithRefParameter(ref string p1);

			void myMethod();
			void myMethod1();
			void myMethod2();
			void myMethod3();
			void anotherMethod();
		}

		[SetUp] public void BeforeEachTest() 
		{
			mock = newDynamicMock("mymock");
			myMethod = typeof(IBlah).GetMethod("myMethod", new Type[0]);
			myMethod1 = typeof(IBlah).GetMethod("myMethod1", new Type[0]);
			myMethod2 = typeof(IBlah).GetMethod("myMethod2", new Type[0]);
			myMethod3 = typeof(IBlah).GetMethod("myMethod3", new Type[0]);
			anotherMethod = typeof(IBlah).GetMethod("anotherMethod", new Type[0]);
		}

		[Test]
		public void SetsRefParameter()
		{
			IDynamicMock mock = newDynamicMock(typeof(IBlah));
			IBlah blah = (IBlah) mock.Object;
			string p1 = "hello";
			mock.Expect("MethodWithRefParameter",
				new Assign("goodbye").AndRequire(new IsEqual("hello"))
				);

			blah.MethodWithRefParameter(ref p1);
			Assertion.AssertEquals("goodbye", p1);
			mock.Verify();
		}

		[Test]
		public void SetsOutParameter()
		{
			IDynamicMock mock = newDynamicMock(typeof(IBlah));
			IBlah blah = (IBlah) mock.Object;
			string p1 = null;
			mock.Expect("MethodWithOutParameter",
				new Assign("hello")
				);

			blah.MethodWithOutParameter(out p1);
			Assertion.AssertEquals("hello", p1);
			mock.Verify();
		}

		[Test]
		public void DefaultDynamicMock()
		{
			IDynamicMock mock = newDynamicMock(typeof(IBlah));
			Assertion.AssertEquals("MockBlah", mock.MockName);
			
			mock.ExpectAndReturn("DoStuff", "world", "hello");
			
			IBlah blah = (IBlah)mock.Object;
			Assertion.AssertEquals("world", blah.DoStuff("hello"));
			
			mock.Verify();
		}

		[Test]		
		public void NamedDynamicMock()
		{
			IDynamicMock mock = newDynamicMock(typeof(IBlah), "XBlah");
			Assertion.AssertEquals("XBlah", mock.MockName);
			mock.Verify();
		}

		[Test]
		public void CustomDynamicMockWithBool()
		{
			IDynamicMock mock = newDynamicMock( typeof(IBlah), "XBlah" );
			mock.ExpectAndReturn( "DoStuffBooleanStyle", false, true );
			IBlah blah = (IBlah) mock.Object;
			Assertion.AssertEquals( false, blah.DoStuffBooleanStyle( true ) );
			mock.Verify();
		}
		[Test]
		public void DynamicMockWithParams() 
		{
			IDynamicMock mock = newDynamicMock(typeof(IBlah));
			mock.ExpectAndReturn( "DoStuffWithParams", "world2", "12345", new string[] {"hello" } );

			IBlah blah = (IBlah)mock.Object;

			Assertion.AssertEquals( "world2", blah.DoStuffWithParams("12345", "hello") );
			mock.Verify();

		}
		[Test]
		public void DynamicMockWithManyParams() 
		{
			IDynamicMock mock = newDynamicMock(typeof(IBlah));
			mock.ExpectAndReturn( "DoStuffWithParams", "world2", "12345", new string[] { "hello", "dotnetmock" } );

			IBlah blah = (IBlah)mock.Object;

			Assertion.AssertEquals( "world2", blah.DoStuffWithParams("12345", "hello", "dotnetmock") );
			mock.Verify();
		}
		[Test]
		public void Name() 
		{
			Assertion.AssertEquals("mymock", mock.MockName);
		}
		
		[Test]
		public void NewMockVerifies() 
		{
			mock.Verify();
		}

		[Test]
		public void CallToVoidMethod() 
		{
			mock.Expect("myMethod");
			mock.Call(myMethod);
			mock.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void NoCallToVoidMethod() 
		{
			mock.Expect("myMethod");
			mock.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void TooManyCallsToVoidMethod() 
		{
			mock.Expect("myMethod");
			mock.Call(myMethod);
			mock.Call(myMethod);
		}

		[Test]
		public void ManyCallsToVoidMethod() 
		{
			mock.Expect("myMethod");
			mock.Expect("myMethod");
			mock.Expect("myMethod");
			mock.Call(myMethod);
			mock.Call(myMethod);
			mock.Call(myMethod);
			mock.Verify();
		}

		[Test]
		public void CallToMethodWithParams() 
		{
			mock.Expect("myMethod", new IsEqual("hello"), new IsAnything());
			mock.Call(myMethod, "hello", null);
			mock.Verify();
		}
		[Test]
		[ExpectedException(typeof(DotNetMock.AssertionException))]
		public void CallToMethodWithInvalidParams() 
		{
			mock.Expect("myMethod", new IsEqual("hello"), new IsAnything());
			mock.Call(myMethod, "world", null);
		}

		[Test]
		public void CallToMethodWithParamsButNotCheckingValues() 
		{
			mock.Expect("myMethod");
			mock.Call(myMethod, "world", null);
			mock.Verify();
		}

		[Test]
		public void CallMultipleMethods() 
		{
			mock.Expect("myMethod1");
			mock.Expect("myMethod2");
			mock.Expect("myMethod3");
			mock.Call(myMethod1);
			mock.Call(myMethod2);
			mock.Call(myMethod3);
			mock.Verify();
		}

		[Test]
		public void CallToNonVoidMethod() 
		{
			object something = new object();
			mock.ExpectAndReturn("myMethod", something);
			object result = mock.Call(myMethod);
			mock.Verify();
			Assertion.AssertEquals(something, result);
		}

		[Test]
		public void CallToNonVoidMethodWithParams() 
		{
			object something = new object();
			mock.ExpectAndReturn("myMethod", something, new IsEqual("hello"));
			object result = mock.Call(myMethod, "hello");
			mock.Verify();
			Assertion.AssertEquals(something, result);
		}

		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void CallToNonVoidMethodWithWrongParams() 
		{
			object something = new object();
			mock.ExpectAndReturn("myMethod", something, new IsEqual("hello"));
			object result = mock.Call(myMethod, "bye");
			mock.Verify();
			Assertion.AssertEquals(something, result);
		}

		[Test]
		public void MultipleCallToNonVoidMethod() 
		{
			object something = new object();
			object anotherthing = new object();
			int x = 3;
			mock.ExpectAndReturn("myMethod", something);
			mock.ExpectAndReturn("myMethod", anotherthing);
			mock.ExpectAndReturn("myMethod", x);
			Assertion.AssertEquals(something, mock.Call(myMethod));
			Assertion.AssertEquals(anotherthing, mock.Call(myMethod));
			Assertion.AssertEquals(x, mock.Call(myMethod));
			mock.Verify();
		}

		[Test]
		public void CallToNonVoidMethodReturningNull() 
		{
			mock.ExpectAndReturn("myMethod", null);
			Assertion.AssertNull(mock.Call(myMethod));
			mock.Verify();
		}

		[Test]
		public void DefaultEqualsPredicates() 
		{
			object o = new object();
			mock.Expect("myMethod", o);
			mock.Call(myMethod, o);
		}

		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void DefaultEqualsPredicatesFailure() 
		{
			mock.Expect("myMethod", new object());
			mock.Call(myMethod, new object());
		}

		[Test]
		public void DefaultAnythingPredicates() 
		{
			mock.Expect("myMethod", null, null);
			mock.Expect("myMethod", null, "zzz");
			mock.Expect("myMethod", "zzz", null);
			mock.Call(myMethod, "???", "???");
			mock.Call(myMethod, "???", "zzz");
			mock.Call(myMethod, "zzz", "???");
		}

		[Test]
		public void FixedValue() 
		{
			mock.SetValue("myMethod", "hello");
			mock.SetValue("anotherMethod", "world");
			Assertion.AssertEquals("hello", mock.Call(myMethod));
			Assertion.AssertEquals("hello", mock.Call(myMethod));
			Assertion.AssertEquals("hello", mock.Call(myMethod));
			Assertion.AssertEquals("hello", mock.Call(myMethod));
			Assertion.AssertEquals("world", mock.Call(anotherMethod));
			Assertion.AssertEquals("world", mock.Call(anotherMethod));
			mock.SetValue("myMethod", "bye");
			Assertion.AssertEquals("bye", mock.Call(myMethod));
			Assertion.AssertEquals("bye", mock.Call(myMethod));
			Assertion.AssertEquals("world", mock.Call(anotherMethod));
			mock.SetValue("myMethod", null);
			Assertion.AssertNull(mock.Call(myMethod));
			Assertion.AssertNull(mock.Call(myMethod));
			mock.Verify();
		}
		
		[Test]
		[ExpectedException(typeof(System.IO.IOException))]
		public void CallThrowingException()
		{
			mock.ExpectAndThrow("myMethod", new System.IO.IOException());
			mock.Call(myMethod);
		}
	}
}