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 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 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 CanDequeueThenEnqueueThenDequeue()
{
//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();
string value6 = "6";
string value7 = "7";
testQueue.Enqueue(value6);
testQueue.Enqueue(value7);
//Assert
Assert.Equal(value4, testQueue.Dequeue());
}
public void AlternatingEnqueueDequeueNumberValueTest()
{
//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();
string answer6 = "6";
string answer7 = "7";
test.Enqueue(answer6);
test.Enqueue(answer7);
//Assert
Assert.Equal(answer4, test.Dequeue());
}
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 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 TestIfDequeueDoesNotGiveLastValueAdded()
{
testQueue.Enqueue(1);
testQueue.Enqueue(4);
testQueue.Enqueue(12);
testQueue.Enqueue(15);
testQueue.Enqueue(44);
testQueue.Enqueue(9);
Assert.NotEqual(9, testQueue.Dequeue());
}
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 CanDequeueMultiple()
{
PseudoQueue pq = new PseudoQueue();
pq.Enqueue(1);
pq.Enqueue(2);
pq.Enqueue(3);
pq.Dequeue();
pq.Dequeue();
string testString = pq.ToString();
Assert.Equal("Top -> 3 -> null", testString);
}
public void DequeuesLILO()
{
PseudoQueue pQ = new PseudoQueue();
Stack stack = new Stack();
stack.Push(new Node(1));
stack.Push(new Node(2));
stack.Push(new Node(3));
pQ.In = stack;
pQ.Dequeue();
pQ.Dequeue();
Assert.Equal(3, pQ.Dequeue().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 CheckMultipleSuccessfulDequeues()
{
PseudoQueue <int> pseudoQueue = new PseudoQueue <int>();
pseudoQueue.Enqueue(1);
pseudoQueue.Enqueue(2);
pseudoQueue.Enqueue(3);
pseudoQueue.Enqueue(4);
pseudoQueue.Dequeue();
pseudoQueue.Dequeue();
Node <int> node = pseudoQueue.Dequeue();
Assert.True(node.Value == 3);
}
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 CanThrowExceptionOnEmptyDequeue()
{
PseudoQueue queue = new PseudoQueue();
var result = Assert.Throws <Exception>(() => queue.Dequeue());
Assert.Equal("Empty pseudoqueue", result.Message);
}
public void NullDequeue()
{
PseudoQueue pq = new PseudoQueue();
var x = pq.Dequeue();
Assert.Null(x);
}
public void DequeueThrowExceptionTest()
{
//Arrange
PseudoQueue test = new PseudoQueue();
//Assert
Assert.Throws <NullReferenceException>(() => test.Dequeue());
}
public void CanEmptyQueue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue("nicco");
queue.Enqueue("ryan");
queue.Enqueue("dev");
string result1 = queue.Dequeue();
queue.Dequeue();
string result3 = queue.Dequeue();
Assert.Equal("nicco", result1);
Assert.Equal("dev", result3);
Assert.Null(queue.Front);
}
public void CanEnqueueAndDequeueMultipleItems()
{
// Assign
PseudoQueue pseudo = new PseudoQueue();
// Act
pseudo.Enqueue(10);
pseudo.Enqueue(15);
pseudo.Enqueue(25);
pseudo.Dequeue();
pseudo.Dequeue();
int expected = 25;
int actual = pseudo.Dequeue();
// Assert
Assert.Equal(expected, actual);
}
public void EnqueueAndDequeueWorksEdgeCase()
{
PseudoQueue testQueue = new PseudoQueue();
testQueue.Enqueue(5);
Assert.Equal(5, testQueue.Dequeue());
}
public void CanEnqueueToEmptyQueue()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(5);
Assert.Equal(5, test.Dequeue());
}
public void DequeuingAnEmptyQueueThrowsException()
{
//Arrange
PseudoQueue testQueue = new PseudoQueue();
//Assert
Assert.Throws <NullReferenceException>(() => testQueue.Dequeue());
}
public void CanDequeueValue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue("nicco");
string result = queue.Dequeue();
Assert.Equal("nicco", result);
}
public void Dequeue()
{
PseudoQueue pq = new PseudoQueue();
pq.Enqueue(50);
pq.Dequeue();
Assert.Null(pq.DeQueue.top);
Assert.Null(pq.EnQueue.top);
}
public void CanDequeueFromAPseudoQueueTwice()
{
PseudoQueue <int> que = new PseudoQueue <int>();
// act
que.Enqueue(5);
que.Enqueue(10);
que.Enqueue(15);
que.Enqueue(20);
int expected = 10;
que.Dequeue();
int returnFromMethod = que.Dequeue();
// assert
Assert.Equal(expected, returnFromMethod);
}
public void IDoNotDoFirstInLastOut()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(6);
test.Enqueue(7);
Assert.NotEqual(7, test.Dequeue());
}
public void DequeueEmptyStackThrowsTest()
{
PseudoQueue <object> pseudo1 = new PseudoQueue <object>();
Assert.Throws <Exception>(() =>
{
pseudo1.Dequeue();
});
}
public void DequeueSingleNodeStackToNull()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(9999);
Assert.Equal(9999, test.Dequeue());
Assert.Null(test.PQueue.Top);
}
public void IDoFirstInFirstOut()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(6);
test.Enqueue(7);
Assert.Equal(6, test.Dequeue());
}
public void TestDequeue()
{
PseudoQueue <string> queue = new PseudoQueue <string>();
queue.Enqueue("Test");
Assert.Equal("Test", queue.Dequeue().Data);
Assert.Null(queue.Front.Top);
Assert.Null(queue.Back.Top);
}