public void CopyToAsync_CopiesFromStart_AfterReset(TestStreamInitInfo info)
{
var skippedBytes = info.SegmentSize;
var writeStream = new SegmentWriteStream(info.SegmentSize);
var stream = new SegmentReadStream(info.Segments, info.Length);
stream.Read(new byte[skippedBytes], 0, skippedBytes);
stream.CopyTo(writeStream);
// Assert bytes read from current location to the end
Assert.Equal(stream.Length, stream.Position);
Assert.Equal(stream.Length - skippedBytes, writeStream.Length);
// Reset
stream.Position = 0;
writeStream = new SegmentWriteStream(info.SegmentSize);
stream.CopyTo(writeStream);
Assert.Equal(stream.Length, stream.Position);
Assert.Equal(stream.Length, writeStream.Length);
var writeSegments = writeStream.GetSegments();
for (var i = 0; i < info.Segments.Count; i++)
{
Assert.True(writeSegments[i].SequenceEqual(info.Segments[i]));
}
}
public void Write_CanWriteAllBytes(int writeSize)
{
var segmentSize = 5;
var stream = new SegmentWriteStream(segmentSize);
for (var i = 0; i < WriteData.Length; i += writeSize)
{
stream.Write(WriteData, i, Math.Min(writeSize, WriteData.Length - i));
}
var segments = stream.GetSegments();
Assert.Equal(WriteData.Length, stream.Length);
Assert.Equal((WriteData.Length + segmentSize - 1) / segmentSize, segments.Count);
for (var i = 0; i < WriteData.Length; i += segmentSize)
{
var expectedSegmentSize = Math.Min(segmentSize, WriteData.Length - i);
var expectedSegment = new byte[expectedSegmentSize];
for (int j = 0; j < expectedSegmentSize; j++)
{
expectedSegment[j] = (byte)(i + j);
}
var segment = segments[i / segmentSize];
Assert.Equal(expectedSegmentSize, segment.Length);
Assert.True(expectedSegment.SequenceEqual(segment));
}
}
public void GetSegments_ExtractionDisablesWriting()
{
var stream = new SegmentWriteStream(1);
Assert.True(stream.CanWrite);
Assert.Empty(stream.GetSegments());
Assert.False(stream.CanWrite);
}
public void ReadAndSeekOperations_Throws()
{
var stream = new SegmentWriteStream(1);
Assert.Throws <NotSupportedException>(() => stream.Read(new byte[1], 0, 0));
Assert.Throws <NotSupportedException>(() => stream.Position = 0);
Assert.Throws <NotSupportedException>(() => stream.Seek(0, SeekOrigin.Begin));
}
internal ResponseCachingStream(Stream innerStream, long maxBufferSize, int segmentSize, Action startResponseCallback)
{
_innerStream = innerStream;
_maxBufferSize = maxBufferSize;
_segmentSize = segmentSize;
_startResponseCallback = startResponseCallback;
_segmentWriteStream = new SegmentWriteStream(_segmentSize);
}
public void CopyToAsync_CopiesAllBytes(TestStreamInitInfo info)
{
var stream = new SegmentReadStream(info.Segments, info.Length);
var writeStream = new SegmentWriteStream(info.SegmentSize);
stream.CopyTo(writeStream);
Assert.Equal(stream.Length, stream.Position);
Assert.Equal(stream.Length, writeStream.Length);
var writeSegments = writeStream.GetSegments();
for (var i = 0; i < info.Segments.Count; i++)
{
Assert.True(writeSegments[i].SequenceEqual(info.Segments[i]));
}
}
public void CopyToAsync_CopiesFromCurrentPosition(TestStreamInitInfo info)
{
var skippedBytes = info.SegmentSize;
var writeStream = new SegmentWriteStream((int)info.Length);
var stream = new SegmentReadStream(info.Segments, info.Length);
stream.Read(new byte[skippedBytes], 0, skippedBytes);
stream.CopyTo(writeStream);
Assert.Equal(stream.Length, stream.Position);
Assert.Equal(stream.Length - skippedBytes, writeStream.Length);
var writeSegments = writeStream.GetSegments();
for (var i = skippedBytes; i < info.Length; i++)
{
Assert.Equal(info.Segments[i / info.SegmentSize][i % info.SegmentSize], writeSegments[0][i - skippedBytes]);
}
}
