[Dotnetmock-developer] dotnetmock/DotNetMock.Tests/Dynamic DynamicMockTests.cs,NONE,1.1 MockTests.cs,NONE,1.1 PredicateTests.cs,NONE,1.1

[<gc...@us...>]

Update of /cvsroot/dotnetmock/dotnetmock/DotNetMock.Tests/Dynamic
In directory usw-pr-cvs1:/tmp/cvs-serv12370/DotNetMock.Tests/Dynamic

Added Files:
	DynamicMockTests.cs MockTests.cs PredicateTests.cs 
Log Message:

Added the dynamic Mock Object Generation package

--- NEW FILE: DynamicMockTests.cs ---
using System;
using NUnit.Framework;
using DotNetMock.Dynamic;

namespace DotNetMock.tests.Dynamic
{
	[TestFixture]
	public class DynamicMockTest 
	{
		interface IBlah 
		{
			object DoStuff(string name);
		}
		
		[Test]
		public void DefaultDynamicMock()
		{
			IMock mock = new DynamicMock(typeof(IBlah));
			Assertion.AssertEquals("MockBlah", mock.Name);
			
			mock.ExpectAndReturn("DoStuff", "world", "hello");
			
			IBlah blah = (IBlah)mock.Object;
			Assertion.AssertEquals("world", blah.DoStuff("hello"));
			
			mock.Verify();
		}

		[Test]		
		public void NamedDynamicMock()
		{
			IMock mock = new DynamicMock(typeof(IBlah), "XBlah");
			Assertion.AssertEquals("XBlah", mock.Name);
			mock.Verify();
		}

		[Test]		
		public void CustomDynamicMock()
		{
			IMock mock = new CustomMock(typeof(IBlah));
			IBlah blah = (IBlah)mock.Object;
			Assertion.AssertEquals("CUSTOM", blah.DoStuff("hello"));
			mock.Verify();
		}

		private class CustomMock : DynamicMock
		{
			public CustomMock(Type t) : base(t) {}
			
			public override object Call(string name, params object[] args)
			{
				return "CUSTOM";
			}
		}
	}

}

--- NEW FILE: MockTests.cs ---
using System;
using NUnit.Framework;
using DotNetMock.Dynamic;

namespace DotNetMock.tests.Dynamic
{
	/// <summary>
	/// Summary description for MockTest.
	/// </summary>
	[TestFixture]
	public class MockTests
	{
		private IMock mock;

		[SetUp]
		public void SetUp() 
		{
			mock = new Mock("mymock");
		}

		[Test]
		public void Name() 
		{
			Assertion.AssertEquals("mymock", mock.Name);
		}
		
		[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(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]
		[ExpectedException(typeof(AssertionException))]
		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.AssertSame(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.AssertSame(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.AssertSame(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.AssertSame(something, mock.Call("myMethod"));
			Assertion.AssertSame(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");
		}
	}
}

--- NEW FILE: PredicateTests.cs ---
using System;
using System.Text.RegularExpressions;
using NUnit.Framework;
using DotNetMock.Dynamic;

namespace DotNetMock.tests.Dynamic
{
	/// <summary>
	/// Summary description for PredicateTests.
	/// </summary>
	public class PredicateTests
	{
		[TestFixture]
		public class PredicatesTest
		{
		
			private IPredicate p;
		
			[Test]
			public void IsNull() 
			{
				p = new IsNull();
				Assertion.Assert(p.eval(null));
				Assertion.Assert(!p.eval(new object()));
				Assertion.Assert(!p.eval(1));
				Assertion.Assert(!p.eval(true));
				Assertion.Assert(!p.eval(false));
			}
		
			[Test]
			public void NotNull() 
			{
				p = new NotNull();
				Assertion.Assert(!p.eval(null));
				Assertion.Assert(p.eval(new object()));
			}
		
			[Test]
			public void IsEqual()
			{
				object o1 = new object();
				object o2 = new object();
				p = new IsEqual(o1);
				Assertion.Assert(p.eval(o1));
				Assertion.Assert(!p.eval(o2));
				Assertion.Assert(!p.eval(null));

				int i1 = 1;
				int i2 = 2;
				p = new IsEqual(i1);
				Assertion.Assert(p.eval(i1));
				Assertion.Assert(p.eval(1));
				Assertion.Assert(!p.eval(i2));
				Assertion.Assert(!p.eval(2));
			}
	
			[Test]
			public void NotEqual() 
			{
				object o1 = new object();
				object o2 = new object();
				p = new NotEqual(o1);
				Assertion.Assert(!p.eval(o1));
				Assertion.Assert(p.eval(o2));
				Assertion.Assert(p.eval(null));

				int i1 = 1;
				int i2 = 2;
				p = new NotEqual(i1);
				Assertion.Assert(!p.eval(i1));
				Assertion.Assert(!p.eval(1));
				Assertion.Assert(p.eval(i2));
				Assertion.Assert(p.eval(2));
			}
	
			[Test]
			public void IsAnything()
			{
				p = new IsAnything();
				Assertion.Assert(p.eval(null));
				Assertion.Assert(p.eval(0));
				Assertion.Assert(p.eval(99));
				Assertion.Assert(p.eval(-2));
				Assertion.Assert(p.eval(true));
				Assertion.Assert(p.eval(false));
				Assertion.Assert(p.eval(""));
				Assertion.Assert(p.eval("hello"));
				Assertion.Assert(p.eval(new object()));
			}

			[Test]
			public void IsType()
			{
				p = new IsTypeOf(typeof(System.IO.TextReader));
				Assertion.Assert(!p.eval(null));
				Assertion.Assert(p.eval(new System.IO.StringReader("")));
				Assertion.Assert(!p.eval(new System.IO.StringWriter()));
			}
		
			[Test]
			public void Not()
			{
				Assertion.Assert(new Not(new False()).eval(null));
				Assertion.Assert(!new Not(new True()).eval(null));
			}
		
			[Test]
			public void And()
			{
				Assertion.Assert( new And(new True() , new True() ).eval(null));
				Assertion.Assert(!new And(new True() , new False()).eval(null));
				Assertion.Assert(!new And(new False(), new True() ).eval(null));
				Assertion.Assert(!new And(new False(), new False()).eval(null));
			}
		
			[Test]
			public void Or()
			{
				Assertion.Assert( new Or(new True() , new True() ).eval(null));
				Assertion.Assert( new Or(new True() , new False()).eval(null));
				Assertion.Assert( new Or(new False(), new True() ).eval(null));
				Assertion.Assert(!new Or(new False(), new False()).eval(null));
			}
		
			[Test]
			public void IsIn()
			{
				p = new IsIn(2, 3, 5);
				Assertion.Assert(!p.eval(1));
				Assertion.Assert(p.eval(2));
				Assertion.Assert(p.eval(3));
				Assertion.Assert(!p.eval(4));
				Assertion.Assert(p.eval(5));
				Assertion.Assert(!p.eval(6));
				Assertion.Assert(!p.eval(null));

				int[] array = {1, 2};
				p = new IsIn(array);
				Assertion.Assert(p.eval(1));
				Assertion.Assert(p.eval(2));
				Assertion.Assert(!p.eval(3));
			}
	
			[Test]
			public void NotIn()
			{
				p = new NotIn(1, 2);
				Assertion.Assert(!p.eval(1));
				Assertion.Assert(!p.eval(2));
				Assertion.Assert(p.eval(3));

				int[] array = {1, 2};
				p = new NotIn(array);
				Assertion.Assert(!p.eval(1));
				Assertion.Assert(!p.eval(2));
				Assertion.Assert(p.eval(3));
			}

			[Test]
			public void IsEqualIgnoreCase()
			{
				p = new IsEqualIgnoreCase("heLLo");
				Assertion.Assert(p.eval("HELLO"));
				Assertion.Assert(p.eval("hello"));
				Assertion.Assert(p.eval("HelLo"));
				Assertion.Assert(!p.eval("abcde"));
			}
		
			[Test]
			public void StripSpace()
			{
				Assertion.AssertEquals("Hello World", IsEqualIgnoreWhiteSpace.StripSpace("Hello\n  \n World"));
				Assertion.AssertEquals("Hello World", IsEqualIgnoreWhiteSpace.StripSpace(" Hello World "));
				Assertion.AssertEquals("", IsEqualIgnoreWhiteSpace.StripSpace("  "));
			}
		
			[Test]
			public void TestIsEqualIgnoreWhiteSpace()
			{
				p = new IsEqualIgnoreWhiteSpace("Hello World   how\n are we?");
				Assertion.Assert(p.eval("Hello World how are we?"));
				Assertion.Assert(p.eval("   Hello World   how are \n\n\twe?"));
				Assertion.Assert(!p.eval("HelloWorld how are we?"));
				Assertion.Assert(!p.eval("Hello World how are we"));
			}
		
			[Test]
			public void IsMatch()
			{
				p = new IsMatch(new Regex(@"^th[aeiou]\w* .*$"));
				Assertion.Assert(p.eval("the world"));
				Assertion.Assert(!p.eval("theworld"));
				Assertion.Assert(!p.eval("ThE world"));
				Assertion.Assert(!p.eval(" the world"));
				Assertion.Assert(p.eval("thats nice"));
				Assertion.Assert(!p.eval(new object()));
				Assertion.Assert(!p.eval(null));

				p = new IsMatch(@"^th[aeiou]\w* .*$");
				Assertion.Assert(p.eval("the world"));
				Assertion.Assert(!p.eval("theworld"));
				Assertion.Assert(!p.eval("ThE world"));

				p = new IsMatch(@"^th[aeiou]\w* .*$", false);
				Assertion.Assert(p.eval("the world"));
				Assertion.Assert(!p.eval("theworld"));
				Assertion.Assert(!p.eval("ThE world"));

				p = new IsMatch(@"^th[aeiou]\w* .*$", true);
				Assertion.Assert(p.eval("the world"));
				Assertion.Assert(!p.eval("theworld"));
				Assertion.Assert(p.eval("ThE world"));

			}
		
			[Test]
			public void Delegate()
			{
				p = new Predicate(new Predicate.Method(myEval));
				myFlag = false;
				Assertion.Assert(p.eval(null));
				Assertion.Assert(!p.eval(null));
				Assertion.Assert(p.eval(null));
				Assertion.Assert(!p.eval(null));
			}
		
			private bool myFlag;
		
			private bool myEval(object val)
			{
				myFlag = !myFlag;
				return myFlag;
			}
		
			class True : IPredicate 
			{
				public bool eval(object val)
				{
					return true;
				}
			}

			class False : IPredicate
			{
				public bool eval(object val)
				{
					return false;
				}
			}
		}
	}
}