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); }