public void UIntMax()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
buffer.u32(uint.MaxValue);
Assert.AreEqual(5, buffer.LengthWritten);
}
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 i16ReadWrite()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i16(i16.MinValue);
writer.i16(i16.MinValue / 2);
writer.i16(0);
i16 half = i16.MaxValue / 2;
writer.i16(half);
writer.i16(i16.MaxValue);
writer.Align();
var allocated = new byte[i16.MaxValue];
writer.ToSpan(allocated);
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >(allocated.Length);
reader.CopyFrom(allocated);
Assert.AreEqual(i16.MinValue, reader.i16());
Assert.AreEqual(i16.MinValue / 2, reader.i16());
Assert.AreEqual(0, reader.i16());
Assert.AreEqual(half, reader.i16Peek());
Assert.AreEqual(half, reader.i16());
Assert.AreEqual(i16.MaxValue, reader.i16());
}
public void u8ArrayWriteLimit()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var input = new byte[writer.Options.U8SpanLengthMax + 1];
Assert.Throws <ArgumentException>(() => writer.u8(input));
}
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 UIntMin()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.u32(uint.MinValue);
Assert.AreEqual(1, writer.LengthWritten);
}
public void u8WriteOutOfRange()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
Assert.Throws <ArgumentOutOfRangeException>(() => writer.u8(125, 0, 123));
Assert.Throws <ArgumentOutOfRangeException>(() => writer.u8(1, 2, 123));
Assert.Throws <ArgumentException>(() => writer.u8(123, 2));
Assert.Throws <ArgumentException>(() => writer.u8(44, 55, 33));
}
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 ByteMin3()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
buffer.u8(byte.MinValue);
buffer.u8(byte.MinValue);
buffer.u8(byte.MinValue);
Assert.AreEqual(3, buffer.LengthWritten);
}
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 GlobalSetup()
{
if (N <= 0)
{
throw new Exception();
}
buffer1 = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >(2 * 64 * N);
buffer3 = new BitBufferWriter <RawEncoding <u32ArrayMemory> >(2 * 64 * N);
}
public void ShortMinMax4()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
buffer.i16(short.MaxValue, short.MinValue, short.MaxValue);
buffer.i16(short.MaxValue, short.MinValue, short.MaxValue);
buffer.i16(short.MaxValue, short.MinValue, short.MaxValue);
buffer.i16(short.MaxValue, short.MinValue, short.MaxValue);
Assert.AreEqual(8, buffer.LengthWritten);
}
public void ByteShort0()
{
var buffer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
buffer.i16(0);
buffer.i16(0);
buffer.i16(0);
buffer.i16(0);
Assert.AreEqual(4, buffer.LengthWritten);
}
public void SByte0()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i8(0);
writer.i8(0);
writer.i8(0);
writer.i8(0);
Assert.AreEqual(4, writer.LengthWritten);
}
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 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 ShortZeroMax4()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.i16(short.MaxValue, 0, short.MaxValue);
writer.i16(short.MaxValue, 0, short.MaxValue);
writer.i16(short.MaxValue, 0, short.MaxValue);
writer.i16(short.MaxValue, 0, short.MaxValue);
Assert.AreEqual(8, writer.LengthWritten);
}
public void SimpleStructWrite()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
var expected = new SimpleStruct {
a = 1.2f, b = 123, c = byte.MaxValue, d = ushort.MaxValue
};
writer.block(in expected);
Assert.True(writer.LengthWritten < Unsafe.SizeOf <SimpleStruct>());
}
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 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 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 Capacity()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >(100);
Assert.AreEqual(0, writer.LengthWritten);
var received = new byte[2000];
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >();
reader.CopyFrom(received);
Assert.AreEqual(0, writer.LengthWritten);
}
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 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 StringWriteRead()
{
var writer = new BitBufferWriter <SevenBitEncoding <u32ArrayMemory> >();
writer.c("lahoda.prо/минск");
var allocated = new byte[ushort.MaxValue];
writer.ToSpan(allocated);
var reader = new BitBufferReader <SevenBitDecoding <u32ArrayMemory> >(allocated.Length);
reader.CopyFrom(allocated);
Assert.AreEqual("lahoda.prо/минск", reader.String());
}
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());
}
