public void EnqueueMethod_RefferenceTypes_Enqueued()
{
string[] array = new string[] { "hello", "this", "is", "just", "a", "test" };
QueueGeneric <string> queue = new QueueGeneric <string>(array);
Assert.AreEqual(queue.Count, array.Length);
}
/// <summary>
/// Creation of the enumerator.
/// </summary>
/// <param name="queue"><see cref="QueueGeneric{T}"/>.</param>
public Enumerator(QueueGeneric <T> queue)
{
_queue = queue;
_version = queue._version;
_index = -1;
_currentElement = default(T);
}
public void EnqueueMethod_ValueTypes_Enqueued()
{
QueueGeneric <int> queue = new QueueGeneric <int>();
queue.Enqueue(1);
queue.Enqueue(2);
Assert.AreEqual(queue.Count, 2);
}
public void PeekMethod_PeekFromQueueWithTwoElements_ShowLastElementFromQueue()
{
PersonInfo[] array = new PersonInfo[]
{
new PersonInfo {
Name = "Jonh", Surname = "Newman"
},
new PersonInfo {
Name = "Olly", Surname = "Murs"
}
};
QueueGeneric <PersonInfo> queue = new QueueGeneric <PersonInfo>(array);
PersonInfo peekHuman = queue.Peek();
Assert.AreEqual(peekHuman.Name, array[array.Length - 1].Name);
}
public void DequeueMethod_DequeueFromQueueWithTwoElements_TakeFirstElementFromQueue()
{
PersonInfo[] array = new PersonInfo[]
{
new PersonInfo {
Name = "Jonh", Surname = "Newman"
},
new PersonInfo {
Name = "Olly", Surname = "Murs"
}
};
QueueGeneric <PersonInfo> queue = new QueueGeneric <PersonInfo>(array);
PersonInfo human = queue.Dequeue();
Assert.AreEqual(human.Name, array[0].Name);
}
public void ContainsMethod_QueueWithTwoPersonInfo_ElementIsNotFoundByValues()
{
PersonInfo[] array = new PersonInfo[]
{
new PersonInfo {
Name = "Jonh", Surname = "Newman"
},
new PersonInfo {
Name = "Olly", Surname = "Murs"
}
};
QueueGeneric <PersonInfo> queue = new QueueGeneric <PersonInfo>(array);
Assert.IsFalse(queue.Contains(new PersonInfo {
Name = "Jonh", Surname = "Newman"
}));
}
public void ContainsMethod_QueueWithTwoPersonInfoObjectEquals_ElementIsFoundByOverrideObjectEquals()
{
PersonInfoObjectEquals[] array = new PersonInfoObjectEquals[]
{
new PersonInfoObjectEquals {
Name = "Alexander", Surname = "Turchin"
},
new PersonInfoObjectEquals {
Name = "Site", Surname = "Github"
}
};
QueueGeneric <PersonInfoObjectEquals> queue = new QueueGeneric <PersonInfoObjectEquals>(array);
Assert.IsTrue(queue.Contains(array[1]));
Assert.IsTrue(queue.Contains(new PersonInfoObjectEquals {
Name = "Site", Surname = "Github"
}));
}
public void ContainsMethod_QueueWithTwoPersonInfoEquatable_ElementIsFoundByIEquatableEquals()
{
PersonInfoEquatable[] array = new PersonInfoEquatable[]
{
new PersonInfoEquatable {
Name = "Jonh", Surname = "Newman"
},
new PersonInfoEquatable {
Name = "Olly", Surname = "Murs"
}
};
QueueGeneric <PersonInfoEquatable> queue = new QueueGeneric <PersonInfoEquatable>(array);
Assert.IsTrue(queue.Contains(array[0]));
Assert.IsTrue(queue.Contains(new PersonInfoEquatable {
Name = "Jonh", Surname = "Newman"
}));
}
public void DequeueMethod_DequeueFromQueueWithTwoElements_QueueWithOneElement()
{
PersonInfo[] array = new PersonInfo[]
{
new PersonInfo {
Name = "Jonh", Surname = "Newman"
},
new PersonInfo {
Name = "Olly", Surname = "Murs"
}
};
QueueGeneric <PersonInfo> queue = new QueueGeneric <PersonInfo>(array);
Assert.AreEqual(queue.Count, 2);
queue.Dequeue();
Assert.AreEqual(queue.Count, 1);
}
/// <summary>
/// A breadth first search traversal of the graph, starting from a specified vertex.
/// Returns the visited vertices of the graph.
/// </summary>
public virtual IEnumerable <T> BreadthFirstWalk(T source)
{
// Check for existence of source
if (VerticesCount == 0)
{
return(new ArrayListGeneric <T>(0));
}
else if (!HasVertex(source))
{
throw new KeyNotFoundException("The source vertex doesn't exist.");
}
var visited = new HashSet <T>();
var queue = new QueueGeneric <T>();
var listOfNodes = new ArrayListGeneric <T>(VerticesCount);
listOfNodes.Add(source);
visited.Add(source);
queue.Enqueue(source);
while (!queue.IsEmpty)
{
var current = queue.Dequeue();
var neighbors = Neighbours(current);
foreach (var adjacent in neighbors)
{
if (!visited.Contains(adjacent))
{
listOfNodes.Add(adjacent);
visited.Add(adjacent);
queue.Enqueue(adjacent);
}
}
}
return(listOfNodes);
}
public void QueueTests()
{
bool hasException = false;
object peekObject = new object();
object dequObject = new object();
QueueGeneric <int?> queue1 = new QueueGeneric <int?>();
QueueComparable <int> queue2 = new QueueComparable <int>();
QueueComparable <string> queue3 = new QueueComparable <string>();
DoubleStackQueue <string> queue4 = new DoubleStackQueue <string>();
#region QueueTest :: empty Queue<non-nullable>
try
{
peekObject = queue2.Peek(); // peek an empty queue
}
catch (QueueOperationException e)
{
hasException = true;
Assert.IsNotNull(e.Message);
}
finally
{
Assert.IsNotNull(peekObject);
Assert.IsTrue(hasException);
}
hasException = false;
try
{
dequObject = queue2.Dequeue(); // operate on empty queue
}
catch (QueueOperationException e)
{
hasException = true;
Assert.IsNotNull(e.Message);
}
finally
{
Assert.IsNotNull(dequObject);
Assert.IsTrue(hasException);
}
#endregion
#region QueueTest :: empty Queue<nullable>
hasException = false;
try
{
peekObject = queue1.Peek();
}
catch (QueueOperationException e)
{
hasException = true;
Assert.IsNotNull(e.Message); //should never come here
}
finally
{
Assert.IsFalse(hasException);
Assert.IsNull(peekObject);
}
hasException = false;
try
{
var test1 = "Queue3.test1";
queue3.Enqueue(test1);
peekObject = queue3.Peek();
dequObject = queue3.Dequeue();
Assert.IsTrue(dequObject.Equals(peekObject));
Assert.IsTrue(dequObject.Equals(test1));
Assert.IsNotNull(dequObject);
dequObject = queue3.Dequeue();
}
catch (QueueOperationException e)
{
hasException = true;
Assert.IsNotNull(e.Message); //should never come here
}
finally
{
Assert.IsFalse(hasException);
Assert.IsNull(dequObject);
}
hasException = false;
try
{
peekObject = queue3.Peek();
}
catch (QueueOperationException e)
{
hasException = true;
Assert.IsNotNull(e.Message); //should never come here
}
finally
{
Assert.IsFalse(hasException);
Assert.IsNull(peekObject);
}
#endregion
#region QueueTest :: Get the minimum in the Queue
var test3_1 = "";
var test3_2 = "ABCD";
var test3_3 = "abcd";
var test3_4 = "xyz...12345";
var test3_5 = "5555";
queue3.Enqueue(test3_1);
queue4.Enqueue(test3_1);
Assert.AreEqual(queue4.First, queue3.First);
Assert.AreEqual(queue4.Last, queue3.Last);
Assert.IsTrue(test3_1.Equals(queue3.GetMinimum()));
Assert.IsTrue(test3_1.Equals(queue3.Minimum));
queue3.Enqueue(test3_2);
queue4.Enqueue(test3_2);
Assert.AreEqual(queue4.First, queue3.First);
Assert.AreEqual(queue4.Last, queue3.Last);
Assert.IsTrue(test3_1.Equals(queue3.GetMinimum()));
Assert.IsTrue(test3_1.Equals(queue3.Minimum));
queue3.Enqueue(test3_3);
queue4.Enqueue(test3_3);
Assert.AreEqual(queue4.First, queue3.First);
Assert.AreEqual(queue4.Last, queue3.Last);
Assert.IsTrue(test3_1.Equals(queue3.GetMinimum()));
Assert.IsTrue(test3_1.Equals(queue3.Minimum));
queue3.Dequeue();
queue4.Dequeue();
Assert.AreEqual(queue4.Peek(), queue3.Peek());
queue3.Enqueue(test3_4);
queue4.Enqueue(test3_4);
Assert.AreEqual(queue4.First, queue3.First);
Assert.AreEqual(queue4.Last, queue3.Last);
Assert.IsTrue(test3_3.Equals(queue3.GetMinimum()));
Assert.IsTrue(test3_3.Equals(queue3.Minimum));
queue3.Enqueue(test3_5);
queue4.Enqueue(test3_5);
Assert.AreEqual(queue4.First, queue3.First);
Assert.AreEqual(queue4.Last, queue3.Last);
Assert.IsTrue(test3_5.Equals(queue3.GetMinimum()));
Assert.IsTrue(test3_5.Equals(queue3.Minimum));
string q3string = queue3.ToString();
string q4string = queue4.ToString();
Assert.AreEqual(q3string, q4string);
#endregion
#region QueueTest ::
#endregion
}
static void Main(string[] args)
{
Queue<Currencies> myqueue = new Queue<int>();
int selection;
do
{
Console.WriteLine("1) EnQueue");
Console.WriteLine("2) Peek");
Console.WriteLine("3) DeQueue");
Console.WriteLine("4) Print");
Console.WriteLine("5) Search");
Console.WriteLine("6) Exit");
Console.WriteLine("What do you want to do?");
selection = int.Parse(Console.ReadLine());
if (selection == 1)
{
Console.WriteLine("What number do you want to add to your queue?");
int pushadd = int.Parse(Console.ReadLine());
myqueue.EnQueue(pushadd);
Console.WriteLine("Done");
}
if (selection == 2)
{
Console.WriteLine("The top value is a " + myqueue.Peek());
}
if (selection == 3)
{
int popval = myqueue.DeQueue();
if(popval == -1)
{
Console.WriteLine("Can't, your queue is empty");
}
else { Console.WriteLine("The top value of the queue is a " + popval); }
}
if (selection == 4)
{
myqueue.Print();
}
if (selection == 5)
{
myqueue.share();
}
QueueGeneric<Currencies> currencies = new QueueGeneric<Currencies>();
for(int i = 0; i < 10; i++)
{
currencis.Enqueue(new Currencies(Random.Next(0,100), Random.Next(0,100), Random.Next(0,100))
}
} while (selection != 6);
}
public void ContainsMethod_QueueWithThreeIntElements_ElementIsNotInQueue()
{
QueueGeneric <int> queue = new QueueGeneric <int>(new int[] { 1, 5, 7 });
Assert.IsFalse(queue.Contains(10));
}
