public void FailedIsTrueIfFutureValueIsException()
{
var f = new Future <object>();
f.Fail(new Exception("test"));
Assert.IsTrue(f.Failed);
}
public void InvokesOnCompletesWhenFailed()
{
var f = new Future <object>();
object completeResult = null;
f.RegisterOnComplete((_) => { completeResult = _.Error ?? _.Result; });
f.Fail(new Exception("test"));
Assert.AreEqual("test", (completeResult as Exception).Message);
}
public void ChildFutureFailuresDoNotAbortTasksIfHandled()
{
var failed = new Future <object>();
failed.Fail(new Exception("pancakes"));
var f = Scheduler.Start(YieldAndCheck(failed), TaskExecutionPolicy.RunWhileFutureLives);
Assert.AreEqual(false, Scheduler.WaitFor(f, 15));
}
public static Future <Network.UdpPacket> AsyncReceive(this UdpClient udpClient)
{
var f = new Future <Network.UdpPacket>();
try {
udpClient.BeginReceive((ar) => {
IPEndPoint endpoint = default(IPEndPoint);
try {
var bytes = udpClient.EndReceive(ar, ref endpoint);
f.Complete(new Network.UdpPacket(bytes, endpoint));
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
}
}, null);
} catch (Exception ex) {
f.Fail(ex);
}
return(f);
}
public void GettingResultThrowsExceptionIfFutureValueIsException()
{
var f = new Future <object>();
f.Fail(new Exception("test"));
try {
var _ = f.Result;
Assert.Fail();
} catch (FutureException e) {
Assert.AreEqual("test", e.InnerException.Message);
}
}
public void ChildFutureFailuresAbortTasksIfIgnored()
{
var failed = new Future <object>();
failed.Fail(new Exception("pancakes"));
var f = Scheduler.Start(YieldAndIgnore(failed), TaskExecutionPolicy.RunWhileFutureLives);
try {
Scheduler.WaitFor(f, 5);
throw new Exception("WaitFor did not bubble an exception");
} catch (FutureException fe) {
Assert.AreEqual("pancakes", fe.InnerException.Message);
}
}
public static Future <int> AsyncSend(this UdpClient udpClient, byte[] datagram, int bytes, string hostname, int port)
{
var f = new Future <int>();
try {
udpClient.BeginSend(
datagram, bytes, hostname, port,
(ar) => {
try {
var bytesSent = udpClient.EndSend(ar);
f.Complete(bytesSent);
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
}
},
null
);
} catch (Exception ex) {
f.Fail(ex);
}
return(f);
}
public static Future <TcpClient> AcceptIncomingConnection(this TcpListener listener)
{
var f = new Future <TcpClient>();
listener.BeginAcceptTcpClient((ar) => {
try {
TcpClient result = listener.EndAcceptTcpClient(ar);
f.Complete(result);
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
}
}, null);
return(f);
}
public static Future <HttpListenerContext> GetContextAsync(this HttpListener listener)
{
var f = new Future <HttpListenerContext>();
listener.BeginGetContext((ar) => {
try {
var result = listener.EndGetContext(ar);
f.Complete(result);
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
}
}, null);
return(f);
}
public static Future <TcpClient> ConnectTo(IPAddress address, int port)
{
var f = new Future <TcpClient>();
TcpClient client = new TcpClient();
client.BeginConnect(address, port, (ar) => {
try {
client.EndConnect(ar);
f.Complete(client);
} catch (FutureHandlerException) {
throw;
} catch (Exception ex) {
f.Fail(ex);
client.Close();
}
}, null);
return(f);
}
public override void Fail(Exception ex)
{
Future.Fail(ex);
}