[Test] public void testShove()
{
GenericStack <string> stringStack = new GenericStack <string>();
stringStack.Shove("value 1", 0);
Assert.AreEqual(1, stringStack.Count);
Assert.AreEqual("value 1", stringStack.DeepPeek(0));
Assert.AreEqual("value 1", stringStack.Peek(0));
stringStack.Shove("value 4", 0);
Assert.AreEqual(2, stringStack.Count);
Assert.AreEqual("value 1", stringStack.DeepPeek(0));
Assert.AreEqual("value 4", stringStack.Peek(0));
stringStack.Pop();
stringStack.Shove("value 2", 1);
Assert.AreEqual(2, stringStack.Count);
// Assert.AreEqual("value 2", stringStack.DeepPeek(0));
// Assert.AreEqual("value 1", stringStack.DeepPeek(1));
// Assert.AreEqual("[value 1 value 2]", stringStack.ToString());
Assert.AreEqual("value 2", stringStack.DeepPeek(1));
Assert.AreEqual("value 1", stringStack.DeepPeek(0));
Assert.AreEqual(2, stringStack.Count);
stringStack.Shove("value 3", 1);
Assert.AreEqual(3, stringStack.Count);
// Assert.AreEqual("[value 1 value 3 value 2]", stringStack.ToString());
Assert.AreEqual("value 2", stringStack.DeepPeek(2));
Assert.AreEqual("value 3", stringStack.DeepPeek(1));
Assert.AreEqual("value 1", stringStack.DeepPeek(0));
Assert.AreEqual("value 2", stringStack.Peek(0));
Assert.AreEqual("value 3", stringStack.Peek(1));
Assert.AreEqual("value 1", stringStack.Peek(2));
}
public void Peek_AddingAnInteger_ReturnsTheInteger()
{
int numberToAdd1 = 6;
int numberToAdd2 = 5;
_intStack.Push(numberToAdd1);
_intStack.Push(numberToAdd2);
int peekedNumber = _intStack.Peek();
Assert.IsTrue(numberToAdd2 == peekedNumber);
}
[Test] public void testPeek()
{
GenericStack <string> stringStack = new GenericStack <string>();
stringStack.Push("value 1");
stringStack.Push("value 2");
Assert.AreEqual("value 2", stringStack.Peek(0)); // deepest stack
Assert.AreEqual(2, stringStack.Count);
Assert.AreEqual("value 2", stringStack.Top());
Assert.AreEqual("value 1", stringStack.Peek(1));
}
[Test] public void testDup()
{
GenericStack <string> stringStack = new GenericStack <string>();
stringStack.Dup();
Assert.AreEqual(0, stringStack.Count);
stringStack.Push("value 1");
stringStack.Push("value 2");
stringStack.Dup();
Assert.AreEqual(3, stringStack.Count);
Assert.AreEqual("value 2", stringStack.Peek(0));
Assert.AreEqual("value 2", stringStack.Peek(1));
Assert.AreEqual("value 1", stringStack.Peek(2));
}
static void Main(string[] args)
{
GenericStack<int> stack = new GenericStack<int>();
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Peek());
int[] array = new int[] { 1, 3, 5, 6, 7, 8, 9, 11, 13 };
for(int i=0;i<array.Length;i++)
{
stack.Push(array[i]);
}
Console.WriteLine(stack.Pop());
Console.WriteLine(stack.Peek());
Console.WriteLine(stack.Contains(8));
stack.Clear();
Console.WriteLine(stack.Pop());
}
public void TestGenericStackPeek()
{
GenericStack<string> stack = new GenericStack<string>();
stack.Push("1. John");
stack.Push("2. Nicholas");
stack.Push("3. Mary");
stack.Push("4. George");
Assert.AreEqual("4. George", stack.Peek());
}
public void TestGenericStackPeek()
{
GenericStack <string> stack = new GenericStack <string>();
stack.Push("1. John");
stack.Push("2. Nicholas");
stack.Push("3. Mary");
stack.Push("4. George");
Assert.AreEqual("4. George", stack.Peek());
}
public static void Main(string[] args)
{
GenericPair<int, string> pairche = new GenericPair<int, string>(5, "asd");
GenericPair<int, string> pairche2 = new GenericPair<int, string>(5, "asd");
Console.WriteLine("{0} equals {1} : {2}\n", pairche, pairche2, pairche.Equals(pairche2));
GenericStack<int> stackche = new GenericStack<int>();
stackche.Push(1);
stackche.Push(2);
stackche.Push(3);
stackche.Push(4);
Console.WriteLine(stackche.Peek()); // 4
Console.WriteLine(stackche.Pop()); // 4
Console.WriteLine(stackche.Peek()); // 3
Console.WriteLine("The stack contains 2 : {0}", stackche.Contains(2));
Console.WriteLine("The stack contains 7 : {0}", stackche.Contains(7));
stackche.Clear();
Console.WriteLine("Stack was cleared.");
Console.WriteLine("The stack contains 2 : {0}\n", stackche.Contains(2));
//Console.WriteLine(stackche.Peek()); // throws InvalidOperationException;
GenericDequeue<int> dequeueche = new GenericDequeue<int>();
dequeueche.AddToEnd(3); // {3}
dequeueche.AddToEnd(2); // {3, 2}
dequeueche.AddToFront(4); // {4, 3, 2}
dequeueche.AddToEnd(1); // {4, 3, 2, 1}
dequeueche.AddToFront(5); // {5, 4, 3, 2, 1}
Console.WriteLine(dequeueche.PeekFromEnd()); // 1
Console.WriteLine(dequeueche.PeekFromFront()); // 5
Console.WriteLine("Dequeue contains 5: {0}", dequeueche.Contains(5));
dequeueche.RemoveFromEnd(); // {5, 4, 3, 2}
dequeueche.RemoveFromFront(); // {4, 3, 2}
Console.WriteLine("Dequeue contains 5: {0}", dequeueche.Contains(5));
Console.WriteLine(dequeueche.PeekFromEnd()); // 2
Console.WriteLine(dequeueche.PeekFromFront()); // 4
dequeueche.Clear();
//Console.WriteLine(dequeuche.PeekFromEnd()); // throws InvalidOperationException;
}
private static TreeNode GenerateTreeFromPostorder(int[] input)
{
TreeNode temp = null;
TreeNode p = null;
int i = input.Length - 1;
TreeNode root = new TreeNode();
root.Value = input[i--];
if (input.Length == 1)
{
return(root);
}
var stack = new GenericStack <TreeNode>(input.Length);
p = root;
while (i >= 0)
{
if (input[i] < p.Value)
{
temp = new TreeNode();
temp.Value = input[i--];
p.Left = temp;
stack.Push(p);
p = temp;
}
else
{
if (input[i] > p.Value && (stack.IsEmpty() || input[i] < stack.Peek().Value))
{
temp = new TreeNode();
temp.Value = input[i--];
p.Right = temp;
p = temp;
}
else
{
p = stack.Pop();
}
}
}
return(root);
}
static void Main(string[] args)
{
Console.WriteLine("---Generic Stack Test---");
GenericStack<int> stack = new GenericStack<int>(0);
stack.Push(1);
stack.Push(2);
stack.Push(3);
while(!stack.IsEmpty())
{
Console.WriteLine(stack.Contains(2));
Console.WriteLine(stack.Peek());
Console.WriteLine(stack.Pop());
}
Console.WriteLine("---Generic Dequeue Test---");
GenericDequeue<int> dequeue = new GenericDequeue<int>(0);
dequeue.AddToEnd(3);
dequeue.AddToEnd(4);
dequeue.AddToFront(2);
dequeue.AddToFront(1);
while (!dequeue.IsEmpty())
{
Console.WriteLine(dequeue.Contains(3));
Console.WriteLine(dequeue.PeekFromEnd());
Console.WriteLine(dequeue.RemoveFromEnd());
Console.WriteLine(dequeue.Contains(3));
Console.WriteLine(dequeue.PeekFromFront());
Console.WriteLine(dequeue.RemoveFromFront());
}
Console.WriteLine("---Lotto Game Test---");
LottoGame<int, string> lottoGame = new LottoGame<int, string>(new Combination<int, string>(1, 2, 3, "a", "b", "c"));
var comb1 = new Combination<int, string>(5, 7, 9, "we", "asd", "rgd");
var comb2 = new Combination<int, string>(5, 7, 8, "we", "asd", "rgd");
var comb3 = new Combination<int, string>(5, 7, 9, "we", "asd", "rgd");
var comb4 = new Combination<int, string>(1, 7, 9, "we", "asd", "rgd");
var comb5 = new Combination<int, string>(5, 2, 9, "we", "b", "rgd");
if (lottoGame.AddUserCombination(comb1)) Console.WriteLine("Added combination {0}", comb1);
else Console.WriteLine("Combination {0} already exists!", comb1);
if (lottoGame.AddUserCombination(comb2)) Console.WriteLine("Added combination {0}", comb2);
else Console.WriteLine("Combination {0} already exists!", comb2);
if (lottoGame.AddUserCombination(comb3)) Console.WriteLine("Added combination {0}", comb3);
else Console.WriteLine("Combination {0} already exists!", comb3);
if (lottoGame.AddUserCombination(comb4)) Console.WriteLine("Added combination {0}", comb4);
else Console.WriteLine("Combination {0} already exists!", comb4);
if (lottoGame.AddUserCombination(comb5)) Console.WriteLine("Added combination {0}", comb5);
else Console.WriteLine("Combination {0} already exists!", comb5);
Console.WriteLine();
var lottoResult = lottoGame.Validate();
if (lottoResult.IsWinning) Console.WriteLine("This lotto game has a winner with {0} matching values!", lottoResult.MatchedNumbersCount);
else Console.WriteLine("There is no winner in this lotto game!");
Console.ReadKey();
}
public void PeekTest()
{
stack.Push(1);
Assert.AreEqual(1, stack.Peek());
}
