public void OnPressDown(InputInfo input)
{
_pressInput = input;
if (_pendentInput != null)
{
_pendentInput.Cancel();
}
_pendentInput = _.Wait(_pressTimeMargin).Done(ResolvePress);
}
public void Should_Convert_Cancelled_Promise_To_Task()
{
var promise = new Promise <int>((resolve, reject) => {});
var task = promise.ToTask();
promise.Cancel();
Assert.AreEqual(TaskStatus.Canceled, task.Status);
}
public static Task <TResult> Then <T, TResult>(this Task <T> task, Func <T, TResult> onFulfilled)
{
task.NotNull(nameof(task));
onFulfilled.NotNull(nameof(onFulfilled));
if (task.IsCompleted)
{
if (task.Exception?.InnerException != null)
{
return(Promise.Reject <TResult>(task.Exception.InnerExceptions));
}
if (task.IsCanceled)
{
return(Promise.Cancel <TResult>());
}
try
{
return(Promise.Resolve(onFulfilled(task.Result)));
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types
{
return(Promise.Reject <TResult>(e));
}
}
var tcs = new TaskCompletionSource <TResult>();
task.ContinueWith(t =>
{
if (t.Exception?.InnerException != null)
{
tcs.SetException(t.Exception.InnerExceptions);
return;
}
if (t.IsCanceled)
{
tcs.SetCanceled();
return;
}
try
{
tcs.SetResult(onFulfilled(t.Result));
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types
{
tcs.SetException(e);
}
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return(tcs.Task);
}
void Activate(bool enabled)
{
tintCamera.Tint(FinishTint);
tintCleaner.renderer.enabled = false;
if (_pendentClean != null)
{
_pendentClean.Cancel();
}
_pendentClean = _.Wait(timeToStartClean).Done(EnableCleaner);
tintCleaner.renderer.material.color = Color.blue;
}
public void TestPromiseCancel()
{
var promise = new Promise(() =>
{
while (true)
{
// Infinite loop to cancel
}
});
promise.Cancel();
promise.Wait();
Assert.AreEqual(true, promise.Cancelled);
}
public void TestExecutorPromiseCancel()
{
var promise = new Promise(resolve =>
{
while (true)
{
// Infinite loop to cancel
}
// This is required or visual studio says ambigous
resolve();
});
promise.Cancel();
promise.Wait();
Assert.AreEqual(true, promise.Cancelled);
}
public void Should_Use_Promise_Owner_Cancellation()
{
var called = false;
var promise = new Promise <object>((resolve, reject, onCancel) =>
onCancel(() => called = true));
promise.Cancel();
if (promise.AsyncWaitHandle.WaitOne(5.Sec()))
{
Assert.AreEqual(PromiseState.Cancelled, promise.State);
Assert.IsTrue(called);
}
else
{
Assert.Fail("Operation timed out");
}
}
public void Should_Notify_Unwrapped_Promise_Owner_When_Cancelled()
{
var called = false;
var promise = new Promise <object>(
ChildCancelMode.Any, (resolve, reject, onCancel) => onCancel(() => called = true))
.Then((r, s) => new Promise <object>(ChildCancelMode.Any, (res, rej) => { }));
promise.Cancel();
if (promise.AsyncWaitHandle.WaitOne(5.Sec()))
{
Assert.AreEqual(PromiseState.Cancelled, promise.State);
Assert.IsTrue(called);
}
else
{
Assert.Fail("Operation timed out");
}
}
public void Should_Notify_Promise_Owner_When_Catch_Cancelled()
{
var called = false;
var promise = new Promise <object>((resolve, reject, onCancel) =>
onCancel(() => called = true))
.Then((r, s) => { })
.Catch((TimeoutException tex, bool s) => { })
.Catch((ex, s) => { });;
promise.Cancel();
if (promise.AsyncWaitHandle.WaitOne(5.Sec()))
{
Assert.AreEqual(PromiseState.Cancelled, promise.State);
Assert.IsTrue(called);
}
else
{
Assert.Fail("Operation timed out");
}
}
public void Should_Notify_Promise_Owner_When_Cancelled()
{
var called = false;
var promise = new Promise <object>(
delegate(Promise <object> .ResolveCallbackT resolve, RejectCallback reject, Action <Action> onCancel)
{
onCancel(() => called = true);
});
promise.Cancel();
if (promise.AsyncWaitHandle.WaitOne(5.Sec()))
{
Assert.AreEqual(PromiseState.Cancelled, promise.State);
Assert.IsTrue(called);
}
else
{
Assert.Fail("Operation timed out");
}
}
void CheckCleaned()
{
_pendentCleanCheck = _.Wait(2.0f).Done(CheckCleaned);
if (cleanedCheckTexture != null)
{
RenderTexture buffer = RenderTexture.GetTemporary(cleanedCheckTexture.width, cleanedCheckTexture.height, 0);
Graphics.Blit(downSampledTexture, buffer);
cleanedCheckTexture.ReadPixels(new Rect(0, 0, cleanedCheckTexture.width, cleanedCheckTexture.height), 0, 0);
cleanedCheckTexture.Apply();
RenderTexture.ReleaseTemporary(buffer);
Color[] colors = cleanedCheckTexture.GetPixels();
int nColors = 0;
for (int i = 0; i < colors.Length; ++i)
{
Color c = colors[i];
if (c.r > 0.5f)
{
nColors++;
}
}
_cleanPercent = ((float)nColors) / colors.Length;
}
if (Finished)
{
_pendentCleanCheck.Cancel();
if (onTintCleaned != null)
{
onTintCleaned();
}
ClearTint();
}
}
private SqlMetadata(SqlConnection conn)
{
_conn = conn;
_objectPromise = new Promise <IEnumerable <SqlObject> >();
new SqlCommand(@"SELECT SCHEMA_NAME(SCHEMA_ID) sch
, name
, case when type in ('D') then 'Constraint'
when type in ('F', 'PK', 'UQ') then 'Key'
when type in ('S', 'IT', 'U') then 'Table'
when type in ('IF', 'FN', 'TF') then 'Function'
when type in ('P') then 'Procedure'
when type in ('V') then 'View'
else type end type
, case when type in ('IF', 'TF') then 1
when type = 'PK' then 2 else 0 end sub_type
, object_id
, parent_object_id
FROM sys.objects AS SO
UNION ALL
SELECT
SCHEMA_NAME(o.schema_id) + '.[' + o.name + ']' sch
, ind.name
, 'Index'
, 0 table_valued
, ind.index_id object_id
, ind.object_id parent_object_id
FROM sys.indexes ind
inner join sys.[objects] o
on o.object_id = ind.object_id
WHERE
ind.is_primary_key = 0
AND ind.is_unique = 0
AND ind.is_unique_constraint = 0
AND o.is_ms_shipped = 0", conn)
.GetListAsync <SqlObject>(async(r) => SqlObject.Create(
await r.GetFieldStringAsync(0),
await r.GetFieldStringAsync(1),
await r.GetFieldStringAsync(2),
await r.GetFieldIntAsync(4),
await r.GetFieldIntAsync(5),
(SqlSubType)await r.GetFieldIntAsync(3)
)).ContinueWith(l =>
{
if (l.IsFaulted)
{
_objectPromise.Reject(l.Exception);
}
else if (l.IsCanceled)
{
_objectPromise.Cancel();
}
else
{
var items = l.Result.Concat(_systemViews);
_objects = items.ToDictionary(o => o.Schema + "." + o.Name, StringComparer.OrdinalIgnoreCase);
_schemas = items.Where(o => !string.IsNullOrEmpty(o.Schema)).Select(o => o.Schema).Distinct().ToArray();
_objectPromise.Resolve(_objects.Values);
}
});
}
private SqlMetadata(SqlConnection conn)
{
_conn = conn;
_objectPromise = new Promise<IEnumerable<SqlObject>>();
new SqlCommand(@"SELECT SCHEMA_NAME(SCHEMA_ID) sch
, name
, case when type in ('D') then 'Constraint'
when type in ('F', 'PK', 'UQ') then 'Key'
when type in ('S', 'IT', 'U') then 'Table'
when type in ('IF', 'FN', 'TF') then 'Function'
when type in ('P') then 'Procedure'
when type in ('V') then 'View'
else type end type
, case when type in ('IF', 'TF') then 1
when type = 'PK' then 2 else 0 end sub_type
, object_id
, parent_object_id
FROM sys.objects AS SO
UNION ALL
SELECT
SCHEMA_NAME(o.schema_id) + '.[' + o.name + ']' sch
, ind.name
, 'Index'
, 0 table_valued
, ind.index_id object_id
, ind.object_id parent_object_id
FROM sys.indexes ind
inner join sys.[objects] o
on o.object_id = ind.object_id
WHERE
ind.is_primary_key = 0
AND ind.is_unique = 0
AND ind.is_unique_constraint = 0
AND o.is_ms_shipped = 0", conn)
.GetListAsync<SqlObject>(async (r) => SqlObject.Create(
await r.GetFieldStringAsync(0),
await r.GetFieldStringAsync(1),
await r.GetFieldStringAsync(2),
await r.GetFieldIntAsync(4),
await r.GetFieldIntAsync(5),
(SqlSubType)await r.GetFieldIntAsync(3)
)).ContinueWith(l =>
{
if (l.IsFaulted)
{
_objectPromise.Reject(l.Exception);
}
else if (l.IsCanceled)
{
_objectPromise.Cancel();
}
else
{
var items = l.Result.Concat(_systemViews);
_objects = items.ToDictionary(o => o.Schema + "." + o.Name, StringComparer.OrdinalIgnoreCase);
_schemas = items.Where(o => !string.IsNullOrEmpty(o.Schema)).Select(o => o.Schema).Distinct().ToArray();
_objectPromise.Resolve(_objects.Values);
}
});
}
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 static Task <T> Finally <T>(this Task <T> task, Func <Task> onFinally)
{
task.NotNull(nameof(task));
onFinally.NotNull(nameof(onFinally));
TaskCompletionSource <T> tcs;
if (task.IsCompleted)
{
Task finallyTask;
try
{
finallyTask = onFinally();
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types
{
return(Promise.Reject <T>(e));
}
if (finallyTask.IsCompleted)
{
if (finallyTask.Exception?.InnerException != null)
{
return(Promise.Reject <T>(finallyTask.Exception.InnerExceptions));
}
return(finallyTask.IsCanceled ? Promise.Cancel <T>() : task);
}
tcs = new TaskCompletionSource <T>();
finallyTask.ContinueWith(ft =>
{
if (ft.Exception?.InnerException != null)
{
tcs.SetException(ft.Exception.InnerExceptions);
return;
}
if (ft.IsCanceled)
{
tcs.SetCanceled();
return;
}
tcs.SetFromCompleted(task);
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return(tcs.Task);
}
tcs = new TaskCompletionSource <T>();
task.ContinueWith(t =>
{
Task finallyTask;
try
{
finallyTask = onFinally();
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception e)
#pragma warning restore CA1031 // Do not catch general exception types
{
tcs.SetException(e);
return;
}
if (finallyTask.IsCompleted)
{
if (finallyTask.Exception?.InnerException != null)
{
tcs.SetException(finallyTask.Exception.InnerExceptions);
return;
}
if (finallyTask.IsCanceled)
{
tcs.SetCanceled();
return;
}
tcs.SetFromCompleted(t);
return;
}
finallyTask.ContinueWith(ft =>
{
if (ft.Exception?.InnerException != null)
{
tcs.SetException(ft.Exception.InnerExceptions);
return;
}
if (ft.IsCanceled)
{
tcs.SetCanceled();
return;
}
tcs.SetFromCompleted(t);
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return(tcs.Task);
}
