public void WriteByte_ReportsBytesWritten() { // Arrange HttpRequestMessage request = CreateRequest(); Stream innerStream = new MemoryStream(); byte[] buffer = CreateBufferContent(); long? expectedLength = request.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request); // Act/Assert int totalBytesWritten = 0; while (totalBytesWritten < expectedLength) { progressStream.WriteByte(buffer[totalBytesWritten]); totalBytesWritten += 1; Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public async Task WriteAsync_ReportsBytesWritten() { // Arrange using (ManualResetEvent writeComplete = new ManualResetEvent(false)) { HttpRequestMessage request = CreateRequest(); Stream innerStream = new MemoryStream(); byte[] buffer = CreateBufferContent(); long?expectedLength = request.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request); object userState = new object(); // Act/Assert int totalBytesWritten = 0; int bytesWritten = 0; while (totalBytesWritten < expectedLength) { bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten); await progressStream.WriteAsync(buffer, totalBytesWritten, bytesWritten); totalBytesWritten += bytesWritten; Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); } }
public void Constructor_ReportsBytesWritten(int offset, int count) { // Arrange Mock <Stream> mockInnerStream = new Mock <Stream>(); object userState = new object(); IAsyncResult mockIAsyncResult = CreateMockCompletedAsyncResult(true, userState); mockInnerStream.Setup(s => s.BeginWrite(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())) .Returns(mockIAsyncResult); MockProgressEventHandler mockProgressHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressHandler, sendProgress: true); HttpRequestMessage request = new HttpRequestMessage(); ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(progressMessageHandler: progressMessageHandler, request: request); // Act IAsyncResult result = new ProgressWriteAsyncResult( mockInnerStream.Object, progressStream, sampleData, offset, count, null, userState); // Assert Assert.True(mockProgressHandler.WasInvoked); Assert.Same(request, mockProgressHandler.Sender); Assert.Equal(count, mockProgressHandler.EventArgs.BytesTransferred); Assert.Same(userState, mockProgressHandler.EventArgs.UserState); }
public async Task ReadByte_ReportsBytesRead() { // Arrange HttpResponseMessage response = CreateResponse(); Stream innerStream = await response.Content.ReadAsStreamAsync(); long?expectedLength = response.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response); // Act/Assert int totalBytesRead = 0; while (progressStream.ReadByte() != -1) { totalBytesRead += 1; Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public async Task BeginEndRead_ReportsBytesRead() { // Arrange HttpResponseMessage response = CreateResponse(); Stream innerStream = await response.Content.ReadAsStreamAsync(); long?expectedLength = response.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response); object userState = new object(); // Act/Assert int totalBytesRead = 0; int bytesRead = 0; do { byte[] buffer = new byte[8]; IAsyncResult result = progressStream.BeginRead(buffer, 0, buffer.Length, null, userState); bytesRead = progressStream.EndRead(result); totalBytesRead += bytesRead; Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState); Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); }while (bytesRead > 0); Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public void BeginEndWrite_ReportsBytesWritten() { // Arrange HttpRequestMessage request = CreateRequest(); Stream innerStream = new MemoryStream(); byte[] buffer = CreateBufferContent(); long? expectedLength = request.Content.Headers.ContentLength; MockProgressEventHandler mockProgressEventHandler; ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true); ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request); object userState = new object(); // Act/Assert int totalBytesWritten = 0; int bytesWritten = 0; while (totalBytesWritten < expectedLength) { bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten); IAsyncResult result = progressStream.BeginWrite(buffer, totalBytesWritten, bytesWritten, null, userState); progressStream.EndWrite(result); totalBytesWritten += bytesWritten; Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState); Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred); Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage); } Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes); Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage); }
public void Constructor_CompletesWithExceptionIfInnerStreamThrows() { // Arrange Mock <Stream> mockInnerStream = new Mock <Stream>(); mockInnerStream .Setup( s => s.BeginWrite( It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>() ) ) .Throws <ApplicationException>(); ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(); // Act IAsyncResult result = new ProgressWriteAsyncResult( mockInnerStream.Object, progressStream, sampleData, 2, 2, null, null ); // Assert Assert.True(result.IsCompleted); Assert.Throws <ApplicationException>(() => ProgressWriteAsyncResult.End(result)); }
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) { ProgressStream progressStream = new ProgressStream( stream, _handler, _request, response: null ); return(_innerContent.CopyToAsync(progressStream)); }
private async Task <HttpResponseMessage> AddResponseProgressAsync(HttpRequestMessage request, HttpResponseMessage response) { Stream stream = await response.Content.ReadAsStreamAsync(); ProgressStream progressStream = new ProgressStream(stream, this, request, response); HttpContent progressContent = new StreamContent(progressStream); response.Content.Headers.CopyTo(progressContent.Headers); response.Content = progressContent; return(response); }
public void Constructor_BeginWriteOnInnerStream() { // Arrange Mock <Stream> mockInnerStream = new Mock <Stream>(); ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(); // Act IAsyncResult result = new ProgressWriteAsyncResult( mockInnerStream.Object, progressStream, sampleData, 2, 4, null, null); // Assert mockInnerStream.Verify(s => s.BeginWrite(sampleData, 2, 4, It.IsAny <AsyncCallback>(), It.IsAny <object>()), Times.Once()); }
public void Constructor_CompletesSynchronouslyIfInnerStreamCompletesSynchronously() { // Arrange Mock <Stream> mockInnerStream = new Mock <Stream>(); object userState = new object(); IAsyncResult mockIAsyncResult = CreateMockCompletedAsyncResult(true, userState); mockInnerStream.Setup(s => s.BeginWrite(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <AsyncCallback>(), It.IsAny <object>())) .Returns(mockIAsyncResult); ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(); // Act IAsyncResult result = new ProgressWriteAsyncResult( mockInnerStream.Object, progressStream, sampleData, 2, 4, null, userState); // Assert Assert.True(result.IsCompleted); Assert.True(result.CompletedSynchronously); Assert.Same(userState, result.AsyncState); }
private Task <HttpResponseMessage> AddResponseProgress(HttpRequestMessage request, HttpResponseMessage response) { Task <HttpResponseMessage> responseTask; if (HttpReceiveProgress != null && response != null && response.Content != null) { responseTask = response.Content.ReadAsStreamAsync().Then( stream => { ProgressStream progressStream = new ProgressStream(stream, this, request, response); HttpContent progressContent = new StreamContent(progressStream); response.Content.Headers.CopyTo(progressContent.Headers); response.Content = progressContent; return(response); }, runSynchronously: true); } else { responseTask = TaskHelpers.FromResult(response); } return(responseTask); }
public ProgressWriteAsyncResult( Stream innerStream, ProgressStream progressStream, byte[] buffer, int offset, int count, AsyncCallback callback, object state ) : base(callback, state) { Contract.Assert(innerStream != null); Contract.Assert(progressStream != null); Contract.Assert(buffer != null); _innerStream = innerStream; _progressStream = progressStream; _count = count; try { IAsyncResult result = innerStream.BeginWrite( buffer, offset, count, _writeCompletedCallback, this ); if (result.CompletedSynchronously) { WriteCompleted(result); } } catch (Exception e) { Complete(true, e); } }
public ProgressWriteAsyncResult(Stream innerStream, ProgressStream progressStream, byte[] buffer, int offset, int count, AsyncCallback callback, object state) : base(callback, state) { Contract.Assert(innerStream != null); Contract.Assert(progressStream != null); Contract.Assert(buffer != null); _innerStream = innerStream; _progressStream = progressStream; _count = count; try { IAsyncResult result = innerStream.BeginWrite(buffer, offset, count, _writeCompletedCallback, this); if (result.CompletedSynchronously) { WriteCompleted(result); } } catch (Exception e) { Complete(true, e); } }
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) { ProgressStream progressStream = new ProgressStream(stream, _handler, _request, response: null); return _innerContent.CopyToAsync(progressStream); }
private async Task<HttpResponseMessage> AddResponseProgressAsync(HttpRequestMessage request, HttpResponseMessage response) { Stream stream = await response.Content.ReadAsStreamAsync(); ProgressStream progressStream = new ProgressStream(stream, this, request, response); HttpContent progressContent = new StreamContent(progressStream); response.Content.Headers.CopyTo(progressContent.Headers); response.Content = progressContent; return response; }
private Task<HttpResponseMessage> AddResponseProgress(HttpRequestMessage request, HttpResponseMessage response) { Task<HttpResponseMessage> responseTask; if (HttpReceiveProgress != null && response != null && response.Content != null) { responseTask = response.Content.ReadAsStreamAsync().Then( stream => { ProgressStream progressStream = new ProgressStream(stream, this, request, response); HttpContent progressContent = new StreamContent(progressStream); response.Content.Headers.CopyTo(progressContent.Headers); response.Content = progressContent; return response; }, runSynchronously: true); } else { responseTask = TaskHelpers.FromResult(response); } return responseTask; }