public UndoRedoHistory(int capacity, MapForm s)
{
this.capacity = capacity;
this.undoStack = new CircularStack<Action>(this.capacity);
this.redoStack = new CircularStack<Action>(this.capacity);
this.subject = s;
}
public void CircularStack_Should_BeInitializedWithProvidedCapacity()
{
int capacity = 100;
var obj = new CircularStack(capacity);
Assert.AreEqual(capacity, obj.Capacity);
}
public void Push_ShouldNot_ChangeCapacity()
{
var obj = new CircularStack();
obj.Push(1);
Assert.AreEqual(CircularStack.DefaultCapacity, obj.Capacity);
}
public void Count_Should_ReturnItemCount()
{
var arr = new List <string> {
"a", "b"
};
var obj = new CircularStack(arr);
Assert.AreEqual(2, obj.Count);
}
public void IsFull_Should_ReturnTrue_WhenStackIsFull()
{
var arr = new List <string> {
"a", "b"
};
var obj = new CircularStack(arr);
Assert.IsTrue(obj.IsFull);
}
public void Push_Should_AddItem_WhenStackIsEmpty()
{
var obj = new CircularStack();
obj.Push(1);
Assert.AreEqual(1, obj.Count);
obj.ShouldContainElement(1);
}
public void Constructor()
{
var stack = new CircularStack <int>();
for (int i = 0; i < 4; i++)
{
stack.Add(i);
}
Assert.AreEqual(stack.Count, 4);
}
public void IsEmpty01()
{
var cq = new CircularStack <int>(1);
Assert.IsTrue(cq.IsEmpty());
cq.Push(1);
Assert.IsFalse(cq.IsEmpty());
cq.Pop();
Assert.IsTrue(cq.IsEmpty());
}
public void Push_Should_AddItem_When_ThereIsOnlyOneSpaceLeft()
{
var obj = new CircularStack <int>(2);
obj.Push(1);
obj.Push(2);
Assert.AreEqual(2, obj.Count);
obj.ShouldContainElementsInOrder(2, 1);
}
public void Push01()
{
var capacity = 4;
var cq = new CircularStack <int>(capacity);
for (int i = 0; i < 6; i++)
{
cq.Push(i);
}
Assert.AreEqual(capacity, cq.Count());
}
public void Pop_ShouldNot_ChangeCapacity()
{
var arr = new List <object> {
new { }, new { }
};
var obj = new CircularStack(arr);
obj.Pop();
Assert.AreEqual(2, obj.Capacity);
}
public void Pop_Should_RemoveItem_When_ThereIsOnlyOne()
{
var arr = new List <string> {
"a"
};
var obj = new CircularStack(arr);
obj.Pop();
Assert.AreEqual(0, obj.Count);
}
public void Pop_Should_RespectCapacity()
{
var arr = new List <object> {
new { }
};
var obj = new CircularStack(arr);
obj.Pop();
Assert.Throws <InvalidOperationException>(() => obj.Pop());
}
public void Push_Should_AddItem()
{
var arr = new List <string> {
"a", "b"
};
var obj = new CircularStack <string>(arr, 4);
obj.Push("c");
Assert.AreEqual(3, obj.Count);
obj.ShouldContainElementsInOrder("c", "b", "a");
}
public void Peek_ShouldNot_RemoveItem()
{
var arr = new List <string> {
"a", "b"
};
var obj = new CircularStack <string>(arr);
obj.Peek();
Assert.AreEqual(2, obj.Count);
obj.ShouldContainElementsReversed(arr);
}
public void Pop_Should_ReturnItem()
{
var expected = "b";
var arr = new List <string> {
"a", "b"
};
var obj = new CircularStack(arr);
var actual = obj.Pop();
Assert.AreSame(expected, actual);
}
public void Pop_Should_ReturnItem_When_ThereIsOnlyOne()
{
var expected = "a";
var arr = new List <string> {
"a"
};
var obj = new CircularStack(arr);
var actual = obj.Pop();
Assert.AreSame(expected, actual);
}
public void CircularStack_Should_BeInitializedWithCollectionAndCapacity()
{
var items = new List <string> {
"a", "b"
};
var obj = new CircularStack <string>(items, 4);
Assert.AreEqual(2, obj.Count);
Assert.AreEqual(4, obj.Capacity);
obj.ShouldContainElementsReversed(items);
}
public void Push_Should_DropLastItem_When_StackIsFull()
{
var expected = "b";
var arr = new List <string> {
"a", expected
};
var obj = new CircularStack <string>(arr);
obj.Push("c");
obj.ShouldContainElementsInOrder("c", "b");
}
public void Pop_Should_Work_When_ItemDropped()
{
var obj = new CircularStack(2);
obj.Push("a");
obj.Push("b");
obj.Push("c");
Assert.AreEqual("c", obj.Pop());
Assert.AreEqual("b", obj.Pop());
Assert.Throws <InvalidOperationException>(() => obj.Pop());
}
public void Pop_Should_Work_When_StackIsInitializedFromCollection()
{
var arr = new List <string> {
"a", "b", "c", "d"
};
var obj = new CircularStack(arr);
Assert.AreEqual("d", obj.Pop());
Assert.AreEqual("c", obj.Pop());
Assert.AreEqual("b", obj.Pop());
Assert.AreEqual("a", obj.Pop());
}
public void Pop_Should_RemoveItem()
{
var arr = new List <string> {
"a", "b"
};
var obj = new CircularStack <string>(arr);
obj.Pop();
Assert.AreEqual(1, obj.Count);
obj.ShouldContainElementsInOrder("a");
}
public void EnumeratorTest()
{
var stack = new CircularStack <int>(new[] { 1, 2, 3, 4, 5 });
var i = 2;
foreach (var sElent in stack[1].Take(4))
{
Assert.AreEqual(sElent, i);
i++;
}
Assert.AreEqual(stack[1].Last(), 1);
}
public void Push_Should_Work_When_StackIsInitializedFromCollection()
{
var arr = new List <string> {
"a", "b", "c"
};
var obj = new CircularStack <string>(arr, 5);
var expected = "d";
obj.Push(expected);
obj.ShouldContainElementsInOrder("d", "c", "b", "a");
}
public void Count01()
{
var cq = new CircularStack <int>(4);
Assert.AreEqual(0, cq.Count());
cq.Push(1);
cq.Push(1);
Assert.AreEqual(2, cq.Count());
cq.Pop();
Assert.AreEqual(1, cq.Count());
cq.Pop();
Assert.AreEqual(0, cq.Count());
}
public void Push_Should_WorkAfterPop()
{
var expected = "c";
var arr = new List <string> {
"a", "b", "d"
};
var obj = new CircularStack <string>(arr);
obj.Pop();
obj.Push(expected);
Assert.AreSame(expected, obj.Peek());
obj.ShouldContainElementsInOrder("c", "b", "a");
}
public void Pop_Should_WorkAfterPush()
{
var expected = "k";
var arr = new List <string> {
"a", "b", "d"
};
var obj = new CircularStack <string>(arr);
obj.Push(expected);
var actual = obj.Pop();
Assert.AreSame(expected, actual);
obj.ShouldContainElementsInOrder("d", "b");
}
public static void ShouldContainElement <T>(this CircularStack <T> stack, T element)
{
bool found = false;
foreach (var item in stack)
{
if (item.Equals(element))
{
found = true;
break;
}
}
Assert.IsTrue(found);
}
public static void ShouldContainElementsInOrder <T>(this CircularStack <T> stack, params T[] elements)
{
Assert.AreEqual(elements.Length, stack.Count);
int idx = 0;
foreach (var item in stack)
{
if (item != null)
{
Assert.AreEqual(elements[idx], item);
idx++;
}
}
}
public void EqualityForClassType()
{
var stack1 = new CircularStack <TestClass>();
for (int i = 0; i < 20; i++)
{
stack1.Add(new TestClass(i * 20.1));
}
var stack2 = new CircularStack <TestClass>();
for (int i = 0; i < 20; i++)
{
stack2.Add(new TestClass(i * 20.1));
}
Assert.AreEqual(stack1, stack2);
}
public void Pop01()
{
var capacity = 4;
var cq = new CircularStack <int>(capacity);
for (int i = 0; i < capacity; i++)
{
cq.Push(i);
}
for (int i = 0; i < capacity; i++)
{
Assert.AreEqual(capacity - (i + 1), cq.Pop());
Assert.AreEqual(capacity - (i + 1), cq.Count());
}
Assert.Throws <InvalidOperationException>(() => cq.Pop());
}
