efl

1
//Compile with:
2
// gcc -o emodel_test_file emodel_test_file.c `pkg-config --cflags --libs emodel`
3
#ifdef HAVE_CONFIG_H
4
# include <config.h>
5
#endif
6

7
#include <Eo.h>
8
#include <Eio.h>
9
#include <Ecore.h>
10
#include <Efl.h>
11
#include <stdio.h>
12

13
#include "eio_suite.h"
14

15
Eina_Tmpstr* temp_filename = NULL;
16
const char* tmpdir = NULL;
17
Eina_Bool children_deleted = EINA_FALSE;
18

19
// This will ensure that the child have the time to be automatically destroyed
20
static Eina_Value
21
_delayed_quit(Eo *o EINA_UNUSED, void *data EINA_UNUSED, const Eina_Value v)
22
{
23
   ecore_main_loop_quit();
24

25
   return v;
26
}
27

28
static Eina_Value
29
_children_got(Eo *o, void *data EINA_UNUSED, const Eina_Value v)
30
{
31
   Eo *child = NULL;
32
   unsigned int i, len;
33
   Eina_Value r = (Eina_Value) v;
34

35
   EINA_VALUE_ARRAY_FOREACH(&v, len, i, child)
36
     {
37
        Eina_Value *path;
38
        char *str;
39

40
        path = efl_model_property_get(child, "path");
41
        fail_if(path == NULL);
42
        str = eina_value_to_string(path);
43
        fail_if(str == NULL);
44

45
        if (temp_filename && strcmp(str, temp_filename) == 0)
46
          r = eina_future_as_value(efl_future_then(efl_loop_get(o),
47
                                                   efl_loop_job(efl_loop_get(o)),
48
                                                   .success = _delayed_quit));
49

50

51
        free(str);
52
        eina_value_free(path);
53
     }
54

55
   return r;
56
}
57

58
static Eina_Value
59
_children_failed(Eo *o EINA_UNUSED, void *data EINA_UNUSED, const Eina_Error err)
60
{
61
   if (err != ECANCELED)
62
     ck_abort_msg( "Failed to get the child with '%s'.\n", eina_error_msg_get(err));
63
   return eina_value_error_init(err);
64
}
65

66
static void
67
_children_removed_cb(void *data EINA_UNUSED, const Efl_Event* event)
68
{
69
   Efl_Model_Children_Event* evt = event->info;
70
   Eina_Value *path;
71
   char *str;
72

73
   if (!evt->child)
74
     {
75
        Eina_Future *f;
76

77
        // Last time we can fetch the object
78
        f = efl_future_then(event->object,
79
                            efl_model_children_slice_get(event->object, evt->index, 1),
80
                            .success = _children_got,
81
                            .error = _children_failed,
82
                            .success_type = EINA_VALUE_TYPE_ARRAY);
83
        fail_if(f == NULL);
84
        return;
85
     }
86

87
   fail_if(evt->child == NULL);
88
   path = efl_model_property_get(evt->child, "path");
89
   fail_if(path == NULL);
90
   str = eina_value_to_string(path);
91
   fail_if(str == NULL);
92

93
   if (temp_filename && strcmp(str, temp_filename) == 0)
94
     efl_future_then(efl_loop_get(evt->child),
95
                     efl_loop_job(efl_loop_get(evt->child)),
96
                     .success = _delayed_quit);
97

98
   free(str);
99
   eina_value_free(path);
100
}
101

102
static Eina_Bool started_up = EINA_FALSE;
103

104
static Eina_Value
105
_children_get(void *data,
106
              const Eina_Value v,
107
              const Eina_Future *dead_future EINA_UNUSED)
108
{
109
   Efl_Model *filemodel = data;
110
   Eo *child = NULL;
111
   unsigned int i, len;
112

113
   if (eina_value_type_get(&v) == EINA_VALUE_TYPE_ERROR)
114
     {
115
        Eina_Error err = 0;
116

117
        fail_if(!eina_value_error_get(&v, &err));
118
        fail_if(err != ECANCELED);
119
        return v;
120
     }
121

122
   fail_if(eina_value_type_get(&v) != EINA_VALUE_TYPE_ARRAY);
123

124
   EINA_VALUE_ARRAY_FOREACH(&v, len, i, child)
125
     {
126
        Eina_Value *path;
127
        char *str;
128

129
        path = efl_model_property_get(child, "path");
130
        fail_if(path == NULL);
131
        str = eina_value_to_string(path);
132
        fail_if(str == NULL);
133

134
        if (started_up && strcmp(temp_filename, str) == 0)
135
          {
136
             children_deleted = EINA_TRUE;
137
             efl_model_child_del(filemodel, child);
138
          }
139
        free(str);
140
        eina_value_free(path);
141
     }
142

143
   if (!started_up)
144
     {
145
        int fd;
146

147
        fd = eina_file_mkstemp("prefixXXXXXX.ext", &temp_filename);
148
        ck_assert_int_gt(fd, 0);
149
        close(fd);
150
     }
151
   started_up = EINA_TRUE;
152

153
   return v;
154
}
155

156
static void
157
_children_added_cb(void *d EINA_UNUSED, const Efl_Event* event)
158
{
159
   Efl_Model_Children_Event* evt = event->info;
160
   Eina_Future *future;
161

162
   future = efl_model_children_slice_get(event->object, evt->index, 1);
163
   eina_future_then(future, _children_get, event->object, NULL);
164
}
165

166
EFL_START_TEST(efl_io_model_test_test_monitor_add)
167
{
168
   Eo *filemodel = NULL;
169

170
   tmpdir = eina_environment_tmp_get();
171

172
   filemodel = efl_add(EFL_IO_MODEL_CLASS,
173
                       efl_main_loop_get(),
174
                       efl_io_model_path_set(efl_added, tmpdir));
175
   fail_if(!filemodel, "ERROR: Cannot init model!\n");
176

177
   efl_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_ADDED, &_children_added_cb, filemodel);
178
   efl_event_callback_add(filemodel, EFL_MODEL_EVENT_CHILD_REMOVED, &_children_removed_cb, NULL);
179

180
   ecore_main_loop_begin();
181

182
   efl_del(filemodel);
183

184
   fail_if(!children_deleted);
185
}
186
EFL_END_TEST
187

188
void
189
efl_io_model_test_monitor_add(TCase *tc)
190
{
191
   tcase_add_test(tc, efl_io_model_test_test_monitor_add);
192
}
193