public void ReadTest()
{
byte[] buf = new byte[this.length];
int counter = 0;
using (MemoryStream memstream = new MemoryStream(this.buffer))
using (BandwidthLimitedStream stream = new BandwidthLimitedStream(memstream, limit: this.length)) {
DateTime start = DateTime.Now;
while (counter < this.length)
{
counter += stream.Read(buf, 0, this.length - counter);
}
TimeSpan duration = DateTime.Now - start;
Assert.GreaterOrEqual(duration.TotalMilliseconds, 1000);
Assert.AreEqual(1, duration.TotalSeconds);
}
counter = 0;
using (MemoryStream memstream = new MemoryStream(this.buffer))
using (BandwidthLimitedStream stream = new BandwidthLimitedStream(memstream)) {
DateTime start = DateTime.Now;
while (counter < this.length)
{
counter += stream.Read(buf, 0, this.length - counter);
}
TimeSpan duration = DateTime.Now - start;
Assert.GreaterOrEqual(duration.TotalMilliseconds, 1000);
Assert.AreEqual(1, duration.TotalSeconds);
}
}
public void ConfigureLimitsTest()
{
long limit = this.length;
using (Stream memory = new MemoryStream(this.buffer))
using (BandwidthLimitedStream limited = new BandwidthLimitedStream(memory)) {
Assert.Less(limited.ReadLimit, 0);
Assert.Less(limited.WriteLimit, 0);
limited.ReadLimit = limit;
Assert.AreEqual(limit, limited.ReadLimit);
Assert.Less(limited.WriteLimit, 0);
limited.WriteLimit = limit;
Assert.AreEqual(limit, limited.ReadLimit);
Assert.AreEqual(limit, limited.WriteLimit);
limited.DisableLimits();
Assert.Less(limited.ReadLimit, 0);
Assert.Less(limited.WriteLimit, 0);
limited.ReadLimit = limit;
limited.WriteLimit = limit;
Assert.AreEqual(limit, limited.ReadLimit);
Assert.AreEqual(limit, limited.WriteLimit);
limited.DisableReadLimit();
Assert.Less(limited.ReadLimit, 0);
Assert.AreEqual(limit, limited.WriteLimit);
limited.DisableWriteLimit();
Assert.Less(limited.ReadLimit, 0);
Assert.Less(limited.WriteLimit, 0);
}
}
public void ConstructorWithoutLimits()
{
using (var memory = new MemoryStream(this.buffer))
using (var underTest = new BandwidthLimitedStream(memory)) {
Assert.That(underTest.ReadLimit, Is.Null);
Assert.That(underTest.WriteLimit, Is.Null);
}
}
public void ConstructorTest()
{
long limit = 0;
limit = this.length;
using (Stream memory = new MemoryStream(this.buffer))
using (BandwidthLimitedStream limited = new BandwidthLimitedStream(memory, limit)) {
Assert.AreEqual(limit, limited.ReadLimit);
Assert.AreEqual(limit, limited.WriteLimit);
}
using (Stream memory = new MemoryStream(this.buffer))
using (BandwidthLimitedStream limited = new BandwidthLimitedStream(memory)) {
Assert.Less(limited.ReadLimit, 0);
Assert.Less(limited.WriteLimit, 0);
}
}
public void ConstructorThrowsExceptionIfBothParametersAreInvalid()
{
try
{
using (BandwidthLimitedStream limited = new BandwidthLimitedStream(null, -10))
{
}
}
catch (ArgumentNullException)
{
throw new Exception();
}
catch (ArgumentException)
{
throw new Exception();
}
}
public void ReadOrWriteOneByteMoreThanLimitTakesAtMinimumOneSecond([Values(true, false)] bool read)
{
byte[] buf = new byte[this.length];
using (var memstream = new MemoryStream(this.buffer))
using (var underTest = new BandwidthLimitedStream(memstream, limit: this.limit)) {
var start = DateTime.Now;
if (read)
{
underTest.Read(buf, 0, (int)this.limit + 1);
}
else
{
underTest.Write(buf, 0, (int)this.limit + 1);
}
TimeSpan duration = DateTime.Now - start;
Assert.That(duration.TotalMilliseconds, Is.AtLeast(1000));
}
}
public void SetAndGetReadAndWriteLimits([Values(true, false)] bool limitRead, [Values(true, false)] bool limitWrite)
{
using (var memory = new MemoryStream(this.buffer))
using (var underTest = new BandwidthLimitedStream(memory)) {
Assert.That(underTest.ReadLimit, Is.Null);
Assert.That(underTest.WriteLimit, Is.Null);
underTest.ReadLimit = limitRead ? this.limit : (long?)null;
Assert.That(underTest.ReadLimit, Is.EqualTo(limitRead ? this.limit : (long?)null));
Assert.That(underTest.WriteLimit, Is.Null);
underTest.WriteLimit = limitWrite ? this.limit : (long?)null;
Assert.That(underTest.ReadLimit, Is.EqualTo(limitRead ? this.limit : (long?)null));
Assert.That(underTest.WriteLimit, Is.EqualTo(limitWrite ? this.limit : (long?)null));
underTest.DisableReadLimit();
Assert.That(underTest.ReadLimit, Is.Null);
Assert.That(underTest.WriteLimit, Is.EqualTo(limitWrite ? this.limit : (long?)null));
underTest.DisableWriteLimit();
Assert.That(underTest.ReadLimit, Is.Null);
Assert.That(underTest.WriteLimit, Is.Null);
}
}
public void WriteTest()
{
byte[] buf = new byte[this.length];
using (MemoryStream memstream = new MemoryStream(this.buffer))
using (BandwidthLimitedStream stream = new BandwidthLimitedStream(memstream, limit: this.length)) {
DateTime start = DateTime.Now;
stream.Write(buf, 0, this.length);
TimeSpan duration = DateTime.Now - start;
Assert.GreaterOrEqual(duration.TotalMilliseconds, 1000);
Assert.AreEqual(1, duration.TotalSeconds);
}
using (MemoryStream memstream = new MemoryStream(this.buffer))
using (BandwidthLimitedStream stream = new BandwidthLimitedStream(memstream)) {
DateTime start = DateTime.Now;
stream.Write(buf, 0, this.length);
TimeSpan duration = DateTime.Now - start;
Assert.GreaterOrEqual(duration.TotalMilliseconds, 1000);
Assert.AreEqual(1, duration.TotalSeconds);
}
}
public void ChangingLimitsNotifiesListener()
{
using (var memory = new MemoryStream(this.buffer))
using (var underTest = new BandwidthLimitedStream(memory)) {
int readLimitNotified = 0;
int writeLimitNotified = 0;
long?expectedReadLimit = this.limit;
long?expectedWriteLimit = this.limit;
underTest.PropertyChanged += (sender, e) => {
Assert.That(sender, Is.EqualTo(underTest));
if (e.PropertyName == Utils.NameOf((BandwidthLimitedStream s) => s.ReadLimit))
{
readLimitNotified++;
Assert.That((sender as BandwidthLimitedStream).ReadLimit, Is.EqualTo(expectedReadLimit));
}
else if (e.PropertyName == Utils.NameOf((BandwidthLimitedStream s) => s.WriteLimit))
{
writeLimitNotified++;
Assert.That((sender as BandwidthLimitedStream).WriteLimit, Is.EqualTo(expectedWriteLimit));
}
};
underTest.WriteLimit = expectedWriteLimit;
underTest.ReadLimit = expectedReadLimit;
Assert.That(readLimitNotified, Is.EqualTo(1));
Assert.That(writeLimitNotified, Is.EqualTo(1));
expectedReadLimit = null;
expectedWriteLimit = null;
underTest.DisableLimits();
Assert.That(readLimitNotified, Is.EqualTo(2));
Assert.That(writeLimitNotified, Is.EqualTo(2));
}
}
public void ConstructorThrowsExceptionIfStreamIsNull()
{
using (BandwidthLimitedStream limited = new BandwidthLimitedStream(null, 1))
{
}
}
public void ConstructorThrowsExceptionIfLimitIsNegative()
{
using (BandwidthLimitedStream limited = new BandwidthLimitedStream(Mock.Of <Stream>(), -1))
{
}
}
