public static void test_constructor_with_callback()
{
bool callbackCalled = false;
eina.Value received_value = null;
efl.ILoop loop = efl.App.GetLoopMain();
eina.Promise promise = new eina.Promise();
#pragma warning disable 0219
eina.Future future = new eina.Future(promise, (eina.Value value) => {
callbackCalled = true;
received_value = value;
return(value);
});
#pragma warning restore 0219
eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
reference_value.Set(1984);
promise.Resolve(reference_value);
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
Test.AssertEquals(received_value, reference_value);
}
public static void test_simple_reject()
{
bool callbackCalled = false;
eina.Error received_error = eina.Error.NO_ERROR;
efl.ILoop loop = efl.App.GetLoopMain();
eina.Promise promise = new eina.Promise();
eina.Future future = new eina.Future(promise);
future = future.Then((eina.Value value) => {
callbackCalled = true;
value.Get(out received_error);
return(value);
});
promise.Reject(eina.Error.EPERM);
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
Test.AssertEquals(received_error, eina.Error.EPERM);
Test.AssertRaises <ObjectDisposedException>(() => { promise.Resolve(null); });
Test.AssertRaises <ObjectDisposedException>(future.Cancel);
}
public static void test_simple_task_run()
{
efl.ILoop loop = efl.App.GetLoopMain();
eina.Future future = loop.Idle();
bool callbackCalled = false;
int ret_code = 1992;
future.Then((eina.Value value) => {
callbackCalled = true;
eina.Value v = new eina.Value(eina.ValueType.Int32);
v.Set(ret_code);
loop.Quit(v);
return(value);
});
eina.Value ret_value = loop.Begin();
Test.Assert(callbackCalled, "Future loop callback must have been called.");
Test.AssertEquals(ret_value.GetValueType(), eina.ValueType.Int32);
int ret_from_value;
Test.Assert(ret_value.Get(out ret_from_value));
Test.AssertEquals(ret_from_value, ret_code);
}
public static void test_simple_resolve()
{
bool callbackCalled = false;
eina.Value received_value = null;
efl.ILoop loop = efl.App.GetLoopMain();
eina.Promise promise = new eina.Promise();
eina.Future future = new eina.Future(promise);
future = future.Then((eina.Value value) => {
callbackCalled = true;
received_value = value;
return(value);
});
eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
reference_value.Set(1984);
promise.Resolve(reference_value);
loop.Iterate();
Test.Assert(callbackCalled, "Future callback should have been called.");
Test.AssertEquals(received_value, reference_value);
}
public static async Task Consume(efl.ILoop loop)
{
Task <eina.Value> task = loop.IdleAsync();
eina.Value v = await task;
loop.Quit(v);
}
public static void test_object_promise()
{
efl.ILoop loop = efl.App.GetLoopMain();
test.Testing obj = new test.Testing();
eina.Future future = obj.GetFuture();
bool callbackCalled = false;
int receivedValue = -1;
int sentValue = 1984;
future.Then((eina.Value value) => {
callbackCalled = true;
Test.AssertEquals(value.GetValueType(), eina.ValueType.Int32);
value.Get(out receivedValue);
return(value);
});
obj.FulfillPromise(sentValue);
loop.Iterate();
Test.Assert(callbackCalled, "Future callback must have been called.");
Test.AssertEquals(receivedValue, sentValue);
}
public static void test_object_promise_cancel()
{
efl.ILoop loop = efl.App.GetLoopMain();
test.Testing obj = new test.Testing();
eina.Future future = obj.GetFuture();
bool callbackCalled = false;
eina.Error receivedError = -1;
eina.Error sentError = 120;
future.Then((eina.Value value) => {
callbackCalled = true;
Test.AssertEquals(value.GetValueType(), eina.ValueType.Error);
value.Get(out receivedError);
return(value);
});
obj.RejectPromise(sentError);
loop.Iterate();
Test.Assert(callbackCalled, "Future callback must have been called.");
Test.AssertEquals(receivedError, sentError);
}
public static void test_async_reject()
{
efl.ILoop loop = efl.App.GetLoopMain();
test.ITesting obj = new test.Testing();
Task <eina.Value> task = obj.GetFutureAsync();
eina.Error sentError = 1337;
obj.RejectPromise(sentError);
loop.Iterate();
bool raised = false;
try
{
eina.Value v = task.Result;
}
catch (AggregateException ae)
{
raised = true;
ae.Handle((x) =>
{
Test.Assert(x is efl.FutureException, "AggregateException must have been TaskCanceledException");
efl.FutureException ex = x as efl.FutureException;
Test.AssertEquals(ex.Error, sentError);
return(true);
});
}
Test.Assert(raised, "AggregateException must have been raised.");
}
public static void test_async_cancel()
{
efl.ILoop loop = efl.App.GetLoopMain();
test.ITesting obj = new test.Testing();
CancellationTokenSource cancelSrc = new CancellationTokenSource();
Task <eina.Value> task = obj.GetFutureAsync(cancelSrc.Token);
cancelSrc.Cancel();
loop.Iterate();
bool raised = false;
try
{
eina.Value v = task.Result;
}
catch (AggregateException ae)
{
raised = true;
ae.Handle((x) =>
{
Test.Assert(x is TaskCanceledException, "AggregateException must have been TaskCanceledException");
return(true);
});
}
Test.Assert(raised, "AggregateException must have been raised.");
}
public static void test_simple_async()
{
efl.ILoop loop = efl.App.GetLoopMain();
Task t = LoopConsumer.Consume(loop);
loop.Begin();
Test.Assert(t.Wait(1000), "Task should have been completed in time.");
}
public static void test_then_chain_array()
{
bool[] callbacksCalled = { false, false, false, false };
eina.Value[] received_value = { null, null, null, null };
FutureCbGenerator genResolvedCb = (int i) => {
return((eina.Value value) => {
callbacksCalled[i] = true;
int x;
value.Get(out x);
value.Set(x + i);
received_value[i] = value;
return value;
});
};
var cbs = new List <eina.Future.ResolvedCb>();
for (int i = 0; i < 4; i++)
{
cbs.Add(genResolvedCb(i));
}
efl.ILoop loop = efl.App.GetLoopMain();
eina.Promise promise = new eina.Promise();
eina.Future future = new eina.Future(promise);
future = future.Chain(cbs);
eina.Value reference_value = new eina.Value(eina.ValueType.Int32);
reference_value.Set(0);
promise.Resolve(reference_value);
loop.Iterate();
int current_value = 0;
for (int i = 0; i < 4; i++)
{
current_value += i;
Test.Assert(callbacksCalled[i], $"Future chained callback {i} should have been called.");
int received;
received_value[i].Get(out received);
Test.AssertEquals(received, current_value);
}
Test.AssertRaises <ObjectDisposedException>(() => { promise.Resolve(null); });
Test.AssertRaises <ObjectDisposedException>(future.Cancel);
}
public static void test_async_fulfill()
{
efl.ILoop loop = efl.App.GetLoopMain();
test.ITesting obj = new test.Testing();
Task <eina.Value> task = obj.GetFutureAsync();
int sentValue = 1337;
obj.FulfillPromise(sentValue);
loop.Iterate();
eina.Value v = task.Result;
Test.AssertEquals(v.GetValueType(), eina.ValueType.Int32);
int receivedValue;
v.Get(out receivedValue);
Test.AssertEquals(receivedValue, sentValue);
}
/// <summary>
/// Creates a new Promise with the given callback.
///
/// Currently, creating a promise directly uses the Main Loop scheduler the source of notifications (i.e. the
/// future callbacks will be called mainly from a loop iteration).
/// </summary>
public Promise(CancelCb cancelCb = null)
{
efl.ILoop loop = efl.App.GetLoopMain();
// Should we be able to pass different schedulers?
IntPtr scheduler = efl_loop_future_scheduler_get(loop.raw_handle);
IntPtr cb_data = IntPtr.Zero;
// A safety clean callback to mark this wrapper as invalid
CancelCb safetyCb = () => {
Handle = IntPtr.Zero;
if (cancelCb != null)
{
cancelCb();
}
};
CleanupHandle = GCHandle.Alloc(safetyCb);
cb_data = GCHandle.ToIntPtr(CleanupHandle);
this.Handle = eina_promise_new(scheduler, NativeCancelCb, cb_data);
}
