public void can_reject_simple_promise() { var ex = new Exception(); var promise = new Promise<int>(ex); var errors = 0; promise.Catch(e => { Assert.Equal(ex, e); ++errors; }); Assert.Equal(1, errors); }
public void NotCallBeforePromiseIsRejectedTest() { var promise = new Promise <object>(); var exception = new Exception(); var onRejected = false; promise.Catch((result) => { onRejected = true; }); var task = Task.Factory.StartNew(() => { Thread.Sleep(100); Assert.AreEqual(false, onRejected); }); task.Wait(); }
public void _must_have_a_reason_which_must_not_change() { var rejectedPromise = new Promise <object>(); var reason = new Exception(); var handled = 0; rejectedPromise.Catch(e => { Assert.Equal(reason, e); ++handled; }); rejectedPromise.Reject(reason); Assert.Throws <ApplicationException>(() => rejectedPromise.Reject(new Exception())); Assert.Equal(1, handled); }
public void can_reject_promise_and_trigger_error_handler_with_registration_after_reject() { var promise = new Promise(); var ex = new ApplicationException(); promise.Reject(ex); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); ++completed; }); Assert.Equal(1, completed); }
public void can_reject_promise_via_reject_function() { var ex = new Exception(); var promise = new Promise((resolve, reject) => { reject(ex); }); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); ++completed; }); Assert.Equal(1, completed); }
public void exception_thrown_during_resolver_rejects_proimse() { var ex = new Exception(); var promise = new Promise((resolve, reject) => { throw ex; }); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); ++completed; }); Assert.Equal(1, completed); }
public void CanRejectPromiseAndTriggerErrorHandlerWithRegistrationAfterReject() { var promise = new Promise <int>(); var ex = new Exception(); promise.Reject(ex); var completed = 0; promise.Catch(e => { Assert.AreEqual(ex, e); ++completed; }); Assert.AreEqual(1, completed); }
public void ExceptionThrownDuringResolverRejectsProimse() { var ex = new Exception(); var promise = new Promise <int>((resolve, reject) => { throw ex; }); var completed = 0; promise.Catch(e => { Assert.AreEqual(ex, e); ++completed; }); Assert.AreEqual(1, completed); }
public void NotMoreCallOnRejectedMoreRejectedTest() { var timesCalled = 0; var resultObj = new Exception(); var promise = new Promise <object>(); promise.Catch( (result) => { Assert.AreEqual(1, ++timesCalled); Assert.AreEqual(resultObj, result); } ); promise.Reject(resultObj); promise.Reject(new Exception()); CheckSettled(promise, null, false); }
public void CallAfterPromiseIsRejectedTest() { var promise = new Promise <object>(); var exception = new Exception(); var isRejected = false; promise.Catch((result) => { Assert.AreEqual(exception, result); Assert.AreEqual(isRejected, true); }); var task = Task.Factory.StartNew(() => { Thread.Sleep(50); isRejected = true; promise.Reject(exception); }); CheckSettled(promise, null, false); task.Wait(); }
public void DoubleCatchRejectedPromise() { var recaught = false; var differentError = new Exception("Different Failure."); var promise = new Promise <int>((fulfill, reject) => { reject(error); }); var catchPromise = promise.Catch(e => { throw differentError; }); var recaughtPromise = catchPromise.Catch(e => { recaught = true; }); Assert.That(promise.Rejected, Is.True); Assert.That(catchPromise.Rejected, Is.True); Assert.That(promise.Error, Is.EqualTo(error)); Assert.That(catchPromise.Error, Is.EqualTo(differentError)); Assert.That(recaughtPromise.Rejected, Is.True); Assert.That(recaughtPromise.Error, Is.EqualTo(differentError)); Assert.That(recaught, Is.True); }
public void _If_onFulfilled_is_not_a_function_and_promise1_is_fulfilled_promise2_must_be_fulfilled_with_the_same_value_as_promise1() { var promise1 = new Promise <object>(); var promise2 = promise1.Catch(_ => { throw new Exception("There shouldn't be an error"); }); var promisedValue = new object(); var promise2ThenHandler = 0; promise2.Then(v => { Assert.Equal(promisedValue, v); ++promise2ThenHandler; }); promise1.Resolve(promisedValue); Assert.Equal(1, promise2ThenHandler); }
public void NotMoreCallOnRejectedMoreDelayedRejectTest() { var timesCalled = 0; var resultObj = new Exception(); var promise = new Promise <object>(); promise.Catch( (result) => { Assert.AreEqual(1, ++timesCalled); Assert.AreEqual(resultObj, result); } ); var task = Task.Factory.StartNew(() => { promise.Reject(resultObj); promise.Reject(new Exception()); }); CheckSettled(promise, null, false); task.Wait(); }
public void CanRejectPromiseAndTriggerErrorHandlerWithRegistrationAfterReject() { var promise = new Promise<int>(); var ex = new ApplicationException(); promise.Reject(ex); var completed = 0; promise.Catch(e => { Assert.AreEqual(ex, e); ++completed; }); Assert.AreEqual(1, completed); }
public void CanRejectPromiseAndTriggerMultipleErrorHandlersInOrder() { var promise = new Promise<int>(); var ex = new ApplicationException(); var completed = 0; promise.Catch(e => { Assert.AreEqual(ex, e); Assert.AreEqual(1, ++completed); }); promise.Catch(e => { Assert.AreEqual(ex, e); Assert.AreEqual(2, ++completed); }); promise.Reject(ex); Assert.AreEqual(2, completed); }
public void can_reject_promise_and_trigger_error_handler() { var promise = new Promise(); var ex = new ApplicationException(); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); ++completed; }); promise.Reject(ex); Assert.Equal(1, completed); }
public void exception_thrown_during_resolver_rejects_proimse() { var ex = new Exception(); var promise = new Promise((resolve, reject) => { throw ex; }); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); ++completed; }); Assert.Equal(1, completed); }
public void _when_promise1_is_rejected() { var promise1 = new Promise<object>(); var e = new Exception(); var promise2 = promise1.Catch(_ => { throw e; }); promise1.Catch(_ => { throw new Exception("This shouldn't happen!"); }); var errorHandledForPromise2 = 0; promise2.Catch(ex => { Assert.Equal(e, ex); ++errorHandledForPromise2; }); promise1.Reject(new Exception()); Assert.Equal(1, errorHandledForPromise2); }
public void ExceptionThrownDuringResolverRejectsProimse() { var ex = new Exception(); var promise = new Promise<int>((resolve, reject) => { throw ex; }); var completed = 0; promise.Catch(e => { Assert.AreEqual(ex, e); ++completed; }); Assert.AreEqual(1, completed); }
public void APromiseMayBeCanceledWhenItIsPending1() { string cancelValue = "Cancel"; Action <Promise> validate = promise => { promise .Then(() => Assert.Fail("Promise was resolved when it should have been canceled."), () => Assert.Fail("Promise was rejected when it should have been canceled.")) .CatchCancelation(reason => Assert.AreEqual(cancelValue, reason.Value)); Promise.Manager.HandleCompletes(); }; Promise cancelPromise = null; Action cancel = () => cancelPromise.Cancel(cancelValue); cancelPromise = Promise.Resolved(0).Then(_ => cancel()); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(0); }); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(Promise.Resolved()); }); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(Promise.Resolved(0)); }); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => cancel(), () => { }); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => cancel(), (string failValue) => { }); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(0); }, () => 0); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(0); }, (string failValue) => 0); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(Promise.Resolved()); }, () => Promise.Resolved()); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(Promise.Resolved()); }, (string failValue) => Promise.Resolved()); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(Promise.Resolved(0)); }, () => Promise.Resolved(0)); validate(cancelPromise); cancelPromise = Promise.Resolved(0).Then(_ => { cancel(); return(Promise.Resolved(0)); }, (string failValue) => Promise.Resolved(0)); validate(cancelPromise); Promise <int> rejected = Promise.Rejected <int, string>("Reject"); // Suppress exception. rejected.Catch(() => { }); rejected.Retain(); cancelPromise = rejected.Then(_ => { }, () => cancel()); validate(cancelPromise); cancelPromise = rejected.Then(_ => { }, (string failValue) => cancel()); validate(cancelPromise); cancelPromise = rejected.Then(_ => 0, () => { cancel(); return(0); }); validate(cancelPromise); cancelPromise = rejected.Then(_ => 0, (string failValue) => { cancel(); return(0); }); validate(cancelPromise); cancelPromise = rejected.Then(_ => Promise.Resolved(), () => { cancel(); return(Promise.Resolved()); }); validate(cancelPromise); cancelPromise = rejected.Then(_ => Promise.Resolved(), (string failValue) => { cancel(); return(Promise.Resolved()); }); validate(cancelPromise); cancelPromise = rejected.Then(_ => Promise.Resolved(0), () => { cancel(); return(Promise.Resolved(0)); }); validate(cancelPromise); cancelPromise = rejected.Then(_ => Promise.Resolved(0), (string failValue) => { cancel(); return(Promise.Resolved(0)); }); validate(cancelPromise); cancelPromise = rejected.Catch(() => cancel()); validate(cancelPromise); cancelPromise = rejected.Catch((string failValue) => cancel()); validate(cancelPromise); cancelPromise = rejected.Catch(() => { cancel(); return(Promise.Resolved()); }); validate(cancelPromise); cancelPromise = rejected.Catch((string failValue) => { cancel(); return(Promise.Resolved()); }); validate(cancelPromise); rejected.Release(); // Clean up. Promise.Manager.HandleCompletesAndProgress(); GC.Collect(); Promise.Manager.HandleCompletesAndProgress(); LogAssert.NoUnexpectedReceived(); }
public void can_reject_promise_and_trigger_multiple_error_handlers_in_order() { var promise = new Promise<int>(); var ex = new ApplicationException(); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); Assert.Equal(1, ++completed); }); promise.Catch(e => { Assert.Equal(ex, e); Assert.Equal(2, ++completed); }); promise.Reject(ex); Assert.Equal(2, completed); }
public void _must_have_a_reason_which_must_not_change() { var rejectedPromise = new Promise<object>(); var reason = new Exception(); var handled = 0; rejectedPromise.Catch(e => { Assert.Equal(reason, e); ++handled; }); rejectedPromise.Reject(reason); Assert.Throws<ApplicationException>(() => rejectedPromise.Reject(new Exception())); Assert.Equal(1, handled); }
public void _when_promise_is_rejected_all_respective_onRejected_callbacks_must_execute_in_the_order_of_their_originating_calls_to_then() { var promise = new Promise<object>(); var order = 0; promise.Catch(_ => { Assert.Equal(1, ++order); }); promise.Catch(_ => { Assert.Equal(2, ++order); }); promise.Catch(_ => { Assert.Equal(3, ++order); }); promise.Reject(new Exception()); Assert.Equal(3, order); }
public void _If_onFulfilled_is_not_a_function_and_promise1_is_fulfilled_promise2_must_be_fulfilled_with_the_same_value_as_promise1() { var promise1 = new Promise<object>(); var promise2 = promise1.Catch(_ => { throw new Exception("There shouldn't be an error"); }); var promisedValue = new object(); var promise2ThenHandler = 0; promise2.Then(v => { Assert.Equal(promisedValue, v); ++promise2ThenHandler; }); promise1.Resolve(promisedValue); Assert.Equal(1, promise2ThenHandler); }
public void ErrorHandlerIsNotInvokedForResolvedPromised() { var promise = new Promise<int>(); promise.Catch(e => { throw new ApplicationException("This shouldn't happen"); }); promise.Resolve(5); }
public void CanRejectPromiseViaRejectFunction() { var ex = new Exception(); var promise = new Promise<int>((resolve, reject) => reject(ex)); var completed = 0; promise.Catch(e => { Assert.AreEqual(ex, e); ++completed; }); Assert.AreEqual(1, completed); }
public void can_reject_promise_via_reject_function() { var ex = new Exception(); var promise = new Promise((resolve, reject) => { reject(ex); }); var completed = 0; promise.Catch(e => { Assert.Equal(ex, e); ++completed; }); Assert.Equal(1, completed); }
public void error_handler_is_not_invoked_for_resolved_promised() { var promise = new Promise(); promise.Catch(e => { throw new ApplicationException("This shouldn't happen"); }); promise.Resolve(); }
public void _when_promise1_is_resolved_2() { var promise1 = new Promise<object>(); var e = new Exception(); Action<object> thenHandler = _ => { throw e; }; var promise2 = promise1.Then(thenHandler); promise1.Catch(_ => { throw new Exception("This shouldn't happen!"); }); var errorHandledForPromise2 = 0; promise2.Catch(ex => { Assert.Equal(e, ex); ++errorHandledForPromise2; }); promise1.Resolve(new object()); Assert.Equal(1, errorHandledForPromise2); }