public void StructuredDocumentLogsWithCorrectDepth(string logEntry, int depth) { //Arrange var fileSystem = new Mock <IFileSystem>(); var fileBase = new Mock <FileBase>(); var stream = new TestMemoryStream(); var structuredDocument = new StructuredTextDocument <string>(@"x:\log.log", Id, Id); fileSystem.Setup(f => f.File).Returns(fileBase.Object); fileBase.Setup(f => f.Open(It.IsAny <string>(), It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>())) .Returns(stream); FileSystemHelpers.Instance = fileSystem.Object; //Act structuredDocument.Write(logEntry, depth); //Assert Assert.True(stream.Position > 0, "must write data"); stream.Position = 0; var result = new StreamReader(stream).ReadToEnd(); var writtenDepth = StructuredTextDocument.GetEntryDepth(result); Assert.Equal(depth, writtenDepth); Assert.Equal(string.Concat(logEntry, System.Environment.NewLine), result.Substring(writtenDepth)); stream.RealDispose(); }
public Stream OpenAppend() { var stream = new TestMemoryStream(this); stream.Write(_content, 0, _content.Length); return(stream); }
private void Test() { TestEnity _t = new TestEnity(); return; TestMemoryStream.TestWrite(); }
public void Can_compress_short_block() { var compressedStream = new TestMemoryStream(); var huffmanStream = new HuffmanStream(compressedStream); huffmanStream.Write(new byte[] { 0xB9, 0x80, 0x1F }, 0, 3); compressedStream.ActualBytes.Should().BeEquivalentTo(new byte[] { 0xB3, 0x32, 0x98, 0xDA }); }
public void Can_compress_long_block() { var actualCompressedStream = new TestMemoryStream(); var huffmanStream = new HuffmanStream(actualCompressedStream); huffmanStream.Write(decompressed, 0, decompressed.Length); actualCompressedStream.ActualBytes.Should().BeEquivalentTo(compressed); }
public async Task WriteCharArrayAsync_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new ProtoResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) await writer.WriteAsync((new string('a', byteLength)).ToCharArray()); // Assert Assert.Equal(byteLength, stream.Length); }
public void NoDataWritten_Flush_DoesNotFlushUnderlyingStream() { // Arrange var stream = new TestMemoryStream(); var writer = new ProtoResponseStreamWriter(stream, Encoding.UTF8); // Act writer.Flush(); // Assert Assert.Equal(0, stream.FlushCallCount); Assert.Equal(0, stream.Length); }
public async Task DoesNotClose_UnderlyingStream_OnDisposingWriter() { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act await writer.WriteAsync("Hello"); writer.Close(); // Assert Assert.Equal(0, stream.CloseCallCount); }
public async Task NoDataWritten_FlushAsync_DoesNotFlushUnderlyingStream() { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act await writer.FlushAsync(); // Assert Assert.Equal(0, stream.FlushAsyncCallCount); Assert.Equal(0, stream.Length); }
public async Task FlushesBuffer_OnFlushAsync(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); await writer.WriteAsync(new string('a', byteLength)); // Act await writer.FlushAsync(); // Assert Assert.Equal(1, stream.FlushAsyncCallCount); Assert.Equal(byteLength, stream.Length); }
public async Task DoesNotDispose_UnderlyingStream_OnDisposingWriter() { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act await writer.WriteAsync("Hello world"); writer.Dispose(); // Assert Assert.Equal(0, stream.DisposeCallCount); }
public void FlushesBuffer_OnFlush(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); writer.Write(new string('a', byteLength)); // Act writer.Flush(); // Assert Assert.Equal(1, stream.FlushCallCount); Assert.Equal(byteLength, stream.Length); }
public void WriteCharArray_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) { writer.Write((new string('a', byteLength)).ToCharArray()); } // Assert Assert.Equal(byteLength, stream.Length); }
public async Task WriteReadOnlyMemoryAsync_TokenCanceled_ReturnsCanceledTask() { // Arrange var stream = new TestMemoryStream(); using var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); var memory = new ReadOnlyMemory <char>(new char[] { 'a' }); var cancellationToken = new CancellationToken(true); // Act await Assert.ThrowsAsync <TaskCanceledException>(async() => await writer.WriteAsync(memory, cancellationToken)); // Assert Assert.Equal(0, stream.Length); }
public async Task DoesNotFlush_UnderlyingStream_OnClosingWriter() { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act await writer.WriteAsync("Hello"); writer.Close(); // Assert Assert.Equal(0, stream.FlushCallCount); Assert.Equal(0, stream.FlushAsyncCallCount); }
public async Task WriteCharAsync_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new ProtoResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) for (var i = 0; i < byteLength; i++) { await writer.WriteAsync('a'); } // Assert Assert.Equal(byteLength, stream.Length); }
public void WriteReadOnlySpanChar_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) { var array = new string('a', byteLength).ToCharArray(); var span = new ReadOnlySpan <char>(array); writer.Write(span); } // Assert Assert.Equal(byteLength, stream.Length); }
public async Task WriteReadOnlyMemoryAsync_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) { var array = new string('a', byteLength).ToCharArray(); var memory = new ReadOnlyMemory <char>(array); await writer.WriteAsync(memory); } // Assert Assert.Equal(byteLength, stream.Length); }
public async Task FlushesBuffer_ButNotStream_OnFlushAsync(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); await writer.WriteAsync(new string('a', byteLength)); var expectedWriteCount = Math.Ceiling((double)byteLength / HttpResponseStreamWriter.DefaultBufferSize); // Act await writer.FlushAsync(); // Assert Assert.Equal(0, stream.FlushAsyncCallCount); Assert.Equal(expectedWriteCount, stream.WriteAsyncCallCount); Assert.Equal(byteLength, stream.Length); }
public void StructuredTextLoggerLogFunction(string message, LogEntryType type) { //Arrange var fileSystem = new Mock<IFileSystem>(); var fileBase = new Mock<FileBase>(); var stream = new TestMemoryStream(); var analytics = new Mock<IAnalytics>(); var logger = new StructuredTextLogger(@"x:\log.log", analytics.Object); fileSystem.Setup(f => f.File).Returns(fileBase.Object); fileBase.Setup(f => f.Open(It.IsAny<string>(), It.IsAny<FileMode>(), It.IsAny<FileAccess>(), It.IsAny<FileShare>())) .Returns(stream); fileBase.Setup(f => f.OpenRead(It.IsAny<string>())) .Returns((string path) => { stream.Position = 0; return stream; }); fileBase.Setup(f => f.ReadAllText(It.IsAny<string>())) .Returns((string path) => { using (var reader = new StreamReader(fileBase.Object.OpenRead(path))) { return reader.ReadToEnd(); } }); fileBase.Setup(f => f.ReadAllLines(It.IsAny<string>())) .Returns((string path) => { return fileBase.Object.ReadAllText(path).Split(new[] { System.Environment.NewLine }, StringSplitOptions.None); }); FileSystemHelpers.Instance = fileSystem.Object; //Act logger.Log(message, type); var entries = logger.GetLogEntries(); //Assert Assert.Equal(1, entries.Count()); Assert.Equal(message, entries.First().Message); Assert.Equal(type, entries.First().Type); stream.RealDispose(); }
public async Task WriteLineAsyncCharArray_OnlyWritesNewLineToStream_ForZeroCount(int newLineLength) { // Arrange var content = new char[1]; var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); writer.NewLine = new string('\n', newLineLength); // Act using (writer) { await writer.WriteLineAsync(content, 0, 0); } // Assert Assert.Equal(newLineLength, stream.Length); }
public void DisposesWhenEnumerationIsCompleted() { var disposable = new TestDisposable(); var memoryStream = new TestMemoryStream(Encoding.Default.GetBytes("line1\r\nline2\r\nline3")); var streamReader = new TestStreamReader(memoryStream); var enumerable = new StreamReaderEnumerable(streamReader, disposable); // complete enumeration var lines = enumerable.ToList(); Assert.IsTrue(streamReader.DisposeCalled); Assert.IsTrue(streamReader.DisposeCalledDisposingValue); Assert.IsTrue(memoryStream.DisposeCalled); Assert.IsTrue(memoryStream.DisposeCalledDisposingValue); Assert.IsTrue(disposable.DisposeCalled); }
public async Task WriteLineAsyncString_WritesToStream(int charCount, int newLineLength) { // Arrange var content = new string('a', charCount); var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); writer.NewLine = new string('\n', newLineLength); // Act using (writer) { await writer.WriteLineAsync(content); } // Assert Assert.Equal(charCount + newLineLength, stream.Length); }
public void WriteChar_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) { for (var i = 0; i < byteLength; i++) { writer.Write('a'); } } // Assert Assert.Equal(byteLength, stream.Length); }
public async Task WriteLineAsyncString_OnlyWritesNewLineToStream_ForNullArgument(int newLineLength) { // Arrange string?content = null; var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); writer.NewLine = new string('\n', newLineLength); // Act using (writer) { await writer.WriteLineAsync(content); } // Assert Assert.Equal(newLineLength, stream.Length); }
public void FlushesBuffer_ButNotStream_OnFlush(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new ProtoResponseStreamWriter(stream, Encoding.UTF8); writer.Write(new string('a', byteLength)); var expectedWriteCount = Math.Ceiling((double)byteLength / ProtoResponseStreamWriter.DefaultBufferSize); // Act writer.Flush(); // Assert Assert.Equal(0, stream.FlushCallCount); Assert.Equal(expectedWriteCount, stream.WriteCallCount); Assert.Equal(byteLength, stream.Length); }
public async Task FlushesBuffer_OnClose(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); await writer.WriteAsync(new string('a', byteLength)); // Act #if NET451 writer.Close(); #else writer.Dispose(); #endif // Assert Assert.Equal(0, stream.FlushCallCount); Assert.Equal(0, stream.FlushAsyncCallCount); Assert.Equal(byteLength, stream.Length); }
public async Task HttpResponseStreamWriter_WritesDataCorrectly_ForCharactersHavingSurrogatePairs(int characterSize) { // Arrange // Here "𐐀" (called Deseret Long I) actually represents 2 characters. Try to make this character split across // the boundary var content = new string('a', characterSize - 1) + "𐐀"; var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.Unicode); // Act await writer.WriteAsync(content); await writer.FlushAsync(); // Assert stream.Seek(0, SeekOrigin.Begin); var streamReader = new StreamReader(stream, Encoding.Unicode); var actualContent = await streamReader.ReadToEndAsync(); Assert.Equal(content, actualContent); }
public async Task FlushWriteThrows_DontFlushInDispose(int byteLength) { // Arrange var stream = new TestMemoryStream() { ThrowOnWrite = true }; var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); await writer.WriteAsync(new string('a', byteLength)); await Assert.ThrowsAsync <IOException>(() => writer.FlushAsync()); // Act writer.Dispose(); // Assert Assert.Equal(1, stream.WriteAsyncCallCount); Assert.Equal(0, stream.WriteCallCount); Assert.Equal(0, stream.FlushCallCount); Assert.Equal(0, stream.FlushAsyncCallCount); Assert.Equal(0, stream.Length); }
internal static FileSystemInfo GetTextLoggerMockFileSystem() { var fileSystem = new Mock <IFileSystem>(); var fileBase = new Mock <FileBase>(); var stream = new TestMemoryStream(); fileSystem.Setup(f => f.File).Returns(fileBase.Object); fileBase.Setup(f => f.Open(It.IsAny <string>(), It.IsAny <FileMode>(), It.IsAny <FileAccess>(), It.IsAny <FileShare>())) .Returns(stream); fileBase.Setup(f => f.OpenRead(It.IsAny <string>())) .Returns((string path) => { stream.Position = 0; return(stream); }); fileBase.Setup(f => f.ReadAllText(It.IsAny <string>())) .Returns((string path) => { using (var reader = new StreamReader(fileBase.Object.OpenRead(path))) { return(reader.ReadToEnd()); } }); fileBase.Setup(f => f.ReadAllLines(It.IsAny <string>())) .Returns((string path) => { return(fileBase.Object.ReadAllText(path).Split(new[] { System.Environment.NewLine }, StringSplitOptions.None)); }); return(new FileSystemInfo { FileSystem = fileSystem.Object, MemoryStream = stream }); }
internal static FileSystemInfo GetTextLoggerMockFileSystem() { var fileSystem = new Mock<IFileSystem>(); var fileBase = new Mock<FileBase>(); var stream = new TestMemoryStream(); fileSystem.Setup(f => f.File).Returns(fileBase.Object); fileBase.Setup(f => f.Open(It.IsAny<string>(), It.IsAny<FileMode>(), It.IsAny<FileAccess>(), It.IsAny<FileShare>())) .Returns(stream); fileBase.Setup(f => f.OpenRead(It.IsAny<string>())) .Returns((string path) => { stream.Position = 0; return stream; }); fileBase.Setup(f => f.ReadAllText(It.IsAny<string>())) .Returns((string path) => { using (var reader = new StreamReader(fileBase.Object.OpenRead(path))) { return reader.ReadToEnd(); } }); fileBase.Setup(f => f.ReadAllLines(It.IsAny<string>())) .Returns((string path) => { return fileBase.Object.ReadAllText(path).Split(new[] { System.Environment.NewLine }, StringSplitOptions.None); }); return new FileSystemInfo { FileSystem = fileSystem.Object, MemoryStream = stream }; }
public async Task WriteCharArrayAsync_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) { await writer.WriteAsync((new string('a', byteLength)).ToCharArray()); } // Assert Assert.Equal(byteLength, stream.Length); }
public async Task WriteCharAsync_WritesToStream(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); // Act using (writer) { for (var i = 0; i < byteLength; i++) { await writer.WriteAsync('a'); } } // Assert Assert.Equal(byteLength, stream.Length); }
public async Task FlushesBuffer_OnDispose(int byteLength) { // Arrange var stream = new TestMemoryStream(); var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); await writer.WriteAsync(new string('a', byteLength)); // Act writer.Dispose(); // Assert Assert.Equal(0, stream.FlushCallCount); Assert.Equal(0, stream.FlushAsyncCallCount); Assert.Equal(byteLength, stream.Length); }
private void BuildFileSystemMock(Action <Mock <IFileSystem> > action) { var fileSystemMock = new Mock <IFileSystem>(); var fileBaseMock = new Mock <FileBase>(); var fileInfoFactoryMoack = new Mock <IFileInfoFactory>(); var fileInfoMock = new Mock <FileInfoBase>(); var directoryBaseMock = new Mock <DirectoryBase>(); var files = new Dictionary <string, TestMemoryStream>(); fileSystemMock.SetupGet(fs => fs.File) .Returns(fileBaseMock.Object); fileSystemMock.SetupGet(fs => fs.FileInfo) .Returns(fileInfoFactoryMoack.Object); fileInfoFactoryMoack.Setup(f => f.FromFileName(It.IsAny <string>())) .Returns(fileInfoMock.Object); fileSystemMock.SetupGet(fs => fs.Directory) .Returns(directoryBaseMock.Object); fileBaseMock.Setup(f => f.Exists(It.IsAny <string>())).Returns(true); fileBaseMock.Setup(f => f.Open(It.IsAny <string>(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) .Returns((string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare) => { TestMemoryStream stream; if (!files.TryGetValue(path, out stream)) { stream = new TestMemoryStream(); byte[] contentInBytes = Encoding.UTF8.GetBytes("{}"); if (string.Equals(@"x:\bad-content.json", path)) { contentInBytes = Encoding.UTF8.GetBytes(@"{ ""AzureDriveEnabled"": true, ""AzureDriveTraceLevel"": 2, ""AzureTableEnabled"": true, ""AzureTableTraceLevel"": 8, ""AzureBlobEnabled"": true, ""AzureBlobTraceLevel"": 16 }"); } stream.WriteAsync(contentInBytes, 0, contentInBytes.Length); } stream.Position = 0; return(stream); }); fileBaseMock.Setup(f => f.Open(It.IsAny <string>(), FileMode.Create, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete)) .Returns((string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare) => { files[path] = new TestMemoryStream(); return(files[path]); }); directoryBaseMock.Setup(d => d.Exists(It.IsAny <string>())).Returns(true); try { action(fileSystemMock); } finally { foreach (var f in files) { f.Value.RealDispose(); } } }
public async Task FlushWriteThrows_DontFlushInDispose(int byteLength) { // Arrange var stream = new TestMemoryStream() { ThrowOnWrite = true }; var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8); await writer.WriteAsync(new string('a', byteLength)); await Assert.ThrowsAsync<IOException>(() => writer.FlushAsync()); // Act writer.Dispose(); // Assert Assert.Equal(1, stream.WriteAsyncCallCount); Assert.Equal(0, stream.WriteCallCount); Assert.Equal(0, stream.FlushCallCount); Assert.Equal(0, stream.FlushAsyncCallCount); Assert.Equal(0, stream.Length); }
private void BuildFileSystemMock(Action<Mock<IFileSystem>> action) { var fileSystemMock = new Mock<IFileSystem>(); var fileBaseMock = new Mock<FileBase>(); var fileInfoFactoryMoack = new Mock<IFileInfoFactory>(); var fileInfoMock = new Mock<FileInfoBase>(); var directoryBaseMock = new Mock<DirectoryBase>(); var files = new Dictionary<string, TestMemoryStream>(); fileSystemMock.SetupGet(fs => fs.File) .Returns(fileBaseMock.Object); fileSystemMock.SetupGet(fs => fs.FileInfo) .Returns(fileInfoFactoryMoack.Object); fileInfoFactoryMoack.Setup(f => f.FromFileName(It.IsAny<string>())) .Returns(fileInfoMock.Object); fileSystemMock.SetupGet(fs => fs.Directory) .Returns(directoryBaseMock.Object); fileBaseMock.Setup(f => f.Exists(It.IsAny<string>())).Returns(true); fileBaseMock.Setup(f => f.Open(It.IsAny<string>(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete)) .Returns((string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare) => { TestMemoryStream stream; if (!files.TryGetValue(path, out stream)) { stream = new TestMemoryStream(); byte[] contentInBytes = Encoding.UTF8.GetBytes("{}"); if (string.Equals(@"x:\bad-content.json", path)) { contentInBytes = Encoding.UTF8.GetBytes(@"{ ""AzureDriveEnabled"": true, ""AzureDriveTraceLevel"": 2, ""AzureTableEnabled"": true, ""AzureTableTraceLevel"": 8, ""AzureBlobEnabled"": true, ""AzureBlobTraceLevel"": 16 }"); } stream.WriteAsync(contentInBytes, 0, contentInBytes.Length); } stream.Position = 0; return stream; }); fileBaseMock.Setup(f => f.Open(It.IsAny<string>(), FileMode.Create, FileAccess.Write, FileShare.ReadWrite | FileShare.Delete)) .Returns((string path, FileMode fileMode, FileAccess fileAccess, FileShare fileShare) => { files[path] = new TestMemoryStream(); return files[path]; }); directoryBaseMock.Setup(d => d.Exists(It.IsAny<string>())).Returns(true); try { action(fileSystemMock); } finally { foreach (var f in files) { f.Value.RealDispose(); } } }