public void ProcessNewInputTest()
        {
            using (StreamWriter writer = new StreamWriter("outputFromUnitTestInstance.txt"))
            {

                TransactionManager target = new TransactionManager(writer);

                string inputString = "begin(T1)";
                List<Operation> actual = target.ProcessNewInput(inputString);
                Assert.AreEqual(1, actual.Count);
                Assert.AreEqual(Enumerations.OperationMode.Begin, actual[0].OpMode);
                Assert.AreEqual(1, actual[0].TransactionNumber);
                Assert.AreEqual(-1, actual[0].NewValue);
                Assert.AreEqual(-1, actual[0].DataItem);
                Assert.AreEqual(false, actual[0].ReadOnly);
                Assert.AreEqual(0, actual[0].TimeStamp);

                // test parsing out begin statements
                target.IncrementTimeStamp();
                inputString = "begin(T2);beginRO(T3)";
                actual = target.ProcessNewInput(inputString);
                Assert.AreEqual(2, actual.Count);
                Operation expectedOp = actual[0];
                Assert.AreEqual(Enumerations.OperationMode.Begin, expectedOp.OpMode);
                Assert.AreEqual(2, expectedOp.TransactionNumber);
                Assert.AreEqual(-1, expectedOp.NewValue);
                Assert.AreEqual(-1, expectedOp.DataItem);
                Assert.AreEqual(false, expectedOp.ReadOnly);
                Assert.AreEqual(0, expectedOp.TimeStamp);

                expectedOp = actual[1];
                Assert.AreEqual(Enumerations.OperationMode.Begin, expectedOp.OpMode);
                Assert.AreEqual(3, expectedOp.TransactionNumber);
                Assert.AreEqual(-1, expectedOp.NewValue);
                Assert.AreEqual(-1, expectedOp.DataItem);
                Assert.AreEqual(true, expectedOp.ReadOnly);
                Assert.AreEqual(1, expectedOp.TimeStamp);
                    // because read only transactions have a timestamp set when they begin

                // setup for next test - do not remove because otherwise read/write ops will fail to parse
                foreach (Operation op in actual)
                    if (op.OpMode == Enumerations.OperationMode.Begin)
                        target.activeTransactions[op.TransactionNumber] = new Transaction(op.TransactionNumber,
                                                                                          op.TimeStamp, op.ReadOnly);

                // test parsing out read statements by a regular transaction
                target.IncrementTimeStamp();
                inputString = "begin(T4);beginRO(T5);R(T2, x4)";
                actual = target.ProcessNewInput(inputString);

                Assert.AreEqual(3, actual.Count);
                expectedOp = actual[2];
                Assert.AreEqual(Enumerations.OperationMode.Read, expectedOp.OpMode);
                Assert.AreEqual(2, expectedOp.TransactionNumber);
                Assert.AreEqual(-1, expectedOp.NewValue);
                Assert.AreEqual(4, expectedOp.DataItem);
                Assert.AreEqual(false, expectedOp.ReadOnly);
                Assert.AreEqual(2, expectedOp.TimeStamp);

                // setup for next test - do not remove because otherwise read/write ops will fail to parse
                foreach (Operation op in actual)
                    if (op.OpMode == Enumerations.OperationMode.Begin)
                        target.activeTransactions[op.TransactionNumber] = new Transaction(op.TransactionNumber,
                                                                                          op.TimeStamp, op.ReadOnly);

                // test parsing out read statements by a RO transaction
                target.IncrementTimeStamp();
                inputString = "begin(T6);beginRO(T7);R(T3, x4)";
                actual = target.ProcessNewInput(inputString);
                Assert.AreEqual(3, actual.Count);
                expectedOp = actual[2];
                Assert.AreEqual(Enumerations.OperationMode.Read, expectedOp.OpMode);
                Assert.AreEqual(3, expectedOp.TransactionNumber);
                Assert.AreEqual(-1, expectedOp.NewValue);
                Assert.AreEqual(4, expectedOp.DataItem);
                Assert.AreEqual(true, expectedOp.ReadOnly);
                Assert.AreEqual(1, expectedOp.TimeStamp);
                    // because read only transactions have a timestamp set when they begin

                // setup for next test - do not remove because otherwise read/write ops will fail to parse
                foreach (Operation op in actual)
                    if (op.OpMode == Enumerations.OperationMode.Begin)
                        target.activeTransactions[op.TransactionNumber] = new Transaction(op.TransactionNumber,
                                                                                          op.TimeStamp, op.ReadOnly);

                // test parsing out write statements
                target.IncrementTimeStamp();
                inputString = "begin(T8);R(T2, x4);W(T3, x5, 6)";
                actual = target.ProcessNewInput(inputString);
                Assert.AreEqual(3, actual.Count);
                expectedOp = actual[2];
                Assert.AreEqual(Enumerations.OperationMode.Write, expectedOp.OpMode);
                Assert.AreEqual(3, expectedOp.TransactionNumber);
                Assert.AreEqual(6, expectedOp.NewValue);
                Assert.AreEqual(5, expectedOp.DataItem);
                Assert.AreEqual(false, expectedOp.ReadOnly);
                Assert.AreEqual(4, expectedOp.TimeStamp);

                inputString = "dump()";
                actual = target.ProcessNewInput(inputString);
                inputString = "dump(5)";
                actual = target.ProcessNewInput(inputString);
                inputString = "dump(x5)";
                actual = target.ProcessNewInput(inputString);
            }
        }
 public void TestGetIssuingTransaction()
 {
     TransactionManager target = new TransactionManager();
     target.ProcessNewInput("R(T1,x4)");
 }