public void MaximumSupportedOperationsTest()
{
var mementoService = new MementoService(5);
var listUndoOps = new List <MockUndo>();
for (var i = 0; i < 10; i++)
{
var memento = new MockUndo()
{
Value = i
};
mementoService.Add(memento);
listUndoOps.Add(memento);
}
var count = 0;
while (mementoService.CanUndo)
{
mementoService.Undo();
count++;
}
for (var i = 0; i < 5; i++)
{
Assert.IsFalse(listUndoOps[i].UndoCalled);
}
for (var i = 5; i < 10; i++)
{
Assert.IsTrue(listUndoOps[i].UndoCalled);
}
Assert.AreEqual(count, mementoService.MaximumSupportedBatches);
}
public void RaisesUpdatedEvent(int actionsCount)
{
var mementoService = new MementoService();
var raisedEventsCount = 0;
mementoService.Updated += (sender, args) =>
{
if (args.MementoAction == MementoAction.Undo)
{
raisedEventsCount++;
}
};
for (var i = 0; i < actionsCount; i++)
{
mementoService.Add(new MockUndo(true));
}
for (var i = 0; i < actionsCount; i++)
{
mementoService.Undo();
}
Assert.AreEqual(actionsCount, raisedEventsCount);
}
public void SetsValuesCorrectly()
{
var obj = new Mocks.MockModel();
var tag = "MyTag";
var service = new MementoService();
var observer = new ObjectObserver(obj, tag, service);
Assert.AreEqual(tag, observer.Tag);
}
public void CanUndoTest()
{
var mementoService = new MementoService();
Assert.IsFalse(mementoService.CanUndo);
mementoService.Add(new MockUndo());
Assert.IsTrue(mementoService.CanUndo);
mementoService.Undo();
Assert.IsFalse(mementoService.CanUndo);
}
public void PreventsAdditionsWhenDisabled()
{
var mementoService = new MementoService();
mementoService.IsEnabled = false;
var undo1 = new MockUndo(true);
mementoService.Add(undo1);
Assert.IsFalse(mementoService.CanRedo);
}
public void UndoTest()
{
var mementoService = new MementoService();
var undo1 = new MockUndo();
var undo2 = new MockUndo();
mementoService.Add(undo1);
mementoService.Add(undo2);
mementoService.Undo();
Assert.IsTrue(undo2.UndoCalled);
Assert.IsFalse(undo1.UndoCalled);
Assert.IsTrue(mementoService.CanUndo);
}
public void CancelsSubscriptionForInstance()
{
var obj = new MockModel {
Value = "value1"
};
var service = new MementoService();
service.RegisterObject(obj);
service.UnregisterObject(obj);
obj.Value = "newvalue";
Assert.IsFalse(service.CanUndo);
}
public void CallActions()
{
var value = false;
var mementoService = new MementoService();
var action = new ActionUndo(this, () => value = true, () => value = false);
mementoService.Add(action);
Assert.IsFalse(value);
mementoService.Undo();
Assert.IsTrue(value);
mementoService.Redo();
Assert.IsFalse(value);
}
public void SetProperty()
{
var instance = new MockCatelModel();
var action = new PropertyChangeUndo(instance, "Value", "previousValue", "nextValue");
var mementoService = new MementoService();
mementoService.Add(action);
Assert.AreEqual(MockCatelModel.ValueProperty.GetDefaultValue(), instance.Value);
mementoService.Undo();
Assert.AreEqual("previousValue", instance.Value);
mementoService.Redo();
Assert.AreEqual("nextValue", instance.Value);
}
public void SetProperty()
{
var instance = new IniEntry();
var action = new PropertyChangeUndo(instance, "Key", "previousValue", "nextValue");
var mementoService = new MementoService();
mementoService.Add(action);
Assert.AreEqual(IniEntry.KeyProperty.GetDefaultValue(), instance.Key);
mementoService.Undo();
Assert.AreEqual("previousValue", instance.Key);
mementoService.Redo();
Assert.AreEqual("nextValue", instance.Key);
}
public void ClearsCurrentUndoRedoStackForInstance()
{
var obj = new MockModel {
Value = "value1"
};
var service = new MementoService();
service.RegisterObject(obj);
obj.Value = "newvalue1";
Assert.IsFalse(service.CanRedo);
service.UnregisterObject(obj);
Assert.IsFalse(service.CanUndo);
}
public void CorrectlyIgnoresDuplicatePropertyChangesWithEqualValues()
{
var obj = new Mocks.MockModel();
var service = new MementoService();
var observer = new ObjectObserver(obj, mementoService: service);
Assert.AreEqual(0, service.UndoBatches.Count());
obj.Value = "A";
Assert.AreEqual(1, service.UndoBatches.Count());
obj.Value = "A";
Assert.AreEqual(1, service.UndoBatches.Count());
}
public void HandlesDoubleUndo()
{
var obj = new MockModel {
Value = "value1"
};
var service = new MementoService();
service.RegisterObject(obj);
obj.Value = "value2";
obj.Value = "value3";
service.Undo();
Assert.AreEqual("value2", obj.Value);
service.Undo();
Assert.AreEqual("value1", obj.Value);
}
public void EndsBatchWhenThereAlreadyIsABatch()
{
var mementoService = new MementoService();
var model = new MockModel();
var firstBatch = mementoService.BeginBatch("FirstBatch");
mementoService.Add(new PropertyChangeUndo(model, "Value", model.Value));
Assert.AreEqual(1, firstBatch.ActionCount);
var secondBatch = mementoService.BeginBatch("SecondBatch");
mementoService.Add(new PropertyChangeUndo(model, "Value", model.Value));
Assert.AreEqual(1, secondBatch.ActionCount);
mementoService.EndBatch();
Assert.AreEqual(2, mementoService.UndoBatches.Count());
}
public void RaisesClearDataEvent()
{
var mementoService = new MementoService();
var success = false;
mementoService.Updated += (sender, e) =>
{
if (e.MementoAction == MementoAction.ClearData)
{
success = true;
}
};
mementoService.Clear();
Assert.IsTrue(success);
}
public void RaisesChangeRecordedEvent()
{
var mementoService = new MementoService();
var success = false;
mementoService.Updated += (sender, e) =>
{
if (e.MementoAction == MementoAction.ChangeRecorded)
{
success = true;
}
};
var undo1 = new MockUndo();
mementoService.Add(undo1);
Assert.IsTrue(success);
}
public void UndoBatches()
{
var model = new MockModel();
var mementoService = new MementoService();
mementoService.RegisterObject(model);
string originalNumber = model.Value;
mementoService.BeginBatch();
model.Value = "1000";
model.Value = "100";
model.Value = "10";
var mementoBatch = mementoService.EndBatch();
mementoBatch.Undo();
Assert.AreEqual(originalNumber, model.Value);
}
public void ThrowsArgumentNullExceptionForNullInstance()
{
var service = new MementoService();
ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => service.UnregisterObject(null));
}
public void ExpectDefaultMaximumSupportedActionsValue()
{
var mementoService = new MementoService();
Assert.AreEqual(300, mementoService.MaximumSupportedBatches);
}
public void IsTrueByDefault()
{
var mementoService = new MementoService();
Assert.IsTrue(mementoService.IsEnabled);
}
