public void IsConnected()
{
var test = new AsyncTest(passTimes: 2);
bool first = true;
client.PropertyChanged += (o, e) => {
if (e.PropertyName != "IsConnected")
{
return;
}
if (first)
{
Assert.IsTrue(client.IsConnected);
first = false;
client.DisconnectAsync();
}
else
{
Assert.IsFalse(client.IsConnected);
}
test.PassHandler(null, EventArgs.Empty);
};
client.ConnectAsync(new Target(Target.AnyIP, 0));
test.Assert(10000);
}
public void DisconnectWhileReceiving()
{
var test = new AsyncTest <ClientDisconnectedEventArgs> (e =>
{
Assert.AreEqual(ConnectionResult.Custom, e.Reason);
Assert.IsTrue(e.Requested);
});
bool send = true;
client.Connected += (sender, e) =>
{
new Thread(() =>
{
MockMessage m = new MockMessage {
Content = "asdf"
};
for (int i = 0; i < 10000 && send; ++i)
{
connection.Receive(new MessageEventArgs(connection, m));
}
}).Start();
Thread.Sleep(50);
client.DisconnectAsync();
};
client.Disconnected += test.PassHandler;
client.ConnectAsync(new Target(Target.AnyIP, 0));
test.Assert(10000);
send = false;
}
public void DisconnectFromClientOnServer()
{
var test = new AsyncTest(2);
var c = GetNewClientConnection();
c.Disconnected += (s, e) => {
Assert.IsFalse(c.IsConnected, "IsConnected was still true");
test.PassHandler(s, e);
};;
var wait = new AutoResetEvent(false);
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (s, e) =>
{
e.Connection.Disconnected += (ds, de) => {
Assert.IsFalse(e.Connection.IsConnected, "IsConnected was still true");
test.PassHandler(ds, de);
};
wait.Set();
};
c.ConnectAsync(Target, MessageTypes);
if (!wait.WaitOne(10000))
{
Assert.Fail("Failed to connect");
}
c.DisconnectAsync();
test.Assert(10000);
}
public void StressConcurrentSends()
{
var c = GetNewClientConnection();
const int messages = 10000;
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
Assert.AreSame(c, me.Connection);
int n;
Assert.IsTrue(Int32.TryParse(((MockMessage)me.Message).Content, out n));
}, messages);
const int threads = 4;
ParameterizedThreadStart thread = s =>
{
IConnection cn = (IConnection)s;
try
{
for (int i = 0; i < (messages / threads); ++i)
{
if (i > Int32.MaxValue)
{
System.Diagnostics.Debugger.Break();
}
if (!cn.IsConnected)
{
return;
}
cn.SendAsync(new MockMessage {
Content = i.ToString()
});
Thread.Sleep(1);
}
}
catch (Exception ex)
{
test.FailWith(ex);
}
};
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) =>
{
for (int i = 0; i < threads; ++i)
{
new Thread(thread).Start(e.Connection);
}
};
c.Disconnected += test.FailHandler;
c.MessageReceived += test.PassHandler;
c.ConnectAsync(Target, MessageTypes);
test.Assert(600000);
}
public async Task ProcessesMessagesAfterInternalReconnect()
{
var target = new Target(Target.AnyIP, 0);
var result = await this.client.ConnectAsync(target);
Assume.That(result.Result, Is.EqualTo(ConnectionResult.Success));
await this.connection.DisconnectAsync();
Assume.That(this.client.IsConnected, Is.False);
await this.connection.ConnectAsync(target, MessageTypes.All);
Assume.That(this.client.IsConnected, Is.True);
const string content = "hi";
var test = new AsyncTest(e => {
var me = (MessageEventArgs <MockMessage>)e;
Assert.AreSame(this.connection, me.Connection);
Assert.AreEqual(content, me.Message.Content);
});
bool received = false;
Action <MessageEventArgs <MockMessage> > handler = e => test.PassHandler(test, e);
this.client.RegisterMessageHandler(handler);
this.connection.Receive(new MessageEventArgs(this.connection, new MockMessage {
Content = content
}));
test.Assert(10000);
}
public void ServerSendMessageAsync()
{
const string content = "Oh, hello there.";
var c = GetNewClientConnection();
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
Assert.AreSame(c, me.Connection);
var msg = (me.Message as MockMessage);
Assert.IsNotNull(msg);
Assert.AreEqual(content, msg.Content);
});
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) => e.Connection.SendAsync(new MockMessage {
Content = content
});
c.Disconnected += test.FailHandler;
c.MessageReceived += test.PassHandler;
c.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void SendLongMessageAsync()
{
string content = TestHelpers.GetLongString(random, MaxPayloadSize - sizeof(int));
var c = GetNewClientConnection();
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
Assert.AreSame(c, me.Connection);
var msg = (me.Message as MockMessage);
Assert.IsNotNull(msg);
Assert.AreEqual(content, msg.Content);
});
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) => e.Connection.SendAsync(new MockMessage {
Content = content
});
c.Disconnected += test.FailHandler;
c.MessageReceived += test.PassHandler;
c.ConnectAsync(Target, MessageTypes);
test.Assert(30000);
}
public void ClientMessageSent()
{
const string content = "Oh, hello there.";
var c = GetNewClientConnection();
var test = new AsyncTest();
this.provider.Start(MessageTypes);
c.Disconnected += test.FailHandler;
c.Connected += (sender, e) =>
{
Task <bool> task = c.SendAsync(new MockMessage {
Content = content
});
task.Wait();
if (task.Result)
{
test.PassHandler(null, EventArgs.Empty);
}
else
{
test.FailHandler(null, EventArgs.Empty);
}
};
c.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void ClientSendMessageAsync()
{
const string content = "Oh, hello there.";
var c = GetNewClientConnection();
IServerConnection connection = null;
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
Assert.AreSame(me.Connection, connection);
var msg = (me.Message as MockMessage);
Assert.IsNotNull(msg);
Assert.AreEqual(content, msg.Content);
});
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) =>
{
connection = e.Connection;
e.Connection.MessageReceived += test.PassHandler;
};
c.Connected += (sender, e) => ThreadPool.QueueUserWorkItem(o => c.SendAsync(new MockMessage {
Content = content
}));
c.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void ConnectedWithKey()
{
this.provider.Start(MessageTypes);
RSAAsymmetricKey key = null;
var test = new AsyncTest(e =>
{
var ce = (ConnectionMadeEventArgs)e;
Assert.IsNotNull(ce.ClientPublicKey);
Assert.AreEqual(key, ce.ClientPublicKey);
});
this.provider.ConnectionMade += test.PassHandler;
var c = GetNewClientConnection(out key);
if (key == null)
{
Assert.Ignore();
}
c.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void DisconnectFromServerOnServer()
{
var test = new AsyncTest(2);
var c = GetNewClientConnection();
c.Disconnected += test.PassHandler;
IServerConnection sc = null;
var wait = new AutoResetEvent(false);
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) =>
{
e.Connection.Disconnected += test.PassHandler;
sc = e.Connection;
wait.Set();
};
c.ConnectAsync(Target, MessageTypes);
if (!wait.WaitOne(10000) || sc == null)
{
Assert.Fail("Failed to connect");
}
sc.DisconnectAsync();
test.Assert(10000);
}
public void GenericMessageHandlingGlobalOrder()
{
IServerConnection connection = null;
var test = new AsyncTest(e =>
{
var me = (MessageEventArgs <MockMessage>)e;
Assert.AreSame(connection, me.Connection);
Assert.AreEqual("hi", me.Message.Content);
});
var server = new TempestServer(MessageTypes.Reliable);
server.AddConnectionProvider(provider, ExecutionMode.GlobalOrder);
server.Start();
Action <MessageEventArgs <MockMessage> > handler = e => test.PassHandler(test, e);
server.RegisterMessageHandler(handler);
provider.ConnectionMade += (sender, e) => connection = e.Connection;
var c = provider.GetClientConnection(protocol);
c.ConnectAsync(new Target(Target.AnyIP, 0), MessageTypes.Reliable);
c.SendAsync(new MockMessage {
Content = "hi"
});
test.Assert(10000);
}
public void ConnectionLimitRestartListening()
{
IServerConnection connection = null;
provider.ConnectionMade += (sender, e) =>
{
if (connection == null)
{
connection = e.Connection;
}
};
ConnectionLimit();
Assert.IsNotNull(connection);
connection.DisconnectAsync();
AsyncTest test = new AsyncTest();
provider.ConnectionMade += test.PassHandler;
IClientConnection client = GetNewClientConnection();
client.Disconnected += test.FailHandler;
client.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void MessageHandling()
{
IServerConnection connection = null;
var test = new AsyncTest(e =>
{
var me = (MessageEventArgs)e;
Assert.AreSame(connection, me.Connection);
Assert.IsTrue(me.Message is MockMessage);
Assert.AreEqual("hi", ((MockMessage)me.Message).Content);
});
var server = new TempestServer(provider, MessageTypes.Reliable);
server.Start();
Action <MessageEventArgs> handler = e => test.PassHandler(test, e);
((IContext)server).RegisterMessageHandler(MockProtocol.Instance, 1, handler);
provider.ConnectionMade += (sender, e) => connection = e.Connection;
var c = provider.GetClientConnection(protocol);
c.ConnectAsync(new Target(Target.AnyIP, 0), MessageTypes.Reliable);
c.SendAsync(new MockMessage()
{
Content = "hi"
});
test.Assert(10000);
}
public void ISerializable()
{
byte[] buffer = new byte[20480];
var writer = new BufferValueWriter(buffer);
SerializableTester tester = new SerializableTester
{
Name = "MONKEY!",
Numbers = new[] { 1, 2, 4, 8, 16, 32 }
};
var test = new AsyncTest();
tester.SerializeCalled += test.PassHandler;
writer.Write(context, tester);
writer.Flush();
var reader = new BufferValueReader(buffer);
var serialized = SerializerExtensions.Read <SerializableTester> (reader, context);
Assert.IsNotNull(serialized);
Assert.AreEqual(tester.Name, serialized.Name);
Assert.IsTrue(tester.Numbers.SequenceEqual(serialized.Numbers), "Numbers does not match");
test.Assert(1000);
}
public void PingPong()
{
AsyncTest test = new AsyncTest();
IServerConnection connection = null;
provider.ConnectionMade += (sender, e) =>
{
if (connection == null)
{
connection = e.Connection;
}
};
provider.Start(MessageTypes);
((NetworkConnectionProvider)provider).PingFrequency = 1000;
var client = GetNewClientConnection();
client.Disconnected += test.FailHandler;
client.ConnectAsync(Target, MessageTypes);
test.Assert(30000, false);
Assert.IsNotNull(connection);
Assert.IsTrue(connection.IsConnected);
Assert.IsTrue(client.IsConnected);
}
public void TryGetBufferBlocksAndExisting()
{
var buffer = new BufferPool(128, 1);
SocketAsyncEventArgs e;
buffer.TryGetBuffer(out e);
DateTime now = DateTime.Now;
SocketAsyncEventArgs second = null;
var test = new AsyncTest(args => {
Assert.That(DateTime.Now - now, Is.GreaterThan(TimeSpan.FromSeconds(1)));
Assert.That(second, Is.SameAs(e));
});
Task.Run(() => {
Assert.IsTrue(buffer.TryGetBuffer(out second));
}).ContinueWith(t => {
test.PassHandler(null, EventArgs.Empty);
});
Task.Delay(1000).ContinueWith(t => {
buffer.PushBuffer(e);
});
test.Assert(2000);
}
public void Multiple_Passes_FailIfNotPassed()
{
var test = new AsyncTest(multiple: true);
test.PassHandler(this, EventArgs.Empty);
// failIfNotPassed refers to explicit Assert.Pass() calls only, not PassHandler calls.
Assert.Throws <AssertionException> (() => test.Assert(10, failIfNotPassed: true));
}
public void Multiple_Passes_NoFailures()
{
var test = new AsyncTest(multiple: true);
test.PassHandler(this, EventArgs.Empty);
test.PassHandler(this, EventArgs.Empty);
test.Assert(10, failIfNotPassed: false);
}
public void Multiple_Passes_Failure()
{
var test = new AsyncTest(multiple: true);
test.PassHandler(this, EventArgs.Empty);
test.PassHandler(this, EventArgs.Empty);
test.FailHandler(this, EventArgs.Empty);
Assert.Throws <AssertionException> (() => test.Assert(10, failIfNotPassed: false));
}
public void Connected()
{
var test = new AsyncTest();
client.Connected += test.PassHandler;
client.Disconnected += test.FailHandler;
client.ConnectAsync(new Target(Target.AnyIP, 0));
test.Assert(10000);
}
public void ConnectionMade()
{
this.provider.Start(MessageTypes);
var test = new AsyncTest();
this.provider.ConnectionMade += test.PassHandler;
var c = GetNewClientConnection();
c.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void StressAuthenticatedAndEncrypted()
{
var c = GetNewClientConnection();
const int messages = 1000;
int number = 0;
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
Assert.AreSame(c, me.Connection);
Assert.AreEqual(number, ((AuthenticatedAndEncryptedMessage)me.Message).Number);
Assert.AreEqual(number++.ToString(), ((AuthenticatedAndEncryptedMessage)me.Message).Message);
}, messages);
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) => (new Thread(() =>
{
try
{
for (int i = 0; i < messages; ++i)
{
if (i > Int32.MaxValue)
{
System.Diagnostics.Debugger.Break();
}
if (!e.Connection.IsConnected)
{
return;
}
e.Connection.SendAsync(new AuthenticatedAndEncryptedMessage {
Number = i, Message = i.ToString()
});
}
}
catch (Exception ex)
{
test.FailWith(ex);
}
})).Start();
c.Disconnected += test.FailHandler;
c.MessageReceived += test.PassHandler;
c.ConnectAsync(Target, MessageTypes);
test.Assert(80000);
}
public void EncryptedAndAuthenticatedLongMessage()
{
string message = TestHelpers.GetLongString(random, MaxPayloadSize - sizeof(int) * 2);
var cmessage = new AuthenticatedAndEncryptedMessage
{
Message = message,
Number = 42
};
var c = GetNewClientConnection();
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
var msg = (me.Message as AuthenticatedAndEncryptedMessage);
Assert.IsNotNull(msg);
Assert.IsTrue(msg.Encrypted);
Assert.IsTrue(msg.Authenticated);
Assert.AreEqual(cmessage.Message, msg.Message);
Assert.AreEqual(cmessage.Number, msg.Number);
});
IConnection sc;
ManualResetEvent wait = new ManualResetEvent(false);
this.provider.ConnectionMade += (s, e) =>
{
sc = e.Connection;
sc.MessageReceived += test.PassHandler;
sc.Disconnected += test.FailHandler;
wait.Set();
};
this.provider.Start(MessageTypes);
c.Disconnected += test.FailHandler;
c.Connected += (sender, e) => c.SendAsync(cmessage);
c.ConnectAsync(Target, MessageTypes);
if (!wait.WaitOne(10000))
{
Assert.Fail("Failed to connect");
}
test.Assert(10000);
}
public void ConnectionRejected()
{
var test = new AsyncTest();
var c = GetNewClientConnection();
c.Disconnected += test.PassHandler;
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) => e.Rejected = true;
c.ConnectAsync(Target, MessageTypes);
test.Assert(10000);
}
public void Disconnect()
{
var test = new AsyncTest <ClientDisconnectedEventArgs> (e =>
{
Assert.AreEqual(ConnectionResult.Custom, e.Reason);
Assert.IsTrue(e.Requested);
});
client.Connected += (sender, e) => client.DisconnectAsync();
client.Disconnected += test.PassHandler;
client.ConnectAsync(new Target(Target.AnyIP, 0));
test.Assert(10000);
}
public void DisconnectedFromConnection()
{
var test = new AsyncTest <ClientDisconnectedEventArgs> (e =>
{
Assert.IsFalse(e.Requested);
Assert.AreEqual(ConnectionResult.EncryptionMismatch, e.Reason);
});
client.Connected += (s, e) => connection.Disconnect(ConnectionResult.EncryptionMismatch);
client.Disconnected += test.PassHandler;
client.ConnectAsync(new Target(Target.AnyIP, 0));
test.Assert(1000);
}
public void StressRandomLongAuthenticatedMessage()
{
var c = GetNewClientConnection();
const int messages = 1000;
int number = 0;
var test = new AsyncTest(e =>
{
var me = (e as MessageEventArgs);
Assert.IsNotNull(me);
Assert.AreSame(c, me.Connection);
Assert.AreEqual(number++, ((AuthenticatedMessage)me.Message).Number);
Assert.IsTrue((((AuthenticatedMessage)me.Message).Message.Length >= 7500));
}, messages);
this.provider.Start(MessageTypes);
this.provider.ConnectionMade += (sender, e) => (new Thread(() =>
{
try
{
for (int i = 0; i < messages; ++i)
{
if (!e.Connection.IsConnected)
{
return;
}
e.Connection.SendAsync(new AuthenticatedMessage
{
Number = i,
Message = TestHelpers.GetLongString(random, MaxPayloadSize - sizeof(int) * 2)
});
}
}
catch (Exception ex)
{
test.FailWith(ex);
}
})).Start();
c.Disconnected += test.FailHandler;
c.MessageReceived += test.PassHandler;
c.ConnectAsync(Target, MessageTypes);
test.Assert(900000);
}
public void ConnectionMade()
{
var server = new TempestServer(provider, MessageTypes.Reliable);
server.Start();
var test = new AsyncTest();
server.ConnectionMade += test.PassHandler;
var client = provider.GetClientConnection(protocol);
client.ConnectAsync(new Target(Target.AnyIP, 0), MessageTypes.Reliable);
test.Assert(5000);
}
public void ServerConnectionConnected()
{
var provider = new MockConnectionProvider(MockProtocol.Instance);
provider.Start(MessageTypes.Reliable);
var test = new AsyncTest <ConnectionMadeEventArgs> (e => Assert.AreEqual(true, e.Connection.IsConnected));
provider.ConnectionMade += test.PassHandler;
var client = provider.GetClientConnection(MockProtocol.Instance);
client.ConnectAsync(new Target(Target.AnyIP, 0), MessageTypes.Reliable);
test.Assert(5000);
}