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 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 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 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 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");
}
public void NestedTransactionScope8a()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Suppress))
{
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope())
{
irm2.Value = 20;
scope2.Complete();
}
irm2.Check(1, 1, 0, 0, "irm2");
Assert.AreEqual(20, irm2.Value, "#16a");
scope.Complete();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
Assert.AreEqual(2, irm.Value, "#18a");
irm.Check(0, 0, 0, 0, "irm");
}
public void NestedTransactionScope9()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists (before)");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope(TransactionScopeOption.Suppress)) {
/* Not transactional, so this WONT get committed */
irm2.Value = 4;
scope2.Complete();
}
irm2.Check(0, 0, 0, 0, "irm2");
using (TransactionScope scope3 = new TransactionScope(TransactionScopeOption.RequiresNew)) {
irm.Value = 6;
scope3.Complete();
}
/* vr's value has changed as the inner scope committed = 6 */
irm.Check(1, 1, 0, 0, "irm");
Assert.AreEqual(irm.Value, 6, "#19");
Assert.AreEqual(irm.Actual, 6, "#20");
Assert.AreEqual(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "#21");
scope.Complete();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists (after)");
Assert.AreEqual(irm.Value, 6, "#22");
irm.Check(2, 2, 0, 0, "irm");
}
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 ExplicitTransaction15()
{
CommittableTransaction ct = new CommittableTransaction();
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(3);
Assert.IsNull(Transaction.Current);
Transaction.Current = ct;
try
{
using (TransactionScope scope = new TransactionScope())
{
irm.Value = 2;
Transaction.Current = new CommittableTransaction();
irm2.Value = 6;
}
}
catch (InvalidOperationException)
{
irm.Check(0, 0, 1, 0, "irm");
irm2.Check(0, 0, 1, 0, "irm2");
Transaction.Current = null;
return;
}
Assert.Fail("Should not be reached");
}
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 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");
}
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");
}
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 ExplicitTransaction10b()
{
CommittableTransaction ct = new CommittableTransaction();
IntResourceManager irm = new IntResourceManager(1);
Transaction.Current = ct;
irm.Value = 2;
Transaction.Current = null;
TransactionScope scope = new TransactionScope(ct);
Assert.AreEqual(ct, Transaction.Current, "ambient transaction");
//scope2.Complete ();
//scope2.Dispose ();
IAsyncResult ar = ct.BeginCommit(null, null);
try {
ct.EndCommit(ar);
}
catch (TransactionAbortedException) {
irm.Check(0, 0, 1, 0, "irm");
Transaction.Current = null;
return;
}
Transaction.Current = null;
Assert.Fail();
}
public void Async2()
{
IntResourceManager irm = new IntResourceManager(1);
CommittableTransaction ct = new CommittableTransaction();
using (TransactionScope scope = new TransactionScope(ct))
{
irm.Value = 2;
//scope.Complete ();
IAsyncResult ar = ct.BeginCommit(null, null);
try
{
ct.EndCommit(ar);
}
catch (TransactionAbortedException)
{
irm.Check(0, 0, 1, 0, "irm");
return;
}
}
Assert.Fail("EndCommit should've thrown an exception");
}
public void NestedTransactionScope7()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope(TransactionScopeOption.RequiresNew)) {
irm2.Value = 20;
/* Not completing
* scope2.Complete();*/
}
/* irm2, rolled back*/
irm2.Check(0, 0, 1, 0, "irm2");
Assert.AreEqual(irm2.Value, 10, "#13");
Assert.AreEqual(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "#14");
scope.Complete();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
/* ..But irm got committed */
Assert.AreEqual(irm.Value, 2, "#15");
irm.Check(1, 1, 0, 0, "irm");
}
public void NestedTransactionScope8()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope(TransactionScopeOption.Suppress)) {
/* Not transactional, so this WONT get committed */
irm2.Value = 20;
scope2.Complete();
}
irm2.Check(0, 0, 0, 0, "irm2");
Assert.AreEqual(20, irm2.Value, "#16");
Assert.AreEqual(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "#17");
scope.Complete();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
Assert.AreEqual(irm.Value, 2, "#18");
irm.Check(1, 1, 0, 0, "irm");
}
public void NestedTransactionScope5()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope()) {
irm2.Value = 20;
scope2.Complete();
}
Assert.AreEqual(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "#8");
/* Not completing outer scope
* scope.Complete (); */
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
Assert.AreEqual(irm.Value, 1, "#9");
Assert.AreEqual(irm2.Value, 10, "#10");
irm.Check(0, 0, 1, 0, "irm");
irm2.Check(0, 0, 1, 0, "irm2");
}
public void NestedTransactionScope6()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope(TransactionScopeOption.RequiresNew)) {
irm2.Value = 20;
scope2.Complete();
}
/* vr2, committed */
irm2.Check(1, 1, 0, 0, "irm2");
Assert.AreEqual(irm2.Value, 20);
Assert.AreEqual(TransactionStatus.Active, Transaction.Current.TransactionInformation.Status, "#11");
scope.Complete();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
Assert.AreEqual(irm.Value, 2, "#12");
irm.Check(1, 1, 0, 0, "irm");
}
public void NestedTransactionScope4()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope()) {
irm2.Value = 20;
/* Inner Tx not completed, Tx should get rolled back */
//scope2.Complete();
}
/* Both rolledback */
irm.Check(0, 0, 1, 0, "irm");
irm2.Check(0, 0, 1, 0, "irm2");
Assert.AreEqual(TransactionStatus.Aborted, Transaction.Current.TransactionInformation.Status, "#5");
//scope.Complete ();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
Assert.AreEqual(irm.Value, 1, "#6");
Assert.AreEqual(irm2.Value, 10, "#7");
irm.Check(0, 0, 1, 0, "irm");
}
public void NestedTransactionScope3()
{
IntResourceManager irm = new IntResourceManager(1);
IntResourceManager irm2 = new IntResourceManager(10);
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
using (TransactionScope scope = new TransactionScope()) {
irm.Value = 2;
using (TransactionScope scope2 = new TransactionScope()) {
irm2.Value = 20;
scope2.Complete();
}
scope.Complete();
}
Assert.IsNull(Transaction.Current, "Ambient transaction exists");
/* Both got committed */
Assert.AreEqual(irm.Value, 2, "#3");
Assert.AreEqual(irm2.Value, 20, "#4");
irm.Check(1, 1, 0, 0, "irm");
irm2.Check(1, 1, 0, 0, "irm2");
}
public void ExplicitTransaction16()
{
CommittableTransaction ct = new CommittableTransaction();
IntResourceManager irm0 = new IntResourceManager(3);
IntResourceManager irm = new IntResourceManager(1);
Assert.IsNull(Transaction.Current);
Transaction.Current = ct;
irm.FailPrepare = true;
irm.FailWithException = true;
irm.Value = 2;
irm0.Value = 6;
try {
ct.Commit();
} catch (TransactionAbortedException e) {
Assert.IsNotNull(e.InnerException, "Expected an InnerException of type NotSupportedException");
Assert.AreEqual(typeof(NotSupportedException), e.InnerException.GetType(), "Inner exception should be NotSupportedException");
irm.Check(1, 0, 0, 0, "irm");
irm0.Check(0, 0, 1, 0, "irm0");
Transaction.Current = null;
return;
}
Assert.Fail("Should not be reached");
}
public void Vol0_Dur1_Fail()
{
IntResourceManager irm = new IntResourceManager(1);
/* Durable resource enlisted with a IEnlistedNotification
* object
*/
irm.Volatile = false;
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, "irm");
return;
}
Assert.Fail();
}
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 TransactionDispose()
{
CommittableTransaction ct = new CommittableTransaction();
IntResourceManager irm = new IntResourceManager(1);
irm.Volatile = false;
ct.Dispose();
irm.Check(0, 0, 0, 0, "Dispose transaction");
}
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.IsInstanceOfType(typeof(TransactionAbortedException), ex, "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
}
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
}
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");
}
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 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 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 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 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 ExplicitTransaction10b ()
{
CommittableTransaction ct = new CommittableTransaction ();
IntResourceManager irm = new IntResourceManager ( 1 );
Transaction.Current = ct;
irm.Value = 2;
Transaction.Current = null;
TransactionScope scope = new TransactionScope ( ct );
Assert.AreEqual ( ct, Transaction.Current, "ambient transaction" );
//scope2.Complete ();
//scope2.Dispose ();
IAsyncResult ar = ct.BeginCommit ( null, null );
try {
ct.EndCommit (ar);
}
catch ( TransactionAbortedException) {
irm.Check ( 0, 0, 1, 0, "irm" );
Transaction.Current = null;
return;
}
Transaction.Current = null;
Assert.Fail ();
}
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);
}
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 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 ();
}
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" );
}
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.IsInstanceOfType(ex, 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
}
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");
}
public void TransactionDispose ()
{
CommittableTransaction ct = new CommittableTransaction ();
IntResourceManager irm = new IntResourceManager (1);
irm.Volatile = false;
ct.Dispose ();
irm.Check (0, 0, 0, 0, "Dispose transaction");
}
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);
}
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 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
}
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");
}
public void Async4 ()
{
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 );
ar.AsyncWaitHandle.WaitOne ();
Assert.IsTrue ( ar.IsCompleted );
irm.Check ( 1, 1, 0, 0, "irm" );
}
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.
Assert.IsInstanceOfType(typeof(NotSupportedException), ex, "Invalid exception thrown");
#else
// Mono wrapps the exception into a TransactionAbortedException.
Assert.IsInstanceOfType(ex, typeof(TransactionAbortedException), "Invalid type of exception thrown");
Assert.IsNotNull(ex.InnerException, "InnerException not thrown");
Assert.IsInstanceOfType(ex.InnerException, typeof(NotSupportedException), "Invalid type of inner exception thrown");
#endif
}
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 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.IsInstanceOfType(ex, typeof(NotSupportedException), "Invalid exception thrown");
}
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 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 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 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");
}
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 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 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");
}
public void Async2 ()
{
IntResourceManager irm = new IntResourceManager ( 1 );
CommittableTransaction ct = new CommittableTransaction ();
using ( TransactionScope scope = new TransactionScope (ct) ) {
irm.Value = 2;
//scope.Complete ();
IAsyncResult ar = ct.BeginCommit ( null, null);
try {
ct.EndCommit ( ar );
}
catch ( TransactionAbortedException) {
irm.Check ( 0, 0, 1, 0, "irm" );
return;
}
}
Assert.Fail ( "EndCommit should've thrown an exception" );
}
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 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" );
}
}
