internal void Success_ReturnsCorrectResult(TransactionStatus transactionStatus, bool statusSuccess, bool expected)
        {
            Status status = Factory.CreateStatus(statusSuccess);

            CreditResult creditResult = new CreditResult { Status = status, TransactionStatus = transactionStatus };
            Assert.AreEqual(expected, creditResult.Success);
        }

 private void InvokeOutcomeFunction(TransactionStatus status)
 {
     WeakReference weakRealTransaction = null;
     lock (this)
     {
         if (this.haveIssuedOutcome)
         {
             return;
         }
         this.haveIssuedOutcome = true;
         this.savedStatus = status;
         weakRealTransaction = this.weakRealTransaction;
     }
     if (weakRealTransaction != null)
     {
         RealOletxTransaction target = weakRealTransaction.Target as RealOletxTransaction;
         if (target != null)
         {
             target.FireOutcome(status);
             if (target.phase0EnlistVolatilementContainerList != null)
             {
                 foreach (OletxPhase0VolatileEnlistmentContainer container in target.phase0EnlistVolatilementContainerList)
                 {
                     container.OutcomeFromTransaction(status);
                 }
             }
             if (((TransactionStatus.Aborted == status) || (TransactionStatus.InDoubt == status)) && (target.phase1EnlistVolatilementContainer != null))
             {
                 target.phase1EnlistVolatilementContainer.OutcomeFromTransaction(status);
             }
         }
         weakRealTransaction.Target = null;
     }
 }

        public void Success_ReturnsCorrectResult(TransactionStatus transactionStatus, bool statusSuccess, bool expected)
        {
            Status status = Factory.CreateStatus(statusSuccess);

            CompleteResult completeResult = new CompleteResult { Status = status, TransactionStatus = transactionStatus };
            Assert.AreEqual(expected, completeResult.Success);
        }

        // TODO: Issue #10353 - These variations need to be added once we have promotion support.
        /*
        [InlineData(CloneType.Normal, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.RepeatableRead, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.ReadCommitted, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.ReadUncommitted, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.Snapshot, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.Chaos, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.Normal, IsolationLevel.Unspecified, false, false, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Serializable, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.RepeatableRead, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadCommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.ReadUncommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Snapshot, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Chaos, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.BlockingDependent, IsolationLevel.Unspecified, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Serializable, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.RepeatableRead, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadCommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.ReadUncommitted, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Snapshot, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Chaos, true, true, TransactionStatus.Committed)]
        [InlineData(CloneType.RollbackDependent, IsolationLevel.Unspecified, true, true, TransactionStatus.Committed)]
        */
        public void Run(CloneType cloneType, IsolationLevel isoLevel, bool forcePromote, bool completeClone, TransactionStatus expectedStatus )
        {
            TransactionOptions options = new TransactionOptions
            {
                IsolationLevel = isoLevel,
                // Shorten the delay before a timeout for blocking clones.
                Timeout = TimeSpan.FromSeconds(1)
            };

            CommittableTransaction tx = new CommittableTransaction(options);

            Transaction clone;
            switch (cloneType)
            {
                case CloneType.Normal:
                    {
                        clone = tx.Clone();
                        break;
                    }
                case CloneType.BlockingDependent:
                    {
                        clone = tx.DependentClone(DependentCloneOption.BlockCommitUntilComplete);
                        break;
                    }
                case CloneType.RollbackDependent:
                    {
                        clone = tx.DependentClone(DependentCloneOption.RollbackIfNotComplete);
                        break;
                    }
                default:
                    {
                        throw new Exception("Unexpected CloneType - " + cloneType.ToString());
                    }
            }

            if (forcePromote)
            {
                HelperFunctions.PromoteTx(tx);
            }

            Assert.Equal(clone.IsolationLevel, tx.IsolationLevel);
            Assert.Equal(clone.TransactionInformation.Status, tx.TransactionInformation.Status);
            Assert.Equal(clone.TransactionInformation.LocalIdentifier, tx.TransactionInformation.LocalIdentifier);
            Assert.Equal(clone.TransactionInformation.DistributedIdentifier, tx.TransactionInformation.DistributedIdentifier);

            CommittableTransaction cloneCommittable = clone as CommittableTransaction;
            Assert.Null(cloneCommittable);

            try
            {
                tx.Commit();
            }
            catch (TransactionAbortedException)
            {
                Assert.Equal(expectedStatus, TransactionStatus.Aborted);
            }

            Assert.Equal(expectedStatus, tx.TransactionInformation.Status);
        }

        public void Constructor_Empty()
        {
            var actual = new TransactionStatus();

            Assert.AreEqual(TransactionStatusCode.NotExecuted, actual.StatusCode);
            Assert.AreEqual("", actual.ErrorMessage);
            Assert.AreEqual("", actual.TransactionInfo);
        }

 public IList<OutgoingSingleCredit> GetAllOutgoingSingleCredit(TransactionStatus transactionStatus)
 {
     using (var db = new RTGSGen2DBContext(connectionString))
     {
         IList<OutgoingSingleCredit> outgoingSingleCreditList = db.GetAllOutgoingSingleCredit().ToList();
         return outgoingSingleCreditList
                 .Where(o => o.Status == transactionStatus.ToString()).ToList();
     }
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="documentName">the name of the Document</param>
 protected Document(string documentName)
 {
     this.documentName = documentName;
     //this.hasNoTransactionStatus = true;
     this.hasNoLogStatus = true;
     this.status = TransactionStatus.Success;
     this.message = "";
     this.properties = new Dictionary<string, Property>();
     this.collections = new Dictionary<string, DocumentCollection>();
 }

 public TransactionInfo(Guid txnJobId, TransactionStatus txnStatus, TransactionType txnType, ulong dataStart, ulong dataLength, DateTime txnStartTime)
 {
     VersionNumber = 1;
     JobId = txnJobId;
     TransactionStatus = txnStatus;
     TransactionType = txnType;
     DataStartPosition = dataStart;
     DataLength = dataLength;
     TransactionStartTime = txnStartTime.ToUniversalTime();
 }

        /// <summary>
        /// Creates a response message confirming delivery of transaction result
        /// </summary>
        /// <param name="status">Result of delivery (note this is to confirm that you have received the result, not the result itself)</param>
        /// <param name="message">Optional message for example, any exceptions that may have occurred</param>
        /// <returns>String</returns>
        public string CreateServerResponseString(TransactionStatus status, string message = "")
        {
            var response = new NameValueCollection();
            response.Add("StatusCode", (int)status);
            if (!string.IsNullOrEmpty(message)) {
                response.Add("Message", message);
            }

            return response.ToQueryString();
        }

 internal OletxVolatileEnlistment(IEnlistmentNotificationInternal enlistmentNotification, EnlistmentOptions enlistmentOptions, OletxTransaction oletxTransaction) : base(null, oletxTransaction)
 {
     this.iEnlistmentNotification = enlistmentNotification;
     this.enlistDuringPrepareRequired = (enlistmentOptions & EnlistmentOptions.EnlistDuringPrepareRequired) != EnlistmentOptions.None;
     this.container = null;
     this.pendingOutcome = TransactionStatus.Active;
     if (DiagnosticTrace.Information)
     {
         EnlistmentTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentType.Volatile, enlistmentOptions);
     }
 }

        public void Constructor_DataTableWithColumnsButBadRows()
        {
            // Arrange
            var dt = new DataTable();
            dt.Columns.Add(new DataColumn("ErrorCode"));
            dt.Columns.Add(new DataColumn("ErrorMessage"));
            dt.Columns.Add(new DataColumn("TransactionInfo"));

            var test = new TransactionStatus(dt);
            Assert.IsNotNull(test);
        }

        public Result<List<CreditTransaction>> SetExchangeStatus(IDbConnection db, string orderId, TransactionStatus newStatus)
        {
            // TODO
            // Step 1: Find and Update CoinTransaction 's status to "failure"
            // Step 2: If not found, try on FreeCoinTransaction. Status to "failure"

            // Step 3: CreditTransaction status also mark as "failure"




            // TEST //
            return Result<List<CreditTransaction>>.Null();
        }

 internal void InDoubt()
 {
     OletxVolatileEnlistmentState active = OletxVolatileEnlistmentState.Active;
     IEnlistmentNotificationInternal iEnlistmentNotification = null;
     lock (this)
     {
         if (OletxVolatileEnlistmentState.Prepared == this.state)
         {
             active = this.state = OletxVolatileEnlistmentState.InDoubt;
             iEnlistmentNotification = this.iEnlistmentNotification;
         }
         else
         {
             if (OletxVolatileEnlistmentState.Preparing == this.state)
             {
                 this.pendingOutcome = TransactionStatus.InDoubt;
             }
             active = this.state;
         }
     }
     if (OletxVolatileEnlistmentState.InDoubt == active)
     {
         if (iEnlistmentNotification != null)
         {
             if (DiagnosticTrace.Verbose)
             {
                 EnlistmentNotificationCallTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, NotificationCall.InDoubt);
             }
             iEnlistmentNotification.InDoubt(this);
             return;
         }
         if (DiagnosticTrace.Critical)
         {
             InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
         }
         throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
     }
     if ((OletxVolatileEnlistmentState.Preparing != active) && (OletxVolatileEnlistmentState.Done != active))
     {
         if (DiagnosticTrace.Critical)
         {
             InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
         }
         throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
     }
 }

        public void TwoPhaseDurable(int volatileCount, EnlistmentOptions volatileEnlistmentOption, EnlistmentOptions durableEnlistmentOption, Phase1Vote volatilePhase1Vote, Phase1Vote durablePhase1Vote, bool commit, EnlistmentOutcome expectedVolatileOutcome, EnlistmentOutcome expectedDurableOutcome, TransactionStatus expectedTxStatus)
        {
            Transaction tx = null;
            try
            {
                using (TransactionScope ts = new TransactionScope())
                {
                    tx = Transaction.Current.Clone();

                    if (volatileCount > 0)
                    {
                        TestEnlistment[] volatiles = new TestEnlistment[volatileCount];
                        for (int i = 0; i < volatileCount; i++)
                        {
                            // It doesn't matter what we specify for SinglePhaseVote.
                            volatiles[i] = new TestEnlistment(volatilePhase1Vote, expectedVolatileOutcome);
                            tx.EnlistVolatile(volatiles[i], volatileEnlistmentOption);
                        }
                    }

                    TestEnlistment durable = new TestEnlistment(Phase1Vote.Prepared, expectedDurableOutcome);
                    // TODO: Issue #10353 - This needs to change once we have promotion support.
                    Assert.Throws<PlatformNotSupportedException>(() => // Creation of two phase durable enlistment attempts to promote to MSDTC
                    {
                        tx.EnlistDurable(Guid.NewGuid(), durable, durableEnlistmentOption);
                    });

                    if (commit)
                    {
                        ts.Complete();
                    }
                }
            }
            catch (TransactionInDoubtException)
            {
                Assert.Equal(expectedTxStatus, TransactionStatus.InDoubt);
            }
            catch (TransactionAbortedException)
            {
                Assert.Equal(expectedTxStatus, TransactionStatus.Aborted);
            }

            Assert.NotNull(tx);
            Assert.Equal(expectedTxStatus, tx.TransactionInformation.Status);
        }

        public Result<FreeCoinTransaction> GetFreeCoinTransaction(IDbConnection db, string orderId, TransactionStatus? statusFilter = null)
        {
            var trans = db.Query<FreeCoinTransaction>("SELECT * FROM free_coin_transaction WHERE [email protected]", new { orderId }).FirstOrDefault();
            if (trans == null)
                return Result<FreeCoinTransaction>.Null(ErrorCodes.InvalidTransactionId);

            if (statusFilter.HasValue)
            {
                if (statusFilter.Value.ToString() != trans.status)
                {
                    bool accepted = (trans.status == ConstantValues.S_ACCEPTED);
                    return Result<FreeCoinTransaction>.Null(accepted ? ErrorCodes.TransactionAlreadyProcessed : ErrorCodes.TransactionNotFound);
                }
            }

            // TODO: Need a collection data structure in FreeCoinTransaction to hold packages //
            return Result<FreeCoinTransaction>.Make(trans);
        }

        public void SinglePhaseDurable(int volatileCount, EnlistmentOptions volatileEnlistmentOption, Phase1Vote volatilePhase1Vote, SinglePhaseVote singlePhaseVote, bool commit, EnlistmentOutcome expectedVolatileOutcome, TransactionStatus expectedTxStatus)
        {
            Transaction tx = null;
            try
            {
                using (TransactionScope ts = new TransactionScope())
                {
                    tx = Transaction.Current.Clone();

                    if (volatileCount > 0)
                    {
                        TestSinglePhaseEnlistment[] volatiles = new TestSinglePhaseEnlistment[volatileCount];
                        for (int i = 0; i < volatileCount; i++)
                        {
                            // It doesn't matter what we specify for SinglePhaseVote.
                            volatiles[i] = new TestSinglePhaseEnlistment(volatilePhase1Vote, SinglePhaseVote.InDoubt, expectedVolatileOutcome);
                            tx.EnlistVolatile(volatiles[i], volatileEnlistmentOption);
                        }
                    }

                    // Doesn't really matter what we specify for EnlistmentOutcome here. This is an SPC, so Phase2 won't happen for this enlistment.
                    TestSinglePhaseEnlistment durable = new TestSinglePhaseEnlistment(Phase1Vote.Prepared, singlePhaseVote, EnlistmentOutcome.Committed);
                    tx.EnlistDurable(Guid.NewGuid(), durable, EnlistmentOptions.None);

                    if (commit)
                    {
                        ts.Complete();
                    }
                }
            }
            catch (TransactionInDoubtException)
            {
                Assert.Equal(expectedTxStatus, TransactionStatus.InDoubt);
            }
            catch (TransactionAbortedException)
            {
                Assert.Equal(expectedTxStatus, TransactionStatus.Aborted);
            }


            Assert.NotNull(tx);
            Assert.Equal(expectedTxStatus, tx.TransactionInformation.Status);
        }

 internal RealOletxTransaction(OletxTransactionManager transactionManager, ITransactionShim transactionShim, OutcomeEnlistment outcomeEnlistment, Guid identifier, OletxTransactionIsolationLevel oletxIsoLevel, bool isRoot)
 {
     bool flag = false;
     try
     {
         this.oletxTransactionManager = transactionManager;
         this.transactionShim = transactionShim;
         this.outcomeEnlistment = outcomeEnlistment;
         this.txGuid = identifier;
         this.isolationLevel = OletxTransactionManager.ConvertIsolationLevelFromProxyValue(oletxIsoLevel);
         this.status = TransactionStatus.Active;
         this.undisposedOletxTransactionCount = 0;
         this.phase0EnlistVolatilementContainerList = null;
         this.phase1EnlistVolatilementContainer = null;
         this.tooLateForEnlistments = false;
         this.internalTransaction = null;
         this.creationTime = DateTime.UtcNow;
         this.lastStateChangeTime = this.creationTime;
         this.internalClone = new OletxTransaction(this);
         if (this.outcomeEnlistment != null)
         {
             this.outcomeEnlistment.SetRealTransaction(this);
         }
         else
         {
             this.status = TransactionStatus.InDoubt;
         }
         if (DiagnosticTrace.HaveListeners)
         {
             DiagnosticTrace.TraceTransfer(this.txGuid);
         }
         flag = true;
     }
     finally
     {
         if (!flag && (this.outcomeEnlistment != null))
         {
             this.outcomeEnlistment.UnregisterOutcomeCallback();
             this.outcomeEnlistment = null;
         }
     }
 }

        // TODO: Incomplete & Not Tested //
        public Result<List<CreditTransaction>> GetExchange(IDbConnection db, string orderId, TransactionStatus? statusFilter = null)
        {
            var coinTran = GetCoinTransaction(db, orderId, statusFilter);
            if (coinTran.HasData)
            {
                // TODO: Full up the list of packages IAP items //
                //Result< List<CreditTransaction> >.Make(coinTran.Data, coinTran.Error);
            }
            // Else, not succeeded //

            var freeCoinTran = GetFreeCoinTransaction(db, orderId, statusFilter);
            if (freeCoinTran.HasData)
            {
                // TODO: Full up the list of packages IAP items //
                // return Result< List<CreditTransaction> >.Make(freeCoinTran.Data, freeCoinTran.Error);
            }

            // TEST //
            return Result<List<CreditTransaction>>.Null();
        }

        public void Constructor_DataTable()
        {
            // Arrange
            var dt = new DataTable();
            dt.Columns.Add(new DataColumn("ErrorCode"));
            dt.Columns.Add(new DataColumn("ErrorMessage"));
            dt.Columns.Add(new DataColumn("TransactionInfo"));
            var row = dt.NewRow();
            row[0] = 0;
            row[1] = "Test Message";
            row[2] = "Test info about the transaction";
            dt.Rows.Add(row);

            // Act
            var actual = new TransactionStatus(dt);

            // Assert
            Assert.AreEqual(TransactionStatusCode.Successful, actual.StatusCode);
            Assert.AreEqual("Test Message", actual.ErrorMessage);
            Assert.AreEqual("Test info about the transaction", actual.TransactionInfo);
        }

 internal ReadyForQueryMessage Load(NpgsqlBuffer buf) {
     TransactionStatusIndicator = (TransactionStatus)buf.ReadByte();
     return this;
 }