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 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);
}
private void GetHidReport(HidInputReportReceivedEventArgs args)
{
// For now there is only one data type
HidInputReport rpt = args.Report;
IBuffer buff = rpt.Data;
DataReader dr = DataReader.FromBuffer(buff);
byte[] bytes = new byte[rpt.Data.Length];
dr.ReadBytes(bytes);
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
try
{
// Have to remove a bonus byte on the payload
byte[] parsed = new byte[bytes.Length - 1];
for (int i = 0; i < parsed.Length; i++)
{
parsed[i] = bytes[i + 1];
}
packet.Serialize(parsed);
byte[] stream = new byte[packet.ExpectedLen + DataPacket.NumOverHeadBytes];
packet.SerializeToStream(stream, 0);
SetData(stream);
}
catch (ArgumentException e0)
{
LogMessage(e0.Message + e0.StackTrace);
}
catch (IndexOutOfRangeException e1)
{
LogMessage(e1.Message + e1.StackTrace);
}
}
public void Motus_1_PacketTestSerializeInvalidPayload()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
byte[] invalidBytePayload = new byte[12];
packet.Serialize(invalidBytePayload);
}
public static void Service()
{
client.ClientStartRead();
byte[] dataBytes = client.ClientGetRxData();
byte type = client.ClientGetRxType();
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
if (type == (byte)ValidPacketTypes.motus_1_raw_data_packet)
{
packet.Serialize(dataBytes);
short[] sData = packet.DeSerialize();
int[] data = new int[sData.Length];
for (int i = 0; i < data.Length; i++)
{
data[i] = (int)sData[i];
}
DataStorageTable.SetMotus_1_Data(data);
if (logRawData)
{
string msg = data[0].ToString();
for (int i = 1; i < data.Length; i++)
{
msg += "," + data[i].ToString();
}
Logger.LogMessage(msg);
}
}
}
public void DataQueue_TestAddPacket()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
Assert.IsTrue(queue.Add(packet));
Assert.IsFalse(queue.IsEmpty());
}
public void DataQueue_TestAddOverFlowProtection()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(sampleMotusPayload);
DataQueue queue = new DataQueue();
for (int i = 0; i < queue.MaxSize; i++)
{
Assert.IsTrue(queue.Add(packet));
}
Assert.IsFalse(queue.Add(packet));
}
public void DataQueue_TestFlush()
{
DataQueue queue = new DataQueue();
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
FillQueue(queue, packet);
Assert.IsFalse(queue.IsEmpty());
Assert.AreEqual(queue.Count, queue.MaxSize);
queue.Flush();
Assert.IsTrue(queue.IsEmpty());
Assert.AreEqual(queue.Count, 0);
}
public void DataQueue_TestTransferAllUnderFlow()
{
DataQueue queue1 = new DataQueue();
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
FillQueue(queue1, packet);
DataQueue queue2 = new DataQueue(128);
queue2.TransferAll(queue1);
Assert.IsTrue(queue1.IsEmpty());
Assert.IsFalse(queue2.IsEmpty());
Assert.AreEqual(queue2.Count, queue1.MaxSize);
}
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 Motus_1_PacketTestInvalidConstructor2()
{
byte[] invalidBytePayload = new byte[12];
DataPacket dPacket = new DataPacket(ValidPacketTypes.motus_1_raw_data_packet,
(short)invalidBytePayload.Length, invalidBytePayload);
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(dPacket);
Assert.AreEqual(ValidPacketTypes.motus_1_raw_data_packet, packet.Type);
Assert.AreEqual(18, packet.ExpectedLen);
DataPacket dPacket1 = new DataPacket(ValidPacketTypes.motus_1_raw_data_packet,
18, invalidBytePayload);
Motus_1_RawDataPacket packet1 = new Motus_1_RawDataPacket(dPacket1);
}
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]);
}
}
public void Motus_1_TestPacketToString()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
packet.Serialize(testBytePayload);
Int16[] intPayload = packet.DeSerialize();
string known = intPayload[0].ToString();
for (int i = 1; i < intPayload.Length; i++)
{
known += ",";
known += intPayload[i].ToString();
}
Assert.AreEqual(known, packet.ToString());
}
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 Motus_1_PacketTestSerializeBytes()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
packet.Serialize(testBytePayload);
byte[] rtnPayload = packet.Payload;
Int16[] rtnIntPayload = packet.DeSerialize();
Assert.AreEqual(packet.ExpectedLen, rtnPayload.Length);
Assert.AreEqual(packet.ExpectedLen / 2, rtnIntPayload.Length);
for (int i = 0; i < rtnPayload.Length; i++)
{
Assert.AreEqual(testBytePayload[i], rtnPayload[i]);
}
Int16[] known = new Int16[packet.ExpectedLen / 2];
Buffer.BlockCopy(packet.Payload, 0, known, 0, packet.ExpectedLen);
for (int i = 0; i < rtnIntPayload.Length; i++)
{
Assert.AreEqual(known[i], rtnIntPayload[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]);
}
}
}
public void Motus_1_PacketTestConstructor()
{
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket();
Motus_1_RawDataPacket packet1 = new Motus_1_RawDataPacket(testBytePayload);
DataPacket dPacket = new DataPacket(ValidPacketTypes.motus_1_raw_data_packet,
(short)testBytePayload.Length, testBytePayload);
Motus_1_RawDataPacket packet2 = new Motus_1_RawDataPacket(dPacket);
Assert.AreEqual(ValidPacketTypes.motus_1_raw_data_packet,
packet.Type);
Assert.AreEqual(18, packet.ExpectedLen);
Assert.AreEqual(ValidPacketTypes.motus_1_raw_data_packet,
packet1.Type);
Assert.AreEqual(18, packet1.ExpectedLen);
Assert.AreEqual(ValidPacketTypes.motus_1_raw_data_packet,
packet2.Type);
Assert.AreEqual(18, packet2.ExpectedLen);
for (int i = 0; i < testBytePayload.Length; i++)
{
Assert.AreEqual(testBytePayload[i], packet1.Payload[i]);
Assert.AreEqual(testBytePayload[i], packet2.Payload[i]);
}
}
public void Motus_1_PacketTestInvalidConstructor()
{
byte[] invalidBytePayload = new byte[12];
Motus_1_RawDataPacket packet = new Motus_1_RawDataPacket(invalidBytePayload);
}
