public void TestStack()
{
var stack = new StackArray <int>();
stack.Push(10);
stack.Push(20);
Assert.Equal(2, stack.Count);
Assert.False(stack.IsEmpty);
Assert.Equal(20, stack.Pop());
Assert.Equal(10, stack.Pop());
Assert.True(stack.IsEmpty);
}
public override int Pop()
{
while (!IsEmpty())
{
_stackArray.Push(base.Pop());
}
int ret = _stackArray.Pop();
while (!_stackArray.IsEmpty())
{
Push(_stackArray.Pop());
}
return(ret);
}
public void FullStackArrayTests0()
{
var stackArray = new StackArray <int>(5);
for (var i = 0; i < 5; i++)
{
Assert.True(stackArray.Count == i);
stackArray.Push(i * 2);
}
Assert.True(stackArray.IsFull);
Assert.False(stackArray.IsEmpty);
Assert.Throws <InvalidOperationException>(() => stackArray.Push(10));
Assert.Throws <InvalidOperationException>(() => stackArray.Push(12));
Assert.True(stackArray.Peek() == 8);
Assert.True(stackArray.Pop() == 8);
Assert.True(stackArray.Count == 4);
Assert.True(stackArray.Length == 5);
Assert.False(stackArray.IsFull);
Assert.False(stackArray.IsEmpty);
stackArray.Push(8);
Assert.True(stackArray.Peek() == 8);
Assert.Throws <InvalidOperationException>(() => stackArray.Push(10));
Assert.True(stackArray.IsFull);
Assert.False(stackArray.IsEmpty);
Assert.True(stackArray.Length == 5);
Assert.True(stackArray.Count == 5);
}
[TestMethod] //получение элемента из пустго стека
public void PopEmptyTest()
{
int n = 3;
StackArray<object> data = new StackArray<object>(n);
data.Pop();
}
[TestMethod] //получение элемента из пустго стека
public void PopEmptyTest()
{
int n = 3;
StackArray <object> data = new StackArray <object>(n);
data.Pop();
}
public void EmptyStackExceptionTest()
{
IStack stack = new Stack();
stack.Pop();
stack = new StackArray();
stack.Pop();
}
/// <summary>
/// Pops the most recent element and closes it
/// </summary>
private void PopElementAndClose()
{
var elementName = openElements.Pop();
xml.Append("</");
xml.Append(elementName);
xml.Append('>');
}
public void PushPop()
{
var stack = new StackArray <int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);
stack.Push(4);
stack.Push(5);
Assert.AreEqual("54321", stack.GetValues());
stack.Pop();
Assert.AreEqual("4321", stack.GetValues());
stack.Pop();
Assert.AreEqual("321", stack.GetValues());
}
[TestMethod] //получение последнего элемента
public void PopTest()
{
int n = 3;
StackArray <object> data = new StackArray <object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
data.Pop();
}
[TestMethod] //получение последнего элемента
public void PopTest()
{
int n = 3;
StackArray<object> data = new StackArray<object>(n);
data.Push(8);
data.Push(6);
data.Push(10);
data.Pop();
}
public void ResizeTest()
{
var stack = new StackArray();
for (var i = 0; i < 1000; ++i)
{
stack.Push(i);
}
Assert.AreEqual(999, stack.Pop());
}
[TestMethod] public void Push_Pop_Testing()
{
void Test <T>(T[] values)
{
Towel.Sort.Shuffle(values);
IStack <T> stack = new StackArray <T>();
values.Stepper(x => stack.Push(x));
Array.Reverse(values);
values.Stepper(x => x.Equals(stack.Pop()));
}
public void PeekTest()
{
Stack stack = new StackArray();
stack.Push(5);
var peek = stack.Peek();
Assert.IsNotNull(peek);
Assert.AreEqual(5, peek);
peek = stack.Peek();
Assert.IsNotNull(peek);
Assert.AreEqual(5, peek);
var pop = stack.Pop();
Assert.IsNotNull(pop);
Assert.AreEqual(5, pop);
peek = stack.Peek();
Assert.IsNull(peek);
Assert.IsNull(stack.Pop());
}
public void PopReturnsValue()
{
var stack = new StackArray <int>();
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
for (int i = MAX_SIZE - 1; i > 0; i--)
{
Assert.AreEqual(i, stack.Pop());
}
}
public void StackSizeDecreases()
{
var stack = new StackArray <int>();
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
for (int i = MAX_SIZE; i > 0; i--)
{
stack.Pop();
}
Assert.AreEqual(0, stack.Size());
}
public static int[] CalculateSpan(int[] Input)
{
int len = Input.Length;
int[] Span = new int[len];
//Span[0] = 0;
IStack stk = new StackArray(len);
//stk.Push(0);
for (int i = 0; i < len; i++)
{
if (i == 0)
{
Span[0] = 0;
stk.Push(0);
}
else
{
if (Input[i] < Input[i - 1])
{
Span[i] = 1;
stk.Push(i);
}
else
{
while (!stk.IsEmpty() && Input[stk.Top()] < Input[i])
{
stk.Pop();
}
if (stk.IsEmpty())
{
Span[i] = 0;
stk.Push(i);
}
else
{
Span[i] = i - stk.Top();
stk.Push(i);
}
}
}
}
return(Span);
}
/////////////////////////////////////////////////////////////////////////////
//
//Methods
//
public Bullet Create(Vector3 position)
{
Bullet bullet;
if (!stack.IsEmpty)
{
bullet = stack.Pop();
bullet.gameObject.SetActive(true);
bullet.transform.position = position;
}
else
{
bullet = Instantiate <GameObject>(bulletPrefab, position, Quaternion.identity).GetComponent <Bullet>();
}
return(bullet);
}
public static bool IspisiStekObrnuto <T>(Stack <T> stack)
{
//posto mi vec ToString() ispisuje Top na kraju, sad ce ga ispisati prvog. Ovo nema smisla, jer ne mogu da procitam nista sem TOP na steku, pa moram da obrisem ceo stek i ponovo ga napravim.
StackArray <T> tmp = new StackArray <T>((uint)stack.Size);
int len = stack.Size;
for (int i = 0; i < len; ++i)
{
tmp.Push(stack.Top);
stack.Pop();
}
Console.WriteLine(tmp);
for (int i = 0; i < len; ++i)
{
stack.Push(tmp.Top);
tmp.Pop();
}
return(true);
}
public void FullTest()
{
Stack stack = new StackArray(100);
int testLength = 512;
Random rnd = new Random();
int[] comparisonArray = new int[testLength];
for (int i = 0; i < testLength; i++)
{
int element = rnd.Next(0, 10000000);
comparisonArray[comparisonArray.Length - i - 1] = element;
stack.Push(element);
}
for (int i = 0; i < comparisonArray.Length; i++)
{
Assert.AreEqual(comparisonArray[i], stack.Peek());
Assert.AreEqual(comparisonArray[i], stack.Pop());
}
}
static void Main(string[] args)
{
string inputLine;
StackArray <int> stack = new StackArray <int>();
while ((inputLine = Console.ReadLine()) != "END")
{
string[] data = inputLine.Split(new string[] { " ", ", " }, StringSplitOptions.RemoveEmptyEntries);
switch (data[0])
{
case "Push":
IEnumerable <int> elements = data.Skip(1).Select(int.Parse);
stack.Push(elements);
break;
case "Pop":
try
{
stack.Pop();
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
break;
default:
break;
}
}
printStack(stack);
printStack(stack);
}
public void PushPop()
{
var stack = new StackArray <int>();
try
{
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
for (int i = MAX_SIZE; i > 0; i--)
{
stack.Pop();
}
}
catch (InvalidOperationException)
{
Assert.Fail("Failed to pop all elements.");
}
}
public void StackIsEmpty()
{
var stack = new StackArray <int>();
InvalidOperationException ex = new InvalidOperationException();
try
{
for (int i = 0; i < MAX_SIZE; i++)
{
stack.Push(i);
}
for (int i = 0; i < MAX_SIZE + 1; i++)
{
stack.Pop();
}
}
catch (InvalidOperationException e)
{
ex = e;
}
Assert.AreEqual("The Stack is empty.", ex.Message);
}
public void PopTest()
{
Stack stack = new StackArray(3);
stack.Push(1);
var output = stack.Pop();
Assert.AreEqual(1, output);
output = stack.Pop();
Assert.IsNull(output);
stack.Push(2);
stack.Push(5);
stack.Push(7);
output = stack.Pop();
Assert.AreEqual(7, output);
output = stack.Pop();
Assert.AreEqual(5, output);
output = stack.Pop();
Assert.AreEqual(2, output);
output = stack.Pop();
Assert.IsNull(output);
}
public void PopFromEmptyStack()
{
Assert.Throws <StackIsEmptyException>(() => { stack.Pop(); });
}
public void PopArrayStackTest()
{
stack.Push(1);
Assert.AreEqual(1, stack.Pop(), delta);
}
