public MonitoringStreamTests(ITestOutputHelper logger) : base(logger) { this.underlyingStream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 }); this.monitoringStream = new MonitoringStream(this.underlyingStream); this.buffer = new byte[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; }
public async Task FlushAsync() { var mockedUnderlyingStream = new Mock <Stream>(MockBehavior.Strict); mockedUnderlyingStream.Setup(s => s.FlushAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask); var monitoringStream = new MonitoringStream(mockedUnderlyingStream.Object); await monitoringStream.FlushAsync(); mockedUnderlyingStream.VerifyAll(); }
public void Flush() { var mockedUnderlyingStream = new Mock <Stream>(MockBehavior.Strict); mockedUnderlyingStream.Setup(s => s.Flush()); var monitoringStream = new MonitoringStream(mockedUnderlyingStream.Object); monitoringStream.Flush(); mockedUnderlyingStream.VerifyAll(); }
public void CanTimeout() { var mockedUnderlyingStream = new Mock <Stream>(MockBehavior.Strict); mockedUnderlyingStream.SetupGet(s => s.CanTimeout).Returns(true); var monitoringStream = new MonitoringStream(mockedUnderlyingStream.Object); Assert.True(monitoringStream.CanTimeout); mockedUnderlyingStream.SetupGet(s => s.CanTimeout).Returns(false); Assert.False(monitoringStream.CanTimeout); }
public void WriteTimeout() { var mockedUnderlyingStream = new Mock <Stream>(MockBehavior.Strict); mockedUnderlyingStream.SetupProperty(s => s.WriteTimeout); var monitoringStream = new MonitoringStream(mockedUnderlyingStream.Object); Assert.Equal(mockedUnderlyingStream.Object.WriteTimeout, monitoringStream.WriteTimeout); monitoringStream.WriteTimeout = 13; Assert.Equal(mockedUnderlyingStream.Object.WriteTimeout, monitoringStream.WriteTimeout); Assert.Equal(13, mockedUnderlyingStream.Object.WriteTimeout); }
public void Flush() { var mockedUnderlyingStream = new Mock <Stream>(MockBehavior.Strict); mockedUnderlyingStream.Setup(s => s.Flush()); var monitoringStream = new MonitoringStream(mockedUnderlyingStream.Object); bool didFlushRaised = false; monitoringStream.DidFlush += (s, e) => didFlushRaised = true; monitoringStream.Flush(); Assert.True(didFlushRaised); mockedUnderlyingStream.VerifyAll(); }
public async Task FlushAsync() { var mockedUnderlyingStream = new Mock <Stream>(MockBehavior.Strict); mockedUnderlyingStream.Setup(s => s.FlushAsync(It.IsAny <CancellationToken>())).Returns(Task.CompletedTask); var monitoringStream = new MonitoringStream(mockedUnderlyingStream.Object); bool didFlushRaised = false; monitoringStream.DidFlush += (s, e) => didFlushRaised = true; await monitoringStream.FlushAsync(); Assert.True(didFlushRaised); mockedUnderlyingStream.VerifyAll(); }
public void TryRead_FalseCanBeCalledRepeatedly() { // Arrange for the read stream to never respond so that the test doesn't randomly fail in the StreamUsePipeReaderTests derived test class. var unblockReader = new ManualResetEventSlim(); var slowReadStream = new MonitoringStream(new MemoryStream(new byte[] { 1, 2, 3 })); slowReadStream.WillReadMemory += (s, e) => unblockReader.Wait(this.TimeoutToken); slowReadStream.WillRead += (s, e) => unblockReader.Wait(this.TimeoutToken); var reader = this.CreatePipeReader(slowReadStream); // Verify that it's safe to call TryRead repeatedly when it returns False. Assert.False(reader.TryRead(out var readResult)); Assert.False(reader.TryRead(out readResult)); }
public async Task Flush_FlushesUnderlyingStream(bool async) { var monitoredStream = new MonitoringStream(this.underlyingStream); int flushed = 0; monitoredStream.DidFlush += (s, e) => flushed++; const int bufferSize = 4; var substreamBuffer = this.GetRandomBuffer(bufferSize); var substream = monitoredStream.WriteSubstream(64); await this.WriteSyncOrAsync(substream, async, substreamBuffer, 0, substreamBuffer.Length, this.TimeoutToken); Assert.Equal(0, flushed); await this.FlushSyncOrAsync(substream, async); Assert.Equal(1, flushed); }
public async Task Dispose_FlushesFinalBytes(bool async) { var monitoredStream = new MonitoringStream(this.underlyingStream); int lastOperation = 0; monitoredStream.DidWrite += (s, e) => lastOperation = 1; monitoredStream.DidWriteMemory += (s, e) => lastOperation = 1; monitoredStream.DidWriteSpan += (s, e) => lastOperation = 1; monitoredStream.DidWriteByte += (s, e) => lastOperation = 1; monitoredStream.DidFlush += (s, e) => lastOperation = 2; const int bufferSize = 64; Substream?substream = monitoredStream.WriteSubstream(bufferSize); byte[]? substreamBuffer = this.GetRandomBuffer(256); await this.DisposeSyncOrAsync(substream, async); Assert.Equal(2, lastOperation); }
public async Task StreamClosesDeterministically() { Tuple <Nerdbank.FullDuplexStream, Nerdbank.FullDuplexStream> streams = Nerdbank.FullDuplexStream.CreateStreams(); var monitoredStream = new MonitoringStream(new OneWayStreamWrapper(streams.Item1, canWrite: true)); var disposedEvent = new AsyncManualResetEvent(); monitoredStream.Disposed += (s, e) => disposedEvent.Set(); bool writing = false; monitoredStream.WillWrite += (s, e) => { Assert.False(writing); writing = true; this.Logger.WriteLine("Writing {0} bytes.", e.Count); }; monitoredStream.WillWriteByte += (s, e) => { Assert.False(writing); writing = true; this.Logger.WriteLine("Writing 1 byte."); }; monitoredStream.WillWriteMemory += (s, e) => { Assert.False(writing); writing = true; this.Logger.WriteLine("Writing {0} bytes.", e.Length); }; monitoredStream.WillWriteSpan += (s, e) => { Assert.False(writing); writing = true; this.Logger.WriteLine("Writing {0} bytes.", e.Length); }; monitoredStream.DidWrite += (s, e) => { Assert.True(writing); writing = false; this.Logger.WriteLine("Wrote {0} bytes.", e.Count); }; monitoredStream.DidWriteByte += (s, e) => { Assert.True(writing); writing = false; this.Logger.WriteLine("Wrote 1 byte."); }; monitoredStream.DidWriteMemory += (s, e) => { Assert.True(writing); writing = false; this.Logger.WriteLine("Wrote {0} bytes.", e.Length); }; monitoredStream.DidWriteSpan += (s, e) => { Assert.True(writing); writing = false; this.Logger.WriteLine("Wrote {0} bytes.", e.Length); }; try { await this.clientRpc.InvokeWithCancellationAsync( nameof(Server.AcceptWritableStream), new object[] { monitoredStream, MemoryBuffer.Length }, this.TimeoutToken); this.Logger.WriteLine("RPC call completed."); } catch (Exception ex) when(!(ex is RemoteInvocationException)) { // The only failure case where the stream will be closed automatically is if it came in as an error response from the server. monitoredStream.Dispose(); throw; } await disposedEvent.WaitAsync(this.TimeoutToken); this.Logger.WriteLine("Stream disposed."); }