public void ConvertEmptyStackToArray()
{
ArrayStack<int> arrayStack = new ArrayStack<int>();
int [] expected= new int[0];
int[] actual = arrayStack.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void Test_Push_Pop()
{
ArrayStack<int> roo = new ArrayStack<int>();
Assert.AreEqual(0,roo.Count);
roo.Push(9);
Assert.AreEqual(1,roo.Count);
Assert.AreEqual(9,roo.Pop());
Assert.AreEqual(0,roo.Count);
ArrayStack<string> testPush = new ArrayStack<string>();
Assert.AreEqual(0, testPush.Count);
for (int i = 1; i <= 1000; i++)
{
testPush.Push("as"+i);
Assert.AreEqual(i, testPush.Count);
}
for (int i = 1000; i >= 1; i--)
{
Assert.AreEqual("as"+i, testPush.Pop());
Assert.AreEqual(i - 1, testPush.Count);
}
}
public void EmptyStackToArray_ShouldReturnEmptyArray()
{
var stack = new ArrayStack<DateTime>();
var actual = stack.ToArray().Length;
Assert.AreEqual(0, actual, "Array is not empty.");
}
public void TestPushPopElement()
{
var arrayStack = new ArrayStack<int>();
arrayStack.Push(6);
// I'll know how to make unit testing in a week.
}
public void ArrayStack_PushPopManyChunks_ShouldWorkCorrectly()
{
// Arrange
var stack = new ArrayStack<int>();
int chunks = 100;
// Act & Assert in a loop
int value = 1;
for (int i = 0; i < chunks; i++)
{
Assert.AreEqual(0, stack.Count);
var chunkSize = i + 1;
for (int counter = 0; counter < chunkSize; counter++)
{
Assert.AreEqual(value - 1, stack.Count);
stack.Push(value);
Assert.AreEqual(value, stack.Count);
value++;
}
for (int counter = 0; counter < chunkSize; counter++)
{
value--;
Assert.AreEqual(value, stack.Count);
stack.Pop();
Assert.AreEqual(value - 1, stack.Count);
}
Assert.AreEqual(0, stack.Count);
}
}
public void Push_OneElement_ShouldBeReturnedWhenPop()
{
var arrayStack = new ArrayStack<bool>();
arrayStack.Push(true);
Assert.AreEqual(true, arrayStack.Pop());
}
public void Push_OneElement_InCustomCapacityStack_ShouldAddProperly()
{
var newStack = new ArrayStack<string>(1);
newStack.Push("ha");
Assert.AreEqual(1, newStack.Count);
}
public void EmptyStackToArray()
{
var stack = new ArrayStack<DateTime>();
var testArr = new DateTime[0];
CollectionAssert.AreEqual(testArr, stack.ToArray());
}
public void TestEmptyStackToArray_ShouldReturnEmptyArray()
{
var stack = new ArrayStack<DateTime>();
var array = stack.ToArray();
var expected = new DateTime[0];
CollectionAssert.AreEqual(expected, array);
}
public void CreateStack_PushSingleElement_ShouldWorkCorrectly()
{
var stack = new ArrayStack<int>();
stack.Push(3);
Assert.AreEqual(3, stack.Peak());
Assert.AreEqual(1, stack.Count);
}
public void PushAndPopRepeat1000Times()
{
// Arrange
ArrayStack<string> stack = new ArrayStack<string>();
var count = 0;
// Assert
Assert.AreEqual(count, stack.Count);
// Act
for (int i = 0; i < 1000; i++)
{
stack.Push("Plamen");
}
// Assert
Assert.AreEqual(1000, stack.Count);
// Act
var poppedElement = string.Empty;
for (int i = 0; i < 1000; i++)
{
poppedElement = stack.Pop();
}
Assert.AreEqual(poppedElement, "Plamen");
Assert.AreEqual(count, stack.Count);
}
public void PushAndPopWithInitialCapacity1ShouldWorkCorrectly()
{
//Arrange
var stack = new ArrayStack<int>(1);
//Assert
Assert.AreEqual(0, stack.Count);
//Act
stack.Push(1);
//Assert
Assert.AreEqual(1, stack.Count);
//Act
stack.Push(2);
//Assert
Assert.AreEqual(2, stack.Count);
//Act
var element = stack.Pop();
//Assert
Assert.AreEqual(2, element);
Assert.AreEqual(1, stack.Count);
//Act
element = stack.Pop();
//Assert
Assert.AreEqual(1, element);
Assert.AreEqual(0, stack.Count);
}
public void StackWithOneElementShouldHaveCountOne()
{
ArrayStack<int> arrayStack = new ArrayStack<int>();
arrayStack.Push(15);
Assert.AreEqual(1, arrayStack.Count);
}
public void PushPop100Elements_CountShouldBeCorrect()
{
var stack = new ArrayStack<string>();
var items = new List<string>();
Assert.AreEqual(0, stack.Count, "Count is not 0.");
for (int i = 0; i < 1000; i++)
{
string currentElement = i.ToString();
items.Add((999 - i).ToString());
stack.Push(currentElement);
Assert.AreEqual(i + 1, stack.Count, $"Count is not {i + 1}.");
}
Assert.AreEqual(1000, stack.Count, "Count is not 1000.");
for (int i = 0; i < 1000; i++)
{
string poppedElement = stack.Pop();
string expectedElement = items[i];
Assert.AreEqual(expectedElement, poppedElement, $"Popped element is not {expectedElement}");
Assert.AreEqual(999 - i, stack.Count, $"Count is not {999 - i}.");
}
Assert.AreEqual(0, stack.Count, "Count is not 0");
}
public void PushPopElement()
{
ArrayStack<int> testStack = new ArrayStack<int>();
Assert.AreEqual(0,testStack.Count);
testStack.Push(1);
Assert.AreEqual(1,testStack.Count);
}
public void PushAndPop_StackWith1000Elemnts_ShouldTestTheAutoGrowFunctionality()
{
//Arrange
var stack = new ArrayStack<string>();
int i = 0;
//Assert
Assert.AreEqual(0, stack.Count);
while(i != 1000)
{
//Act
i++;
stack.Push(i.ToString());
//Assert
Assert.AreEqual(i, stack.Count);
}
while (i != 0)
{
//Act
i--;
string lastElement = stack.Pop();
//Assert
Assert.AreEqual(i, stack.Count);
Assert.AreEqual((i + 1).ToString(), lastElement);
}
}
public void TestEmptyStackToArray()
{
var stack = new ArrayStack<DateTime>();
DateTime[] array = stack.ToArray();
Assert.AreEqual(0, array.Length);
}
public void EmptyStack_PushSingleElement_CountShouldBeOne()
{
var stack = new ArrayStack<int>();
stack.Push(1);
Assert.AreEqual(1, stack.Count, "Stack Count is not 1.");
}
public void ToArray_EmptyStack_ShouldReturnEmptyArray()
{
var stack = new ArrayStack<DateTime>();
var arr = stack.ToArray();
CollectionAssert.AreEqual(new DateTime [] {}, arr);
}
public void EmptyStackToArray_ArrayShouldBeEmpty()
{
var stack = new ArrayStack<int>();
var array = stack.ToArray();
Assert.AreEqual(0, array.Length);
}
[TestMethod] // IDisposable
public void DisposeTest()
{
int n = 2;
ArrayStack<object> data = new ArrayStack<object>(n);
data.Push(6);
data.Push(10);
data.Dispose();
}
public void PopEmptyStack()
{
ArrayStack<string> testStack = new ArrayStack<string>();
Assert.Throws<IndexOutOfRangeException>(() =>
{
testStack.Pop();
});
}
public void TestCountAfterPushing()
{
var stack = new ArrayStack<int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
Assert.AreEqual(3, stack.Count);
}
public void Create_EmptyArrayStack_ShouldGetCountZero()
{
// Arrange
var emptyStack = new ArrayStack<int>();
// Assert
Assert.AreEqual(0, emptyStack.Count);
}
[TestMethod] // ICloneable
public void CloneTest()
{
int n = 2;
ArrayStack<object> data = new ArrayStack<object>(n);
data.Push(8);
data.Push(10);
data.Clone();
}
[TestMethod] // получение последнего элемента
public void PopTest()
{
int n = 2;
ArrayStack<object> data = new ArrayStack<object>(n);
data.Push(8);
data.Push(6);
data.Pop();
}
public void TestEmptyStackToArray_ShouldReturnEmptyArray()
{
var stack = new ArrayStack<List<Dictionary<bool[], decimal>>>();
var arr = stack.ToArray();
Assert.AreEqual(0, arr.Length);
}
public void CreateStack_PeakTopElement_ShouldWorkCorrectly()
{
var stack = new ArrayStack<int>();
stack.Push(2);
stack.Push(6);
Assert.AreEqual(6, stack.Peak());
}
public void PopElementFromStackShouldReturnTheProperElementAndDecreaseCountWithOne()
{
ArrayStack<int> stackOfInts = new ArrayStack<int>();
stackOfInts.Push(5);
int poppedElement = stackOfInts.Pop();
Assert.AreEqual(5, poppedElement);
Assert.AreEqual(0, stackOfInts.Count);
}
public void Push_FewElements_InCustomCapacityStack_ShouldAddProperly()
{
var newStack = new ArrayStack<string>(1);
newStack.Push("Az");
newStack.Push("Ti");
Assert.AreEqual(2, newStack.Count);
}
public void ToArray_ShouldReturnCorrectArray()
{
var initialArr = new[] { 7, -2, 5, 3 };
var stack = new ArrayStack <int>();
for (int i = initialArr.Length - 1; i >= 0; i--)
{
stack.Push(initialArr[i]);
}
var convertedStack = stack.ToArray();
CollectionAssert.AreEqual(initialArr, convertedStack);
}
public void ToArray_ShouldReturnCorrectArray()
{
var array = new[] { 7, -2, 5, 3 };
var stack = new ArrayStack <int>();
for (int i = array.Length - 1; i >= 0; i--)
{
stack.Push(array[i]);
}
var arrayFromStack = stack.ToArray();
CollectionAssert.AreEqual(array, arrayFromStack);
}
public void Peek_RemoveAnItemFromStack_ReturnLastItem()
{
// Create and initialise ArrayStack
ArrayStack stack = new ArrayStack(2);
stack.Push("Tong");
stack.Push("Test");
stack.Pop();
String expected = "The string 'Tong' was recently added to stack";
String actual = stack.Peek();
Assert.AreEqual(expected, actual);
}
public void Count_RemoveOneItemFromFilledStack_ReturnOne()
{
// Create and initialise ArrayStack
ArrayStack stack = new ArrayStack(2);
stack.Push("Tong");
stack.Push("Test");
stack.Pop();
int expected = 1;
int actual = stack.Count();
Assert.AreEqual(expected, actual);
}
public void Pop_OutElementFromStack_ReturnProperFeedback()
{
// Create and initialise ArrayStack
ArrayStack stack = new ArrayStack(2);
// Push an element
stack.Push("Test");
stack.Push("Test");
String expected = "The string 'Test' was removed from stack";
String actual = stack.Pop();
//Check if the pop properly outputs the correct feedback
Assert.AreEqual(expected, actual);
}
public void Peek_IfElementIsLatest_ReturnProperFeedback()
{
// Create and initialise ArrayStack
ArrayStack stack = new ArrayStack(2);
// Push an element
stack.Push("Test");
stack.Push("Ayy");
String expected = "The string 'Ayy' was recently added to stack";
String actual = stack.Peek();
//Check if the peek properly outputs the correct feedback
Assert.AreEqual(expected, actual);
}
public static void Main(string[] args)
{
ArrayStack <int> stack = new ArrayStack <int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
stack.Push(4);
stack.Push(5);
stack.Push(6);
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Pop());
int[] nums = stack.ToArray();
Console.WriteLine(string.Join(", ", nums));
}
public static void DisplayArrayStack()
{
ArrayStack <int> stack = new ArrayStack <int>();
for (int i = 1; i <= 5; i++)
{
stack.Push(i);
}
while (!stack.IsEmpty())
{
stack.Pop();
Console.Write(stack.CurrentData + " ");
}
}
public void TestToArrayMethod()
{
int[] numbers = new int[] { 3, 5, -2, 7 };
ArrayStack <int> elements = new ArrayStack <int>();
foreach (int number in numbers)
{
elements.Push(number);
}
int[] arrayStackNumbers = elements.ToArray();
// asserts the two arrays are equal
Assert.IsTrue(numbers.Reverse().SequenceEqual(arrayStackNumbers), MESSAGE_THETWOARRAYSARENOTSAME);
}
public void Pop100ElementsShouldNotContainElements()
{
var stack = new ArrayStack <int>();
for (int i = 0; i < 500; i++)
{
stack.Push(i);
}
for (int i = 0; i < 500; i++)
{
stack.Pop();
}
Assert.IsTrue(stack.Count == 0, "The stack count must be 0.");
}
public void Count_FilledArrayThenEmptied_ReturnZero()
{
// Create and initialise ArrayStack
ArrayStack stack = new ArrayStack(2);
// Push elements
stack.Push("Test");
stack.Push("Test");
stack.Pop();
stack.Pop();
int expected = 0;
int actual = stack.Count();
Assert.AreEqual(expected, actual);
}
public void Push_StackOverflow_ThrowsExcepton()
{
IStack <int> stack = new ArrayStack <int>(5);
stack.Push(7);
stack.Push(5);
stack.Push(4);
stack.Push(1);
stack.Push(2);
Assert.Throws <InvalidOperationException>(() =>
{
stack.Push(0);
});
}
public void PushPopTwoElement()
{
ArrayStack <int> arrayStack = new ArrayStack <int>();
Assert.IsTrue(arrayStack.Count == 0);
arrayStack.Push(1);
arrayStack.Push(2);
Assert.IsTrue(arrayStack.Count == 2);
int actual = arrayStack.Pop();
Assert.AreEqual(2, actual);
Assert.IsTrue(arrayStack.Count == 1);
actual = arrayStack.Pop();
Assert.AreEqual(1, actual);
Assert.IsTrue(arrayStack.Count == 0);
}
public void TestPushPopElementAndCount_ShouldChangeCountAndElementMustBeTheSameAfterPop()
{
var numberToPush = 5;
var stack = new ArrayStack <int>();
Assert.AreEqual(0, stack.Count);
stack.Push(numberToPush);
Assert.AreEqual(1, stack.Count);
var popedNumber = stack.Pop();
Assert.AreEqual(0, stack.Count);
Assert.AreEqual(numberToPush, popedNumber);
}
public void PushPopElements()
{
ArrayStack <string> testStack = new ArrayStack <string>();
for (int i = 0; i < 1000; i++)
{
Assert.AreEqual(i, testStack.Count);
testStack.Push("test");
}
for (int i = 1000; i >= 1; i--)
{
Assert.AreEqual(i, testStack.Count);
testStack.Pop();
}
Assert.AreEqual(0, testStack.Count);
}
public void TestStackWithInitialCapacityOfOne()
{
int numberOne = 1;
int numberTwo = 2;
var stack = new ArrayStack <int>(1);
Assert.AreEqual(0, stack.Count);
stack.Push(numberOne);
Assert.AreEqual(1, stack.Count);
stack.Push(numberTwo);
Assert.AreEqual(2, stack.Count);
Assert.AreEqual(numberTwo, stack.Pop());
Assert.AreEqual(1, stack.Count);
Assert.AreEqual(numberOne, stack.Pop());
Assert.AreEqual(0, stack.Count);
}
public void Push_Pop_1000_Elements()
{
var testArrayStack = new ArrayStack <string>();
Assert.AreEqual(0, testArrayStack.Count, "Initial count of ArrayStack is not 0.");
for (int iter = 1; iter <= 1000; iter++)
{
testArrayStack.Push(iter + "");
Assert.AreEqual(iter, testArrayStack.Count, "Count is not equal at iteration: " + iter);
}
string lastElement = testArrayStack.Pop();
Assert.AreEqual("1000", lastElement, "Last popped element is not correct.");
}
static void Main(string[] args)
{
ArrayStack <int> arr = new ArrayStack <int>();
arr.Push(1);
arr.Push(5);
arr.Push(6);
Console.WriteLine(arr.Count);
//arr.Pop();
foreach (var i in arr.ToArray())
{
Console.WriteLine(i);
}
}
public static void Main()
{
var stack = new ArrayStack <int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
stack.Push(4);
stack.Push(5);
stack.Push(6);
while (stack.Count != 0)
{
Console.WriteLine(stack.Pop());
}
}
public void TestPopPush_ShouldReturn_CorrectCount()
{
//Arrange
int number = 1;
var stack = new ArrayStack <int>();
//Act
Assert.AreEqual(0, stack.Count);
stack.Push(number);
//Assert
Assert.AreEqual(1, stack.Count);
int expected = stack.Pop();
Assert.AreEqual(expected, number);
Assert.AreEqual(0, stack.Count);
}
public void IsEmpty_PopFullyStackArray_ReturnTrue()
{
// Create and initialise ArrayStack
ArrayStack stack = new ArrayStack(2);
stack.Push("Test");
stack.Push("Test");
stack.Pop();
stack.Pop();
bool expected = true;
bool actual = stack.IsEmpty();
Assert.AreEqual(expected, actual);
}
public void Push_Throw_InvalidOperationException_When_Stack_Full()
{
var stack = new ArrayStack <int>(5);
stack.Push(2);
stack.Push(4);
stack.Push(6);
stack.Push(8);
stack.Push(10);
Exception ex = Assert.Throws <InvalidOperationException>(() => stack.Push(11));
Assert.IsType <InvalidOperationException>(ex);
PrintStackArray(stack);
}
static void Main(string[] args)
{
var easyStack = new EasyStack <int>();
easyStack.Push(1);
easyStack.Push(2);
easyStack.Push(3);
var item = easyStack.Pop();
var item2 = easyStack.Peek();
Console.WriteLine(item);
Console.WriteLine(item2);
Console.ReadLine();
Stack <double> stack = new Stack <double>();
var linkedStack = new LinkedStack <int>();
linkedStack.Push(10);
linkedStack.Push(20);
linkedStack.Push(30);
Console.WriteLine(linkedStack.Peek());
Console.WriteLine(linkedStack.Pop());
Console.WriteLine(linkedStack.Pop());
Console.WriteLine(linkedStack.Peek());
Console.ReadLine();
var arrayStack = new ArrayStack <int>(5);
Console.WriteLine(arrayStack.Count);
arrayStack.Push(100);
Console.WriteLine(arrayStack.Count);
arrayStack.Push(200);
arrayStack.Push(300);
arrayStack.Push(400);
arrayStack.Push(500);
Console.WriteLine(arrayStack.Peek());
Console.WriteLine(arrayStack.Pop());
Console.WriteLine(arrayStack.Pop());
Console.WriteLine(arrayStack.Peek());
Console.ReadLine();
}
public void ToArray_ShouldReturnPushedElements()
{
var stack = new ArrayStack <int>();
stack.Push(10);
stack.Push(15);
stack.Push(11);
int[] expected = { 11, 15, 10 };
var actual = stack.ToArray();
for (int i = 0; i < expected.Length; i++)
{
var expectedElement = expected[i];
var actualAelement = actual[i];
Assert.AreEqual(expectedElement, actualAelement, $"Actual element is not ${expectedElement}");
}
}
public void PoppingAllItemsAndPushingAgain()
{
var stack = new ArrayStack <int>();
int itemCount = 500000;
for (int i = 0; i < itemCount; i++)
{
stack.Push(i);
}
int lastItem = int.MaxValue;
for (int i = 0; i < itemCount; i++)
{
if (lastItem < stack.Pop())
{
Assert.Fail();
}
}
bool countWasZero = stack.Count == 0;
for (int i = 0; i < itemCount; i++)
{
stack.Push(i);
}
int trueCount = 0;
lastItem = int.MaxValue;
foreach (var item in stack)
{
if (lastItem < item)
{
Assert.Fail();
}
lastItem = item;
trueCount++;
}
Assert.IsTrue(stack.Count == itemCount &&
stack.Count == trueCount &&
countWasZero);
}
public void TestPopPush_1000Times_ShouldReturn_CorrectCount()
{
var stack = new ArrayStack <int>();
Assert.AreEqual(0, stack.Count);
for (int i = 0; i < 1000; i++)
{
stack.Push(i);
Assert.AreEqual(i + 1, stack.Count);
}
for (int i = stack.Count - 1; i >= 0; i--)
{
int element = stack.Pop();
Assert.AreEqual(i, element);
Assert.AreEqual(i, stack.Count);
}
}
public void Push500Elements_ToArray_ShouldWorkCorrectly()
{
// Arrange
var array = Enumerable.Range(1, 500).ToArray();
var stack = new ArrayStack <int>();
// Act
for (int i = 0; i < array.Length; i++)
{
stack.Push(array[i]);
}
var arrayFromStack = stack.ToArray();
// Assert
CollectionAssert.AreEqual(array, arrayFromStack);
}
public void TestToArray_ShouldReturn_ElementsInReversedOrderToPushing()
{
int[] arrayChe = new[]
{
69, 420, 666, 1337
};
var stack = new ArrayStack <int>();
stack.Push(1337);
stack.Push(666);
stack.Push(420);
stack.Push(69);
var arrayBe = stack.ToArray();
CollectionAssert.AreEqual(arrayChe, arrayBe);
}
public void CheckIfContainedBeforeAndAfterPopping()
{
var stack = new ArrayStack <int>();
int itemCount = 10000;
for (int i = 0; i < itemCount; i++)
{
if (stack.Contains(i))
{
Assert.Fail();
}
stack.Push(i);
if (!stack.Contains(i))
{
Assert.Fail();
}
}
int lastItem = int.MaxValue;
for (int i = itemCount - 1; i >= 0; i--)
{
var top = stack.Peek();
if (!stack.Contains(i))
{
Assert.Fail();
}
var popped = stack.Pop();
if (popped != top)
{
Assert.Fail();
}
if (lastItem < popped)
{
Assert.Fail();
}
if (stack.Contains(i))
{
Assert.Fail();
}
lastItem = top;
}
Assert.IsTrue(stack.Count == 0);
}
public void ToArrayReturnsProperArray()
{
ArrayStack <int> stack = new ArrayStack <int>();
for (int i = 1; i <= 5; i++)
{
stack.Push(i);
}
int[] stackData = stack.ToArray();
int[] expectedData = new int[] { 5, 4, 3, 2, 1 };
for (int index = 0; index < stackData.Length; index++)
{
Assert.AreEqual(stackData[index], expectedData[index]);
}
}
