public void DisposedTest()
{
var ms = new NativeMemoryStream(20);
ms.Dispose();
Assert.That(ms.CanRead, Is.False);
Assert.That(ms.CanSeek, Is.False);
Assert.That(ms.CanWrite, Is.False);
Assert.That(() => ms.Capacity > 0, Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Read <int>(), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Read(typeof(int)), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Read(new byte[3], 0, 3), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.ReadByte(), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.ReadArray(typeof(byte), 1, false), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.ReadReference <int>(), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.ReadReference <string>(), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Seek(0, SeekOrigin.Begin), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.SetLength(20), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Write("X"), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Write("X", CharSet.Ansi), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Write(new[] { "X", "Y" }), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Write(new byte[3], 0, 3), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Write(new[] { 1, 2 }), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.Write(256), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.WriteByte(1), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.WriteObject(Guid.NewGuid()), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.WriteReference("X"), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.WriteReference(256), Throws.InstanceOf <ObjectDisposedException>());
Assert.That(() => ms.WriteReferenceObject(Guid.NewGuid()), Throws.InstanceOf <ObjectDisposedException>());
}
public void RefStringTest()
{
using (var ms = new NativeMemoryStream(20, 20))
{
Assert.That(() => ms.WriteReference(""), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(2 + IntPtr.Size));
Assert.That(ms.Position, Is.EqualTo(IntPtr.Size));
Assert.That(ms.Capacity, Is.EqualTo(20));
Assert.That(() => ms.WriteReference(testStr), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(24 + IntPtr.Size * 2));
Assert.That(ms.Position, Is.EqualTo(IntPtr.Size * 2));
Assert.That(() => ms.WriteReference((string)null), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(24 + IntPtr.Size * 3));
Assert.That(ms.Position, Is.EqualTo(IntPtr.Size * 3));
var ptrs = ms.Pointer.ToArray <IntPtr>(3);
Assert.That(ptrs, Is.EquivalentTo(new[] { IntPtr.Zero, IntPtr.Zero, IntPtr.Zero }));
ms.Flush();
Assert.That(ms.Capacity, Is.EqualTo(40));
ptrs = ms.Pointer.ToArray <IntPtr>(3);
Assert.That(ptrs, Is.Not.EquivalentTo(new[] { IntPtr.Zero, IntPtr.Zero, IntPtr.Zero }));
Assert.That(StringHelper.GetString(ptrs[0], ms.CharSet), Is.EqualTo(""));
Assert.That(StringHelper.GetString(ptrs[1], ms.CharSet), Is.EqualTo(testStr));
Assert.That(StringHelper.GetString(ptrs[2], ms.CharSet), Is.Null);
TestContext.WriteLine(ms.Pointer.ToHexDumpString((int)ms.Length, 32));
ms.Position = 0;
Assert.That(ms.ReadReference <string>(), Is.EqualTo(string.Empty));
Assert.That(ms.Position, Is.EqualTo(IntPtr.Size));
Assert.That(ms.ReadReference <string>(), Is.EqualTo(testStr));
Assert.That(ms.ReadReference <string>(), Is.Null);
Assert.That(ms.Read <string>(), Is.EqualTo(string.Empty));
Assert.That(ms.Read <string>(), Is.EqualTo(testStr));
}
}
public void StructTest()
{
using (var ms = new NativeMemoryStream(8, 16, 48))
{
Assert.That(() => ms.Write(256), Throws.Nothing);
var isz = sizeof(int);
Assert.That(ms.Length, Is.EqualTo(Len()));
Assert.That(ms.Position, Is.EqualTo(Pos()));
Assert.That(ms.Capacity, Is.EqualTo(8));
Assert.That(() => ms.Write((ushort)256), Throws.Nothing);
isz += sizeof(ushort);
Assert.That(ms.Length, Is.EqualTo(Len()));
Assert.That(ms.Position, Is.EqualTo(Pos()));
Assert.That(ms.Capacity, Is.EqualTo(8));
Assert.That(() => ms.Write((long)1), Throws.Nothing);
isz += sizeof(long);
Assert.That(ms.Length, Is.EqualTo(Len()));
Assert.That(ms.Position, Is.EqualTo(Pos()));
Assert.That(ms.Capacity, Is.EqualTo(24));
var newGuid = Guid.NewGuid();
Assert.That(() => ms.Write(newGuid), Throws.Nothing);
isz += Marshal.SizeOf(typeof(Guid));
Assert.That(ms.Length, Is.EqualTo(Len()));
Assert.That(ms.Position, Is.EqualTo(Pos()));
Assert.That(ms.Capacity, Is.EqualTo(40));
Assert.That(ms.Length, Is.EqualTo(ms.Position));
Assert.That(ms.Capacity, Is.GreaterThanOrEqualTo(ms.Length));
Assert.That(() => ms.Write(new Unblittable()), Throws.Exception);
TestContext.WriteLine(ms.Pointer.ToHexDumpString((int)ms.Length, 32));
ms.Position = 0;
Assert.That(() => ms.Read(null), Throws.ArgumentNullException);
Assert.That(ms.Read <int>(), Is.EqualTo(256));
Assert.That(ms.Read <ushort>(), Is.EqualTo(256));
Assert.That(ms.Read <long>(), Is.EqualTo(1));
Assert.That(ms.Read <Guid>(), Is.EqualTo(newGuid));
int Len() => isz;
int Pos() => isz;
}
}
public void StringTest()
{
using (var ms = new NativeMemoryStream(20))
{
Assert.That(() => ms.Write(""), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(2));
Assert.That(ms.Position, Is.EqualTo(2));
Assert.That(ms.Capacity, Is.EqualTo(20));
Assert.That(() => ms.Write(testStr), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(24));
Assert.That(ms.Position, Is.EqualTo(24));
Assert.That(ms.Capacity, Is.GreaterThan(20));
ms.Flush();
ms.Position = 0;
Assert.That(ms.Read <string>(), Is.EqualTo(string.Empty));
Assert.That(ms.Position, Is.EqualTo(StringHelper.GetCharSize(ms.CharSet)));
Assert.That(ms.Read <string>(), Is.EqualTo(testStr));
}
}
public void MixedReadWriteTest()
{
using (var m = new SafeHGlobalHandle(512))
{
var str = "Test1";
var guid = Guid.NewGuid();
var lVal = 1208L;
byte b = 18;
using (var ms = new NativeMemoryStream(m)
{
CharSet = CharSet.Unicode
})
{
Assert.That(() => ms.WriteReference(str), Throws.Nothing);
Assert.That(() => ms.Write(str), Throws.Nothing);
Assert.That(() => ms.WriteReference(guid), Throws.Nothing);
Assert.That(() => ms.Write(guid), Throws.Nothing);
Assert.That(() => ms.WriteReference(lVal), Throws.Nothing);
Assert.That(() => ms.Write(lVal), Throws.Nothing);
Assert.That(() => ms.WriteReference(b), Throws.Nothing);
Assert.That(() => ms.Write(b), Throws.Nothing);
Assert.That(() => ms.WriteReference(str), Throws.Nothing);
ms.Flush();
ms.Position = 0;
Assert.That(ms.ReadReference <string>(CharSet.Unicode), Is.EqualTo(str));
Assert.That(ms.Read <string>(CharSet.Unicode), Is.EqualTo(str));
Assert.That(ms.ReadReference <Guid>(), Is.EqualTo(guid));
Assert.That(ms.Read <Guid>(), Is.EqualTo(guid));
Assert.That(ms.ReadReference <long>(), Is.EqualTo(lVal));
Assert.That(ms.Read <long>(), Is.EqualTo(lVal));
Assert.That(ms.ReadReference <byte>(), Is.EqualTo(b));
Assert.That(ms.Read <byte>(), Is.EqualTo(b));
Assert.That(ms.ReadReference <string>(CharSet.Unicode), Is.EqualTo(str));
}
}
}
public void ReadWriteOnlyTest()
{
using (var m = new SafeHGlobalHandle(10))
using (var ms = new NativeMemoryStream((IntPtr)m, m.Size))
{
Assert.That(ms.CanWrite, Is.False);
Assert.That(ms.CanSeek, Is.True);
Assert.That(ms.CanRead, Is.True);
Assert.That(() => ms.Write("X"), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Write("X", CharSet.Ansi), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Write(new[] { "X", "Y" }), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Write(new byte[3], 0, 3), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Write(new[] { 1, 2 }), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Write(256), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.WriteByte(1), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.WriteObject(Guid.NewGuid()), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.WriteReference("X"), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.WriteReference(256), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.WriteReferenceObject(Guid.NewGuid()), Throws.InstanceOf <NotSupportedException>());
}
using (var ms = new NativeMemoryStream(10, 10, 20, FileAccess.Write))
{
Assert.That(ms.CanWrite, Is.True);
Assert.That(ms.CanSeek, Is.True);
Assert.That(ms.CanRead, Is.False);
Assert.That(() => ms.Read <int>(), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Read(typeof(int)), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.Read(new byte[3], 0, 3), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.ReadByte(), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.ReadArray(typeof(byte), 1, false), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.ReadReference <int>(), Throws.InstanceOf <NotSupportedException>());
Assert.That(() => ms.ReadReference <string>(), Throws.InstanceOf <NotSupportedException>());
}
}
public void BytesTest()
{
using (var ms = new NativeMemoryStream(20, 10))
{
Assert.That(ms.Length, Is.EqualTo(0));
Assert.That(() => ms.Write(null, 0, 0), Throws.ArgumentNullException);
var bytes = new byte[] { 0, 0, 0, 0, 0, 0, 0, 3 };
Assert.That(() => ms.Write(bytes, 1, 8), Throws.ArgumentException);
Assert.That(() => ms.Write(bytes, -1, 8), Throws.TypeOf <ArgumentOutOfRangeException>());
Assert.That(() => ms.Write(bytes, 1, -8), Throws.TypeOf <ArgumentOutOfRangeException>());
Assert.That(() => ms.Write(bytes, 0, 8), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(8));
Assert.That(ms.Position, Is.EqualTo(8));
Assert.That(ms.Capacity, Is.EqualTo(20));
var ones = new byte[22];
for (var i = 0; i < ones.Length; i++)
{
ones[i] = 1;
}
Array.ForEach(ones, b => b = 1);
Assert.That(() => ms.Write(ones, 0, ones.Length), Throws.Nothing);
Assert.That(ms.Length, Is.EqualTo(30));
Assert.That(ms.Position, Is.EqualTo(30));
Assert.That(ms.Capacity, Is.EqualTo(30));
ms.Flush();
ms.Position = 0;
Assert.That(() => ms.Read(null, 0, 0), Throws.ArgumentNullException);
var rbytes = new byte[bytes.Length];
Assert.That(() => ms.Read(rbytes, 5, bytes.Length), Throws.ArgumentException);
Assert.That(() => ms.Read(rbytes, -1, 1), Throws.InstanceOf <ArgumentOutOfRangeException>());
Assert.That(() => ms.Read(rbytes, 0, -1), Throws.InstanceOf <ArgumentOutOfRangeException>());
Assert.That(ms.Read(rbytes, 0, bytes.Length), Is.EqualTo(bytes.Length));
Assert.That(rbytes, Is.EquivalentTo(bytes));
Assert.That(ms.Position, Is.EqualTo(bytes.Length));
rbytes = new byte[ms.Length];
Assert.That(() => ms.Read(rbytes, (int)ms.Position, 40), Throws.ArgumentException);
Assert.That(ms.Read(rbytes, (int)ms.Position, ones.Length), Is.EqualTo(ones.Length));
for (var i = bytes.Length; i < ms.Position; i++)
{
Assert.That(rbytes[i], Is.EqualTo(1));
}
Assert.That(() => ms.Read(rbytes, 0, 2), Throws.InstanceOf <ArgumentOutOfRangeException>());
}
}
private static Bitmap GetTransparentBitmap(HBITMAP hbitmap)
{
try
{
var dibsection = GetObject <BITMAP>(hbitmap);
var bitmap = new Bitmap(dibsection.bmWidth, dibsection.bmHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
using var mstr = new NativeMemoryStream(dibsection.bmBits, dibsection.bmBitsPixel * dibsection.bmHeight * dibsection.bmWidth);
for (var x = 0; x < dibsection.bmWidth; x++)
{
for (var y = 0; y < dibsection.bmHeight; y++)
{
var rgbquad = mstr.Read <RGBQUAD>();
if (rgbquad.rgbReserved != 0)
{
bitmap.SetPixel(x, y, rgbquad.Color);
}
}
}
return(bitmap);
}
catch { }
return(Image.FromHbitmap((IntPtr)hbitmap));
}
