public void TryActionTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(16);
//Inserts 10 items.
SplitQueue(q);
//Insert 6 more to fill the queue
for (int i = 0; i < 6; i++)
{
UnsafeSPSCQueue.TryEnqueue(q, 999);
}
Assert.IsFalse(UnsafeSPSCQueue.TryEnqueue(q, 10));
Assert.IsTrue(UnsafeSPSCQueue.TryPeek(q, out int result));
Assert.AreEqual(0, result);
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(UnsafeSPSCQueue.TryDequeue(q, out int val));
Assert.AreEqual(i, val);
}
//Empty 6 last items
for (int i = 0; i < 6; i++)
{
Assert.IsTrue(UnsafeSPSCQueue.TryDequeue(q, out int val));
Assert.AreEqual(999, val);
}
//Empty queue
Assert.IsFalse(UnsafeSPSCQueue.TryPeek(q, out int res));
UnsafeSPSCQueue.Free(q);
}
//Demonstration that this queue isn't MPSC
public void ConcurrencyTest2()
{
var q = UnsafeSPSCQueue.Allocate <int>(1600000);
int count = 1000000;
Thread writer = new Thread(() =>
{
for (int i = 0; i < count / 2; i++)
{
UnsafeSPSCQueue.Enqueue(q, i);
}
});
Thread writer2 = new Thread(() =>
{
for (int i = 0; i < count / 2; i++)
{
UnsafeSPSCQueue.Enqueue(q, i);
}
});
writer.Start();
writer2.Start();
writer.Join();
writer2.Join();
Assert.AreNotEqual(count, UnsafeSPSCQueue.GetCount(q));
UnsafeSPSCQueue.Free(q);
}
private static void SplitQueue(UnsafeSPSCQueue *q)
{
//Wrap tail back to 0
for (int i = 0; i < 5; i++)
{
UnsafeSPSCQueue.Enqueue(q, 111);
}
//First half
for (int i = 0; i < 5; i++)
{
UnsafeSPSCQueue.Enqueue(q, i);
}
//Move head by 5
for (int i = 0; i < 5; i++)
{
UnsafeSPSCQueue.Dequeue <int>(q);
}
//Second half (head and tail are now both 5)
for (int i = 5; i < 10; i++)
{
UnsafeSPSCQueue.Enqueue(q, i);
}
//Circular buffer now "ends" in the middle of the underlying array
}
public void InvalidTypeTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
Assert.Catch <AssertException>(() => { UnsafeSPSCQueue.Enqueue <float>(q, 162); });
UnsafeSPSCQueue.Free(q);
}
public void ConstructorTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
Assert.AreEqual(0, UnsafeSPSCQueue.GetCount(q));
Assert.AreEqual(10, UnsafeSPSCQueue.GetCapacity(q));
UnsafeSPSCQueue.Free(q);
}
public void CopyToTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
SplitQueue(q);
var arr = UnsafeSPSCQueue.ToArray <int>(q);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(i, arr[i]);
}
}
public void ClearTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
//Inserts 10 items.
SplitQueue(q);
Assert.AreEqual(10, UnsafeSPSCQueue.GetCount(q));
UnsafeSPSCQueue.Clear(q);
Assert.AreEqual(0, UnsafeSPSCQueue.GetCount(q));
Assert.IsTrue(UnsafeSPSCQueue.IsEmpty <int>(q));
UnsafeSPSCQueue.Free(q);
}
public void DequeueTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
for (int i = 0; i < 10; i++)
{
UnsafeSPSCQueue.Enqueue(q, i * i);
}
for (int i = 0; i < 10; i++)
{
int num = UnsafeSPSCQueue.Dequeue <int>(q);
Assert.AreEqual(i * i, num);
}
UnsafeSPSCQueue.Free(q);
}
public void ExpandTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(16);
SplitQueue(q);
//Fill buffer to capacity.
for (int i = 0; i < 6; i++)
{
UnsafeSPSCQueue.Enqueue(q, 999);
}
//Buffer is full, can no longer insert.
Assert.IsFalse(UnsafeSPSCQueue.TryEnqueue(q, 10));
UnsafeSPSCQueue.Free(q);
}
public void EnqueueTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
for (int i = 0; i < 10; i++)
{
UnsafeSPSCQueue.Enqueue(q, i * i);
}
Assert.AreEqual(10, UnsafeSPSCQueue.GetCount(q));
Assert.AreEqual(10, UnsafeSPSCQueue.GetCapacity(q));
UnsafeSPSCQueue.Clear(q);
Assert.AreEqual(0, UnsafeSPSCQueue.GetCount(q));
Assert.AreEqual(10, UnsafeSPSCQueue.GetCapacity(q));
UnsafeSPSCQueue.Free(q);
}
public void PeekTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
for (int i = 0; i < 10; i++)
{
UnsafeSPSCQueue.Enqueue(q, (int)Math.Pow(i + 2, 2));
}
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(4, UnsafeSPSCQueue.Peek <int>(q));
}
//Verify no items are dequeued
Assert.AreEqual(10, UnsafeSPSCQueue.GetCount(q));
UnsafeSPSCQueue.Free(q);
}
public void IteratorTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(10);
// Wrap tail around
SplitQueue(q);
// Iterator should start from the head.
int num = 0;
foreach (int i in UnsafeSPSCQueue.GetEnumerator <int>(q))
{
Assert.AreEqual(num, i);
num++;
}
// Iterated 10 items
Assert.AreEqual(10, num);
UnsafeSPSCQueue.Free(q);
}
public void CopyTo(T[] array, int arrayIndex)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array));
}
if ((uint)arrayIndex > array.Length)
{
throw new ArgumentOutOfRangeException(nameof(arrayIndex));
}
if (array.Length - arrayIndex < Count)
{
throw new ArgumentException("Insufficient space in the target location to copy the information.");
}
if (array.Length == 0)
{
return;
}
UnsafeSPSCQueue.ToArray <T>(m_inner).CopyTo(array, arrayIndex);
}
// Demonstration that this queue is SPSC
public void ConcurrencyTest()
{
var q = UnsafeSPSCQueue.Allocate <int>(16);
int count = 10000;
Thread reader = new Thread(() =>
{
for (int i = 0; i < count; i++)
{
Assert.AreEqual(i, UnsafeSPSCQueue.Dequeue <int>(q));
}
});
reader.Start();
for (int i = 0; i < count; i++)
{
UnsafeSPSCQueue.Enqueue(q, i);
}
reader.Join();
UnsafeSPSCQueue.Free(q);
}
public NativeSPSCQueue(int capacity)
{
m_inner = UnsafeSPSCQueue.Allocate <T>(capacity);
}
public void Dispose()
{
UnsafeSPSCQueue.Free(m_inner);
m_inner = null;
}
IEnumerator IEnumerable.GetEnumerator()
{
return(UnsafeSPSCQueue.GetEnumerator <T>(m_inner));
}
public UnsafeSPSCQueue.Enumerator <T> GetEnumerator()
{
return(UnsafeSPSCQueue.GetEnumerator <T>(m_inner));
}
public T[] ToArray()
{
return(UnsafeSPSCQueue.ToArray <T>(m_inner));
}
public void Clear()
{
UnsafeSPSCQueue.Clear(m_inner);
}
public bool TryPeek(out T item)
{
return(UnsafeSPSCQueue.TryPeek <T>(m_inner, out item));
}
public T Peek()
{
return(UnsafeSPSCQueue.Peek <T>(m_inner));
}
public bool TryDequeue(out T item)
{
return(UnsafeSPSCQueue.TryDequeue <T>(m_inner, out item));
}
public void Enqueue(T item)
{
UnsafeSPSCQueue.Enqueue <T>(m_inner, item);
}
public bool TryEnqueue(T item)
{
return(UnsafeSPSCQueue.TryEnqueue <T>(m_inner, item));
}
public T Dequeue()
{
return(UnsafeSPSCQueue.Dequeue <T>(m_inner));
}
