public async Task SslStream_DefaultTlsConfigurationAsync_Ok()
{
using (var test = new AsyncTest())
{
await test.RunTest();
}
}
public IEnumerator GetAccessCodeFromTokenAsync_WebResponseSuccess_ReturnsToken()
{
LearningLayersOidcProvider lloidc = new LearningLayersOidcProvider();
IRestConnector restConnector = A.Fake <IRestConnector>();
A.CallTo(() => restConnector.PostAsync(A <string> .Ignored, A <string> .Ignored))
.Returns(Task.FromResult(new WebResponse <string>("json string", null, 200)));
lloidc.RestConnector = restConnector;
lloidc.ClientData = A.Fake <ClientData>();
LearningLayersAuthorizationFlowAnswer answer = new LearningLayersAuthorizationFlowAnswer();
answer.access_token = "myAccessToken";
IJsonSerializer serializer = A.Fake <IJsonSerializer>();
A.CallTo(() => serializer.FromJson <LearningLayersAuthorizationFlowAnswer>(A <string> .Ignored))
.Returns(answer);
lloidc.JsonSerializer = serializer;
Task <string> task = lloidc.GetAccessTokenFromCodeAsync("", "");
yield return(AsyncTest.WaitForTask(task));
string res = task.Result;
Assert.AreEqual(answer.access_token, res);
}
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 ReceiveRemove()
{
var person = new Person("remove");
list.Add(person);
var test = new AsyncTest();
list.CollectionChanged += (sender, args) => {
Assert.AreEqual(NotifyCollectionChangedAction.Remove, args.Action);
Assert.IsNull(args.NewItems);
Assert.IsNotNull(args.OldItems);
CollectionAssert.Contains(args.OldItems, person);
CollectionAssert.DoesNotContain(list, person);
test.PassHandler(null, EventArgs.Empty);
};
this.server.SendAsync(new BuddyListMessage
{
ChangeAction = NotifyCollectionChangedAction.Remove,
People = new[] { person }
});
test.Assert(10000);
}
public StateMachine(AsyncTest instance, StringBuilder builder, string secondLine)
{
this.instance = instance;
this.builder = builder;
this.secondLine = secondLine;
this.completionSource = new TaskCompletionSource <string>();
}
public IEnumerator GetUserInfoAsync_JsonParseFailed_ReturnsNull()
{
LearningLayersOidcProvider lloidc = new LearningLayersOidcProvider();
IRestConnector restConnector = A.Fake <IRestConnector>();
A.CallTo(() => restConnector.GetAsync(A <string> .Ignored))
.Returns(new WebResponse <string>("answer", null, 200));
lloidc.RestConnector = restConnector;
LearningLayersUserInfo userInfo = new LearningLayersUserInfo("tester", "*****@*****.**", "Tester");
IJsonSerializer serializer = A.Fake <IJsonSerializer>();
A.CallTo(() => serializer.FromJson <LearningLayersUserInfo>(A <string> .Ignored))
.Returns(null);
lloidc.JsonSerializer = serializer;
LogAssert.Expect(LogType.Error, new Regex(@"\w*Could not parse user info\w*"));
Task <IUserInfo> task = lloidc.GetUserInfoAsync("");
yield return(AsyncTest.WaitForTask(task));
IUserInfo res = task.Result;
Assert.IsNull(res);
}
public async Task SslStream_DefaultTlsConfigurationAsync_Ok()
{
using (var test = new AsyncTest())
{
await test.RunTest();
}
}
static void Main(string[] args)
{
AsyncTest a = new AsyncTest();
Task task = a.MethodAsync();
Console.WriteLine("Waiting in Main thread");
task.Wait();
}
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 ThrowsInvalidOperationExceptionWhenTransmissionIsAlreadySending()
{
AsyncTest.Run(async() =>
{
Transmission transmission = new Transmission(new Uri("http://uri"), new byte[] { 1, 2, 3, 4, 5 }, new HttpClient(), string.Empty, string.Empty); FieldInfo isSendingField = typeof(Transmission).GetField("isSending", BindingFlags.NonPublic | BindingFlags.Instance);
isSendingField.SetValue(transmission, 1);
await AssertEx.ThrowsAsync <InvalidOperationException>(() => transmission.SendAsync());
});
}
private async void btnAsyncUpdateTable_Click(object sender, EventArgs e)
{
var result = await AsyncTest.CallingAsync();
dohlcValues = AsyncTest.ConvertDatesToDohlcModel(dohlcValues, result);
dgvDohlcValues.DataSource = dohlcValues;
SqlConnector.InsertDohlcValuesToSql(dohlcValues);
}
public void ThrowsInvalidOperationExceptionWhenTransmissionIsAlreadySending()
{
AsyncTest.Run(async() =>
{
var transmission = new TestableTransmission();
FieldInfo isSendingField = typeof(Transmission).GetField("isSending", BindingFlags.NonPublic | BindingFlags.Instance);
isSendingField.SetValue(transmission, 1, BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Instance, null, null);
await AssertEx.ThrowsAsync <InvalidOperationException>(() => transmission.SendAsync());
});
}
public IEnumerator ExtendedLogging_Enabled_CommentsLogged()
{
mtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeLoader(content);
mtlLibrary.ExtendedLogging = true;
Task task = LoadLibrary();
yield return(AsyncTest.WaitForTask(task));
LogAssert.Expect(LogType.Log, new Regex(@"\w*Comment found\w*"));
}
public IEnumerator ExtendedLogging_Disabled_CommentsNotLogged()
{
mtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeLoader(content);
mtlLibrary.ExtendedLogging = false;
Task task = LoadLibrary();
yield return(AsyncTest.WaitForTask(task));
LogAssert.NoUnexpectedReceived();
}
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 Connected()
{
var test = new AsyncTest();
client.Connected += test.PassHandler;
client.Disconnected += test.FailHandler;
client.ConnectAsync (new IPEndPoint (IPAddress.Any, 0));
test.Assert (10000);
}
public IEnumerator GetMaterialConstructor_ExistentMatLibExistentMat_ReturnsNotNull()
{
mtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeLoader(content);
Task task = LoadLibrary();
yield return(AsyncTest.WaitForTask(task));
MaterialConstructor res = mtlLibrary.GetMaterialConstructor(libraryName, "BlueMat");
Assert.IsNotNull(res);
}
public IEnumerator LoadLibraryAsync_NewLibrary_LibraryLoadedReturnsTrue()
{
mtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeLoader(content);
Task task = LoadLibrary();
yield return(AsyncTest.WaitForTask(task));
bool loaded = mtlLibrary.LibraryLoaded(libraryName);
Assert.IsTrue(loaded, "The library should have been loaded but is not displayed as loaded");
}
public IEnumerator FetchDependencies_NoTexturesProvided_ReturnsTrue()
{
MaterialConstructor materialConstructor = new MaterialConstructor();
Task <bool> task = materialConstructor.FetchDependencies();
yield return(AsyncTest.WaitForTask(task));
bool success = task.Result;
Assert.True(success);
}
public IEnumerator ImportAsync_ThreeObj_HasThreeChildren()
{
ObjImporter objImporter = SetUpObjImporter(threeObj, threeMtl);
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
Assert.AreEqual(3, res.transform.childCount);
}
public IEnumerator GetMaterialConstructor_ExistentMatLibExistentMat_MatConstrColorSet()
{
mtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeLoader(content);
Task task = LoadLibrary();
yield return(AsyncTest.WaitForTask(task));
MaterialConstructor res = mtlLibrary.GetMaterialConstructor(libraryName, "BlueMat");
Assert.IsNotNull(res);
Assert.AreEqual(new Color(0.185991f, 0.249956f, 0.800000f), res.Color);
}
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);
}
public IEnumerator ImportAsync_WebRequestSuccess_SetName()
{
ObjImporter objImporter = SetUpObjImporter(cubeObj, cubeMtl);
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
Assert.NotNull(res);
Assert.AreEqual("test", res.name);
}
public IEnumerator ImportAsync_CubeObj_HasChild()
{
ObjImporter objImporter = SetUpObjImporter(cubeObj, cubeMtl);
Task <GameObject> testTask = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(testTask));
GameObject res = testTask.Result;
Assert.NotNull(res);
Assert.AreEqual(1, res.transform.childCount);
}
public IEnumerator ImportAsync_CubeObj_ChildHasCorrectMaterial()
{
ObjImporter objImporter = SetUpObjImporter(cubeObj, cubeMtl);
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
MeshRenderer mr = res.transform.GetChild(0).GetComponent <MeshRenderer>();
Assert.AreEqual("TestMaterial", mr.sharedMaterial.name);
}
public IEnumerator LoadLibraryAsync_LoadFailed_LibraryLoadedReturnsFalse()
{
mtlLibrary.ContentLoader = FakeContentLoaderFactory.CreateFakeFailLoader <string>();
LogAssert.Expect(LogType.Error, new Regex(@"\w*This is a simulated fail\w*"));
Task task = LoadLibrary();
yield return(AsyncTest.WaitForTask(task));
bool loaded = mtlLibrary.LibraryLoaded(libraryName);
Assert.IsFalse(loaded, "The import should have aborted but apparently, the library is shown as imported");
}
public void ThrowsInvalidOperationExceptionWhenTransmissionIsAlreadySending()
{
AsyncTest.Run(async() =>
{
var request = new StubWebRequest();
request.OnBeginGetRequestStream = (callback, state) => TaskEx.Delay(TimeSpan.FromMilliseconds(10)).AsAsyncResult(callback, request);
var transmission = new TestableTransmission();
transmission.OnCreateRequest = uri => request;
Task dontWait = transmission.SendAsync();
await AssertEx.ThrowsAsync <InvalidOperationException>(() => transmission.SendAsync());
});
}
public IEnumerator ImportAsync_CubeObj_ChildHasCorrectMesh()
{
ObjImporter objImporter = SetUpObjImporter(cubeObj, cubeMtl);
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
MeshFilter mf = res.transform.GetChild(0).GetComponent <MeshFilter>();
Assert.AreEqual(24, mf.sharedMesh.vertices.Length); // 8 * 3 = 24 (every vertex belongs to three triangles)
Assert.AreEqual(36, mf.sharedMesh.triangles.Length); // 12 *3 = 36
}
public IEnumerator FetchTextureAsync_WebRequestFailed_ReturnsNull()
{
TextureConstructor textureConstructor = new TextureConstructor(loadPath);
textureConstructor.TextureLoader = FakeContentLoaderFactory.CreateFakeFailLoader <Texture2D>();
LogAssert.Expect(LogType.Error, new Regex(@"\w*This is a simulated fail\w*"));
Task <Texture2D> task = textureConstructor.FetchTextureAsync();
yield return(AsyncTest.WaitForTask(task));
Texture2D res = task.Result;
Assert.Null(res);
}
public IEnumerator ImportAsync_EmptyObj_ReturnGameObject()
{
ObjImporter objImporter = SetUpObjImporter(emptyObj, emptyMtl);
LogAssert.Expect(LogType.Warning, new Regex(@"\w*There is an object without parsed vertices\w*"));
LogAssert.Expect(LogType.Error, new Regex(@"\w*No objects could be constructed.\w*"));
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
Assert.NotNull(res);
Assert.AreEqual(0, res.transform.childCount);
}
public IEnumerator FetchTextureAsync_WebRequestSuccessful_ReturnsTexture()
{
TextureConstructor textureConstructor = new TextureConstructor(loadPath);
Texture2D expected = new Texture2D(2, 2);
textureConstructor.TextureLoader = FakeContentLoaderFactory.CreateFakeLoader(expected);
Task <Texture2D> task = textureConstructor.FetchTextureAsync();
yield return(AsyncTest.WaitForTask(task));
Texture2D res = task.Result;
Assert.NotNull(res);
Assert.AreEqual(expected.imageContentsHash, res.imageContentsHash);
}
public static GameObject Find(string name)
{
if (MainForm.global_beh is AsyncTest)
{
AsyncTest beh = MainForm.global_beh as AsyncTest;
if (name.Equals("Canvas"))
{
return(beh.canvas);
}
else if (name.Equals("Button"))
{
return(beh.button);
}
}
return(null);
}
public IEnumerator FetchDependencies_TextureFetchFail_ReturnsFalse()
{
MaterialConstructor materialConstructor = new MaterialConstructor();
ITextureConstructor fakeTextureConstructorFail = A.Fake <ITextureConstructor>();
A.CallTo(() => fakeTextureConstructorFail.FetchTextureAsync()).Returns(Task.FromResult <Texture2D>(null));
materialConstructor.SetTexture("tex", fakeTextureConstructorFail);
Task <bool> task = materialConstructor.FetchDependencies();
yield return(AsyncTest.WaitForTask(task));
bool success = task.Result;
Assert.False(success);
}
public void AbortsPreviousAction()
{
AsyncTest.Run(async() =>
{
var timer = new TaskTimer {
Delay = TimeSpan.FromMilliseconds(1)
};
bool actionInvoked = false;
timer.Start(() => Task.Factory.StartNew(() => actionInvoked = true));
timer.Cancel();
await Task.Delay(20);
Assert.False(actionInvoked);
});
}
public IEnumerator GetAccessCodeFromTokenAsync_NoClientData_ReturnsEmptyString()
{
LearningLayersOidcProvider lloidc = new LearningLayersOidcProvider();
lloidc.RestConnector = A.Fake <IRestConnector>();
LogAssert.Expect(LogType.Error,
new Regex(@"\w*No client data supplied for the OpenID Connect Client\w*"));
Task <string> task = lloidc.GetAccessTokenFromCodeAsync("", "");
yield return(AsyncTest.WaitForTask(task));
string res = task.Result;
Assert.IsEmpty(res);
}
public IEnumerator ImportAsync_CubeObj_ChildHasComponents()
{
ObjImporter objImporter = SetUpObjImporter(cubeObj, cubeMtl);
Task <GameObject> task = objImporter.ImportAsync("http://test.org/test.obj");
yield return(AsyncTest.WaitForTask(task));
GameObject res = task.Result;
MeshFilter mf = res.transform.GetChild(0).GetComponent <MeshFilter>();
Assert.NotNull(mf);
MeshRenderer mr = res.transform.GetChild(0).GetComponent <MeshRenderer>();
Assert.NotNull(mr);
}
public void DisconnectWithReason()
{
var test = new AsyncTest<ClientDisconnectedEventArgs> (e =>
{
Assert.AreEqual ("reason", e.CustomReason);
Assert.AreEqual (ConnectionResult.Custom, e.Reason);
Assert.IsTrue (e.Requested);
});
client.Connected += (sender, e) => client.DisconnectWithReason ("reason");
client.Disconnected += test.PassHandler;
client.ConnectAsync (new IPEndPoint (IPAddress.Any, 0));
test.Assert (10000);
}
public void GenericMessageHandling()
{
var test = new AsyncTest (e =>
{
var me = (MessageEventArgs<MockMessage>)e;
Assert.AreSame (connection, me.Connection);
Assert.AreEqual ("hi", me.Message.Content);
});
Action<MessageEventArgs<MockMessage>> handler = e => test.PassHandler (test, e);
client.RegisterMessageHandler (handler);
client.ConnectAsync (new IPEndPoint (IPAddress.Any, 0));
connection.Receive (new MessageEventArgs (connection, new MockMessage { Content = "hi" }));
test.Assert (10000);
}
public void FailIfNotPassed_False()
{
var test = new AsyncTest();
test.Assert (10, failIfNotPassed: false);
}
public void DisconnectFromHandlerThread()
{
var test = new AsyncTest();
Action<MessageEventArgs<MockMessage>> handler = e => {
client.DisconnectAsync().ContinueWith (t => {
test.PassHandler (null, EventArgs.Empty);
});
};
client.RegisterMessageHandler (handler);
client.ConnectAsync (new Target (Target.AnyIP, 0));
connection.Receive (new MessageEventArgs (connection, new MockMessage { Content = "hi" }));
test.Assert (10000);
}
public void RejectSha1()
{
TearDown();
provider = new NetworkConnectionProvider (new [] { MockProtocol.Instance }, (IPEndPoint)EndPoint, MaxConnections, () => new RSACrypto(), new string[] { "SHA256" } );
provider.Start (MessageTypes);
var test = new AsyncTest<DisconnectedEventArgs> (d => Assert.AreEqual (ConnectionResult.FailedHandshake, d.Result));
var client = new NetworkClientConnection (new[] { MockProtocol.Instance }, () => new MockSha1OnlyCrypto());
client.ConnectAsync (EndPoint, MessageTypes);
client.Connected += test.FailHandler;
client.Disconnected += test.PassHandler;
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 MessageHandlingGlobalOrder()
{
IServerConnection connection = null;
var test = new AsyncTest(e =>
{
var me = (MessageEventArgs)e;
Assert.AreSame (connection, me.Connection);
Assert.IsInstanceOf (typeof(MockMessage), me.Message);
Assert.AreEqual ("hi", ((MockMessage)me.Message).Content);
});
var server = new MockServer (MessageTypes.Reliable);
server.AddConnectionProvider (provider, ExecutionMode.GlobalOrder);
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 IPEndPoint (IPAddress.Any, 0), MessageTypes.Reliable);
c.Send (new MockMessage { Content = "hi" });
test.Assert (10000);
}
public void MessageHandling()
{
var test = new AsyncTest (e =>
{
var me = (MessageEventArgs)e;
Assert.AreSame (connection, me.Connection);
Assert.IsInstanceOf (typeof(MockMessage), me.Message);
Assert.AreEqual ("hi", ((MockMessage)me.Message).Content);
});
Action<MessageEventArgs> handler = e => test.PassHandler (test, e);
((IContext)client).RegisterMessageHandler (MockProtocol.Instance, 1, handler);
client.ConnectAsync (new IPEndPoint (IPAddress.Any, 0));
connection.Receive (new MessageEventArgs (connection, new MockMessage { Content = "hi" }));
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 async Task<object> Any(AsyncTest request)
{
var response = await Client.PostAsync(new Echoes { Sentence = "Foo" });
return response;
}
public void MultiProtocolMessageHandling()
{
var test = new AsyncTest (e =>
{
var me = (MessageEventArgs)e;
Assert.AreSame (connection, me.Connection);
Assert.IsTrue (me.Message is MockMessage2);
Assert.AreEqual ("hi", ((MockMessage2)me.Message).Content);
});
Action<MessageEventArgs> handler = e => test.PassHandler (test, e);
((IContext)client).RegisterMessageHandler (MockProtocol.Instance, 1, handler);
((IContext)client).RegisterMessageHandler (MockProtocol2.Instance, 1, handler);
client.ConnectAsync (new Target (Target.AnyIP, 0));
connection.Receive (new MessageEventArgs (connection, new MockMessage2 { Content = "hi" }));
test.Assert (10000);
}
public void MultiProtocolGenericMessageHandling()
{
var test = new AsyncTest (e =>
{
var me = (MessageEventArgs<MockMessage2>)e;
Assert.AreSame (connection, me.Connection);
Assert.AreEqual ("hi", me.Message.Content);
});
Action<MessageEventArgs<MockMessage2>> handler = e => test.PassHandler (test, e);
client.RegisterMessageHandler (handler);
client.RegisterMessageHandler (handler);
client.ConnectAsync (new Target (Target.AnyIP, 0));
connection.Receive (new MessageEventArgs (connection, new MockMessage2 { Content = "hi" }));
test.Assert (10000);
}
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 DisconnectFromHandlerThread()
{
var test = new AsyncTest();
Action<MessageEventArgs<MockMessage>> handler = e =>
{
client.Disconnect (true);
test.PassHandler (null, EventArgs.Empty);
};
client.RegisterMessageHandler (handler);
client.ConnectAsync (new IPEndPoint (IPAddress.Any, 0));
connection.Receive (new MessageEventArgs (connection, new MockMessage { Content = "hi" }));
test.Assert (10000);
}
public void ConnectionMade()
{
var server = new MockServer (provider, MessageTypes.Reliable);
server.Start();
var test = new AsyncTest();
server.ConnectionMade += test.PassHandler;
var client = provider.GetClientConnection (protocol);
client.ConnectAsync (new IPEndPoint (IPAddress.Any, 0), MessageTypes.Reliable);
test.Assert (5000);
}
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 GenericMessageHandling()
{
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 MockServer (provider, MessageTypes.Reliable);
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 IPEndPoint (IPAddress.Any, 0), MessageTypes.Reliable);
c.Send (new MockMessage { Content = "hi" });
test.Assert (10000);
}
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 ConnectionLimit()
{
provider.Start (MessageTypes);
AutoResetEvent wait = new AutoResetEvent (false);
int counter = 0;
provider.ConnectionMade += (s, e) =>
{
if (Interlocked.Increment (ref counter) == MaxConnections)
wait.Set();
};
IClientConnection client;
AsyncTest test;
for (int i = 0; i < MaxConnections; ++i)
{
test = new AsyncTest();
client = GetNewClientConnection();
client.Connected += test.PassHandler;
client.Disconnected += test.FailHandler;
client.ConnectAsync (Target, MessageTypes);
test.Assert (10000);
}
if (!wait.WaitOne (30000))
Assert.Fail ("MaxConnections was not reached in time");
test = new AsyncTest();
provider.ConnectionMade += test.FailHandler;
client = GetNewClientConnection();
client.Disconnected += test.PassHandler;
client.ConnectAsync (Target, MessageTypes);
test.Assert (10000, false);
}
public void FailIfNotPassed()
{
var test = new AsyncTest();
Assert.Throws<AssertionException> (() => test.Assert (10, failIfNotPassed: true));
}
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);
}
