public void CheckCountAfterOnePush_ShouldBeOne()
{
var arrayStack = new ArrayStack<int>();
arrayStack.Push(1);
Assert.AreEqual(1, arrayStack.Count);
}
public void CheckCountAfterOnePop_ShouldBeZero()
{
var arrayStack = new ArrayStack<int>();
arrayStack.Push(1);
arrayStack.Pop();
Assert.AreEqual(0, arrayStack.Count);
}
public void Pop_EmptyStack_ThrowsException()
{
// Arrange
var stack = new ArrayStack<int>();
// Act
stack.Pop();
// Assert: expect and exception
}
private static void TestArrayStack()
{
ArrayStack<int> stack = new ArrayStack<int>();
Console.WriteLine(stack.Count);
stack.Push(1);
Console.WriteLine(stack.Count);
}
public void CheckCountAfterEveryPush_ShouldIncreaseByOne()
{
var arrayStack = new ArrayStack<string>();
for (int i = 0; i < 1000; i++)
{
arrayStack.Push("Element: " + i);
Assert.AreEqual(i + 1, arrayStack.Count);
}
}
public void LastTest()
{
ArrayStack myStack = new ArrayStack();
myStack.Push(8);
Assert.AreEqual(8, myStack.Pop());
myStack.Push(10);
myStack.Push(-12);
Assert.AreEqual(-12, myStack.Pop());
Assert.AreEqual(10, myStack.Pop());
Assert.AreEqual(true, myStack.IsEmpty());
}
public void Push_ShouldAddElement()
{
// Arrange
var stack = new ArrayStack<int>();
// Act
stack.Push(5);
// Assert
Assert.AreEqual(1, stack.Count);
}
public void TestPushPopElement()
{
var stack = new ArrayStack<int>();
Assert.AreEqual(0, stack.Count);
stack.Push(1);
Assert.AreEqual(1, stack.Count);
var item = stack.Pop();
Assert.AreEqual(1, item);
Assert.AreEqual(0, stack.Count);
}
public void PushPop_ShouldWorkCorrectly()
{
// Arrange
var stack = new ArrayStack<string>();
var element = "some value";
// Act
stack.Push(element);
var elementFromStack = stack.Pop();
// Assert
Assert.AreEqual(0, stack.Count);
Assert.AreEqual(element, elementFromStack);
}
public static void Main(string[] args)
{
ArrayStack myStack = new ArrayStack();
myStack.Push(1);
myStack.Push(2);
myStack.Push(3);
if (myStack.IsEmpty())
{
Console.WriteLine("The stack is empty");
}
while (!myStack.IsEmpty())
{
Console.WriteLine("Value in the stack: {0}", myStack.Pop());
}
}
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 CheckInitialCapacity_ShouldReturnCorrectElement()
{
var arrayStack = new ArrayStack<int>(1);
arrayStack.Push(1);
Assert.AreEqual(1, arrayStack.Count);
arrayStack.Push(100);
Assert.AreEqual(2, arrayStack.Count);
arrayStack.Pop();
Assert.AreEqual(1, arrayStack.Count);
int element = arrayStack.Pop();
Assert.AreEqual(1, element);
Assert.AreEqual(0, arrayStack.Count);
}
static void Main(string[] args)
{
ArrayStack<int> numbers = new ArrayStack<int>();
for (int i = 0; i < 30; i++)
{
numbers.Push(i);
}
for (int i = 0; i < 30; i++)
{
Console.WriteLine(numbers.Pop());
}
numbers.Push(2);
Console.WriteLine(numbers.Pop());
}
public void Test1000PushPopElements()
{
ArrayStack<string> stack = new ArrayStack<string>();
Assert.AreEqual(0, stack.Count);
for (int i = 0; i < 1000; i++)
{
stack.Push(i.ToString());
Assert.AreEqual(i + 1, stack.Count);
}
for (int i = 0; i < 1000; i++)
{
var item = stack.Pop();
Assert.AreEqual((1000 - i - 1).ToString(), item);
Assert.AreEqual(1000 - i - 1, stack.Count);
}
}
static void Main(string[] args)
{
// Статична имплементация на стек (FILO or LIFO)
var stack = new ArrayStack <int>();
// Добавяме
var items = Console.ReadLine().Split().Select(int.Parse).ToArray();
foreach (var item in items)
{
stack.Push(item);
}
// Печат
while (stack.Count > 0)
{
Console.Write("{0} ", stack.Pop());
}
}
static void Main(string[] args)
{
ArrayStack <int> stack = new ArrayStack <int>();
int[] items = Console.ReadLine()
.Split()
.Select(int.Parse)
.ToArray();
foreach (var item in items)
{
stack.Push(item);
}
while (stack.Count > 0)
{
Console.Write(stack.Pop() + " ");
}
}
public void TestPushPopWithInitialCapacity()
{
var stack = new ArrayStack<int>(1);
Assert.AreEqual(0, stack.Count);
stack.Push(1);
Assert.AreEqual(1, stack.Count);
stack.Push(-1);
Assert.AreEqual(2, stack.Count);
var item = stack.Pop();
Assert.AreEqual(-1, item);
Assert.AreEqual(1, stack.Count);
item = stack.Pop();
Assert.AreEqual(1, item);
Assert.AreEqual(0, stack.Count);
}
static void Main()
{
// Some basic tests, covered more thoroughly in the unit tests project
var arrayStack = new ArrayStack<int>(4);
arrayStack.Push(1675474);
arrayStack.Push(2);
arrayStack.Push(3);
arrayStack.Push(4);
arrayStack.Push(5);
arrayStack.Push(2);
arrayStack.Push(1);
arrayStack.Push(83);
arrayStack.Push(92);
arrayStack.Push(1520);
Console.WriteLine(arrayStack.Count);
var array = arrayStack.ToArray();
}
public void PushPop1000Elements_ShouldWorkCorrectly()
{
// Arrange
var stack = new ArrayStack<int>();
int numberOfElements = 1000;
// Act
for (int i = 1; i <= numberOfElements; i++)
{
stack.Push(i);
}
// Assert
for (int i = numberOfElements; i > 0; i--)
{
Assert.AreEqual(numberOfElements, stack.Count);
var element = stack.Pop();
Assert.AreEqual(i, element);
Assert.AreEqual(numberOfElements - (numberOfElements - i) - 1, stack.Count);
numberOfElements--;
}
}
public void TestStack_PushAfterCurrentLength_ShouldGrowCapacityTwice()
{
ArrayStack<string> strings = new ArrayStack<string>();
Assert.AreEqual(0, strings.Count);
for (int i = 0; i < 1000; i++)
{
strings.Push(i.ToString());
}
Assert.AreEqual(1000, strings.Count);
for (int i = 0; i < 1000; i++)
{
strings.Push(i.ToString());
}
Assert.AreEqual(2000, strings.Count);
string lastString = strings.Pop();
Assert.AreEqual("999", lastString);
}
public void InitialCapacity1_PushPop20Elements_ShouldWorkCorrectly()
{
// Arrange
int elementsCount = 20;
int initialCapacity = 1;
// Act
var stack = new ArrayStack<int>(initialCapacity);
for (int i = 0; i < elementsCount; i++)
{
stack.Push(i);
}
// Assert
Assert.AreEqual(elementsCount, stack.Count);
for (int i = elementsCount - 1; i >= 0; i--)
{
var elementFromStack = stack.Pop();
Assert.AreEqual(i, elementFromStack);
}
Assert.AreEqual(0, stack.Count);
}
public void InitialStateTest()
{
ArrayStack myStack = new ArrayStack();
}
public void CheckInitialCount_ShouldBeZero()
{
var arrayStack = new ArrayStack<int>();
Assert.AreEqual(0, arrayStack.Count);
}
public void IsEmptyTest()
{
ArrayStack myStack = new ArrayStack();
Assert.AreEqual(true, myStack.IsEmpty());
}
public void CheckCountOnEmptyPop_ShouldThrowException()
{
var arrayStack = new ArrayStack<int>();
arrayStack.Pop();
}
public void PopUpperBorderTest()
{
ArrayStack myStack = new ArrayStack();
myStack.Push(int.MaxValue);
Assert.AreEqual(int.MaxValue, myStack.Pop());
}
public void IsNotEmptyTest()
{
ArrayStack myStack = new ArrayStack();
myStack.Push(8);
Assert.AreEqual(false, myStack.IsEmpty());
}
public void PushTest()
{
ArrayStack myStack = new ArrayStack();
Assert.AreEqual(true, myStack.Push(8));
}
public void TestEmptyStackToArray()
{
var stack = new ArrayStack<DateTime>();
DateTime[] dates = stack.ToArray();
Assert.AreEqual(0, dates.Length);
}
public void NewStack()
{
numbers = new ArrayStack<int>();
}
public void TestToArray()
{
var stack = new ArrayStack<int>();
stack.Push(5);
stack.Push(4);
stack.Push(3);
stack.Push(2);
stack.Push(1);
int[] arrayFromStack = stack.ToArray();
for (int i = 0; i < arrayFromStack.Length; i++)
{
Assert.AreEqual(arrayFromStack[arrayFromStack.Length - 1 - i], stack.Pop());
}
}
public void TestPopFromEmptyString()
{
var stack = new ArrayStack<int>();
stack.Pop();
}
