public void ResolveTest()
{
var deferred = new Deferred<string, int>();
bool alwaysHit = false;
dynamic alwaysArg = null;
bool doneHit = false;
string doneArg = null;
bool failHit = false;
var promise = deferred.Promise();
promise.Always((arg) =>
{
alwaysHit = true;
alwaysArg = arg;
});
promise.Done((arg) =>
{
doneHit = true;
doneArg = arg;
});
promise.Fail(() => failHit = true);
deferred.Resolve("test");
Assert.IsTrue(alwaysHit, "Always is hit");
Assert.AreEqual("test", alwaysArg);
Assert.IsTrue(doneHit, "Done is hit");
Assert.AreEqual("test", doneArg);
Assert.IsFalse(failHit, "Fail is not hit");
}
public void RejectTest()
{
var deferred = new Deferred<string, int>();
bool alwaysHit = false;
dynamic alwaysArg = null;
bool doneHit = false;
bool failHit = false;
int? failArg = null;
var promise = deferred.Promise();
promise.Always((arg) =>
{
alwaysHit = true;
alwaysArg = arg;
});
promise.Done(() => doneHit = true);
promise.Fail((arg) =>
{
failHit = true;
failArg = arg;
});
deferred.Reject(1337);
Assert.IsTrue(alwaysHit, "Always is hit");
Assert.AreEqual(alwaysArg, 1337);
Assert.IsFalse(doneHit, "Done is not hit");
Assert.IsTrue(failHit, "Fail is hit");
Assert.AreEqual(failArg, 1337);
}
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();
};
}
public void AlwaysCallbackTest()
{
CallCounter counter = new CallCounter();
Deferred<None> d = new Deferred<None>();
d.Always(p =>
counter.Always++
);
d.Resolve();
d.Reject();
Assert.AreEqual(2, counter.Always);
}
public Task <IResult> Execute(IStatement sql)
{
var deferred = new Deferred <IResult>();
if (_connection == null)
{
deferred.Reject(new Exception("No active connection"));
}
else
{
sql.Execute(_connection, deferred);
}
return(deferred.Task);
}
/// <summary>
/// This will save game foundation's data as a JSON file on your machine.
/// This data will persist between play sessions.
/// This sample only showcases inventories, but this method saves their items, and stats too.
/// </summary>
public void Save()
{
// Deferred is a struct that helps you track the progress of an asynchronous operation of Game Foundation.
Deferred saveOperation = m_DataLayer.Save();
// Check if the operation is already done.
if (saveOperation.isDone)
{
LogSaveOperationCompletion(saveOperation);
}
else
{
StartCoroutine(WaitForSaveCompletion(saveOperation));
}
}
public async Task <IActionResult> GetNotifications(DomainId userId, [FromQuery] long version = EtagVersion.Any)
{
CheckPermissions(userId);
var result = await commentsLoader.GetCommentsAsync(userId, version);
var response = Deferred.Response(() =>
{
return(CommentsDto.FromResult(result));
});
Response.Headers[HeaderNames.ETag] = result.Version.ToString(CultureInfo.InvariantCulture);
return(Ok(response));
}
public async Task <IActionResult> GetAssetFolders(string app, [FromQuery] DomainId parentId, [FromQuery] AssetFolderScope scope = AssetFolderScope.PathAndItems)
{
var(folders, path) = await AsyncHelper.WhenAll(
GetAssetFoldersAsync(parentId, scope),
GetAssetPathAsync(parentId, scope));
var response = Deferred.Response(() =>
{
return(AssetFoldersDto.FromAssets(folders, path, Resources));
});
Response.Headers[HeaderNames.ETag] = folders.ToEtag();
return(Ok(response));
}
/// <summary>
/// Shows a dialog with a message and an ok button
/// </summary>
/// <param name="message">the message to show</param>
/// <returns>a promise that resolves when the dialog is dismissed. The promise never rejects.</returns>
public static Promise ShowMessage(ConsoleString message)
{
var d = Deferred.Create();
var buttonPromise = ShowMessage(new DialogButtonOptions()
{
Message = message,
Options = new List <DialogOption>()
{
DialogButtonOptions.OK
}
});
buttonPromise.Then((button) => d.Resolve());
return(d.Promise);
}
public override void Execute(SQLiteConnection connection, Deferred <IResult> deferred)
{
try
{
var results = connection.Query <T>(Sql, GetCommandArguments());
deferred.Resolve(new ResultSet <T>()
{
Objects = results
});
}
catch (Exception error)
{
deferred.Reject(error);
}
}
private Promise <string> QueryForAccessToken()
{
Deferred <string> deferred = new Deferred <string>();
// register callback support (required for WebClient)
if (ServicePointManager.ServerCertificateValidationCallback == null)
{
AddCertificateChainValidation();
}
// get an access token
using (WebClient client = new WebClient())
{
client.Headers.Add("Ocp-Apim-Subscription-Key", TranslationKey);
client.UploadDataCompleted += (object sender, UploadDataCompletedEventArgs e) =>
{
try
{
if (e.Cancelled)
{
_status = StatusOptions.failed;
deferred.Reject("web call was cancelled.");
}
else if (e.Error != null)
{
_status = StatusOptions.failed;
deferred.Reject(e.Error.Message);
}
else
{
accessToken = System.Text.Encoding.Default.GetString(e.Result);
lastToken = DateTime.Now;
deferred.Resolve();
}
}
catch (Exception ex)
{
_status = StatusOptions.failed;
deferred.Reject(ex.Message);
}
Reset();
};
byte[] buffer = { 0 };
client.UploadDataAsync(new System.Uri("https://api.cognitive.microsoft.com/sts/v1.0/issueToken"), buffer);
}
return(deferred.Promise());
}
/// <summary>
/// Resolve the returned promise once the predicate evalutes to true
/// </summary>
public Promise <object> WaitUntil(Func <TimeData, bool> predicate)
{
var promise = new Deferred <object>();
var wait = new PredicateWait()
{
timeStarted = curTime,
pendingPromise = promise,
timeData = new TimeData(),
predicate = predicate
};
waiting.Add(wait);
return(promise);
}
public void ShouldRejectWhenDoneInThenThrows_DeferredWithFailCase()
{
var source = new Deferred <TWrapper <int> > ();
source.Then <TWrapper <int> > (
_ => {
throw new Exception();
},
_ => {
return(Promises.Resolved(1.Wrap()));
})
.Done(doneCallback.Create()).Fail(failCallback.Create());
source.Resolve(1.Wrap());
Assert.That(doneCallback.IsCalled, Is.False);
Assert.That(failCallback.IsCalled, Is.True);
}
public void InitDeferred(NativeList <DataInstance> instanceList, TileTheme theme)
{
sourceType = SourceType.FromTheme;
meshFilters = null;
meshes = null;
matrices = null;
deferred = true;
deferredHandler = new Deferred(instanceList);
immediateHandler = null;
SourceMeshData = theme.TileThemeCache.MeshData;
Inited();
}
public void Init(NativeArray <DataInstance> instanceArray, TileTheme theme)
{
sourceType = SourceType.FromTheme;
meshFilters = null;
meshes = null;
matrices = null;
deferred = false;
immediateHandler = new Immediate(instanceArray);
deferredHandler = null;
SourceMeshData = theme.TileThemeCache.MeshData;
Inited();
}
public async Task <IActionResult> GetAsset(string app, DomainId id)
{
var asset = await assetQuery.FindAsync(Context, id, ct : HttpContext.RequestAborted);
if (asset == null)
{
return(NotFound());
}
var response = Deferred.Response(() =>
{
return(AssetDto.FromAsset(asset, Resources));
});
return(Ok(response));
}
public async Task <IActionResult> GetApps()
{
var userOrClientId = HttpContext.User.UserOrClientId();
var userPermissions = HttpContext.Permissions();
var apps = await appProvider.GetUserApps(userOrClientId, userPermissions);
var response = Deferred.Response(() =>
{
return(apps.Select(a => AppDto.FromApp(a, userOrClientId, userPermissions, appPlansProvider, this)).ToArray());
});
Response.Headers[HeaderNames.ETag] = apps.ToEtag();
return(Ok(response));
}
void Start()
{
var d = new Deferred <int>();
d.action = () => {
while (d.progress < 1)
{
Thread.Sleep(100);
d.Progress(d.progress + 0.4f);
}
return(42);
};
d.RunAsync().QueueOnMainThread(null, null, onProgressed);
}
public async Task <IActionResult> GetAssetFolders(string app, [FromQuery] Guid parentId)
{
var assetFolders = assetQuery.QueryAssetFoldersAsync(Context, parentId);
var assetPath = assetQuery.FindAssetFolderAsync(parentId);
await Task.WhenAll(assetFolders, assetPath);
var response = Deferred.Response(() =>
{
return(AssetFoldersDto.FromAssets(assetFolders.Result, assetPath.Result, Resources));
});
Response.Headers[HeaderNames.ETag] = assetFolders.Result.ToEtag();
return(Ok(response));
}
public Task InsertWines(Wine[] wines)
{
Deferred deferred = Deferred.Create();
_winesCollection.Insert(wines, null, delegate(Exception error) {
if (error == null)
{
deferred.Resolve();
return;
}
deferred.Reject(error);
});
return(deferred.Task);
}
public async Task <IActionResult> GetContent(string app, string schema, DomainId id)
{
var content = await contentQuery.FindAsync(Context, schema, id, ct : HttpContext.RequestAborted);
if (content == null)
{
return(NotFound());
}
var response = Deferred.Response(() =>
{
return(ContentDto.FromDomain(content, Resources));
});
return(Ok(response));
}
public async Task <IActionResult> GetAsset(string app, Guid id)
{
var asset = await assetQuery.FindAssetAsync(Context, id);
if (asset == null)
{
return(NotFound());
}
var response = Deferred.Response(() =>
{
return(AssetDto.FromAsset(asset, this, app));
});
return(Ok(response));
}
public Task <int> CountWines()
{
Deferred <int> deferred = Deferred.Create <int>();
_winesCollection.Count(delegate(Exception error, int count) {
if (error == null)
{
deferred.Resolve(count);
return;
}
deferred.Reject(error);
});
return(deferred.Task);
}
public void Execute(SQLiteConnection connection, Deferred <IResult> deferred)
{
try
{
var data = Objects?.ToArray() ?? new T[] { };
var results = connection.InsertAll(data, typeof(T));
deferred.Resolve(new RowsAffected()
{
Count = results
});
}
catch (Exception error)
{
deferred.Reject(error);
}
}
public void WhenAll()
{
Deferred test = new Deferred();
Deferred test2 = new Deferred();
message = null;
IPromise all = When.All(test, test2)
.Then((Action <string>)Resolved);
test.Resolve();
Assert.AreNotEqual("resolved", message);
test2.Resolve();
Assert.AreEqual("resolved", message);
}
public void WhenAllTimeout()
{
Deferred test = new Deferred();
Deferred test2 = new Deferred();
IPromise all = When.All(500, test, test2)
.Then((Action <string>)Resolved, (Action <string>)Rejected);
message = null;
Assert.IsNull(message);
System.Threading.Thread.Sleep(200);
Assert.IsNull(message);
System.Threading.Thread.Sleep(400);
Assert.AreEqual("rejected", message);
}
public async Task <IActionResult> GetAssetFolders(string app, [FromQuery] DomainId parentId)
{
var(folders, path) =
await AsyncHelper.WhenAll(
assetQuery.QueryAssetFoldersAsync(Context, parentId),
assetQuery.FindAssetFolderAsync(Context.App.Id, parentId)
);
var response = Deferred.Response(() =>
{
return(AssetFoldersDto.FromAssets(folders, path, Resources));
});
Response.Headers[HeaderNames.ETag] = folders.ToEtag();
return(Ok(response));
}
public void ShouldRejectWhenFailInThenThrows()
{
var source = new Deferred <TWrapper <int> > ();
source.Then <TWrapper <int> > (
_ => {
return(Promises.Resolved(1.Wrap()));
},
_ => {
throw new Exception("expected");
})
.Done(doneCallback.Create()).Fail(failCallback.Create());
source.Reject(new Exception("NOT expected"));
Assert.That(doneCallback.IsCalled, Is.False);
Assert.That(failCallback.IsCalled, Is.True);
Assert.That(failCallback.Exception.Message, Is.EqualTo("expected"));
}
public Task <IDatabase> Connect(string connectionString)
{
var deferred = new Deferred <IDatabase>();
try
{
_connection = new SQLiteConnection(connectionString);
deferred.Resolve(this);
}
catch (Exception error)
{
_connection = null;
deferred.Reject(error);
}
return(deferred.Task);
}
public async Task <IActionResult> GetContents(string app, string name, [FromQuery] string?ids = null, [FromQuery] string?q = null)
{
var schema = await contentQuery.GetSchemaOrThrowAsync(Context, name);
var contents = await contentQuery.QueryAsync(Context, name,
Q.Empty
.WithIds(ids)
.WithJsonQuery(q)
.WithODataQuery(Request.QueryString.ToString()));
var response = Deferred.AsyncResponse(async() =>
{
return(await ContentsDto.FromContentsAsync(contents, Context, this, schema, contentWorkflow));
});
return(Ok(response));
}
public Promise <T> Create(List <Promise <T> > promises)
{
if (promises.Count == 0)
{
return(Promises.Disposed <T> ());
}
nonResolvedCount = 0;
size = promises.Count;
deferred = new Deferred <T>();
foreach (var each in promises)
{
ObservePromise(each);
}
return(deferred);
}
public Task <object> ExecuteRequest(ApiRequest request)
{
ApiRequestObject requestObject = new ApiRequestObject(request);
object result = _app.Scripts.Execute(_path, GetScriptPath(request), "request", requestObject);
if (Script.IsNullOrUndefined(result) == false)
{
Task <object> taskResult = result as Task <object>;
if (taskResult != null)
{
return(taskResult);
}
}
return(Deferred.Create <object>(result).Task);
}
public void Load()
{
GameFoundationSdk.Uninitialize();
if (_dataLayer?.persistence == null)
{
Debug.LogError("DataLayer is null.");
return;
}
Deferred def = GameFoundationSdk.Initialize(_dataLayer);
if (def.isDone)
{
if (def.isFulfilled)
{
_onInitOrLoadComplete?.Invoke();
OnInitOrLoadComplete?.Invoke();
}
else
{
Debug.LogError(def.error.Message);
_onInitOrLoadFail?.Invoke();
}
}
else
{
IEnumerator Routine(Deferred aDef)
{
yield return(aDef.Wait());
if (aDef.isFulfilled)
{
_onInitOrLoadComplete?.Invoke();
OnInitOrLoadComplete?.Invoke();
}
else
{
Debug.LogError(aDef.error.Message);
_onInitOrLoadFail?.Invoke();
}
}
StartCoroutine(Routine(def));
}
}
private Promise <CUnit> SaveApiToDatabase()
{
Debug.Log("SaveApiToDatabase called");
var promise = new Deferred <CUnit>();
promise.Then <CUnit>(_ =>
{
Debug.Log("db saved");
return(null);
}, _ =>
{
Debug.Log("db is not saved");
return(null);
});
promise.Reject(new SystemException());
return(promise);
}
public void FailCallbackTest()
{
CallCounter counter = new CallCounter();
Deferred<None> d = new Deferred<None>();
d.Done(p =>
counter.Done++
).Fail(p =>
counter.Fail++
).Progress(p =>
counter.Progress++
);
d.Reject();
Assert.AreEqual(0, counter.Done);
Assert.AreEqual(1, counter.Fail);
Assert.AreEqual(0, counter.Progress);
}
public void GetProgressTest()
{
CallCounter counter = new CallCounter();
Deferred<System.String> d = new Deferred<System.String>();
d.Progress(p => {
Assert.AreEqual(0.5f, p.ProgressValue);
counter.Progress++;
});
d.Notify(0.5f);
Assert.AreEqual(1, counter.Progress);
}
public void GetResultTest()
{
CallCounter counter = new CallCounter();
Deferred<System.String> d = new Deferred<System.String>();
d.Done(p => {
Assert.AreEqual("UniDeffered", p.GetResult<System.String>());
counter.Done++;
});
d.Resolve("UniDeffered");
Assert.AreEqual(1, counter.Done);
}
public void StateTest()
{
Deferred<None> d = new Deferred<None>();
Assert.AreEqual(StateType.Pending, d.State);
d.Resolve();
Assert.AreEqual(StateType.Resolved, d.State);
d.Reject();
Assert.AreEqual(StateType.Rejected, d.State);
}
/// <summary>
/// Executes the callback of the deferred in timeout milliseconds.
/// result is the first parameter of the first callback in the deferred.
/// </summary>
/// <param name="deferred">
/// A <see cref="Deferred"/>
/// </param>
/// <param name="result">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="timeout">
/// A <see cref="System.Int32"/>
/// </param>
public void CallLater(Deferred deferred, object result, int timeout)
{
this._callLaterItems.Add((timeout * TimeSpan.TicksPerMillisecond) + DateTime.Now.Ticks, new CallLaterItem(deferred, result));
}
public void ResolveFinishedTest()
{
var deferred = new Deferred();
deferred.Resolve();
var promise = deferred.Promise();
bool alwaysHit = false;
bool doneHit = false;
bool failHit = false;
promise.Always(() => alwaysHit = true);
promise.Done(() => doneHit = true);
promise.Fail(() => failHit = true);
Assert.IsTrue(alwaysHit, "Always is hit");
Assert.IsTrue(doneHit, "Done is hit");
Assert.IsFalse(failHit, "Fail is not hit");
}
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);
};
};
}
public void NextCallBackTest()
{
CallCounter counter = new CallCounter();
Deferred<None> d = new Deferred<None>();
d.Done(p =>
counter.Done++
).Next<None>(df => {
Assert.AreEqual(1, counter.Done);
counter.Next++;
df.Reject();
}).Fail(p =>
counter.Fail++
).Next<None>(df =>
counter.Next++
);
d.Resolve();
Assert.AreEqual(1, counter.Done);
Assert.AreEqual(1, counter.Fail);
Assert.AreEqual(1, counter.Next);
}
public void GetErrorTest()
{
CallCounter counter = new CallCounter();
Deferred<System.String> d = new Deferred<System.String>();
d.Fail(p => {
Assert.AreEqual("UniDeffered", p.Error);
counter.Fail++;
});
d.Reject("UniDeffered");
Assert.AreEqual(1, counter.Fail);
}
public CallLaterItem(Deferred deferred, object result)
{
this.deferred = deferred;
this.result = result;
}
