public void Contains()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
Assert.IsTrue(queue.Contains(50));
Assert.IsFalse(queue.Contains(100));
}
public void MultiAdd()
{
int cores = CoreCount();
var threads = new Thread[cores];
var queue = new LLQueue<int>();
for(int i = 0; i != cores; ++i)
{
threads[i] = new Thread(obj =>
{
int off = (int)obj;
for(int x = 0; x != 100000; ++x)
queue.Enqueue(x * cores + off);
});
}
for(int i = 0; i != cores; ++i)
threads[i].Start(i);
for(int i = 0; i != cores; ++i)
threads[i].Join();
Dictionary<int, int> dict = new Dictionary<int, int>();
for(int i = 0; i != cores; ++i)
dict[i] = -1;
foreach(int test in queue)
{
int bucket = test % cores;
int last = dict[bucket];
Assert.IsTrue(test > last);
dict[bucket] = last;
}
}
public void ICloneable()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
var clone = (LLQueue <int>)((ICloneable)queue).Clone();
Assert.IsTrue(queue.SequenceEqual(clone));
}
public void Enumerate()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
int cur = 0;
foreach (int i in queue)
{
Assert.AreEqual(cur++, i);
}
Assert.AreEqual(100, queue.Count);
cur = 0;
foreach (int i in queue.DequeueAll())
{
Assert.AreEqual(cur++, i);
Assert.AreEqual(100 - cur, queue.Count);
}
Assert.AreEqual(0, queue.Count);
queue.EnqueueRange(Enumerable.Range(0, 100));
Assert.AreEqual(100, queue.Count);
cur = 0;
foreach (int i in queue.AtomicDequeueAll())
{
Assert.AreEqual(cur++, i);
Assert.AreEqual(0, queue.Count);
}
}
public void SimpleAddAndRemove()
{
var queue = new LLQueue <int>();
for (int i = 0; i != 10; ++i)
{
queue.Enqueue(i);
}
int cur = 0;
int res;
int peek;
queue.TryPeek(out peek);
Assert.AreEqual(0, peek);
while (queue.TryDequeue(out res))
{
Assert.AreEqual(cur++, res);
if (queue.TryPeek(out peek))
{
Assert.AreEqual(cur, peek);
Assert.IsFalse(queue.IsEmpty);
}
else
{
Assert.IsTrue(queue.IsEmpty);
}
}
}
public void RacingEnumeration()
{
int cores = CoreCount();
if (cores < 2)
{
cores = 2;
}
var threads = new Thread[cores];
var queue = new LLQueue <int>();
bool failed = false;
for (int i = 0; i != cores; ++i)
{
if (i % 2 == 0)
{
threads[i] = new Thread(obj =>
{
int off = (int)obj;
for (int x = 0; x != 100000; ++x)
{
queue.Enqueue(x * cores + off);
}
});
}
else
{
threads[i] = new Thread(obj =>
{
int prev = -1;
foreach (int taken in queue)
{
if (prev >= taken)
{
failed = false;
}
prev = taken;
}
});
}
}
for (int i = 0; i < cores; i += 2)
{
threads[i].Start(i);
}
for (int i = 1; i < cores; i += 2)
{
threads[i].Start(i);
}
for (int i = 0; i != cores; ++i)
{
threads[i].Join();
}
Assert.IsFalse(failed);
}
public void ICollectionT()
{
ICollection <int> queue = new LLQueue <int>();
Assert.IsFalse(queue.IsReadOnly);
queue.Add(1);
foreach (int i in queue)
{
Assert.AreEqual(1, i);
}
}
public void Serialisation()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
using(MemoryStream ms = new MemoryStream())
{
new BinaryFormatter().Serialize(ms, queue);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
Assert.IsTrue(queue.ToList().SequenceEqual((LLQueue<int>)new BinaryFormatter().Deserialize(ms)));
}
}
public void CopyTo()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
var array = new int[150];
queue.CopyTo(array, 50);
Assert.IsTrue(array.Skip(50).SequenceEqual(queue));
array = new int[150];
((ICollection)queue).CopyTo(array, 50);
Assert.IsTrue(array.Skip(50).SequenceEqual(queue));
}
public void CountMax()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
Assert.AreEqual(100, queue.CountUntil(200));
Assert.AreEqual(100, queue.CountUntil(100));
Assert.AreEqual(50, queue.CountUntil(50));
Assert.AreEqual(0, queue.CountUntil(0));
queue.Clear();
Assert.IsTrue(queue.IsEmpty);
}
public void ICollection()
{
ICollection queue = new LLQueue <int>(Enumerable.Range(0, 10));
Assert.IsFalse(queue.IsSynchronized);
int cmp = 0;
foreach (int i in queue)
{
Assert.AreEqual(cmp++, i);
}
}
public void Serialisation()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
using (MemoryStream ms = new MemoryStream())
{
new BinaryFormatter().Serialize(ms, queue);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
Assert.IsTrue(queue.ToList().SequenceEqual((LLQueue <int>) new BinaryFormatter().Deserialize(ms)));
}
}
public void Transfer()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
var trans = queue.Transfer();
Assert.IsTrue(queue.IsEmpty);
int cmp = 0;
foreach (int i in queue.ToArray())
{
Assert.AreEqual(cmp++, i);
}
}
public void ClearLast()
{
var queue = new LLQueue <FinalisationNoter>();
queue.Enqueue(new FinalisationNoter());
queue.Enqueue(new FinalisationNoter());
queue.DequeueToList();
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.AreEqual(1, FinalisationNoter.FinalisationCount);
queue.ClearLastItem();
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.AreEqual(2, FinalisationNoter.FinalisationCount);
}
public void ResetDeEnum()
{
var queue = new LLQueue <int>(Enumerable.Range(0, 100));
var en = queue.DequeueAll().GetEnumerator();
while (en.MoveNext() && en.Current < 50)
{
;
}
en.Reset();
int cmp = 51;
while (en.MoveNext())
{
Assert.AreEqual(cmp++, en.Current);
}
}
public void RacingClears()
{
int cores = CoreCount();
if (cores < 2)
{
cores = 2;
}
var threads = new Thread[cores];
var queue = new LLQueue <int>();
int done = 0;
threads[0] = new Thread(() =>
{
for (int x = 0; x != 1000000; ++x)
{
queue.Enqueue(x);
}
Interlocked.Increment(ref done);
});
for (int i = 1; i != cores; ++i)
{
threads[i] = new Thread(() =>
{
while (done == 0)
{
for (int x = 0; x != 1000; ++x)
{
queue.Clear();
}
}
});
}
for (int i = 0; i < cores; ++i)
{
threads[i].Start();
}
for (int i = 0; i < cores; ++i)
{
threads[i].Join();
}
Assert.IsTrue(queue.IsEmpty);
}
public void HalfDequeue()
{
int cores = CoreCount();
if(cores < 2)
cores = 2;
var threads = new Thread[cores];
var queue = new LLQueue<int>();
var secQueue = new LLQueue<int>();
for(int i = 0; i != cores; ++i)
{
if(i % 2 == 0)
threads[i] = new Thread(obj =>
{
int off = (int)obj;
for(int x = 0; x != 100000; ++x)
queue.Enqueue(x * cores + off);
});
else
threads[i] = new Thread(obj =>
{
foreach(int taken in queue.DequeueAll())
secQueue.Enqueue(taken);
});
}
for(int i = 0; i < cores; i += 2)
threads[i].Start(i);
for(int i = 1; i < cores; i += 2)
threads[i].Start(i);
for(int i = 0; i != cores; ++i)
threads[i].Join();
Dictionary<int, int> dict = new Dictionary<int, int>();
for(int i = 0; i != cores; ++i)
dict[i] = -1;
secQueue.EnqueueRange(queue);
foreach(int test in secQueue)
{
int bucket = test % cores;
int last = dict[bucket];
Assert.IsTrue(test > last);
dict[bucket] = last;
}
}
public void SimpleAddAndRemove()
{
var queue = new LLQueue<int>();
for(int i = 0; i != 10; ++i)
queue.Enqueue(i);
int cur = 0;
int res;
int peek;
queue.TryPeek(out peek);
Assert.AreEqual(0, peek);
while(queue.TryDequeue(out res))
{
Assert.AreEqual(cur++, res);
if(queue.TryPeek(out peek))
{
Assert.AreEqual(cur, peek);
Assert.IsFalse(queue.IsEmpty);
}
else
Assert.IsTrue(queue.IsEmpty);
}
}
public void MultiAdd()
{
int cores = CoreCount();
var threads = new Thread[cores];
var queue = new LLQueue <int>();
for (int i = 0; i != cores; ++i)
{
threads[i] = new Thread(obj =>
{
int off = (int)obj;
for (int x = 0; x != 100000; ++x)
{
queue.Enqueue(x * cores + off);
}
});
}
for (int i = 0; i != cores; ++i)
{
threads[i].Start(i);
}
for (int i = 0; i != cores; ++i)
{
threads[i].Join();
}
Dictionary <int, int> dict = new Dictionary <int, int>();
for (int i = 0; i != cores; ++i)
{
dict[i] = -1;
}
foreach (int test in queue)
{
int bucket = test % cores;
int last = dict[bucket];
Assert.IsTrue(test > last);
dict[bucket] = last;
}
}
public void Enumerate()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
int cur = 0;
foreach(int i in queue)
Assert.AreEqual(cur++, i);
Assert.AreEqual(100, queue.Count);
cur = 0;
foreach(int i in queue.DequeueAll())
{
Assert.AreEqual(cur++, i);
Assert.AreEqual(100 - cur, queue.Count);
}
Assert.AreEqual(0, queue.Count);
queue.EnqueueRange(Enumerable.Range(0, 100));
Assert.AreEqual(100, queue.Count);
cur = 0;
foreach(int i in queue.AtomicDequeueAll())
{
Assert.AreEqual(cur++, i);
Assert.AreEqual(0, queue.Count);
}
}
static void Main(string[] args)
{
//test queue
//create list
LinkedList myList = new LinkedList();
//create queue
LLQueue myQueue = new LLQueue(myList);
//enqueue 6 numbers
Console.WriteLine("enqueue 6");
myQueue.Enqueue(6);
Console.WriteLine("enqueue 5");
myQueue.Enqueue(5);
Console.WriteLine("enqueue 4");
myQueue.Enqueue(4);
Console.WriteLine("enqueue 3");
myQueue.Enqueue(3);
Console.WriteLine("enqueue 2");
myQueue.Enqueue(2);
Console.WriteLine("enqueue 1");
myQueue.Enqueue(1);
//peek front to ensure that "6" is the first node in queue
Console.WriteLine("Peek front: " + myQueue.Peek());
//dequeue the first 3 nodes
Console.WriteLine("Dequeue");
Console.WriteLine("removed " + myQueue.Dequeue());
Console.WriteLine("Dequeue");
Console.WriteLine("removed " + myQueue.Dequeue());
Console.WriteLine("Dequeue");
Console.WriteLine("removed " + myQueue.Dequeue());
//peek front again to ensure that "3" is now the front node
Console.WriteLine("Peek Front: " + myQueue.Peek());
Console.ReadKey();
}
static void Main()
{
LLQueue q = new LLQueue();
q.Enqueue(123);
q.Enqueue("lgslaya");
q.Enqueue('f');
q.Enqueue("Nodes R US");
q.Enqueue(34.46);
Console.WriteLine("Peek: " + q.Peek());
Console.WriteLine(q.ToString());
q.Dequeue();
q.Dequeue();
q.Dequeue();
q.Dequeue();
Console.WriteLine(q.ToString());
q.Enqueue(1337);
q.Enqueue("\'7th item");
q.Enqueue("Should be wrapping around");
q.Dequeue();
Console.WriteLine(q.ToString());
}
public void ICloneable()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
var clone = (LLQueue<int>)((ICloneable)queue).Clone();
Assert.IsTrue(queue.SequenceEqual(clone));
}
public void Transfer()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
var trans = queue.Transfer();
Assert.IsTrue(queue.IsEmpty);
int cmp = 0;
foreach(int i in queue.ToArray())
Assert.AreEqual(cmp++, i);
}
public void CantRemove()
{
ICollection <int> queue = new LLQueue <int>();
queue.Remove(93);
}
public void Contains()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
Assert.IsTrue(queue.Contains(50));
Assert.IsFalse(queue.Contains(100));
}
public void RacingClears()
{
int cores = CoreCount();
if(cores < 2)
cores = 2;
var threads = new Thread[cores];
var queue = new LLQueue<int>();
int done = 0;
threads[0] = new Thread(() =>
{
for(int x = 0; x != 1000000; ++x)
queue.Enqueue(x);
Interlocked.Increment(ref done);
});
for(int i = 1; i != cores; ++i)
{
threads[i] = new Thread(() =>
{
while(done == 0)
for(int x = 0; x != 1000; ++x)
queue.Clear();
});
}
for(int i = 0; i < cores; ++i)
threads[i].Start();
for(int i = 0; i < cores; ++i)
threads[i].Join();
Assert.IsTrue(queue.IsEmpty);
}
public void Test_LLQueue_Empty()
{
LLQueue <int> q = new LLQueue <int>();
IntQueueTestEmpty(q);
}
public void SyncRootFail()
{
ICollection queue = new LLQueue<int>(Enumerable.Range(0, 100));
object root = queue.SyncRoot;
}
public void ICollectionT()
{
ICollection<int> queue = new LLQueue<int>();
Assert.IsFalse(queue.IsReadOnly);
queue.Add(1);
foreach(int i in queue)
Assert.AreEqual(1, i);
}
public void CantRemove()
{
ICollection<int> queue = new LLQueue<int>();
queue.Remove(93);
}
public void ResetDeEnum()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
var en = queue.DequeueAll().GetEnumerator();
while(en.MoveNext() && en.Current < 50);
en.Reset();
int cmp = 51;
while(en.MoveNext())
Assert.AreEqual(cmp++, en.Current);
}
public void RacingEnumeration()
{
int cores = CoreCount();
if(cores < 2)
cores = 2;
var threads = new Thread[cores];
var queue = new LLQueue<int>();
bool failed = false;
for(int i = 0; i != cores; ++i)
{
if(i % 2 == 0)
threads[i] = new Thread(obj =>
{
int off = (int)obj;
for(int x = 0; x != 100000; ++x)
queue.Enqueue(x * cores + off);
});
else
threads[i] = new Thread(obj =>
{
int prev = -1;
foreach(int taken in queue)
{
if(prev >= taken)
failed = false;
prev = taken;
}
});
}
for(int i = 0; i < cores; i += 2)
threads[i].Start(i);
for(int i = 1; i < cores; i += 2)
threads[i].Start(i);
for(int i = 0; i != cores; ++i)
threads[i].Join();
Assert.IsFalse(failed);
}
public void ClearLast()
{
var queue = new LLQueue<FinalisationNoter>();
queue.Enqueue(new FinalisationNoter());
queue.Enqueue(new FinalisationNoter());
queue.DequeueToList();
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.AreEqual(1, FinalisationNoter.FinalisationCount);
queue.ClearLastItem();
GC.Collect();
GC.WaitForPendingFinalizers();
Assert.AreEqual(2, FinalisationNoter.FinalisationCount);
}
public void CountMax()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
Assert.AreEqual(100, queue.CountUntil(200));
Assert.AreEqual(100, queue.CountUntil(100));
Assert.AreEqual(50, queue.CountUntil(50));
Assert.AreEqual(0, queue.CountUntil(0));
queue.Clear();
Assert.IsTrue(queue.IsEmpty);
}
public void HalfDequeue()
{
int cores = CoreCount();
if (cores < 2)
{
cores = 2;
}
var threads = new Thread[cores];
var queue = new LLQueue <int>();
var secQueue = new LLQueue <int>();
for (int i = 0; i != cores; ++i)
{
if (i % 2 == 0)
{
threads[i] = new Thread(obj =>
{
int off = (int)obj;
for (int x = 0; x != 100000; ++x)
{
queue.Enqueue(x * cores + off);
}
});
}
else
{
threads[i] = new Thread(obj =>
{
foreach (int taken in queue.DequeueAll())
{
secQueue.Enqueue(taken);
}
});
}
}
for (int i = 0; i < cores; i += 2)
{
threads[i].Start(i);
}
for (int i = 1; i < cores; i += 2)
{
threads[i].Start(i);
}
for (int i = 0; i != cores; ++i)
{
threads[i].Join();
}
Dictionary <int, int> dict = new Dictionary <int, int>();
for (int i = 0; i != cores; ++i)
{
dict[i] = -1;
}
secQueue.EnqueueRange(queue);
foreach (int test in secQueue)
{
int bucket = test % cores;
int last = dict[bucket];
Assert.IsTrue(test > last);
dict[bucket] = last;
}
}
public void ICollection()
{
ICollection queue = new LLQueue<int>(Enumerable.Range(0, 10));
Assert.IsFalse(queue.IsSynchronized);
int cmp = 0;
foreach(int i in queue)
Assert.AreEqual(cmp++, i);
}
public void CopyTo()
{
var queue = new LLQueue<int>(Enumerable.Range(0, 100));
var array = new int[150];
queue.CopyTo(array, 50);
Assert.IsTrue(array.Skip(50).SequenceEqual(queue));
array = new int[150];
((ICollection)queue).CopyTo(array, 50);
Assert.IsTrue(array.Skip(50).SequenceEqual(queue));
}
public void SyncRootFail()
{
ICollection queue = new LLQueue <int>(Enumerable.Range(0, 100));
object root = queue.SyncRoot;
}
public void Test_LLQueue_CopyTo()
{
LLQueue <int> q = new LLQueue <int>();
IntQueueTestCopyTo(q);
}
public void Test_LLQueue_00()
{
LLQueue <string> q = new LLQueue <string>();
StringQueueTest(q);
}
