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 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 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 CodePagesBitsRequited()
{
var bits = BitBuffer.BitsRequired("0".AsSpan(), 1);
var bitBuffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
bitBuffer.c("0".AsSpan());
Assert.AreEqual(bits, bitBuffer.BitsWritten);
var result = bitBuffer.ToArray();
}
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 u16ReadWrite()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.u16(u16.MinValue);
writer.u16(u16.MaxValue / 2);
writer.u16(u16.MaxValue);
var data = writer.ToArray();
writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(u16.MinValue, reader.u16());
var half = u16.MaxValue / 2;
Assert.AreEqual(half, reader.u16());
Assert.AreEqual(u16.MaxValue, reader.u16());
}
public void f64ReadWrite()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.f64(f64.MaxValue);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(f64.MaxValue, reader.f64());
}
public void f32Bits()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.f32(1f, 0f, 1f, 1);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(1, reader.f32(0f, 1f, 1));
}
public void f32MinMaxRequired()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.f32(1234.5f, 0, 12345.6f, 0.01f);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(1234.5f, reader.f32(0, 12345.6f, 0.01f));
}
public void u8MaxValueWritePeek()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.u8(u8.MaxValue);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(u8.MaxValue, reader.u8Peek());
Assert.AreEqual(reader.u8Peek(), reader.u8());
}
public void PeekBool()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.b(true);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.True(reader.bPeek());
Assert.True(reader.b());
}
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 i32BdiffLimits()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i32BDiff(0, 1, -1, 10);
writer.i32BDiff(1, 1, 0, 100);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(1, reader.i32BDiff(0, -1, 10));
Assert.AreEqual(1, reader.i32BDiff(1, 0, 100));
}
public void f32ReadWrite()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.f32(123.456f);
writer.Align();
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(123.456f, reader.f32Peek());
Assert.AreEqual(123.456f, reader.f32());
}
public void u16Bdiff()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.u16BDiff(0, 1);
writer.u16BDiff(1, 1);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(1, reader.u16BDiff(0));
Assert.AreEqual(1, reader.u16BDiff(1));
}
public void u16ReadWriteLimits()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.u16(2, 0, 10);
writer.u16(1, 3);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(2, reader.i16(0, 10));
Assert.AreEqual(1, reader.u16(3));
}
public void BoolWritePeek128()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.b(true);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
for (int i = 0; i < 128; i++)
{
Assert.True(reader.bPeek());
}
}
public void u8ArrayReadLimit()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var input = new byte[writer.Options.U8SpanLengthMax];
writer.u8(input);
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.Throws <ArgumentException>(() => reader.u8(new byte[1]));
Assert.Throws <ArgumentException>(() => reader.u8(new byte[writer.Options.U8SpanLengthMax], writer.Options.U8SpanLengthMax + 1));
}
public void i8ReadWriteLimits()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i8(13, 0, 14);
writer.i8(2, 4);
var bitsWritten = writer.BitsWritten;
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(13, reader.i8(0, 14));
Assert.AreEqual(2, reader.i8(4));
Assert.AreEqual(bitsWritten, reader.BitsRead);
}
public void AngleZero()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var angle = 0f;
buffer.f32(angle);
Assert.AreEqual(32, buffer.BitsWritten);
var data = buffer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
var result = reader.f32();
Assert.AreEqual(0f, result, 1);
}
public void u32ReadWriteLimits <TEncoder, TDecoder>()
where TEncoder : struct, ICompression <RawBitWriter <u32ArrayMemory> >
where TDecoder : struct, IDecompression <RawBitReader <u32ArrayMemory> >
{
var writer = new BitBufferWriter <TEncoder>();
writer.u32(123123, 0, 13213123);
writer.u32(123, 20);
var data = writer.ToArray();
var reader = new BitBufferReader <TDecoder>();
reader.CopyFrom(data);
Assert.AreEqual(123123u, reader.u32(0, 13213123));
Assert.AreEqual(123u, reader.u32(20));
}
private void u32ReadWrite <TEncoder, TDecoder>()
where TEncoder : struct, ICompression <RawBitWriter <u32ArrayMemory> >
where TDecoder : struct, IDecompression <BitBufferReader <TDecoder> >
{
var writer = new BitBufferWriter <TEncoder>();
writer.u32(u32.MinValue);
writer.u32(u32.MaxValue);
var data = writer.ToArray();
var reader = new BitBufferReader <TDecoder>();
reader.CopyFrom(data);
Assert.AreEqual(u32.MinValue, reader.u32());
Assert.AreEqual(u32.MaxValue, reader.u32());
}
public void AngleHalf()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var angle = 359.1f;
buffer.f32Half(angle);
Assert.AreEqual(16, buffer.BitsWritten);
var data = buffer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
var result = reader.f32Half();
Assert.AreEqual(359, result);
}
public void AngleQuantization()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var angle = 35901u;
buffer.u32(angle, 0, 36000);
Assert.AreEqual(16, buffer.BitsWritten);
var data = buffer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
var result = reader.f32(0f, 360f, 0.01f);
Assert.AreEqual(359.01f, result, 2);
}
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());
}
private void i8ReadWrite <TEncoder, TDecoder>()
where TEncoder : struct, ICompression <RawBitWriter <u32ArrayMemory> >
where TDecoder : struct, IDecompression <RawBitReader <u32ArrayMemory> >
{
var writer = new BitBufferWriter <TEncoder>();
writer.i8(i8.MinValue);
i8 half = i8.MaxValue / 2;
writer.i8(half);
writer.i8(i8.MaxValue);
var data = writer.ToArray();
var reader = new BitBufferReader <TDecoder>();
reader.CopyFrom(data);
Assert.AreEqual(i8.MinValue, reader.i8());
Assert.AreEqual(half, reader.i8Peek());
Assert.AreEqual(half, reader.i8());
Assert.AreEqual(i8.MaxValue, reader.i8());
}
public void u8WritePeekRead256()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >(1000);
for (int i = 0; i < 513; i++)
{
var val = (u8)(u8.MaxValue / (i % 2 + 1));
writer.u8(val);
}
var data = writer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
for (int i = 0; i < 513; i++)
{
var val = (u8)(u8.MaxValue / (i % 2 + 1));
Assert.AreEqual(val, reader.u8Peek());
Assert.AreEqual(val, reader.u8());
}
}
public void u8MinMaxRequired()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
buffer.u8(123, 0, 201);
buffer.u8(1);
buffer.u8(42, 1, 43);
buffer.u8(1, 0, 10);
buffer.u8(2, 3);
buffer.u8(0);
var bitsWritten = buffer.BitsWritten;
var data = buffer.ToArray();
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(data);
Assert.AreEqual(123, reader.u8(0, 201));
Assert.AreEqual(1, reader.u8());
Assert.AreEqual(42, reader.u8(1, 43));
Assert.AreEqual(1, reader.u8(0, 10));
Assert.AreEqual(2, reader.u8(3));
Assert.AreEqual(0, reader.u8());
Assert.AreEqual(bitsWritten, reader.BitsRead);
}
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);
}
