//
// Tests for combination of volatile & durable resource manangers
//
// Author:
//	Ankit Jain	<JAnkit@novell.com>
//
// Copyright (C) 2006 Novell, Inc (http://www.novell.com)
//

// This define is needed when running this tests under MS.NET as right
// now we always wrap thrown exceptions insde TransactionAbortedException.
// However, MS implementation in some cases, directly relays the exception
// thrown by RM without wrapping it. Not sure if this is a bug or a feature.
//#define MS_EXCEPTIONS_BEHAVIOR

using System;
using System.Transactions;
using NUnit.Framework;
using NUnit.Framework.Constraints;

namespace MonoTests.System.Transactions {

	[TestFixture]
	public class EnlistTest {

		#region Vol1_Dur0

		/* Single volatile resource, SPC happens */
		[Test]
		public void Vol1_Dur0 ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			irm.UseSingle = true;
			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}
			irm.CheckSPC ("irm");
		}

		[Test]
		public void Vol1_Dur0_2PC ()
		{
			IntResourceManager irm = new IntResourceManager (1);

			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}
			irm.Check2PC ("irm");
		}

		/* Single volatile resource, SPC happens */
		[Test]
		public void Vol1_Dur0_Fail1 ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			irm.UseSingle = true;
			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				/* Not completing this..
				scope.Complete ();*/
			}

			irm.Check ( 0, 0, 0, 1, 0, 0, 0, "irm" );
		}

		[Test]
		[ExpectedException ( typeof ( TransactionAbortedException ) )]
		public void Vol1_Dur0_Fail2 ()
		{
			IntResourceManager irm = new IntResourceManager (1);

			irm.FailPrepare = true;

			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}
		}

		[Test]
		[ExpectedException ( typeof ( TransactionAbortedException ) )]
		public void Vol1_Dur0_Fail3 ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			irm.UseSingle = true;
			irm.FailSPC = true;

			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}
		}

		#endregion

		#region Vol2_Dur0

		/* >1 volatile, 2PC */
		[Test]
		public void Vol2_Dur0_SPC ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			IntResourceManager irm2 = new IntResourceManager (3);

			irm.UseSingle = true;
			irm2.UseSingle = true;
			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;
				irm2.Value = 6;

				scope.Complete ();
			}
			irm.Check2PC ( "irm" );
			irm2.Check2PC ( "irm2" );
		}

		#endregion

		#region Vol0_Dur1
		/* 1 durable */
		[Test]
		public void Vol0_Dur1 ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			irm.Type = ResourceManagerType.Durable;
			irm.UseSingle = true;

			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}

			irm.CheckSPC ( "irm" );
		}

		/* We support only 1 durable with 2PC
		 * On .net, this becomes a distributed transaction
		 */ 
		[Test]
		[Category ("NotWorking")]
		public void Vol0_Dur1_2PC ()
		{
			IntResourceManager irm = new IntResourceManager (1);

			/* Durable resource enlisted with a IEnlistedNotification
			 * object
			 */
			irm.Type = ResourceManagerType.Durable;

			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}
		}

		[Test]
		public void Vol0_Dur1_Fail ()
		{
			IntResourceManager irm = new IntResourceManager ( 1 );

			/* Durable resource enlisted with a IEnlistedNotification
			 * object
			 */
			irm.Type = ResourceManagerType.Durable;
			irm.FailSPC = true;
			irm.UseSingle = true;
			try {
				using (TransactionScope scope = new TransactionScope ()) {
					irm.Value = 2;

					scope.Complete ();
				}
			}
			catch (TransactionAbortedException) {
				irm.Check ( 1, 0, 0, 0, 0, 0, 0, "irm" );
				return;
			}

			Assert.Fail ();
		}
		#endregion

		#region Vol2_Dur1
		/* >1vol + 1 durable */
		[Test]
		public void Vol2_Dur1 ()
		{
			IntResourceManager [] irm = new IntResourceManager [4];
			irm [0] = new IntResourceManager ( 1 );
			irm [1] = new IntResourceManager ( 3 );
			irm [2] = new IntResourceManager ( 5 );
			irm [3] = new IntResourceManager ( 7 );

			irm [0].Type = ResourceManagerType.Durable;
			for ( int i = 0; i < 4; i++ )
				irm [i].UseSingle = true;

			using (TransactionScope scope = new TransactionScope ()) {
				irm [0].Value = 2;
				irm [1].Value = 6;
				irm [2].Value = 10;
				irm [3].Value = 14;

				scope.Complete ();
			}

			irm [0].CheckSPC ( "irm [0]" );

			/* Volatile RMs get 2PC */
			for (int i = 1; i < 4; i++)
				irm [i].Check2PC ( "irm [" + i + "]" );
		}

		/* >1vol + 1 durable
		 * Durable fails SPC
		 */
		[Test]
		public void Vol2_Dur1_Fail1 ()
		{
			IntResourceManager [] irm = new IntResourceManager [4];
			irm [0] = new IntResourceManager (1);
			irm [1] = new IntResourceManager (3);
			irm [2] = new IntResourceManager (5);
			irm [3] = new IntResourceManager (7);

			irm [0].Type = ResourceManagerType.Durable;
			irm [0].FailSPC = true;

			for ( int i = 0; i < 4; i++ )
				irm [i].UseSingle = true;

			/* Durable RM irm[0] does Abort on SPC, so
			 * all volatile RMs get Rollback */
			try {
				using (TransactionScope scope = new TransactionScope ()) {
					irm [0].Value = 2;
					irm [1].Value = 6;
					irm [2].Value = 10;
					irm [3].Value = 14;

					scope.Complete ();
				}
			}
			catch (TransactionAbortedException) {
				irm [0].CheckSPC ( "irm [0]" );
				/* Volatile RMs get 2PC Prepare, and then get rolled back */
				for (int i = 1; i < 4; i++)
					irm [i].Check ( 0, 1, 0, 1, 0, 0, 0, "irm [" + i + "]" );

				return;
			}

			Assert.Fail();
		}

		/* >1vol + 1 durable 
		 * durable doesn't complete SPC
		 */
		[Test]
		[Ignore ( "Correct this test, it should throw TimeOutException or something" )]
		public void Vol2_Dur1_Fail2 ()
		{
			TransactionAbortedException exception = null;
			IntResourceManager [] irm = new IntResourceManager [4];
			irm [0] = new IntResourceManager (1);
			irm [1] = new IntResourceManager (3);
			irm [2] = new IntResourceManager (5);
			irm [3] = new IntResourceManager (7);

			irm [0].Type = ResourceManagerType.Durable;
			irm [0].IgnoreSPC = true;

			for ( int i = 0; i < 4; i++ )
				irm [i].UseSingle = true;

			/* Durable RM irm[2] does on SPC, so
			 * all volatile RMs get Rollback */
			try {
				using (TransactionScope scope = new TransactionScope ( TransactionScopeOption.Required, new TimeSpan ( 0, 0, 5 ) )) {
					irm [0].Value = 2;
					irm [1].Value = 6;
					irm [2].Value = 10;
					irm [3].Value = 14;

					scope.Complete ();
				}
			}
			catch (TransactionAbortedException ex) {
				irm [0].CheckSPC ( "irm [0]" );

				/* Volatile RMs get 2PC Prepare, and then get rolled back */
				for (int i = 1; i < 4; i++)
					irm [i].Check ( 0, 1, 0, 1, 0, 0, 0, "irm [" + i + "]" );

				exception = ex;
			}

			Assert.IsNotNull(exception, "Expected TransactionAbortedException not thrown!");
			Assert.IsNotNull(exception.InnerException, "TransactionAbortedException has no inner exception!");
			Assert.AreEqual(typeof(TimeoutException), exception.InnerException.GetType());
		}

		/* Same as Vol2_Dur1_Fail2, but with a volatile manager timming out */
		[Test]
		[Ignore ( "Correct this test, it should throw TimeOutException or something" )]
		public void Vol2_Dur1_Fail2b()
		{
			TransactionAbortedException exception = null;
			IntResourceManager[] irm = new IntResourceManager[4];
			irm[0] = new IntResourceManager(1);
			irm[1] = new IntResourceManager(3);
			irm[2] = new IntResourceManager(5);
			irm[3] = new IntResourceManager(7);

			irm[0].IgnoreSPC = true;
			irm[1].Type = ResourceManagerType.Durable;

			for (int i = 0; i < 4; i++)
				irm[i].UseSingle = true;

			/* Durable RM irm[2] does on SPC, so
			 * all volatile RMs get Rollback */
			try
			{
				using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(0, 0, 5)))
				{
					irm[0].Value = 2;
					irm[1].Value = 6;
					irm[2].Value = 10;
					irm[3].Value = 14;

					scope.Complete();
				}
			}
			catch (TransactionAbortedException ex)
			{
				irm[0].CheckSPC("irm [0]");

				/* Volatile RMs get 2PC Prepare, and then get rolled back */
				for (int i = 1; i < 4; i++)
					irm[i].Check(0, 1, 0, 1, 0, 0, 0, "irm [" + i + "]");

				exception = ex;
			}

			Assert.IsNotNull(exception, "Expected TransactionAbortedException not thrown!");
			Assert.IsNotNull(exception.InnerException, "TransactionAbortedException has no inner exception!");
			Assert.AreEqual(typeof(TimeoutException), exception.InnerException.GetType());
		}

		/* >1vol + 1 durable
		 * Volatile fails Prepare
		 */
		[Test]
		public void Vol2_Dur1_Fail3 ()
		{
			IntResourceManager [] irm = new IntResourceManager [4];
			irm [0] = new IntResourceManager ( 1 );
			irm [1] = new IntResourceManager ( 3 );
			irm [2] = new IntResourceManager ( 5 );
			irm [3] = new IntResourceManager ( 7 );

			irm [0].Type = ResourceManagerType.Durable;
			irm [2].FailPrepare = true;

			for ( int i = 0; i < 4; i++ )
				irm [i].UseSingle = true;

			/* Durable RM irm[2] does on SPC, so
			 * all volatile RMs get Rollback */
			try {
				using (TransactionScope scope = new TransactionScope ()) {
					irm [0].Value = 2;
					irm [1].Value = 6;
					irm [2].Value = 10;
					irm [3].Value = 14;

					scope.Complete ();
				}
			}
			catch (TransactionAbortedException) {
				irm [0].Check ( 0, 0, 0, 1, 0, 0, 0, "irm [0]");

				/* irm [1] & [2] get prepare,
				 * [2] -> ForceRollback,
				 * [1] & [3] get rollback,
				 * [0](durable) gets rollback */
				irm [1].Check ( 0, 1, 0, 1, 0, 0, 0, "irm [1]" );
				irm [2].Check ( 0, 1, 0, 0, 0, 0, 0, "irm [2]" );
				irm [3].Check ( 0, 0, 0, 1, 0, 0, 0, "irm [3]" );

				return;
			}

			Assert.Fail ( "Expected TransactionAbortedException" );
		}

		[Test]
		public void Vol2_Dur1_Fail4 ()
		{
			IntResourceManager [] irm = new IntResourceManager [2];
			irm [0] = new IntResourceManager ( 1 );
			irm [1] = new IntResourceManager ( 3 );

			irm [0].Type = ResourceManagerType.Durable;
			irm [0].FailSPC = true;
			irm [0].FailWithException = true;

			for ( int i = 0; i < 2; i++ )
				irm [i].UseSingle = true;

			/* Durable RM irm[2] does on SPC, so
			 * all volatile RMs get Rollback */
			try {
				using ( TransactionScope scope = new TransactionScope () ) {
					irm [0].Value = 2;
					irm [1].Value = 6;

					scope.Complete ();
				}
			}
			catch ( TransactionAbortedException e) {
				Assert.IsNotNull ( e.InnerException, "Expected e.InnerException == NotSupportedException, but got None");
				Assert.AreEqual ( typeof ( NotSupportedException ), e.InnerException.GetType (), "Expected e.InnerException == NotSupportedException, but got " + e.GetType () );

				irm [0].Check ( 1, 0, 0, 0, 0, 0, 0, "irm [0]" );
				irm [1].Check ( 0, 1, 0, 1, 0, 0, 0, "irm [1]" );
				return;
			}

			Assert.Fail ( "Expected TransactionAbortedException" );
		}

		[Test]
		public void Vol2_Dur1_Fail5 ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager [] irm = new IntResourceManager [2];
			irm [0] = new IntResourceManager ( 1 );
			irm [1] = new IntResourceManager ( 3 );

			Transaction.Current = ct;
			irm [0].Type = ResourceManagerType.Durable;
			irm [0].FailSPC = true;
			irm [0].FailWithException = true;

			for ( int i = 0; i < 2; i++ )
				irm [i].UseSingle = true;

			/* Durable RM irm[2] does on SPC, so
			 * all volatile RMs get Rollback */
			
			using ( TransactionScope scope = new TransactionScope () ) {
				irm [0].Value = 2;
				irm [1].Value = 6;

				scope.Complete ();
			}

			try {
				ct.Commit ();
			}
			catch ( TransactionAbortedException e ) {
				Assert.IsNotNull ( e.InnerException, "Expected e.InnerException == NotSupportedException, but got None" );
				Assert.AreEqual ( typeof ( NotSupportedException ), e.InnerException.GetType (), "Expected e.InnerException == NotSupportedException, but got " + e.GetType () );

				irm [0].Check ( 1, 0, 0, 0, 0, 0, 0, "irm [0]" );
				irm [1].Check ( 0, 1, 0, 1, 0, 0, 0, "irm [1]" );
				try {
					ct.Commit ();
				}
				catch (InvalidOperationException x ) {
					Assert.IsNull ( x.InnerException);
					Transaction.Current = null;
					return;
				}
				Assert.Fail ( "Should not be reached" );
			}

			Assert.Fail ( "Expected TransactionAbortedException" );
		}

		#endregion

		#region Promotable Single Phase Enlistment
		[Test]
		public void Vol0_Dur0_Pspe1 ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			irm.Type = ResourceManagerType.Promotable;
			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

				scope.Complete ();
			}
			irm.Check ( 1, 0, 0, 0, 0, 1, 0, "irm" );
		}

		[Test]
		public void Vol1_Dur0_Pspe1 ()
		{
			IntResourceManager irm0 = new IntResourceManager (1);
			IntResourceManager irm1 = new IntResourceManager (1);
			irm1.Type = ResourceManagerType.Promotable;
			using (TransactionScope scope = new TransactionScope ()) {
				irm0.Value = 2;
				irm1.Value = 8;

				scope.Complete ();
			}
			irm1.Check ( 1, 0, 0, 0, 0, 1, 0, "irm1" );
		}

		[Test]
		public void Vol0_Dur1_Pspe1 ()
		{
			IntResourceManager irm0 = new IntResourceManager (1);
			IntResourceManager irm1 = new IntResourceManager (1);
			irm0.Type = ResourceManagerType.Durable;
			irm0.UseSingle = true;
			irm1.Type = ResourceManagerType.Promotable;
			using (TransactionScope scope = new TransactionScope ()) {
				irm0.Value = 8;
				irm1.Value = 2;
				Assert.AreEqual(0, irm1.NumEnlistFailed, "PSPE enlist did not fail although durable RM was already enlisted");
			}
		}

		[Test]
		public void Vol0_Dur0_Pspe2 ()
		{
			IntResourceManager irm0 = new IntResourceManager (1);
			IntResourceManager irm1 = new IntResourceManager (1);
			irm0.Type = ResourceManagerType.Promotable;
			irm1.Type = ResourceManagerType.Promotable;
			using (TransactionScope scope = new TransactionScope ()) {
				irm0.Value = 8;
				irm1.Value = 2;
				Assert.AreEqual(0, irm1.NumEnlistFailed, "PSPE enlist did not fail although PSPE RM was already enlisted");
			}
		}
		#endregion

		#region Others
		/* >1vol  
		 * > 1 durable, On .net this becomes a distributed transaction
		 * We don't support this in mono yet. 
		 */
		[Test]
		[Category ("NotWorking")]
		public void Vol0_Dur2 ()
		{
			IntResourceManager [] irm = new IntResourceManager [2];
			irm [0] = new IntResourceManager ( 1 );
			irm [1] = new IntResourceManager ( 3 );

			irm [0].Type = ResourceManagerType.Durable;
			irm [1].Type = ResourceManagerType.Durable;

			for ( int i = 0; i < 2; i++ )
				irm [i].UseSingle = true;

			using (TransactionScope scope = new TransactionScope ()) {
				irm [0].Value = 2;
				irm [1].Value = 6;

				scope.Complete ();
			}
		}

		[Test]
		public void TransactionDispose ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager irm = new IntResourceManager (1);
			irm.Type = ResourceManagerType.Durable;

			ct.Dispose ();
			irm.Check  (0, 0, 0, 0, "Dispose transaction");
		}

		[Test]
		public void TransactionDispose2 ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager irm = new IntResourceManager (1);

			Transaction.Current = ct;
			irm.Value = 5;

			try {
				ct.Dispose ();
			} finally {
				Transaction.Current = null;
			}

			irm.Check (0, 0, 1, 0, "Dispose transaction");
			Assert.AreEqual (1, irm.Value);
		}

		[Test]
		public void TransactionDispose3 ()
		{
			CommittableTransaction ct = new CommittableTransaction ();
			IntResourceManager irm = new IntResourceManager (1);

			try {
				Transaction.Current = ct;
				irm.Value = 5;
				ct.Commit ();
				ct.Dispose ();
			} finally {
				Transaction.Current = null;
			}

			irm.Check (1, 1, 0, 0, "Dispose transaction");
			Assert.AreEqual (5, irm.Value);
		}
		#endregion

		#region TransactionCompleted
		[Test]
		public void TransactionCompleted_Committed ()
		{
			bool called = false;
			using (var ts = new TransactionScope ())
			{
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => called = true;
				ts.Complete ();
			}

			Assert.IsTrue (called, "TransactionCompleted event handler not called!");
		}

		[Test]
		public void TransactionCompleted_Rollback ()
		{
			bool called = false;
			using (var ts = new TransactionScope ())
			{
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => called = true;
				// Not calling ts.Complete() on purpose..
			}

			Assert.IsTrue (called, "TransactionCompleted event handler not called!");
		}
		#endregion

		#region Success/Failure behavior tests
		#region Success/Failure behavior Vol1_Dur0 Cases
		[Test]
		public void Vol1SPC_Committed()
		{
			bool called = false;
			TransactionStatus status = TransactionStatus.Active;
			var rm = new IntResourceManager(1)
			{
				UseSingle = true,
				Type = ResourceManagerType.Volatile
			};

			using (var ts = new TransactionScope())
			{
				rm.Value = 2;
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
				ts.Complete();
			}

			rm.Check(1, 0, 0, 0, 0, 0, 0, "rm");
			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Committed, status, "TransactionStatus != Commited");
		}

		[Test]
		public void Vol1_Committed()
		{
			bool called = false;
			TransactionStatus status = TransactionStatus.Active;
			var rm = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile,
			};

			using (var ts = new TransactionScope())
			{
				rm.Value = 2;
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
				ts.Complete();
			}

			rm.Check(0, 1, 1, 0, 0, 0, 0, "rm");
			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Committed, status, "TransactionStatus != Commited");
		}

		[Test]
		public void Vol1_Rollback()
		{
			bool called = false;
			TransactionStatus status = TransactionStatus.Active;
			var rm = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile,
			};

			using (var ts = new TransactionScope())
			{
				rm.Value = 2;
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
				// Not calling ts.Complete() on purpose..
			}

			rm.Check(0, 0, 0, 1, 0, 0, 0, "rm");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
		}

		[Test]
		public void Vol1SPC_Throwing_On_Commit()
		{
			bool called = false;
			Exception ex = null;
			TransactionStatus status = TransactionStatus.Active;
			var rm = new IntResourceManager(1)
			{
				UseSingle = true,
				FailSPC = true,
				FailWithException = true,
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm.Value = 2;
					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm.Check(1, 0, 0, 0, 0, 0, 0, "rm");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
			Assert.IsNotNull(ex, "Exception not thrown");
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException is null");
			Assert.That (ex.InnerException, InstanceOf( typeof(NotSupportedException)), "Invalid inner exception thrown");
		}

		[Test]
		public void Vol1_Throwing_On_Commit()
		{
			bool called = false;
			TransactionStatus status = TransactionStatus.Active;
			Exception ex = null;
			var rm = new IntResourceManager(1)
			{
				FailCommit = true,
				FailWithException = true,
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm.Value = 2;
					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm.Check(0, 1, 1, 0, 0, 0, 0, "rm");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
#if MS_EXCEPTIONS_BEHAVIOR
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			InstanceOf(typeof(NotSupportedException), ex, "Invalid exception thrown");
#else
			// Mono wrapps the exception into a TransactionAbortedException.
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid type of exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException not thrown");
			Assert.That (ex.InnerException, InstanceOf( typeof(NotSupportedException)), "Invalid inner exception thrown");
#endif
		}

		[Test]
		public void Vol1_Throwing_On_Rollback()
		{
			bool called = false;
			TransactionStatus status = TransactionStatus.Active;
			Exception ex = null;
			var rm = new IntResourceManager(1)
			{
				FailRollback = true,
				FailWithException = true,
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm.Value = 2;
					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					// Not calling ts.Complete() on purpose..
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm.Check(0, 0, 0, 1, 0, 0, 0, "rm");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			Assert.That (ex, InstanceOf( typeof(NotSupportedException)), "Invalid exception thrown");
		}

		[Test]
		public void Vol1_Throwing_On_Prepare()
		{
			bool called = false;
			TransactionStatus status = TransactionStatus.Active;
			Exception ex = null;
			var rm = new IntResourceManager(1)
			{
				FailPrepare = true,
				FailWithException = true,
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm.Value = 2;
					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm.Check(0, 1, 0, 0, 0, 0, 0, "rm");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.IsNotNull(ex, "Exception not thrown");
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException is null");
			Assert.That (ex.InnerException, InstanceOf( typeof(NotSupportedException)), "Invalid inner exception thrown");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
		}
		#endregion

		#region Success/Failure behavior Vol2_Dur0 Cases
		[Test]
		public void Vol2SPC_Committed()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			var rm1 = new IntResourceManager(1)
			{
				UseSingle = true,
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				UseSingle = true,
				Type = ResourceManagerType.Volatile
			};

			using (var ts = new TransactionScope())
			{
				rm1.Value = 11;
				rm2.Value = 22;
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
				ts.Complete();
			}

			// There can be only one *Single* PC enlistment,
			// so TM will downgrade both to normal enlistments.
			rm1.Check(0, 1, 1, 0, 0, 0, 0, "rm1");
			rm2.Check(0, 1, 1, 0, 0, 0, 0, "rm2");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Committed, status, "TransactionStatus != Committed");
		}

		[Test]
		public void Vol2_Committed()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			var rm1 = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile
			};

			using (var ts = new TransactionScope())
			{
				rm1.Value = 11;
				rm2.Value = 22;
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
				ts.Complete();
			}
			rm1.Check(0, 1, 1, 0, 0, 0, 0, "rm1");
			rm2.Check(0, 1, 1, 0, 0, 0, 0, "rm2");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Committed, status, "TransactionStatus != Committed");
		}

		[Test]
		public void Vol2_Rollback()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			var rm1 = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile
			};

			using (var ts = new TransactionScope())
			{
				rm1.Value = 11;
				rm2.Value = 22;
				var tr = Transaction.Current;
				tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
				// Not calling ts.Complete() on purpose..
			}

			rm1.Check(0, 0, 0, 1, 0, 0, 0, "rm1");
			rm2.Check(0, 0, 0, 1, 0, 0, 0, "rm2");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
		}

		[Test]
		public void Vol2SPC_Throwing_On_Commit()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				UseSingle = true,
				FailCommit = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm1"),
				Type = ResourceManagerType.Volatile,
			};
			var rm2 = new IntResourceManager(2)
			{
				UseSingle = true,
				Type = ResourceManagerType.Volatile,
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			// There can be only one *Single* PC enlistment,
			// so TM will downgrade both to normal enlistments.
			rm1.Check(0, 1, 1, 0, 0, 0, 0, "rm1");
			rm2.Check(0, 1, 0, 0, 0, 0, 0, "rm2");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
#if MS_EXCEPTIONS_BEHAVIOR
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			Assert.AreEqual(rm1.ThrowThisException, ex, "Exception does not come from the expected RM");
#else
			// Mono wrapps the exception into a TransactionAbortedException.
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid type of exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException not thrown");
			Assert.AreEqual(rm1.ThrowThisException, ex.InnerException, "Exception does not come from the expected RM \n Ex: {0}", ex);
#endif
		}

		[Test]
		public void Vol2_Throwing_On_Commit()
		{
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				FailCommit = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm1"),
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => called = true;
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm1.Check(0, 1, 1, 0, 0, 0, 0, "rm1");
			rm2.Check(0, 1, 0, 0, 0, 0, 0, "rm2");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
#if MS_EXCEPTIONS_BEHAVIOR
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			Assert.AreEqual(rm1.ThrowThisException, ex, "Exception does not come from the expected RM \n Ex: {0}", ex);
#else
			// Mono wrapps the exception into a TransactionAbortedException.
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid type of exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException not thrown");
			Assert.AreEqual(rm1.ThrowThisException, ex.InnerException, "Exception does not come from the expected RM \n Ex: {0}", ex);
#endif
		}

		[Test]
		public void Vol2_Throwing_On_Rollback()
		{
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				FailRollback = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm1"),
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => called = true;
					// Not calling ts.Complete() on purpose..
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm1.Check(0, 0, 0, 1, 0, 0, 0, "rm1");
			rm2.Check(0, 0, 0, 0, 0, 0, 0, "rm2");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			Assert.AreEqual(rm1.ThrowThisException, ex, "Exception does not come from the expected RM \n Ex: {0}", ex);

		}

		[Test]
		public void Vol2_Throwing_On_First_Prepare()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				FailPrepare = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm1"),
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm1.Check(0, 1, 0, 0, 0, 0, 0, "rm1");
			rm2.Check(0, 0, 0, 1, 0, 0, 0, "rm2");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.IsNotNull(ex, "Exception not thrown");
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException is null");
			Assert.That (ex.InnerException, InstanceOf( typeof(InvalidOperationException)), "Invalid inner exception thrown");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
		}

		[Test]
		public void Vol2_Throwing_On_Second_Prepare()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				FailPrepare = true,
				FailWithException = true,
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm1.Check(0, 1, 0, 1, 0, 0, 0, "rm1");
			rm2.Check(0, 1, 0, 0, 0, 0, 0, "rm2");

			Assert.IsTrue(called, "TransactionCompleted event handler not called!");
			Assert.IsNotNull(ex, "Exception not thrown");
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException is null");
			Assert.That (ex.InnerException, InstanceOf( typeof(NotSupportedException)), "Invalid inner exception thrown");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
		}

		[Test]
		public void Vol2_Throwing_On_First_Prepare_And_Second_Rollback()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				FailPrepare = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm1"),
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				FailRollback = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm2"),
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm1.Check(0, 1, 0, 0, 0, 0, 0, "rm1");
			rm2.Check(0, 0, 0, 1, 0, 0, 0, "rm2");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
#if MS_EXCEPTIONS_BEHAVIOR
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			Assert.AreEqual(rm2.ThrowThisException, ex, "Exception does not come from the expected RM");
#else
			// Mono wrapps the exception into a TransactionAbortedException.
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid type of exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException not thrown");
			Assert.AreEqual(rm2.ThrowThisException, ex.InnerException, "Exception does not come from the expected RM \n Ex: {0}", ex.InnerException);
#endif
		}

		[Test]
		public void Vol2_Throwing_On_First_Rollback_And_Second_Prepare()
		{
			TransactionStatus status = TransactionStatus.Active;
			bool called = false;
			Exception ex = null;
			var rm1 = new IntResourceManager(1)
			{
				FailRollback = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm1"),
				Type = ResourceManagerType.Volatile
			};
			var rm2 = new IntResourceManager(2)
			{
				FailPrepare = true,
				FailWithException = true,
				ThrowThisException = new InvalidOperationException("rm2"),
				Type = ResourceManagerType.Volatile
			};

			try
			{
				using (var ts = new TransactionScope())
				{
					rm1.Value = 11;
					rm2.Value = 22;

					var tr = Transaction.Current;
					tr.TransactionCompleted += (s, e) => { called = true; status = e.Transaction.TransactionInformation.Status; };
					ts.Complete();
				}
			}
			catch (Exception _ex)
			{
				ex = _ex;
			}

			rm1.Check(0, 1, 0, 1, 0, 0, 0, "rm1");
			rm2.Check(0, 1, 0, 0, 0, 0, 0, "rm2");

			// MS.NET wont call TransactionCompleted event in this particular case.
			Assert.IsFalse(called, "TransactionCompleted event handler _was_ called!?!?!");
			Assert.IsNotNull(ex, "Exception not thrown");
#if MS_EXCEPTIONS_BEHAVIOR
			// MS.NET will relay the exception thrown by RM instead of wrapping it on a TransactionAbortedException.
			Assert.AreEqual(rm1.ThrowThisException, ex, "Exception does not come from the expected RM");
#else
			// Mono wrapps the exception into a TransactionAbortedException.
			Assert.That (ex, InstanceOf( typeof(TransactionAbortedException)), "Invalid type of exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException not thrown");
			Assert.AreEqual(rm1.ThrowThisException, ex.InnerException, "Exception does not come from the expected RM \n Ex: {0}", ex);
#endif
		}


		#endregion

		#endregion

		public static InstanceOfTypeConstraint InstanceOf (Type expectedType)
		{
			return new InstanceOfTypeConstraint (expectedType);
		}
	}
}