[prev in list] [next in list] [prev in thread] [next in thread] 

List:       mono-devel-list
Subject:    Re: [Mono-dev] Patch 2/2 - Tests for System.Diagnostics.Contracts
From:       Chris Bacon <chris () dunelm ! org ! uk>
Date:       2010-06-27 12:24:48
Message-ID: 4C274310.40900 () dunelm ! org ! uk
[Download RAW message or body]

[Attachment #2 (multipart/alternative)]


Hi,

Last Thursday, 24th, I followed these instructions and sent my public 
SSH key to miguel@ximian.com.
Should I expect to hear something back?

Thanks
Chris

Miguel de Icaza wrote:
> Hey Chris,
> 
> Could you get these commited yourself?
> 
> For this you will need an SVN key, follow the steps here:
> 
> 	www.mono-project.com/SVN
> 
> 
> > Hi,
> > 
> > Updated patch attached. I've checked that all tests still pass.
> > 
> > The delegate has been removed, and #if NET_4_0 now surrounds the whole 
> > of each file.
> > 
> > However, the #defines are not un-defined at the end of each file, as I 
> > don't think this is possible in C#, as all #define and #undef statements 
> > have to be before any code. Please let me know if there is a way of 
> > #undef-ing another way.
> > 
> > Thanks
> > Chris
> > 
> > Marek Safar wrote:
> > 
> > > Hello Chris,
> > > 
> > > Only a few small issues
> > > 
> > > +#define CONTRACTS_FULL
> > > +#define DEBUG
> > > +
> > > 
> > > Undefined these at the end of each file. They perhaps should be inside 
> > > #if NET_4_0 too.
> > > 
> > > +        // Required when compiling/running under .NET3.5
> > > +        delegate void Action<T1, T2, T3, T4, T5> (T1 arg1, T2 arg2, 
> > > T3 arg3, T4 arg4, T5 arg5);
> > > +
> > > 
> > > Why is it needed when NET_4_0 is used for whole file ?
> > > 
> > > When fixed please commit. Thanks!
> > > 
> > > Marek
> > > 
> > > 
> > > > Hi,
> > > > I've attached a new patch with slightly better formatting - it uses 
> > > > tabs rather than spaces.
> > > > Kind regards
> > > > Chris
> > > > 
> > > > Chris Bacon wrote:
> > > > 
> > > > > Hi,
> > > > > 
> > > > > Here are the tests to add to corlib for System.Diagnostics.Contracts.
> > > > > 
> > > > > Please let me know what changes are required.
> > > > > 
> > > > > Kind regards
> > > > > Chris
> > > > > ------------------------------------------------------------------------ 
> > > > > 
> > > > > 
> > > > > _______________________________________________
> > > > > Mono-devel-list mailing list
> > > > > Mono-devel-list@lists.ximian.com
> > > > > http://lists.ximian.com/mailman/listinfo/mono-devel-list
> > > > > 
> > > > ------------------------------------------------------------------------
> > > > 
> > > > _______________________________________________
> > > > Mono-devel-list mailing list
> > > > Mono-devel-list@lists.ximian.com
> > > > http://lists.ximian.com/mailman/listinfo/mono-devel-list
> > > > 
> > plain text document attachment (CodeContractsTest.patch)
> > Index: corlib_test.dll.sources
> > ===================================================================
> > --- corlib_test.dll.sources	(revision 159418)
> > +++ corlib_test.dll.sources	(working copy)
> > @@ -60,6 +60,14 @@
> > System.Diagnostics/StackFrameTest.cs
> > System.Diagnostics/StackTraceTest.cs
> > System.Diagnostics/TextWriterTraceListenerTest.cs
> > +System.Diagnostics.Contracts/ContractAssertTest.cs
> > +System.Diagnostics.Contracts/ContractAssumeTest.cs
> > +System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs
> > +System.Diagnostics.Contracts/ContractHelperTest.cs
> > +System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs
> > +System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs
> > +System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs
> > +System.Diagnostics.Contracts/Helpers/TestContractBase.cs
> > System/DoubleFormatterTest.cs
> > System/DoubleTest.cs
> > System/EnumTest.cs
> > Index: Test/System.Diagnostics.Contracts/ContractAssumeTest.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ContractAssumeTest.cs	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/ContractAssumeTest.cs	(revision 0)
> > @@ -0,0 +1,47 @@
> > +#if NET_4_0
> > +
> > +#define CONTRACTS_FULL
> > +#define DEBUG
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using System.Diagnostics.Contracts;
> > +using MonoTests.System.Diagnostics.Contracts.Helpers;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts {
> > +
> > +	[TestFixture]
> > +	public class ContractAssumeTest : TestContractBase {
> > +
> > +		/// <summary>
> > +		/// At runtime Contract.Assume() acts just like a Contract.Assert(), except \
> > the exact message in the assert +		/// or exception is slightly different.
> > +		/// </summary>
> > +		[Test]
> > +		public void TestAssumeMessage ()
> > +		{
> > +			try {
> > +				Contract.Assume (false);
> > +				Assert.Fail ("TestAssumeMessage() exception not thrown #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof(NotImplementedException), ex, \
> > "TestAssumeMessage() wrong exception type #1"); +			}
> > +
> > +			try {
> > +				Contract.Assume (false, "Message");
> > +				Assert.Fail ("TestAssumeMessage() exception not thrown #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof(NotImplementedException), ex, \
> > "TestAssumeMessage() wrong exception type #1"); +			}
> > +		}
> > +
> > +		// Identical to Contract.Assert, so no more testing required.
> > +
> > +	}
> > +
> > +}
> > +
> > +#endif
> > 
> > Property changes on: Test/System.Diagnostics.Contracts/ContractAssumeTest.cs
> > ___________________________________________________________________
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs	(revision \
> >                 0)
> > +++ Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs	(revision \
> > 0) @@ -0,0 +1,129 @@
> > +#if NET_4_0
> > +
> > +#define CONTRACTS_FULL
> > +#define DEBUG
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using MonoTests.System.Diagnostics.Contracts.Helpers;
> > +using System.Diagnostics.Contracts;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts {
> > +
> > +	[TestFixture]
> > +	public class ContractCollectionMethodsTest {
> > +
> > +		/// <summary>
> > +		/// Contract.Exists() determines that at least one element in the collection \
> > satisfies the predicate. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestExistsInt ()
> > +		{
> > +			try {
> > +				Contract.Exists (0, 10, null);
> > +				Assert.Fail ("TestExistsInt() no exception #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
> > "TestExistsInt() wrong exception #1"); +			}
> > +
> > +			try {
> > +				Contract.Exists (10, 0, i => false);
> > +				Assert.Fail ("TestExistsInt() no exception #2");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentException), ex, "TestExistsInt() \
> > wrong exception #2"); +			}
> > +
> > +			Assert.IsTrue (Contract.Exists (0, 10, i => i <= 0), "TestExistsInt() #1");
> > +			Assert.IsTrue (Contract.Exists (0, 10, i => i >= 9), "TestExistsInt() #2");
> > +			Assert.IsFalse (Contract.Exists (0, 10, i => i < 0), "TestExistsInt() #3");
> > +			Assert.IsFalse (Contract.Exists (0, 10, i => i > 9), "TestExistsInt() #4");
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Exists() determines that at least one element in the collection \
> > satisfies the predicate. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestExistsEnumeration ()
> > +		{
> > +			try {
> > +				Contract.Exists (Enumerable.Range (0, 10), null);
> > +				Assert.Fail ("TestExistsEnumeration() no exception #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
> > "TestExistsEnumeration() wrong exception #1"); +			}
> > +
> > +			try {
> > +				Contract.Exists<int> (null, x => false);
> > +				Assert.Fail ("TestExistsEnumeration() no exception #2");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
> > "TestExistsEnumeration() wrong exception #2"); +			}
> > +
> > +			var en = Enumerable.Range (0, 10);
> > +			Assert.IsTrue (Contract.Exists (en, i => i <= 0), "TestExistsEnumeration() \
> > #1"); +			Assert.IsTrue (Contract.Exists (en, i => i >= 9), \
> > "TestExistsEnumeration() #2"); +			Assert.IsFalse (Contract.Exists (en, i => i < \
> > 0), "TestExistsEnumeration() #3"); +			Assert.IsFalse (Contract.Exists (en, i => \
> > i > 9), "TestExistsEnumeration() #4"); +		}
> > +
> > +		/// <summary>
> > +		/// Contract.ForAll() determines if all elements in the collection satisfy the \
> > predicate. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestForAllInt ()
> > +		{
> > +			try {
> > +				Contract.ForAll (0, 10, null);
> > +				Assert.Fail ("TestForAllInt() no exception #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
> > "TestForAllInt() wrong exception #1"); +			}
> > +
> > +			try {
> > +				Contract.ForAll (10, 0, i => false);
> > +				Assert.Fail ("TestForAllInt() no exception #2");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentException), ex, "TestForAllInt() \
> > wrong exception #2"); +			}
> > +
> > +			Assert.IsTrue (Contract.ForAll (0, 10, i => i <= 9), "TestForAllInt() #1");
> > +			Assert.IsTrue (Contract.ForAll (0, 10, i => i >= 0), "TestForAllInt() #2");
> > +			Assert.IsFalse (Contract.ForAll (0, 10, i => i < 9), "TestForAllInt() #3");
> > +			Assert.IsFalse (Contract.ForAll (0, 10, i => i > 0), "TestForAllInt() #4");
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.ForAll() determines if all elements in the collection satisfy the \
> > predicate. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestForAllEnumeration ()
> > +		{
> > +			try {
> > +				Contract.ForAll (Enumerable.Range (0, 10), null);
> > +				Assert.Fail ("TestForAllEnumeration() no exception #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
> > "TestForAllEnumeration() wrong exception #1"); +			}
> > +
> > +			try {
> > +				Contract.ForAll<int> (null, x => false);
> > +				Assert.Fail ("TestForAllEnumeration() no exception #2");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
> > "TestForAllEnumeration() wrong exception #2"); +			}
> > +
> > +			var en = Enumerable.Range (0, 10);
> > +			Assert.IsTrue (Contract.ForAll (en, i => i <= 9), "TestForAllEnumeration() \
> > #1"); +			Assert.IsTrue (Contract.ForAll (en, i => i >= 0), \
> > "TestForAllEnumeration() #2"); +			Assert.IsFalse (Contract.ForAll (en, i => i < \
> > 9), "TestForAllEnumeration() #3"); +			Assert.IsFalse (Contract.ForAll (en, i => \
> > i > 0), "TestForAllEnumeration() #4"); +		}
> > +
> > +	}
> > +
> > +}
> > +
> > +#endif
> > 
> > Property changes on: \
> > Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs \
> >                 ___________________________________________________________________
> >                 
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/ContractHelperTest.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ContractHelperTest.cs	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/ContractHelperTest.cs	(revision 0)
> > @@ -0,0 +1,258 @@
> > +#if NET_4_0
> > +
> > +#define CONTRACTS_FULL
> > +#define DEBUG
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using System.Diagnostics.Contracts.Internal;
> > +using System.Diagnostics.Contracts;
> > +using MonoTests.System.Diagnostics.Contracts.Helpers;
> > +using NUnit.Framework.Constraints;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts {
> > +
> > +	[TestFixture]
> > +	public class ContractHelperTest : TestContractBase {
> > +
> > +		private void CheckAllMessages (ContractFailureKind kind, string messageStart, \
> > Action<string, Exception, string, ContractFailureKind, Func<string>> fnAssert) \
> > +		{ +
> > +			foreach (Exception ex in new [] { null, new ArgumentNullException () }) {
> > +				fnAssert (messageStart + ".", ex, null, kind, () => {
> > +					return ContractHelper.RaiseContractFailedEvent (kind, null, null, ex);
> > +				});
> > +
> > +				fnAssert (messageStart + ".  Message", ex, null, kind, () => {
> > +					return ContractHelper.RaiseContractFailedEvent (kind, "Message", null, ex);
> > +				});
> > +
> > +				fnAssert (messageStart + ": Condition", ex, "Condition", kind, () => {
> > +					return ContractHelper.RaiseContractFailedEvent (kind, null, "Condition", \
> > ex); +				});
> > +
> > +				fnAssert (messageStart + ": Condition  Message", ex, "Condition", kind, () \
> > => { +					return ContractHelper.RaiseContractFailedEvent (kind, "Message", \
> > "Condition", ex); +				});
> > +			}
> > +
> > +		}
> > +
> > +		private void CheckAllKinds (Action<string, Exception, string, \
> > ContractFailureKind, Func<string>> fnAssert) +		{
> > +			this.CheckAllMessages (ContractFailureKind.Assert, "Assertion failed", \
> > fnAssert); +			this.CheckAllMessages (ContractFailureKind.Assume, "Assumption \
> > failed", fnAssert); +			this.CheckAllMessages (ContractFailureKind.Invariant, \
> > "Invariant failed", fnAssert); +			this.CheckAllMessages \
> > (ContractFailureKind.Postcondition, "Postcondition failed", fnAssert); \
> > +			this.CheckAllMessages (ContractFailureKind.PostconditionOnException, \
> > "Postcondition failed after throwing an exception", fnAssert); \
> > +			this.CheckAllMessages (ContractFailureKind.Precondition, "Precondition \
> > failed", fnAssert); +		}
> > +
> > +		private void CheckAllKinds (Action<string, Exception, Func<string>> fnAssert)
> > +		{
> > +			this.CheckAllKinds ((expected, ex, condition, kind, fnTest) => fnAssert \
> > (expected, ex, fnTest)); +		}
> > +
> > +		/// <summary>
> > +		/// If no event handler is present, then the string returned describes the \
> > condition failure. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractFailedEventNoHandler ()
> > +		{
> > +			this.CheckAllKinds ((expected, ex, fnTest) => {
> > +				string msg = fnTest ();
> > +				Assert.AreEqual (expected, msg, "TestRaiseContractFailedEventNoHandler() \
> > incorrect message"); +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// When SetHandled() is called, null is returned.
> > +		/// The event args are also checked.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractFailedEventHandled ()
> > +		{
> > +			string expectedMsg = null;
> > +			Exception originalException = null;
> > +			string expectedCondition = null;
> > +			ContractFailureKind expectedKind = ContractFailureKind.Assert;
> > +			Contract.ContractFailed += (sender, e) => {
> > +				Assert.AreEqual (expectedMsg, e.Message, \
> > "TestRaiseContractFailedEventHandled() event message wrong"); +				Assert.AreSame \
> > (originalException, e.OriginalException, "TestRaiseContractFailedEventHandled() \
> > event exception wrong"); +				Assert.AreEqual (expectedCondition, e.Condition, \
> > "TestRaiseContractFailedEventHandled() event condition wrong"); \
> > +				Assert.AreEqual (expectedKind, e.FailureKind, \
> > "TestRaiseContractFailedEventHandled() event failure kind wrong"); \
> > +				e.SetHandled (); +			};
> > +
> > +			this.CheckAllKinds ((expected, ex, condition, kind, fnTest) => {
> > +				expectedMsg = expected;
> > +				originalException = ex;
> > +				expectedCondition = condition;
> > +				expectedKind = kind;
> > +				string msg = fnTest ();
> > +				Assert.IsNull (msg, "TestRaiseContractFailedEventHandled() expected null \
> > message"); +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// When SetUnwind() is called, a ContractException is thrown. If an \
> > innerException is passed, then +		/// it is put in the InnerException of the \
> > ContractException. Otherwise, the InnerException is set to null. +		/// \
> > </summary> +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractFailedEventUnwind ()
> > +		{
> > +			Contract.ContractFailed += (sender, e) => {
> > +				e.SetUnwind ();
> > +			};
> > +
> > +			this.CheckAllKinds ((expected, expectedEx, fnTest) => {
> > +				try {
> > +					fnTest ();
> > +					Assert.Fail ("TestRaiseContractFailedEventUnwind() exception not thrown");
> > +				} catch (Exception ex) {
> > +					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestRaiseContractFailedEventUnwind() wrong exception type"); +					if \
> > (expectedEx == null) { +						Assert.IsNull (ex.InnerException, \
> > "TestRaiseContractFailedEventUnwind() inner exception should be null"); +					} \
> > else { +						Assert.AreSame (expectedEx, ex.InnerException, \
> > "TestRaiseContractFailedEventUnwind() wrong inner exception type"); +					}
> > +				}
> > +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// When the ContractFailed event throws an exception, then it becomes the \
> > inner exception of the +		/// ContractException. Except if an exception is passed \
> > in to the call, then that exception is put +		/// in the InnerException.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractFailedEventThrows ()
> > +		{
> > +			Contract.ContractFailed += (sender, e) => {
> > +				throw new InvalidOperationException ();
> > +			};
> > +
> > +			this.CheckAllKinds ((expected, expectedEx, fnTest) => {
> > +				try {
> > +					fnTest ();
> > +					Assert.Fail ("TestRaiseContractFailedEventThrows() exception not thrown");
> > +				} catch (Exception ex) {
> > +					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestRaiseContractFailedEventThrows() wrong exception type"); +					Type \
> > expectedInnerExceptionType = expectedEx == null ? typeof \
> > (InvalidOperationException) : expectedEx.GetType (); \
> > +					Assert.IsInstanceOfType (expectedInnerExceptionType, ex.InnerException, \
> > "TestRaiseContractFailedEventThrows() wrong inner exception type"); +				}
> > +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// Both event handlers should be called, constraint is not handled.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractMultipleHandlers1 ()
> > +		{
> > +			bool visited1, visited2;
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited1 = true;
> > +			};
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited2 = true;
> > +			};
> > +
> > +			this.CheckAllKinds ((expected, ex, fnTest) => {
> > +				visited1 = visited2 = false;
> > +				string msg = fnTest ();
> > +				Assert.AreEqual (expected, msg, "TestRaiseContractMultipleHandlers1() msg \
> > not as expected"); +				Assert.IsTrue (visited1, \
> > "TestRaiseContractMultipleHandlers1() handler 1 not visited"); +				Assert.IsTrue \
> > (visited2, "TestRaiseContractMultipleHandlers1() handler 2 not visited"); +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// Both event handlers should be called. SetUnwind() takes precedent over \
> > SetHandled(). +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractMultipleHandlers2 ()
> > +		{
> > +			bool visited1, visited2;
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited1 = true;
> > +				e.SetHandled ();
> > +			};
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited2 = true;
> > +				e.SetUnwind ();
> > +			};
> > +
> > +			this.CheckAllKinds ((expected, expectedEx, fnTest) => {
> > +				visited1 = visited2 = false;
> > +				try {
> > +					fnTest ();
> > +					Assert.Fail ("TestRaiseContractMultipleHandlers2() exception not thrown");
> > +				} catch (Exception ex) {
> > +					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestRaiseContractMultipleHandlers2() wrong exception type"); +					if \
> > (expectedEx == null) { +						Assert.IsNull (ex.InnerException, \
> > "TestRaiseContractMultipleHandlers2() inner exception not null"); +					} else {
> > +						Assert.AreSame (expectedEx, ex.InnerException, \
> > "TestRaiseContractMultipleHandlers2() wrong inner exception"); +					}
> > +					Assert.IsTrue (visited1, "TestRaiseContractMultipleHandlers2() handler 1 \
> > not visited"); +					Assert.IsTrue (visited2, \
> > "TestRaiseContractMultipleHandlers2() handler 2 not visited"); +				}
> > +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// Both event handlers should be called. The exceptions are treated as calls \
> > to SetUnwind(), with +		/// the exception being put in the InnerException.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestRaiseContractMultipleHandlers3 ()
> > +		{
> > +			bool visited1, visited2;
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited1 = true;
> > +				throw new InvalidOperationException ();
> > +			};
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited2 = true;
> > +				throw new InvalidOperationException ();
> > +			};
> > +
> > +			this.CheckAllKinds ((expected, expectedEx, fnTest) => {
> > +				visited1 = visited2 = false;
> > +				try {
> > +					fnTest ();
> > +					Assert.Fail ("TestRaiseContractMultipleHandlers3() failed to throw \
> > exception"); +				} catch (Exception ex) {
> > +					Type expectedInnerExceptionType = expectedEx == null ? typeof \
> > (InvalidOperationException) : expectedEx.GetType (); \
> > +					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestRaiseContractMultipleHandlers3() wrong exception type"); \
> > +					Assert.IsInstanceOfType (expectedInnerExceptionType, ex.InnerException, \
> > "TestRaiseContractMultipleHandlers3() wrong inner exception type"); \
> > +					Assert.IsTrue (visited1, "TestRaiseContractMultipleHandlers3() handler 1 \
> > not visited"); +					Assert.IsTrue (visited2, \
> > "TestRaiseContractMultipleHandlers3() handler 2 not visited"); +				}
> > +			});
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.TriggerFailure() triggers the assert. Check that the assert is \
> > triggered, with the correct text. +		/// </summary>
> > +		[Test]
> > +		public void TestTriggerFailure ()
> > +		{
> > +			try {
> > +				ContractHelper.TriggerFailure (ContractFailureKind.Assert, "Display", null, \
> > "Condition", null); +				Assert.Fail ("TestTriggerFailure() failed to throw \
> > exception"); +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType(typeof(NotImplementedException), ex, \
> > "TestTriggerFailure() wrong exception type"); +				//Assert.AreEqual \
> > ("Expression: Condition" + Environment.NewLine + "Description: Display", \
> > ex.Message, "TestTriggerFailure() wrong message"); +			}
> > +		}
> > +
> > +	}
> > +
> > +}
> > +
> > +#endif
> > 
> > Property changes on: Test/System.Diagnostics.Contracts/ContractHelperTest.cs
> > ___________________________________________________________________
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs	(revision \
> >                 0)
> > +++ Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs	(revision \
> > 0) @@ -0,0 +1,18 @@
> > +#if NET_4_0
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts.Helpers {
> > +
> > +	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
> > +	class RunAgainstReferenceAttribute : CategoryAttribute
> > +	{
> > +	}
> > +
> > +}
> > +
> > +#endif
> > 
> > Property changes on: \
> > Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs \
> >                 ___________________________________________________________________
> >                 
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs	(revision 0)
> > @@ -0,0 +1,48 @@
> > +#if NET_4_0
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using System.Diagnostics.Contracts;
> > +using System.Diagnostics;
> > +using System.Reflection;
> > +using System.Diagnostics.Contracts.Internal;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts.Helpers {
> > +
> > +	public class TestContractBase {
> > +
> > +		protected TestContractBase() {
> > +			// Get the type of System.Diagnostics.Contracts.ContractException
> > +			// Have to do this differently depending on how the test is being run.
> > +			this.ContractExceptionType = \
> > Type.GetType("System.Diagnostics.Contracts.ContractException"); +			if \
> > (this.ContractExceptionType == null) { +				// Special code for when Contracts \
> > namespace is not in CorLib +				var mGetContractExceptionType = typeof \
> > (Contract).GetMethod ("GetContractExceptionType", BindingFlags.NonPublic | \
> > BindingFlags.Static); +				this.ContractExceptionType = (Type) \
> > mGetContractExceptionType.Invoke (null, null); +			}
> > +		}
> > +
> > +		[SetUp]
> > +		public void Setup() {
> > +			// Remove all event handlers from Contract.ContractFailed
> > +			var eventField = typeof(Contract).GetField("ContractFailed", \
> > BindingFlags.Static | BindingFlags.NonPublic); +			if (eventField == null) {
> > +				// But in MS.NET it's done this way.
> > +				eventField = typeof(ContractHelper).GetField("contractFailedEvent", \
> > BindingFlags.Static | BindingFlags.NonPublic); +			}
> > +			eventField.SetValue(null, null);
> > +		}
> > +
> > +		[TearDown]
> > +		public void TearDown() {
> > +		}
> > +
> > +		protected Type ContractExceptionType { get; private set; }
> > +
> > +	}
> > +}
> > +
> > +#endif
> > 
> > Property changes on: \
> > Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs \
> >                 ___________________________________________________________________
> >                 
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/ContractAssertTest.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ContractAssertTest.cs	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/ContractAssertTest.cs	(revision 0)
> > @@ -0,0 +1,175 @@
> > +#if NET_4_0
> > +
> > +#define CONTRACTS_FULL
> > +#define DEBUG
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using System.Diagnostics.Contracts;
> > +using System.Diagnostics;
> > +using MonoTests.System.Diagnostics.Contracts.Helpers;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts {
> > +
> > +	[TestFixture]
> > +	public class ContractAssertTest : TestContractBase {
> > +
> > +		/// <summary>
> > +		/// Ensures that Assert(true) allows execution to continue.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestAssertTrue ()
> > +		{
> > +			Contract.Assert (true);
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Assert(false) will cause an assert to be triggered with the \
> > correct message. +		/// </summary>
> > +		[Test]
> > +		public void TestAssertNoEventHandler ()
> > +		{
> > +			try {
> > +				Contract.Assert (false);
> > +				Assert.Fail ("TestAssertNoEventHandler() exception not thrown #1");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
> > "TestAssertNoEventHandler() wrong exception type #1"); +			}
> > +
> > +			try {
> > +				Contract.Assert (false, "Message");
> > +				Assert.Fail ("TestAssertNoEventHandler() exception not thrown #2");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
> > "TestAssertNoEventHandler() wrong exception type #2"); +			}
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Assert(true) will not call the ContractFailed event handler.
> > +		/// Contract.Assert(false) will call the ContractFailed event handler.
> > +		/// Because nothing is done in the event handler, an assert should be \
> > triggered. +		/// </summary>
> > +		[Test]
> > +		public void TestAssertEventHandlerNoAction ()
> > +		{
> > +			bool visitedEventHandler = false;
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visitedEventHandler = true;
> > +			};
> > +
> > +			Contract.Assert (true);
> > +
> > +			Assert.IsFalse (visitedEventHandler, "TestAssertEventHandlerNoAction() \
> > handler visited"); +
> > +			try {
> > +				Contract.Assert (false);
> > +				Assert.Fail ("TestAssertEventHandlerNoAction() exception not thrown");
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
> > "TestAssertEventHandlerNoAction() wrong exception type"); +			}
> > +
> > +			Assert.IsTrue (visitedEventHandler, "TestAssertEventHandlerNoAction() handler \
> > not visited"); +		}
> > +
> > +		/// <summary>
> > +		/// Event handler calls SetHandled(), so no assert should be triggered.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestAssertEventHandlerSetHandled ()
> > +		{
> > +			Contract.ContractFailed += (sender, e) => {
> > +				e.SetHandled ();
> > +			};
> > +
> > +			Contract.Assert (false);
> > +		}
> > +
> > +		/// <summary>
> > +		/// Event handler calls SetUnwind(), so exception of type ContractException \
> > should be thrown. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestAssertEventHandlerSetUnwind ()
> > +		{
> > +			Contract.ContractFailed += (sender, e) => {
> > +				e.SetUnwind ();
> > +			};
> > +
> > +			try {
> > +				Contract.Assert (false);
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestAssertEventHandlerSetUnwind() wrong exception type"); +				Assert.IsNull \
> > (ex.InnerException, "TestAssertEventHandlerSetUnwind() inner exception not \
> > null"); +			}
> > +		}
> > +
> > +		/// <summary>
> > +		/// Event handler calls SetHandled() and SetUnwind(), so exception of type \
> > ContractException should be thrown, +		/// as SetUnwind overrides SetHandled.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestAssertEventHandlerSetUnwindHandled ()
> > +		{
> > +			Contract.ContractFailed += (sender, e) => {
> > +				e.SetHandled ();
> > +				e.SetUnwind ();
> > +			};
> > +
> > +			try {
> > +				Contract.Assert (false);
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestAssertEventHandlerSetUnwindHandled() wrong exception type"); \
> > +				Assert.IsNull (ex.InnerException, "TestAssertEventHandlerSetUnwindHandled() \
> > inner exception not null"); +			}
> > +		}
> > +
> > +		/// <summary>
> > +		/// Event handler throws exception.
> > +		/// ContractException is thrown by Contract.Assert(), with InnerException set \
> > to the thrown exception. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestAssertEventHandlerThrows ()
> > +		{
> > +			Contract.ContractFailed += (sender, e) => {
> > +				throw new ArgumentNullException ();
> > +			};
> > +
> > +			try {
> > +				Contract.Assert (false);
> > +			} catch (Exception ex) {
> > +				Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
> > "TestAssertEventHandlerSetUnwindHandled() wrong exception type"); \
> > +				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex.InnerException, \
> > "TestAssertEventHandlerSetUnwindHandled() wrong inner exception type"); +			}
> > +		}
> > +
> > +		/// <summary>
> > +		/// Multiple event handlers are registered. Check that both are called, and \
> > that the SetHandled() +		/// call in one of them is handled correctly.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestAssertMultipleHandlers ()
> > +		{
> > +			bool visited1 = false, visited2 = false;
> > +
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited1 = true;
> > +				Assert.IsFalse (e.Handled, "TestAssertMultipleHandlers() Handled incorrect \
> > #1"); +				e.SetHandled ();
> > +			};
> > +			Contract.ContractFailed += (sender, e) => {
> > +				visited2 = true;
> > +				Assert.IsTrue (e.Handled, "TestAssertMultipleHandlers() Handled incorrect \
> > #2"); +			};
> > +
> > +			Contract.Assert (false);
> > +
> > +			Assert.IsTrue (visited1, "TestAssertMultipleHandlers() visited1 incorrect");
> > +			Assert.IsTrue (visited2, "TestAssertMultipleHandlers() visited2 incorrect");
> > +		}
> > +
> > +	}
> > +}
> > +
> > +#endif
> > 
> > Property changes on: Test/System.Diagnostics.Contracts/ContractAssertTest.cs
> > ___________________________________________________________________
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs	(revision 0)
> > @@ -0,0 +1,76 @@
> > +#if NET_4_0
> > +
> > +#define CONTRACTS_FULL
> > +#define DEBUG
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using System.Diagnostics.Contracts;
> > +using MonoTests.System.Diagnostics.Contracts.Helpers;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts {
> > +
> > +	[TestFixture]
> > +	public class ContractMarkerMethodsTest : TestContractBase {
> > +
> > +		/// <summary>
> > +		/// Contract.EndContractBlock() has no effects.
> > +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestEndContractBlock ()
> > +		{
> > +			Contract.EndContractBlock ();
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.OldValue() has no effect, and always returns the default value \
> > for the type. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestOldValue ()
> > +		{
> > +			int i = Contract.OldValue<int> (8);
> > +			object o = Contract.OldValue<object> (new object ());
> > +
> > +			Assert.AreEqual (0, i, "TestOldValue() int value wrong");
> > +			Assert.IsNull (o, "TestOldValue() object value wrong");
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Result() has no effect, and always returns the default value for \
> > the type. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestResult ()
> > +		{
> > +			int i = Contract.Result<int> ();
> > +			object o = Contract.Result<object> ();
> > +
> > +			Assert.AreEqual (0, i, "TestResult() int value wrong");
> > +			Assert.IsNull (o, "TestResult() object value wrong");
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.ValueAtReturn() has no effect, and always returns the default \
> > value for the type. +		/// </summary>
> > +		[Test, RunAgainstReference]
> > +		public void TestValueAtReturn ()
> > +		{
> > +			int iOut, i;
> > +			object oOut, o;
> > +
> > +			i = Contract.ValueAtReturn (out iOut);
> > +			o = Contract.ValueAtReturn (out oOut);
> > +
> > +			Assert.AreEqual (0, i, "TestValueAtReturn() int return value wrong");
> > +			Assert.IsNull (o, "TestValueAtReturn() object return value wrong");
> > +			Assert.AreEqual (0, iOut, "TestValueAtReturn() int out value wrong");
> > +			Assert.IsNull (oOut, "TestValueAtReturn() object out value wrong");
> > +		}
> > +
> > +	}
> > +
> > +}
> > +
> > +#endif
> > 
> > Property changes on: \
> > Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs \
> >                 ___________________________________________________________________
> >                 
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/ChangeLog
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ChangeLog	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/ChangeLog	(revision 0)
> > @@ -0,0 +1,4 @@
> > +2010-06-23  Chris Bacon <chrisbacon76@gmail.com>
> > +
> > +	* Added all files
> > +
> > 
> > Property changes on: Test/System.Diagnostics.Contracts/ChangeLog
> > ___________________________________________________________________
> > Added: svn:eol-style
> > + native
> > 
> > Index: Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs
> > ===================================================================
> > --- Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs	(revision 0)
> > +++ Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs	(revision 0)
> > @@ -0,0 +1,121 @@
> > +#if NET_4_0
> > +
> > +#define CONTRACTS_FULL
> > +#define DEBUG
> > +
> > +using System;
> > +using System.Collections.Generic;
> > +using System.Linq;
> > +using System.Text;
> > +using NUnit.Framework;
> > +using System.Diagnostics.Contracts;
> > +using MonoTests.System.Diagnostics.Contracts.Helpers;
> > +
> > +namespace MonoTests.System.Diagnostics.Contracts {
> > +
> > +	[TestFixture]
> > +	public class ContractMustUseRewriterTest : TestContractBase {
> > +
> > +		private void CheckMustUseRewriter (string expectedMsg, params Action[] \
> > fnTests) +		{
> > +			foreach (var fnTest in fnTests) {
> > +				try {
> > +					fnTest ();
> > +					Assert.Fail ("CheckMustUseRewriter() exception not thrown");
> > +				} catch (Exception ex) {
> > +					Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
> > "CheckMustUseRewriter() wrong exception thrown"); +				}
> > +			}
> > +
> > +			bool handlerVisited = false;
> > +			Contract.ContractFailed += (sender, e) => {
> > +				handlerVisited = true;
> > +			};
> > +
> > +			foreach (var fnTest in fnTests) {
> > +				try {
> > +					fnTest ();
> > +					Assert.Fail ("CheckMustUseRewriter() exception not thrown");
> > +				} catch (Exception ex) {
> > +					Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
> > "CheckMustUseRewriter() wrong exception thrown"); +				}
> > +			}
> > +
> > +			Assert.IsFalse (handlerVisited, "CheckMustUseRewriter() handled visited");
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Requires() ALWAYS triggers an assert, regardless of any other \
> > factors. +		/// </summary>
> > +		[Test]
> > +		public void TestRequires ()
> > +		{
> > +			CheckMustUseRewriter ("Description: Must use the rewriter when using \
> > Contract.Requires", +				() => Contract.Requires (true),
> > +				() => Contract.Requires (false),
> > +				() => Contract.Requires (true, "Message"),
> > +				() => Contract.Requires (false, "Message")
> > +			);
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Requires() ALWAYS triggers an assert, regardless of any other \
> > factors. +		/// </summary>
> > +		[Test]
> > +		public void TestRequiresTException ()
> > +		{
> > +			CheckMustUseRewriter ("Description: Must use the rewriter when using \
> > Contract.Requires<TException>", +				() => Contract.Requires<Exception> (true),
> > +				() => Contract.Requires<Exception> (false),
> > +				() => Contract.Requires<Exception> (true, "Message"),
> > +				() => Contract.Requires<Exception> (false, "Message")
> > +			);
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Ensures() ALWAYS triggers an assert, regardless of any other \
> > factors. +		/// </summary>
> > +		[Test]
> > +		public void TestEnsures ()
> > +		{
> > +			CheckMustUseRewriter ("Description: Must use the rewriter when using \
> > Contract.Ensures", +				() => Contract.Ensures (true),
> > +				() => Contract.Ensures (false),
> > +				() => Contract.Ensures (true, "Message"),
> > +				() => Contract.Ensures (false, "Message")
> > +			);
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Ensures() ALWAYS triggers an assert, regardless of any other \
> > factors. +		/// </summary>
> > +		[Test]
> > +		public void TestEnsuresOnThrow ()
> > +		{
> > +			CheckMustUseRewriter ("Description: Must use the rewriter when using \
> > Contract.EnsuresOnThrow", +				() => Contract.EnsuresOnThrow<Exception> (true),
> > +				() => Contract.EnsuresOnThrow<Exception> (false),
> > +				() => Contract.EnsuresOnThrow<Exception> (true, "Message"),
> > +				() => Contract.EnsuresOnThrow<Exception> (false, "Message")
> > +			);
> > +		}
> > +
> > +		/// <summary>
> > +		/// Contract.Ensures() ALWAYS triggers an assert, regardless of any other \
> > factors. +		/// </summary>
> > +		[Test]
> > +		public void TestInvariant ()
> > +		{
> > +			CheckMustUseRewriter ("Description: Must use the rewriter when using \
> > Contract.Invariant", +				() => Contract.Invariant (true),
> > +				() => Contract.Invariant (false),
> > +				() => Contract.Invariant (true, "Message"),
> > +				() => Contract.Invariant (false, "Message")
> > +			);
> > +		}
> > +
> > +	}
> > +
> > +}
> > +
> > +#endif
> > 
> > Property changes on: \
> > Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs \
> >                 ___________________________________________________________________
> >                 
> > Added: svn:eol-style
> > + native
> > 
> > _______________________________________________
> > Mono-devel-list mailing list
> > Mono-devel-list@lists.ximian.com
> > http://lists.ximian.com/mailman/listinfo/mono-devel-list
> > 
> 
> 
> 


[Attachment #5 (text/html)]

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta content="text/html;charset=ISO-8859-1" http-equiv="Content-Type">
</head>
<body bgcolor="#ffffff" text="#000000">
Hi,<br>
<br>
Last Thursday, 24th, I followed these instructions and sent my public
SSH key to <a class="moz-txt-link-abbreviated" \
href="mailto:miguel@ximian.com">miguel@ximian.com</a>.<br> Should I expect to hear \
something back?<br> <br>
Thanks<br>
Chris<br>
<br>
Miguel de Icaza wrote:
<blockquote cite="mid:1277310891.1678.327.camel@erandi.site" type="cite">
  <pre wrap="">Hey Chris,

    Could you get these commited yourself?

    For this you will need an SVN key, follow the steps here:

	<a class="moz-txt-link-abbreviated" \
href="http://www.mono-project.com/SVN">www.mono-project.com/SVN</a>

  </pre>
  <blockquote type="cite">
    <pre wrap="">Hi,

Updated patch attached. I've checked that all tests still pass.

The delegate has been removed, and #if NET_4_0 now surrounds the whole 
of each file.

However, the #defines are not un-defined at the end of each file, as I 
don't think this is possible in C#, as all #define and #undef statements 
have to be before any code. Please let me know if there is a way of 
#undef-ing another way.

Thanks
Chris

Marek Safar wrote:
    </pre>
    <blockquote type="cite">
      <pre wrap="">Hello Chris,

Only a few small issues

+#define CONTRACTS_FULL
+#define DEBUG
+

Undefined these at the end of each file. They perhaps should be inside 
#if NET_4_0 too.

+        // Required when compiling/running under .NET3.5
+        delegate void Action&lt;T1, T2, T3, T4, T5&gt; (T1 arg1, T2 arg2, 
T3 arg3, T4 arg4, T5 arg5);
+

Why is it needed when NET_4_0 is used for whole file ?

When fixed please commit. Thanks!

Marek

      </pre>
      <blockquote type="cite">
        <pre wrap="">Hi,
I've attached a new patch with slightly better formatting - it uses 
tabs rather than spaces.
Kind regards
Chris

Chris Bacon wrote:
        </pre>
        <blockquote type="cite">
          <pre wrap="">Hi,

Here are the tests to add to corlib for System.Diagnostics.Contracts.

Please let me know what changes are required.

Kind regards
Chris
------------------------------------------------------------------------ 


_______________________________________________
Mono-devel-list mailing list
<a class="moz-txt-link-abbreviated" \
href="mailto:Mono-devel-list@lists.ximian.com">Mono-devel-list@lists.ximian.com</a> \
<a class="moz-txt-link-freetext" \
href="http://lists.ximian.com/mailman/listinfo/mono-devel-list">http://lists.ximian.com/mailman/listinfo/mono-devel-list</a>
  </pre>
        </blockquote>
        <pre wrap="">------------------------------------------------------------------------


_______________________________________________
Mono-devel-list mailing list
<a class="moz-txt-link-abbreviated" \
href="mailto:Mono-devel-list@lists.ximian.com">Mono-devel-list@lists.ximian.com</a> \
<a class="moz-txt-link-freetext" \
href="http://lists.ximian.com/mailman/listinfo/mono-devel-list">http://lists.ximian.com/mailman/listinfo/mono-devel-list</a>
  </pre>
      </blockquote>
    </blockquote>
    <pre wrap="">plain text document attachment (CodeContractsTest.patch)
Index: corlib_test.dll.sources
===================================================================
--- corlib_test.dll.sources	(revision 159418)
+++ corlib_test.dll.sources	(working copy)
@@ -60,6 +60,14 @@
 System.Diagnostics/StackFrameTest.cs
 System.Diagnostics/StackTraceTest.cs
 System.Diagnostics/TextWriterTraceListenerTest.cs
+System.Diagnostics.Contracts/ContractAssertTest.cs
+System.Diagnostics.Contracts/ContractAssumeTest.cs
+System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs
+System.Diagnostics.Contracts/ContractHelperTest.cs
+System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs
+System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs
+System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs
+System.Diagnostics.Contracts/Helpers/TestContractBase.cs
 System/DoubleFormatterTest.cs
 System/DoubleTest.cs
 System/EnumTest.cs
Index: Test/System.Diagnostics.Contracts/ContractAssumeTest.cs
===================================================================
--- Test/System.Diagnostics.Contracts/ContractAssumeTest.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/ContractAssumeTest.cs	(revision 0)
@@ -0,0 +1,47 @@
+#if NET_4_0
+
+#define CONTRACTS_FULL
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using System.Diagnostics.Contracts;
+using MonoTests.System.Diagnostics.Contracts.Helpers;
+
+namespace MonoTests.System.Diagnostics.Contracts {
+
+	[TestFixture]
+	public class ContractAssumeTest : TestContractBase {
+
+		/// &lt;summary&gt;
+		/// At runtime Contract.Assume() acts just like a Contract.Assert(), except the \
exact message in the assert +		/// or exception is slightly different.
+		/// &lt;/summary&gt;
+		[Test]
+		public void TestAssumeMessage ()
+		{
+			try {
+				Contract.Assume (false);
+				Assert.Fail ("TestAssumeMessage() exception not thrown #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof(NotImplementedException), ex, \
"TestAssumeMessage() wrong exception type #1"); +			}
+
+			try {
+				Contract.Assume (false, "Message");
+				Assert.Fail ("TestAssumeMessage() exception not thrown #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof(NotImplementedException), ex, \
"TestAssumeMessage() wrong exception type #1"); +			}
+		}
+
+		// Identical to Contract.Assert, so no more testing required.
+
+	}
+
+}
+
+#endif

Property changes on: Test/System.Diagnostics.Contracts/ContractAssumeTest.cs
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs
===================================================================
--- Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs	(revision 0)
@@ -0,0 +1,129 @@
+#if NET_4_0
+
+#define CONTRACTS_FULL
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using MonoTests.System.Diagnostics.Contracts.Helpers;
+using System.Diagnostics.Contracts;
+
+namespace MonoTests.System.Diagnostics.Contracts {
+
+	[TestFixture]
+	public class ContractCollectionMethodsTest {
+
+		/// &lt;summary&gt;
+		/// Contract.Exists() determines that at least one element in the collection \
satisfies the predicate. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestExistsInt ()
+		{
+			try {
+				Contract.Exists (0, 10, null);
+				Assert.Fail ("TestExistsInt() no exception #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, "TestExistsInt() \
wrong exception #1"); +			}
+
+			try {
+				Contract.Exists (10, 0, i =&gt; false);
+				Assert.Fail ("TestExistsInt() no exception #2");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentException), ex, "TestExistsInt() wrong \
exception #2"); +			}
+
+			Assert.IsTrue (Contract.Exists (0, 10, i =&gt; i &lt;= 0), "TestExistsInt() #1");
+			Assert.IsTrue (Contract.Exists (0, 10, i =&gt; i &gt;= 9), "TestExistsInt() #2");
+			Assert.IsFalse (Contract.Exists (0, 10, i =&gt; i &lt; 0), "TestExistsInt() #3");
+			Assert.IsFalse (Contract.Exists (0, 10, i =&gt; i &gt; 9), "TestExistsInt() #4");
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Exists() determines that at least one element in the collection \
satisfies the predicate. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestExistsEnumeration ()
+		{
+			try {
+				Contract.Exists (Enumerable.Range (0, 10), null);
+				Assert.Fail ("TestExistsEnumeration() no exception #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
"TestExistsEnumeration() wrong exception #1"); +			}
+
+			try {
+				Contract.Exists&lt;int&gt; (null, x =&gt; false);
+				Assert.Fail ("TestExistsEnumeration() no exception #2");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
"TestExistsEnumeration() wrong exception #2"); +			}
+
+			var en = Enumerable.Range (0, 10);
+			Assert.IsTrue (Contract.Exists (en, i =&gt; i &lt;= 0), "TestExistsEnumeration() \
#1"); +			Assert.IsTrue (Contract.Exists (en, i =&gt; i &gt;= 9), \
"TestExistsEnumeration() #2"); +			Assert.IsFalse (Contract.Exists (en, i =&gt; i \
&lt; 0), "TestExistsEnumeration() #3"); +			Assert.IsFalse (Contract.Exists (en, i \
=&gt; i &gt; 9), "TestExistsEnumeration() #4"); +		}
+
+		/// &lt;summary&gt;
+		/// Contract.ForAll() determines if all elements in the collection satisfy the \
predicate. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestForAllInt ()
+		{
+			try {
+				Contract.ForAll (0, 10, null);
+				Assert.Fail ("TestForAllInt() no exception #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, "TestForAllInt() \
wrong exception #1"); +			}
+
+			try {
+				Contract.ForAll (10, 0, i =&gt; false);
+				Assert.Fail ("TestForAllInt() no exception #2");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentException), ex, "TestForAllInt() wrong \
exception #2"); +			}
+
+			Assert.IsTrue (Contract.ForAll (0, 10, i =&gt; i &lt;= 9), "TestForAllInt() #1");
+			Assert.IsTrue (Contract.ForAll (0, 10, i =&gt; i &gt;= 0), "TestForAllInt() #2");
+			Assert.IsFalse (Contract.ForAll (0, 10, i =&gt; i &lt; 9), "TestForAllInt() #3");
+			Assert.IsFalse (Contract.ForAll (0, 10, i =&gt; i &gt; 0), "TestForAllInt() #4");
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.ForAll() determines if all elements in the collection satisfy the \
predicate. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestForAllEnumeration ()
+		{
+			try {
+				Contract.ForAll (Enumerable.Range (0, 10), null);
+				Assert.Fail ("TestForAllEnumeration() no exception #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
"TestForAllEnumeration() wrong exception #1"); +			}
+
+			try {
+				Contract.ForAll&lt;int&gt; (null, x =&gt; false);
+				Assert.Fail ("TestForAllEnumeration() no exception #2");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex, \
"TestForAllEnumeration() wrong exception #2"); +			}
+
+			var en = Enumerable.Range (0, 10);
+			Assert.IsTrue (Contract.ForAll (en, i =&gt; i &lt;= 9), "TestForAllEnumeration() \
#1"); +			Assert.IsTrue (Contract.ForAll (en, i =&gt; i &gt;= 0), \
"TestForAllEnumeration() #2"); +			Assert.IsFalse (Contract.ForAll (en, i =&gt; i \
&lt; 9), "TestForAllEnumeration() #3"); +			Assert.IsFalse (Contract.ForAll (en, i \
=&gt; i &gt; 0), "TestForAllEnumeration() #4"); +		}
+
+	}
+
+}
+
+#endif

Property changes on: \
Test/System.Diagnostics.Contracts/ContractCollectionMethodsTest.cs \
                ___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/ContractHelperTest.cs
===================================================================
--- Test/System.Diagnostics.Contracts/ContractHelperTest.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/ContractHelperTest.cs	(revision 0)
@@ -0,0 +1,258 @@
+#if NET_4_0
+
+#define CONTRACTS_FULL
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using System.Diagnostics.Contracts.Internal;
+using System.Diagnostics.Contracts;
+using MonoTests.System.Diagnostics.Contracts.Helpers;
+using NUnit.Framework.Constraints;
+
+namespace MonoTests.System.Diagnostics.Contracts {
+
+	[TestFixture]
+	public class ContractHelperTest : TestContractBase {
+
+		private void CheckAllMessages (ContractFailureKind kind, string messageStart, \
Action&lt;string, Exception, string, ContractFailureKind, Func&lt;string&gt;&gt; \
fnAssert) +		{
+
+			foreach (Exception ex in new [] { null, new ArgumentNullException () }) {
+				fnAssert (messageStart + ".", ex, null, kind, () =&gt; {
+					return ContractHelper.RaiseContractFailedEvent (kind, null, null, ex);
+				});
+
+				fnAssert (messageStart + ".  Message", ex, null, kind, () =&gt; {
+					return ContractHelper.RaiseContractFailedEvent (kind, "Message", null, ex);
+				});
+
+				fnAssert (messageStart + ": Condition", ex, "Condition", kind, () =&gt; {
+					return ContractHelper.RaiseContractFailedEvent (kind, null, "Condition", ex);
+				});
+
+				fnAssert (messageStart + ": Condition  Message", ex, "Condition", kind, () =&gt; \
{ +					return ContractHelper.RaiseContractFailedEvent (kind, "Message", "Condition", \
ex); +				});
+			}
+
+		}
+
+		private void CheckAllKinds (Action&lt;string, Exception, string, \
ContractFailureKind, Func&lt;string&gt;&gt; fnAssert) +		{
+			this.CheckAllMessages (ContractFailureKind.Assert, "Assertion failed", fnAssert);
+			this.CheckAllMessages (ContractFailureKind.Assume, "Assumption failed", \
fnAssert); +			this.CheckAllMessages (ContractFailureKind.Invariant, "Invariant \
failed", fnAssert); +			this.CheckAllMessages (ContractFailureKind.Postcondition, \
"Postcondition failed", fnAssert); +			this.CheckAllMessages \
(ContractFailureKind.PostconditionOnException, "Postcondition failed after throwing \
an exception", fnAssert); +			this.CheckAllMessages \
(ContractFailureKind.Precondition, "Precondition failed", fnAssert); +		}
+
+		private void CheckAllKinds (Action&lt;string, Exception, Func&lt;string&gt;&gt; \
fnAssert) +		{
+			this.CheckAllKinds ((expected, ex, condition, kind, fnTest) =&gt; fnAssert \
(expected, ex, fnTest)); +		}
+
+		/// &lt;summary&gt;
+		/// If no event handler is present, then the string returned describes the \
condition failure. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestRaiseContractFailedEventNoHandler ()
+		{
+			this.CheckAllKinds ((expected, ex, fnTest) =&gt; {
+				string msg = fnTest ();
+				Assert.AreEqual (expected, msg, "TestRaiseContractFailedEventNoHandler() \
incorrect message"); +			});
+		}
+
+		/// &lt;summary&gt;
+		/// When SetHandled() is called, null is returned.
+		/// The event args are also checked.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestRaiseContractFailedEventHandled ()
+		{
+			string expectedMsg = null;
+			Exception originalException = null;
+			string expectedCondition = null;
+			ContractFailureKind expectedKind = ContractFailureKind.Assert;
+			Contract.ContractFailed += (sender, e) =&gt; {
+				Assert.AreEqual (expectedMsg, e.Message, "TestRaiseContractFailedEventHandled() \
event message wrong"); +				Assert.AreSame (originalException, e.OriginalException, \
"TestRaiseContractFailedEventHandled() event exception wrong"); +				Assert.AreEqual \
(expectedCondition, e.Condition, "TestRaiseContractFailedEventHandled() event \
condition wrong"); +				Assert.AreEqual (expectedKind, e.FailureKind, \
"TestRaiseContractFailedEventHandled() event failure kind wrong"); +				e.SetHandled \
(); +			};
+
+			this.CheckAllKinds ((expected, ex, condition, kind, fnTest) =&gt; {
+				expectedMsg = expected;
+				originalException = ex;
+				expectedCondition = condition;
+				expectedKind = kind;
+				string msg = fnTest ();
+				Assert.IsNull (msg, "TestRaiseContractFailedEventHandled() expected null \
message"); +			});
+		}
+
+		/// &lt;summary&gt;
+		/// When SetUnwind() is called, a ContractException is thrown. If an \
innerException is passed, then +		/// it is put in the InnerException of the \
ContractException. Otherwise, the InnerException is set to null. +		/// \
&lt;/summary&gt; +		[Test, RunAgainstReference]
+		public void TestRaiseContractFailedEventUnwind ()
+		{
+			Contract.ContractFailed += (sender, e) =&gt; {
+				e.SetUnwind ();
+			};
+
+			this.CheckAllKinds ((expected, expectedEx, fnTest) =&gt; {
+				try {
+					fnTest ();
+					Assert.Fail ("TestRaiseContractFailedEventUnwind() exception not thrown");
+				} catch (Exception ex) {
+					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
"TestRaiseContractFailedEventUnwind() wrong exception type"); +					if (expectedEx == \
null) { +						Assert.IsNull (ex.InnerException, \
"TestRaiseContractFailedEventUnwind() inner exception should be null"); +					} else \
{ +						Assert.AreSame (expectedEx, ex.InnerException, \
"TestRaiseContractFailedEventUnwind() wrong inner exception type"); +					}
+				}
+			});
+		}
+
+		/// &lt;summary&gt;
+		/// When the ContractFailed event throws an exception, then it becomes the inner \
exception of the +		/// ContractException. Except if an exception is passed in to the \
call, then that exception is put +		/// in the InnerException.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestRaiseContractFailedEventThrows ()
+		{
+			Contract.ContractFailed += (sender, e) =&gt; {
+				throw new InvalidOperationException ();
+			};
+
+			this.CheckAllKinds ((expected, expectedEx, fnTest) =&gt; {
+				try {
+					fnTest ();
+					Assert.Fail ("TestRaiseContractFailedEventThrows() exception not thrown");
+				} catch (Exception ex) {
+					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
"TestRaiseContractFailedEventThrows() wrong exception type"); +					Type \
expectedInnerExceptionType = expectedEx == null ? typeof (InvalidOperationException) \
: expectedEx.GetType (); +					Assert.IsInstanceOfType (expectedInnerExceptionType, \
ex.InnerException, "TestRaiseContractFailedEventThrows() wrong inner exception \
type"); +				}
+			});
+		}
+
+		/// &lt;summary&gt;
+		/// Both event handlers should be called, constraint is not handled.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestRaiseContractMultipleHandlers1 ()
+		{
+			bool visited1, visited2;
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited1 = true;
+			};
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited2 = true;
+			};
+
+			this.CheckAllKinds ((expected, ex, fnTest) =&gt; {
+				visited1 = visited2 = false;
+				string msg = fnTest ();
+				Assert.AreEqual (expected, msg, "TestRaiseContractMultipleHandlers1() msg not as \
expected"); +				Assert.IsTrue (visited1, "TestRaiseContractMultipleHandlers1() \
handler 1 not visited"); +				Assert.IsTrue (visited2, \
"TestRaiseContractMultipleHandlers1() handler 2 not visited"); +			});
+		}
+
+		/// &lt;summary&gt;
+		/// Both event handlers should be called. SetUnwind() takes precedent over \
SetHandled(). +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestRaiseContractMultipleHandlers2 ()
+		{
+			bool visited1, visited2;
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited1 = true;
+				e.SetHandled ();
+			};
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited2 = true;
+				e.SetUnwind ();
+			};
+
+			this.CheckAllKinds ((expected, expectedEx, fnTest) =&gt; {
+				visited1 = visited2 = false;
+				try {
+					fnTest ();
+					Assert.Fail ("TestRaiseContractMultipleHandlers2() exception not thrown");
+				} catch (Exception ex) {
+					Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
"TestRaiseContractMultipleHandlers2() wrong exception type"); +					if (expectedEx == \
null) { +						Assert.IsNull (ex.InnerException, \
"TestRaiseContractMultipleHandlers2() inner exception not null"); +					} else {
+						Assert.AreSame (expectedEx, ex.InnerException, \
"TestRaiseContractMultipleHandlers2() wrong inner exception"); +					}
+					Assert.IsTrue (visited1, "TestRaiseContractMultipleHandlers2() handler 1 not \
visited"); +					Assert.IsTrue (visited2, "TestRaiseContractMultipleHandlers2() \
handler 2 not visited"); +				}
+			});
+		}
+
+		/// &lt;summary&gt;
+		/// Both event handlers should be called. The exceptions are treated as calls to \
SetUnwind(), with +		/// the exception being put in the InnerException.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestRaiseContractMultipleHandlers3 ()
+		{
+			bool visited1, visited2;
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited1 = true;
+				throw new InvalidOperationException ();
+			};
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited2 = true;
+				throw new InvalidOperationException ();
+			};
+
+			this.CheckAllKinds ((expected, expectedEx, fnTest) =&gt; {
+				visited1 = visited2 = false;
+				try {
+					fnTest ();
+					Assert.Fail ("TestRaiseContractMultipleHandlers3() failed to throw exception");
+				} catch (Exception ex) {
+					Type expectedInnerExceptionType = expectedEx == null ? typeof \
(InvalidOperationException) : expectedEx.GetType (); +					Assert.IsInstanceOfType \
(base.ContractExceptionType, ex, "TestRaiseContractMultipleHandlers3() wrong \
exception type"); +					Assert.IsInstanceOfType (expectedInnerExceptionType, \
ex.InnerException, "TestRaiseContractMultipleHandlers3() wrong inner exception \
type"); +					Assert.IsTrue (visited1, "TestRaiseContractMultipleHandlers3() handler \
1 not visited"); +					Assert.IsTrue (visited2, "TestRaiseContractMultipleHandlers3() \
handler 2 not visited"); +				}
+			});
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.TriggerFailure() triggers the assert. Check that the assert is \
triggered, with the correct text. +		/// &lt;/summary&gt;
+		[Test]
+		public void TestTriggerFailure ()
+		{
+			try {
+				ContractHelper.TriggerFailure (ContractFailureKind.Assert, "Display", null, \
"Condition", null); +				Assert.Fail ("TestTriggerFailure() failed to throw \
exception"); +			} catch (Exception ex) {
+				Assert.IsInstanceOfType(typeof(NotImplementedException), ex, \
"TestTriggerFailure() wrong exception type"); +				//Assert.AreEqual ("Expression: \
Condition" + Environment.NewLine + "Description: Display", ex.Message, \
"TestTriggerFailure() wrong message"); +			}
+		}
+
+	}
+
+}
+
+#endif

Property changes on: Test/System.Diagnostics.Contracts/ContractHelperTest.cs
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs
===================================================================
--- Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs	(revision \
                0)
+++ Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs	(revision \
0) @@ -0,0 +1,18 @@
+#if NET_4_0
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+
+namespace MonoTests.System.Diagnostics.Contracts.Helpers {
+
+	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+	class RunAgainstReferenceAttribute : CategoryAttribute
+	{
+	}
+
+}
+
+#endif

Property changes on: \
Test/System.Diagnostics.Contracts/Helpers/RunAgainstReferenceAttribute.cs \
                ___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs
===================================================================
--- Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs	(revision 0)
@@ -0,0 +1,48 @@
+#if NET_4_0
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using System.Diagnostics.Contracts;
+using System.Diagnostics;
+using System.Reflection;
+using System.Diagnostics.Contracts.Internal;
+
+namespace MonoTests.System.Diagnostics.Contracts.Helpers {
+
+	public class TestContractBase {
+
+		protected TestContractBase() {
+			// Get the type of System.Diagnostics.Contracts.ContractException
+			// Have to do this differently depending on how the test is being run.
+			this.ContractExceptionType = \
Type.GetType("System.Diagnostics.Contracts.ContractException"); +			if \
(this.ContractExceptionType == null) { +				// Special code for when Contracts \
namespace is not in CorLib +				var mGetContractExceptionType = typeof \
(Contract).GetMethod ("GetContractExceptionType", BindingFlags.NonPublic | \
BindingFlags.Static); +				this.ContractExceptionType = (Type) \
mGetContractExceptionType.Invoke (null, null); +			}
+		}
+
+		[SetUp]
+		public void Setup() {
+			// Remove all event handlers from Contract.ContractFailed
+			var eventField = typeof(Contract).GetField("ContractFailed", BindingFlags.Static \
| BindingFlags.NonPublic); +			if (eventField == null) {
+				// But in MS.NET it's done this way.
+				eventField = typeof(ContractHelper).GetField("contractFailedEvent", \
BindingFlags.Static | BindingFlags.NonPublic); +			}
+			eventField.SetValue(null, null);
+		}
+
+		[TearDown]
+		public void TearDown() {
+		}
+
+		protected Type ContractExceptionType { get; private set; }
+
+	}
+}
+
+#endif

Property changes on: Test/System.Diagnostics.Contracts/Helpers/TestContractBase.cs
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/ContractAssertTest.cs
===================================================================
--- Test/System.Diagnostics.Contracts/ContractAssertTest.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/ContractAssertTest.cs	(revision 0)
@@ -0,0 +1,175 @@
+#if NET_4_0
+
+#define CONTRACTS_FULL
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using System.Diagnostics.Contracts;
+using System.Diagnostics;
+using MonoTests.System.Diagnostics.Contracts.Helpers;
+
+namespace MonoTests.System.Diagnostics.Contracts {
+
+	[TestFixture]
+	public class ContractAssertTest : TestContractBase {
+
+		/// &lt;summary&gt;
+		/// Ensures that Assert(true) allows execution to continue.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestAssertTrue ()
+		{
+			Contract.Assert (true);
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Assert(false) will cause an assert to be triggered with the correct \
message. +		/// &lt;/summary&gt;
+		[Test]
+		public void TestAssertNoEventHandler ()
+		{
+			try {
+				Contract.Assert (false);
+				Assert.Fail ("TestAssertNoEventHandler() exception not thrown #1");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
"TestAssertNoEventHandler() wrong exception type #1"); +			}
+
+			try {
+				Contract.Assert (false, "Message");
+				Assert.Fail ("TestAssertNoEventHandler() exception not thrown #2");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
"TestAssertNoEventHandler() wrong exception type #2"); +			}
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Assert(true) will not call the ContractFailed event handler.
+		/// Contract.Assert(false) will call the ContractFailed event handler.
+		/// Because nothing is done in the event handler, an assert should be triggered.
+		/// &lt;/summary&gt;
+		[Test]
+		public void TestAssertEventHandlerNoAction ()
+		{
+			bool visitedEventHandler = false;
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visitedEventHandler = true;
+			};
+
+			Contract.Assert (true);
+
+			Assert.IsFalse (visitedEventHandler, "TestAssertEventHandlerNoAction() handler \
visited"); +
+			try {
+				Contract.Assert (false);
+				Assert.Fail ("TestAssertEventHandlerNoAction() exception not thrown");
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
"TestAssertEventHandlerNoAction() wrong exception type"); +			}
+
+			Assert.IsTrue (visitedEventHandler, "TestAssertEventHandlerNoAction() handler not \
visited"); +		}
+
+		/// &lt;summary&gt;
+		/// Event handler calls SetHandled(), so no assert should be triggered.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestAssertEventHandlerSetHandled ()
+		{
+			Contract.ContractFailed += (sender, e) =&gt; {
+				e.SetHandled ();
+			};
+
+			Contract.Assert (false);
+		}
+
+		/// &lt;summary&gt;
+		/// Event handler calls SetUnwind(), so exception of type ContractException should \
be thrown. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestAssertEventHandlerSetUnwind ()
+		{
+			Contract.ContractFailed += (sender, e) =&gt; {
+				e.SetUnwind ();
+			};
+
+			try {
+				Contract.Assert (false);
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
"TestAssertEventHandlerSetUnwind() wrong exception type"); +				Assert.IsNull \
(ex.InnerException, "TestAssertEventHandlerSetUnwind() inner exception not null"); \
+			} +		}
+
+		/// &lt;summary&gt;
+		/// Event handler calls SetHandled() and SetUnwind(), so exception of type \
ContractException should be thrown, +		/// as SetUnwind overrides SetHandled.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestAssertEventHandlerSetUnwindHandled ()
+		{
+			Contract.ContractFailed += (sender, e) =&gt; {
+				e.SetHandled ();
+				e.SetUnwind ();
+			};
+
+			try {
+				Contract.Assert (false);
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
"TestAssertEventHandlerSetUnwindHandled() wrong exception type"); +				Assert.IsNull \
(ex.InnerException, "TestAssertEventHandlerSetUnwindHandled() inner exception not \
null"); +			}
+		}
+
+		/// &lt;summary&gt;
+		/// Event handler throws exception.
+		/// ContractException is thrown by Contract.Assert(), with InnerException set to \
the thrown exception. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestAssertEventHandlerThrows ()
+		{
+			Contract.ContractFailed += (sender, e) =&gt; {
+				throw new ArgumentNullException ();
+			};
+
+			try {
+				Contract.Assert (false);
+			} catch (Exception ex) {
+				Assert.IsInstanceOfType (base.ContractExceptionType, ex, \
"TestAssertEventHandlerSetUnwindHandled() wrong exception type"); \
+				Assert.IsInstanceOfType (typeof (ArgumentNullException), ex.InnerException, \
"TestAssertEventHandlerSetUnwindHandled() wrong inner exception type"); +			}
+		}
+
+		/// &lt;summary&gt;
+		/// Multiple event handlers are registered. Check that both are called, and that \
the SetHandled() +		/// call in one of them is handled correctly.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestAssertMultipleHandlers ()
+		{
+			bool visited1 = false, visited2 = false;
+
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited1 = true;
+				Assert.IsFalse (e.Handled, "TestAssertMultipleHandlers() Handled incorrect #1");
+				e.SetHandled ();
+			};
+			Contract.ContractFailed += (sender, e) =&gt; {
+				visited2 = true;
+				Assert.IsTrue (e.Handled, "TestAssertMultipleHandlers() Handled incorrect #2");
+			};
+
+			Contract.Assert (false);
+
+			Assert.IsTrue (visited1, "TestAssertMultipleHandlers() visited1 incorrect");
+			Assert.IsTrue (visited2, "TestAssertMultipleHandlers() visited2 incorrect");
+		}
+
+	}
+}
+
+#endif

Property changes on: Test/System.Diagnostics.Contracts/ContractAssertTest.cs
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs
===================================================================
--- Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs	(revision 0)
@@ -0,0 +1,76 @@
+#if NET_4_0
+
+#define CONTRACTS_FULL
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using System.Diagnostics.Contracts;
+using MonoTests.System.Diagnostics.Contracts.Helpers;
+
+namespace MonoTests.System.Diagnostics.Contracts {
+
+	[TestFixture]
+	public class ContractMarkerMethodsTest : TestContractBase {
+
+		/// &lt;summary&gt;
+		/// Contract.EndContractBlock() has no effects.
+		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestEndContractBlock ()
+		{
+			Contract.EndContractBlock ();
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.OldValue() has no effect, and always returns the default value for \
the type. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestOldValue ()
+		{
+			int i = Contract.OldValue&lt;int&gt; (8);
+			object o = Contract.OldValue&lt;object&gt; (new object ());
+
+			Assert.AreEqual (0, i, "TestOldValue() int value wrong");
+			Assert.IsNull (o, "TestOldValue() object value wrong");
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Result() has no effect, and always returns the default value for the \
type. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestResult ()
+		{
+			int i = Contract.Result&lt;int&gt; ();
+			object o = Contract.Result&lt;object&gt; ();
+
+			Assert.AreEqual (0, i, "TestResult() int value wrong");
+			Assert.IsNull (o, "TestResult() object value wrong");
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.ValueAtReturn() has no effect, and always returns the default value \
for the type. +		/// &lt;/summary&gt;
+		[Test, RunAgainstReference]
+		public void TestValueAtReturn ()
+		{
+			int iOut, i;
+			object oOut, o;
+
+			i = Contract.ValueAtReturn (out iOut);
+			o = Contract.ValueAtReturn (out oOut);
+
+			Assert.AreEqual (0, i, "TestValueAtReturn() int return value wrong");
+			Assert.IsNull (o, "TestValueAtReturn() object return value wrong");
+			Assert.AreEqual (0, iOut, "TestValueAtReturn() int out value wrong");
+			Assert.IsNull (oOut, "TestValueAtReturn() object out value wrong");
+		}
+
+	}
+
+}
+
+#endif

Property changes on: Test/System.Diagnostics.Contracts/ContractMarkerMethodsTest.cs
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/ChangeLog
===================================================================
--- Test/System.Diagnostics.Contracts/ChangeLog	(revision 0)
+++ Test/System.Diagnostics.Contracts/ChangeLog	(revision 0)
@@ -0,0 +1,4 @@
+2010-06-23  Chris Bacon <a class="moz-txt-link-rfc2396E" \
href="mailto:chrisbacon76@gmail.com">&lt;chrisbacon76@gmail.com&gt;</a> +
+	* Added all files
+

Property changes on: Test/System.Diagnostics.Contracts/ChangeLog
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

Index: Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs
===================================================================
--- Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs	(revision 0)
+++ Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs	(revision 0)
@@ -0,0 +1,121 @@
+#if NET_4_0
+
+#define CONTRACTS_FULL
+#define DEBUG
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using System.Diagnostics.Contracts;
+using MonoTests.System.Diagnostics.Contracts.Helpers;
+
+namespace MonoTests.System.Diagnostics.Contracts {
+
+	[TestFixture]
+	public class ContractMustUseRewriterTest : TestContractBase {
+
+		private void CheckMustUseRewriter (string expectedMsg, params Action[] fnTests)
+		{
+			foreach (var fnTest in fnTests) {
+				try {
+					fnTest ();
+					Assert.Fail ("CheckMustUseRewriter() exception not thrown");
+				} catch (Exception ex) {
+					Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
"CheckMustUseRewriter() wrong exception thrown"); +				}
+			}
+
+			bool handlerVisited = false;
+			Contract.ContractFailed += (sender, e) =&gt; {
+				handlerVisited = true;
+			};
+
+			foreach (var fnTest in fnTests) {
+				try {
+					fnTest ();
+					Assert.Fail ("CheckMustUseRewriter() exception not thrown");
+				} catch (Exception ex) {
+					Assert.IsInstanceOfType (typeof (NotImplementedException), ex, \
"CheckMustUseRewriter() wrong exception thrown"); +				}
+			}
+
+			Assert.IsFalse (handlerVisited, "CheckMustUseRewriter() handled visited");
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Requires() ALWAYS triggers an assert, regardless of any other \
factors. +		/// &lt;/summary&gt;
+		[Test]
+		public void TestRequires ()
+		{
+			CheckMustUseRewriter ("Description: Must use the rewriter when using \
Contract.Requires", +				() =&gt; Contract.Requires (true),
+				() =&gt; Contract.Requires (false),
+				() =&gt; Contract.Requires (true, "Message"),
+				() =&gt; Contract.Requires (false, "Message")
+			);
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Requires() ALWAYS triggers an assert, regardless of any other \
factors. +		/// &lt;/summary&gt;
+		[Test]
+		public void TestRequiresTException ()
+		{
+			CheckMustUseRewriter ("Description: Must use the rewriter when using \
Contract.Requires&lt;TException&gt;", +				() =&gt; \
Contract.Requires&lt;Exception&gt; (true), +				() =&gt; \
Contract.Requires&lt;Exception&gt; (false), +				() =&gt; \
Contract.Requires&lt;Exception&gt; (true, "Message"), +				() =&gt; \
Contract.Requires&lt;Exception&gt; (false, "Message") +			);
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Ensures() ALWAYS triggers an assert, regardless of any other factors.
+		/// &lt;/summary&gt;
+		[Test]
+		public void TestEnsures ()
+		{
+			CheckMustUseRewriter ("Description: Must use the rewriter when using \
Contract.Ensures", +				() =&gt; Contract.Ensures (true),
+				() =&gt; Contract.Ensures (false),
+				() =&gt; Contract.Ensures (true, "Message"),
+				() =&gt; Contract.Ensures (false, "Message")
+			);
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Ensures() ALWAYS triggers an assert, regardless of any other factors.
+		/// &lt;/summary&gt;
+		[Test]
+		public void TestEnsuresOnThrow ()
+		{
+			CheckMustUseRewriter ("Description: Must use the rewriter when using \
Contract.EnsuresOnThrow", +				() =&gt; Contract.EnsuresOnThrow&lt;Exception&gt; \
(true), +				() =&gt; Contract.EnsuresOnThrow&lt;Exception&gt; (false),
+				() =&gt; Contract.EnsuresOnThrow&lt;Exception&gt; (true, "Message"),
+				() =&gt; Contract.EnsuresOnThrow&lt;Exception&gt; (false, "Message")
+			);
+		}
+
+		/// &lt;summary&gt;
+		/// Contract.Ensures() ALWAYS triggers an assert, regardless of any other factors.
+		/// &lt;/summary&gt;
+		[Test]
+		public void TestInvariant ()
+		{
+			CheckMustUseRewriter ("Description: Must use the rewriter when using \
Contract.Invariant", +				() =&gt; Contract.Invariant (true),
+				() =&gt; Contract.Invariant (false),
+				() =&gt; Contract.Invariant (true, "Message"),
+				() =&gt; Contract.Invariant (false, "Message")
+			);
+		}
+
+	}
+
+}
+
+#endif

Property changes on: Test/System.Diagnostics.Contracts/ContractMustUseRewriterTest.cs
___________________________________________________________________
Added: <a class="moz-txt-link-freetext" href="svn:eol-style">svn:eol-style</a>
   + native

_______________________________________________
Mono-devel-list mailing list
<a class="moz-txt-link-abbreviated" \
href="mailto:Mono-devel-list@lists.ximian.com">Mono-devel-list@lists.ximian.com</a> \
<a class="moz-txt-link-freetext" \
href="http://lists.ximian.com/mailman/listinfo/mono-devel-list">http://lists.ximian.com/mailman/listinfo/mono-devel-list</a>
  </pre>
  </blockquote>
  <pre wrap=""><!---->

  </pre>
</blockquote>
</body>
</html>



_______________________________________________
Mono-devel-list mailing list
Mono-devel-list@lists.ximian.com
http://lists.ximian.com/mailman/listinfo/mono-devel-list


[prev in list] [next in list] [prev in thread] [next in thread]