Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

mcs/nunit24/NUnitMocks/mocks/AssemblyInfo.cs

@@ -0,0 +1,12 @@
+// ****************************************************************
+// This is free software licensed under the NUnit license. You
+// may obtain a copy of the license as well as information regarding
+// copyright ownership at http://nunit.org/?p=license&r=2.4.
+// ****************************************************************
+
+using System;
+using System.Reflection;
+
+[assembly: AssemblyDelaySign(false)]
+[assembly: AssemblyKeyFile("../../nunit.snk")]
+[assembly: AssemblyKeyName("")]

mcs/nunit24/NUnitMocks/mocks/DynamicMock.cs

@@ -0,0 +1,47 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// Summary description for DynamicMock.
+	/// </summary>
+	public class DynamicMock : Mock
+	{
+		private Type type;
+
+		private object mockInstance;
+
+		public object MockInstance
+		{
+			get 
+			{ 
+				if ( mockInstance == null )
+				{
+					MockInterfaceHandler handler = new MockInterfaceHandler( type, this );
+					mockInstance = handler.GetTransparentProxy();
+				}
+
+				return mockInstance; 
+			}
+		}
+
+		#region Constructors
+
+		public DynamicMock( Type type ) : this( "Mock" + type.Name, type ) { }
+
+		public DynamicMock( string name, Type type ) : base( name )
+		{
+//			if ( !type.IsInterface )
+//				throw new VerifyException( "DynamicMock constructor requires an interface type" );
+			this.type = type;
+		}
+
+		#endregion
+	}
+}

mcs/nunit24/NUnitMocks/mocks/ICall.cs

@@ -0,0 +1,24 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// The ICall interface is implemented by objects that can be called
+	/// with an array of arguments and return a value.
+	/// </summary>
+	public interface ICall
+	{
+		/// <summary>
+		/// Process a call with a possibly empty set of arguments.
+		/// </summary>
+		/// <param name="args">Arguments for this call</param>
+		/// <returns>An implementation-defined return value</returns>
+		object Call( object[] args );
+	}
+}

mcs/nunit24/NUnitMocks/mocks/ICallHandler.cs

@@ -0,0 +1,25 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// The ICallHandler interface dispatches calls to methods or
+	/// other objects implementing the ICall interface.
+	/// </summary>
+	public interface ICallHandler
+	{		
+		/// <summary>
+		/// Simulate a method call on the mocked object.
+		/// </summary>
+		/// <param name="methodName">The name of the method</param>
+		/// <param name="args">Arguments for this call</param>
+		/// <returns>Previously specified object or null</returns>
+		object Call( string methodName, params object[] args );
+	}
+}

mcs/nunit24/NUnitMocks/mocks/IMethod.cs

@@ -0,0 +1,28 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// The IMethod interface represents an method or other named object that 
+	/// is both callable and self-verifying.
+	/// </summary>
+	public interface IMethod : IVerify, ICall
+	{
+		/// <summary>
+		/// The name of the object
+		/// </summary>
+		string Name { get; }
+
+		/// <summary>
+		/// Tell the object to expect a certain call.
+		/// </summary>
+		/// <param name="call"></param>
+		void Expect( ICall call );
+	}
+}

mcs/nunit24/NUnitMocks/mocks/IMock.cs

@@ -0,0 +1,66 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// Summary description for IMock.
+	/// </summary>
+	public interface IMock : IVerify, ICallHandler
+	{
+		/// <summary>
+		/// The name of this mock - used in messages
+		/// </summary>
+		string Name { get; }
+	
+		/// <summary>
+		/// True if unexpected calls should cause an error, false to ignore them
+		/// </summary>
+		bool Strict { get; set; }
+
+		/// <summary>
+		/// Set up to expect a call to a method with a set of arguments
+		/// </summary>
+		/// <param name="methodName">The name of the method</param>
+		/// <param name="args">Arguments for this call</param>
+		void Expect( string methodName, params object[] args );
+
+		void Expect( string MethodName );
+
+		/// <summary>
+		/// Set up expectation that the named method will not be called
+		/// </summary>
+		/// <param name="methodName">The name of the method</param>
+		void ExpectNoCall( string methodName );
+
+		/// <summary>
+		/// Set up to expect a call to a method with a set of arguments.
+		/// The specified value will be returned.
+		/// </summary>
+		/// <param name="methodName">The name of the method</param>
+		/// <param name="returnVal">The value to be returned</param>
+		/// <param name="args">Arguments for this call</param>
+		void ExpectAndReturn( string methodName, object returnVal, params object[] args );
+
+		/// <summary>
+		/// Set up to expect a call to a method with a set of arguments.
+		/// The specified exception will be thrown.
+		/// </summary>
+		/// <param name="methodname">The name of the method</param>
+		/// <param name="exception">The exception to throw</param>
+		/// <param name="args">Arguments for this call</param>
+		void ExpectAndThrow( string methodname, Exception exception, params object[] args );
+
+		/// <summary>
+		/// Set value to return for a method or property called with any arguments
+		/// </summary>
+		/// <param name="methodName">The name of the method</param>
+		/// <param name="returnVal">The value to be returned</param>
+		void SetReturnValue( string methodName, object returnVal );
+	}
+}

mcs/nunit24/NUnitMocks/mocks/IVerify.cs

@@ -0,0 +1,18 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// The IVerify interface is implemented by objects capable of self-verification.
+	/// </summary>
+	public interface IVerify
+	{
+		void Verify();
+	}
+}

mcs/nunit24/NUnitMocks/mocks/Makefile

@@ -0,0 +1,29 @@
+thisdir = nunit24/NUnitMocks/mocks
+SUBDIRS = 
+include ../../../build/rules.make
+
+LIBRARY = nunit.mocks.dll
+LIBRARY_SNK = $(topdir)/nunit24/nunit.snk
+
+LOCAL_MCS_FLAGS= -debug -r:nunit.framework.dll -r:System.dll /d:StronglyNamedAssembly
+NO_TEST = yo
+
+ifneq (net_2_0, $(PROFILE))
+NO_INSTALL = yes
+install-local: install-symlink
+uninstall-local: uninstall-symlink
+endif
+
+EXTRA_DISTFILES = \
+	nunit.mocks.csproj \
+	nunit.mocks_VS2005.csproj
+
+include ../../../build/library.make
+
+symlinkdir = $(mono_libdir)/mono/$(FRAMEWORK_VERSION)
+install-symlink:
+	$(MKINSTALLDIRS) $(DESTDIR)$(symlinkdir)
+	cd $(DESTDIR)$(symlinkdir) && rm -f $(LIBRARY_NAME) && ln -s ../2.0/$(LIBRARY_NAME) $(LIBRARY_NAME)
+
+uninstall-symlink:
+	rm -f $(DESTDIR)$(symlinkdir)/$(LIBRARY_NAME)

mcs/nunit24/NUnitMocks/mocks/MethodSignature.cs

@@ -0,0 +1,56 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// Summary description for MockSignature.
+	/// </summary>
+	public class MethodSignature
+	{
+		public readonly string typeName;
+		public readonly string methodName;
+		public readonly Type[] argTypes;
+
+		public MethodSignature( string typeName, string methodName, Type[] argTypes )
+		{
+			this.typeName = typeName;
+			this.methodName = methodName;
+			this.argTypes = argTypes; 
+		}
+
+		public bool IsCompatibleWith( object[] args )
+		{
+			if ( args.Length != argTypes.Length )
+				return false;
+
+			for( int i = 0; i < args.Length; i++ )
+				if ( !argTypes[i].IsAssignableFrom( args[i].GetType() ) )
+					return false;
+
+			return true;
+		}
+
+		public static Type[] GetArgTypes( object[] args )
+		{
+			if ( args == null )
+				return new Type[0];
+
+			Type[] argTypes = new Type[args.Length];
+			for (int i = 0; i < argTypes.Length; ++i)
+			{
+				if (args[i] == null)
+					argTypes[i] = typeof(object);
+				else
+					argTypes[i] = args[i].GetType();
+			}
+
+			return argTypes;
+		}
+	}
+}

mcs/nunit24/NUnitMocks/mocks/Mock.cs

@@ -0,0 +1,155 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+using System.Collections;
+using System.Runtime.Remoting.Proxies;
+using System.Runtime.Remoting.Messaging;
+using NUnit.Framework;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// Summary description for MockObject.
+	/// </summary>
+	public class Mock : IMock
+	{
+		#region Private Fields
+
+		private string name;
+
+		private bool strict;
+
+		private IDictionary methods = new Hashtable();
+
+		private Exception lastException;
+
+		#endregion
+
+		#region Properties
+
+		public Exception LastException
+		{
+			get { return lastException; }
+		}
+
+		#endregion
+
+		#region Constructors
+
+		public Mock() : this( "Mock" ) { }
+
+		public Mock( string name )
+		{
+			this.name = name;
+		}
+
+		#endregion
+
+		#region IMock Members
+
+		public string Name
+		{
+			get { return name; }
+		}
+
+		public bool Strict
+		{
+			get { return strict; }
+			set { strict = value; }
+		}
+
+		public void Expect( string methodName, params object[] args )
+		{
+			ExpectAndReturn( methodName, null, args );
+		}
+
+		public void Expect( string methodName )
+		{
+			ExpectAndReturn( methodName, null, null );
+		}
+
+		public void ExpectNoCall( string methodName )
+		{
+			methods[methodName] = new MockMethod( methodName, null, 
+				new AssertionException("Unexpected call to method " + methodName) );
+		}
+
+		public void ExpectAndReturn( string methodName, object returnVal, params object[] args )
+		{
+			AddExpectedCall( methodName, returnVal, null, args );
+		}
+
+		public void ExpectAndThrow( string methodName, Exception exception, params object[] args )
+		{
+			AddExpectedCall( methodName, null, exception, args );
+		}
+
+		public void SetReturnValue( string methodName, object returnVal )
+		{
+			methods[methodName] = new MockMethod( methodName, returnVal );
+		}
+
+		#endregion
+
+		#region IVerify Members
+
+		public virtual void Verify()
+		{
+			foreach( IMethod method in methods.Values )
+				method.Verify();
+		}
+
+		#endregion
+
+		#region ICallHandler Members
+
+		public virtual object Call( string methodName, params object[] args )
+		{
+			if ( methods.Contains( methodName ) )
+			{
+				try
+				{
+					IMethod method = (IMethod)methods[methodName];
+					return method.Call( args );
+				}
+				catch( Exception exception )
+				{
+					// Save exception in case MO is running on a separate thread
+					lastException = exception;
+					throw;
+				}
+			}
+			else // methodName is not listed in methods
+			if ( Strict )
+				Assert.Fail( "Unexpected call to " + methodName );
+			
+			// not listed but Strict is not specified
+			return null;
+		}
+
+		#endregion
+	
+		#region Helper Methods
+
+		private void AddExpectedCall( string methodName, object returnVal, Exception exception, object[] args )
+		{
+			IMethod method = (IMethod)methods[methodName];
+			if ( method == null )
+			{
+				method = new MockMethod( methodName );
+				methods[methodName] = method;
+			}
+
+			Type[] argTypes = MethodSignature.GetArgTypes( args );
+			MethodSignature signature = new MethodSignature( this.Name, methodName, argTypes );
+
+			method.Expect( new MockCall( signature, returnVal, exception, args ) );
+		}
+
+		#endregion
+	}
+}

mcs/nunit24/NUnitMocks/mocks/MockCall.cs

@@ -0,0 +1,54 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// Summary description for ExpectedCall.
+	/// </summary>
+	public class MockCall : ICall
+	{
+		private MethodSignature signature;
+		private object returnVal;
+		private Exception exception;
+		private object[] expectedArgs;
+
+//		public static object[] Any = new object[0];
+
+		public MockCall( MethodSignature signature, object  returnVal, Exception exception, params object[] args )
+		{
+			this.signature = signature;
+			this.returnVal = returnVal;
+			this.exception = exception;
+			this.expectedArgs = args;
+		}
+
+		public object Call( object[] actualArgs )
+		{
+			if ( expectedArgs != null )
+			{
+				Assert.AreEqual( expectedArgs.Length, actualArgs.Length, "Invalid argument count in call to {0}", this.signature.methodName );
+
+				for( int i = 0; i < expectedArgs.Length; i++ )
+				{
+					if ( expectedArgs[i] is Constraint )
+						Assert.That( actualArgs[i], (Constraint)expectedArgs[i] );
+					else
+						Assert.AreEqual( expectedArgs[i], actualArgs[i] );
+				}
+			}
+			
+			if ( exception != null )
+				throw exception;
+
+			return returnVal;
+		}
+	}
+}

mcs/nunit24/NUnitMocks/mocks/MockInterfaceHandler.cs

@@ -0,0 +1,72 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+using System.Collections;
+using System.Runtime.Remoting.Proxies;
+using System.Runtime.Remoting.Messaging;
+using System.Reflection;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// Summary description for MockInterfaceHandler.
+	/// </summary>
+	public class MockInterfaceHandler : RealProxy
+	{
+		private ICallHandler callHandler;
+
+		public MockInterfaceHandler( Type type, ICallHandler callHandler ) : base( type ) 
+		{ 
+			this.callHandler = callHandler;
+		}
+
+		public override IMessage Invoke( IMessage msg )
+		{
+			IMethodCallMessage call = (IMethodCallMessage)msg;
+			IMethodReturnMessage result = null; 
+
+			if ( call != null )
+			{
+				try
+				{
+					object ret = callHandler.Call( call.MethodName, call.Args );
+
+					if ( ret == null )
+					{
+						MethodInfo info = call.MethodBase as MethodInfo;
+						Type returnType = info.ReturnType;
+
+						if( returnType == typeof( System.Boolean ) ) ret = false; 
+
+						if( returnType == typeof( System.Byte    ) ) ret = (System.Byte)0;
+						if( returnType == typeof( System.SByte   ) ) ret = (System.SByte)0;
+						if( returnType == typeof( System.Decimal ) ) ret = (System.Decimal)0;
+						if( returnType == typeof( System.Double  ) ) ret = (System.Double)0;
+						if( returnType == typeof( System.Single  ) ) ret = (System.Single)0;
+						if( returnType == typeof( System.Int32   ) ) ret = (System.Int32)0;
+						if( returnType == typeof( System.UInt32  ) ) ret = (System.UInt32)0;
+						if( returnType == typeof( System.Int64   ) ) ret = (System.Int64)0;
+						if( returnType == typeof( System.UInt64  ) ) ret = (System.UInt64)0;
+						if( returnType == typeof( System.Int16   ) ) ret = (System.Int16)0;
+						if( returnType == typeof( System.UInt16  ) ) ret = (System.UInt16)0;
+
+						if( returnType == typeof( System.Char	 ) ) ret = '?';
+					}
+
+					result = new ReturnMessage( ret, null, 0, null, call );
+				} 
+				catch( Exception e )
+				{
+					result = new ReturnMessage( e, call );
+				}
+			}
+
+			return result;
+		}
+	}
+}
+

mcs/nunit24/NUnitMocks/mocks/MockMethod.cs

@@ -0,0 +1,119 @@
+// ****************************************************************
+// Copyright 2007, Charlie Poole
+// This is free software licensed under the NUnit license. You may
+// obtain a copy of the license at http://nunit.org/?p=license&r=2.4
+// ****************************************************************
+
+using System;
+using System.Collections;
+using NUnit.Framework;
+
+namespace NUnit.Mocks
+{
+	/// <summary>
+	/// The MockMethod object represents one named method on a mock object.
+	/// All overloads are represented by one MockMethod. A method may return
+	/// a fixed value, throw a fixed exception or have an expected sequence
+	/// of calls. If it has a call sequence, then the signature must match and
+	/// each call provides it's own return value or exception.
+	/// </summary>
+	public class MockMethod : IMethod
+	{
+		#region Private Fields
+
+		/// <summary>
+		/// Name of this method
+		/// </summary>
+		private string methodName;
+		
+		/// <summary>
+		/// Fixed return value
+		/// </summary>
+		private object returnVal;
+		
+		/// <summary>
+		/// Exception to be thrown
+		/// </summary>
+		private Exception exception;
+
+		/// <summary>
+		/// Expected call sequence. If null, this method has no expectations
+		/// and simply provides a fixed return value or exception.
+		/// </summary>
+		private ArrayList expectedCalls = null;
+		
+		/// <summary>
+		/// Actual sequence of calls... currently not used
+		/// </summary>
+		//private ArrayList actualCalls = null;
+
+		#endregion
+
+		#region Constructors
+
+		public MockMethod( string methodName ) 
+			: this( methodName, null, null ) { }
+
+		public MockMethod( string methodName, object returnVal ) 
+			: this( methodName, returnVal, null ) { }
+
+		public MockMethod( string methodName, object returnVal, Exception exception )
+		{
+			this.methodName = methodName;
+			this.returnVal = returnVal;
+			this.exception = exception;
+		}
+
+		#endregion
+
+		#region IMethod Members
+
+		public string Name
+		{
+			get { return methodName; }
+		}
+
+		public void Expect( ICall call )
+		{
+			if ( expectedCalls == null )
+				expectedCalls = new ArrayList();
+
+			expectedCalls.Add( call );
+		}
+
+		#endregion
+
+		#region ICall Members
+
+		public object Call( object[] args )
+		{
+			if ( expectedCalls == null )
+			{
+				if ( exception != null )
+					throw exception;
+
+				return returnVal;
+			}
+			else
+			{
+				//actualCalls.Add( new MethodCall( methodName, null, null, args ) );
+				Assert.IsTrue( expectedCalls.Count > 0, "Too many calls to " + Name );
+				MockCall mockCall = (MockCall)expectedCalls[0];
+				expectedCalls.RemoveAt( 0 );
+				return mockCall.Call( args );
+			}
+		}
+
+		#endregion
+
+		#region IVerify Members
+
+		public void Verify()
+		{
+			if ( expectedCalls != null )
+				Assert.IsTrue( expectedCalls.Count == 0, "Not all methods were called" );
+		}
+
+		#endregion
+	}
+}

mcs/nunit24/NUnitMocks/mocks/nunit.mocks.csproj

@@ -0,0 +1,161 @@
+<VisualStudioProject>
+    <CSHARP
+        ProjectType = "Local"
+        ProductVersion = "7.10.3077"
+        SchemaVersion = "2.0"
+        ProjectGuid = "{EEE7C98B-23E6-472D-9036-C2D53B0DFE7C}"
+    >
+        <Build>
+            <Settings
+                ApplicationIcon = ""
+                AssemblyKeyContainerName = ""
+                AssemblyName = "nunit.mocks"
+                AssemblyOriginatorKeyFile = ""
+                DefaultClientScript = "JScript"
+                DefaultHTMLPageLayout = "Grid"
+                DefaultTargetSchema = "IE50"
+                DelaySign = "false"
+                OutputType = "Library"
+                PreBuildEvent = ""
+                PostBuildEvent = ""
+                RootNamespace = "NUnit.Mocks"
+                RunPostBuildEvent = "OnBuildSuccess"
+                StartupObject = ""
+            >
+                <Config
+                    Name = "Debug"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "DEBUG;TRACE"
+                    DocumentationFile = ""
+                    DebugSymbols = "true"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "false"
+                    NoStdLib = "false"
+                    NoWarn = ""
+                    Optimize = "false"
+                    OutputPath = "bin\Debug\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+                <Config
+                    Name = "Release"
+                    AllowUnsafeBlocks = "false"
+                    BaseAddress = "285212672"
+                    CheckForOverflowUnderflow = "false"
+                    ConfigurationOverrideFile = ""
+                    DefineConstants = "TRACE"
+                    DocumentationFile = ""
+                    DebugSymbols = "false"
+                    FileAlignment = "4096"
+                    IncrementalBuild = "false"
+                    NoStdLib = "false"
+                    NoWarn = ""
+                    Optimize = "true"
+                    OutputPath = "bin\Release\"
+                    RegisterForComInterop = "false"
+                    RemoveIntegerChecks = "false"
+                    TreatWarningsAsErrors = "false"
+                    WarningLevel = "4"
+                />
+            </Settings>
+            <References>
+                <Reference
+                    Name = "System"
+                    AssemblyName = "System"
+                    HintPath = "c:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
+                />
+                <Reference
+                    Name = "System.Data"
+                    AssemblyName = "System.Data"
+                    HintPath = "c:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
+                />
+                <Reference
+                    Name = "System.XML"
+                    AssemblyName = "System.Xml"
+                    HintPath = "c:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
+                />
+                <Reference
+                    Name = "nunit.framework.dll"
+                    Project = "{83DD7E12-A705-4DBA-9D71-09C8973D9382}"
+                    Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
+                />
+            </References>
+        </Build>
+        <Files>
+            <Include>
+                <File
+                    RelPath = "AssemblyInfo.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "CommonAssemblyInfo.cs"
+                    Link = "..\..\CommonAssemblyInfo.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "DynamicMock.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "ICall.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "ICallHandler.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "IMethod.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "IMock.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "IVerify.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "MethodSignature.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "Mock.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "MockCall.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "MockInterfaceHandler.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+                <File
+                    RelPath = "MockMethod.cs"
+                    SubType = "Code"
+                    BuildAction = "Compile"
+                />
+            </Include>
+        </Files>
+    </CSHARP>
+</VisualStudioProject>
+

mcs/nunit24/NUnitMocks/mocks/nunit.mocks.dll.sources

@@ -0,0 +1,13 @@
+../../CommonAssemblyInfo.cs
+AssemblyInfo.cs
+DynamicMock.cs
+ICall.cs
+ICallHandler.cs
+IMethod.cs
+IMock.cs
+IVerify.cs
+MethodSignature.cs
+Mock.cs
+MockCall.cs
+MockInterfaceHandler.cs
+MockMethod.cs

mcs/nunit24/NUnitMocks/mocks/nunit.mocks_VS2005.csproj

@@ -0,0 +1,107 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ProjectType>Local</ProjectType>
+    <ProductVersion>8.0.50727</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EEE7C98B-23E6-472D-9036-C2D53B0DFE7C}</ProjectGuid>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ApplicationIcon>
+    </ApplicationIcon>
+    <AssemblyKeyContainerName>
+    </AssemblyKeyContainerName>
+    <AssemblyName>nunit.mocks</AssemblyName>
+    <AssemblyOriginatorKeyFile>
+    </AssemblyOriginatorKeyFile>
+    <DefaultClientScript>JScript</DefaultClientScript>
+    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>
+    <DefaultTargetSchema>IE50</DefaultTargetSchema>
+    <DelaySign>false</DelaySign>
+    <OutputType>Library</OutputType>
+    <RootNamespace>NUnit.Mocks</RootNamespace>
+    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
+    <StartupObject>
+    </StartupObject>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release2005|AnyCPU' ">
+    <OutputPath>bin\Release2005\</OutputPath>
+    <DefineConstants>TRACE;VS2005</DefineConstants>
+    <BaseAddress>285212672</BaseAddress>
+    <Optimize>true</Optimize>
+    <NoWarn>1699</NoWarn>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug2005|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\Debug2005\</OutputPath>
+    <DefineConstants>TRACE;DEBUG;VS2005</DefineConstants>
+    <BaseAddress>285212672</BaseAddress>
+    <NoWarn>1699</NoWarn>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System">
+      <Name>System</Name>
+    </Reference>
+    <Reference Include="System.Data">
+      <Name>System.Data</Name>
+    </Reference>
+    <Reference Include="System.Xml">
+      <Name>System.XML</Name>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\CommonAssemblyInfo.cs">
+      <Link>CommonAssemblyInfo.cs</Link>
+    </Compile>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="DynamicMock.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ICall.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="ICallHandler.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="IMethod.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="IMock.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="IVerify.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MethodSignature.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Mock.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MockCall.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MockInterfaceHandler.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="MockMethod.cs">
+      <SubType>Code</SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\NUnitFramework\framework\nunit.framework.dll_VS2005.csproj">
+      <Project>{83DD7E12-A705-4DBA-9D71-09C8973D9382}</Project>
+      <Name>nunit.framework.dll_VS2005</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>
+    </PreBuildEvent>
+    <PostBuildEvent>
+    </PostBuildEvent>
+  </PropertyGroup>
+</Project>