efl

1
/*
2
 * Copyright 2019 by its authors. See AUTHORS.
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *     http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16
using System;
17
using System.Threading.Tasks;
18
using System.Threading;
19

20
namespace TestSuite
21
{
22

23
class TestEoPromises
24
{
25
    public static void test_simple_task_run()
26
    {
27
        Efl.Loop loop = Efl.App.AppMain;
28
        Eina.Future future = loop.Idle();
29

30
        bool callbackCalled = false;
31
        int ret_code = 1992;
32

33
        future.Then((Eina.Value value) => {
34
            callbackCalled = true;
35
            Eina.Value v = new Eina.Value(Eina.ValueType.Int32);
36
            v.Set(ret_code);
37
            loop.Quit(v);
38
            return value;
39
        });
40
        Eina.Value ret_value = loop.Begin();
41

42
        Test.Assert(callbackCalled, "Future loop callback must have been called.");
43

44
        Test.AssertEquals(ret_value.GetValueType(), Eina.ValueType.Int32);
45

46
        int ret_from_value;
47
        Test.Assert(ret_value.Get(out ret_from_value));
48
        Test.AssertEquals(ret_from_value, ret_code);
49

50
    }
51

52
    public static void test_object_promise()
53
    {
54
        Efl.Loop loop = Efl.App.AppMain;
55
        var obj = new Dummy.TestObject();
56

57
        Eina.Future future = obj.GetFuture();
58

59
        bool callbackCalled = false;
60
        int receivedValue = -1;
61
        int sentValue = 1984;
62
        future.Then((Eina.Value value) => {
63
            callbackCalled = true;
64
            Test.AssertEquals(value.GetValueType(), Eina.ValueType.Int32);
65
            value.Get(out receivedValue);
66

67
            return value;
68
        });
69

70
        obj.FulfillPromise(sentValue);
71

72
        loop.Iterate();
73
        Test.Assert(callbackCalled, "Future callback must have been called.");
74
        Test.AssertEquals(receivedValue, sentValue);
75
        obj.Dispose();
76
    }
77

78
    public static void test_object_promise_cancel()
79
    {
80
        Efl.Loop loop = Efl.App.AppMain;
81
        var obj = new Dummy.TestObject();
82

83
        Eina.Future future = obj.GetFuture();
84

85
        bool callbackCalled = false;
86
        Eina.Error receivedError = -1;
87
        Eina.Error sentError = 120;
88
        future.Then((Eina.Value value) => {
89
            callbackCalled = true;
90
            Test.AssertEquals(value.GetValueType(), Eina.ValueType.Error);
91
            value.Get(out receivedError);
92

93
            return value;
94
        });
95

96
        obj.RejectPromise(sentError);
97

98
        loop.Iterate();
99
        Test.Assert(callbackCalled, "Future callback must have been called.");
100
        Test.AssertEquals(receivedError, sentError);
101
        obj.Dispose();
102
    }
103

104
}
105

106
class LoopConsumer
107
{
108
    public static async Task Consume(Efl.Loop loop)
109
    {
110
        Task<Eina.Value> task = loop.IdleAsync();
111
        Eina.Value v = await task.ConfigureAwait(false);
112
        loop.Quit(v);
113
    }
114
}
115

116
class TestLoopEoAsyncMethods
117
{
118
    public static void test_simple_async()
119
    {
120
        Efl.Loop loop = Efl.App.AppMain;
121
        Task t = LoopConsumer.Consume(loop);
122

123
        loop.Begin();
124
        Test.Assert(t.Wait(1000), "Task should have been completed in time.");
125
    }
126
}
127

128
class TestEoAsyncMethods
129
{
130

131
    public static void test_async_fulfill()
132
    {
133
        Efl.Loop loop = Efl.App.AppMain;
134
        var obj = new Dummy.TestObject();
135

136
        Task<Eina.Value> task = obj.GetFutureAsync();
137

138
        int sentValue = 1337;
139

140
        obj.FulfillPromise(sentValue);
141
        loop.Iterate();
142

143
        Eina.Value v = task.Result;
144
        Test.AssertEquals(v.GetValueType(), Eina.ValueType.Int32);
145

146
        int receivedValue;
147
        v.Get(out receivedValue);
148
        Test.AssertEquals(receivedValue, sentValue);
149
        obj.Dispose();
150
    }
151

152
    public static void test_async_cancel()
153
    {
154
        Efl.Loop loop = Efl.App.AppMain;
155
        var obj = new Dummy.TestObject();
156

157
        CancellationTokenSource cancelSrc = new CancellationTokenSource();
158
        Task<Eina.Value> task = obj.GetFutureAsync(cancelSrc.Token);
159

160
        cancelSrc.Cancel();
161
        loop.Iterate();
162

163
        bool raised = false;
164
        try
165
        {
166
            Eina.Value v = task.Result;
167
        }
168
        catch (AggregateException ae)
169
        {
170
            raised = true;
171
            ae.Handle((x) =>
172
            {
173
                Test.Assert(x is TaskCanceledException, "AggregateException must have been TaskCanceledException");
174
                return true;
175
            });
176
        }
177

178
        Test.Assert(raised, "AggregateException must have been raised.");
179
        cancelSrc.Dispose();
180
        obj.Dispose();
181
    }
182

183
    public static void test_async_reject()
184
    {
185
        Efl.Loop loop = Efl.App.AppMain;
186
        var obj = new Dummy.TestObject();
187

188
        Task<Eina.Value> task = obj.GetFutureAsync();
189

190
        Eina.Error sentError = 1337;
191
        obj.RejectPromise(sentError);
192

193
        loop.Iterate();
194

195
        bool raised = false;
196
        try
197
        {
198
            Eina.Value v = task.Result;
199
        }
200
        catch (AggregateException ae)
201
        {
202
            raised = true;
203
            ae.Handle((x) =>
204
            {
205
                Test.Assert(x is Efl.FutureException, "AggregateException must have been TaskCanceledException");
206
                Efl.FutureException ex = x as Efl.FutureException;
207
                Test.AssertEquals(ex.Error, sentError);
208
                return true;
209
            });
210
        }
211

212
        Test.Assert(raised, "AggregateException must have been raised.");
213
        obj.Dispose();
214
    }
215
}
216
}
217