public void DataQueue_TestGetUnderFlowProtection()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
FillQueue(queue, packet);
int count;
for (count = 0; !queue.IsEmpty(); count++)
{
DataPacket getPacket = queue.Get();
Assert.AreEqual(packet.Type, getPacket.Type);
Assert.AreEqual(packet.ExpectedLen, getPacket.ExpectedLen);
for (int j = 0; j < packet.ExpectedLen; j++)
{
Assert.AreEqual(packet.Payload[j], getPacket.Payload[j]);
}
}
Assert.AreEqual(count, queue.MaxSize);
Assert.IsTrue(queue.IsEmpty());
DataPacket badPacket = queue.Get();
Assert.AreEqual(ValidPacketTypes.end_valid_packet_types, badPacket.Type);
Assert.AreEqual(-1, badPacket.ExpectedLen);
}
public void DataQueue_TestGarbageStreamParsing()
{
short length = 5;
byte[] streamWithGarbage = new byte[] { 0x45, 0x34, 0x00, 0x45, 0x34, 0x00,
DataPacket.Header1, 0x45, 0x34, 0x00, DataPacket.Header2,
DataPacket.Header1, DataPacket.Header2, (byte)ValidPacketTypes.test_packet, (byte)(length >> 8),
(byte)length, 0, 1, 2, 3, 4, 0x45, 0x34, 0x00, 0x45, 0x34, 0x00, 0x45, 0x34, 0x00, DataPacket.Header1,
DataPacket.Header1, DataPacket.Header2, (byte)ValidPacketTypes.test_packet, (byte)(length >> 8),
(byte)length, 0, 1, 2, 3, 4, };
DataQueue queue = new DataQueue();
queue.ParseStreamable(streamWithGarbage, streamWithGarbage.Length);
Assert.AreEqual(2, queue.Count);
DataPacket packet = queue.Get();
Assert.AreEqual(ValidPacketTypes.test_packet, packet.Type);
Assert.AreEqual(length, packet.ExpectedLen);
for (int i = 0; i < packet.ExpectedLen; i++)
{
Assert.AreEqual(i, packet.Payload[i]);
}
packet = queue.Get();
Assert.AreEqual(ValidPacketTypes.test_packet, packet.Type);
Assert.AreEqual(length, packet.ExpectedLen);
for (int i = 0; i < packet.ExpectedLen; i++)
{
Assert.AreEqual(i, packet.Payload[i]);
}
Assert.IsTrue(queue.IsEmpty());
}
public void DataQueue_TestGet()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
queue.Add(packet);
DataPacket getPacket = queue.Get();
Assert.AreEqual(packet.Type, getPacket.Type);
Assert.AreEqual(packet.ExpectedLen, getPacket.ExpectedLen);
for (int i = 0; i < packet.ExpectedLen; i++)
{
Assert.AreEqual(packet.Payload[i], getPacket.Payload[i]);
}
}
protected DataFrameGroup ProductDataGroup(string cmdKey)
{
IMatch cmdEndMatch = new CmdEndMatch();
DataFrameGroup dataFrameGroup = null;
while (true)
{
if (_DataRrameQueue.Count() <= 0)
{
_reciveARE.WaitOne();
}
DataItem <DataFrameStr> currentDataFrame = null;
lock (_lockObj)
{
currentDataFrame = _DataRrameQueue.Get(TimeSpan.FromSeconds(20));
if (currentDataFrame == null)
{
continue;
}
// IOHelper.WriteLine(currentDataFrame.Data.Context,ConsoleColor.Blue);
}
if (currentDataFrame != null && currentDataFrame.Data != null)
{
if (currentDataFrame.Data.Context == cmdKey && dataFrameGroup == null)
{
dataFrameGroup = new DataFrameGroup(cmdKey);
}
else
{
if (dataFrameGroup == null)
{
continue;
}
if (cmdEndMatch.Match(currentDataFrame.Data.Context))
{
//this is frameend
break;
}
else
{
dataFrameGroup.Add(currentDataFrame.Data);
}
}
}
}
return(dataFrameGroup);
}
public void SocketWrapper_TestEndToEnd()
{
SocketWrapper server = new SocketWrapper(Configuration.server);
SocketWrapper client = new SocketWrapper(Configuration.client);
DataQueue knownData = new DataQueue();
DataQueue toSend = new DataQueue();
DataQueue toRecieve = new DataQueue();
short[] known = new short[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
byte[] payload = new byte[known.Length * 2];
Buffer.BlockCopy(known, 0, payload, 0, payload.Length);
Motus_1_RawDataPacket dummyPacket = new Motus_1_RawDataPacket(payload);
for (int i = 0; i < knownData.MaxSize; i++)
{
knownData.Add(dummyPacket);
toSend.Add(dummyPacket);
}
server.StartServer();
server.ServerSetTxData(toSend);
Assert.IsTrue(toSend.IsEmpty());
client.ClientStartRead();
Thread.Sleep(1000);
Assert.IsTrue(client.ClientHasData());
client.ClientGetRxData(toRecieve);
Assert.AreEqual(toRecieve.Count, toRecieve.MaxSize);
while (!toRecieve.IsEmpty())
{
Motus_1_RawDataPacket packetKnown = new Motus_1_RawDataPacket(knownData.Get());
Motus_1_RawDataPacket packetTest = new Motus_1_RawDataPacket(toRecieve.Get());
short[] payloadKnown = packetKnown.DeSerialize();
short[] payloadTest = packetTest.DeSerialize();
for (int i = 0; i < payloadKnown.Length; i++)
{
Assert.AreEqual(known[i], payloadKnown[i]);
Assert.AreEqual(payloadKnown[i], payloadTest[i]);
}
}
}
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]);
}
}
}
