public void Contains()
{
var queue = new TrackedConcurrentQueue <int>(Enumerable.Range(0, 100));
Assert.IsTrue(queue.Contains(50));
Assert.IsFalse(queue.Contains(100));
}
public void SimpleAddAndRemove()
{
var queue = new TrackedConcurrentQueue <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 TrackedConcurrentQueue <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 CopyTo()
{
var queue = new TrackedConcurrentQueue <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 Serialisation()
{
var queue = new TrackedConcurrentQueue <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((TrackedConcurrentQueue <int>) new BinaryFormatter().Deserialize(ms)));
}
}
public void ICollection()
{
ICollection queue = new TrackedConcurrentQueue <int>(Enumerable.Range(0, 10));
Assert.IsFalse(queue.IsSynchronized);
int cmp = 0;
foreach (int i in queue)
{
Assert.AreEqual(cmp++, i);
}
}
public void ResetEnum()
{
var queue = new TrackedConcurrentQueue <int>(Enumerable.Range(0, 100));
var en = queue.GetEnumerator();
while (en.MoveNext() && en.Current < 50)
{
;
}
en.Reset();
int cmp = 0;
while (en.MoveNext())
{
Assert.AreEqual(cmp++, en.Current);
}
}
public void MultiAdd()
{
int cores = CoreCount();
var threads = new Thread[cores];
var queue = new TrackedConcurrentQueue <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 HalfDequeue()
{
int cores = CoreCount();
if (cores < 2)
{
cores = 2;
}
var threads = new Thread[cores];
var queue = new SlimConcurrentQueue <int>();
var secQueue = new TrackedConcurrentQueue <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 SyncRootFail()
{
ICollection queue = new TrackedConcurrentQueue <int>(Enumerable.Range(0, 100));
object root = queue.SyncRoot;
}
