dotnetmock-developer

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

Update of /cvsroot/dotnetmock/dotnetmock/DotNetMock.Framework.Tests/Xml/XPath
In directory sc8-pr-cvs1:/tmp/cvs-serv23859/DotNetMock.Framework.Tests/Xml/XPath

Added Files:
	MockXPathDocumentTests.cs MockXPathNavigatorTests.cs 
	MockXPathNodeIteratorTests.cs 
Log Message:
Added Mock Objects for System.Xml.XPath namespace: XPathDocument, XPathNavigator, XPathNodeIterator
Added MockObject & NUnitTest wizards
Added nunit.framework.dll to distribution
Fixed Master build install of VisualStudioTemplates
Added various comments and XML documentation to various classes


--- NEW FILE: MockXPathDocumentTests.cs ---
using System;
using System.Xml;
using System.Xml.XPath;
using NUnit.Framework;
using DotNetMock.Framework.Xml.XPath;

namespace DotNetMock.Tests.Xml.XPath
{
	[TestFixture]
	public class MockXPathDocumentTests
	{
		private class TestXPathNavigator : XPathNavigator 
		{
			
			public override string BaseURI
			{
				get
				{
					return null;
				}
			}

			public override System.Xml.XPath.XPathNavigator Clone()
			{
				return null;
			}

			public override string GetAttribute(string localName, string namespaceURI)
			{
				return null;
			}

			public override string GetNamespace(string name)
			{
				return null;
			}

			public override bool HasAttributes
			{
				get
				{
					return true;
				}
			}

			public override bool HasChildren
			{
				get
				{
					return true;
				}
			}

			public override bool IsEmptyElement
			{
				get
				{
					return true;
				}
			}

			public override bool IsSamePosition(System.Xml.XPath.XPathNavigator other)
			{
				return true;
			}

			public override string LocalName
			{
				get
				{
					return null;
				}
			}

			public override bool MoveTo(System.Xml.XPath.XPathNavigator other)
			{
				return true;
			}

			public override bool MoveToAttribute(string localName, string namespaceURI)
			{
				return true;
			}

			public override bool MoveToFirst()
			{
				return true;
			}

			public override bool MoveToFirstAttribute()
			{
				return true;
			}

			public override bool MoveToFirstChild()
			{
				return true;
			}

			public override bool MoveToFirstNamespace(System.Xml.XPath.XPathNamespaceScope namespaceScope)
			{
				return true;
			}

			public override bool MoveToId(string id)
			{
				return true;
			}

			public override bool MoveToNamespace(string name)
			{
				return true;
			}

			public override bool MoveToNext()
			{
				return true;
			}

			public override bool MoveToNextAttribute()
			{
				return true;
			}

			public override bool MoveToNextNamespace(System.Xml.XPath.XPathNamespaceScope namespaceScope)
			{
				return true;
			}

			public override bool MoveToParent()
			{
				return true;
			}

			public override void MoveToRoot()
			{
			
			}

			public override string Name
			{
				get
				{
					return null;
				}
			}

			public override string NamespaceURI
			{
				get
				{
					return null;
				}
			}

			public override System.Xml.XmlNameTable NameTable
			{
				get
				{
					return null;
				}
			}

			public override System.Xml.XPath.XPathNodeType NodeType
			{
				get
				{
					return new System.Xml.XPath.XPathNodeType();
				}
			}

			public override string Prefix
			{
				get
				{
					return null;
				}
			}

			public override string Value
			{
				get
				{
					return null;
				}
			}

			public override string XmlLang
			{
				get
				{
					return null;
				}
			}

			public override bool MoveToPrevious()
			{
				return true;
			}
		}

		private MockXPathDocument mockXD = null;

		[SetUp]
		public void init() 
		{
			mockXD = new MockXPathDocument();
		}
		[TearDown]
		public void Destroy() 
		{
			mockXD = null;
		}
		[Test]
		public void CreateNavigatorExpectedCount()
		{
			mockXD.SetExpectedCreateCalls(2);
			mockXD.CreateNavigator();
			mockXD.CreateNavigator();
			mockXD.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void CreateNavigatorExpectedCountFails() 
		{
			mockXD.SetExpectedCreateCalls(2);
			mockXD.CreateNavigator();
			mockXD.Verify();
		}
		[Test]
		[ExpectedException(typeof(XmlException))]
		public void ExceptionCreateNavigator() 
		{
			mockXD.SetExpectedCreateException(new XmlException("", null));
			mockXD.CreateNavigator();
		}
		[Test]
		public void ExpectedNavigator() 
		{
			XPathNavigator expectedNav = new TestXPathNavigator();
			mockXD.SetExpectedNavigator( expectedNav );
 			Assertion.AssertEquals("Navigators not equal.", expectedNav, mockXD.CreateNavigator());
		}
		[Test]
		public void DummyNavigator() 
		{
			XPathNavigator navigator = null;
			navigator = mockXD.CreateNavigator();
			Assertion.AssertNotNull( "Navigator should never be null.", navigator );
			Assertion.AssertEquals( "Navigators should equal.", typeof(XPathNavigator), navigator.GetType().BaseType );

		}
	}
}

--- NEW FILE: MockXPathNavigatorTests.cs ---
using System;
using NUnit.Framework;
using DotNetMock.Framework.Xml.XPath;
namespace DotNetMock.Framework.Tests.Xml.XPath
{
	[TestFixture]
	public class MockXPathNavigatorTests
	{
		private MockXPathNavigator mockNav = null;

		[SetUp]
		public void Init()
		{
			mockNav = new MockXPathNavigator();
		}
		[TearDown]
		public void Destroy()
		{
			mockNav = null;
		}
		[Test]
		public void SelectCalls()
		{
			mockNav.SetExpectedSelectCalls( 4 );
			mockNav.Select("");
			mockNav.Select("");
			mockNav.Select("");
			mockNav.Select("");
			mockNav.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InvalidSelectCalls()
		{
			mockNav.SetExpectedSelectCalls( 5 );
			mockNav.Select("");
			mockNav.Select("");
			mockNav.Verify();
		}
		[Test]
		public void IteratorNeverNull()
		{
			Assertion.AssertNotNull("Iterator is null!", mockNav.Select(""));
		}
		[Test]
		public void IteratorsEqual()
		{
			MockXPathNodeIterator it = new MockXPathNodeIterator();
			mockNav.SetExpectedIterator( it );
			Assertion.AssertEquals("Iterators do not equal.", it, mockNav.Select(""));
		}
		[Test]
		[ExpectedException(typeof(ArgumentException))]
		public void ThrowsSelectException()
		{
			mockNav.SetExpectedException( new ArgumentException() );
			mockNav.Select("");
		}
	}
}

--- NEW FILE: MockXPathNodeIteratorTests.cs ---
using System;
using System.Collections;
using DotNetMock.Framework.Xml.XPath;
using System.Xml.XPath;
using NUnit.Framework;

namespace DotNetMock.Framework.Tests.Xml.XPath
{
	[TestFixture]
	public class MockXPathNodeIteratorTests 
	{
		private MockXPathNodeIterator _iterator = null;

		[SetUp]
		public void Init() 
		{
			_iterator = new MockXPathNodeIterator();
		}
		[TearDown]
		public void Destroy()
		{
			_iterator = null;
		}
		[Test]
		public void MoveNextCount()
		{
			_iterator.SetExpectedMoveNextCalls( 3 );
			_iterator.MoveNext();
			_iterator.MoveNext();
			_iterator.MoveNext();
			_iterator.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InvalidMoveNextCount()
		{
			_iterator.SetExpectedMoveNextCalls( 3 );
			_iterator.MoveNext();
			_iterator.MoveNext();
			_iterator.Verify();
		}
		[Test]
		public void ValidCount()
		{
			Assertion.AssertEquals("Counts don't equal.", 0, _iterator.Count);
			SetValidAssumptions();
			Assertion.AssertEquals("Counts don't equal.", 3, _iterator.Count);
		}
		[Test]
		public void ValidCurrent()
		{
			SetValidAssumptions();
			Assertion.Assert(_iterator.MoveNext());
			Assertion.AssertNotNull("Current is null.", _iterator.Current);
			Assertion.Assert(_iterator.MoveNext());
			Assertion.AssertNotNull("Current is null.", _iterator.Current);
			Assertion.Assert(_iterator.MoveNext());
			Assertion.AssertNotNull("Current is null.", _iterator.Current);
			Assertion.Assert(!_iterator.MoveNext());
		}
		[Test]
		public void ValidCurrentPosition()
		{
			SetValidAssumptions();
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 0, _iterator.CurrentPosition);
			Assertion.Assert(_iterator.MoveNext());
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 1, _iterator.CurrentPosition);
			Assertion.Assert(_iterator.MoveNext());
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 2, _iterator.CurrentPosition);
			Assertion.Assert(_iterator.MoveNext());
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 3, _iterator.CurrentPosition);
			Assertion.Assert(!_iterator.MoveNext());
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 3, _iterator.CurrentPosition);

		}
		[Test]
		public void NoDataToIterateOver()
		{
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 0, _iterator.CurrentPosition);
			Assertion.Assert(!_iterator.MoveNext());
			Assertion.AssertEquals("CurrentPosition doesn't equal.", 0, _iterator.CurrentPosition);
		}
		private void SetValidAssumptions()
		{
			ArrayList expected = new ArrayList();
			expected.Add(new MockXPathNavigator());
			expected.Add(new MockXPathNavigator());
			expected.Add(new MockXPathNavigator());
			_iterator.SetExpectedData( expected );
		}
	}
}