public void Start_CallbackCalled_AcceptedClientRaisedWithTcpClient()
{
Smock.Run(context =>
{
// Arrange
AsyncCallback callback = null;
var expectedTcpClient = new TcpClient();
var asyncResultMock = new Mock <IAsyncResult>();
asyncResultMock.SetupGet(mock => mock.AsyncState).Returns(expectedTcpClient);
IAsyncResult ar = new Mock <IAsyncResult>().Object;
var tcpListenerMock = new Mock <ITcpListener>();
tcpListenerMock
.Setup(mock => mock.BeginAcceptTcpClient(It.IsAny <AsyncCallback>(), null))
.Callback((AsyncCallback cb, object state) => callback = cb)
.Returns(asyncResultMock.Object);
tcpListenerMock
.Setup(mock => mock.EndAcceptTcpClient(It.IsAny <IAsyncResult>()))
.Returns(expectedTcpClient);
context.Setup(() => MultiSourceTcpListener.Create(It.IsAny <int>()))
.Returns(tcpListenerMock.Object);
AcceptedTcpClient actualTcpClient = null;
// Act
var tcpServer = new TcpServer(0);
tcpServer.AcceptedClient += (sender, args) => actualTcpClient = args.TcpClient;
tcpServer.Start();
callback(ar);
// Assert
Assert.AreEqual(expectedTcpClient, actualTcpClient.TcpClient);
});
}
public void Start_CallbackCalled_TcpListenerKeepAcceptingIncomingConnection()
{
Smock.Run(context =>
{
// Arrange
AsyncCallback callback = null;
IAsyncResult ar = new Mock <IAsyncResult>().Object;
var tcpListenerMock = new Mock <ITcpListener>();
tcpListenerMock
.Setup(mock => mock.BeginAcceptTcpClient(It.IsAny <AsyncCallback>(), null))
.Callback((AsyncCallback cb, object state) => callback = cb)
.Returns(ar);
context.Setup(() => MultiSourceTcpListener.Create(It.IsAny <int>()))
.Returns(tcpListenerMock.Object);
// Act
var tcpServer = new TcpServer(0);
tcpServer.Start();
callback(ar);
// Assert
tcpListenerMock.Verify(mock => mock.BeginAcceptTcpClient(It.IsAny <AsyncCallback>(), null), Times.Exactly(2));
});
}
public void Start_TcpListenerIsNotStartedAndIsNotListening_TcpListenerIsStartedAndListening()
{
Smock.Run(context =>
{
// Arrange
var asyncResultMock = new Mock <IAsyncResult>();
var tcpListenerMock = new Mock <ITcpListener>();
tcpListenerMock.Setup(mock => mock.Start())
.Verifiable();
tcpListenerMock.Setup(mock => mock.BeginAcceptTcpClient(It.IsAny <AsyncCallback>(), null))
.Returns(asyncResultMock.Object)
.Verifiable();
context.Setup(() => MultiSourceTcpListener.Create(It.IsAny <int>()))
.Returns(tcpListenerMock.Object);
var tcpServer = new TcpServer(1000);
// Act
tcpServer.Start();
// Assert
tcpListenerMock.Verify();
});
}
public void Start_StartCalled_DataStreamingTcpServerSubscribedToAcceptedClient()
{
Smock.Run(context =>
{
// Arrange
var tcpListenerMock = new Mock <ITcpListener>();
context.Setup(() => MultiSourceTcpListener.Create(It.IsAny <int>()))
.Returns(tcpListenerMock.Object);
// Act
var dataStreamingTcpServer = new DataStreamingTcpServer(new TcpServer(0));
dataStreamingTcpServer.Start();
// Assert
var acceptedClientHandler = GetAcceptedClientHandlerByReflection(dataStreamingTcpServer);
Assert.IsNotNull(acceptedClientHandler);
Assert.AreEqual(1, acceptedClientHandler.GetInvocationList().Length);
});
}
public void Stop_StopCalled_DataStreamingTcpServerUnsubscribedFromAcceptedClient()
{
Smock.Run(context =>
{
// Arrange
var tcpListenerMock = new Mock <ITcpListener>();
context.Setup(() => MultiSourceTcpListener.Create(It.IsAny <int>()))
.Returns(tcpListenerMock.Object);
var dataStreamingTcpServer = new DataStreamingTcpServer(new TcpServer(0));
dataStreamingTcpServer.Start();
// Act
dataStreamingTcpServer.Stop();
// Assert
var acceptedClientHandler = GetAcceptedClientHandlerByReflection(dataStreamingTcpServer);
Assert.IsNull(acceptedClientHandler);
});
}
public void Stop_TcpListenerIsStartedAndIsListening_TcpListenerIsStopped()
{
Smock.Run(context =>
{
// Arrange
var tcpListenerMock = new Mock <ITcpListener>();
tcpListenerMock.Setup(mock => mock.Stop())
.Verifiable();
context.Setup(() => MultiSourceTcpListener.Create(It.IsAny <int>()))
.Returns(tcpListenerMock.Object);
var tcpServer = new TcpServer(0);
tcpServer.Start();
// Act
tcpServer.Stop();
// Assert
tcpListenerMock.Verify();
});
}
