public void OnContinueIsInvokedWhenPromiseIsCanceled()
{
CancelationSource cancelationSource1 = CancelationSource.New();
var deferred = Promise.NewDeferred(cancelationSource1.Token);
CancelationSource cancelationSource2 = CancelationSource.New();
var deferred2 = Promise.NewDeferred(cancelationSource2.Token);
int voidFinallyFired = 0;
int intFinallyFired = 0;
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => ++ voidFinallyFired
);
TestHelper.AddContinueCallbacks <int, string>(deferred2.Promise,
onContinue: r => ++ intFinallyFired
);
cancelationSource1.Cancel();
cancelationSource2.Cancel("Cancel");
Promise.Manager.HandleCompletes();
Assert.AreEqual(TestHelper.continueVoidCallbacks * 2, voidFinallyFired);
Assert.AreEqual(TestHelper.continueTCallbacks * 2, intFinallyFired);
cancelationSource1.Dispose();
cancelationSource2.Dispose();
TestHelper.Cleanup();
}
public void OnContinueResultWhenPromiseIsResolved()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
int expected = 50;
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => Assert.AreEqual(r.State, Promise.State.Resolved)
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Resolved);
Assert.AreEqual(expected, r.Result);
}
);
deferred.Resolve();
deferredInt.Resolve(expected);
Promise.Manager.HandleCompletes();
TestHelper.Cleanup();
}
public void OnContinueCancelReasonWhenPromiseIsCanceled1()
{
CancelationSource cancelationSource1 = CancelationSource.New();
var deferred = Promise.NewDeferred(cancelationSource1.Token);
CancelationSource cancelationSource2 = CancelationSource.New();
var deferredInt = Promise.NewDeferred <int>(cancelationSource2.Token);
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Canceled);
Assert.AreEqual(null, r.CancelContainer.ValueType);
}
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Canceled);
Assert.AreEqual(null, r.CancelContainer.ValueType);
}
);
cancelationSource1.Cancel();
cancelationSource2.Cancel();
Promise.Manager.HandleCompletes();
cancelationSource1.Dispose();
cancelationSource2.Dispose();
TestHelper.Cleanup();
}
public void OnContinueRejectReasonWhenPromiseIsRejected()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
string rejection = "Reject";
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Rejected);
Assert.AreEqual(rejection, r.RejectContainer.Value);
}
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Rejected);
Assert.AreEqual(rejection, r.RejectContainer.Value);
}
);
deferred.Reject(rejection);
deferredInt.Reject(rejection);
Promise.Manager.HandleCompletes();
TestHelper.Cleanup();
}
public void OnContinueWillBeInvokedWithCapturedValue1()
{
var deferred = Promise.NewDeferred();
string expected = "expected";
bool invoked = false;
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
captureValue: expected,
onContinueCapture: (cv, r) =>
{
Assert.AreEqual(expected, cv);
invoked = true;
}
);
deferred.Reject("Reject");
Promise.Manager.HandleCompletes();
Assert.AreEqual(true, invoked);
// Clean up.
GC.Collect();
Promise.Manager.HandleCompletesAndProgress();
LogAssert.NoUnexpectedReceived();
}
public void OnContinueIsInvokedWhenPromiseIsRejected()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
int voidFinallyFired = 0;
int intFinallyFired = 0;
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => ++ voidFinallyFired
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r => ++ intFinallyFired
);
deferred.Promise.Catch(() => { });
deferredInt.Promise.Catch(() => { });
deferred.Reject("Reject");
deferredInt.Reject("Reject");
Promise.Manager.HandleCompletes();
Assert.AreEqual(TestHelper.continueVoidCallbacks * 2, voidFinallyFired);
Assert.AreEqual(TestHelper.continueTCallbacks * 2, intFinallyFired);
TestHelper.Cleanup();
}
public void OnContinueIsInvokedWhenPromiseIsResolved()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
int voidFinallyFired = 0;
int intFinallyFired = 0;
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => ++ voidFinallyFired
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r => ++ intFinallyFired
);
deferred.Resolve();
deferredInt.Resolve(50);
Promise.Manager.HandleCompletes();
Assert.AreEqual(TestHelper.continueVoidCallbacks, voidFinallyFired);
Assert.AreEqual(TestHelper.continueTCallbacks, intFinallyFired);
// Clean up.
GC.Collect();
Promise.Manager.HandleCompletesAndProgress();
LogAssert.NoUnexpectedReceived();
}
public void OnContinueCancelReasonWhenPromiseIsCanceled1()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Canceled);
Assert.AreEqual(null, r.CancelContainer.ValueType);
}
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r =>
{
Assert.AreEqual(r.State, Promise.State.Canceled);
Assert.AreEqual(null, r.CancelContainer.ValueType);
}
);
deferred.Cancel();
deferredInt.Cancel();
Promise.Manager.HandleCompletes();
// Clean up.
GC.Collect();
Promise.Manager.HandleCompletesAndProgress();
LogAssert.NoUnexpectedReceived();
}
public void OnContinueRethrowCancelReasonWhenPromiseIsCanceled0()
{
CancelationSource cancelationSource1 = CancelationSource.New();
var deferred = Promise.NewDeferred(cancelationSource1.Token);
CancelationSource cancelationSource2 = CancelationSource.New();
var deferredInt = Promise.NewDeferred <int>(cancelationSource2.Token);
int cancelations = 0;
string cancelation = "Cancel";
Promise.ResultContainer voidContainer = default(Promise.ResultContainer);
Promise <int> .ResultContainer intContainer = default(Promise <int> .ResultContainer);
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => voidContainer = r,
promiseToVoid: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); },
promiseToConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); return(0); },
promiseToPromise: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); return(null); },
promiseToPromiseConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); return(null); }
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r => intContainer = r,
promiseToVoid: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); },
promiseToConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); return(0); },
promiseToPromise: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); return(null); },
promiseToPromiseConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); return(null); }
);
cancelationSource1.Cancel(cancelation);
cancelationSource2.Cancel(cancelation);
Promise.Manager.HandleCompletes();
Assert.AreEqual(
(TestHelper.continueVoidCallbacks + TestHelper.continueTCallbacks) * 2,
cancelations
);
cancelationSource1.Dispose();
cancelationSource2.Dispose();
TestHelper.Cleanup();
}
public void OnContinueRethrowCancelReasonWhenPromiseIsCanceled0()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
int cancelations = 0;
string cancelation = "Cancel";
Promise.ResultContainer voidContainer = default(Promise.ResultContainer);
Promise <int> .ResultContainer intContainer = default(Promise <int> .ResultContainer);
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => voidContainer = r,
promiseToVoid: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); },
promiseToConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); return(0); },
promiseToPromise: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); return(null); },
promiseToPromiseConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); voidContainer.RethrowIfCanceled(); return(null); }
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r => intContainer = r,
promiseToVoid: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); },
promiseToConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); return(0); },
promiseToPromise: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); return(null); },
promiseToPromiseConvert: p => { p.CatchCancelation(e => { Assert.AreEqual(cancelation, e.Value); ++cancelations; }); intContainer.RethrowIfCanceled(); return(null); }
);
deferred.Cancel(cancelation);
deferredInt.Cancel(cancelation);
Promise.Manager.HandleCompletes();
Assert.AreEqual(TestHelper.continueVoidCallbacks + TestHelper.continueTCallbacks,
cancelations);
// Clean up.
GC.Collect();
Promise.Manager.HandleCompletesAndProgress();
LogAssert.NoUnexpectedReceived();
}
public void OnContinueRethrowRejectReasonWhenPromiseIsRejected()
{
var deferred = Promise.NewDeferred();
var deferredInt = Promise.NewDeferred <int>();
int rejections = 0;
string rejection = "Reject";
Promise.ResultContainer voidContainer = default(Promise.ResultContainer);
Promise <int> .ResultContainer intContainer = default(Promise <int> .ResultContainer);
TestHelper.AddContinueCallbacks <int, string>(deferred.Promise,
onContinue: r => voidContainer = r,
promiseToVoid: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); voidContainer.RethrowIfRejected(); },
promiseToConvert: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); voidContainer.RethrowIfRejected(); return(0); },
promiseToPromise: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); voidContainer.RethrowIfRejected(); return(null); },
promiseToPromiseConvert: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); voidContainer.RethrowIfRejected(); return(null); }
);
TestHelper.AddContinueCallbacks <int, int, string>(deferredInt.Promise,
onContinue: r => intContainer = r,
promiseToVoid: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); intContainer.RethrowIfRejected(); },
promiseToConvert: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); intContainer.RethrowIfRejected(); return(0); },
promiseToPromise: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); intContainer.RethrowIfRejected(); return(null); },
promiseToPromiseConvert: p => { p.Catch((object e) => { Assert.AreEqual(rejection, e); ++rejections; }); intContainer.RethrowIfRejected(); return(null); }
);
deferred.Reject(rejection);
deferredInt.Reject(rejection);
Promise.Manager.HandleCompletes();
Assert.AreEqual(
(TestHelper.continueVoidCallbacks + TestHelper.continueTCallbacks) * 2,
rejections
);
TestHelper.Cleanup();
}
public void OnContinueWillBeInvokedWithCapturedValue2()
{
var deferred = Promise.NewDeferred <int>();
string expected = "expected";
bool invoked = false;
TestHelper.AddContinueCallbacks <int, int, string>(deferred.Promise,
captureValue: expected,
onContinueCapture: (cv, r) =>
{
Assert.AreEqual(expected, cv);
invoked = true;
}
);
deferred.Resolve(50);
Promise.Manager.HandleCompletes();
Assert.AreEqual(true, invoked);
TestHelper.Cleanup();
}
public void AccessingRethrowInOnResolvedThrows()
{
var promise1 = Promise.Resolved();
var promise2 = Promise.Resolved(100);
int voidErrors = 0;
int intErrors = 0;
Action <Promise> callback = p =>
{
p.Catch((object e) =>
{
Assert.IsInstanceOf(typeof(InvalidOperationException), e);
++voidErrors;
});
var _ = Promise.Rethrow;
};
Action <Promise> callbackT = p =>
{
p.Catch((object e) =>
{
Assert.IsInstanceOf(typeof(InvalidOperationException), e);
++intErrors;
});
var _ = Promise.Rethrow;
};
TestHelper.AddResolveCallbacks <int, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddCallbacks <int, object, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddContinueCallbacks <int, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddResolveCallbacks <int, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(0); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(0)); }
);
TestHelper.AddCallbacks <int, bool, object, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(false); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(false)); }
);
TestHelper.AddContinueCallbacks <int, int, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(0); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(0)); }
);
Promise.Manager.HandleCompletes();
Assert.AreEqual(TestHelper.resolveVoidVoidCallbacks + TestHelper.resolveVoidConvertCallbacks +
TestHelper.resolveVoidPromiseVoidCallbacks + TestHelper.resolveVoidPromiseConvertCallbacks +
TestHelper.continueVoidVoidCallbacks + TestHelper.continueVoidConvertCallbacks +
TestHelper.continueVoidPromiseVoidCallbacks + TestHelper.continueVoidPromiseConvertCallbacks,
voidErrors);
Assert.AreEqual(TestHelper.resolveTVoidCallbacks + TestHelper.resolveTConvertCallbacks +
TestHelper.resolveTPromiseVoidCallbacks + TestHelper.resolveTPromiseConvertCallbacks +
TestHelper.continueTVoidCallbacks + TestHelper.continueTConvertCallbacks +
TestHelper.continueTPromiseVoidCallbacks + TestHelper.continueTPromiseConvertCallbacks,
intErrors);
// Clean up.
GC.Collect();
Promise.Manager.HandleCompletesAndProgress();
LogAssert.NoUnexpectedReceived();
}
public void ThrowingCancelExceptionInOnRejectedCancelsThePromiseWithTheGivenValue()
{
var promise1 = Promise.Rejected("Rejected");
var promise2 = Promise.Rejected <int, string>("Rejected");
int voidCancelations = 0;
int intCancelations = 0;
string expected = "Cancel!";
Action <Promise> callback = p =>
{
p.CatchCancelation(reason =>
{
Assert.AreEqual(expected, reason.Value);
++voidCancelations;
});
throw Promise.CancelException(expected);
};
Action <Promise> callbackT = p =>
{
p.CatchCancelation(reason =>
{
Assert.AreEqual(expected, reason.Value);
++intCancelations;
});
throw Promise.CancelException(expected);
};
TestHelper.AddCallbacks <int, object, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddContinueCallbacks <int, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddCallbacks <int, bool, object, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(false); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(false)); }
);
TestHelper.AddContinueCallbacks <int, int, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(0); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(0)); }
);
Promise.Manager.HandleCompletes();
Assert.AreEqual(TestHelper.rejectVoidVoidCallbacks + TestHelper.rejectVoidConvertCallbacks +
TestHelper.rejectVoidPromiseVoidCallbacks + TestHelper.rejectVoidPromiseConvertCallbacks +
TestHelper.continueVoidVoidCallbacks + TestHelper.continueVoidConvertCallbacks +
TestHelper.continueVoidPromiseVoidCallbacks + TestHelper.continueVoidPromiseConvertCallbacks,
voidCancelations);
Assert.AreEqual(TestHelper.rejectTVoidCallbacks + TestHelper.rejectTConvertCallbacks +
TestHelper.rejectTPromiseVoidCallbacks + TestHelper.rejectTPromiseConvertCallbacks +
TestHelper.continueTVoidCallbacks + TestHelper.continueTConvertCallbacks +
TestHelper.continueTPromiseVoidCallbacks + TestHelper.continueTPromiseConvertCallbacks,
intCancelations);
// Clean up.
GC.Collect();
Promise.Manager.HandleCompletesAndProgress();
LogAssert.NoUnexpectedReceived();
}
public void ThrowingRejectExceptionInOnResolvedRejectsThePromiseWithTheGivenValue()
{
var promise1 = Promise.Resolved();
var promise2 = Promise.Resolved(100);
int voidRejections = 0;
int intRejections = 0;
string expected = "Reject!";
Action <Promise> callback = p =>
{
p.Catch((string e) =>
{
Assert.AreEqual(expected, e);
++voidRejections;
});
throw Promise.RejectException(expected);
};
Action <Promise> callbackT = p =>
{
p.Catch((string e) =>
{
Assert.AreEqual(expected, e);
++intRejections;
});
throw Promise.RejectException(expected);
};
TestHelper.AddResolveCallbacks <int, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddCallbacks <int, object, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddContinueCallbacks <int, string>(promise1,
promiseToVoid: callback,
promiseToConvert: p => { callback(p); return(0); },
promiseToPromise: p => { callback(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callback(p); return(Promise.Resolved(0)); }
);
TestHelper.AddResolveCallbacks <int, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(0); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(0)); }
);
TestHelper.AddCallbacks <int, bool, object, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(false); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(false)); }
);
TestHelper.AddContinueCallbacks <int, int, string>(promise2,
promiseToVoid: callbackT,
promiseToConvert: p => { callbackT(p); return(0); },
promiseToPromise: p => { callbackT(p); return(Promise.Resolved()); },
promiseToPromiseConvert: p => { callbackT(p); return(Promise.Resolved(0)); }
);
Promise.Manager.HandleCompletes();
Assert.AreEqual(
(TestHelper.resolveVoidVoidCallbacks + TestHelper.resolveVoidConvertCallbacks +
TestHelper.resolveVoidPromiseVoidCallbacks + TestHelper.resolveVoidPromiseConvertCallbacks +
TestHelper.continueVoidVoidCallbacks + TestHelper.continueVoidConvertCallbacks +
TestHelper.continueVoidPromiseVoidCallbacks + TestHelper.continueVoidPromiseConvertCallbacks) * 2,
voidRejections
);
Assert.AreEqual(
(TestHelper.resolveTVoidCallbacks + TestHelper.resolveTConvertCallbacks +
TestHelper.resolveTPromiseVoidCallbacks + TestHelper.resolveTPromiseConvertCallbacks +
TestHelper.continueTVoidCallbacks + TestHelper.continueTConvertCallbacks +
TestHelper.continueTPromiseVoidCallbacks + TestHelper.continueTPromiseConvertCallbacks) * 2,
intRejections
);
TestHelper.Cleanup();
}