using Moyer;
using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace QueueTest
{
///
///This is a test class for QueueTest and is intended
///to contain all QueueTest Unit Tests
///
[TestClass()]
public class QueueTest
{
private TestContext testContextInstance;
///
///Gets or sets the test context which provides
///information about and functionality for the current test run.
///
public TestContext TestContext
{
get
{
return testContextInstance;
}
set
{
testContextInstance = value;
}
}
#region Additional test attributes
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
///
///Initialize a 0 item circular queue.
///
[TestMethod()]
public void initialize0CircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Size, Queue.initialize(ref queue, 0, false));
}
///
///Initialize a 0 item non-circular queue.
///
[TestMethod()]
public void initialize0NonCircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Size, Queue.initialize(ref queue, 0, true));
}
///
///Initialize a 1 item circular queue.
///
[TestMethod()]
public void initialize1CircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 1, false));
}
///
///Initialize a 1 item non-circular queue.
///
[TestMethod()]
public void initialize1NonCircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 1, true));
}
///
///Initialize a 10 item circular queue.
///
[TestMethod()]
public void initialize10CircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 10, false));
}
///
///Initialize a 10 item non-circular queue.
///
[TestMethod()]
public void initialize10NonCircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 10, true));
}
///
///A test for enqueue, circular
///
[TestMethod()]
public void enqueue1CircTest()
{
Queue queue = null;
uint size = 1;
QueueStatus expected = QueueStatus.Success;
QueueStatus actual;
actual = Queue.initialize(ref queue, size, false);
Assert.AreEqual(expected, actual);
actual = queue.enqueue(1);
Assert.AreEqual(expected, actual);
}
///
///A test for enqueue, non-circular
///
[TestMethod()]
public void enqueue1NonCircTest()
{
Queue queue = null;
uint size = 1;
QueueStatus expected = QueueStatus.Success;
QueueStatus actual;
actual = Queue.initialize(ref queue, size, true);
Assert.AreEqual(expected, actual);
actual = queue.enqueue(1);
Assert.AreEqual(expected, actual);
}
///
///Enqueue and dequeue a single value circular.
///
[TestMethod()]
public void dequeue1CircTest()
{
Queue queue = null;
uint size = 1;
int queueOutput = 0;
Queue.initialize(ref queue, size, false);
queue.enqueue(1);
queue.dequeue(ref queueOutput);
Assert.AreEqual(1, queueOutput);
}
///
///Enqueue and dequeue a single value non-circular.
///
[TestMethod()]
public void dequeue1NonCircTest()
{
Queue queue = null;
uint size = 1;
int queueOutput = 0;
Queue.initialize(ref queue, size, true);
queue.enqueue(1);
queue.dequeue(ref queueOutput);
Assert.AreEqual(1, queueOutput);
}
///
///Enqueue and dequeue a 5 values, circular.
///
[TestMethod()]
public void dequeue5CircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 5, false));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(2));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(3));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(4));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(5));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(1, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(2, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(3, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(4, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(5, queueOutput);
}
///
///Enqueue and dequeue a 5 values, non-circular.
///
[TestMethod()]
public void dequeue5NonCircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 5, true));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(2));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(3));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(4));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(5));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(1, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(2, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(3, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(4, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(5, queueOutput);
}
///
///Empty 1 item cicular
///
[TestMethod()]
public void empty1CircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 5, false));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(1, queueOutput);
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
///
///Empty 1 item non-cicular
///
[TestMethod()]
public void empty1NonCircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 5, true));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(1, queueOutput);
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
///
///Fill 1 item circular
///
[TestMethod()]
public void fill1CircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 1, false));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Overrun, queue.enqueue(1));
}
///
///Fill 1 item non-circular
///
[TestMethod()]
public void fill1NonCircTest()
{
Queue queue = null;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 1, true));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Full, queue.enqueue(1));
}
///
///Overflow a 3 item queue with 4 items non-circular and dequeue 4
///
[TestMethod()]
public void overflow3NonCircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 3, true));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(2));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(3));
Assert.AreEqual(QueueStatus.Full, queue.enqueue(4));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(1, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(2, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(3, queueOutput);
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
///
///Overflow a 3 item queue with 4 items circular and dequeue 4
///
[TestMethod()]
public void overflow3CircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 3, false));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(2));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(3));
Assert.AreEqual(QueueStatus.Overrun, queue.enqueue(4));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(2, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(3, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(4, queueOutput);
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
///
///Overflow a queue with some items circular and dequeue 4
///
[TestMethod()]
public void overflowCircTest()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 3, false));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(1));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(2));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(3));
Assert.AreEqual(QueueStatus.Overrun, queue.enqueue(4));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(2, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(3, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(4, queueOutput);
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(5));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(6));
Assert.AreEqual(QueueStatus.Success, queue.enqueue(7));
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(5, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(6, queueOutput);
Assert.AreEqual(QueueStatus.Success, queue.dequeue(ref queueOutput));
Assert.AreEqual(7, queueOutput);
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
///
/// Dequeue on newly initialized and empty non-circular queue.
///
[TestMethod()]
public void dequeueNewInitNonCirc()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 1, true));
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
///
/// Dequeue on newly initialized and empty circular queue.
///
[TestMethod()]
public void dequeueNewInitCirc()
{
Queue queue = null;
int queueOutput = 0;
Assert.AreEqual(QueueStatus.Success, Queue.initialize(ref queue, 1, false));
Assert.AreEqual(QueueStatus.Empty, queue.dequeue(ref queueOutput));
}
}
}