void when_running_in_parallel_with_collect()
{
Promise <object> p1 = null;
Promise <object> p2 = null;
Promise <object[]> promise = null;
List <float> eventProgresses = null;
context["when running with a promise that fulfills and one that fails"] = () => {
before = () => {
eventProgresses = new List <float>();
p1 = TestHelper.PromiseWithError <object>("error 42", delay * 2);
p2 = TestHelper.PromiseWithResult <object>("42", delay);
promise = Promise.Collect(p1, p2);
promise.OnProgressed += eventProgresses.Add;
promise.Await();
};
it["is fulfilled"] = () => promise.state.should_be(PromiseState.Fulfilled);
it["has progressed 100%"] = () => promise.progress.should_be(1f);
it["has result"] = () => promise.result.should_not_be_null();
it["has no error"] = () => promise.error.should_be_null();
it["has results at correct index"] = () => {
(promise.result[0]).should_be_null();
(promise.result[1]).should_be("42");
};
it["calls progress"] = () => {
eventProgresses.Count.should_be(2);
eventProgresses[0].should_be(0.5f);
eventProgresses[1].should_be(1f);
};
it["has initial progress"] = () => {
var deferred = new Deferred <object>();
deferred.Progress(0.5f);
p2 = TestHelper.PromiseWithResult <object>("42", delay);
var collect = Promise.Collect(deferred, p2);
collect.progress.should_be(0.25f);
deferred.Fulfill(null);
collect.Await();
};
};
context["when all promises fail"] = () => {
before = () => {
eventProgresses = new List <float>();
p1 = TestHelper.PromiseWithError <object>("error 42", delay * 2);
p2 = TestHelper.PromiseWithError <object>("error 43", delay);
promise = Promise.Collect(p1, p2);
promise.OnProgressed += eventProgresses.Add;
promise.Await();
};
it["progresses"] = () => {
eventProgresses.Count.should_be(2);
eventProgresses[0].should_be(0.5f);
eventProgresses[1].should_be(1f);
};
};
}
void when_running_in_parallel_with_any()
{
Promise <string> p1 = null;
Promise <string> p2 = null;
Promise <string> p3 = null;
Promise <string> p4 = null;
Promise <string> promise = null;
context["when at least one promise fulfills"] = () => {
List <float> eventProgresses = null;
before = () => {
p1 = TestHelper.PromiseWithError <string>("error 42", delay);
p2 = TestHelper.PromiseWithResult("42", delay * 2);
p3 = TestHelper.PromiseWithResult("43", delay * 3);
p4 = TestHelper.PromiseWithResult("44", delay * 3);
eventProgresses = new List <float>();
promise = Promise.Any(p1, p2, p3, p4);
promise.OnProgressed += eventProgresses.Add;
promise.Await();
};
it["is fulfilled"] = () => promise.state.should_be(PromiseState.Fulfilled);
it["first promise to be complete is fulfilled"] = () => p2.state.should_be(PromiseState.Fulfilled);
it["has result of first complete promise"] = () => promise.result.should_be("42");
context["progress"] = () => {
it["calculates progress of promise with highest progress"] = () => {
eventProgresses.Count.should_be(1);
eventProgresses[0].should_be(1f);
};
it["has initial max progress"] = () => {
var deferred = new Deferred <object>();
deferred.Progress(0.5f);
var p = TestHelper.PromiseWithResult <object>("42", delay * 2);
var any = Promise.Any(deferred, p);
any.progress.should_be(0.5f);
deferred.Fulfill(null);
any.Await();
};
};
};
context["when all promises fail"] = () => {
before = () => {
p1 = TestHelper.PromiseWithError <string>("error 42", delay);
p2 = TestHelper.PromiseWithError <string>("error 43", delay * 2);
p3 = TestHelper.PromiseWithError <string>("error 44", delay * 3);
promise = Promise.Any(p1, p2, p3);
promise.Await();
};
it["fails"] = () => promise.state.should_be(PromiseState.Failed);
it["has no result"] = () => promise.result.should_be_null();
it["has error"] = () => promise.error.should_not_be_null();
};
}
void when_running_in_parallel_with_any()
{
Promise<string> p1 = null;
Promise<string> p2 = null;
Promise<string> p3 = null;
Promise<string> p4 = null;
Promise<string> promise = null;
context["when at least one promise fulfills"] = () => {
List<float> eventProgresses = null;
before = () => {
p1 = TestHelper.PromiseWithError<string>("error 42", delay);
p2 = TestHelper.PromiseWithResult("42", delay * 2);
p3 = TestHelper.PromiseWithResult("43", delay * 3);
p4 = TestHelper.PromiseWithResult("44", delay * 3);
eventProgresses = new List<float>();
promise = Promise.Any(p1, p2, p3, p4);
promise.OnProgressed += eventProgresses.Add;
promise.Await();
};
it["is fulfilled"] = () => promise.state.should_be(PromiseState.Fulfilled);
it["first promise to be complete is fulfilled"] = () => p2.state.should_be(PromiseState.Fulfilled);
it["has result of first complete promise"] = () => promise.result.should_be("42");
context["progress"] = () => {
it["calculates progress of promise with highest progress"] = () => {
eventProgresses.Count.should_be(1);
eventProgresses[0].should_be(1f);
};
it["has initial max progress"] = () => {
var deferred = new Deferred<object>();
deferred.Progress(0.5f);
var p = TestHelper.PromiseWithResult<object>("42", delay * 2);
var any = Promise.Any(deferred, p);
any.progress.should_be(0.5f);
deferred.Fulfill(null);
any.Await();
};
};
};
context["when all promises fail"] = () => {
before = () => {
p1 = TestHelper.PromiseWithError<string>("error 42", delay);
p2 = TestHelper.PromiseWithError<string>("error 43", delay * 2);
p3 = TestHelper.PromiseWithError<string>("error 44", delay * 3);
promise = Promise.Any(p1, p2, p3);
promise.Await();
};
it["fails"] = () => promise.state.should_be(PromiseState.Failed);
it["has no result"] = () => promise.result.should_be_null();
it["has error"] = () => promise.error.should_not_be_null();
};
}
void when_concatenating_with_then()
{
Promise <int> firstPromise = null;
Promise <string> thenPromise = null;
after = () => {
firstPromise.Await();
thenPromise.Await();
};
context["when first promise fulfilles"] = () => {
before = () => {
firstPromise = TestHelper.PromiseWithResult(42, delay);
thenPromise = firstPromise.Then(result => {
Thread.Sleep(delay);
return(result + "_then");
});
};
context["before first promise finished"] = () => {
it["first promise is running"] = () => assertRunning(firstPromise, 0f);
it["then promise is pending"] = () => assertPending(thenPromise);
it["then promise waits"] = () => {
thenPromise.Await();
assertFulfilled(firstPromise, 42);
assertFulfilled(thenPromise, "42_then");
};
context["when first promise finished"] = () => {
before = () => firstPromise.Await();
it["first promise is fulfilled"] = () => assertFulfilled(firstPromise, 42);
it["then promise in running with correct progress"] = () => assertRunning(thenPromise, 0.5f);
context["when then promise finished"] = () => {
before = () => thenPromise.Await();
it["then promise is fulfilled"] = () => assertFulfilled(thenPromise, "42_then");
};
};
};
};
context["when first promise fails"] = () => {
before = () => {
firstPromise = TestHelper.PromiseWithError <int>("error 42", delay);
thenPromise = firstPromise.Then(result => {
Thread.Sleep(delay);
return(result + "_then");
});
firstPromise.Await();
};
it["first promise failed"] = () => assertFailed(firstPromise, "error 42");
it["then promise failed"] = () => assertFailed(thenPromise, "error 42");
};
context["when putting it all together"] = () => {
it["fulfills all promises and passes result"] = () => {
var promise = Promise.WithAction(() => "1")
.Then(result => result + "2")
.Then(result => result + "3")
.Then(result => result + "4");
var fulfilled = 0;
promise.OnFulfilled += result => fulfilled++;
promise.Await();
fulfilled.should_be(1);
promise.result.should_be("1234");
};
it["forwards error"] = () => {
var promise = TestHelper.PromiseWithError <string>("error 42")
.Then(result => result + "2")
.Then(result => result + "3")
.Then(result => result + "4");
var fulfilled = false;
Exception eventError = null;
promise.OnFulfilled += result => fulfilled = true;
promise.OnFailed += error => eventError = error;
promise.Await();
fulfilled.should_be_false();
eventError.Message.should_be("error 42");
promise.result.should_be_null();
promise.error.Message.should_be("error 42");
};
it["calculates correct progress"] = () => {
var promise = Promise.WithAction(() => {
Thread.Sleep(delay);
return("1");
}).Then(result => result + "2")
.Then(result => result + "3")
.Then <string>(result => {
throw new Exception("error 42");
});
int eventCalled = 0;
var expectedProgresses = new [] { 0.25f, 0.5f, 0.75, 1f };
promise.OnProgressed += progress => {
progress.should_be(expectedProgresses[eventCalled]);
eventCalled++;
};
promise.Await();
eventCalled.should_be(expectedProgresses.Length - 1);
};
it["has initial progress"] = () => {
var deferred = new Deferred <string>();
deferred.Progress(0.5f);
var then = deferred.promise.Then(result => 0);
then.progress.should_be(0.25f);
deferred.Fulfill(null);
then.Await();
};
it["calculates correct progress with custum progress"] = () => {
var deferred1 = new Deferred <int>();
deferred1.action = () => {
Thread.Sleep(delay);
var progress = 0f;
while (progress < 1f)
{
progress += 0.25f;
deferred1.Progress(progress);
Thread.Sleep(delay);
}
return(0);
};
var deferred2 = new Deferred <int>();
deferred2.action = () => {
var progress = 0f;
while (progress < 1f)
{
progress += 0.25f;
deferred2.Progress(progress);
Thread.Sleep(delay);
}
return(0);
};
int eventCalled = 0;
var expectedProgresses = new [] {
0.125f, 0.25f, 0.375, 0.5f,
0.625f, 0.75f, 0.875f, 1f,
};
var promise = deferred1.RunAsync().Then(deferred2);
promise.OnProgressed += progress => {
progress.should_be(expectedProgresses[eventCalled]);
eventCalled++;
};
promise.Await();
eventCalled.should_be(expectedProgresses.Length);
};
};
}
void when_running_in_parallel_with_collect()
{
Promise<object> p1 = null;
Promise<object> p2 = null;
Promise<object[]> promise = null;
List<float> eventProgresses = null;
context["when running with a promise that fulfills and one that fails"] = () => {
before = () => {
eventProgresses = new List<float>();
p1 = TestHelper.PromiseWithError<object>("error 42", delay * 2);
p2 = TestHelper.PromiseWithResult<object>("42", delay);
promise = Promise.Collect(p1, p2);
promise.OnProgressed += eventProgresses.Add;
promise.Await();
};
it["is fulfilled"] = () => promise.state.should_be(PromiseState.Fulfilled);
it["has progressed 100%"] = () => promise.progress.should_be(1f);
it["has result"] = () => promise.result.should_not_be_null();
it["has no error"] = () => promise.error.should_be_null();
it["has no thread assigned"] = () => promise.thread.should_be_null();
it["has results at correct index"] = () => {
(promise.result[0]).should_be_null();
(promise.result[1]).should_be("42");
};
it["calls progress"] = () => {
eventProgresses.Count.should_be(2);
eventProgresses[0].should_be(0.5f);
eventProgresses[1].should_be(1f);
};
it["has initial progress"] = () => {
var deferred = new Deferred<object>();
deferred.Progress(0.5f);
p2 = TestHelper.PromiseWithResult<object>("42", delay);
var collect = Promise.Collect(deferred, p2);
collect.progress.should_be(0.25f);
deferred.Fulfill(null);
collect.Await();
};
};
context["when all promises fail"] = () => {
before = () => {
eventProgresses = new List<float>();
p1 = TestHelper.PromiseWithError<object>("error 42", delay * 2);
p2 = TestHelper.PromiseWithError<object>("error 43", delay);
promise = Promise.Collect(p1, p2);
promise.OnProgressed += eventProgresses.Add;
promise.Await();
};
it["progresses"] = () => {
eventProgresses.Count.should_be(2);
eventProgresses[0].should_be(0.5f);
eventProgresses[1].should_be(1f);
};
};
}
private void FulfillThenPromise()
{
thenPromise.Fulfill(5);
}
private void FulfillPromise()
{
promise.Fulfill(5);
}
