public void SeekToBegin()
{
using (var stream = GetResourceStream(ResourceName))
{
using (var bufferedStream = new CachingStream(stream))
{
bufferedStream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(0, bufferedStream.Position);
bufferedStream.Seek(10, SeekOrigin.Begin);
Assert.AreEqual(10, bufferedStream.Position);
}
}
}
public void CachingStreamSeeksToBeginTest()
{
using (var stream = TestHelpers.GetResourceStream(ResourceName))
{
using (var cachingStream = new CachingStream(stream))
{
cachingStream.Seek(0, SeekOrigin.Begin);
Assert.AreEqual(0, cachingStream.Position);
cachingStream.Seek(10, SeekOrigin.Begin);
Assert.AreEqual(10, cachingStream.Position);
}
}
}
public void CachingStreamFailsToSeekCurrentBeforeBeginTest()
{
using (var sourceStream = TestHelpers.GetResourceStream(ResourceName))
{
using (var cachingStream = new CachingStream(sourceStream))
{
cachingStream.Seek(100, SeekOrigin.Begin);
var exception = Assert.Throws <ArgumentOutOfRangeException>
(
() => { cachingStream.Seek(-101, SeekOrigin.Current); }
);
Assert.AreEqual(@"offset", exception.ParamName);
}
}
}
public void CachingStreamSeeksToEndTest()
{
using (var stream = TestHelpers.GetResourceStream(ResourceName))
{
using (var cachingStream = new CachingStream(stream))
{
cachingStream.Seek(0, SeekOrigin.End);
Assert.AreEqual(cachingStream.Length, cachingStream.Position);
}
}
}
public void CachingStreamSeeksCurrentTest()
{
using (var stream = TestHelpers.GetResourceStream(ResourceName))
{
using (var cachingStream = new CachingStream(stream))
{
var tempBuffer = new byte[100];
var bytesRead = cachingStream.Read(tempBuffer, 0, tempBuffer.Length);
Assert.AreEqual(tempBuffer.Length, bytesRead);
var position = cachingStream.Position;
Assert.AreEqual(position, cachingStream.Seek(0, SeekOrigin.Current));
position = cachingStream.Position;
Assert.AreEqual(position + 100, cachingStream.Seek(100, SeekOrigin.Current));
position = cachingStream.Position;
Assert.AreEqual(position - 55, cachingStream.Seek(-55, SeekOrigin.Current));
}
}
}
public void CachingStreamFailsToSeekWithUnknownOriginTest()
{
using (var sourceStream = TestHelpers.GetResourceStream(ResourceName))
{
using (var cachingStream = new CachingStream(sourceStream))
{
Assert.Throws <NotSupportedException>
(
() => { cachingStream.Seek(0, (SeekOrigin)100); }
);
}
}
}
public void CachingStreamFailsToSeekAfterEndTest()
{
using (var sourceStream = TestHelpers.GetResourceStream(ResourceName))
{
using (var cachingStream = new CachingStream(sourceStream))
{
var exception = Assert.Throws <ArgumentOutOfRangeException>
(
() => { cachingStream.Seek(1, SeekOrigin.End); }
);
Assert.AreEqual(@"offset", exception.ParamName);
}
}
}
public void Dispose()
{
var data = GenerateData(1000);
using (var memoryStream = new MemoryStream(data, writable: false))
using (var cachingStream = new CachingStream(memoryStream, Ownership.Owns))
{
cachingStream.Dispose();
Assert.Throws <ObjectDisposedException>(() => { cachingStream.Flush(); });
Assert.Throws <ObjectDisposedException>(() => { var temp = cachingStream.Length; });
Assert.Throws <ObjectDisposedException>(() => { var temp = cachingStream.Position; });
Assert.Throws <ObjectDisposedException>(() => { cachingStream.Position = 1; });
Assert.Throws <ObjectDisposedException>(() => cachingStream.ReadByte());
Assert.Throws <ObjectDisposedException>(() => cachingStream.Read(new byte[10], 0, 1));
Assert.Throws <ObjectDisposedException>(() => cachingStream.Seek(1, SeekOrigin.Begin));
}
}
public void SeekAndRead()
{
Random random = new Random(1);
var data = GenerateData(1234567);
using (var memoryStream = new MemoryStream(data, writable: false))
using (var cachingStream = new CachingStream(memoryStream, Ownership.Owns))
{
for (int i = 0; i < 100; i++)
{
int offset = random.Next(data.Length - 100);
int length = random.Next(1, data.Length - offset);
Assert.AreEqual(offset, cachingStream.Seek(offset, SeekOrigin.Begin));
var read = cachingStream.ReadExactly(length);
Assert.AreEqual(data.Skip(offset).Take(length), read);
}
}
}
public void SeekCurrent()
{
using (var stream = GetResourceStream(ResourceName))
{
using (var bufferedStream = new CachingStream(stream))
{
var tempBuffer = new byte[100];
var bytesRead = bufferedStream.Read(tempBuffer, 0, tempBuffer.Length);
Assert.AreEqual(tempBuffer.Length, bytesRead);
var position = bufferedStream.Position;
Assert.AreEqual(position, bufferedStream.Seek(0, SeekOrigin.Current));
position = bufferedStream.Position;
Assert.AreEqual(position + 100, bufferedStream.Seek(100, SeekOrigin.Current));
position = bufferedStream.Position;
Assert.AreEqual(position - 55, bufferedStream.Seek(-55, SeekOrigin.Current));
}
}
}
public void SeekAndCopyTo()
{
Random random = new Random(1);
var data = GenerateData(54321);
using (var memoryStream = new MemoryStream(data, writable: false))
using (var cachingStream = new CachingStream(memoryStream, Ownership.Owns))
{
for (int i = 0; i < 100; i++)
{
int offset = random.Next(data.Length - 100);
Assert.AreEqual(offset, cachingStream.Seek(offset, SeekOrigin.Begin));
using (var destination = new MemoryStream(data.Length))
{
cachingStream.CopyTo(destination);
Assert.AreEqual(data.Skip(offset), destination.ToArray());
}
}
}
}
public void SeekToEnd()
{
using (var stream = GetResourceStream(ResourceName))
{
using (var bufferedStream = new CachingStream(stream))
{
bufferedStream.Seek(0, SeekOrigin.End);
Assert.AreEqual(bufferedStream.Length, bufferedStream.Position);
}
}
}
