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.");
}
