public void TestPushPop()
{
CircularBuffer<double> queue = new CircularBuffer<double>(3);
queue.PushBack(1.0);
queue.PushBack(2.0);
queue.PushBack(3.0);
Assert.That(queue[0], Is.EqualTo(1.0).Within(0.00005));
Assert.That(queue[1], Is.EqualTo(2.0).Within(0.00005));
Assert.That(queue[2], Is.EqualTo(3.0).Within(0.00005));
//The buffer is now full.
queue.PushBack(4.0);
Assert.That(queue[0], Is.EqualTo(2.0).Within(0.00005));
Assert.That(queue[1], Is.EqualTo(3.0).Within(0.00005));
Assert.That(queue[2], Is.EqualTo(4.0).Within(0.00005));
queue.PushBack(5.0);
Assert.That(queue[0], Is.EqualTo(3.0).Within(0.00005));
Assert.That(queue[1], Is.EqualTo(4.0).Within(0.00005));
Assert.That(queue[2], Is.EqualTo(5.0).Within(0.00005));
queue.PopBack();
Assert.That(queue[0], Is.EqualTo(3.0).Within(0.00005));
Assert.That(queue[1], Is.EqualTo(4.0).Within(0.00005));
queue.PopFront();
Assert.That(queue[0], Is.EqualTo(4.0).Within(0.00005));
}
public LinearRegressionInputData GetValues(
CircularBuffer<MarketDataPair> data,
int fromIndex)
{
List<MarketDataPair> rangeData = data.PeekRange(fromIndex);
return GetLinearRegressionData(rangeData);
}
public void LevelReset(float liveCount){
timeOfDeath = float.PositiveInfinity;
playerEvents = new CircularBuffer<PlayerEvent>(2);
roundScore = 0f;
lived = false;
lives = liveCount;
}
public WidcommBluetoothStream(CircularBuffer buffer, CircularBuffer sbuffer, byte[] address, string pin)
: base(buffer, sbuffer, address, pin)
{
wdStack[0] = WidcommAPI.CreateWidcommStack();
if (wdStack[0] == IntPtr.Zero)
throw new Exception("Cannot create stack");
}
/// <summary>
/// 係数を配列で指定して初期化
/// </summary>
/// <param name="a">分母係数を格納した配列</param>
/// <param name="b">分子係数を格納した配列</param>
/// <param name="c">ゲイン</param>
public IirFilter(double[] a, double[] b, double c)
{
this.a = a;
this.b = b;
this.c = c;
this.buf = new CircularBuffer(a.Length);
}
/// <summary>
/// Creates a linear FIR or IIR filter.
/// </summary>
/// <param name="source">The <see cref="IPIDSource"/> object that is used to get values.</param>
/// <param name="ffGains">The "feed forward" or FIR gains.</param>
/// <param name="fbGains">The "feed back" or IIR gains.</param>
public LinearDigitalFilter(IPIDSource source, double[] ffGains, double[] fbGains) : base(source)
{
m_inputs = new CircularBuffer<double>(ffGains.Length);
m_outputs = new CircularBuffer<double>(fbGains.Length);
m_inputGains = ffGains;
m_outputGains = fbGains;
}
public void OverflowException()
{
var buffer = new CircularBuffer<int>(4);
for (int i = 0; i < 32; i++)
buffer.Put(i);
}
public void CircularBufferExt_DecoderConvert1_BoundariesFlush()
{
Encoding enc = Encoding.GetEncoding("UTF-8");
Decoder d = enc.GetDecoder();
byte[] m = new byte[] {
0xAC, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E,
0x4F, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56,
0x57, 0x58, 0x59, 0x5A, 0xE2, 0x82
};
char[] c = new char[28];
CircularBuffer<byte> cb = new CircularBuffer<byte>(m, 16, m.Length);
int bu;
int cu;
bool complete;
// Based on the test "Decoder_Boundaries2"
d.Convert(cb, c, 0, c.Length, true, out bu, out cu, out complete);
Assert.IsTrue(complete);
Assert.AreEqual(m.Length, bu);
Assert.AreEqual(0, cb.Length);
Assert.AreEqual(c.Length, cu);
Assert.AreEqual("OPQRSTUVWXYZ€@ABCDEFGHIJKLMN", new string(c));
}
// Use this for initialization
void init()
{
//Loop through the object prefabs and make a new list for each one.
//We do this because the pool can only support prefabs set to it in the editor,
//so we can assume the lists of pooled objects are in the same order as object prefabs in the array
_objects = new CircularBuffer<GameObject>[_prefabs.Length];
int i = 0;
foreach ( GameObject objectPrefab in _prefabs )
{
_objects[i] = new CircularBuffer<GameObject>(_bufferAmount[i]);
for ( int n=0; n<_bufferAmount[i]; n++)
{
GameObject obj = Instantiate(objectPrefab) as GameObject;
obj.name = objectPrefab.name;
obj.SetActiveRecursively(false);
obj.transform.parent = transform;
_objects[i].Add(obj);
}
i++;
}
}
public QueueClient Get(Address address)
{
var key = address.ToString();
var buffer = queueClients.GetOrAdd(key, s =>
{
var b = new CircularBuffer<QueueClientEntry>(numberOfQueueClientsPerAddress);
for (var i = 0; i < numberOfQueueClientsPerAddress; i++)
{
var factory = messagingFactories.Get(address);
b.Put(new QueueClientEntry
{
Client = queueClientCreator.Create(address.Queue, factory)
});
}
return b;
});
var entry = buffer.Get();
if (entry.Client.IsClosed)
{
lock (entry.mutex)
{
if (entry.Client.IsClosed)
{
var factory = messagingFactories.Get(address);
entry.Client = queueClientCreator.Create(address.Queue, factory);
}
}
}
return entry.Client;
}
internal void Recycle(CircularBuffer<byte[]> buffer)
{
if (buffer != null)
{
while (buffer.Count != 0) Recycle(buffer.Pop());
}
}
public object Clone()
{
CircularBuffer cb = new CircularBuffer(this.Count);
cb.buf = (double[])this.buf.Clone();
cb.top = this.top;
return cb;
}
protected virtual void Awake()
{
_activeTrail = new CircularBuffer<PCTrailPoint>(MaxNumberOfPoints);
_fadingTrails = new List<CircularBuffer<PCTrailPoint>>();
_t = transform;
_emit = Emit;
}
public MessagingFactory Get(Address address)
{
var key = address.ToString();
var buffer = MessagingFactories.GetOrAdd(key, s => {
var b = new CircularBuffer<FactoryEntry>(numberOfFactoriesPerAddress);
for(var i = 0; i < numberOfFactoriesPerAddress; i++)
b.Put(new FactoryEntry { Factory = createMessagingFactories.Create(address) });
return b;
});
var entry = buffer.Get();
if (entry.Factory.IsClosed)
{
lock (entry.mutex)
{
if (entry.Factory.IsClosed)
{
entry.Factory = createMessagingFactories.Create(address);
}
}
}
return entry.Factory;
}
public void CreateTrail(Vector3 from, Vector3 to, float distanceBetweenPoints)
{
float num = Vector3.Distance(from, to);
Vector3 normalized = (to - from).normalized;
float num2 = 0f;
CircularBuffer<PCTrailPoint> circularBuffer = new CircularBuffer<PCTrailPoint>(this.GetMaxNumberOfPoints());
int num3 = 0;
while (num2 < num)
{
PCTrailPoint pCTrailPoint = new PCTrailPoint();
pCTrailPoint.PointNumber = num3;
pCTrailPoint.Position = from + normalized * num2;
circularBuffer.Add(pCTrailPoint);
this.InitialiseNewPoint(pCTrailPoint);
num3++;
if (distanceBetweenPoints <= 0f)
{
break;
}
num2 += distanceBetweenPoints;
}
PCTrailPoint pCTrailPoint2 = new PCTrailPoint();
pCTrailPoint2.PointNumber = num3;
pCTrailPoint2.Position = to;
circularBuffer.Add(pCTrailPoint2);
this.InitialiseNewPoint(pCTrailPoint2);
PCTrail pCTrail = new PCTrail(this.GetMaxNumberOfPoints());
pCTrail.Points = circularBuffer;
this._fadingTrails.Add(pCTrail);
}
public QueueProcessor(Logger log, IDataStore dataStore, IHubContext<IMatchmakingClient> hub, ITracker tracker, IMatchEvaluator matchBuilder, CircularBuffer<TimeSpan> timeToMatch)
{
_log = log;
_dataStore = dataStore;
_hub = hub;
_tracker = tracker;
_matchBuilder = matchBuilder;
_timeToMatch = timeToMatch;
_queueSleepMin = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMin") );
_queueSleepMax = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMax") );
_queueSleepLength = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepLength") );
Task.Run( async () =>
{
_log.Info("Running QueueProcessor...");
while( true )
{
var sleepTime = _queueSleepMax;
try
{
await processQueue();
sleepTime = _queueSleepMax - (_dataStore.DocumentDbPopulation * (_queueSleepMax/_queueSleepLength));
}
catch(Exception ex)
{
_log.Error(ex);
}
Thread.Sleep(sleepTime < _queueSleepMin ? _queueSleepMin : sleepTime);
}
});
}
public Guest(string channel, IApplicationShutdown shutdown, IServiceProvider serviceProvider)
{
this.channel = channel;
this.shutdown = shutdown;
this.serviceProvider = serviceProvider;
this.guestBuffer = new CircularBuffer(channel);
this.hostBuffer = new CircularBuffer(channel + "*");
}
public void ShouldSaveWithoutOverflow()
{
var buffer = new CircularBuffer<int>(5);
buffer.Add(1);
buffer.Add(2);
buffer.Add(3);
CollectionAssert.AreEqual(new [] { 1, 2, 3 }, buffer);
}
public byte[] Serialize(CircularBuffer<Packet> buffer)
{
if (buffer.Size == 0)
return null;
var json = JsonConvert.SerializeObject(buffer.Get());
return Encoding.UTF8.GetBytes(json);
}
public void TestCircularBuffer_2()
{
var cb = new CircularBuffer<int>(3);
Assert.Equal(0, cb.Read(new int[10], 0, 10));
cb.Write(new[] { 1, 2 });
Assert.Equal(new[] { 1, 2 }, Read(cb, 2));
cb.Write(new[] { 3, 4 });
Assert.Equal(new[] { 3, 4 }, Read(cb, 2));
}
public object Clone()
{
CircularBuffer cb = new CircularBuffer(this.length);
cb.buf = (double[])this.buf.Clone();
cb.top = this.top;
cb.length = this.length;
cb.mask = this.mask;
return cb;
}
public void ShouldSaveWithOverflow()
{
var buffer = new CircularBuffer<int>(4);
for(var i = 0; i < 6; i++)
{
buffer.Add(i);
}
Assert.AreEqual(buffer, new [] { 3, 4, 5 });
}
public void ClearTest()
{
var target = new CircularBuffer<int>(3) { 1, 2, 3 };
target.Clear();
Assert.IsTrue(target.Capacity == 3);
Assert.IsTrue(target.Count == 0);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="taps">遅延タップ数</param>
public Delay(int taps)
{
if(taps <= 0)
this.buf = null;
else
this.buf = new CircularBuffer(taps);
this.Clear();
}
/*
* coroutine
IEnumerator YieldSign() {
print ("spawn yield symbol");
yield return new WaitForSeconds(2);
PowerSpawn();
}
void PowerSpawn(){
print ("spawn power");
}
void Start() {
StartCoroutine(YieldSign());
print ("disable button");
}
*/
void Start(){
CircularBuffer<int> buffer = new CircularBuffer<int>(2);
buffer.Add(1);
buffer.Add(2);
buffer.Add(3);
foreach(int i in buffer.Reverse<int>()){
print (i);
}
}
private static int[] Read(CircularBuffer<int> cb, int count)
{
var buffer = new int[count];
int read = 0;
while (read < count)
{
read += cb.Read(buffer, read, count - read);
}
return buffer;
}
public float Average(CircularBuffer<int> buff, int period)
{
float avg = 0;
int i = 0;
for (; i < period && i < buff.Length; i++)
avg += buff[i];
return (i > 0) ? avg / i : 0;
}
protected override void Dispose(bool disposing)
{
if(disposing)
{
if (context != null) context.Recycle(buffers);
context = null;
buffers = null;
}
base.Dispose(disposing);
}
public void CircularBuffer_CopyTo()
{
var data = new[] { 12, 4, 9, 43, 0 };
var buffer = new CircularBuffer<int>(10);
buffer.EnqueueRange(data, 0, data.Length);
var dataCopy = new int[5];
buffer.CopyTo(dataCopy, 0, 5);
CollectionAssert.AreEqual(new[] { 12, 4, 9, 43, 0 }, dataCopy);
}
public void TestSimple()
{
var buffer = new CircularBuffer<int>(16);
var data = new int[8];
buffer.Put(data, 0, 8);
Assert.AreEqual(
8,
buffer.Size);
}
/// <summary>
/// Initializes a new instance of the <see cref="HistoryStack"/> class.
/// </summary>
/// <param name="historyActionsLimit">The history actions limit.</param>
public HistoryStack(int historyActionsLimit = 1000)
{
_historyActionsLimit = historyActionsLimit;
_historyActions = new CircularBuffer <IHistoryAction>(_historyActionsLimit);
_reverseActions = new CircularBuffer <IHistoryAction>(_historyActionsLimit);
}
private static void Remove(CircularBuffer <string> buffer, int n)
{
buffer.RemoveMany(n);
}
public void Read_EmptyBuffer_ThrowsException()
{
var buffer = new CircularBuffer <int>(1);
Assert.Throws <InvalidOperationException>(() => buffer.Read());
}
public void Have_No_Bytes_Cut_When_Created()
{
var sut = new CircularBuffer(ArrayPool <byte> .Shared);
sut.BytesCut.Should().Be(0);
}
public PartitionQueueInfo(int maxBufferSize)
{
Queue = new CircularBuffer <Message>(maxBufferSize); // TODO: Max Enqueued Batches configuration!
}
/// <summary>
/// The default buffer is 1<<16, if small will automatically add buffer block
/// </summary>
/// <param name="bufferSize"></param>
public TcpSocket(int bufferSize = 1 << 16)
{
SendBuffer = new CircularBuffer <byte>(bufferSize);
ReceiveBuffer = new CircularBuffer <byte>(bufferSize);
}
public void UnsafePeekTest_With_Overflow()
{
Random rnd = new Random(1337);
byte[] buffer = new byte[9];
rnd.NextBytes(buffer);
CircularBuffer cb = new CircularBuffer(16);
byte[] dummy = new byte[100];
fixed(byte *src = dummy)
{
Assert.AreEqual(0, cb.Peek(src, 78, 0));
}
cb.Write(buffer, 0, buffer.Length);
fixed(byte *src = dummy)
{
Assert.AreEqual(buffer.Length, cb.Peek(src, 78, 0));
}
cb.Dispose();
cb = new CircularBuffer(16);
cb.Write(buffer, 0, buffer.Length);
cb.Write(buffer, 0, buffer.Length);
Assert.AreEqual(cb.Count, 16);
byte[] readBuffer2 = new byte[9];
fixed(byte *src = readBuffer2)
{
Assert.AreEqual(7, cb.Peek(src, readBuffer2.Length, 9));
}
Assert.AreEqual(cb.Count, 16);
Assert.IsFalse(cb.IsEmpty);
Assert.IsTrue(readBuffer2.Take(7).SequenceEqual(buffer.Take(7)));
cb.Dispose();
cb = new CircularBuffer(16);
cb.Write(buffer, 0, buffer.Length);
byte[] readBuffer4 = new byte[9];
fixed(byte *src = readBuffer4)
{
Assert.AreEqual(9, cb.Read(src, readBuffer4.Length, 0));
}
Assert.AreEqual(0, cb.Count);
Assert.IsTrue(cb.IsEmpty);
cb.Write(buffer, 0, buffer.Length);
fixed(byte *src = readBuffer4)
{
Assert.AreEqual(9, cb.Peek(src, readBuffer4.Length, 0));
}
Assert.AreEqual(cb.Count, 9);
Assert.IsFalse(cb.IsEmpty);
cb.Dispose();
cb = new CircularBuffer(16);
cb.Write(buffer, 0, buffer.Length);
fixed(byte *src = readBuffer4)
{
Assert.AreEqual(9, cb.Read(src, readBuffer4.Length, 0));
}
Assert.AreEqual(0, cb.Count);
Assert.IsTrue(cb.IsEmpty);
cb.Write(buffer, 0, buffer.Length);
fixed(byte *src = readBuffer4)
{
Assert.AreEqual(1, cb.Peek(src, 1, 8));
}
Assert.AreEqual(9, cb.Count);
Assert.IsFalse(cb.IsEmpty);
Assert.IsTrue(readBuffer4.Take(1).SequenceEqual(buffer.Skip(8).Take(1)));
}
public void ReadWrite_NonSequentialReadWrite_HeaderIndexesCorrect()
{
string name = Guid.NewGuid().ToString();
Random r = new Random();
int bufSize = 1024;
byte[] data = new byte[bufSize];
byte[] readBuf = new byte[bufSize];
CircularBuffer.NodeHeader header;
// Fill with random data
r.NextBytes(data);
using (var smr = new CircularBuffer(name, 5, bufSize))
{
header = smr.ReadNodeHeader();
Assert.AreEqual(0, header.WriteStart, "Initial WriteStart");
Assert.AreEqual(0, header.WriteEnd, "Intial WriteEnd");
Assert.AreEqual(0, header.ReadStart, "Initial ReadStart");
Assert.AreEqual(0, header.ReadEnd, "Initial ReadEnd");
Assert.AreEqual(bufSize, smr.Write((ptr) =>
{
header = smr.ReadNodeHeader();
Assert.AreEqual(1, header.WriteStart, "During nested out of order write (1) WriteStart");
Assert.AreEqual(0, header.WriteEnd, "During nested out of order write (1) WriteEnd");
smr.Write((ptr2) =>
{
header = smr.ReadNodeHeader();
Assert.AreEqual(2, header.WriteStart, "During nested out of order write (2) WriteStart");
Assert.AreEqual(0, header.WriteEnd, "During nested out of order write (2) WriteEnd");
smr.Write((ptr3) =>
{
header = smr.ReadNodeHeader();
Assert.AreEqual(3, header.WriteStart, "During nested out of order write (3) WriteStart");
Assert.AreEqual(0, header.WriteEnd, "During nested out of order write (3) WriteEnd");
Marshal.Copy(data, 0, ptr3, bufSize);
return(bufSize);
});
header = smr.ReadNodeHeader();
Assert.AreEqual(0, header.WriteEnd, "After nested out of order write (3) WriteEnd");
Marshal.Copy(data, 0, ptr2, bufSize);
return(bufSize);
});
header = smr.ReadNodeHeader();
Assert.AreEqual(0, header.WriteEnd, "After nested out of order write (2) WriteEnd");
Marshal.Copy(data, 0, ptr, bufSize);
return(data.Length);
}), String.Format("Failed to write {0} bytes", bufSize));
header = smr.ReadNodeHeader();
Assert.AreEqual(3, header.WriteStart, "After nested out of order writes (1,2,3) WriteStart");
Assert.AreEqual(3, header.WriteEnd, "After nested out of order writes (1,2,3) WriteEnd");
Assert.AreEqual(bufSize, smr.Read((ptr) =>
{
header = smr.ReadNodeHeader();
Assert.AreEqual(1, header.ReadStart, "During nested out of order read (1) ReadStart");
Assert.AreEqual(0, header.ReadEnd, "During nested out of order read (1) ReadEnd");
smr.Read((ptr2) =>
{
header = smr.ReadNodeHeader();
Assert.AreEqual(2, header.ReadStart, "During nested out of order read (2) ReadStart");
Assert.AreEqual(0, header.ReadEnd, "During nested out of order read (2) ReadEnd");
smr.Read((ptr3) =>
{
header = smr.ReadNodeHeader();
Assert.AreEqual(3, header.ReadStart, "During nested out of order read (3) ReadStart");
Assert.AreEqual(0, header.ReadEnd, "During nested out of order read (3) ReadEnd");
Marshal.Copy(ptr3, readBuf, 0, smr.NodeBufferSize);
return(smr.NodeBufferSize);
});
header = smr.ReadNodeHeader();
Assert.AreEqual(0, header.ReadEnd, "After nested out of order read (3) ReadEnd");
Marshal.Copy(ptr2, readBuf, 0, smr.NodeBufferSize);
return(smr.NodeBufferSize);
});
header = smr.ReadNodeHeader();
Assert.AreEqual(0, header.ReadEnd, "After nested out of order read (2) ReadEnd");
Marshal.Copy(ptr, readBuf, 0, smr.NodeBufferSize);
return(smr.NodeBufferSize);
}), String.Format("Failed to read {0} bytes", bufSize));
header = smr.ReadNodeHeader();
Assert.AreEqual(3, header.ReadStart, "After nested out of order read (1,2,3) ReadStart");
Assert.AreEqual(3, header.ReadEnd, "After nested out of order read (1,2,3) ReadEnd");
}
}
public PacketParser(CircularBuffer buffer)
{
this.buffer = buffer;
}
internal Enumerator(CircularBuffer <T> circularBuffer, int maxSize)
{
this.Current = null;
this.circularBuffer = circularBuffer;
this.count = Math.Min(maxSize, circularBuffer.Count);
}
internal Enumerator(T item)
{
this.Current = item;
this.circularBuffer = null;
this.count = -1;
}
internal Batch(T item)
{
this.item = item ?? throw new ArgumentNullException(nameof(item));
this.circularBuffer = null;
this.maxSize = 1;
}
public void Reading_empty_buffer_should_fail()
{
var buffer = new CircularBuffer <int>(capacity: 1);
Assert.Throws <InvalidOperationException>(() => buffer.Read());
}
public MyByteBuffer(int maxSize, bool netOrder)
{
mMaxSize = maxSize;
mBuffer = new CircularBuffer <byte>(maxSize);
mNetOrder = netOrder;
}
public UARTBackend()
{
history = new CircularBuffer <byte>(BUFFER_SIZE);
}
public Property CircularBuffer_dequeue_after_enqueue_should_return_original_item(CircularBuffer <int> buffer,
int[] itemsToAdd)
{
for (var i = 0; i < itemsToAdd.Length; i++)
{
buffer.Enqueue(itemsToAdd[i]);
var dequeue = buffer.Dequeue();
if (dequeue != itemsToAdd[i])
{
return(false.When(buffer.Capacity > 0).Label($"Failed with {buffer}"));
}
}
return(true.ToProperty());
}
protected void SetSourceIdHistory(int count)
{
_previousSourceIds = new CircularBuffer <ISourceId>(count);
}
/// <summary>
/// Creates a new BlockAlignReductionStream
/// </summary>
/// <param name="sourceStream">the input stream</param>
public BlockAlignReductionStream(WaveStream sourceStream)
{
this.sourceStream = sourceStream;
circularBuffer = new CircularBuffer(sourceStream.WaveFormat.AverageBytesPerSecond * 4);
}
public void SafeReadTest_With_Overflow()
{
Random rnd = new Random(1337);
byte[] buffer = new byte[9];
rnd.NextBytes(buffer);
CircularBuffer cb = new CircularBuffer(16);
byte[] dummy = new byte[100];
Assert.AreEqual(0, cb.Read(dummy, 0, 78, 0));
cb.Write(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, cb.Read(dummy, 0, 78, 0));
cb.Dispose();
cb = new CircularBuffer(16);
cb.Write(buffer, 0, buffer.Length);
cb.Write(buffer, 0, buffer.Length);
Assert.AreEqual(cb.Count, 16);
byte[] readBuffer2 = new byte[9];
Assert.AreEqual(readBuffer2.Length, cb.Read(readBuffer2, 0, readBuffer2.Length, 0));
Assert.AreEqual(cb.Count, 16 - 9);
Assert.IsFalse(cb.IsEmpty);
Assert.IsTrue(readBuffer2.Take(9).SequenceEqual(buffer));
cb.Dispose();
cb = new CircularBuffer(16);
cb.Write(buffer, 0, buffer.Length);
byte[] readBuffer4 = new byte[9];
Assert.AreEqual(9, cb.Read(readBuffer4, 0, readBuffer4.Length, 0));
Assert.AreEqual(cb.Count, 0);
Assert.IsTrue(cb.IsEmpty);
cb.Write(buffer, 0, buffer.Length);
Assert.AreEqual(9, cb.Read(readBuffer4, 0, readBuffer4.Length, 0));
Assert.AreEqual(cb.Count, 0);
Assert.IsTrue(cb.IsEmpty);
cb.Dispose();
cb = new CircularBuffer(16);
cb.Write(buffer, 0, buffer.Length);
Assert.AreEqual(9, cb.Read(readBuffer4, 0, readBuffer4.Length, 0));
Assert.AreEqual(cb.Count, 0);
Assert.IsTrue(cb.IsEmpty);
cb.Write(buffer, 0, buffer.Length);
Assert.AreEqual(1, cb.Read(readBuffer4, 0, 1, 8));
Assert.AreEqual(cb.Count, 0);
Assert.IsTrue(cb.IsEmpty);
Assert.IsTrue(readBuffer4.Take(1).SequenceEqual(buffer.Skip(8).Take(1)));
}
public void GlobalSetup()
{
this.activity = this.CreateTestActivity();
this.activityBatch = new CircularBuffer <Activity>(this.NumberOfSpans);
}
public void UsageExample()
{
// Create a buffer with a capacity of 5 items.
var buffer = new CircularBuffer <long>(5);
// Add three.
foreach (var i in Enumerable.Range(1, 3))
{
buffer.Enqueue(i);
}
Debug.WriteLine(buffer);
// Capacity=5, Count=3, Buffer=[1,2,3]
// Add three more.
foreach (var i in Enumerable.Range(4, 3))
{
buffer.Enqueue(i);
}
Debug.WriteLine(buffer);
// Capacity=5, Count=5, Buffer=[2,3,4,5,6]
// Remove the third.
var value = buffer[3];
buffer.RemoveAt(3);
Debug.WriteLine(buffer);
// Capacity=5, Count=4, Buffer=[2,3,4,6]
// Re-insert it.
buffer.Insert(3, value);
Debug.WriteLine(buffer);
// Capacity=5, Count=5, Buffer=[2,3,4,5,6]
// Dequeue.
Debug.Print("Value = {0}", buffer.Dequeue());
// Value = 2
Debug.WriteLine(buffer);
// Capacity=5, Count=4, Buffer=[3,4,5,6]
// Increase the capacity.
buffer.Capacity = 6;
Debug.WriteLine(buffer);
// Capacity=6, Count=4, Buffer=[3,4,5,6]
// Add three more.
foreach (var i in Enumerable.Range(7, 3))
{
buffer.Enqueue(i);
}
Debug.WriteLine(buffer);
// Capacity=6, Count=6, Buffer=[4,5,6,7,8,9]
// Reduce the capacity.
buffer.Capacity = 4;
Debug.WriteLine(buffer);
// Capacity=4, Count=4, Buffer=[4,5,6,7]
// Clear the buffer.
buffer.Clear();
Debug.WriteLine(buffer);
// Capacity=4, Count=0, Buffer=[]
}
public void Decode(Stream input, Stream output)
{
var inputStartPosition = input.Position;
var buffer = new byte[4];
input.Read(buffer, 0, 4);
if (!buffer.SequenceEqual(new byte[] { 0x59, 0x61, 0x79, 0x30 }))
{
throw new InvalidCompressionException("Yay0" + (_byteOrder == ByteOrder.LittleEndian ? "LE" : "BE"));
}
input.Read(buffer, 0, 4);
var uncompressedLength = _byteOrder == ByteOrder.LittleEndian ? buffer.GetInt32LittleEndian(0) : buffer.GetInt32BigEndian(0);
input.Read(buffer, 0, 4);
var compressedTableOffset = _byteOrder == ByteOrder.LittleEndian ? buffer.GetInt32LittleEndian(0) : buffer.GetInt32BigEndian(0);
input.Read(buffer, 0, 4);
var uncompressedTableOffset = _byteOrder == ByteOrder.LittleEndian ? buffer.GetInt32LittleEndian(0) : buffer.GetInt32BigEndian(0);
_circularBuffer = new CircularBuffer(0x1000);
//var windowBuffer = new byte[0x1000];
//var windowBufferPosition = 0;
var compressedTablePosition = 0;
var uncompressedTablePosition = 0;
var bitLayout = new byte[compressedTableOffset - 0x10];
input.Read(bitLayout, 0, bitLayout.Length);
using (var bitReader = new BitReader(new MemoryStream(bitLayout), BitOrder.MsbFirst, 1, ByteOrder.BigEndian))
{
while (output.Length < uncompressedLength)
{
if (bitReader.ReadBit() == 1)
{
// Flag for uncompressed byte
input.Position = inputStartPosition + uncompressedTableOffset + uncompressedTablePosition++;
var value = (byte)input.ReadByte();
output.WriteByte(value);
_circularBuffer.WriteByte(value);
}
else
{
// Flag for compressed data
input.Position = inputStartPosition + compressedTableOffset + compressedTablePosition;
var firstByte = input.ReadByte();
var secondByte = input.ReadByte();
compressedTablePosition += 2;
var length = firstByte >> 4;
if (length > 0)
{
length += 2;
}
else
{
// Yes, we do read the length from the uncompressed data stream
input.Position = inputStartPosition + uncompressedTableOffset + uncompressedTablePosition++;
length = input.ReadByte() + 0x12;
}
var displacement = (((firstByte & 0xF) << 8) | secondByte) + 1;
_circularBuffer.Copy(output, displacement, length);
}
}
}
}
static void Main(string[] args)
{
var list = new CircularBuffer <int>(5);
var ilist = list as IList <int>;
Console.WriteLine("Adding 10 items");
for (var i = 0; i < 10; ++i)
{
list.PushBack(i + 1);
}
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Removing 1 item");
list.PopFront();
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
for (var i = 7; i >= 0; --i)
{
if (0 == i % 2)
{
Console.WriteLine("Removing 1 item");
ilist.RemoveAt(i);
}
}
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Removing 1 item");
list.PopBack();
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Adding 1 item");
list.PushBack(11);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Inserting 2 items");
list.PushFront(2);
list.PushFront(1);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Removing 1 item");
list.PopFront();
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Inserting 1 item");
ilist.Insert(2, 4);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Removing 4 items");
list.PopFront();
list.PopFront();
list.PopFront();
list.PopFront();
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Adding 4 items");
list.PushBack(12);
list.PushBack(13);
list.PushBack(15);
list.PushBack(16);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Inserting 1 item");
ilist.Insert(5, 14);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Inserting 1 item");
list.PushFront(8);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
Console.WriteLine("Capacity is " + list.Capacity);
Console.WriteLine("Trimming");
list.Trim();
Console.WriteLine("Capacity is " + list.Capacity);
Console.Write("Enumerating " + list.Count + " items:");
foreach (var item in list)
{
Console.Write(" " + item.ToString());
}
Console.WriteLine();
}
public static IEnumerable <string> ReadLines(this TextReader reader, string EOLDelimiter = null, char quoteChar = ChoCharEx.NUL, bool mayContainEOLInData = false, int maxLineSize = 32768)
{
ChoGuard.ArgumentNotNull(reader, "TextReader");
EOLDelimiter = EOLDelimiter ?? Environment.NewLine;
if (!mayContainEOLInData &&
(EOLDelimiter == Environment.NewLine ||
(EOLDelimiter.Length == 1 && EOLDelimiter[0] == '\r') ||
(EOLDelimiter.Length == 1 && EOLDelimiter[0] == '\n')
))
{
string line;
while ((line = reader.ReadLine()) != null)
{
yield return(line);
}
}
bool inQuote = false;
List <char> buffer = new List <char>();
CircularBuffer <char> delim_buffer = new CircularBuffer <char>(EOLDelimiter.Length);
while (reader.Peek() >= 0)
{
char c = (char)reader.Read();
delim_buffer.Enqueue(c);
if (quoteChar != ChoCharEx.NUL && quoteChar == c)
{
inQuote = !inQuote;
}
if (!inQuote)
{
if (delim_buffer.ToString() == EOLDelimiter)
{
if (buffer.Count > 0)
{
string x = new String(buffer.ToArray());
yield return(x.Substring(0, x.Length - (EOLDelimiter.Length - 1)));
buffer.Clear();
}
continue;
}
}
buffer.Add(c);
if (buffer.Count > maxLineSize)
{
throw new ApplicationException("Large line found. Check and correct the end of line delimiter.");
}
}
if (buffer.Count > 0)
{
yield return(new String(buffer.ToArray()));
}
else
{
yield break;
}
}
private unsafe void ReceiveAsyncCompleted(object sender, SocketAsyncEventArgs e)
{
if (e.SocketError != SocketError.Success)
{
InvokeClientDisconnect(e.AcceptSocket, DisconnectReason.Error);
return;
}
int length = e.BytesTransferred;
if (length <= 0)
{
InvokeClientDisconnect(e.AcceptSocket, DisconnectReason.Graceful);
return;
}
ServerClientStateObject state = (ServerClientStateObject)e.UserToken;
CircularBuffer circularBuffer = state.CircularBuffer;
int size = circularBuffer.Write(e.Buffer, 0, length);
while (circularBuffer.PeekHeader(
0, out byte packetHeader, out uint commandID, out int dataLength, out ushort checksum) &&
dataLength <= circularBuffer.Count - Constants.TCP_HEADER_SIZE)
{
if (circularBuffer.PeekByte((Constants.TCP_HEADER_SIZE + dataLength) - 1, out byte b) &&
b == Constants.ZERO_BYTE)
{
fixed(byte *ptr = state.BufferRead)
{
circularBuffer.Read(ptr, 0, dataLength, Constants.TCP_HEADER_SIZE);
if (size < length)
{
circularBuffer.Write(e.Buffer, size, length - size);
}
uint responseID = 0;
int offset = 0;
if ((packetHeader & Serialization.Serialization.RESPONSE_BIT_MASK) != 0)
{
responseID = *(uint *)ptr;
offset = 4;
}
CompressionMode compressionMode =
(CompressionMode)(packetHeader & Serialization.Serialization.COMPRESSED_MODE_MASK);
if (compressionMode != CompressionMode.None)
{
offset += 4;
}
byte[] deserializeBuffer = ByteArrayPool.Rent(dataLength);
if (Serialization.Serialization.S2E(
ptr, offset, dataLength - 1, deserializeBuffer, out int bufferLength) == checksum)
{
switch (compressionMode)
{
case CompressionMode.Lz4:
int l = *(int *)(ptr + offset);
byte[] buffer = ByteArrayPool.Rent(l);
int s = LZ4Codec.Decode(
deserializeBuffer, 0, bufferLength, buffer, 0, l, true);
if (s != l)
{
throw new Exception("LZ4.Decode FAILED!");
}
ByteArrayPool.Return(deserializeBuffer);
deserializeBuffer = buffer;
bufferLength = l;
break;
}
ReceiveAsync(e);
DeserializeData(e.AcceptSocket, commandID, deserializeBuffer, 0, bufferLength, responseID);
return;
}
break;
}
}
bool skipped = circularBuffer.SkipUntil(Constants.TCP_HEADER_SIZE, Constants.ZERO_BYTE);
if (size < length)
{
size += circularBuffer.Write(e.Buffer, size, length - size);
}
if (!skipped && !circularBuffer.SkipUntil(0, Constants.ZERO_BYTE))
{
break;
}
}
ReceiveAsync(e);
}
public void CircularBuffer_Front_CorrectItem()
{
var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3, 4 });
Assert.That(buffer.Front(), Is.EqualTo(0));
}
public void CircularBuffer_Back_CorrectItem()
{
var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3, 4 });
Assert.That(buffer.Back(), Is.EqualTo(4));
}
public void CircularBuffer_ToArrayConstructorDefinedArray_CorrectContent()
{
var buffer = new CircularBuffer <int>(5, new[] { 0, 1, 2, 3 });
Assert.That(buffer.ToArray(), Is.EqualTo(new[] { 0, 1, 2, 3 }));
}
public async Task HttpClient_ClientUsesAuxRecord_Ok()
{
var options = new HttpsTestServer.Options();
options.AllowedProtocols = SslProtocols.Tls;
using (var server = new HttpsTestServer(options))
using (HttpClientHandler handler = CreateHttpClientHandler())
using (HttpClient client = CreateHttpClient(handler))
{
handler.ServerCertificateCustomValidationCallback = TestHelper.AllowAllCertificates;
server.Start();
var tasks = new Task[2];
bool serverAuxRecordDetected = false;
bool serverAuxRecordDetectedInconclusive = false;
int serverTotalBytesReceived = 0;
int serverChunks = 0;
CircularBuffer buffer = new CircularBuffer(4);
tasks[0] = server.AcceptHttpsClientAsync((requestString) =>
{
buffer.Add(requestString);
serverTotalBytesReceived += requestString.Length;
if (serverTotalBytesReceived == 1 && serverChunks == 0)
{
serverAuxRecordDetected = true;
}
serverChunks++;
// Test is inconclusive if any non-CBC cipher is used:
if (server.Stream.CipherAlgorithm == CipherAlgorithmType.None ||
server.Stream.CipherAlgorithm == CipherAlgorithmType.Null ||
server.Stream.CipherAlgorithm == CipherAlgorithmType.Rc4)
{
serverAuxRecordDetectedInconclusive = true;
}
// Detect end of HTML request
if (buffer.Equals("\r\n\r\n"))
{
return(Task.FromResult(HttpsTestServer.Options.DefaultResponseString));
}
else
{
return(Task.FromResult <string>(null));
}
});
string requestUriString = "https://localhost:" + server.Port.ToString();
tasks[1] = client.GetStringAsync(requestUriString);
await tasks.WhenAllOrAnyFailed(15 * 1000);
if (serverAuxRecordDetectedInconclusive)
{
_output.WriteLine("Test inconclusive: The Operating system preferred a non-CBC or Null cipher.");
}
else
{
Assert.True(serverAuxRecordDetected, "Server reports: Client auxiliary record not detected.");
}
}
}
public void New_Buffer_Is_Empty()
{
var buffer = new CircularBuffer <double>();
Assert.IsTrue(buffer.IsEmpty);
}
