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)); } }
private ShaderMixinObjectId() { objectIdBuilder = new ObjectIdBuilder(); buffer = Marshal.AllocHGlobal(65536); memStream = new NativeMemoryStream(buffer, 65536); writer = new HashSerializationWriter(memStream); writer.Context.SerializerSelector = new SerializerSelector("Default", "Hash"); }
public void StringEnumTest() { var abc = new[] { "A", "B", "C" }; var a_c = new[] { "A", null, "C" }; using (var ms = new NativeMemoryStream(128, 128)) { Assert.That(() => ms.Write(null, StringListPackMethod.Concatenated), Throws.Nothing); Assert.That(() => ms.Write(abc, StringListPackMethod.Concatenated), Throws.Nothing); var len = 14; var pos = len; Assert.That(len, Is.EqualTo(ms.Length).And.EqualTo(ms.Position)); Assert.That(() => ms.Write(abc, StringListPackMethod.Packed), Throws.Nothing); Assert.That(len += 12 + IntPtr.Size * 3, Is.EqualTo(ms.Length)); Assert.That(pos += IntPtr.Size * 3, Is.EqualTo(ms.Position)); Assert.That(ms.Capacity, Is.EqualTo(128)); Assert.That(() => ms.Write(a_c, StringListPackMethod.Concatenated), Throws.Exception); Assert.That(() => ms.Write(a_c, StringListPackMethod.Packed), Throws.Nothing); Assert.That(len += 8 + IntPtr.Size * 3, Is.EqualTo(ms.Length)); Assert.That(pos += IntPtr.Size * 3, Is.EqualTo(ms.Position)); Assert.That(ms.Capacity, Is.EqualTo(128)); var testSz = 10; var strSz = 50; var l = new List <string>(testSz); for (var i = 0; i < testSz; i++) { l.Add(new string('X', strSz)); } Assert.That(() => ms.Write(l, StringListPackMethod.Concatenated), Throws.Nothing); var strLen = ((strSz + 1) * testSz + 1) * StringHelper.GetCharSize(); Assert.That(len += strLen, Is.EqualTo(ms.Length)); Assert.That(pos += strLen, Is.EqualTo(ms.Position)); Assert.That(ms.Capacity, Is.GreaterThan(128)); Assert.That(() => ms.Write(l, StringListPackMethod.Packed), Throws.Nothing); strLen = (strSz + 1) * testSz * StringHelper.GetCharSize(); Assert.That(len += strLen + IntPtr.Size * testSz, Is.EqualTo(ms.Length)); Assert.That(pos += IntPtr.Size * testSz, Is.EqualTo(ms.Position)); Assert.That(ms.Position, Is.LessThan(ms.Length)); ms.Flush(); Assert.That(ms.Position, Is.EqualTo(ms.Length)); Assert.That(ms.Position, Is.LessThanOrEqualTo(ms.Capacity)); ms.Position = 0; Assert.That(ms.ReadArray(typeof(string), abc.Length, false), Is.EquivalentTo(abc)); Assert.That(ms.ReadArray(typeof(string), abc.Length, true), Is.EquivalentTo(abc)); Assert.That(ms.ReadArray(typeof(string), a_c.Length, true), Is.EquivalentTo(a_c)); Assert.That(ms.ReadArray <string>(l.Count, false), Is.EquivalentTo(l)); Assert.That(ms.ReadArray <string>(l.Count, true), Is.EquivalentTo(l)); l.Clear(); } }
public void SetLengthTest() { using (var m = new SafeHGlobalHandle(1000)) using (var ms = new NativeMemoryStream((IntPtr)m, m.Size)) { Assert.That(() => ms.SetLength(-1), Throws.TypeOf <ArgumentOutOfRangeException>()); Assert.That(() => ms.SetLength(1001), Throws.Exception); Assert.That(() => ms.SetLength(100), Throws.Nothing); } }
/// <summary> /// Create and Load a sound effect from an input wav stream. /// </summary> /// <param name="engine">Name of the audio engine in which to create the sound effect</param> /// <param name="stream">A stream corresponding to a wav file.</param> /// <returns>A new instance soundEffect ready to be played</returns> /// <exception cref="ArgumentNullException"><paramref name="engine"/> or <paramref name="stream"/> is null.</exception> /// <exception cref="NotSupportedException">The wave file or has more than 2 channels or is not encoded in 16bits.</exception> /// <exception cref="InvalidOperationException">The content of the stream does not correspond to a valid wave file.</exception> /// <exception cref="OutOfMemoryException">There is not enough memory anymore to load the specified file in memory. </exception> /// <exception cref="ObjectDisposedException">The audio engine has already been disposed</exception> /// <remarks>Supported WAV files' audio format is the 16bits PCM format.</remarks> public static SoundEffect Load(AudioEngine engine, Stream stream) { if (engine == null) { throw new ArgumentNullException("engine"); } if (stream == null) { throw new ArgumentNullException("stream"); } if (engine.IsDisposed) { throw new ObjectDisposedException("Audio Engine"); } // create a native memory stream to extract the lz4 audio stream. var newSdEff = new SoundEffect(engine) { nativeDataBuffer = Utilities.AllocateMemory((int)stream.Length) }; var nativeStream = new NativeMemoryStream(newSdEff.nativeDataBuffer, stream.Length); stream.CopyTo(nativeStream); nativeStream.Position = 0; var waveStreamReader = new SoundStream(nativeStream); var waveFormat = waveStreamReader.Format; if (waveFormat.Channels > 2) { throw new NotSupportedException("The wave file contains more than 2 data channels. Only mono and stereo formats are currently supported."); } if (waveFormat.Encoding != WaveFormatEncoding.Pcm || waveFormat.BitsPerSample != 16) { throw new NotSupportedException("The wave file audio format is not supported. Only 16bits PCM encoded formats are currently supported."); } newSdEff.WaveFormat = waveFormat; newSdEff.WaveDataPtr = newSdEff.nativeDataBuffer + (int)nativeStream.Position; newSdEff.WaveDataSize = (int)waveStreamReader.Length; newSdEff.Name = "Sound Effect " + soundEffectCreationCount; newSdEff.AdaptAudioDataImpl(); // register the sound to the AudioEngine so that it will be properly freed if AudioEngine is disposed before this. engine.RegisterSound(newSdEff); Interlocked.Increment(ref soundEffectCreationCount); return(newSdEff); }
public void SeekTest() { using (var m = new SafeHGlobalHandle(1000)) using (var ms = new NativeMemoryStream((IntPtr)m, m.Size)) { Assert.That(ms.Seek(20, SeekOrigin.Begin), Is.EqualTo(20)); Assert.That(ms.Seek(20, SeekOrigin.Current), Is.EqualTo(40)); Assert.That(ms.Seek(-100, SeekOrigin.End), Is.EqualTo(900)); Assert.That(() => ms.Seek(-1, SeekOrigin.Begin), Throws.ArgumentException); Assert.That(() => ms.Seek(1, SeekOrigin.End), Throws.ArgumentException); } }
internal void Load(Stream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } if (AudioEngine.IsDisposed) { throw new ObjectDisposedException("Audio Engine"); } // create a native memory stream to extract the lz4 audio stream. nativeDataBuffer = Utilities.AllocateMemory((int)stream.Length); var nativeStream = new NativeMemoryStream(nativeDataBuffer, stream.Length); stream.CopyTo(nativeStream); nativeStream.Position = 0; var waveStreamReader = new SoundStream(nativeStream); var waveFormat = waveStreamReader.Format; if (waveFormat.Channels > 2) { throw new NotSupportedException("The wave file contains more than 2 data channels. Only mono and stereo formats are currently supported."); } if (waveFormat.Encoding != WaveFormatEncoding.Pcm || waveFormat.BitsPerSample != 16) { throw new NotSupportedException("The wave file audio format is not supported. Only 16bits PCM encoded formats are currently supported."); } WaveFormat = waveFormat; WaveDataPtr = nativeDataBuffer + (int)nativeStream.Position; WaveDataSize = (int)waveStreamReader.Length; Name = "Sound Effect " + soundEffectCreationCount; AdaptAudioDataImpl(); // register the sound to the AudioEngine so that it will be properly freed if AudioEngine is disposed before this. AudioEngine.RegisterSound(this); //create a default instance only when actually we load, previously we were creating this on demand which would result sometimes in useless creations and bugs within the editor DefaultInstance = CreateInstance(); //copy back values we might have set before default instance creation DefaultInstance.Pan = defaultPan; DefaultInstance.Volume = defaultVolume; DefaultInstance.IsLooped = defaultIsLooped; Interlocked.Increment(ref soundEffectCreationCount); }
public void CapacityTest() { using (var ms = new NativeMemoryStream(10, 10, 20)) { Assert.That(ms.Capacity, Is.EqualTo(10)); ms.Write(Guid.NewGuid()); Assert.That(ms.Capacity, Is.EqualTo(20)); Assert.That(ms.Length, Is.EqualTo(16)); Assert.That(() => ms.EnsureCapacity(-100), Throws.TypeOf <ArgumentOutOfRangeException>()); Assert.That(() => ms.EnsureCapacity(40), Throws.TypeOf <ArgumentOutOfRangeException>()); } }
public void AmsiNotifyOperationTest() { using var hsess = new SafeHAMSISESSION(Guid.NewGuid().ToString()); var fn = TestCaseSources.BmpFile; using var fs = File.OpenRead(fn); using var mem = new NativeMemoryStream(); fs.CopyTo(mem); Assert.That(AmsiNotifyOperation(hsess.Context, mem.Pointer, (uint)mem.Length, fn, out var ret), ResultIs.Successful); Assert.IsFalse(AmsiResultIsMalware(ret)); Assert.That(AmsiScanBuffer(hsess.Context, mem.Pointer, (uint)mem.Length, fn, hsess, out ret), ResultIs.Successful); Assert.IsFalse(AmsiResultIsMalware(ret)); }
public void NativeMemoryStreamTest(int sz) { using (var ms = new NativeMemoryStream(sz)) { if (sz <= 0) { Assert.That(() => ms.Capacity, Throws.Exception); } else { Assert.That(ms.Capacity, Is.EqualTo(sz)); } } }
public void PropTest() { using (var m = new SafeHGlobalHandle(1000)) using (var ms = new NativeMemoryStream((IntPtr)m, m.Size)) { Assert.That(ms.Capacity, Is.EqualTo(1000)); Assert.That(ms.CanWrite, Is.False); Assert.That(ms.CanSeek, Is.True); Assert.That(ms.CanRead, Is.True); Assert.That(ms.Length, Is.EqualTo(0)); Assert.That(() => ms.EnsureCapacity(2000), Throws.InvalidOperationException); } }
public void StructEnumTest() { using (var ms = new NativeMemoryStream(48, 16)) { var arr = new[] { 1L, 2L, 3L, 4L, 5L, 6L }; Assert.That(() => ms.Write(arr), Throws.Nothing); var sz = sizeof(long) * arr.Length; Assert.That(ms.Length, Is.EqualTo(sz)); Assert.That(ms.Position, Is.EqualTo(sz)); Assert.That(ms.Capacity, Is.EqualTo(48)); var list = new List <int> { 1, 2, 3 }; Assert.That(() => ms.Write(list), Throws.Nothing); sz += sizeof(int) * list.Count; Assert.That(ms.Length, Is.EqualTo(sz)); Assert.That(ms.Position, Is.EqualTo(sz)); Assert.That(ms.Capacity, Is.EqualTo(64)); var pos = ms.Position; Assert.That(() => ms.Write(arr, true), Throws.Nothing); sz += (sizeof(long) + IntPtr.Size) * arr.Length; pos += IntPtr.Size * arr.Length; Assert.That(ms.Length, Is.EqualTo(sz)); Assert.That(ms.Position, Is.EqualTo(pos)); Assert.That(ms.Capacity, Is.EqualTo(144)); Assert.That(() => ms.Write(list, true), Throws.Nothing); sz += (sizeof(int) + IntPtr.Size) * list.Count; pos += IntPtr.Size * list.Count; Assert.That(ms.Length, Is.EqualTo(sz)); Assert.That(ms.Position, Is.EqualTo(pos)); Assert.That(ms.Capacity, Is.EqualTo(160)); ms.Flush(); ms.Position = 0; Assert.That(() => ms.ReadArray(null, 0, false), Throws.ArgumentNullException); Assert.That(() => ms.ReadArray(typeof(int), -1, false), Throws.InstanceOf <ArgumentOutOfRangeException>()); Assert.That(() => ms.ReadArray(typeof(int), 0, false), Throws.Nothing); Assert.That(ms.ReadArray(typeof(int), 0, false).Length, Is.Zero); Assert.That(() => ms.ReadArray(typeof(Guid), 100, false), Throws.InstanceOf <ArgumentOutOfRangeException>()); Assert.That(ms.ReadArray(typeof(long), arr.Length, false), Is.EquivalentTo(arr)); Assert.That(ms.ReadArray <int>(list.Count, false), Is.EquivalentTo(list)); Assert.That(ms.ReadArray <long>(arr.Length, true), Is.EquivalentTo(arr)); Assert.That(ms.ReadArray(typeof(int), list.Count, true), Is.EquivalentTo(list)); } }
private ShaderMixinObjectId() { objectIdBuilder = new ObjectIdBuilder(); buffer = Marshal.AllocHGlobal(65536); memStream = new NativeMemoryStream(buffer, 65536); writer = new HashSerializationWriter(memStream); writer.Context.SerializerSelector = new SerializerSelector(); writer.Context.SerializerSelector.RegisterProfile("Default"); writer.Context.SerializerSelector.RegisterSerializer(new ParameterKeyHashSerializer()); writer.Context.SerializerSelector.RegisterSerializer(new ParameterCollectionHashSerializer()); if (parameters == null) { parameters = new ParameterCollection(); } }
public void NativeMemoryStreamTest2() { using (var m = new SafeHGlobalHandle(10)) { Assert.That(() => new NativeMemoryStream(null, 10, 20), Throws.ArgumentNullException); using (var ms = new NativeMemoryStream(m, 10, 20)) { Assert.That(ms.Capacity, Is.EqualTo(10)); Assert.That(ms.MaxCapacity, Is.EqualTo(20)); Assert.That(ms.Pointer, Is.EqualTo((IntPtr)m)); Assert.That(() => ms.Write(Guid.NewGuid()), Throws.Nothing); Assert.That(ms.Capacity, Is.EqualTo(20)); Assert.That(() => ms.Write(Guid.NewGuid()), Throws.Exception); } } }
/// <summary> /// Marshals data from a managed list of strings to an unmanaged block of memory allocated by the <paramref name="memAlloc"/> method. /// </summary> /// <param name="values">The enumerated list of strings to marshal.</param> /// <param name="packing">The packing type for the strings.</param> /// <param name="memAlloc"> /// The function that allocates the memory for the block of strings (typically <see cref="Marshal.AllocCoTaskMem(int)"/> or <see cref="Marshal.AllocHGlobal(int)"/>. /// </param> /// <param name="bytesAllocated">The bytes allocated by the <paramref name="memAlloc"/> method.</param> /// <param name="charSet">The character set to use for the strings.</param> /// <param name="prefixBytes">Number of bytes preceding the trailing strings.</param> /// <returns> /// Pointer to the allocated native (unmanaged) array of strings stored using the <paramref name="packing"/> model and the character /// set defined by <paramref name="charSet"/>. /// </returns> public static IntPtr MarshalToPtr(this IEnumerable <string> values, StringListPackMethod packing, Func <int, IntPtr> memAlloc, out int bytesAllocated, CharSet charSet = CharSet.Auto, int prefixBytes = 0) { // Bail early if empty if (values is null || !values.Any()) { bytesAllocated = prefixBytes + (packing == StringListPackMethod.Concatenated ? StringHelper.GetCharSize(charSet) : IntPtr.Size); var ret = memAlloc(bytesAllocated); ret.FillMemory(0, bytesAllocated); return(ret); } // Write to memory stream using (var ms = new NativeMemoryStream(1024, 1024) { CharSet = charSet }) { ms.SetLength(ms.Position = prefixBytes); if (packing == StringListPackMethod.Packed) { foreach (var s in values) { ms.WriteReference(s); } ms.WriteReference(null); } else { foreach (var s in values) { if (string.IsNullOrEmpty(s)) { throw new ArgumentException("Concatenated string arrays cannot contain empty or null strings."); } ms.Write(s); } ms.Write(""); } ms.Flush(); // Copy to newly allocated memory using memAlloc bytesAllocated = (int)ms.Length; var ret = memAlloc(bytesAllocated); ms.Pointer.CopyTo(ret, bytesAllocated); return(ret); } }
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>()); } }
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 RefStructTest() { using (var ms = new NativeMemoryStream(8, 16, 100)) { Assert.That(() => ms.WriteReference(256), Throws.Nothing); var isz = sizeof(int); var pcnt = 1; Assert.That(ms.Length, Is.EqualTo(Len())); Assert.That(ms.Position, Is.EqualTo(Pos())); Assert.That(ms.Capacity, Is.EqualTo(8)); Assert.That(() => ms.WriteReference((ushort)256), Throws.Nothing); isz += sizeof(ushort); pcnt++; Assert.That(ms.Length, Is.EqualTo(Len())); Assert.That(ms.Position, Is.EqualTo(Pos())); Assert.That(ms.Capacity, Is.EqualTo(24)); Assert.That(() => ms.WriteReference((long)1), Throws.Nothing); isz += sizeof(long); pcnt++; Assert.That(ms.Length, Is.EqualTo(Len())); Assert.That(ms.Position, Is.EqualTo(Pos())); Assert.That(ms.Capacity, Is.EqualTo(40)); Assert.That(ms.Pointer.ToArray(IntPtr.Size == 4 ? typeof(uint) : typeof(ulong), pcnt), Is.EquivalentTo(new[] { 0, 0, 0 })); var newGuid = Guid.NewGuid(); Assert.That(() => ms.WriteReference(newGuid), Throws.Nothing); isz += Marshal.SizeOf(typeof(Guid)); pcnt++; Assert.That(ms.Length, Is.EqualTo(Len())); Assert.That(ms.Position, Is.EqualTo(Pos())); Assert.That(ms.Capacity, Is.EqualTo(56)); ms.Flush(); Assert.That(ms.Length, Is.EqualTo(ms.Position)); Assert.That(ms.Capacity, Is.GreaterThanOrEqualTo(ms.Length)); var arr = ms.Pointer.ToArray(IntPtr.Size == 4 ? typeof(uint) : typeof(ulong), pcnt); Assert.That(arr, Is.Not.EquivalentTo(new[] { 0, 0, 0, 0 })); ms.Position = 0; Assert.That(ms.ReadReference <int>(), Is.EqualTo(256)); Assert.That(ms.ReadReference <ushort>(), Is.EqualTo(256)); Assert.That(ms.ReadReference <long>(), Is.EqualTo(1)); Assert.That(ms.ReadReference <Guid>(), Is.EqualTo(newGuid)); int Len() => Pos() + isz; int Pos() => pcnt *IntPtr.Size; } }
/// <summary> /// Marshals data from a managed list of objects to an unmanaged block of memory allocated by the <paramref name="memAlloc"/> method. /// </summary> /// <param name="values">The enumerated list of objects to marshal.</param> /// <param name="memAlloc"> /// The function that allocates the memory for the block of objects (typically <see cref="Marshal.AllocCoTaskMem(int)"/> or <see cref="Marshal.AllocHGlobal(int)"/>. /// </param> /// <param name="bytesAllocated">The bytes allocated by the <paramref name="memAlloc"/> method.</param> /// <param name="referencePointers"> /// if set to <see langword="true"/> the pointer will be processed by storing a reference to the value; if <see langword="false"/>, /// the pointer value will be directly inserted into the array of pointers. /// </param> /// <param name="charSet">The character set to use for strings.</param> /// <param name="prefixBytes">Number of bytes preceding the allocated objects.</param> /// <returns>Pointer to the allocated native (unmanaged) array of objects stored using the character set defined by <paramref name="charSet"/>.</returns> public static IntPtr MarshalObjectsToPtr(this IEnumerable <object> values, Func <int, IntPtr> memAlloc, out int bytesAllocated, bool referencePointers = false, CharSet charSet = CharSet.Auto, int prefixBytes = 0) { // Bail early if empty if (values is null || !values.Any()) { bytesAllocated = prefixBytes + IntPtr.Size; var ret = memAlloc(bytesAllocated); ret.FillMemory(0, bytesAllocated); return(ret); } // Write to memory stream using (var ms = new NativeMemoryStream(1024, 1024) { CharSet = charSet }) { ms.SetLength(ms.Position = prefixBytes); foreach (var o in values) { if (referencePointers) { ms.WriteReferenceObject(o); } else { ms.WriteObject(o); } } if (referencePointers) { ms.WriteReference(null); } ms.Flush(); // Copy to newly allocated memory using memAlloc bytesAllocated = (int)ms.Length; var ret = memAlloc(bytesAllocated); ms.Pointer.CopyTo(ret, bytesAllocated); return(ret); } }
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)); } } }
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)); }
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>()); } }
/// <summary> /// Creates a in-memory binary blob as a <see cref="Blob"/> that will also be stored using the active <see cref="IOdbBackend"/>. /// Even if <see cref="Blob"/> is new (not in the ODB), memory will be copied. /// </summary> /// <param name="data">The data.</param> /// <param name="size">The size.</param> /// <returns>The <see cref="Blob"/> containing given data, with its reference count incremented.</returns> public Blob CreateBlob(IntPtr data, int size) { // Generate hash ObjectId objectId; var nativeMemoryStream = new NativeMemoryStream(data, size); using (var digestStream = new DigestStream(Stream.Null)) { nativeMemoryStream.CopyTo(digestStream); objectId = digestStream.CurrentHash; } lock (LoadedBlobs) { var blob = Lookup(objectId); // Blob doesn't exist yet, so let's create it and save it to ODB. if (blob == null) { // Let's go back to beginning of stream after previous hash nativeMemoryStream.Position = 0; // Create blob blob = new Blob(this, objectId, data, size); blob.AddReference(); // Write to disk backendWrite.Write(objectId, nativeMemoryStream, size, false); // Add blob to cache LoadedBlobs.Add(objectId, blob); } return(blob); } }