public void CorrectPoolingTest()
{
var pool = new ByteBufferPool();
var buf = pool.Get(5);
pool.Return(buf);
Assert.AreEqual(1, pool.FreeAmount);
var buf2 = pool.Get(4);
pool.Return(buf2);
Assert.AreEqual(1, pool.FreeAmount);
// ByteBufferPool removes a buffer when none of the buffers in the pool
// is large enough to satisfy a Get, and it has at least 1 buffer in the pool.
// This way the number of items in the pool does not grow beyond the number
// of buffers that are in use simultaneously, lowering overall memory usage.
// the following Get should remove the size 5 buffer from the pool because it is not in use
var buf3 = pool.Get(6);
pool.Return(buf3);
Assert.AreEqual(1, pool.FreeAmount);
buf3 = pool.Get(6);
var buf4 = pool.Get(5);
pool.Return(buf4);
pool.Return(buf3);
Assert.AreEqual(2, pool.FreeAmount);
}
public void SendReliableFragmented()
{
_sock.MaxPayload = 3;
Utils.SendConnectRequest(_bareSock, _remoteEndPoint, _bufferPool);
var receivedPacket = new ReceivedSmartPacket();
Assert.IsFalse(_sock.Receive(ref receivedPacket));
var ms = new MemoryStream();
ms.Write(BitConverter.GetBytes((ushort)12345), 0, 2);
ms.Write(new byte[] { 77 }, 0, 1);
ms.Write(BitConverter.GetBytes((ushort)23456), 0, 2);
var buffer = ms.ToArray();
_sock.Send(_remoteEndPoint, buffer, 0, buffer.Length, true);
Assert.AreEqual(3, _bareSock.Sends.Count); // 2 for payload + connect response
var packetToSend = _bareSock.Sends[1];
var header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(_sock.MaxPayload + header.HeaderLength, header.Length);
Assert.AreEqual(12345, BitConverter.ToInt16(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(0, header.SeqNum);
Assert.IsTrue(header.GetNeedAck());
Assert.IsFalse(packetToSend.PutBufferToPool, "Reliable packets should wait for Ack before going to pool");
packetToSend = _bareSock.Sends[2];
header = new PacketHeader();
header.Init(packetToSend.Buffer, packetToSend.Offset);
Assert.AreEqual(buffer.Length - _sock.MaxPayload + header.HeaderLength, header.Length);
Assert.AreEqual(23456, BitConverter.ToInt16(packetToSend.Buffer, header.HeaderLength));
Assert.AreEqual(1, header.SeqNum);
Assert.IsTrue(header.GetNeedAck());
Assert.IsFalse(packetToSend.PutBufferToPool, "Reliable packets should wait for Ack before going to pool");
// Ack buffers
var header1 = new PacketHeader();
header1.AddAck(0);
header1.AddAck(1);
header1.SetSeqNum(1);
header1.Length = (ushort)header1.HeaderLength;
var buffer1 = _bufferPool.Get(header1.Length);
header1.WriteTo(buffer1, 0);
_bareSock.FakeReceive(buffer1, 0, header1.Length, _remoteEndPoint);
var receivedPackets = Utils.ReceiveAll(_sock);
}
private ArraySegment <byte> CreateFirstFragment()
{
var header = new PacketHeader();
header.SetSeqNum(100);
header.SetFrag(3, 0, 2);
header.Length = (ushort)(header.HeaderLength + 3);
var buffer = _bufferPool.Get(header.Length);
header.WriteTo(buffer, 0);
Array.Copy(BitConverter.GetBytes((ushort)12345), 0, buffer, header.HeaderLength, 2);
buffer[header.HeaderLength + 2] = 77;
return(new ArraySegment <byte>(buffer, 0, header.Length));
}
public void CorrectPoolingTest()
{
var pool = new ByteBufferPool();
var buf = pool.Get(5);
pool.Return(buf);
Assert.AreEqual(1, pool.FreeAmount);
var buf2 = pool.Get(4);
pool.Return(buf2);
Assert.AreEqual(1, pool.FreeAmount);
var buf3 = pool.Get(6);
pool.Return(buf3);
Assert.AreEqual(2, pool.FreeAmount);
}
private void PlatformSubmitBuffer(byte[] buffer, int offset, int count)
{
// we need to copy so datastream does not pin the buffer that the user might modify later
byte[] pooledBuffer;
pooledBuffer = _bufferPool.Get(count);
_pooledBuffers.Enqueue(pooledBuffer);
Buffer.BlockCopy(buffer, offset, pooledBuffer, 0, count);
var stream = DataStream.Create(pooledBuffer, true, false, 0, true);
var audioBuffer = new AudioBuffer(stream);
audioBuffer.AudioBytes = count;
_voice.SubmitSourceBuffer(audioBuffer, null);
_queuedBuffers.Enqueue(audioBuffer);
}
