public void MultiOrderedOnFailureCalled() { var token = new AsyncToken <TestResult>(); var failureACalled = false; var failureBCalled = false; var failureCCalled = false; token .OnFailure(exception => failureACalled = true) .OnFailure(exception => { Assert.IsTrue(failureACalled); failureBCalled = true; }) .OnFailure(exception => { Assert.IsTrue(failureACalled); Assert.IsTrue(failureBCalled); failureCCalled = true; }); token.Fail(new Exception()); Assert.IsTrue(failureCCalled); }
/// <summary> /// Creates a single token from a collection of tokens. /// /// A failure from any one of the tokens will result in a failure of /// the returned token. If only a single token fails, only that exception /// is returned. If multiple tokens fail, an <c>AggregateException</c> /// is returned. /// /// If no tokens are passed in, the returned token is a Success. /// /// TODO: TESTS. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="tokens"></param> /// <returns></returns> public static IAsyncToken <T[]> All <T>(params IAsyncToken <T>[] tokens) { var len = tokens.Length; if (0 == len) { return(new AsyncToken <T[]>(new T[0])); } var returnToken = new AsyncToken <T[]>(); var values = new T[len]; var exceptions = new List <Exception>(); var numReturned = 0; for (var i = 0; i < len; i++) { var token = tokens[i]; var index = i; token .OnSuccess(value => values[index] = value) .OnFailure(exception => exceptions.Add(exception)) .OnFinally(_ => { if (++numReturned == len) { if (exceptions.Count > 1) { var aggregate = new AggregateException(); aggregate.Exceptions.AddRange(exceptions); returnToken.Fail(aggregate); } else if (exceptions.Count == 1) { returnToken.Fail(exceptions[0]); } else { returnToken.Succeed(values); } } }); } return(returnToken); }
public void OnSuccessNotCalledAfterResolved() { var token = new AsyncToken <TestResult>(); var called = false; token.Fail(new Exception()); token.OnSuccess(_ => called = true); Assert.IsFalse(called); }
public void OnFinallyCalledFromFail() { var token = new AsyncToken <TestResult>(); var called = false; token.OnFinally(_ => called = true); token.Fail(new Exception()); Assert.IsTrue(called); }
public void OnFinallyNotCalledAfterAbort() { var token = new AsyncToken <TestResult>(); var called = false; token.OnFinally(_ => called = true); token.Abort(); token.Fail(new Exception()); Assert.IsFalse(called); }
public void OnFailureAborted() { var token = new AsyncToken <TestResult>(); var called = false; token.OnFailure(_ => called = true); token.Abort(); token.OnFailure(_ => called = true); token.Fail(new Exception()); Assert.IsFalse(called); }
public void OnFinallyCalledInOrderOnFailure() { var token = new AsyncToken <TestResult>(); var failCalled = false; var finallyCalled = false; token .OnFailure(_ => failCalled = true) .OnFinally(_ => { Assert.IsTrue(failCalled); finallyCalled = true; }); token.Fail(new Exception()); Assert.IsTrue(finallyCalled); }
public void ExceptionIsCaughtOnFail() { var token = new AsyncToken <TestResult>(); var exception = new Exception(); var called = false; try { token .OnFailure(_ => throw exception) .OnFailure(_ => called = true); token.Fail(new Exception()); } catch (Exception thrown) { Assert.AreSame(exception, thrown); } Assert.IsTrue(called); }
public void OnFailureCalledExclusively() { var token = new AsyncToken <TestResult>(); var exception = new Exception(); var successCalled = false; var failureCalled = false; token .OnSuccess(value => { successCalled = true; }) .OnFailure(returnedException => { failureCalled = true; Assert.AreSame(exception, returnedException); }); token.Fail(exception); Assert.IsTrue(failureCalled); Assert.IsFalse(successCalled); }
public async Task TaskFail() { var token = new AsyncToken <float>(); Exception callbackException = null; token.OnFailure(exception => callbackException = exception); var task = token.AsTask(); var expectedException = new InvalidOperationException("Test exception"); token.Fail(expectedException); try { await task; } catch (Exception exception) { Assert.AreEqual(expectedException, exception); } Assert.AreEqual(expectedException, callbackException); }