public void ChunkedMemoryStream_Read_CanReadPartOfDataOutCorrectly()
{
var buffers = new[]
{
new byte[10] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
},
new byte[20] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
}
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
var outBuffer = new byte[30];
// Read first 20 bytes out
var bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 20);
Assert.AreEqual(20, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i, outBuffer[i]);
}
// Read last 20 bytes out
chunkedMemoryStream.Position = 10;
bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 20);
Assert.AreEqual(20, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i + 10, outBuffer[i]);
}
}
static void Main(string[] args)
{
ChunkedMemoryStream cms = new ChunkedMemoryStream();
Debug.Assert(cms.Length == 0);
Debug.Assert(cms.Position == 0);
cms.Position = 0;
byte[] helloworld = Encoding.UTF8.GetBytes("hello world");
cms.Write(helloworld, 0, 3);
cms.Write(helloworld, 3, 3);
cms.Write(helloworld, 6, 5);
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 11);
cms.Position = 0;
byte[] b = new byte[20];
cms.Read(b, 3, (int)cms.Length);
Debug.Assert(b.Skip(3).Take(11).SequenceEqual(helloworld));
cms.Position = 0;
cms.Write(Encoding.UTF8.GetBytes("seeya"), 0, 5);
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 5);
cms.Position = 0;
cms.Read(b, 0, (byte)cms.Length);
Debug.Assert(b.Take(11).SequenceEqual(Encoding.UTF8.GetBytes("seeya world")));
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 11);
cms.Write(Encoding.UTF8.GetBytes(" again"), 0, 6);
Debug.Assert(cms.Length == 17);
Debug.Assert(cms.Position == 17);
cms.Position = 0;
cms.Read(b, 0, (byte)cms.Length);
Debug.Assert(b.Take(17).SequenceEqual(Encoding.UTF8.GetBytes("seeya world again")));
}
public void Write_100_bytes_Read_100_bytes()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void ChunkedMemoryStream_Read_CanReadAllDataOutCorrectlyWhenUndelyingBufferSizeIsGreaterThanActualLength()
{
var buffers = new[]
{
new byte[10] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
},
new byte[20] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
}
};
// Length 20 is less than the underlying buffer length 30
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 20);
Assert.AreEqual(20, chunkedMemoryStream.Length);
var outBuffer = new byte[20];
// Read all out
var bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 20);
Assert.AreEqual(20, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i, outBuffer[i]);
}
}
public void ChunkedMemoryStream_Read_CanReadAllTheDataOutCorrectly()
{
var buffers = new[]
{
new byte[10] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
},
new byte[20] {
10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29
}
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
var outBuffer = new byte[30];
// Read all the data
var bytesRead = chunkedMemoryStream.Read(outBuffer, 0, 30);
Assert.AreEqual(30, bytesRead);
for (int i = 0; i < buffers.Length; i++)
{
Assert.AreEqual(i, outBuffer[i]);
}
}
public void Write_64k_bytes_Truncate_17k_Read_64k()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.SetLength(17 * 1024);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(17 * 1024, read);
Assert.AreEqual(bytes.Take(17 * 1024).ToArray(), buffer.Take(17 * 1024).ToArray());
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Read_from_an_initialized_buffer()
{
var originalBytes = GetBytes(100);
var stream = new ChunkedMemoryStream(originalBytes);
var readBytes = new byte[100];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(originalBytes, readBytes);
}
public void Write_100_bytes_100_times_Read_10000_bytes()
{
byte[] bytes = GetBytes(100);
byte[][] arrays = new byte[100][];
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
arrays[i] = bytes;
}
stream.Position = 0;
byte[] buffer = new byte[100 * bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(ArrayUtil.Concat(arrays), buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Read_from_an_initialized_buffer()
{
var originalBytes = GetBytes(100);
var stream = new ChunkedMemoryStream(originalBytes);
var readBytes = new byte[100];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(originalBytes, readBytes);
}
public void Write_100_bytes_100_times_Read_10000_bytes()
{
byte[] bytes = GetBytes(100);
byte[][] arrays = new byte[100][];
var stream = new ChunkedMemoryStream();
for (int i = 0; i < 100; ++i)
{
stream.Write(bytes, 0, bytes.Length);
arrays[i] = bytes;
}
stream.Position = 0;
byte[] buffer = new byte[100 * bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(ArrayUtil.Concat(arrays), buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_fixed_buffer_with_offset()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 10);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
stream.Position = 0;
var readBytes = new byte[10];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(writtenBytes, readBytes);
}
public void MemoryStream_ReadByteBufferTest(int length)
{
using MemoryStream ms = this.CreateTestStream(length);
using var cms = new ChunkedMemoryStream(this.allocator);
ms.CopyTo(cms);
cms.Position = 0;
var expected = ms.ToArray();
var buffer = new byte[2];
for (int i = 0; i < expected.Length; i += 2)
{
cms.Read(buffer);
Assert.Equal(expected[i], buffer[0]);
Assert.Equal(expected[i + 1], buffer[1]);
}
}
public void MemoryStream_ReadTest_Negative()
{
var ms2 = new ChunkedMemoryStream(this.allocator);
Assert.Throws <ArgumentNullException>(() => ms2.Read(null, 0, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => ms2.Read(new byte[] { 1 }, -1, 0));
Assert.Throws <ArgumentOutOfRangeException>(() => ms2.Read(new byte[] { 1 }, 0, -1));
Assert.Throws <ArgumentException>(() => ms2.Read(new byte[] { 1 }, 2, 0));
Assert.Throws <ArgumentException>(() => ms2.Read(new byte[] { 1 }, 0, 2));
ms2.Dispose();
Assert.Throws <ObjectDisposedException>(() => ms2.Read(new byte[] { 1 }, 0, 1));
}
public static void MemoryStream_WriteToTests()
{
using (var ms2 = new ChunkedMemoryStream())
{
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 (var readonlyStream = new ChunkedMemoryStream())
{
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 (var ms2 = new ChunkedMemoryStream())
using (var ms3 = new ChunkedMemoryStream())
{
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 MemoryStream_WriteByteTests()
{
using (var ms2 = new ChunkedMemoryStream(this.allocator))
{
byte[] bytArrRet;
byte[] bytArr = new byte[] { byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250 };
for (int i = 0; i < bytArr.Length; i++)
{
ms2.WriteByte(bytArr[i]);
}
using var readonlyStream = new ChunkedMemoryStream(this.allocator);
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]);
}
}
}
public void Write_fixed_buffer_with_offset()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 10);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
stream.Position = 0;
var readBytes = new byte[10];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(writtenBytes, readBytes);
}
public void Write_64k_bytes_Truncate_17k_Read_64k()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.SetLength(17 * 1024);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(17 * 1024, read);
Assert.AreEqual(bytes.Take(17 * 1024).ToArray(), buffer.Take(17 * 1024).ToArray());
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_64k_bytes_Read_64k_bytes()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_100_bytes_100_times_Read_100_bytes_100_times()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
}
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
for(int i = 0; i < 100; ++i) {
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
}
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void TestRead()
{
using (var stream = new ChunkedMemoryStream(8)) {
for (var i = 0; i < 32; i++) {
stream.WriteByte((byte)i);
}
Assert.AreEqual(0L, stream.Seek(0, SeekOrigin.Begin));
var buffer = new byte[16];
Assert.AreEqual(1, stream.Read(buffer, 0, 1));
Assert.AreEqual(new byte[] {0x00}, buffer.Slice(0, 1));
Assert.AreEqual(1L, stream.Position);
Assert.AreEqual(3, stream.Read(buffer, 0, 3));
Assert.AreEqual(new byte[] {0x01, 0x02, 0x03}, buffer.Slice(0, 3));
Assert.AreEqual(4L, stream.Position);
Assert.AreEqual(4, stream.Read(buffer, 0, 4));
Assert.AreEqual(new byte[] {0x04, 0x05, 0x06, 0x07}, buffer.Slice(0, 4));
Assert.AreEqual(8L, stream.Position);
Assert.AreEqual(7, stream.Read(buffer, 0, 7));
Assert.AreEqual(new byte[] {0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e}, buffer.Slice(0, 7));
Assert.AreEqual(15L, stream.Position);
Assert.AreEqual(2, stream.Read(buffer, 0, 2));
Assert.AreEqual(new byte[] {0x0f, 0x10}, buffer.Slice(0, 2));
Assert.AreEqual(17L, stream.Position);
Assert.AreEqual(15, stream.Read(buffer, 0, 16));
Assert.AreEqual(new byte[] {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, buffer.Slice(0, 15));
Assert.AreEqual(32L, stream.Position);
}
}
