public void ResetSet()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >(8);
writer.i32(666);
var bitsWritten = writer.BitsWritten;
var bitsAvailable = writer.BitsAvailable;
writer.Reset();
Assert.AreEqual(0, writer.BitsWritten);
writer.i32(666);
Assert.AreEqual(bitsWritten, writer.BitsWritten);
Assert.AreEqual(bitsAvailable, writer.BitsAvailable);
writer.i32(-273);
writer.b(true);
writer.i64(1234567890);
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(writer.ToArray());
Assert.AreEqual(666, reader.i32());
var bitsRead = reader.BitsRead;
reader.i32();
reader.SetPosition(bitsRead);
Assert.AreEqual(-273, reader.i32());
var bitPosition = reader.BitsRead;
reader.b();
reader.SetPosition(bitPosition);
Assert.True(reader.b());
}
public void i32WriteOutOfRange()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
Assert.Throws <ArgumentOutOfRangeException>(() => writer.i32(12345, 0, 123));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.i32(-12345, 0, 123));
Assert.Throws <ArgumentException>(() => writer.i32(-12345, 2));
Assert.Throws <ArgumentException>(() => writer.i32(444, 666, 123));
}
public void IntZeroMaxValue4()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i32(int.MaxValue, 0, int.MaxValue);
writer.i32(int.MaxValue, 0, int.MaxValue);
writer.i32(int.MaxValue, 0, int.MaxValue);
writer.i32(int.MaxValue, 0, int.MaxValue);
Assert.AreEqual(16, writer.LengthWritten);
}
public void RandomManyTimes()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
var random = new Random(42);
for (var i = 0; i < i16.MaxValue; i++)
{
for (var j = 0; j < BitBufferLimits.MtuIeee802; j++)
{
if (random.Next() % 11 == 0)
{
writer.i64(long.MaxValue);
}
if (random.Next() % 7 == 0)
{
writer.i32(int.MaxValue);
}
if (random.Next() % 5 == 0)
{
writer.i16(i16.MaxValue);
}
if (random.Next() % 3 == 0)
{
writer.b(true);
}
}
var result = writer.ToArray();
reader.CopyFrom(result);
writer.Reset();
}
}
public void BitsRead()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
Assert.AreEqual(0, writer.BitsWritten);
writer.b(true);
Assert.AreEqual(1, writer.BitsWritten);
writer.u8(123);
Assert.AreEqual(9, writer.BitsWritten);
writer.i16(12345);
Assert.AreEqual(33, writer.BitsWritten);
writer.i32(1234567890);
Assert.AreEqual(73, writer.BitsWritten);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(0, reader.BitsRead);
reader.b();
Assert.AreEqual(1, reader.BitsRead);
reader.u8();
Assert.AreEqual(9, reader.BitsRead);
reader.i16();
Assert.AreEqual(33, reader.BitsRead);
reader.i32();
Assert.AreEqual(73, reader.BitsRead);
}
public void IntReadWrite()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i32(int.MinValue);
writer.i32(0);
writer.i32(int.MaxValue);
writer.Align();
var allocated = new byte[ushort.MaxValue];
writer.ToSpan(allocated);
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >(allocated.Length);
reader.CopyFrom(allocated);
Assert.AreEqual(int.MinValue, reader.i32());
Assert.AreEqual(0, reader.i32());
Assert.AreEqual(int.MaxValue, reader.i32());
}
public void NoEncodingsWrite()
{
var writer = new BitBufferWriter <RawEncoding <u32ArrayMemory> >();
writer.i32(i32.MaxValue);
var data = writer.ToArray();
var value = BitConverter.ToInt32(data, 0);
Assert.AreEqual(i32.MaxValue, value);
}
public void Encodings()
{
var writer1 = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var writer2 = new BitBufferWriter <RawEncoding <u32ArrayMemory> >();
writer1.i32(i32.MaxValue);
writer2.i32(i32.MaxValue);
Assert.AreEqual(40, writer1.BitsWritten);
Assert.AreEqual(32, writer2.BitsWritten);
}
public void IntOfShortMax4Divided()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
for (var i = 0; i < 8; i++)
{
writer.i32(short.MaxValue / 3);
}
Assert.AreEqual(24, writer.LengthWritten);
}
public void RawToEncodedReadWrite()
{
var rawWriter = new BitBufferWriter <RawEncoding <u32ArrayMemory> >();
rawWriter.i32(i32.MaxValue - 13);
rawWriter.u32(u32.MaxValue - 666);
var rawReader = new BitBufferReader <RawDecoding <u32ArrayMemory> >();
var data = rawWriter.ToArray();
rawReader.CopyFrom(data);
Assert.AreEqual(i32.MaxValue - 13, rawReader.i32());
Assert.AreEqual(u32.MaxValue - 666, rawReader.u32());
}
public void i8ReadWriteSmallLimits()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i32(500);
writer.i16(1);
writer.i32(0);
writer.u8(0, 0, 4);
writer.u8(1, 0, 4);
writer.u8(2, 0, 4);
writer.u8(3, 0, 4);
writer.u8(4, 0, 4);
writer.i32(0, 0, 4);
writer.i32(1, 0, 4);
writer.i32(2, 0, 4);
writer.i32(3, 0, 4);
writer.i32(4, 0, 4);
#if !NO_EXCEPTIONS
Assert.Throws <System.ArgumentOutOfRangeException>(() => writer.u8(5, 0, 4));
Assert.Throws <System.ArgumentOutOfRangeException>(() => writer.u8(255, 0, 4));
Assert.Throws <System.ArgumentOutOfRangeException>(() => writer.i32(5, 0, 4));
Assert.Throws <System.ArgumentOutOfRangeException>(() => writer.i32(255, 0, 4));
#endif
}
public void ToArrayFromFrom()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >(100);
writer.i64(i64.MaxValue);
writer.i32(i32.MaxValue);
writer.i16(i16.MaxValue);
var result = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(result);
Assert.AreEqual(i64.MaxValue, reader.i64());
Assert.AreEqual(i32.MaxValue, reader.i32());
Assert.AreEqual(i16.MaxValue, reader.i16());
reader.CopyFrom(result);
Assert.AreEqual(i64.MaxValue, reader.i64());
Assert.AreEqual(i32.MaxValue, reader.i32());
Assert.AreEqual(i16.MaxValue, reader.i16());
}
public void ToSpanFromFrom()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >(100);
writer.i64(i64.MaxValue);
writer.i32(i32.MaxValue);
writer.i16(i16.MaxValue);
Span <byte> span = new byte[writer.LengthWritten];
ReadOnlySpan <byte> read = span;
writer.ToSpan(span);
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(read);
Assert.AreEqual(i64.MaxValue, reader.i64());
Assert.AreEqual(i32.MaxValue, reader.i32());
Assert.AreEqual(i16.MaxValue, reader.i16());
reader.CopyFrom(read);
Assert.AreEqual(i64.MaxValue, reader.i64());
Assert.AreEqual(i32.MaxValue, reader.i32());
Assert.AreEqual(i16.MaxValue, reader.i16());
}
public void IntMinMaxRequired()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i32(12345, 0, 123456);
writer.i32(1);
writer.i32(42, -1, 43);
writer.i32(1, 0, 10);
writer.i32(2, 3);
writer.i32(0);
var bitsWritten = writer.BitsWritten;
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(12345, reader.i32(0, 123456));
Assert.AreEqual(1, reader.i32());
Assert.AreEqual(42, reader.i32Peek(-1, 43));
Assert.AreEqual(42, reader.i32(-1, 43));
Assert.AreEqual(1, reader.i32(0, 10));
Assert.AreEqual(2, reader.i32(3));
Assert.AreEqual(0, reader.i32());
Assert.AreEqual(bitsWritten, reader.BitsRead);
}
public void BitBufferWriterRawEncoding()
{
for (int i = 0; i < N; i++)
{
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
buffer3.i32(666); buffer3.i32(666); buffer3.i32(666); buffer3.i32(666);
}
}
public void BitBufferWriterSevenBitEncoding()
{
for (int i = 0; i < N; i++)
{
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
buffer1.i32(666); buffer1.i32(666); buffer1.i32(666); buffer1.i32(666);
}
}
