public void TestTransactionRollbacked()
{
var stack = TransactionStackFactory.Create(5);
var raiseCount = 0;
var expectedRaiseCount = 0;
stack.TransactionRollbacked += (sender, e) => Assert.Equal(expectedRaiseCount, ++raiseCount);
for (var j = 0; j < stack.Capacity + 3; ++j)
{
using (stack.CreateTransaction())
{
for (var i = 0; i < 3; ++i)
{
var operation = new SimpleOperation();
stack.PushOperation(operation);
}
}
}
for (var j = 0; j < stack.Capacity; ++j)
{
++expectedRaiseCount;
stack.Rollback();
}
Assert.Equal(stack.Capacity, expectedRaiseCount);
Assert.Equal(stack.Capacity, raiseCount);
Assert.Equal(5, stack.Capacity);
}
public void TestKeepParentAlive()
{
var stack = (TransactionStack)TransactionStackFactory.Create(5);
SimpleOperation operation;
// Root transaction
var transaction1 = stack.CreateTransaction();
operation = new SimpleOperation();
stack.PushOperation(operation);
// Nested transaction
var transaction2 = stack.CreateTransaction(TransactionFlags.KeepParentsAlive);
operation = new SimpleOperation();
stack.PushOperation(operation);
transaction1.Complete();
// transaction1 is still kept alive by transaction2
Assert.That(stack.TransactionInProgress);
stack.PushOperation(operation);
transaction2.Complete();
// All transactions should be done now
Assert.That(!stack.TransactionInProgress);
// And stack has one transaction
Assert.That(!stack.IsEmpty);
}
public void TestDiscardOnePurged()
{
var stack = TransactionStackFactory.Create(5);
var operations = new SimpleOperation[6];
for (var i = 0; i < operations.Length - 1; ++i)
{
using (stack.CreateTransaction())
{
operations[i] = new SimpleOperation();
stack.PushOperation(operations[i]);
}
}
stack.Rollback();
using (stack.CreateTransaction())
{
operations[5] = new SimpleOperation();
stack.PushOperation(operations[5]);
}
for (var i = 0; i < 4; ++i)
{
Assert.AreEqual(false, operations[i].IsFrozen);
Assert.AreEqual(operations[i], ((TransactionStack)stack).Transactions[i].Operations[0]);
}
// operations[4] is the discarded transaction
Assert.AreEqual(true, operations[4].IsFrozen);
Assert.AreEqual(false, operations[5].IsFrozen);
Assert.AreEqual(operations[5], ((TransactionStack)stack).Transactions[4].Operations[0]);
}
public void TestMultipleOperationsTransactionRollforward()
{
var stack = TransactionStackFactory.Create(5);
var counter = new OrderedOperation.Counter();
OrderedOperation[] operations = new OrderedOperation[4];
using (stack.CreateTransaction())
{
for (var i = 0; i < operations.Length; ++i)
{
operations[i] = new OrderedOperation(counter, i, operations.Length);
stack.PushOperation(operations[i]);
}
}
stack.Rollback();
// Above code must be similar to TestMultipleOperationsTransactionRollback
counter.Reset();
stack.Rollforward();
Assert.AreEqual(false, stack.IsEmpty);
Assert.AreEqual(true, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.AreEqual(operations.Length, counter.Value);
foreach (var operation in operations)
{
Assert.AreEqual(true, operation.IsDone);
Assert.AreEqual(1, operation.RollbackCount);
Assert.AreEqual(1, operation.RollforwardCount);
}
}
public void TestOverCapacity()
{
var stack = (TransactionStack)TransactionStackFactory.Create(5);
var operations = new SimpleOperation[6];
for (var i = 0; i < 5; ++i)
{
Assert.AreEqual(false, stack.IsFull);
using (stack.CreateTransaction())
{
operations[i] = new SimpleOperation();
stack.PushOperation(operations[i]);
}
}
Assert.AreEqual(true, stack.IsFull);
Assert.AreEqual(5, stack.Capacity);
for (var i = 0; i < 5; ++i)
{
Assert.AreEqual(operations[i], ((Transaction)stack.Transactions[i]).Operations[0]);
}
using (stack.CreateTransaction())
{
operations[5] = new SimpleOperation();
stack.PushOperation(operations[5]);
}
Assert.AreEqual(5, stack.Transactions.Count);
Assert.AreEqual(5, stack.Capacity);
Assert.AreEqual(true, operations[0].IsFrozen);
for (var i = 0; i < 5; ++i)
{
Assert.AreEqual(operations[i + 1], ((Transaction)stack.Transactions[i]).Operations[0]);
}
}
public void TestZeroCapacity()
{
var stack = (TransactionStack)TransactionStackFactory.Create(0);
SimpleOperation operation;
Assert.AreEqual(false, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.AreEqual(0, stack.Capacity);
Assert.AreEqual(true, stack.IsFull);
Assert.AreEqual(true, stack.IsEmpty);
using (stack.CreateTransaction())
{
operation = new SimpleOperation();
stack.PushOperation(operation);
}
Assert.AreEqual(true, operation.IsFrozen);
using (stack.CreateTransaction())
{
operation = new SimpleOperation();
stack.PushOperation(operation);
}
Assert.AreEqual(true, operation.IsFrozen);
Assert.AreEqual(false, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.AreEqual(0, stack.Capacity);
Assert.AreEqual(true, stack.IsFull);
Assert.AreEqual(true, stack.IsEmpty);
}
public void TestEmptyTransactionCompleted()
{
var stack = TransactionStackFactory.Create(5);
var raiseCount = 0;
var expectedRaiseCount = 1;
stack.TransactionCompleted += (sender, e) => Assert.Equal(expectedRaiseCount, ++raiseCount);
using (stack.CreateTransaction())
{
// Empty transaction
}
Assert.Equal(1, expectedRaiseCount);
Assert.Equal(1, raiseCount);
++expectedRaiseCount;
using (stack.CreateTransaction())
{
using (stack.CreateTransaction())
{
// Empty transaction
}
}
Assert.Equal(2, expectedRaiseCount);
Assert.Equal(2, raiseCount);
}
public void TestConstruction()
{
var stack = TransactionStackFactory.Create(5);
Assert.AreEqual(false, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.AreEqual(5, stack.Capacity);
Assert.AreEqual(true, stack.IsEmpty);
Assert.AreEqual(false, stack.IsFull);
}
public void TestEmptyTransaction()
{
var stack = TransactionStackFactory.Create(5);
using (stack.CreateTransaction())
{
// Empty transaction
}
Assert.AreEqual(true, stack.IsEmpty);
Assert.AreEqual(false, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.Throws <TransactionException>(() => stack.Rollback());
}
public void TestTransactionDiscardPurgeMultiple()
{
var stack = TransactionStackFactory.Create(5);
var raiseCount = 0;
var expectedRaiseCount = 0;
var transactions = new ITransaction[5];
stack.TransactionDiscarded += (sender, e) =>
{
Assert.Equal(expectedRaiseCount, ++raiseCount);
Assert.Equal(DiscardReason.StackPurged, e.Reason);
Assert.Equal(3, e.Transactions.Count);
for (int i = 0; i < 3; ++i)
{
Assert.NotNull(e.Transactions[i]);
Assert.Equal(true, ((Operation)e.Transactions[i]).IsFrozen);
}
Assert.Equal((object)transactions[2], e.Transactions[0]);
Assert.Equal((object)transactions[3], e.Transactions[1]);
Assert.Equal((object)transactions[4], e.Transactions[2]);
++expectedRaiseCount;
};
for (var j = 0; j < stack.Capacity; ++j)
{
using (var transaction = stack.CreateTransaction())
{
for (var i = 0; i < 3; ++i)
{
var operation = new SimpleOperation();
stack.PushOperation(operation);
}
transactions[j] = transaction;
}
}
stack.Rollback();
stack.Rollback();
stack.Rollback();
stack.TransactionCompleted += (sender, e) => Assert.Equal(expectedRaiseCount, ++raiseCount);
using (stack.CreateTransaction())
{
for (var i = 0; i < 3; ++i)
{
var operation = new SimpleOperation();
stack.PushOperation(operation);
expectedRaiseCount = 1;
}
}
Assert.Equal(2, expectedRaiseCount);
Assert.Equal(2, raiseCount);
Assert.Equal(5, stack.Capacity);
}
public void TestEmptyNestedTransaction()
{
var stack = TransactionStackFactory.Create(5);
using (stack.CreateTransaction())
{
using (stack.CreateTransaction())
{
// Empty transaction
}
}
Assert.True(stack.IsEmpty);
Assert.False(stack.CanRollback);
Assert.False(stack.CanRollforward);
Assert.Throws <TransactionException>(() => stack.Rollback());
}
public void TestSingleOperationTransaction()
{
var stack = TransactionStackFactory.Create(5);
SimpleOperation operation;
using (stack.CreateTransaction())
{
operation = new SimpleOperation();
stack.PushOperation(new SimpleOperation());
}
Assert.AreEqual(false, stack.IsEmpty);
Assert.AreEqual(true, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.AreEqual(true, operation.IsDone);
Assert.AreEqual(0, operation.RollbackCount);
Assert.AreEqual(0, operation.RollforwardCount);
}
public void TestMultipleOperationsTransaction()
{
var stack = TransactionStackFactory.Create(5);
var counter = new OrderedOperation.Counter();
OrderedOperation[] operations = new OrderedOperation[4];
using (stack.CreateTransaction())
{
for (int i = 0; i < operations.Length; ++i)
{
var operation = new OrderedOperation(counter, 0, operations.Length - i - 1);
stack.PushOperation(operation);
}
}
Assert.AreEqual(false, stack.IsEmpty);
Assert.AreEqual(true, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
}
public void TestSingleOperationTransactionRollback()
{
var stack = TransactionStackFactory.Create(5);
SimpleOperation operation;
using (stack.CreateTransaction())
{
operation = new SimpleOperation();
stack.PushOperation(operation);
}
// Above code must be similar to TestSingleOperationTransaction
stack.Rollback();
Assert.Equal(false, stack.IsEmpty);
Assert.Equal(false, stack.CanRollback);
Assert.Equal(true, stack.CanRollforward);
Assert.Equal(false, operation.IsDone);
Assert.Equal(1, operation.RollbackCount);
Assert.Equal(0, operation.RollforwardCount);
}
public void TestInterleavedTransactionThrows()
{
var stack = (TransactionStack)TransactionStackFactory.Create(5);
SimpleOperation operation;
// Root transaction
var transaction1 = stack.CreateTransaction();
operation = new SimpleOperation();
stack.PushOperation(operation);
// Nested transaction
stack.CreateTransaction();
operation = new SimpleOperation();
stack.PushOperation(operation);
// Complete root transaction
Assert.Throws(typeof(TransactionException), () => transaction1.Complete());
}
public void TestTransactionDiscardStackFull()
{
var stack = TransactionStackFactory.Create(5);
var raiseCount = 0;
var expectedRaiseCount = 0;
var transactions = new ITransaction[5];
stack.TransactionDiscarded += (sender, e) =>
{
Assert.Equal(expectedRaiseCount, ++raiseCount);
Assert.Equal(DiscardReason.StackFull, e.Reason);
Assert.Equal(1, e.Transactions.Count);
Assert.NotNull(e.Transactions[0]);
Assert.Equal((object)transactions[0], e.Transactions[0]);
Assert.True(((Operation)e.Transactions[0]).IsFrozen);
++expectedRaiseCount;
};
for (var j = 0; j < stack.Capacity; ++j)
{
using (var transaction = stack.CreateTransaction())
{
for (var i = 0; i < 3; ++i)
{
var operation = new SimpleOperation();
stack.PushOperation(operation);
}
transactions[j] = transaction;
}
}
stack.TransactionCompleted += (sender, e) => Assert.Equal(expectedRaiseCount, ++raiseCount);
using (stack.CreateTransaction())
{
for (var i = 0; i < 3; ++i)
{
var operation = new SimpleOperation();
stack.PushOperation(operation);
}
expectedRaiseCount = 1;
}
Assert.Equal(2, expectedRaiseCount);
Assert.Equal(2, raiseCount);
}
public void TestDiscardStackFull()
{
var stack = TransactionStackFactory.Create(5);
var operations = new SimpleOperation[6];
for (var i = 0; i < operations.Length; ++i)
{
using (stack.CreateTransaction())
{
operations[i] = new SimpleOperation();
stack.PushOperation(operations[i]);
}
}
Assert.AreEqual(true, operations[0].IsFrozen);
for (var i = 1; i < operations.Length; ++i)
{
Assert.AreEqual(false, operations[i].IsFrozen);
Assert.AreEqual(operations[i], ((TransactionStack)stack).Transactions[i - 1].Operations[0]);
}
}
public void TestTransactionCompleted()
{
var stack = TransactionStackFactory.Create(5);
var raiseCount = 0;
var expectedRaiseCount = 0;
stack.TransactionCompleted += (sender, e) => Assert.Equal(expectedRaiseCount, ++raiseCount);
for (var j = 0; j < 8; ++j)
{
using (stack.CreateTransaction())
{
for (var i = 0; i < 5; ++i)
{
var operation = new SimpleOperation();
stack.PushOperation(operation);
}
++expectedRaiseCount;
}
}
Assert.Equal(8, expectedRaiseCount);
Assert.Equal(8, raiseCount);
}
public void TestClear()
{
var stack = TransactionStackFactory.Create(5);
var operations = new SimpleOperation[4];
for (var i = 0; i < operations.Length; ++i)
{
using (stack.CreateTransaction())
{
operations[i] = new SimpleOperation();
stack.PushOperation(operations[i]);
}
}
stack.Clear();
Assert.AreEqual(false, stack.CanRollback);
Assert.AreEqual(false, stack.CanRollforward);
Assert.AreEqual(5, stack.Capacity);
Assert.AreEqual(true, stack.IsEmpty);
Assert.AreEqual(false, stack.IsFull);
foreach (var operation in operations)
{
Assert.AreEqual(true, operation.IsFrozen);
}
}
public void TestDiscardMultipleStackFull()
{
var stack = TransactionStackFactory.Create(5);
var operations = new SimpleOperation[8];
for (var i = 0; i < operations.Length; ++i)
{
using (stack.CreateTransaction())
{
operations[i] = new SimpleOperation();
stack.PushOperation(operations[i]);
}
}
for (int i = 0; i < 3; ++i)
{
Assert.True(operations[0].IsFrozen);
}
for (var i = 3; i < operations.Length; ++i)
{
Assert.False(operations[i].IsFrozen);
Assert.Equal(operations[i], ((TransactionStack)stack).Transactions[i - 3].Operations[0]);
}
}
public UndoRedoService(int stackCapacity)
{
stack = TransactionStackFactory.Create(stackCapacity);
stack.TransactionCompleted += TransactionCompleted;
dirtiableManager = new DirtiableManager(stack);
}
