public void AfterDispose_UnusableMethodsThrow() { var subject = new SmallBlockMemoryStream(); subject.Dispose(); long dummy; var buffer = new byte[1]; var dummyTarget = new MemoryStream(); var actions = new Action[] { () => dummy = subject.Length, () => subject.SetLength(0), () => dummy = subject.Capacity, () => subject.Capacity = 100, () => dummy = subject.Position, () => subject.Position = 0, () => subject.Seek(0, SeekOrigin.Begin), () => subject.Write(buffer, 0, 1), () => subject.WriteByte(1), () => CallWriteTo(subject, dummyTarget), () => subject.Read(buffer, 0, 1), () => subject.ReadByte() }; foreach (var action in actions) { action.ShouldThrow <ObjectDisposedException>(); } }
public void Position_withBadParameters_fails() { var subject = new SmallBlockMemoryStream(); Action action = () => subject.Position = -10; action.ShouldThrow <ArgumentOutOfRangeException>(); }
private static void AssertEquivalent(MemoryStream standard, SmallBlockMemoryStream subject) { // length and position should be identical to standard subject.Length.Should().Be(standard.Length); subject.Position.Should().Be(standard.Position); // allocations should never exceed LOH limit var allocationSizes = subject.GetAllocationSizes(); allocationSizes.Any(x => x > SmallBlockMemoryStream.MaxBlockSize) .Should().BeFalse(); // capacity should match allocations var calculatedCapacity = allocationSizes.Sum(x => (long)Math.Max(0, x)); subject.Capacity.Should().Be(calculatedCapacity); // total allocation should be identical to the standard until the LOH limit // is exceeded... if (standard.Capacity < SmallBlockMemoryStream.MaxBlockSize) { calculatedCapacity.Should().Be(standard.Capacity); } // contents of the stream should be identical to the standard Assert.AreEqual(standard, subject); }
public void Seek_withBadParameters_fails() { var subject = new SmallBlockMemoryStream(); Action action = () => subject.Seek(0, (SeekOrigin)123); action.ShouldThrow <ArgumentException>(); }
private static void VerifyThrows <T>(Action <Stream> action) where T : Exception { using (var standard = new MemoryStream()) using (var subject = new SmallBlockMemoryStream()) { ((Action)(() => action(standard))).ShouldThrow <T>(); ((Action)(() => action(subject))).ShouldThrow <T>(); } }
private static void VerifyResultsAreEqual <T>(Func <Stream, T> func) { using (var standard = new MemoryStream()) using (var subject = new SmallBlockMemoryStream()) { Assert.AreEqual(func(standard), func(subject)); AssertEquivalent(standard, subject); } }
public void SmallBlockMemoryStream() { using (var stream = new SmallBlockMemoryStream()) { for (int position = 0; position < this.Length; position += blockSize) { stream.Write(this.data, position, Math.Min(blockSize, this.Length - position)); } } }
private static void VerifyAction(Action <Stream> action) { using (var standard = new MemoryStream()) using (var subject = new SmallBlockMemoryStream()) { action(standard); action(subject); AssertEquivalent(standard, subject); } }
public void Flush_AfterDispose_DoesNotThrow() { // Just to mimic the MemoryStream implementation var standard = new MemoryStream(); standard.Dispose(); standard.Flush(); var subject = new SmallBlockMemoryStream(); subject.Dispose(); subject.Flush(); }
public void Dispose_LeavesSafePropertiesInTheCorrectState() { var subject = new SmallBlockMemoryStream(); subject.Dispose(); subject.ShouldBeEquivalentTo(new { CanRead = false, CanSeek = false, CanWrite = false, }, EqOpts); subject.GetAllocationSizes().ShouldBeEquivalentTo(NoAllocations); }
public void ReadByte_PastEndOfStream_succeeds() { using (var standard = new MemoryStream()) using (var subject = new SmallBlockMemoryStream()) { standard.Write(TestData, 0, TestData.Length); subject.Write(TestData, 0, TestData.Length); for (var i = 0; i <= TestData.Length; i++) { subject.ReadByte().Should().Be(standard.ReadByte()); } } }
public void ReadPastEnd_succeedsWithCorrectReadLength() { const int dataLength = 100; const int readLength = 110; var writeData = MakeTestData(dataLength); var subject = new SmallBlockMemoryStream(); subject.Write(writeData, 0, dataLength); subject.Position = 0; var readData = new byte[readLength]; var read = subject.Read(readData, 0, readLength); Assert.AreEqual(writeData.Length, read); }
public void Write_withBadParameters_fails() { var subject = new SmallBlockMemoryStream(); var data = MakeTestData(10); Action action = () => subject.Write(null, 0, 0); action.ShouldThrow <ArgumentException>(); action = () => subject.Write(data, -10, 0); action.ShouldThrow <ArgumentException>(); action = () => subject.Write(data, 0, -10); action.ShouldThrow <ArgumentException>(); action = () => subject.Write(data, 0, 20); action.ShouldThrow <ArgumentException>(); }
public void Read_withBadParameters_fails() { var subject = new SmallBlockMemoryStream(); var data = new byte[10]; Action action = () => subject.Read(null, 0, 0); action.ShouldThrow <ArgumentException>(); action = () => subject.Read(data, -10, 0); action.ShouldThrow <ArgumentException>(); action = () => subject.Read(data, 0, -10); action.ShouldThrow <ArgumentException>(); action = () => subject.Read(data, 0, 20); action.ShouldThrow <ArgumentException>(); }
internal static TaskSequence ReadToString(this Stream stream, System.Text.Encoding encoding, Action <string> result) { using (var ms = new SmallBlockMemoryStream()) { int read = -1; while (read != 0) { byte[] buffer = new byte[1024]; Task <int> count = stream.ReadAsync(buffer, 0, 1024); yield return(count); ms.Write(buffer, 0, count.Result); read = count.Result; } ms.Seek(0, SeekOrigin.Begin); using (var strm = new StreamReader(ms, encoding)) { result(strm.ReadToEnd()); } } }
internal static TaskSequence ReadToString(this Stream stream, System.Text.Encoding encoding, Action<string> result) { using (var ms = new SmallBlockMemoryStream()) { int read = -1; while (read != 0) { byte[] buffer = new byte[1024]; StorageTask<int> count = stream.ReadAsyncEx(buffer, 0, 1024); yield return count; ms.Write(buffer, 0, count.Result); read = count.Result; } ms.Seek(0, SeekOrigin.Begin); using (var strm = new StreamReader(ms, encoding)) { result(strm.ReadToEnd()); } } }
public static Stream Compress(Stream inputStream, CompressionMethod level = CompressionMethod.Default) { switch (level) { // bypass compression case CompressionMethod.None: return(inputStream); // average compression using DeflateStream case CompressionMethod.DeflateStream: { var stream = new SmallBlockMemoryStream(); using (var output = new DeflateStream(stream, CompressionMode.Compress, true)) { int read; var buffer = new byte[BufferSize]; while ((read = inputStream.Read(buffer, 0, BufferSize)) > 0) { output.Write(buffer, 0, read); } } stream.Seek(0, SeekOrigin.Begin); return(stream); } // fast compression using LZF case CompressionMethod.LZF: { var buffer = new byte[BufferSize]; var output = new byte[BufferSize * 2]; // safe value for uncompressible data var outStream = new SmallBlockMemoryStream(); var lzf = new LZF(); while (true) { var readCount = (short)inputStream.Read(buffer, 0, buffer.Length); if (readCount == 0) { break; } var writeCount = (short)lzf.Compress(buffer, readCount, output, output.Length); if (writeCount == 0) { throw new InvalidOperationException("Cannot compress input stream."); } // write source size var temp = BitConverter.GetBytes(readCount); outStream.Write(temp, 0, ShortSize); // write destination size temp = BitConverter.GetBytes(writeCount); outStream.Write(temp, 0, ShortSize); // write data chunk outStream.Write(output, 0, writeCount); } // rewind the output stream outStream.Seek(0, SeekOrigin.Begin); return(outStream); } } // unknown compression method throw new InvalidOperationException(); }
public static Stream Decompress(Stream inputStream, CompressionMethod level = CompressionMethod.Default) { switch (level) { // bypass decompression case CompressionMethod.None: return(inputStream); // decompress using DeflateStream case CompressionMethod.DeflateStream: { var stream = new SmallBlockMemoryStream(); using (var output = new DeflateStream(inputStream, CompressionMode.Decompress, true)) { int read; var buffer = new byte[BufferSize]; while ((read = output.Read(buffer, 0, BufferSize)) > 0) { stream.Write(buffer, 0, read); } } stream.Seek(0, SeekOrigin.Begin); return(stream); } // decompress using LZF case CompressionMethod.LZF: { var buffer = new byte[BufferSize * 2]; var output = new byte[BufferSize]; var temp = new byte[ShortSize * 2]; var outStream = new SmallBlockMemoryStream(); var lzf = new LZF(); while (true) { // read chunk sizes if (inputStream.Read(temp, 0, ShortSize * 2) == 0) { break; } var sourceSize = BitConverter.ToInt16(temp, 0); var destSize = BitConverter.ToInt16(temp, ShortSize); var readCount = inputStream.Read(buffer, 0, destSize); if (readCount != destSize) { throw new InvalidOperationException("Cannot read input stream."); } var writeCount = lzf.Decompress(buffer, readCount, output, output.Length); if (writeCount != sourceSize) { throw new InvalidOperationException("Cannot decompress input stream."); } outStream.Write(output, 0, writeCount); } // rewind the output stream outStream.Seek(0, SeekOrigin.Begin); return(outStream); } } // unknown compression method throw new InvalidOperationException(); }
public void CtorWithCapacity_succeeds(int capacity) { using (var standard = new MemoryStream(capacity)) using (var subject = new SmallBlockMemoryStream(capacity)) AssertEquivalent(standard, subject); }
public void DefaultCtor_succeeds() { using (var standard = new MemoryStream()) using (var subject = new SmallBlockMemoryStream()) AssertEquivalent(standard, subject); }