C# IntResourceManager.Check方法代码示例

		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" );
		}

		public void TransactionScopeAbort ()
		{
			Assert.IsNull (Transaction.Current, "Ambient transaction exists");
			IntResourceManager irm = new IntResourceManager (1);
			using (TransactionScope scope = new TransactionScope ()) {
				Assert.IsNotNull (Transaction.Current, "Ambient transaction does not exist");
				Assert.AreEqual (TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "transaction is not active");

				irm.Value = 2;
				/* Not completing scope here */
			}
			irm.Check ( 0, 0, 1, 0, "irm");
			Assert.AreEqual (1, irm.Value);
			Assert.IsNull (Transaction.Current, "Ambient transaction exists");
		}

		public void RMFail1 ()
		{
			IntResourceManager irm = new IntResourceManager (1);
			IntResourceManager irm2 = new IntResourceManager (10);
			IntResourceManager irm3 = new IntResourceManager (12);

			Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)");
			try {
				using (TransactionScope scope = new TransactionScope ()) {
					irm.Value = 2;
					irm2.Value = 20;
					irm3.Value = 24;

					/* Make second RM fail to prepare, this should throw
					 * TransactionAbortedException when the scope ends 
					 */
					irm2.FailPrepare = true;
					scope.Complete ();
				}
			} catch (TransactionAbortedException) {
				irm.Check ( 1, 0, 1, 0, "irm");
				irm2.Check ( 1, 0, 0, 0, "irm2");
				irm3.Check ( 0, 0, 1, 0, "irm3");
			}
			Assert.IsNull (Transaction.Current, "Ambient transaction exists (after)");
		}

		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");
		}

		public void Async5 ()
		{
			IntResourceManager irm = new IntResourceManager ( 1 );

			CommittableTransaction ct = new CommittableTransaction ();
			/* Set ambient Tx */
			Transaction.Current = ct;

			/* Enlist */
			irm.Value = 2;
			irm.FailPrepare = true;

			IAsyncResult ar = ct.BeginCommit ( null, null );
			ar.AsyncWaitHandle.WaitOne ();
			Assert.IsTrue ( ar.IsCompleted );
			try {
				CommittableTransaction ctx = ar as CommittableTransaction;
				ctx.EndCommit ( ar );
			} catch ( TransactionAbortedException ) {
				irm.Check ( 1, 0, 0, 0, "irm" );
				return;
			}

			Assert.Fail ("EndCommit should've failed");
		}

		public void Async3 ()
		{
			IntResourceManager irm = new IntResourceManager ( 1 );

			CommittableTransaction ct = new CommittableTransaction ();
			/* Set ambient Tx */
			Transaction.Current = ct;

			/* Enlist */
			irm.Value = 2;

			IAsyncResult ar = ct.BeginCommit ( null, null );
			ct.EndCommit ( ar );

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

		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");
		}

		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.IsInstanceOfType(ex, typeof(TransactionAbortedException), "Invalid exception thrown");
			Assert.IsNotNull(ex.InnerException, "InnerException is null");
            Assert.IsInstanceOfType(ex.InnerException, typeof(NotSupportedException), "Invalid inner exception thrown");
			Assert.AreEqual(TransactionStatus.Aborted, status, "TransactionStatus != Aborted");
		}

		public void ExplicitTransaction8a ()
		{
			CommittableTransaction ct = new CommittableTransaction ();

			IntResourceManager irm = new IntResourceManager ( 1 );
			using ( TransactionScope scope = new TransactionScope ( ct ) ) {
				irm.Value = 2;
				scope.Complete ();
				/* FIXME: Why TransactionAbortedException ?? */
				try {
					ct.Commit ();
				}
				catch ( TransactionAbortedException) {
					irm.Check ( 0, 0, 1, 0, "irm" );
					return;
				}
				Assert.Fail ( "Should not be reached" );
			}
		}

		public void NestedTransactionScope1 ()
		{
			IntResourceManager irm = new IntResourceManager (1);

			Assert.IsNull (Transaction.Current, "Ambient transaction exists");
			using (TransactionScope scope = new TransactionScope ()) {
				irm.Value = 2;

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

			Assert.IsNull (Transaction.Current, "Ambient transaction exists");
			/* Value = 2, got committed */
			Assert.AreEqual (irm.Value, 2, "#1");
			irm.Check ( 1, 1, 0, 0, "irm" );
		}

		public void ExplicitTransaction6c ()
		{
			CommittableTransaction ct = new CommittableTransaction ();

			IntResourceManager irm = new IntResourceManager ( 1 );

			Transaction.Current = ct;

			TransactionScope scope1 = new TransactionScope (TransactionScopeOption.RequiresNew);
			/* Enlist */
			irm.Value = 2;

			TransactionScope scope2 = new TransactionScope ();
			try {
				scope1.Dispose ();
			} catch (InvalidOperationException) {
				/* Error: TransactionScope nested incorrectly */
				irm.Check ( 0, 0, 1, 0, "irm" );
				scope2.Dispose ();
				Transaction.Current = null;
				return;
			}

			Assert.Fail ("Commit should've failed");
		}

		public void ExplicitTransaction6b ()
		{
			CommittableTransaction ct = new CommittableTransaction ();

			IntResourceManager irm = new IntResourceManager ( 1 );
			
			Transaction.Current = ct; 

			TransactionScope scope1 = new TransactionScope ();
			/* Enlist */
			irm.Value = 2;

			scope1.Complete ();

			try {
				ct.Commit ();
			} catch (TransactionAbortedException) {
				irm.Check ( 0, 0, 1, 0, "irm" );
				
				scope1.Dispose ();
				Transaction.Current = null;
				return;
			}
			Assert.Fail ( "Commit should've failed" );
		}

		public void ExplicitTransaction5 ()
		{
			Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)");
			CommittableTransaction ct = new CommittableTransaction ();
			Transaction oldTransaction = Transaction.Current;

			/* Not setting ambient transaction 
			 Transaction.Current = ct; 
			 */

			IntResourceManager irm = new IntResourceManager (1);

			using (TransactionScope scope = new TransactionScope (ct)) {
				Assert.AreEqual (ct, Transaction.Current, "#59");

				irm.Value = 2;

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

			Assert.AreEqual (oldTransaction, Transaction.Current, "#60");
			Assert.AreEqual (TransactionStatus.Aborted, ct.TransactionInformation.Status, "#61");
			Assert.AreEqual (1, irm.Actual, "#62"); /* Actual value */

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

		public void ExplicitTransaction4 ()
		{
			Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)");
			CommittableTransaction ct = new CommittableTransaction ();
			Transaction oldTransaction = Transaction.Current;

			/* Not setting ambient transaction 
			 Transaction.Current = ct; 
			 */

			IntResourceManager irm = new IntResourceManager (1);

			using (TransactionScope scope = new TransactionScope (ct)) {
				Assert.AreEqual (ct, Transaction.Current, "#53");

				irm.Value = 2;
				scope.Complete ();
			}

			Assert.AreEqual (oldTransaction, Transaction.Current, "#54");
			Assert.AreEqual (TransactionStatus.Active, ct.TransactionInformation.Status, "#55");
			Assert.AreEqual (1, irm.Actual, "#56"); /* Actual value */

			ct.Commit ();
			Assert.AreEqual (2, irm.Actual, "#57"); /* New committed actual value */
			Assert.AreEqual (TransactionStatus.Committed, ct.TransactionInformation.Status, "#58");

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

		public void ExplicitTransaction2 ()
		{
			Assert.IsNull (Transaction.Current, "Ambient transaction exists (before)");
			CommittableTransaction ct = new CommittableTransaction ();
			Transaction oldTransaction = Transaction.Current;

			Transaction.Current = ct;

			IntResourceManager irm = new IntResourceManager (1);

			irm.Value = 2;
			using (TransactionScope scope = new TransactionScope ()) {
				Assert.AreEqual (ct, Transaction.Current, "#44");

				/* Not calling scope.Complete
				scope.Complete ();*/
			}

			Assert.AreEqual (TransactionStatus.Aborted, ct.TransactionInformation.Status, "#45");
			Assert.AreEqual (ct, Transaction.Current, "#46");
			Assert.AreEqual (1, irm.Actual, "#47");
			Assert.AreEqual (1, irm.NumRollback, "#48");
			irm.Check ( 0, 0, 1, 0, "irm" );
			Transaction.Current = oldTransaction;

			try {
				ct.Commit ();
			} catch (TransactionAbortedException) {
				return;
			}
			Assert.Fail ("Commit on an aborted transaction should fail");
		}