public void TestHeaderToLength()
{
var header = new byte[] { 1, 32, 3 };
long expectedLength = 256 * 256 * 1 + 32 * 256 + 3;
var length = DataProcessorUtil.HeaderToLength(header);
Assert.AreEqual(expectedLength, length);
}
public void TestHeaderSizeFromLengthZero()
{
long size = 0;
byte[] headerExpected = new byte[] { 0 };
var heeader = DataProcessorUtil.LengthToHeader(size, 1);
Assert.IsTrue(headerExpected.SequenceEqual(heeader));
}
public void TestHeaderSizeFromLengthPad()
{
long size = 224 + (2 * 256) + (3 * 256 * 256) + (4 * 256 * 256 * 256);
byte[] headerExpected = new byte[] { 0, 0, 4, 3, 2, 224 };
var heeader = DataProcessorUtil.LengthToHeader(size, 6);
Assert.IsTrue(headerExpected.SequenceEqual(heeader));
}
/// <summary>
/// Filter send data
/// </summary>
/// <param name="msg"></param>
/// <returns></returns>
public byte[] FilterSendData(byte[] msg)
{
// length check
if (msg.Length > MaxSize)
{
_logger.LogError("Message is too long.");
return(null);
}
// set length header
var header = DataProcessorUtil.LengthToHeader(msg.Length, _headerSize);
var ret = new byte[msg.Length + 1 + _headerSize];
ret[0] = 0;
Buffer.BlockCopy(header, 0, ret, 1, _headerSize);
Buffer.BlockCopy(msg, 0, ret, 1 + _headerSize, msg.Length);
return(ret);
}
/// <summary>
/// Process buffer
/// </summary>
/// <param name="recieved"></param>
/// <param name="length"></param>
/// <returns></returns>
public IEnumerable <byte[]> ProcessReceivedRawData(byte[] recieved, int length)
{
// check package length
if (length > _buffer.Length)
{
_logger.LogError("Recieved is too long.");
return(null);
}
// check buffer lenght
else if (_bufferLength + length > _buffer.Length)
{
_logger.LogError("Buffer overdraw. Deleting buffer.");
_bufferLength = 0;
return(null);
}
// copy message to buffer
Buffer.BlockCopy(recieved, 0, _buffer, _bufferLength, length);
_bufferLength = _bufferLength + length;
// find starts of messages
var starts = _buffer.FindOccurrences(_delimiter, _bufferLength, ContainerSize);
if (!starts.Any())
{
return(new List <byte[]>());
}
// get intervals
var intervals = starts.Where(pos => _bufferLength >= pos + ContainerSize &&
_bufferLength >= pos + ContainerSize + DataProcessorUtil.HeaderToLength(_buffer.Slice(pos + 1, _headerSize))).
Select(pos => new Tuple <int, int>(pos + ContainerSize,
(int)DataProcessorUtil.HeaderToLength(_buffer.Slice(pos + 1, _headerSize)))).
ToArray();
// no intervals found
if (!intervals.Any())
{
return(new List <byte[]>());
}
// fix intervals to not overlap
intervals = Enumerable.Range(0, intervals.Length).Select(i => {
var cur = intervals[i];
if (i + 1 >= intervals.Length)
{
return(cur);
}
var next = intervals[i + 1];
var endPos = cur.Item1 + cur.Item2 - 1;
if (endPos >= next.Item1)
{
_logger.LogError("Overlapping messages");
return(new Tuple <int, int>(cur.Item1, next.Item1 - cur.Item1));
}
return(cur);
}).ToArray();
// get messages
var msgs = _buffer.SliceMulti(intervals);
// move buffer
var start = intervals.Last().Item1 + intervals.Last().Item2 + 1;
if (start >= _bufferLength)
{
_bufferLength = 0;
}
else
{
var len = _bufferLength - start;
_bufferLength = _buffer.ReplaceWith(_buffer, start, 0, len);
}
// return
return(msgs);
}
public void TestHeaderSizeZeroRequiresOneByteForLength()
{
long length = 0;
Assert.ThrowsException <ArgumentException>(() => DataProcessorUtil.LengthToHeader(length, 0));
}
public void TestHeaderSizeTooSmall()
{
long length = 256 * 256;
Assert.ThrowsException <ArgumentException>(() => DataProcessorUtil.LengthToHeader(length, 1));
}
public void TestHeadertoLengthTooBigHeader()
{
var header = Enumerable.Range(0, 2000).Select(i => (byte)1).ToArray();
Assert.ThrowsException <ArgumentException>(() => DataProcessorUtil.HeaderToLength(header));
}
