public void EnumerationShouldReturnOnlyRecordsWithData()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Assert.That(buffer.ToList().Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(1));
buffer.Enqueue(1);
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(2));
}
public void BufferShouldCountUntilMaxHitThenAlswaysShowMax()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Assert.That(buffer.Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(1));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldCountUntilMaxHitThenAlswaysShowMax()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Assert.That(buffer.Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(1));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void EnumerationShouldReturnOnlyRecordsWithData()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Assert.That(buffer.ToList().Count, Is.EqualTo(0));
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(1));
buffer.Enqueue(1);
buffer.Enqueue(1);
Assert.That(buffer.ToList().Count, Is.EqualTo(2));
}
public void EnqueueShouldAddToFirstSlot()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
buffer.Enqueue(1);
Assert.That(buffer.First(), Is.EqualTo(1));
}
public void ConcurrentEnqueueShouldNotLeakIndexPosition()
{
var buffer = new ConcurrentCircularBuffer<int>(10);
Parallel.For(0, 100000, i => buffer.Enqueue(i));
Assert.That(buffer.Count, Is.EqualTo(10));
}
public void ConcurrentEnqueueShouldNotLeakIndexPosition()
{
var buffer = new ConcurrentCircularBuffer <int>(10);
Parallel.For(0, 100000, i => buffer.Enqueue(i));
Assert.That(buffer.Count, Is.EqualTo(10));
}
private void ConcurrentEnqueueTestRun(int batchSize)
{
var buffer = new ConcurrentCircularBuffer <int>(10);
try
{
int index = 0;
int testSize = batchSize;
Parallel.For(0, testSize, i => buffer.Enqueue(Interlocked.Increment(ref index)));
Assert.That(buffer.Count, Is.EqualTo(10));
for (var i = testSize; i > testSize - 10; i--)
{
Assert.That(buffer.Contains(i));
}
}
catch
{
foreach (var i in buffer)
{
Console.WriteLine(i);
}
throw;
}
}
public void BufferMaxSizeShouldReportMax()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
}
public void BufferMaxSizeShouldReportMax()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
buffer.Enqueue(1);
Assert.That(buffer.MaxSize, Is.EqualTo(2));
}
public void EnqueueCanBeUseFromDefferantThread()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
Parallel.For(0, 1000, (i) =>
{
buffer.Enqueue(i);
Assert.That(buffer.Count, Is.LessThanOrEqualTo(2));
});
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldOnlyStoreMaxAmount()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
for (int i = 0; i < 10; i++)
{
buffer.Enqueue(i);
}
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void BufferShouldOnlyStoreMaxAmount()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
for (int i = 0; i < 10; i++)
{
buffer.Enqueue(i);
}
Assert.That(buffer.Count, Is.EqualTo(2));
}
public void EnqueueCanBeUseFromDefferantThread()
{
var buffer = new ConcurrentCircularBuffer <int>(2);
Parallel.For(0, 1000, (i) =>
{
buffer.Enqueue(i);
Assert.That(buffer.Count, Is.LessThanOrEqualTo(2));
});
Assert.That(buffer.Count, Is.EqualTo(2));
}
public static void CompleteNetworkWrite(KafkaDataPayload payload, long milliseconds, bool failed)
{
if (payload.TrackPayload == false)
{
return;
}
NetworkWriteStatistic stat;
if (NetworkWriteQueuedIndex.TryRemove(payload.CorrelationId, out stat))
{
stat.SetCompleted(milliseconds, failed);
CompletedNetworkWriteStatistics.Enqueue(stat);
}
Interlocked.Decrement(ref Gauges.QueuedWriteOperation);
}
public override void Send(NetworkData data)
{
HasUnsentMessages = true;
SendQueue.Enqueue(data);
Schedule();
}
private void ConcurrentEnqueueTestRun(int batchSize)
{
var buffer = new ConcurrentCircularBuffer<int>(10);
try
{
int index = 0;
int testSize = batchSize;
Parallel.For(0, testSize, i => buffer.Enqueue(Interlocked.Increment(ref index)));
Assert.That(buffer.Count, Is.EqualTo(10));
for (var i = testSize; i > testSize - 10; i--)
{
Assert.That(buffer.Contains(i));
}
}
catch
{
foreach (var i in buffer)
{
Console.WriteLine(i);
}
throw;
}
}
public static void RecordProduceRequest(int messageCount, int payloadBytes, int compressedBytes)
{
ProduceRequestStatistics.Enqueue(new ProduceRequestStatistic(messageCount, payloadBytes, compressedBytes));
}
public void EnqueueShouldAddToFirstSlot()
{
var buffer = new ConcurrentCircularBuffer<int>(2);
buffer.Enqueue(1);
Assert.That(buffer.First(), Is.EqualTo(1));
}
