public void DataQueue_TestGetStreamable()
{
byte[] stream = new byte[2048];
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
int expectedNumBytesToQueue = ((18 + DataPacket.NumOverHeadBytes) * queue.MaxSize);
FillQueue(queue, packet);
int numBytesQueued = queue.GetStreamable(stream);
Assert.AreEqual(expectedNumBytesToQueue, numBytesQueued);
Assert.IsTrue(queue.IsEmpty());
for (int i = 0; i < numBytesQueued;)
{
DataPacket rebuilt = new DataPacket();
i += rebuilt.SerializeFromStream(stream, i);
Assert.AreEqual(packet.Type, rebuilt.Type);
Assert.AreEqual(packet.ExpectedLen, rebuilt.ExpectedLen);
for (int j = 0; j < rebuilt.ExpectedLen; j++)
{
Assert.AreEqual(packet.Payload[j], rebuilt.Payload[j]);
}
}
}
public byte[] GetData()
{
byte[] data = new byte[2048];
int len = 0;
lock (_lock) { len = _queue.GetStreamable(data); }
byte[] rtn = new byte[len];
Buffer.BlockCopy(data, 0, rtn, 0, len);
return(rtn);
}
public void DataQueue_TestGetStreamableBufferOverflow()
{
byte[] stream = new byte[1028];
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
int expectedNumPacketsToQueue = (stream.Length / (18 + DataPacket.NumOverHeadBytes));
int expectedNumBytesToQueue = (18 + DataPacket.NumOverHeadBytes) * expectedNumPacketsToQueue;
FillQueue(queue, packet);
int numBytesQueued = queue.GetStreamable(stream);
int numPacketsQueued = queue.MaxSize - queue.Count;
Assert.AreEqual(expectedNumBytesToQueue, numBytesQueued);
Assert.AreEqual(expectedNumPacketsToQueue, numPacketsQueued);
}
public void DataQueue_TestParseStreamable()
{
byte[] stream = new byte[2048];
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
FillQueue(queue, packet);
int numBytesQueued = queue.GetStreamable(stream);
FillQueue(queue, packet);
DataQueue queue2 = new DataQueue();
queue2.ParseStreamable(stream, stream.Length);
while (!queue2.IsEmpty() && !queue.IsEmpty())
{
DataPacket packet1 = queue.Get();
DataPacket packet2 = queue2.Get();
// Ensure packet1 is the same as packet
Assert.AreEqual(packet.Type, packet1.Type);
Assert.AreEqual(packet.ExpectedLen, packet1.ExpectedLen);
for (int j = 0; j < packet1.ExpectedLen; j++)
{
Assert.AreEqual(packet.Payload[j], packet1.Payload[j]);
}
// Ensure packet2 is the same as packet1
Assert.AreEqual(packet1.Type, packet2.Type);
Assert.AreEqual(packet1.ExpectedLen, packet2.ExpectedLen);
for (int j = 0; j < packet2.ExpectedLen; j++)
{
Assert.AreEqual(packet1.Payload[j], packet2.Payload[j]);
}
}
}
private void Send(Socket handler)
{
try
{
lock (_lock)
{
_numBytesToSend = _queue.GetStreamable(_dataToSend);
}
handler.BeginSend(_dataToSend, 0, _numBytesToSend, 0, new AsyncCallback(SendCB), handler);
}
catch (ArgumentNullException e0)
{
string msg = e0.Message + e0.StackTrace;
LogMessage(msg);
}
catch (ArgumentOutOfRangeException e1)
{
string msg = e1.Message + e1.StackTrace;
LogMessage(msg);
}
catch (SocketException e2)
{
string msg = e2.Message + e2.StackTrace;
LogMessage(msg);
}
catch (ObjectDisposedException e3)
{
string msg = e3.Message + e3.StackTrace;
LogMessage(msg);
}
catch (Exception e4)
{
string msg = e4.Message + e4.StackTrace;
LogMessage(msg);
}
}
