public void Write_Call_Properly_Checks_The_Constraints_When_Stream_Is_Null(byte[] nullBuff)
{
using (var instance = new ByteCountStream())
{
//null buff
var err = Assert.Throws <DdnDfException>(() => instance.Write(nullBuff, 0, 0));
Assert.NotNull(err);
Assert.True(err.ErrorCode == DdnDfErrorCode.NullObject);
// -ve offset
err = Assert.Throws <DdnDfException>(() => instance.Write(new byte[0], -1, 0));
Assert.NotNull(err);
Assert.True(err.ErrorCode == DdnDfErrorCode.ValueLessThanThreshold);
// -ve count
err = Assert.Throws <DdnDfException>(() => instance.Write(new byte[0], 0, -1));
Assert.NotNull(err);
Assert.True(err.ErrorCode == DdnDfErrorCode.ValueLessThanThreshold);
// buff length < offset + count
err = Assert.Throws <DdnDfException>(() => instance.Write(new byte[0], 0, 1));
Assert.NotNull(err);
Assert.True(err.ErrorCode == DdnDfErrorCode.ValueLessThanThreshold);
//this would pass
instance.Write(new byte[0], 0, 0);
}
}
public void Write_Call_Properly_Estimates_The_Count(int buffSize)
{
using (var mem = new MemoryStream())
{
using (var instance = new ByteCountStream(mem, true))
{
var buffer = new byte[buffSize];
for (var i = 0; i < buffSize; i++)
{
buffer[i] = 5;
}
instance.Write(buffer, 0, buffSize);
Assert.True(instance.ByteCount == mem.Length);
using (var mem1 = new MemoryStream())
{
instance.ResetWith(mem1, true);
buffer = new byte[buffSize];
for (var i = 0; i < buffSize; i++)
{
buffer[i] = 5;
}
instance.Write(buffer, 0, buffSize);
Assert.True(instance.ByteCount == mem.Length);
}
}
}
}
public void Properties_With_Null_Stream_Works_As_Expected()
{
var instance = new ByteCountStream();
using (instance)
{
Assert.True(instance.CanRead);
Assert.True(instance.CanWrite);
Assert.True(instance.CanSeek);
Assert.False(instance.CanTimeout);
Assert.True(instance.InnerStream == Stream.Null);
Assert.True(instance.Position == 0);
instance.Position = 10;
Assert.True(instance.Position == 0);
Assert.True(instance.Length == 0);
instance.SetLength(10);
Assert.True(instance.Length == 0);
Assert.True(instance.Seek(10, SeekOrigin.Begin) == 0);
Assert.True(instance.ByteCount == 0);
instance.Flush();
}
//Available after dispose
Assert.True(instance.ByteCount == 0);
Assert.Throws <ObjectDisposedException>(() =>
{
var _ = instance.CanSeek;
});
Assert.Null(instance.InnerStream);
}
internal static Func <Task <PullFuncStream> > ApplyByteCount(this Func <Task <PullFuncStream> > pipe,
ByteCountStream bcs)
{
return(async() =>
{
var data = await pipe().StartIfNeeded().ConfigureAwait(false);
return data.ApplyByteCount(bcs);
});
}
public void Read_Call_Properly_Estimates_The_Count(int buffSize)
{
using (var mem = new MemoryStream(TestValues.BigString.ToBytes()))
{
using (var instance = new ByteCountStream(mem, true))
{
var buffer = new byte[buffSize];
var cnt = instance.Read(buffer, 0, buffSize);
Assert.True(instance.ByteCount == cnt);
}
}
}
public void LeaveOpen_Logic_Works_As_Expected(bool leaveOpen)
{
var strm = Substitute.For <Stream>();
using (var _ = new ByteCountStream(strm, leaveOpen))
{
//dual dispose must work
using (_)
{ }
}
strm.Received(leaveOpen ? 0 : 1).Dispose();
}
// we keep internal extensions here
internal static Func <PushFuncStream, Task> ApplyByteCount(this Func <PushFuncStream, Task> pipe,
ByteCountStream bcs)
{
return(async pfs =>
{
bcs.ResetWith(pfs.Writable, pfs.Dispose);
using (bcs)
{
var t = pfs.Token;
await pipe(new PushFuncStream(bcs, false, t)).StartIfNeeded()
.ConfigureAwait(false);
await bcs.FlushAsync(t).ConfigureAwait(false);
}
});
}
internal static PullFuncStream ApplyByteCount(this PullFuncStream data, ByteCountStream bcs)
{
bcs.ResetWith(data.Readable, data.Dispose);
return(new PullFuncStream(bcs, true));
}
internal static Func <PullFuncStream> ApplyByteCount(this Func <PullFuncStream> pipe,
ByteCountStream bcs)
{
return(() => pipe().ApplyByteCount(bcs));
}
