public void TestMultipleClientConnections()
{
SocketState state = new SocketState(null, null);
int i = 0;
int j = 0;
void toServerCall(SocketState s)
{
i++;
}
void toClientCall(SocketState s)
{
j++;
NetworkTestHelper.WaitForOrTimeout(() => false, 2000);
Assert.IsTrue(i == j);
}
TcpListener listener = Networking.StartServer(toServerCall, 2112);
Networking.ConnectToServer(toClientCall, "localhost", 2112);
Networking.ConnectToServer(toClientCall, "localhost", 2112);
Networking.ConnectToServer(toClientCall, "localhost", 2112);
Networking.ConnectToServer(toClientCall, "localhost", 2112);
Networking.ConnectToServer(toClientCall, "localhost", 2112);
}
public void TestConnectWithIPV6()
{
bool isCalled = false;
bool serverActionCalled = false;
void saveClientState(SocketState x)
{
isCalled = true;
testLocalSocketState = x;
}
void saveServerState(SocketState x)
{
testLocalSocketState = x;
serverActionCalled = true;
}
testListener = Networking.StartServer(saveServerState, 2112);
// Try to connect without setting up a server first.
Networking.ConnectToServer(saveClientState, "ipv6.google.com", 2112);
// NetworkTestHelper.WaitForOrTimeout(() => isCalled, NetworkTestHelper.timeout);
Assert.IsTrue(isCalled);
Assert.IsTrue(testLocalSocketState.ErrorOccured);
Assert.AreEqual("IPV4 addresses were not found", testLocalSocketState.ErrorMessage);
}
public void TestConnectCallsDelegate()
{
bool serverActionCalled = false;
bool clientActionCalled = false;
void saveServerState(SocketState x)
{
testLocalSocketState = x;
serverActionCalled = true;
}
void saveClientState(SocketState x)
{
testRemoteSocketState = x;
clientActionCalled = true;
}
testListener = Networking.StartServer(saveServerState, 2112);
Networking.ConnectToServer(saveClientState, "localhost", 2112);
NetworkTestHelper.WaitForOrTimeout(() => serverActionCalled, NetworkTestHelper.timeout);
NetworkTestHelper.WaitForOrTimeout(() => clientActionCalled, NetworkTestHelper.timeout);
Assert.IsTrue(serverActionCalled);
Assert.IsTrue(clientActionCalled);
}
public void TestStopServer()
{
void saveServerState(SocketState x)
{
testLocalSocketState = x;
}
void saveClientState(SocketState x)
{
testLocalSocketState = x;
}
testListener = Networking.StartServer(saveServerState, 2112);
Networking.ConnectToServer(saveClientState, "localhost", 2112);
Assert.IsTrue(testLocalSocketState.TheSocket.Connected);
Networking.StopServer(testListener);
}
public void TestStartServer()
{
SocketState state = new SocketState(null, null);
void toCall(SocketState s)
{
}
bool passed = false;
try {
TcpListener listener = Networking.StartServer(toCall, 10000000);
NetworkTestHelper.WaitForOrTimeout(() => false, 2000);
}
catch (Exception e) {
passed = true;
}
Assert.IsTrue(passed);
}
private TcpListener SetupSingleServerTest()
{
void saveServerState(SocketState x)
{
testLocalSocketState = x;
testLocalSocketState.OnNetworkAction = s => { };
}
void saveClientState(SocketState x)
{
testRemoteSocketState = x;
}
TcpListener listener = Networking.StartServer(saveServerState, 2112);
Networking.ConnectToServer(saveClientState, "localhost", 2112);
WaitForOrTimeout(() => (testLocalSocketState != null) && (testRemoteSocketState != null), timeout);
return(listener);
}
public void TestConnectCallsDelegate()
{
bool isCalled = false;
void saveServerState(SocketState x)
{
testLocalSocketState = x;
isCalled = true;
}
void saveClientState(SocketState x)
{
testRemoteSocketState = x;
}
testListener = Networking.StartServer(saveServerState, 2112);
Networking.ConnectToServer(saveClientState, "localhost", 2112);
WaitForOrTimeout(() => isCalled, timeout);
Assert.IsTrue(isCalled);
}
public static void SetupSingleConnectionTest(out TcpListener listener, out SocketState client, out SocketState server, int port)
{
SocketState clientResult = null;
SocketState serverResult = null;
void saveClientState(SocketState x)
{
clientResult = x;
}
void saveServerState(SocketState x)
{
serverResult = x;
}
listener = Networking.StartServer(saveServerState, port);
Networking.ConnectToServer(saveClientState, "localhost", port);
WaitForOrTimeout(() => (clientResult != null) && (serverResult != null), timeout);
client = clientResult;
server = serverResult;
}
public void TestConnectToServerError3()
{
string message = "this message here";
bool firstTime = true;
int times = 0;
void toCall(SocketState s)
{
times++;
testLocalSocketState = s;
if (firstTime)
{
firstTime = false;
throw new Exception(message);
}
}
testListener = Networking.StartServer(s => { }, 2134);
Networking.ConnectToServer(toCall, "localhost", 2134);
NetworkTestHelper.WaitForOrTimeout(() => false, 3000);
Assert.IsTrue(testLocalSocketState.ErrorOccured);
Assert.IsTrue(testLocalSocketState.ErrorMessage.Equals(message));
}
public void TestTwoServers()
{
SocketState server2 = null;
SocketState client2 = null;
bool server2Connected = false;
bool receive1Called = false;
bool receive2Called = false;
string client1Message = "";
string client2Message = "";
string server1Message = "";
string server2Message = "";
void Server2OnConnect(SocketState s)
{
if (s.ErrorOccured)
{
return;
}
server2Connected = true;
server2 = s;
server2.OnNetworkAction = Server2OnReceive;
}
void Client2OnConnect(SocketState s)
{
if (s.ErrorOccured)
{
return;
}
client2 = s;
}
void Server1OnReceive(SocketState s)
{
if (s.ErrorOccured)
{
return;
}
receive1Called = true;
server1Message = s.GetData();
}
void Server2OnReceive(SocketState s)
{
if (s.ErrorOccured)
{
return;
}
receive2Called = true;
server2Message = s.GetData();
}
void Client1OnReceive(SocketState s)
{
if (s.ErrorOccured)
{
return;
}
receive1Called = true;
client1Message = s.GetData();
}
void Client2OnReceive(SocketState s)
{
if (s.ErrorOccured)
{
return;
}
receive2Called = true;
client2Message = s.GetData();
}
// setup first server and client using the normal helper
SetupTestConnections(false);
testLocalSocketState.OnNetworkAction = Server1OnReceive;
// setup second server and client
TcpListener listener2 = Networking.StartServer(Server2OnConnect, 2222);
Networking.ConnectToServer(Client2OnConnect, "localhost", 2222);
// wait for the second pair to connect
WaitForOrTimeout(() => server2 != null && client2 != null, timeout);
// Receive on server1
Networking.GetData(testLocalSocketState);
// Receive on server2
Networking.GetData(server2);
// Receive on client1
testRemoteSocketState.OnNetworkAction = Client1OnReceive;
Networking.GetData(testRemoteSocketState);
// Receive on client2
client2.OnNetworkAction = Client2OnReceive;
Networking.GetData(client2);
// Send from client1 to server1
Networking.Send(testRemoteSocketState.TheSocket, "a");
// Send from client2 to server2
Networking.Send(client2.TheSocket, "b");
// Send from server1 to client1
Networking.Send(testLocalSocketState.TheSocket, "c");
// Send from server2to client2
Networking.Send(server2.TheSocket, "d");
WaitForOrTimeout(() => server2Connected && receive1Called && receive2Called, timeout);
Assert.IsTrue(server2Connected);
Assert.IsTrue(receive1Called);
Assert.IsTrue(receive2Called);
Assert.AreEqual("a", server1Message);
Assert.AreEqual("b", server2Message);
Assert.AreEqual("c", client1Message);
Assert.AreEqual("d", client2Message);
}
private TcpListener StartTestServer(int port)
{
TcpListener listener = Networking.StartServer(OnNewClient, port);
return(listener);
}
private void GameServer(
out Dictionary <long, StringBuilder> serverSentMessages,
out Dictionary <long, StringBuilder> serverReceivedMessages)
{
object serverConnectionsLock = new object();
Dictionary <long, SocketState> serverSocketStates = new Dictionary <long, SocketState>();
Dictionary <long, StringBuilder> sentMessages = new Dictionary <long, StringBuilder>();
Dictionary <long, StringBuilder> receivedMessages = new Dictionary <long, StringBuilder>();
Random rand = new Random(0);
// Local function to serve as a callMe delegate
void serverFirstContact(SocketState state)
{
if (state.ErrorOccured)
{
return;
}
// Save the socket state so we can broadcast to all clients
// Also save the rest of the per-connection state for validating the test
lock (serverConnectionsLock)
{
// Use one of the stringbuilder lists as a unique socket ID
// since they will strictly grow (the SocketState lists will grow and shrink)
//state.uid = sentMessages.Count;
sentMessages[state.ID] = new StringBuilder();
receivedMessages[state.ID] = new StringBuilder();
serverSocketStates[state.ID] = state;
// send the client's ID
// important to do this inside the lock so the broadcast loop doesn't
// run before sending the client's ID
sentMessages[state.ID].Append("" + state.ID + "\n");
Networking.Send(state.TheSocket, "" + state.ID + "\n");
}
// Start a receive loop from the client
state.OnNetworkAction = removeMessage;
Networking.GetData(state);
}
// Local function to serve as a callMe delegate
// Receive loop for the server that just removes and saves the client's messages
void removeMessage(SocketState state)
{
if (state.ErrorOccured)
{
return;
}
StringBuilder rcv;
lock (serverConnectionsLock)
{
rcv = receivedMessages[state.ID];
}
rcv.Append(state.GetData());
state.RemoveData(0, state.GetData().Length);
Networking.GetData(state);
}
testListener = Networking.StartServer(serverFirstContact, 2112);
// Start a stopwatch to simulate a game server's tick-rate
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch = new System.Diagnostics.Stopwatch();
watch.Start();
int nextChar = 0;
// Run for 150 frames
for (int frame = 0; frame < 150; frame++)
{
// Create several messages ranging in size between 0x - 0.5x the buffer size,
StringBuilder messages = new StringBuilder();
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < rand.Next((int)(SocketState.BufferSize * 0.5)); j++)
{
messages.Append((char)('a' + (nextChar++ % 26)));
}
// Newline separator indicates end of object
messages.Append("\n");
}
lock (serverConnectionsLock)
{
foreach (StringBuilder sb in sentMessages.Values)
{
sb.Append(messages);
}
foreach (SocketState ss in serverSocketStates.Values)
{
if (ss.TheSocket.Connected)
{
Networking.Send(ss.TheSocket, messages.ToString());
}
}
}
// Simulate slow-ish server that gives the clients enough time to receive
// between frames so that we can assume that everything sent is also received
while (watch.ElapsedMilliseconds < 30)
{ /* just waiting */
}
watch.Restart();
} // end frame loop
serverSentMessages = sentMessages;
serverReceivedMessages = receivedMessages;
}
public void TestSimulateClientAndServer()
{
// For this test, we will use testRemoteSocketState as the server's SocketState
// and testLocalSocketState as the client's SocketState
Random rand = new Random(0);
StringBuilder serverReceived = new StringBuilder();
StringBuilder clientReceived = new StringBuilder();
StringBuilder clientSent = new StringBuilder();
// Local function to serve as a callMe delegate
void serverFirstContact(SocketState state)
{
if (state.ErrorOccured)
{
return;
}
// Save the socket state globally so that the Cleanup method can close it
testRemoteSocketState = state;
// Start a receive loop from the client
state.OnNetworkAction = removeMessage;
Networking.GetData(state);
}
// Local function to serve as a callMe delegate
// Receive loop for the server that just removes and saves the client's messages
void removeMessage(SocketState state)
{
if (state.ErrorOccured)
{
return;
}
serverReceived.Append(state.GetData());
state.RemoveData(0, state.GetData().Length);
Networking.GetData(state);
}
// Local function to serve as a callMe delegate
void clientFirstContact(SocketState state)
{
if (state.ErrorOccured)
{
return;
}
// Save the socket state globally so that the Cleanup method can close it
testLocalSocketState = state;
// Start a receive loop from the server
state.OnNetworkAction = handleMessage;
Networking.GetData(state);
}
// Local function to serve as a callMe delegate
// Receive loop for the client that simualtes "processing" a message by
// looking for a newline separator
void handleMessage(SocketState state)
{
if (state.ErrorOccured)
{
return;
}
ProcessMessage(state, clientReceived);
// Reply to the server about half of the time
if (rand.Next(2) == 0)
{
StringBuilder reply = new StringBuilder();
for (int i = 0; i < rand.Next(10); i++)
{
reply.Append((char)('a' + rand.Next(26)));
}
reply.Append("\n");
clientSent.Append(reply);
Networking.Send(state.TheSocket, reply.ToString());
}
// Continue the receive loop
Networking.GetData(state);
}
// Start the listener
testListener = Networking.StartServer(serverFirstContact, 2112);
// Start the client
Networking.ConnectToServer(clientFirstContact, "localhost", 2112);
// Wait for both sides to connect
WaitForOrTimeout(() => testLocalSocketState != null && testRemoteSocketState != null, timeout);
// Run the server loop
StringBuilder serverSent = SingleClientServerLoop();
WaitForOrTimeout(() => clientReceived.Length == serverSent.Length, timeout);
WaitForOrTimeout(() => clientSent.Length == serverReceived.Length, timeout);
Assert.AreEqual(clientReceived.ToString(), serverSent.ToString());
Assert.AreEqual(clientSent.ToString(), serverReceived.ToString());
}
public void TestMyOwn()
{
// List to represents connections
List <SocketState> server = new List <SocketState>();
void SaveServer(SocketState s)
{
lock (this)
{
server.Add(s);
}
}
//Two clients
SocketState client_1 = null;
void SaveClient_1(SocketState s)
{
client_1 = s;
}
SocketState client_2 = null;
void SaveClient_2(SocketState s)
{
client_2 = s;
}
// Starting a server
TcpListener listener = Networking.StartServer(SaveServer, 2112);
// Client1 Connect to the server
Networking.ConnectToServer(SaveClient_1, "localhost", 2112);
// Client2 Connect to the server
Networking.ConnectToServer(SaveClient_2, "localhost", 2112);
// Make sure this line is what you want to it behave
NetworkTestHelper.WaitForOrTimeout(() => (client_2 != null) && (client_1 != null) && (server.Count == 2), NetworkTestHelper.timeout);
// Set the action to do nothing
foreach (SocketState state in server)
{
state.OnNetworkAction = x => { };
}
client_1.OnNetworkAction = x => { };
client_2.OnNetworkAction = x => { };
foreach (SocketState state in server)
{
Networking.SendAndClose(state.TheSocket, "a");
}
Networking.GetData(client_1);
Networking.GetData(client_2);
// Note that waiting for data like this is *NOT* how the networking library is
// intended to be used. This is only for testing purposes.
// Normally, you would provide an OnNetworkAction that handles the data.
NetworkTestHelper.WaitForOrTimeout(() => client_1.GetData().Length > 0 && client_2.GetData().Length > 0, NetworkTestHelper.timeout);
Assert.AreEqual("a", client_1.GetData());
Assert.AreEqual("a", client_2.GetData());
//Make sure everything close and stop properly
listener.Stop();
foreach (SocketState state in server)
{
state.TheSocket.Close();
}
client_1.TheSocket.Close();
client_2.TheSocket.Close();
}
