public void Do_Should_override_oldest_operation_When_max_capacity()
{
IUnDoManager manager = new UnDoManager(2);
IUnDo operation1 = Substitute.For <IUnDo>();
IUnDo operation2 = Substitute.For <IUnDo>();
IUnDo operation3 = Substitute.For <IUnDo>();
operation1.Description.Returns("un");
operation2.Description.Returns("dos");
operation3.Description.Returns("tres");
manager.Do(operation1);
manager.Do(operation2);
manager.Do(operation3);
Check.That(manager.UndoDescriptions).ContainsExactly("tres", "dos");
manager.Undo();
manager.Undo();
Check.That(manager.RedoDescriptions).ContainsExactly("dos", "tres");
manager.Redo();
manager.Redo();
Check.That(manager.UndoDescriptions).ContainsExactly("tres", "dos");
}
public void DoClear_Should_add_old_elements_When_undone()
{
ICollection <object> source = new List <object>
{
new object(),
new object(),
new object()
};
IUnDoManager manager = Substitute.For <IUnDoManager>();
IUnDo undo = null;
List <object> sourceCopy = source.ToList();
manager.Do(Arg.Do <IUnDo>(i => undo = i));
manager.DoClear(source);
Check.That(undo).IsNotNull();
undo.Do();
Check.That(source.Count).IsEqualTo(0);
undo.Undo();
Check.That(source).ContainsExactly(sourceCopy);
}
public void TryMerge_Should_return_false_When_description_are_different()
{
IMergeableUnDo value = new ValueUnDo <int>("kikoo", _ => { }, 0, 0);
IUnDo undo = Substitute.For <IUnDo>();
undo.Description.Returns("lol");
Check.That(value.TryMerge(undo, out _)).IsFalse();
}
public void TryMerge_Should_return_false_When_other_is_not_GroupUnDo_with_single_ValueUnDo()
{
IMergeableUnDo value = new ValueUnDo <int>("test", _ => { }, 0, 0);
IUnDo undo = Substitute.For <IUnDo>();
undo.Description.Returns("test");
Check.That(value.TryMerge(new GroupUnDo("test", undo), out _)).IsFalse();
}
/// <inheritdoc />
bool IMergeableUnDo.TryMerge(IUnDo other, out IUnDo mergedCommand)
{
mergedCommand =
Equals(_description, other.Description) &&
TryGetSingle(out IMergeableUnDo mergeable) &&
mergeable.TryMerge(other, out mergedCommand)
? new GroupUnDo(_description, mergedCommand)
: null;
return(mergedCommand != null);
}
public void Do_Should_not_add_command_in_history_when_a_group_is_going_on(IUnDoManager manager)
{
IUnDo undo = Substitute.For <IUnDo>();
int version = manager.Version;
using (manager.BeginTransaction())
{
manager.Do(undo);
Check.That(manager.Version).IsEqualTo(version);
}
}
public void Do_Should_Do(IUnDoManager manager)
{
IUnDo undo = Substitute.For <IUnDo>();
bool done = false;
undo.When(u => u.Do()).Do(_ => done = true);
manager.Do(undo);
Check.That(done).IsTrue();
}
/// <inheritdoc />
bool IMergeableUnDo.TryMerge(IUnDo other, out IUnDo mergedCommand)
{
mergedCommand =
Equals(_description, other.Description) &&
(other is ValueUnDo <T> value || (other is GroupUnDo group && group.TryGetSingle(out value))) &&
_setter == value._setter &&
Equals(_newValue, value._oldValue) &&
(value._timeStamp - _timeStamp) < MergeInterval
? new ValueUnDo <T>(_description, _setter, value._newValue, _oldValue)
: null;
return(mergedCommand != null);
}
public void DoOnUnDo_Should_call_action()
{
IUnDoManager manager = Substitute.For <IUnDoManager>();
IUnDo undo = null;
bool done = false;
manager.Do(Arg.Do <IUnDo>(i => undo = i));
manager.DoOnUndo(() => done = true);
Check.That(undo).IsNotNull();
undo.Undo();
Check.That(done).IsTrue();
}
public int Push(IUnDo command, int doVersion, int undoVersion)
{
if (_doneOperations.Count > 0 &&
_doneOperations.Peek().Command is IMergeableUnDo mergeable &&
mergeable.TryMerge(command, out IUnDo mergedCommand))
{
command = mergedCommand;
undoVersion = _doneOperations.Pop().UndoVersion;
}
_doneOperations.Push(new Operation(command, doVersion, undoVersion));
_undoneOperations.Clear();
return(doVersion);
}
public void IUnDoTransactionDispose_Should_undo_When_not_committed()
{
IUnDoManager manager = new UnDoManager(1);
bool unDone = false;
using (IUnDoTransaction transaction = manager.BeginTransaction())
{
IUnDo undo = Substitute.For <IUnDo>();
undo.When(u => u.Undo()).Do(_ => unDone = true);
manager.Do(undo);
}
Check.That(unDone).IsTrue();
}
public void RedoDescriptions_Should_return_descriptions_of_redoable_operations(IUnDoManager manager)
{
IUnDo operation1 = Substitute.For <IUnDo>();
IUnDo operation2 = Substitute.For <IUnDo>();
operation1.Description.Returns("kikoo");
operation2.Description.Returns("lol");
manager.Do(operation1);
manager.Do(operation2);
Check.That(manager.RedoDescriptions).IsEmpty();
manager.Undo();
manager.Undo();
Check.That(manager.RedoDescriptions).ContainsExactly("kikoo", "lol");
}
public void Do_Should_merge_When_possible(IUnDoManager manager)
{
IMergeableUnDo mergeable = Substitute.For <IMergeableUnDo>();
IUnDo undo = Substitute.For <IUnDo>();
IUnDo merged = Substitute.For <IUnDo>();
merged.Description.Returns("yay");
mergeable.TryMerge(undo, out Arg.Any <IUnDo>()).Returns(x =>
{
x[1] = merged;
return(true);
});
manager.Do(mergeable);
manager.Do(undo);
Check.That(manager.UndoDescriptions).ContainsExactly("yay");
}
public void Do_Should_operation_When_max_capacity_is_one()
{
IUnDoManager manager = new UnDoManager(1);
IUnDo operation1 = Substitute.For <IUnDo>();
IUnDo operation2 = Substitute.For <IUnDo>();
operation1.Description.Returns("kikoo");
operation2.Description.Returns("lol");
manager.Do(operation1);
manager.Do(operation2);
Check.That(manager.UndoDescriptions).ContainsExactly("lol");
Check.That(manager.RedoDescriptions).IsEmpty();
manager.Undo();
Check.That(manager.UndoDescriptions).IsEmpty();
Check.That(manager.RedoDescriptions).ContainsExactly("lol");
}
public void Do_IDictionary_Should_remove_element_When_undone()
{
object key = new();
IDictionary <object, object> source = new Dictionary <object, object>();
IUnDoManager manager = Substitute.For <IUnDoManager>();
IUnDo undo = null;
manager.Do(Arg.Do <IUnDo>(i => undo = i));
manager.Do(source, key, null);
Check.That(undo).IsNotNull();
undo.Do();
Check.That(source.ContainsKey(key)).IsTrue();
undo.Undo();
Check.That(source.ContainsKey(key)).IsFalse();
}
public int Push(IUnDo command, int doVersion, int undoVersion)
{
if (_hasOperation)
{
if (_buffer[_current].Command is IMergeableUnDo mergeable &&
mergeable.TryMerge(command, out IUnDo mergedCommand))
{
command = mergedCommand;
undoVersion = _buffer[_current].UndoVersion;
}
else
{
if (++_current >= _buffer.Length)
{
_current -= _buffer.Length;
}
if (_tail == _current && ++_tail >= _buffer.Length)
{
_tail -= _buffer.Length;
}
}
}
public void BeginTransaction_Should_add_commands_as_one_operation_in_history_once_disposed(IUnDoManager manager)
{
IUnDo undo = Substitute.For <IUnDo>();
undo.Description.Returns("dummy");
int version = manager.Version;
using (IUnDoTransaction t1 = manager.BeginTransaction("first"))
using (IUnDoTransaction t2 = manager.BeginTransaction("second"))
{
manager.Do(undo);
manager.Do(undo);
t2.Commit();
t1.Commit();
}
Check.That(manager.Version).IsStrictlyGreaterThan(version);
Check.That(manager.UndoDescriptions).ContainsExactly("first");
manager.Undo();
Check.That(manager.Version).IsEqualTo(version);
}
public void Add(IUnDo command) => _commands.Add(command);
private void Push(IUnDo command) => Version = _stack.Push(command, ++_lastVersion, Version);
public Operation(IUnDo command, int doVersion, int undoVersion)
{
Command = command;
DoVersion = doVersion;
UndoVersion = undoVersion;
}
