public void Read_Must_Indicate_End_Of_Stream() { var pool = new BufferManagerAllocator(1024, 1024 * 1024); var stream = new PooledMemoryStream(pool); var buffer = new byte[129]; Assert.Equal(-1, stream.Read(buffer, 0, buffer.Length)); stream.Write(buffer, 0, buffer.Length); Assert.Equal(-1, stream.Read(buffer, 0, buffer.Length)); }
public void Data_Written_Can_Be_Read_Back() { var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024, 4 }; var pool = new BufferManagerAllocator(1024, 1024 * 1024); byte i = 1; foreach (var size in sizes) { using (var stream = new PooledMemoryStream(pool)) { var data = new byte[size]; for (var j = 0; j < data.Length; j++) data[j] = i; stream.Write(data, 0, data.Length); stream.Position = 0; Assert.Equal(0, stream.Position); Assert.Equal(data.Length, stream.Length); var copy = new byte[size]; stream.Read(copy, 0, copy.Length); Assert.Equal(data, copy); } i++; } }
public void ExpandOnSingleSegment() { PooledMemoryStream stream = s_manager.GetStream(); byte[] buffer = new byte[4]; new Random(42).NextBytes(buffer); stream.Write(buffer); Assert.Equal(16, stream.Capacity); Assert.Equal(4, stream.Length); Assert.Equal(4, stream.Position); stream.SetLength(8); Assert.Equal(16, stream.Capacity); Assert.Equal(8, stream.Length); Assert.Equal(4, stream.Position); stream.Seek(0, SeekOrigin.Begin); byte[] buffer2 = new byte[8]; Assert.Equal(8, stream.Read(buffer2)); Assert.True(buffer2.AsSpan(0, 4).SequenceEqual(buffer.AsSpan(0, 4))); Assert.True(buffer2.AsSpan(4, 4).SequenceEqual(s_emptyBytes.AsSpan(0, 4))); }
public static void PooledMemoryStream_Write_BeyondCapacity() { using (PooledMemoryStream memoryStream = new PooledMemoryStream()) { long origLength = memoryStream.Length; byte[] bytes = new byte[10]; for (int i = 0; i < bytes.Length; i++) { bytes[i] = (byte)i; } int spanPastEnd = 5; memoryStream.Seek(spanPastEnd, SeekOrigin.End); // Test Write memoryStream.Write(bytes, 0, bytes.Length); long pos = memoryStream.Position; Assert.Equal(pos, origLength + spanPastEnd + bytes.Length); Assert.Equal(memoryStream.Length, origLength + spanPastEnd + bytes.Length); // Verify bytes were correct. memoryStream.Position = origLength; byte[] newData = new byte[bytes.Length + spanPastEnd]; int n = memoryStream.Read(newData, 0, newData.Length); Assert.Equal(n, newData.Length); for (int i = 0; i < spanPastEnd; i++) { Assert.Equal(0, newData[i]); } for (int i = 0; i < bytes.Length; i++) { Assert.Equal(bytes[i], newData[i + spanPastEnd]); } } }
public void StreamCanHoldLongData() { const long dataSize = (long)int.MaxValue + Constants.MB; const int bufferPartitionSize = 512 * Constants.MB; PredictableStream originalStream = new PredictableStream(); PooledMemoryStream arrayPoolStream = PooledMemoryStream.BufferStreamPartitionInternal(originalStream, dataSize, dataSize, 0, _pool, bufferPartitionSize, false, default).EnsureCompleted(); originalStream.Position = 0; // assert it holds the correct amount of data. other tests assert data validity and it's so expensive to do that here. // test without blowing up memory const int testSize = 256 * Constants.MB; var pooledStreamBuffer = new byte[testSize]; long totalRead = 0; int read; do { // both these streams are backed in memory and will always read what is asked until the pooled stream hits the end read = arrayPoolStream.Read(pooledStreamBuffer, 0, testSize); totalRead += read; } while (read != 0); Assert.AreEqual(dataSize, totalRead); }
public void Data_Written_Can_Be_Read_Back() { var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024, 4 }; var pool = new BufferManagerAllocator(1024, 1024 * 1024); byte i = 1; foreach (var size in sizes) { using (var stream = new PooledMemoryStream(pool)) { var data = new byte[size]; for (var j = 0; j < data.Length; j++) { data[j] = i; } stream.Write(data, 0, data.Length); stream.Position = 0; Assert.Equal(0, stream.Position); Assert.Equal(data.Length, stream.Length); var copy = new byte[size]; stream.Read(copy, 0, copy.Length); Assert.Equal(data, copy); } i++; } }
public void TestReadOnly() { var data = new byte[] { 1, 2, 3, 4 }; using (var stm = new PooledMemoryStream(data)) { Assert.True(stm.CanRead); Assert.False(stm.CanWrite); var buf = new byte[128]; var bytesread = stm.Read(buf, 4, buf.Length - 4); Assert.Equal(4, bytesread); Assert.Equal(4, stm.Position); bytesread = stm.Read(buf, 0, buf.Length); Assert.Equal(0, bytesread); } }
public void ShrinkFromTwoSegment() { PooledMemoryStream stream = s_manager.GetStream(); byte[] buffer = new byte[12]; new Random(42).NextBytes(buffer); stream.Write(buffer); stream.Write(buffer); Assert.Equal(32, stream.Capacity); Assert.Equal(24, stream.Length); Assert.Equal(24, stream.Position); stream.SetLength(12); Assert.Equal(16, stream.Capacity); Assert.Equal(12, stream.Length); Assert.Equal(12, stream.Position); stream.Seek(0, SeekOrigin.Begin); byte[] buffer2 = new byte[12]; Assert.Equal(12, stream.Read(buffer2)); Assert.True(buffer2.AsSpan(0, 12).SequenceEqual(buffer.AsSpan(0, 12))); }
private static (int bytesRead, byte[] actual) ReadSomeBytes(PooledMemoryStream stream, int length) { var actual = new byte[length]; int readBytes = stream.Read(actual, 0, actual.Length); return(readBytes, actual); }
public void Segmented_Data_Written_Can_Be_Read_Back_In_Segments() { var sizes = new int[] { 128 + 256 + 512 + 1024 + 1024 + 2, 200, 1000, 1024 * 1024 }; var pool = new BufferManagerAllocator(1024, 1024 * 1024); const int STEP_WRITE = 37; foreach (var size in sizes) { using (var stream = new PooledMemoryStream(pool)) { var remaining = size; var data = new byte[STEP_WRITE]; byte value = 1; for (var i = 0; i < size - (size % STEP_WRITE); i += STEP_WRITE) { Fill(data, value); stream.Write(data, 0, data.Length); value++; remaining -= STEP_WRITE; } if (remaining > 0) { Fill(data, value); stream.Write(data, 0, remaining); } Assert.Equal(size, stream.Position); Assert.Equal(size, stream.Length); stream.Position = 0; Assert.Equal(0, stream.Position); var copy = new byte[STEP_WRITE]; value = 1; for (var i = 0; i < size - (size % STEP_WRITE); i += STEP_WRITE) { Fill(data, value); Fill(copy, (byte)(value - 1)); stream.Read(copy, 0, copy.Length); value++; remaining -= STEP_WRITE; Assert.Equal(data, copy); } if (remaining > 0) { Fill(data, value); stream.Write(data, 0, remaining); Assert.Equal(data.Take(remaining), copy.Take(remaining)); } } } }
public void Can_Rewrite_Stream() { var pool = new BufferManagerAllocator(1024, 1024 * 1024); var stream = new PooledMemoryStream(pool); var chunk = new byte[60]; for (var i = 0; i < 10; i++) { Fill(chunk, (byte)(i + 1)); stream.Write(chunk, 0, chunk.Length); Assert.Equal((i + 1) * 60, stream.Position); Assert.Equal((i + 1) * 60, stream.Length); } stream.Position = 120; Fill(chunk, 200); stream.Write(chunk, 0, chunk.Length); stream.Position = 370; Fill(chunk, 100); stream.Write(chunk, 0, chunk.Length); Assert.Equal(430, stream.Position); Assert.Equal(600, stream.Length); var all = new byte[stream.Length]; stream.Position = 0; stream.Read(all, 0, all.Length); Assert.Equal(600, stream.Position); Assert.Equal(600, stream.Length); var expected = new[] { Enumerable.Repeat(1, 60), // 0 Enumerable.Repeat(2, 60), // 60 Enumerable.Repeat(200, 60), // 120 Enumerable.Repeat(4, 60), // 180 Enumerable.Repeat(5, 60), // 240 Enumerable.Repeat(6, 60), // 300 Enumerable.Repeat(7, 10), // 360 Enumerable.Repeat(100, 60), // 370 Enumerable.Repeat(8, 50), // 430 Enumerable.Repeat(9, 60), // 480 Enumerable.Repeat(10, 60), // 540 }; var expectedValue = expected.SelectMany(_ => _.Select(v => (byte)v)).ToArray(); Assert.Equal(expectedValue.Length, all.Length); Assert.Equal(stream.Length, all.Length); AssertArray(expectedValue, all); }
public void SetLengthOnEmptyInstance() { PooledMemoryStream stream = s_manager.GetStream(); stream.SetLength(10); Assert.Equal(10, stream.Length); Assert.Equal(16, stream.Capacity); Assert.Equal(0, stream.Position); byte[] buffer = new byte[11]; new Random(42).NextBytes(buffer); Assert.Equal(10, stream.Read(buffer, 0, 10)); Assert.True(buffer.AsSpan(0, 10).SequenceEqual(s_emptyBytes.AsSpan(0, 10))); stream.Seek(0, SeekOrigin.Begin); Assert.Equal(10, stream.Read(buffer, 0, 11)); }
[TestCase(Constants.KB + 11, 256)] // content doesn't line up with buffers (extremely unlikely any array pool implementation will add exactly 11 bytes more than requested across 4 buffers) public async Task ReadStream(int dataSize, int bufferPartitionSize) { PredictableStream originalStream = new PredictableStream(); PooledMemoryStream arrayPoolStream = await PooledMemoryStream.BufferStreamPartitionInternal(originalStream, dataSize, dataSize, 0, _pool, bufferPartitionSize, true, default); originalStream.Position = 0; byte[] originalStreamData = new byte[dataSize]; byte[] poolStreamData = new byte[dataSize]; originalStream.Read(originalStreamData, 0, dataSize); arrayPoolStream.Read(poolStreamData, 0, dataSize); CollectionAssert.AreEqual(originalStreamData, poolStreamData); }
public static void MemoryStream_WriteToTests() { using (PooledMemoryStream ms2 = new PooledMemoryStream()) { byte[] bytArrRet; byte[] bytArr = new byte[] { byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250 }; // [] Write to FileStream, check the filestream ms2.Write(bytArr, 0, bytArr.Length); using (PooledMemoryStream readonlyStream = new PooledMemoryStream()) { ms2.WriteTo(readonlyStream); readonlyStream.Flush(); readonlyStream.Position = 0; bytArrRet = new byte[(int)readonlyStream.Length]; readonlyStream.Read(bytArrRet, 0, (int)readonlyStream.Length); for (int i = 0; i < bytArr.Length; i++) { Assert.Equal(bytArr[i], bytArrRet[i]); } } } // [] Write to memoryStream, check the memoryStream using (PooledMemoryStream ms2 = new PooledMemoryStream()) using (PooledMemoryStream ms3 = new PooledMemoryStream()) { byte[] bytArrRet; byte[] bytArr = new byte[] { byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250 }; ms2.Write(bytArr, 0, bytArr.Length); ms2.WriteTo(ms3); ms3.Position = 0; bytArrRet = new byte[(int)ms3.Length]; ms3.Read(bytArrRet, 0, (int)ms3.Length); for (int i = 0; i < bytArr.Length; i++) { Assert.Equal(bytArr[i], bytArrRet[i]); } } }
public void Should_be_able_to_read_from_stream() { using (var stream = new PooledMemoryStream()) { var memory = new MemoryStream(); byte[] origin = WriteSomeBytes(memory, _dataSize); memory.Position = 0; stream.Write(memory, origin.Length); var actual = new byte[origin.Length]; stream.Position = 0; int readBytes = stream.Read(actual, 0, actual.Length); readBytes.Should().Be(origin.Length); actual.Should().BeEquivalentTo(origin); } }
private PooledSegment SerializeObject(object value) { using (var ms = new PooledMemoryStream(allocator)) { new BinaryFormatter().Serialize(ms, value); var retval = new PooledSegment(allocator, (int)ms.Length); ms.Position = 0; ms.Read(retval.Array, 0, retval.Count); return retval; } }