public void Read_ShouldReadBytesAndMovePositionInStreamIndependentlyForEachSharedInstance()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream1 = new SharedMemoryStream(bytes);
var sharedMemoryStream2 = sharedMemoryStream1.MakeShared();
sharedMemoryStream1.Position = 123;
sharedMemoryStream2.Position = 321;
// Assume
Assume.That(sharedMemoryStream1.Position, Is.EqualTo(123));
Assume.That(sharedMemoryStream2.Position, Is.EqualTo(321));
// Act
var buffer1 = new byte[10];
var read1 = sharedMemoryStream1.Read(buffer1, 0, 10);
var buffer2 = new byte[100];
var read2 = sharedMemoryStream2.Read(buffer2, 0, 100);
// Assert
Assert.That(read1, Is.EqualTo(10));
Assert.That(buffer1, Is.EqualTo(bytes.Skip(123).Take(10)));
Assert.That(sharedMemoryStream1.Position, Is.EqualTo(133));
Assert.That(read2, Is.EqualTo(100));
Assert.That(buffer2, Is.EqualTo(bytes.Skip(321).Take(100)));
Assert.That(sharedMemoryStream2.Position, Is.EqualTo(421));
}
public void ReadLengthZeroAtEnd()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Seek(0, System.IO.SeekOrigin.End);
Assert.Equal(0, sms.Read(buffer1, 0, 0));
}
}
public void NoReadBeyondCapacity()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Write(buffer1, 0, buffer1.Length);
sms.Seek(0, System.IO.SeekOrigin.Begin);
byte[] localBuf = new byte[buffer1.Length * 2];
int amount = sms.Read(localBuf, 0, localBuf.Length);
Assert.Equal(buffer1.Length, amount);
}
}
public void Read_ShouldThrowExceptionWhenStreamDisposed()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
sharedMemoryStream.Dispose();
// Act
// Assert
Assert.That(() => sharedMemoryStream.Read(new byte[100], 0, 100), Throws.TypeOf <ObjectDisposedException>());
}
public void ConstructorFromByteArray_ShouldCreateStreamFromByteArray()
{
// Arrange
var bytes = GetRandomBytes();
// Act
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Assert
var buffer = new byte[bytes.Length];
sharedMemoryStream.Read(buffer, 0, buffer.Length);
Assert.That(buffer, Is.EqualTo(bytes));
}
public void ReadAfterWriteResultsInSameData()
{
using (var sms = new SharedMemoryStream(buffer1.Length))
{
sms.Write(buffer1, 0, buffer1.Length);
sms.Seek(0, System.IO.SeekOrigin.Begin);
byte[] readBack = new byte[buffer1.Length];
int amount = sms.Read(readBack, 0, readBack.Length);
Assert.Equal(buffer1.Length, amount);
Assert.Equal(buffer1, readBack);
}
}
public void NoReadNullArray()
{
using (var sms = new SharedMemoryStream(buffer1.Length - 1))
try
{
sms.Read(null, 0, 10);
}
catch (ArgumentException)
{
Assert.True(true);
return;
}
Assert.True(false);
}
public void NoReadNegative()
{
using (var sms = new SharedMemoryStream(buffer1.Length - 1))
try
{
sms.Read(buffer1, 0, -1);
}
catch (ArgumentOutOfRangeException)
{
Assert.True(true);
return;
}
Assert.True(false);
}
public void Read_ShouldReadBytesAndMovePositionInStream()
{
// Arrange
var bytes = GetRandomBytes();
var sharedMemoryStream = new SharedMemoryStream(bytes);
// Assume
Assume.That(sharedMemoryStream.Position, Is.Zero);
// Act
var buffer = new byte[123];
var read = sharedMemoryStream.Read(buffer, 0, 123);
// Assert
Assert.That(read, Is.EqualTo(123));
Assert.That(buffer, Is.EqualTo(bytes.Take(123)));
Assert.That(sharedMemoryStream.Position, Is.EqualTo(123));
}
public void NoReadUnwritten()
{
using (var sms = new SharedMemoryStream(buffer1.Length * 2))
{
sms.Write(buffer1, 0, buffer1.Length);
byte[] one = new byte[] { 5 };
sms.Write(one, 0, one.Length);
sms.Seek(0, System.IO.SeekOrigin.Begin);
byte[] outData = new byte[buffer1.Length + one.Length];
int read = sms.Read(outData, 0, buffer1.Length + one.Length);
Assert.Equal(read, buffer1.Length + one.Length);
}
}
protected override void OnHandler(ParameterHandlerInfo info)
{
Core.Log.Warning("Starting MEMORY STREAMS TEST");
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start RecycleMemoryStream Test.");
Console.ReadLine();
var xbuffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
using (Watch.Create("RecycleMemoryStream"))
{
for (var m = 0; m < 50000; m++)
{
using (var rms = new RecycleMemoryStream())
{
for (var x = 0; x < 1; x++)
{
for (int i = 0; i < 10000; i++)
{
rms.Write(xbuffer, 0, xbuffer.Length);
}
}
rms.Position = 0;
for (var x = 0; x < 10; x++)
{
for (int i = 0; i < 2000; i++)
{
var bt = rms.ReadByte();
}
}
}
}
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start MemoryStream Test.");
Console.ReadLine();
using (Watch.Create("MemoryStream"))
{
for (var m = 0; m < 50000; m++)
{
using (var rms = new MemoryStream())
{
for (var x = 0; x < 1; x++)
{
for (var i = 0; i < 10000; i++)
{
rms.Write(xbuffer, 0, xbuffer.Length);
}
}
rms.Position = 0;
for (var x = 0; x < 10; x++)
{
for (var i = 0; i < 2000; i++)
{
var bt = rms.ReadByte();
}
}
}
}
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start CircularBufferStream Test. Press Enter Again to finish the test.");
Console.ReadLine();
using (var cbs = new CircularBufferStream(50))
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
var i = 0;
while (!cts.Token.IsCancellationRequested)
{
i++;
cbs.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 });
if (i % 50 == 0)
{
Core.Log.InfoMedium("Write {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
var i = 0;
var buffer = new byte[15];
while (!cts.Token.IsCancellationRequested)
{
i++;
cbs.Read(buffer, 0, 7);
if (i % 50 == 0)
{
Core.Log.InfoMedium("Read {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Console.ReadLine();
cts.Cancel();
}
Core.Log.WriteEmptyLine();
Core.Log.InfoBasic("Press Enter to Start SharedMemoryStream Test. Press Enter Again to finish the test.");
Console.ReadLine();
using (var sharedms = new SharedMemoryStream("test", 2000))
{
var cts = new CancellationTokenSource();
Task.Run(async() =>
{
var i = 0;
while (!cts.Token.IsCancellationRequested)
{
i++;
sharedms.WriteBytes(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 });
if (i % 50 == 0)
{
Core.Log.InfoMedium("Write {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Task.Run(async() =>
{
var i = 0;
var buffer = new byte[15];
while (!cts.Token.IsCancellationRequested)
{
i++;
sharedms.Read(buffer, 0, 7);
if (i % 50 == 0)
{
Core.Log.InfoMedium("Read {0}", i);
}
await Task.Delay(1, cts.Token).ConfigureAwait(false);
}
});
Console.ReadLine();
}
}
