public void WriteInvalidateTest()
{
BitStreamer bs = new BitStreamer(false);
IntPtr ptr = Memory.Alloc(8);
Assert.IsFalse(bs.ThrowsOnExceededBuffer);
Assert.IsFalse(bs.IsValid);
bs.ResetWrite(ptr, 8);
Assert.IsTrue(bs.IsValid);
bs.WriteULong(123);
Assert.IsTrue(bs.IsValid);
bs.WriteInt32(321);
Assert.IsFalse(bs.IsValid);
// Confirm offset hasn't increased.
Assert.AreEqual(8, bs.ByteOffset);
bs.ResetWrite();
Assert.IsTrue(bs.IsValid);
Memory.Free(ptr);
}
public void NonAlignBufferTest()
{
IntPtr ptr = Memory.Alloc(12);
BitStreamer bs = new BitStreamer();
bs.ResetWrite(ptr, 12);
Assert.AreEqual(8, bs.ByteLength);
bs.ResetRead();
Assert.AreEqual(12, bs.ByteLength);
bs.ResetWrite();
Assert.AreEqual(8, bs.ByteLength);
bs.WriteULong(123);
// The write buffer should be rounded down to 8. So this must fail.
Assert.Throws <InvalidOperationException>(() =>
{
bs.WriteByte(1);
});
Memory.Free(ptr);
}
public void ReadInvalidateTest()
{
BitStreamer bs = new BitStreamer(false);
IntPtr ptr = Memory.Alloc(4);
Assert.IsFalse(bs.ThrowsOnExceededBuffer);
Assert.IsFalse(bs.IsValid);
bs.ResetRead(ptr, 4);
Assert.IsTrue(bs.IsValid);
bs.ReadInt32();
Assert.IsTrue(bs.IsValid);
bs.ReadInt32();
Assert.IsFalse(bs.IsValid);
// Confirm offset hasn't increased.
Assert.AreEqual(4, bs.ByteOffset);
bs.ResetRead();
Assert.IsTrue(bs.IsValid);
Memory.Free(ptr);
}
static void convertBitmap(string inputFile, string outputFile)
{
Image im = Bitmap.FromFile(inputFile);
Bitmap b = new Bitmap(im);
using (FileStream of = new FileStream(outputFile, FileMode.Create))
using (BinaryWriter bw = new BinaryWriter(of))
{
bw.Write(MagicCodeBitmap);
bw.Write(b.Width);
bw.Write(b.Height);
UInt32[] bitmapData = new UInt32[(b.Width * b.Height + 31) / 32];
BitStreamer bs = new BitStreamer(bitmapData);
for (int y = 0; y != b.Height; ++y)
{
for (int x = 0; x != b.Width; ++x)
{
if (b.GetPixel(x, y).B < 200)
bs.PutBits(1, 1);
else
bs.PutBits(0, 1);
}
}
foreach (var word in bitmapData)
bw.Write(word);
}
}
public void WriteResizeTest()
{
BitStreamer bs = new BitStreamer(false);
Assert.IsFalse(bs.ThrowsOnExceededBuffer);
Assert.IsFalse(bs.IsValid);
bs.ResetWrite(8);
Assert.IsTrue(bs.IsValid);
bs.WriteULong(123);
Assert.IsTrue(bs.IsValid);
Assert.AreEqual(8, bs.ByteLength);
bs.WriteInt32(321);
Assert.IsTrue(bs.IsValid);
Assert.AreEqual(16, bs.ByteLength);
// Confirm offset has increased.
Assert.AreEqual(12, bs.ByteOffset);
bs.ResetRead();
Assert.AreEqual(123, bs.ReadULong());
Assert.AreEqual(321, bs.ReadInt32());
Assert.IsTrue(bs.IsValid);
}
static void convertBitmap(string inputFile, string outputFile)
{
Image im = Bitmap.FromFile(inputFile);
Bitmap b = new Bitmap(im);
using (FileStream of = new FileStream(outputFile, FileMode.Create))
using (BinaryWriter bw = new BinaryWriter(of))
{
bw.Write(MagicCodeBitmap);
bw.Write(b.Width);
bw.Write(b.Height);
UInt32[] bitmapData = new UInt32[(b.Width * b.Height + 31) / 32];
BitStreamer bs = new BitStreamer(bitmapData);
for (int y = 0; y != b.Height; ++y)
{
for (int x = 0; x != b.Width; ++x)
{
if (b.GetPixel(x, y).B < 200)
{
bs.PutBits(1, 1);
}
else
{
bs.PutBits(0, 1);
}
}
}
foreach (var word in bitmapData)
{
bw.Write(word);
}
}
}
public static Vector3 ReadVector3(this BitStreamer stream)
{
return(new Vector3(
stream.ReadHalf(),
stream.ReadHalf(),
stream.ReadHalf()
));
}
public void ResetWithoutBufferTest()
{
BitStreamer bs = new BitStreamer();
Assert.Throws <InvalidOperationException>(() =>
{
bs.ResetRead();
});
}
public static void Serialize(this BitStreamer stream, ref Vector3 value)
{
if (stream.IsWriting)
{
WriteVector3(stream, value);
}
else
{
value = ReadVector3(stream);
}
}
public void CTorTest()
{
BitStreamer bs = new BitStreamer();
Assert.AreEqual(0, bs.BitLength);
Assert.AreEqual(0, bs.BitOffset);
Assert.AreEqual(false, bs.IsWriting);
Assert.AreEqual(false, bs.IsReading);
Assert.AreEqual(SerializationMode.None, bs.Mode);
Assert.AreEqual(IntPtr.Zero, bs.Buffer);
}
public void ZeroLargeTest()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite(8);
Assert.AreEqual(8, bs.ByteLength);
bs.Skip(20 << 3);
Assert.AreEqual(24, bs.ByteLength);
}
public void ResetReadTest1()
{
BitStreamer bs = new BitStreamer();
bs.ResetRead(new byte[10]);
Assert.AreEqual(16, bs.ByteLength);
Assert.AreEqual(16 << 3, bs.BitLength);
Assert.AreEqual(0, bs.BitOffset);
Assert.IsTrue(bs.OwnsBuffer);
bs.Dispose();
}
public void ExpandTest()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite(7);
Assert.AreEqual(8, bs.ByteLength);
bs.WriteLong(1);
bs.WriteLong(2);
Assert.AreEqual(16, bs.ByteLength);
}
public void ResetReadTest2()
{
BitStreamer bs = new BitStreamer();
bs.ResetRead(new byte[22], 2, 20);
Assert.Throws <ArgumentOutOfRangeException>(() => bs.ResetRead(new byte[22], 2, 21));
Assert.AreEqual(24, bs.ByteLength);
Assert.AreEqual(24 << 3, bs.BitLength);
Assert.AreEqual(0, bs.BitOffset);
bs.Dispose();
}
public void ResetReadTest3()
{
BitStreamer bs = new BitStreamer();
Assert.Throws <ArgumentNullException>(() => bs.ResetRead((IntPtr)null, 10));
IntPtr ptr = Marshal.AllocHGlobal(30);
bs.ResetRead(ptr, 30, true);
Assert.AreEqual(32 << 3, bs.BitLength);
Assert.AreEqual(0, bs.BitOffset);
bs.Dispose();
}
public void ResetWriteTest1()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite();
Assert.AreEqual(BitStreamer.DefaultSize, bs.ByteLength);
IntPtr ptr = bs.Buffer;
bs.ResetWrite();
Assert.AreEqual(ptr, bs.Buffer);
bs.Dispose();
}
public void CopyWithResize()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite(8);
Assert.AreEqual(8, bs.ByteLength);
bs.ResetRead(new byte[16]);
Assert.AreEqual(16, bs.ByteLength);
Assert.IsTrue(bs.OwnsBuffer);
bs.Dispose();
}
public void ResetWriteInvalid()
{
BitStreamer bs = new BitStreamer();
IntPtr buff = Memory.Alloc(16);
*(byte *)buff = 212;
bs.ResetWrite(8);
Assert.Throws <InvalidOperationException>(() =>
{
bs.ResetWrite(buff, 16);
});
}
public void ResetReadOffsetTest()
{
var arr = new byte[16];
arr[5] = 123;
BitStreamer bs = new BitStreamer();
bs.ResetRead(arr, 5, 10);
Assert.AreEqual(16, bs.ByteLength);
Assert.AreEqual(0, bs.ByteOffset);
Assert.AreEqual(123, bs.ReadByte());
}
public void ReadWriteIntTest()
{
int val = 123456789;
BitStreamer bs = new BitStreamer();
bs.ResetWrite(64);
bs.WriteInt32(val);
Assert.AreEqual(32, bs.BitOffset);
bs.ResetRead();
Assert.AreEqual(val, bs.ReadInt32());
}
public void SizeTest()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite(60);
// Rounded to next multiple of 8 = 64;
Assert.AreEqual(64, bs.ByteLength);
Assert.AreEqual(64 * 8, bs.BitLength);
bs.WriteInt32(1, 28);
Assert.AreEqual(28, bs.BitOffset);
Assert.AreEqual(28 / (double)8, bs.ByteOffset);
Assert.AreEqual(4, bs.BytesUsed);
}
public unsafe void ReadBufferCopyTest()
{
ulong value = 85830981411525;
IntPtr buf = Marshal.AllocHGlobal(8);
*(ulong *)buf = value;
BitStreamer reader = new BitStreamer();
reader.ResetRead(buf, 8, false);
Assert.AreEqual(64, reader.BitLength);
Assert.AreEqual(0, reader.BitOffset);
Assert.AreEqual(value, reader.ReadULong());
}
public void ExpandFailTest()
{
BitStreamer bs = new BitStreamer();
IntPtr ptr = Marshal.AllocHGlobal(9);
bs.ResetWrite(ptr, 9, false);
Assert.AreEqual(8, bs.ByteLength);
bs.WriteLong(1);
Assert.Throws <InvalidOperationException>(() =>
{
bs.WriteLong(2);
});
Assert.AreEqual(8, bs.ByteLength);
}
public unsafe void WriteBufferCopyTest()
{
ulong value = 666;
IntPtr buf = Marshal.AllocHGlobal(8);
BitStreamer reader = new BitStreamer();
reader.ResetWrite(buf, 8, false);
reader.WriteULong(value, 64);
Assert.AreEqual(64, reader.BitLength);
Assert.AreEqual(64, reader.BitOffset);
Assert.AreEqual(value, *(ulong *)reader.Buffer);
reader.Dispose();
}
public void ResetWriteCopyBufferNull()
{
BitStreamer bs = new BitStreamer();
IntPtr buff = Memory.Alloc(16);
*(byte *)buff = 212;
bs.ResetWrite(buff, 16, true);
Assert.AreEqual(16, bs.ByteLength);
Assert.AreEqual(16, bs.ByteOffset);
bs.ResetRead();
Assert.AreEqual(212, bs.ReadByte());
Assert.IsTrue(bs.OwnsBuffer);
Memory.Free(buff);
}
public void BitStream()
{
BitStreamer stream = new BitStreamer();
stream.ResetWrite(m_ptrBuf, SIZE, false);
for (int i = 0; i < AMOUNT / 2; i++)
{
stream.WriteBool(i % 2 == 0);
stream.WriteInt32(i);
}
stream.ResetRead();
for (int i = 0; i < AMOUNT / 2; i++)
{
bool b = stream.ReadBool();
int num = stream.ReadInt32();
}
}
public void ResetWriteTest2()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite(10);
IntPtr ptr = bs.Buffer;
Assert.AreEqual(16, bs.ByteLength);
bs.ResetWrite(12);
Assert.AreEqual(16, bs.ByteLength);
Assert.AreEqual(ptr, bs.Buffer);
bs.ResetWrite(17);
Assert.AreEqual(24, bs.ByteLength);
bs.Dispose();
Assert.AreEqual(IntPtr.Zero, bs.Buffer);
}
public void DisposeWriterTest()
{
BitStreamer bs = new BitStreamer();
bs.Dispose();
bs.ResetWrite(16);
bs.Dispose();
Assert.AreEqual(IntPtr.Zero, bs.Buffer);
bs.ResetWrite(18);
Assert.AreEqual(24, bs.ByteLength);
bs.Dispose();
Assert.AreEqual(IntPtr.Zero, bs.Buffer);
Assert.AreEqual(0, bs.BitLength);
Assert.AreEqual(0, bs.BitOffset);
Assert.AreEqual(SerializationMode.None, bs.Mode);
}
public override void DrawBitmap(BitStreamer bs, MonoBrickFirmware.Display.Point p, uint xSize, uint ySize, bool color)
{
base.DrawBitmap(bs, p, xSize, ySize, color);
for (int x = 0; x < xSize; x++)
{
for (int y = 0; y < ySize; y++)
{
bool isSet = base.IsPixelSet(x + p.X, y + p.Y);
if (isSet)
{
display.SetPixel(x + p.X, y + p.Y);
}
else
{
display.ClearPixel(x + p.X, y + p.Y);
}
}
}
}
public void NonAlignBufferSet()
{
IntPtr ptr = Memory.Alloc(12);
BitStreamer bs = new BitStreamer();
bs.ResetRead(ptr, 4);
Assert.AreEqual(4, bs.ByteLength);
bs.ReadFloat();
// Should fail because we are exceeding the allowed size of 4.
Assert.Throws <InvalidOperationException>(() =>
{
bs.ReadByte(1);
});
bs.ResetWrite();
Assert.AreEqual(0, bs.ByteLength);
}
public unsafe void SizePrefixTest()
{
BitStreamer bs = new BitStreamer();
bs.ResetWrite(64);
bs.ReserveSizePrefix();
Assert.AreEqual(4, bs.ByteOffset);
// Write some random data.
var bits = 32;
for (int i = 0; i < 8; i++)
{
bs.WriteInt32(i + 1, 7);
bits += 7;
}
Assert.AreEqual(bits, bs.BitOffset);
int bytesUsed = bs.BytesUsed;
// Prefix the size and make sure the offset remains unchanged.
Assert.AreEqual(bytesUsed, bs.PrefixSize());
Assert.AreEqual(bits, bs.BitOffset);
var newbs = new BitStreamer();
newbs.ResetRead(bs.Buffer, bs.ByteLength, false);
// Read the length of the buffer.
// Must be read as uint due to Zig/Zagging of int value.
Assert.AreEqual(bytesUsed, newbs.ReadUInt32());
for (int i = 0; i < 8; i++)
{
Assert.AreEqual(i + 1, newbs.ReadInt32(7));
}
Assert.AreEqual(bs.BitOffset, newbs.BitOffset);
}
