public Field(int width, int height, int cellLength, Texture2D cell, int offset, int interval, GameOfLife main)
{
this.width = width;
this.height = height;
this.cellLength = cellLength;
this.offset = offset;
this.main = main;
changedCells = new Queue<Cell>();
pq = new PseudoQueue<Cell>();
WidthInCells = width;
HeightInCells = height;
Interval = interval;
Bounds = new Rectangle(offset, offset, width * cellLength, height * cellLength);
CellTexture = cell;
field = new Cell[width,height];
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
field[i, j] = new Cell(i * cellLength + offset, j * cellLength + offset, cellLength);
}
}
}
public void NullDequeue()
{
PseudoQueue pq = new PseudoQueue();
var x = pq.Dequeue();
Assert.Null(x);
}
public void TestEmptyQueue()
{
PseudoQueue <string> queue = new PseudoQueue <string>();
Assert.Null(queue.Front.Top);
Assert.Null(queue.Back.Top);
}
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 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 QueueWithStackEmptyEnqueueAndDequeueTest()
{
PseudoQueue <int> newPseudoQueue = new PseudoQueue <int>();
newPseudoQueue.enqueue(1);
Assert.Equal(1, newPseudoQueue.dequeue());
}
public void PeekNull()
{
PseudoQueue pQ = new PseudoQueue();
Queue trueQ = new Queue();
Assert.Equal(trueQ.Peek(), pQ.Peek());
}
public void Enqueue()
{
PseudoQueue pq = new PseudoQueue();
pq.Enqueue(100);
Assert.Equal(100, pq.EnQueue.top.data);
}
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 DequeueOnOneNodeStack()
{
PseudoQueue psuedo = new PseudoQueue();
psuedo.Enqueue1(10);
Assert.Equal(10, psuedo.Dequeue1().Value);
}
public void CanEnqueueValue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue("nicco");
Assert.Equal("nicco", queue.Front.Value);
}
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 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 EnqueueNodesPushToTop()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(0);
Assert.Equal(0, test.PQueue.Top.Value);
}
public void CanThrowExceptionOnEmptyDequeue()
{
PseudoQueue queue = new PseudoQueue();
var result = Assert.Throws <Exception>(() => queue.Dequeue());
Assert.Equal("Empty pseudoqueue", result.Message);
}
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 EnqueuePseudoWithNegativeNode()
{
/// Testing input of negative integer
PseudoQueue psuedo = new PseudoQueue();
psuedo.Enqueue1(-10);
Assert.Equal(-10, psuedo.Primary.Top.Value);
}
public void EnqueuePseudoOnEmptyStack()
{
///Testing that enqueue works on empty stack
PseudoQueue psuedo = new PseudoQueue();
psuedo.Enqueue1(10);
Assert.Equal(10, psuedo.Primary.Top.Value);
}
public void CheckSuccessfulEnqueue()
{
PseudoQueue <int> pseudoQueue = new PseudoQueue <int>();
pseudoQueue.Enqueue(1);
Assert.True(pseudoQueue.Stack.Top.Value == 1);
}
public void TestPeekQueue()
{
PseudoQueue <string> queue = new PseudoQueue <string>();
queue.Enqueue("Test");
Assert.Equal("Test", queue.Peek().Data);
Assert.NotNull(queue.Front.Top);
}
public void EnqueueAndDequeueWorksEdgeCase()
{
PseudoQueue testQueue = new PseudoQueue();
testQueue.Enqueue(5);
Assert.Equal(5, testQueue.Dequeue());
}
public void IsEmpty_True_False()
{
PseudoQueue <int> q = new PseudoQueue <int>();
Assert.True(q.isEmpty());
q.EnQueue(1);
Assert.False(q.isEmpty());
}
public void EnqueueOne()
{
Node nodeOne = new Node(11);
PseudoQueue testOne = new PseudoQueue();
Assert.Equal(nodeOne, testOne.Enqueue(nodeOne));
}
public void EnqueueIntoEmptyQueue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue(10);
Assert.True(queue.load.top.Value == 10);
}
public void CanEnqueueTest()
{
PseudoQueue <int> pseudo1 = new PseudoQueue <int>();
pseudo1.Enqueue(5);
Assert.Equal(5, pseudo1.Peek());
}
public void DequeueThrowExceptionTest()
{
//Arrange
PseudoQueue test = new PseudoQueue();
//Assert
Assert.Throws <NullReferenceException>(() => test.Dequeue());
}
public void EnQsNull()
{
PseudoQueue pQ = new PseudoQueue();
Queue trueQ = new Queue();
trueQ.Enqueue(new Node(1));
pQ.Enqueue(new Node(1));
Assert.Equal(trueQ.Peek().Value, pQ.Peek().Value);
}
public void DequeueSingleNodeStackToNull()
{
PseudoQueue test = new PseudoQueue();
test.Enqueue(9999);
Assert.Equal(9999, test.Dequeue());
Assert.Null(test.PQueue.Top);
}
public void CanDequeueValue()
{
PseudoQueue queue = new PseudoQueue();
queue.Enqueue("nicco");
string result = queue.Dequeue();
Assert.Equal("nicco", result);
}
public void TestEnQWorks()
{
PseudoQueue newPseudoQ = new PseudoQueue();
newPseudoQ.PseudoQueueEnqueue(5);
Node answerNode = newPseudoQ.PseudeoPeek();
Assert.Equal(5, answerNode.Value);
}
