public virtual void TestReadShortEndianness()
{
var read = _input.ReadShort(Endianness.LittleEndian);
var val = BytesExtensions.ReadShort(InitData, 0, Endianness.LittleEndian);
Assert.AreEqual(val, read);
}
public void ReadIntSequence()
{
var bytes = new byte[] { 0 };
var sequence = new ReadOnlySequence <byte>(bytes);
Assert.Throws <ArgumentException>(() => _ = BytesExtensions.ReadInt(ref sequence));
bytes = new byte[] { 7, 91, 205, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
sequence = new ReadOnlySequence <byte>(bytes);
Assert.That(BytesExtensions.ReadInt(ref sequence), Is.EqualTo(123456789));
Assert.That(sequence.Length, Is.EqualTo(12));
bytes = new byte[] { 21, 205, 91, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
sequence = new ReadOnlySequence <byte>(bytes);
Assert.That(BytesExtensions.ReadInt(ref sequence, Endianness.LittleEndian), Is.EqualTo(123456789));
Assert.That(sequence.Length, Is.EqualTo(12));
var bytes1 = new byte[] { 7, 91 };
var bytes2 = new byte[] { 205, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
var firstSegment = new MemorySegment <byte>(bytes1);
var lastSegment = firstSegment.Append(bytes2);
sequence = new ReadOnlySequence <byte>(firstSegment, 0, lastSegment, lastSegment.Memory.Length);
Assert.That(BytesExtensions.ReadInt(ref sequence), Is.EqualTo(123456789));
Assert.That(sequence.Length, Is.EqualTo(12));
}
public virtual void TestReadLongForPositionEndianness()
{
var readLong = _input.ReadLong(2, Endianness.LittleEndian);
var longB = BytesExtensions.ReadLongL(InitData, 2);
Assert.AreEqual(longB, readLong);
}
public virtual void TestReadIntPosition()
{
var readInt = _input.ReadInt(2);
var theInt = BytesExtensions.ReadInt(InitData, 2, Endianness.BigEndian);
Assert.AreEqual(theInt, readInt);
}
public virtual void TestReadLongPosition()
{
var readLong = _input.ReadLong(2);
var longB = BytesExtensions.ReadLong(InitData, 2, Endianness.BigEndian);
Assert.AreEqual(longB, readLong);
}
public void ReadUShortSequence()
{
var bytes = new byte[] { 0 };
var sequence = new ReadOnlySequence <byte>(bytes);
Assert.Throws <ArgumentException>(() => _ = BytesExtensions.ReadUShort(ref sequence, Endianness.BigEndian));
bytes = new byte[] { 48, 57, 0, 0, 0 };
sequence = new ReadOnlySequence <byte>(bytes);
Assert.That(BytesExtensions.ReadUShort(ref sequence, Endianness.BigEndian), Is.EqualTo(12345));
Assert.That(sequence.Length, Is.EqualTo(3));
bytes = new byte[] { 57, 48, 0, 0, 0 };
sequence = new ReadOnlySequence <byte>(bytes);
Assert.That(BytesExtensions.ReadUShort(ref sequence, Endianness.LittleEndian), Is.EqualTo(12345));
Assert.That(sequence.Length, Is.EqualTo(3));
var bytes1 = new byte[] { 48 };
var bytes2 = new byte[] { 57, 0, 0, 0 };
var firstSegment = new MemorySegment <byte>(bytes1);
var lastSegment = firstSegment.Append(bytes2);
sequence = new ReadOnlySequence <byte>(firstSegment, 0, lastSegment, lastSegment.Memory.Length);
Assert.That(BytesExtensions.ReadUShort(ref sequence, Endianness.BigEndian), Is.EqualTo(12345));
Assert.That(sequence.Length, Is.EqualTo(3));
}
public virtual void TestReadIntForPositionEndianness()
{
var readInt = _input.ReadInt(3, Endianness.LittleEndian);
var theInt = BytesExtensions.ReadIntL(InitData, 3);
Assert.AreEqual(theInt, readInt);
}
public virtual void TestReadShortPosition()
{
var read = _input.ReadShort(1);
var val = BytesExtensions.ReadShort(InitData, 1, Endianness.BigEndian);
Assert.AreEqual(val, read);
}
public virtual void TestReadFloatPosition()
{
double readFloat = _input.ReadFloat(2);
var intB = BytesExtensions.ReadInt(InitData, 2, Endianness.BigEndian);
double aFloat = BitConverter.ToSingle(BitConverter.GetBytes(intB), 0);
Assert.AreEqual(aFloat, readFloat, 0);
}
public virtual void TestReadFloatEndianness()
{
double readFloat = _input.ReadFloat(Endianness.LittleEndian);
var intB = BytesExtensions.ReadIntL(InitData, 0);
double aFloat = BitConverter.ToSingle(BitConverter.GetBytes(intB), 0);
Assert.AreEqual(aFloat, readFloat, 0);
}
public virtual void TestReadDoublePosition()
{
var readDouble = _input.ReadDouble(2);
var longB = BytesExtensions.ReadLong(InitData, 2, Endianness.BigEndian);
var aDouble = BitConverter.Int64BitsToDouble(longB);
Assert.AreEqual(aDouble, readDouble, 0);
}
public virtual void TestWriteIntBigEndian()
{
var expected = 100;
_output.WriteIntBigEndian(expected);
var actual = BytesExtensions.ReadInt(_output.Buffer, 0);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteIntForVEndianness()
{
var expected = 100;
_output.Write(expected, Endianness.LittleEndian);
var actual = BytesExtensions.ReadIntL(_output.Buffer, 0);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteLongForVEndianness()
{
long expected = 100;
_output.Write(2, expected, Endianness.LittleEndian);
var actual = BytesExtensions.ReadLongL(_output.Buffer, 2);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteIntForPositionV()
{
var expected = 100;
_output.Write(1, expected);
var actual = BytesExtensions.ReadInt(_output.Buffer, 1, Endianness.BigEndian);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteShortForVEndianness()
{
short expected = 100;
_output.Write(2, expected, Endianness.LittleEndian);
var actual = BytesExtensions.ReadShort(_output.Buffer, 2, Endianness.LittleEndian);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteShortV()
{
short expected = 100;
_output.Write(expected);
var actual = BytesExtensions.ReadShort(_output.Buffer, 0, Endianness.BigEndian);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteLongForPositionV()
{
long expected = 100;
_output.Write(2, expected);
var actual = BytesExtensions.ReadLong(_output.Buffer, 2, Endianness.BigEndian);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteFloatForPositionVEndianness()
{
var v = 1.1f;
_output.Write(1, v, Endianness.LittleEndian);
var expected = BitConverter.ToInt32(BitConverter.GetBytes(v), 0);
var actual = BytesExtensions.ReadIntL(_output.Buffer, 1);
Assert.AreEqual(actual, expected);
}
public virtual void TestWriteDoubleForVEndianness()
{
var v = 1.1d;
_output.Write(v, Endianness.LittleEndian);
var theLong = BitConverter.DoubleToInt64Bits(v);
var readLongB = BytesExtensions.ReadLongL(_output.Buffer, 0);
Assert.AreEqual(theLong, readLongB);
}
public virtual void TestWriteDoubleForPositionV()
{
var v = 1.1d;
_output.Write(1, v);
var theLong = BitConverter.DoubleToInt64Bits(v);
var readLongB = BytesExtensions.ReadLong(_output.Buffer, 1, Endianness.BigEndian);
Assert.AreEqual(theLong, readLongB);
}
public virtual void TestWriteFloatV()
{
var v = 1.1f;
_output.Write(v);
var expected = BitConverter.ToInt32(BitConverter.GetBytes(v), 0);
var actual = BytesExtensions.ReadInt(_output.Buffer, 0, Endianness.BigEndian);
Assert.AreEqual(actual, expected);
}
public void Sequences1()
{
const int origin = 1234;
var bytes = new byte[4];
bytes.WriteInt(0, origin, Endianness.BigEndian);
var buffer = new ReadOnlySequence <byte>(bytes);
var value = BytesExtensions.ReadInt(ref buffer, Endianness.BigEndian);
NUnit.Framework.Assert.AreEqual(origin, value);
}
private void ParseBody(byte[] data)
{
this.UnprocessedData = new byte[] { };
if (StartBoundary == "--") //isEmpty = > singlepart
{
this._bodyBytes = data;
}
else //multipart
{
var crlf = DefaultEncoding.GetBytes(CRLF);
int index = 0;
byte[] stringBytes;
//чтение собственного текста
{
int nextIndex = index;
while (readLine(data, ref nextIndex, out stringBytes))
{
if (stringBytes.ValueEquals(this.StartBoundaryBytes1) || stringBytes.ValueEquals(this.EndBoundaryBytes))
{
this._bodyBytes = data.GetSubArray(0, index);
break;
}
index = nextIndex;
}
index = nextIndex;
}
//достигнут конец данных
if (stringBytes == null || stringBytes.ValueEquals(this.EndBoundaryBytes))
{
return;
}
int endIndex = BytesExtensions.IndexOf(data, this.EndBoundaryBytes, index);
if (endIndex == -1)
{
endIndex = data.Length;
}
while (index < endIndex)
{
int nextIndex = BytesExtensions.IndexOf(data, this.StartBoundaryBytes1, index);
if (nextIndex == -1)
{
nextIndex = data.Length + crlf.Length;
}
var childData = data.GetSubArray(index, nextIndex - index - crlf.Length);
var child = createMimeReader(this, childData);
this.Children.Add(child);
index = nextIndex + this.StartBoundaryBytes1.Length + crlf.Length;
}
}
}
/// <summary>
/// Get a linenumber
/// </summary>
/// <param name="PCode">Source bytes</param>
/// <param name="offset">position</param>
/// <returns></returns>
private static string GetLineNumber(byte[] PCode, ref int offset)
{
string result = "";
offset++; //1 byte = TOKEN {1}
short LineNumber = BytesExtensions.ToInt16(PCode, ref offset);
result += LineNumber.ToString(); //LINE NUMBER, 2 Bytes
//Populate a list of offsets of every linenumbers
JumpLines.Add(new EditorJumpInfo(JumpType.GOTO, (int)LineNumber, offset - 3));
return(result);
}
/// <summary>
/// Decode a ProgramCode Into Plain Text
/// </summary>
/// <param name="PCode">Byte array (encoded program)</param>
static public string DecodeBytes(byte[] PCode)
{
byte[] prgsize = new byte[2];
string result = "";
Array.Copy(PCode, 0, prgsize, 0, 2);
int ProgLenght = BytesExtensions.ToInt16(prgsize);
int offset; //offset after count of total encoded bytes
bool isFirstToken = true;
offset = 2;
while (offset <= ProgLenght)
{
var tokenvalue = (byte)PCode[offset];
switch (tokenvalue)
{
//linenumbers
case (byte)TYPE_TOKEN.NUMBER:
if (isFirstToken)
{
offset++;
short LineNumber = BytesExtensions.ToInt16(PCode, ref offset);
result += LineNumber.ToString(); //LINE NUMBER, 2 Bytes
}
isFirstToken = false;
break;
//comments
case (byte)LINE_TOKEN.REM:
result += " " + GetComment(PCode, ref offset) + System.Environment.NewLine;
isFirstToken = true;
break;
//assigments
case (byte)LINE_TOKEN.ASSIGN:
result += " " + GetAssigment(PCode, ref offset) + System.Environment.NewLine;
isFirstToken = true;
break;
default:
offset++; //TODO: This line only for debugging purposes
break;
}
}
return(result);
}
public virtual void TestReadFloat()
{
// expected 9.2557164867118492E-41 which is what the original code reads
// now we read 66051.0d? -- but ReadInt *does* return 66051 on original code, how can that become? meh?
// so our reading of the int is ok, our conversion to aFloat is ok
// but our reading (and writing?) of a float is not?
double readFloat = _input.ReadFloat();
var intB = BytesExtensions.ReadInt(InitData, 0, Endianness.BigEndian);
double aFloat = BitConverter.ToSingle(BitConverter.GetBytes(intB), 0);
Assert.AreEqual(aFloat, readFloat, 0);
}
public void CouldSerializeManySortedMaps()
{
var sw = new Stopwatch();
sw.Start();
SortedMap <DateTime, double> sortedMap = new SortedMap <DateTime, double>();
byte[] bytes = null;
var rng = new System.Random();
for (int i = 0; i < 1000; i++)
{
sortedMap.Add(DateTime.UtcNow.Date.AddSeconds(i), Math.Round(i + rng.NextDouble(), 2));
bytes = Serializer.Serialize(sortedMap);
var sortedMap2 = Serializer.Deserialize <SortedMap <DateTime, double> >(bytes);
Assert.AreEqual(sortedMap.Count, sortedMap2.Count);
unsafe
{
fixed(DateTime *ptr1 = &sortedMap.keys[0])
fixed(DateTime * ptr2 = &sortedMap2.keys[0])
{
Assert.IsTrue(BytesExtensions.UnsafeCompare((IntPtr)ptr1, (IntPtr)ptr2, sortedMap.keys.Length * 8));
}
fixed(double *ptr1 = &sortedMap.values[0])
fixed(double *ptr2 = &sortedMap2.values[0])
{
Assert.IsTrue(BytesExtensions.UnsafeCompare((IntPtr)ptr1, (IntPtr)ptr2, sortedMap.size * 8));
}
}
//Assert.IsTrue(sortedMap.Keys.SequenceEqual(sortedMap2.Keys));
//Assert.IsTrue(sortedMap.Values.SequenceEqual(sortedMap2.Values));
}
sw.Stop();
Console.WriteLine("Elapsed msecs: " + sw.ElapsedMilliseconds);
Console.WriteLine("Uncompressed size: 16000");
Console.WriteLine("Compressed size: " + bytes.Length);
}
private byte[] ParseHeaders(byte[] data)
{
var crlf = DefaultEncoding.GetBytes(CRLF);
var endOfHeader = false;
var currentHeader = "";
int index = 0;
while (index < data.Length && !endOfHeader)
{
int lineBreakIndex = BytesExtensions.IndexOf(data, crlf, index);
var breakFound = (lineBreakIndex != -1);
if (!breakFound)
{
lineBreakIndex = data.Length;
}
int subStringLength = lineBreakIndex - index;
var headerLineBytes = new byte[subStringLength];
Array.Copy(data, index, headerLineBytes, 0, subStringLength);
var line = DefaultEncoding.GetString(headerLineBytes);
processHeaderLine(ref currentHeader, line, ref endOfHeader);
index = lineBreakIndex;
if (breakFound)
{
index += crlf.Length;
}
}
this._headerBytes = new byte[index];
Array.Copy(data, this._headerBytes, index);
processCommonHeaderAttribs();
return(getUnprocessedData(data, index));
}
private bool readLine(byte[] data, ref int index, out byte[] stringBytes)
{
if (index >= data.Length)
{
stringBytes = null;
return(false);
}
else
{
var crlf = DefaultEncoding.GetBytes(CRLF);
var crlfIndex = BytesExtensions.IndexOf(data, crlf, index);
if (crlfIndex == -1)
{
stringBytes = data.GetSubArrayStartingAt(index);
index = data.Length;
}
else
{
stringBytes = data.GetSubArray(index, crlfIndex - index);
index = crlfIndex + crlf.Length;
}
return(true);
}
}