public void CanDequeueMultipleValues()
{
//Arrange
PseudoQueue testQueue = new PseudoQueue();
string value1 = "1";
string value2 = "2";
string value3 = "3";
string value4 = "4";
string value5 = "5";
//Act
testQueue.Enqueue(value1);
testQueue.Enqueue(value2);
testQueue.Enqueue(value3);
testQueue.Enqueue(value4);
testQueue.Enqueue(value5);
testQueue.Dequeue();
testQueue.Dequeue();
testQueue.Dequeue();
testQueue.Dequeue();
//Assert
Assert.Equal(value5, testQueue.Dequeue());
}
public void Dequeue_removes_node_from_front_of_pseudoQueue()
{
// Arrange
PseudoQueue pQueue = new PseudoQueue();
pQueue.Enqueue(3);
pQueue.Enqueue("four");
pQueue.Enqueue(5);
Assert.Equal(3, pQueue.Length);
// Act
object result = pQueue.Dequeue();
// Assert
Assert.Equal(2, pQueue.Length);
Assert.Equal(3, result);
// Act2
object result2 = pQueue.Dequeue();
// Assert2
Assert.Equal(1, pQueue.Length);
Assert.Equal("four", result2);
// Act3
object result3 = pQueue.Dequeue();
// Assert3
Assert.Equal(0, pQueue.Length);
Assert.Equal(5, result3);
}
public void EnqueueMultipleNumberValueTest()
{
//Arrange
PseudoQueue test = new PseudoQueue();
string answer1 = "1";
string answer2 = "2";
string answer3 = "3";
string answer4 = "4";
string answer5 = "5";
//Act
test.Enqueue(answer1);
test.Enqueue(answer2);
test.Enqueue(answer3);
test.Enqueue(answer4);
test.Enqueue(answer5);
test.Dequeue();
test.Dequeue();
test.Dequeue();
test.Dequeue();
//Assert
Assert.Equal(answer5, test.Dequeue());
}
public void TwoEnqueueNodesPushToTop()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(0);
test.Enqueue(1);
Assert.Equal(1, test.PQueue.Top.Value);
}
public void IDoFirstInFirstOut()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(6);
test.Enqueue(7);
Assert.Equal(6, test.Dequeue());
}
public void EnqueueIntoQueueShowConnection()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue(10);
queue.Enqueue(5);
Assert.True(queue.load.top.Value == 5);
}
public void CanEnqueueMultipleNodes()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(5);
test.Enqueue(3);
test.Enqueue(2);
Assert.True(test.Dequeue() == 5 && test.Dequeue() == 3);
}
public void IDoNotDoFirstInLastOut()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(6);
test.Enqueue(7);
Assert.NotEqual(7, test.Dequeue());
}
public void CheckSuccessfulDequeue()
{
PseudoQueue <int> pseudoQueue = new PseudoQueue <int>();
pseudoQueue.Enqueue(1);
pseudoQueue.Enqueue(2);
Node <int> node = pseudoQueue.Dequeue();
Assert.True(node.Value == 1);
}
public void EnqueueTwo()
{
Node nodeOne = new Node(11);
Node nodeTwo = new Node(22);
PseudoQueue testTwo = new PseudoQueue();
testTwo.Enqueue(nodeTwo);
Assert.Equal(nodeTwo, testTwo.Enqueue(nodeTwo));
}
public void CanPseudoDequeueOneTest()
{
PseudoQueue <int> pseudo1 = new PseudoQueue <int>();
pseudo1.Enqueue(3);
pseudo1.Enqueue(5);
pseudo1.Enqueue(8);
Assert.Equal(3, pseudo1.Dequeue());
}
public void PseudoEnqueueMultipleValuesTest()
{
PseudoQueue <int> pseudo1 = new PseudoQueue <int>();
pseudo1.Enqueue(3);
pseudo1.Enqueue(5);
pseudo1.Enqueue(8);
Assert.Equal(3, pseudo1.Peek());
}
public void CanEnqueueMultiple()
{
PseudoQueue pq = new PseudoQueue();
pq.Enqueue(1);
pq.Enqueue(2);
string testString = pq.ToString();
Assert.Equal("Top -> 1 -> 2 -> null", testString);
}
public void DequeueIntoEmptyQueue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue(10);
queue.Enqueue(5);
Assert.True(queue.Dequeue().Value == 10);
Assert.True(queue.Dequeue().Value == 5);
}
public void CanEnqueueMultipleValues()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue("nicco");
queue.Enqueue("ryan");
queue.Enqueue("software");
queue.Enqueue("dev");
Assert.Equal("nicco", queue.Front.Value);
}
public void CheckMultipleSuccessfulEnqueues()
{
PseudoQueue <int> pseudoQueue = new PseudoQueue <int>();
pseudoQueue.Enqueue(1);
pseudoQueue.Enqueue(2);
pseudoQueue.Enqueue(3);
pseudoQueue.Enqueue(4);
Assert.True(pseudoQueue.Stack.Top.Value == 4);
}
public void CanDequeueUntilEmpty()
{
PseudoQueue pq = new PseudoQueue();
pq.Enqueue(1);
pq.Enqueue(2);
pq.Dequeue();
pq.Dequeue();
string testString = pq.ToString();
Assert.Equal("Top -> null", testString);
}
public void DesqueueOne()
{
Node nodeOne = new Node(11);
Node nodeTwo = new Node(22);
Node nodeThree = new Node(33);
PseudoQueue testOne = new PseudoQueue();
testOne.Enqueue(nodeOne);
testOne.Enqueue(nodeTwo);
testOne.Enqueue(nodeThree);
Assert.Equal(nodeOne, testOne.Desqueue());
}
public void DequeueReturnsFrontNode()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(22); // front <---result
test.Enqueue(33);
test.Enqueue(44);
test.Enqueue(55); // rear
int result = test.Dequeue();
Assert.Equal(22, result);
}
public void EnqueueThree()
{
Node nodeOne = new Node(11);
Node nodeTwo = new Node(22);
Node nodeThree = new Node(33);
Node nodeFour = new Node(44);
PseudoQueue testThree = new PseudoQueue();
testThree.Enqueue(nodeOne);
testThree.Enqueue(nodeTwo);
testThree.Enqueue(nodeThree);
Assert.Equal(nodeFour, testThree.Enqueue(nodeFour));
}
public void CanEnqueueWithMethod()
{
// arrange
PseudoQueue <int> que = new PseudoQueue <int>();
// act
que.Enqueue(5);
que.Enqueue(10);
que.Enqueue(15);
int expected = 15;
// assert
Assert.Equal(expected, que.Peek());
}
public void EnqueueSecondNodeTest()
{
//arrange- instantiate new stack
Stack StackOne = new Stack();
//instantiate psuedoqueue object
PseudoQueue pseudoQueue = new PseudoQueue();
//act- input the value 15 as new top on stack one
pseudoQueue.Enqueue(StackOne, 10);
pseudoQueue.Enqueue(StackOne, 15);
//assert- new top simulates enqueue via rear
Assert.Equal(15, StackOne.Top.Value);
}
public void DoubleDequeue()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(22); // front
test.Enqueue(33); // <----result
test.Enqueue(44);
test.Enqueue(55); // rear
test.Dequeue();
int result = test.Dequeue();
Assert.Equal(33, result);
}
public void CheckEmptyAfterMultipleEnqueuesDequeues()
{
PseudoQueue <int> pseudoQueue = new PseudoQueue <int>();
pseudoQueue.Enqueue(1);
pseudoQueue.Enqueue(2);
pseudoQueue.Enqueue(3);
pseudoQueue.Enqueue(4);
pseudoQueue.Dequeue();
pseudoQueue.Dequeue();
pseudoQueue.Dequeue();
pseudoQueue.Dequeue();
Assert.True(pseudoQueue.Stack.IsEmpty());
}
public void EnqueueAndDequeueWork()
{
// Assign
PseudoQueue pseudo = new PseudoQueue();
// Act
pseudo.Enqueue(10);
pseudo.Enqueue(15);
pseudo.Enqueue(25);
int expected = 10;
int actual = pseudo.Dequeue();
// Assert
Assert.Equal(expected, actual);
}
public void TestCanEnqueueMultipleValuesToRearOfQueue()
{
//Arrange
PseudoQueue testQueue = new PseudoQueue();
//Act
testQueue.Enqueue(42);
testQueue.Enqueue(43);
testQueue.Enqueue(44);
testQueue.Enqueue(45);
int expectedValue = 45;
//Assert
Assert.Equal(expectedValue, testQueue.Front.Next.Next.Next.Value);
}
public void DequeuePutsBackOriginalOrder()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(22);
test.Enqueue(33);
test.Enqueue(44);
test.Enqueue(55);
test.Dequeue();
Assert.Equal(33, test.PQueue.Top.Next.Next.Value); // front
Assert.Equal(44, test.PQueue.Top.Next.Value);
Assert.Equal(55, test.PQueue.Top.Value); // rear
}
public void TestCanDequeueFromFrontOfQueue()
{
//Arrange
PseudoQueue testQueue = new PseudoQueue();
testQueue.Enqueue(50);
testQueue.Enqueue(51);
//Act
Node dequeuedNode = testQueue.Dequeue();
int expectedValue = 50;
//Assert
Assert.Equal(expectedValue, dequeuedNode.Value); //Checking the value of the node that was removed.
}
public void CanDequeueFromPseudoQueue()
{
// arrange
PseudoQueue <string> myStack = new PseudoQueue <string>();
myStack.Enqueue("Dog");
myStack.Enqueue("Cat");
myStack.Enqueue("Mouse");
myStack.Enqueue("Bear");
// act
string returnedValue = myStack.Dequeue();
// assert
Assert.Equal("Dog", returnedValue);
}
public void CanEnqueueValue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue("nicco");
Assert.Equal("nicco", queue.Front.Value);
}