Esempio n. 1
0
 public void TestCreatesAndUpdates()
 {
     o_region = new RegionOperation(RegionName);
     o_region.Region.Add("Key-1", "Val-1", m_callbackarg);
     o_region.Region.Put("Key-1", "NewVal-1", m_callbackarg);
     Thread.Sleep(10000);
 }
Esempio n. 2
0
        public void ValidateData()
        {
            o_region = new RegionOperation(RegionName);
            DefaultType dc = (DefaultType)o_region.Region.Get("key-1", null);

            Assert.AreEqual(dc.CBool, true, "bool is not equal");
            Assert.AreEqual(dc.CInt, 1000, "int is not equal");

            int[] cia = dc.CIntArray;
            Assert.IsNotNull(cia, "Int array is null");
            Assert.AreEqual(3, cia.Length, "Int array are not three");

            string[] csa = dc.CStringArray;
            Assert.IsNotNull(csa, "String array is null");
            Assert.AreEqual(2, csa.Length, "String array length is not two");

            Assert.AreEqual(dc.CFileName, "gemstone.txt", "Cacheable filename is not equal");

            /*
             * Assert.IsNotNull(dc.CHashSet, "hashset is null");
             * Assert.AreEqual(2, dc.CHashSet.Count, "hashset size is not two");
             * */

            Assert.IsNotNull(dc.CHashMap, "hashmap is null");
            Assert.AreEqual(1, dc.CHashMap.Count, "hashmap size is not one");

            //Assert.IsNotNull(dc.CDate, "Date is null");

            Assert.IsNotNull(dc.CVector);
            Assert.AreEqual(2, dc.CVector.Count, "Vector size is not two");

            //Assert.IsNotNull(dc.CObject);
            //Assert.AreEqual("key", ((CustomSerializableObject)dc.CObject).key, "Object key is not same");
            //Assert.AreEqual("value", ((CustomSerializableObject)dc.CObject).value, "Object value is not same");
        }
Esempio n. 3
0
        public void SuspendResumeCommit()
        {
            o_region1 = new RegionOperation(cstxRegions[0]);
            o_region2 = new RegionOperation(cstxRegions[1]);

            CacheHelper.CSTXManager.Begin();
            o_region1.PutOp(1, null);

            o_region2.PutOp(1, null);


            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(CacheHelper.CSTXManager.TransactionId), false, "Transaction should not be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(CacheHelper.CSTXManager.TransactionId), true, "Transaction should exist");
            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
            Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");

            TransactionId tid = CacheHelper.CSTXManager.Suspend();

            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), true, "Transaction should be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
            Assert.AreEqual(0, o_region1.Region.Keys.Count, "There should be 0 values in the region after suspend");
            Assert.AreEqual(0, o_region2.Region.Keys.Count, "There should be 0 values in the region after suspend");


            CacheHelper.CSTXManager.Resume(tid);
            Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid), false, "The transaction should not have been resumed again.");
            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
            Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");

            o_region2.PutOp(2, null);

            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be four values in the region before commit");
            Assert.AreEqual(4, o_region2.Region.Keys.Count, "There should be four values in the region before commit");

            CacheHelper.CSTXManager.Commit();
            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), false, "Transaction should NOT exist");
            Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid), false, "Transaction should not be resumed");
            Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid, TimeSpan.FromMilliseconds(3000)), false, "Transaction should not be resumed");
            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be four values in the region after commit");
            Assert.AreEqual(4, o_region2.Region.Keys.Count, "There should be four values in the region after commit");
            o_region1.DestroyOpWithPdxValue(1, null);
            o_region2.DestroyOpWithPdxValue(2, null);
            bool resumeEx = false;

            try
            {
                CacheHelper.CSTXManager.Resume(tid);
            }
            catch (IllegalStateException)
            {
                resumeEx = true;
            }
            Assert.AreEqual(resumeEx, true, "The transaction should not be resumed");

            // The transaction should not be suspended
            // Assert.Throws<Exception>( delegate { CacheHelper.CSTXManager.Suspend(); });
        }
Esempio n. 4
0
        public void CallOp2()
        {
            o_region = new RegionOperation(RegionName);
            DefaultType dc = new DefaultType(true);

            o_region.Region.Put("key-1", dc, null);
            Thread.Sleep(1000); // let the events reach at other end.
        }
Esempio n. 5
0
        public void GetOp(string key)
        {
            Util.Log("GetOp started");
            o_region = new RegionOperation(RegionName);
            Region r   = o_region.Region;
            Object val = r[key];

            Thread.Sleep(1000); // let the events reach at other end.
            Util.Log("GetOp finished");
        }
Esempio n. 6
0
        public void InvalidateOp(string key)
        {
            Util.Log("InvalidateOp started");
            o_region = new RegionOperation(RegionName);
            Region r = o_region.Region;

            r.GetLocalView().Invalidate(key);
            Thread.Sleep(1000); // let the events reach at other end.
            Util.Log("InvalidateOp finished");
        }
Esempio n. 7
0
        public void PutOp(string key, string value)
        {
            Util.Log("PutOp started");
            o_region = new RegionOperation(RegionName);
            Region r = o_region.Region;

            r[key] = value;
            Thread.Sleep(1000); // let the events reach at other end.
            Util.Log("PutOp finished");
        }
Esempio n. 8
0
        public void SuspendResumeRollback()
        {
            o_region1 = new RegionOperation(cstxRegions[0]);
            o_region2 = new RegionOperation(cstxRegions[1]);

            CacheHelper.CSTXManager.Begin();
            o_region1.PutOp(1, null);

            o_region2.PutOp(1, null);


            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(CacheHelper.CSTXManager.TransactionId), false, "Transaction should not be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(CacheHelper.CSTXManager.TransactionId), true, "Transaction should exist");
            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
            Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");

            TransactionId tid = CacheHelper.CSTXManager.Suspend();

            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), true, "Transaction should be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
            Assert.AreEqual(0, o_region1.Region.Keys.Count, "There should be 0 values in the region after suspend");
            Assert.AreEqual(0, o_region2.Region.Keys.Count, "There should be 0 values in the region after suspend");


            CacheHelper.CSTXManager.Resume(tid);
            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), true, "Transaction should exist");
            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be two values in the region before commit");
            Assert.AreEqual(2, o_region2.Region.Keys.Count, "There should be two values in the region before commit");

            o_region2.PutOp(2, null);

            Assert.AreEqual(2, o_region1.Region.Keys.Count, "There should be four values in the region before commit");
            Assert.AreEqual(4, o_region2.Region.Keys.Count, "There should be four values in the region before commit");

            CacheHelper.CSTXManager.Rollback();
            Assert.AreEqual(CacheHelper.CSTXManager.IsSuspended(tid), false, "Transaction should not be suspended");
            Assert.AreEqual(CacheHelper.CSTXManager.Exists(tid), false, "Transaction should NOT exist");
            Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid), false, "Transaction should not be resumed");
            Assert.AreEqual(CacheHelper.CSTXManager.TryResume(tid, 3000), false, "Transaction should not be resumed");
            Assert.AreEqual(0, o_region1.Region.Keys.Count, "There should be 0 values in the region after rollback");
            Assert.AreEqual(0, o_region2.Region.Keys.Count, "There should be 0 values in the region after rollback");
            bool resumeEx = false;

            try
            {
                CacheHelper.CSTXManager.Resume(tid);
            }
            catch (IllegalStateException)
            {
                resumeEx = true;
            }
            Assert.AreEqual(resumeEx, true, "The transaction should not be resumed");
        }
Esempio n. 9
0
        public void TestRemoveAll()
        {
            o_region = new RegionOperation(RegionName);
            ICollection <object> keys = new LinkedList <object>();

            for (int i = 0; i < 10; i++)
            {
                o_region.Region["Key-" + i] = "Value-" + i;
                keys.Add("Key-" + i);
            }
            o_region.Region.RemoveAll(keys, m_callbackarg);
        }
Esempio n. 10
0
 public void CallOp()
 {
     o_region = new RegionOperation(RegionName);
     o_region.PutOp(5, null);
     Thread.Sleep(1000); // let the events reach at other end.
     o_region.PutOp(5, null);
     Thread.Sleep(1000);
     o_region.InvalidateOp(5, null);
     Thread.Sleep(1000);
     o_region.DestroyOp(5, null);
     Thread.Sleep(1000);
 }
Esempio n. 11
0
        public void TestPutAll()
        {
            o_region = new RegionOperation(RegionName);
            Dictionary <Object, Object> entryMap = new Dictionary <Object, Object>();

            for (Int32 item = 0; item < 10; item++)
            {
                int    K     = item;
                string value = item.ToString();
                entryMap.Add(K, value);
            }
            o_region.Region.PutAll(entryMap, 15, m_callbackarg);
        }
Esempio n. 12
0
 public void TestInvalidates()
 {
     o_region = new RegionOperation(RegionName);
     o_region.Region.GetLocalView().Add(1234, 1234, m_callbackarg);
     o_region.Region.GetLocalView().Add(12345, 12345, m_callbackarg);
     o_region.Region.GetLocalView().Add(12346, 12346, m_callbackarg);
     o_region.Region.GetLocalView().Put(1234, "Val-1", m_callbackarg);
     o_region.Region.GetLocalView().Invalidate(1234, m_callbackarg);
     Assert.AreEqual(o_region.Region.GetLocalView().Remove(12345, 12345, m_callbackarg), true, "Result of remove should be true, as this value exists locally.");
     Assert.AreEqual(o_region.Region.GetLocalView().ContainsKey(12345), false, "containsKey should be false");
     Assert.AreEqual(o_region.Region.GetLocalView().Remove(12346, m_callbackarg), true, "Result of remove should be true, as this value exists locally.");
     Assert.AreEqual(o_region.Region.GetLocalView().ContainsKey(12346), false, "containsKey should be false");
     o_region.Region.Invalidate("Key-1", m_callbackarg);
     o_region.Region.InvalidateRegion(m_callbackarg);
 }
Esempio n. 13
0
        public void doPutGetWithPdxSerializer()
        {
            CacheHelper.CSTXManager.Begin();
            o_region1 = new RegionOperation(cstxRegions[0]);
            for (int i = 0; i < 10; i++)
            {
                o_region1.Region[i] = i + 1;
                object ret = o_region1.Region[i];
                o_region1.Region[i + 10] = i + 10;
                ret = o_region1.Region[i + 10];
                o_region1.Region[i + 20] = i + 20;
                ret = o_region1.Region[i + 20];
            }
            CacheHelper.CSTXManager.Commit();
            Util.Log("Region keys count after commit for non-pdx keys = {0} ", o_region1.Region.Keys.Count);
            Assert.AreEqual(30, o_region1.Region.Keys.Count, "Commit didn't put two values in the region");

            CacheHelper.CSTXManager.Begin();
            o_region1 = new RegionOperation(cstxRegions[0]);
            for (int i = 100; i < 110; i++)
            {
                object put = new SerializePdx1(true);
                o_region1.Region[i] = put;
                put = new SerializePdx2(true);
                o_region1.Region[i + 10] = put;
                put = new SerializePdx3(true, i % 2);
                o_region1.Region[i + 20] = put;
            }
            CacheHelper.CSTXManager.Commit();

            for (int i = 100; i < 110; i++)
            {
                object put = new SerializePdx1(true);
                object ret = o_region1.Region[i];
                Assert.AreEqual(put, ret);
                put = new SerializePdx2(true);
                ret = o_region1.Region[i + 10];
                Assert.AreEqual(put, ret);
                put = new SerializePdx3(true, i % 2);
                ret = o_region1.Region[i + 20];
                Assert.AreEqual(put, ret);
            }
            Util.Log("Region keys count after pdx-keys commit = {0} ", o_region1.Region.Keys.Count);
            Assert.AreEqual(60, o_region1.Region.Keys.Count, "Commit didn't put two values in the region");
        }
Esempio n. 14
0
        public void TestGetAll()
        {
            o_region = new RegionOperation(RegionName);
            List <Object> keys = new List <Object>();

            for (int item = 0; item < 10; item++)
            {
                Object K = item;
                keys.Add(K);
            }
            Dictionary <Object, Object> values = new Dictionary <Object, Object>();

            o_region.Region.GetAll(keys.ToArray(), values, null, true, m_callbackarg);

            Dictionary <Object, Object> .Enumerator enumerator = values.GetEnumerator();
            while (enumerator.MoveNext())
            {
                Util.Log("Values after getAll with CallBack Key = {0} Value = {1} ", enumerator.Current.Key.ToString(), enumerator.Current.Value.ToString());
            }
        }
Esempio n. 15
0
            public void ThreadStart()
            {
                RegionOperation o_region1 = new RegionOperation(cstxRegions[0]);
                RegionOperation o_region2 = new RegionOperation(cstxRegions[1]);

                CacheHelper.CSTXManager.Begin();

                o_region1.PutOp(1, null);
                o_region2.PutOp(1, null);

                m_tid = CacheHelper.CSTXManager.TransactionId;
                m_txIdUpdated.Set();

                if (m_sleep)
                {
                    m_txevent.WaitOne();
                    Thread.Sleep(5000);
                }

                m_tid = CacheHelper.CSTXManager.Suspend();
            }
Esempio n. 16
0
        /*
         * public void ValidateCSTXListenerWriter()
         * {
         * Util.Log("tallies for listener 1");
         * m_listener1.ShowTallies();
         * Util.Log("tallies for writer 1");
         * m_writer1.ShowTallies();
         * Util.Log("tallies for listener 2");
         * m_listener2.ShowTallies();
         * Util.Log("tallies for writer 2");
         * m_writer2.ShowTallies();
         *
         * // listener 1
         * Assert.AreEqual(4, m_listener1.AfterCommitEvents, "Should be 4");
         * Assert.AreEqual(14, m_listener1.AfterCommitKeyEvents, "Should be 14");
         * Assert.AreEqual(0, m_listener1.AfterFailedCommitEvents, "Should be 0");
         * Assert.AreEqual(0, m_listener1.AfterFailedCommitKeyEvents, "Should be 0");
         * Assert.AreEqual(2, m_listener1.AfterRollbackEvents, "Should be 2");
         * Assert.AreEqual(6, m_listener1.AfterRollbackKeyEvents, "Should be 6");
         * Assert.AreEqual(1, m_listener1.CloseEvent, "Should be 1");
         * Assert.AreEqual(false, m_listener1.IncorrectCacheName, "Incorrect cache name in the events");
         *
         * // listener 2
         * Assert.AreEqual(2, m_listener2.AfterCommitEvents, "Should be 2");
         * Assert.AreEqual(6, m_listener2.AfterCommitKeyEvents, "Should be 6");
         * Assert.AreEqual(0, m_listener2.AfterFailedCommitEvents, "Should be 0");
         * Assert.AreEqual(0, m_listener2.AfterFailedCommitKeyEvents, "Should be 0");
         * Assert.AreEqual(2, m_listener2.AfterRollbackEvents, "Should be 2");
         * Assert.AreEqual(6, m_listener2.AfterRollbackKeyEvents, "Should be 6");
         * Assert.AreEqual(1, m_listener2.CloseEvent, "Should be 1");
         * Assert.AreEqual(false, m_listener2.IncorrectCacheName, "Incorrect cache name in the events");
         *
         * // writer 1
         * Assert.AreEqual(3, m_writer1.BeforeCommitEvents, "Should be 3");
         * Assert.AreEqual(10, m_writer1.BeforeCommitKeyEvents, "Should be 10");
         * Assert.AreEqual(false, m_writer1.IncorrectCacheName, "Incorrect cache name in the events");
         *
         * // writer 2
         * Assert.AreEqual(1, m_writer2.BeforeCommitEvents, "Should be 1");
         * Assert.AreEqual(4, m_writer2.BeforeCommitKeyEvents, "Should be 4");
         * Assert.AreEqual(false, m_writer2.IncorrectCacheName, "Incorrect cache name in the events");
         * }
         */
        #endregion
        public void ValidateListener()
        {
            o_region1 = new RegionOperation(cstxRegions[2]);
            CacheHelper.CSTXManager.Begin();
            o_region1.Region.Put("key3", "value1", null);
            o_region1.Region.Put("key4", "value2", null);
            o_region1.Region.Remove("key4");
            CacheHelper.CSTXManager.Commit();
            // server is conflating the events on the same key hence only 1 create
            Assert.AreEqual(1, m_listener.Creates, "Should be 1 creates");
            Assert.AreEqual(1, m_listener.Destroys, "Should be 1 destroys");

            CacheHelper.CSTXManager.Begin();
            o_region1.Region.Put("key1", "value1", null);
            o_region1.Region.Put("key2", "value2", null);
            o_region1.Region.Invalidate("key1");
            o_region1.Region.Invalidate("key3");
            CacheHelper.CSTXManager.Commit();

            // server is conflating the events on the same key hence only 1 invalidate
            Assert.AreEqual(3, m_listener.Creates, "Should be 3 creates");
            Assert.AreEqual(1, m_listener.Invalidates, "Should be 1 invalidates");
        }
Esempio n. 17
0
        public void CallOp()
        {
            #region CSTX_COMMENTED - transaction listener and writer are disabled for now

            /*
             * m_writer1 = new CSTXWriter<object, object>(CacheHelper.DCache.Name, "cstxWriter1");
             * m_writer2 = new CSTXWriter<object, object>(CacheHelper.DCache.Name, "cstxWriter2");
             * m_listener1 = new CSTXListener<object, object>(CacheHelper.DCache.Name);
             * m_listener2 = new CSTXListener<object, object>(CacheHelper.DCache.Name);
             *
             * CacheHelper.CSTXManager.AddListener<object, object>(m_listener1);
             * CacheHelper.CSTXManager.AddListener<object, object>(m_listener2);
             * CacheHelper.CSTXManager.SetWriter<object, object>(m_writer1);
             *
             * // test two listener one writer for commit on two regions
             * Util.Log(" test two listener one writer for commit on two regions");
             */
            #endregion

            CacheHelper.CSTXManager.Begin();
            o_region1 = new RegionOperation(cstxRegions[0]);
            o_region1.PutOp(2, null);

            o_region2 = new RegionOperation(cstxRegions[1]);
            o_region2.PutOp(2, null);

            CacheHelper.CSTXManager.Commit();
            //two pdx put as well
            Assert.AreEqual(2 + 2, o_region1.Region.Keys.Count, "Commit didn't put two values in the region");
            Assert.AreEqual(2 + 2, o_region2.Region.Keys.Count, "Commit didn't put two values in the region");

            #region CSTX_COMMENTED - transaction listener and writer are disabled for now

            /*
             * Util.Log(" test two listener one writer for commit on two regions - complete");
             * //////////////////////////////////
             *
             * // region test two listener one writer for commit on one region
             * Util.Log(" region test two listener one writer for commit on one region");
             * CacheHelper.CSTXManager.Begin();
             * o_region1.PutOp(2, null);
             *
             * CacheHelper.CSTXManager.Commit();
             * Util.Log(" region test two listener one writer for commit on one region - complete");
             * //////////////////////////////////
             * // test two listener one writer for rollback on two regions
             * Util.Log(" test two listener one writer for rollback on two regions");
             */
            #endregion

            CacheHelper.CSTXManager.Begin();
            o_region1.PutOp(2, null);

            o_region2.PutOp(2, null);

            CacheHelper.CSTXManager.Rollback();
            //two pdx put as well
            Assert.AreEqual(2 + 2, o_region1.Region.Keys.Count, "Region has incorrect number of objects");
            Assert.AreEqual(2 + 2, o_region2.Region.Keys.Count, "Region has incorrect number of objects");
            o_region1.DestroyOpWithPdxValue(2, null);
            o_region2.DestroyOpWithPdxValue(2, null);

            #region CSTX_COMMENTED - transaction listener and writer are disabled for now

            /*
             *
             * Util.Log(" test two listener one writer for rollback on two regions - complete");
             * //////////////////////////////////
             *
             * // test two listener one writer for rollback on on region
             * Util.Log(" test two listener one writer for rollback on on region");
             * CacheHelper.CSTXManager.Begin();
             *
             * o_region2.PutOp(2, null);
             *
             * CacheHelper.CSTXManager.Rollback();
             * Util.Log(" test two listener one writer for rollback on on region - complete");
             * //////////////////////////////////
             *
             * // test remove listener
             * Util.Log(" test remove listener");
             * CacheHelper.CSTXManager.RemoveListener<object, object>(m_listener2);
             *
             * CacheHelper.CSTXManager.Begin();
             * o_region1.PutOp(2, null);
             *
             * o_region2.PutOp(2, null);
             *
             * CacheHelper.CSTXManager.Commit();
             * Util.Log(" test remove listener - complete" );
             * //////////////////////////////////
             *
             * // test GetWriter
             * Util.Log("test GetWriter");
             * CSTXWriter<object, object> writer = (CSTXWriter<object, object>)CacheHelper.CSTXManager.GetWriter<object, object>();
             * Assert.AreEqual(writer.InstanceName, m_writer1.InstanceName, "GetWriter is not returning the object set by SetWriter");
             * Util.Log("test GetWriter - complete");
             * //////////////////////////////////
             *
             * // set a different writer
             * Util.Log("set a different writer");
             * CacheHelper.CSTXManager.SetWriter<object, object>(m_writer2);
             *
             * CacheHelper.CSTXManager.Begin();
             * o_region1.PutOp(2, null);
             *
             * o_region2.PutOp(2, null);
             *
             * CacheHelper.CSTXManager.Commit();
             * Util.Log("set a different writer - complete");
             * //////////////////////////////////
             */
            #endregion
        }
Esempio n. 18
0
 public void TestlocalClear()
 {
     o_region = new RegionOperation(RegionName);
     o_region.Region.GetLocalView().Clear(m_callbackarg);
 }
Esempio n. 19
0
 public void TestRemove()
 {
     o_region = new RegionOperation(RegionName);
     o_region.Region.Remove("Key-1", "NewVal-1", m_callbackarg);
     o_region.Region.DestroyRegion(m_callbackarg);
 }
Esempio n. 20
0
            public void ThreadStart()
            {
                RegionOperation o_region1 = new RegionOperation(cstxRegions[0]);
                RegionOperation o_region2 = new RegionOperation(cstxRegions[1]);

                if (m_tryResumeWithSleep)
                {
                    if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
                    {
                        return;
                    }
                }
                else
                {
                    if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == true, "Transaction should be suspended"))
                    {
                        return;
                    }
                }
                if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == true, "Transaction should exist"))
                {
                    return;
                }
                if (AssertCheckFail(0 == o_region1.Region.Keys.Count, "There should be 0 values in the region after suspend"))
                {
                    return;
                }
                if (AssertCheckFail(0 == o_region2.Region.Keys.Count, "There should be 0 values in the region after suspend"))
                {
                    return;
                }

                if (m_tryResumeWithSleep)
                {
                    m_txevent.Set();
                    CacheHelper.CSTXManager.TryResume(m_tid, 30000);
                }
                else
                {
                    CacheHelper.CSTXManager.Resume(m_tid);
                }

                if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
                {
                    return;
                }
                if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == true, "Transaction should exist"))
                {
                    return;
                }
                if (AssertCheckFail(o_region1.Region.Keys.Count == 2, "There should be two values in the region after suspend"))
                {
                    return;
                }
                if (AssertCheckFail(o_region2.Region.Keys.Count == 2, "There should be two values in the region after suspend"))
                {
                    return;
                }

                o_region2.PutOp(2, null);

                if (m_isCommit)
                {
                    CacheHelper.CSTXManager.Commit();
                    if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
                    {
                        return;
                    }
                    if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == false, "Transaction should NOT exist"))
                    {
                        return;
                    }
                    if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid) == false, "Transaction should not be resumed"))
                    {
                        return;
                    }
                    if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid, 3000) == false, "Transaction should not be resumed"))
                    {
                        return;
                    }
                    if (AssertCheckFail(2 == o_region1.Region.Keys.Count, "There should be four values in the region after commit"))
                    {
                        return;
                    }
                    if (AssertCheckFail(4 == o_region2.Region.Keys.Count, "There should be four values in the region after commit"))
                    {
                        return;
                    }
                    o_region1.DestroyOpWithPdxValue(1, null);
                    o_region2.DestroyOpWithPdxValue(2, null);
                }
                else
                {
                    CacheHelper.CSTXManager.Rollback();
                    if (AssertCheckFail(CacheHelper.CSTXManager.IsSuspended(m_tid) == false, "Transaction should not be suspended"))
                    {
                        return;
                    }
                    if (AssertCheckFail(CacheHelper.CSTXManager.Exists(m_tid) == false, "Transaction should NOT exist"))
                    {
                        return;
                    }
                    if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid) == false, "Transaction should not be resumed"))
                    {
                        return;
                    }
                    if (AssertCheckFail(CacheHelper.CSTXManager.TryResume(m_tid, 3000) == false, "Transaction should not be resumed"))
                    {
                        return;
                    }
                    if (AssertCheckFail(0 == o_region1.Region.Keys.Count, "There should be 0 values in the region after rollback"))
                    {
                        return;
                    }
                    if (AssertCheckFail(0 == o_region2.Region.Keys.Count, "There should be 0 values in the region after rollback"))
                    {
                        return;
                    }
                }
            }