efl

1
/* EINA - EFL data type library
2
 * Copyright (C) 2009 Rafael Antognolli
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library;
16
 * if not, see <http://www.gnu.org/licenses/>.
17
 */
18

19
#ifdef HAVE_CONFIG_H
20
# include "config.h"
21
#endif
22

23
#include <stdio.h>
24

25
#include <Eina.h>
26

27
#include "eina_suite.h"
28

29
struct test_rect
30
{
31
   unsigned long col, row;
32
   int x, y, w, h;
33
   Eina_Bool full;
34
};
35

36
static void
37
check_iterator(Eina_Iterator *it, struct test_rect *cur_test)
38
{
39
   unsigned int i = 0;
40
   struct Eina_Tile_Grid_Info *tile;
41

42
   EINA_ITERATOR_FOREACH(it, tile) {
43
      fail_if(cur_test[i].col != tile->col ||
44
              cur_test[i].row != tile->row ||
45
              cur_test[i].x != tile->rect.x ||
46
              cur_test[i].y != tile->rect.y ||
47
              cur_test[i].w != tile->rect.w ||
48
              cur_test[i].h != tile->rect.h ||
49
              cur_test[i].full != tile->full);
50
      i++;
51
   }
52

53
   fail_if(i == 0);
54
}
55

56
EFL_START_TEST(eina_test_tile_grid_slicer_iterator)
57
{
58
   Eina_Iterator *it;
59
   struct test_rect *cur_test;
60
   struct test_rect test1[] = {{1, 1, 72, 82, 10, 15, 0}};
61
   struct test_rect test2[] =
62
   {{1, 1,  72,  82,  56,  15,  0},
63
    {2, 1,   0,  82, 128,  15,  0},
64
    {3, 1,   0,  82, 116,  15,  0}};
65
   struct test_rect test3[] =
66
   {{1, 1,  72,  82,  10,  46,  0},
67
    {1, 2,  72,   0,  10, 128,  0},
68
    {1, 3,  72,   0,  10, 126,  0}};
69
   struct test_rect test4[] =
70
   {{1, 1,  72,  82,  56,  46,  0},
71
    {2, 1,   0,  82, 128,  46,  0},
72
    {3, 1,   0,  82, 128,  46,  0},
73
    {4, 1,   0,  82,  88,  46,  0},
74
    {1, 2,  72,   0,  56, 128,  0},
75
    {2, 2,   0,   0, 128, 128,  1},
76
    {3, 2,   0,   0, 128, 128,  1},
77
    {4, 2,   0,   0,  88, 128,  0},
78
    {1, 3,  72,   0,  56, 126,  0},
79
    {2, 3,   0,   0, 128, 126,  0},
80
    {3, 3,   0,   0, 128, 126,  0},
81
    {4, 3,   0,   0,  88, 126,  0}};
82
   struct test_rect test5[] = {{1, 1, 0, 0, 128, 128, 1}};
83
   struct test_rect test6[] = {{1, 1, 0, 0, 1, 1, 0}};
84
   struct test_rect test7[] =
85
   {{1, 1,   0,   0, 128, 128,  1},
86
    {2, 1,   0,   0,   1, 128,  0},
87
    {1, 2,   0,   0, 128,   1,  0},
88
    {2, 2,   0,   0,   1,   1,  0}};
89

90

91
   cur_test = test1;
92
   it = eina_tile_grid_slicer_iterator_new(200, 210, 10, 15, 128, 128);
93
   check_iterator(it, cur_test);
94
   eina_iterator_free(it);
95

96
   cur_test = test2;
97
   it = eina_tile_grid_slicer_iterator_new(200, 210, 300, 15, 128, 128);
98
   check_iterator(it, cur_test);
99
   eina_iterator_free(it);
100

101
   cur_test = test3;
102
   it = eina_tile_grid_slicer_iterator_new(200, 210, 10, 300, 128, 128);
103
   check_iterator(it, cur_test);
104
   eina_iterator_free(it);
105

106
   cur_test = test4;
107
   it = eina_tile_grid_slicer_iterator_new(200, 210, 400, 300, 128, 128);
108
   check_iterator(it, cur_test);
109
   eina_iterator_free(it);
110

111
   cur_test = test5;
112
   it = eina_tile_grid_slicer_iterator_new(128, 128, 128, 128, 128, 128);
113
   check_iterator(it, cur_test);
114
   eina_iterator_free(it);
115

116
   cur_test = test6;
117
   it = eina_tile_grid_slicer_iterator_new(128, 128, 1, 1, 128, 128);
118
   check_iterator(it, cur_test);
119
   eina_iterator_free(it);
120

121
   cur_test = test7;
122
   it = eina_tile_grid_slicer_iterator_new(128, 128, 129, 129, 128, 128);
123
   check_iterator(it, cur_test);
124
   eina_iterator_free(it);
125

126
}
127
EFL_END_TEST
128

129
EFL_START_TEST(eina_test_tiler_all)
130
{
131
   Eina_Tiler *tl;
132
   Eina_Iterator *it;
133
   Eina_Rectangle *rp;
134
   Eina_Rectangle r;
135
   int i = 0;
136
   int width, height;
137

138

139
   tl = eina_tiler_new(1, 1);
140

141
   eina_tiler_area_size_get(tl, &width, &height);
142
   fail_if(width != 1 && height != 1);
143

144
   width = 640;
145
   height = 480;
146
   eina_tiler_area_size_set(tl, width, height);
147
   eina_tiler_area_size_get(tl, &width, &height);
148
   fail_if(width != 640 && height != 480);
149

150
   eina_tiler_tile_size_set(tl, 32, 32);
151

152
   EINA_RECTANGLE_SET(&r, 50, 50, 20, 20);
153
   fail_if(!eina_tiler_rect_add(tl, &r));
154

155
   EINA_RECTANGLE_SET(&r, -10, -10, 5, 5);
156
   fail_if(eina_tiler_rect_add(tl, &r));
157

158
   EINA_RECTANGLE_SET(&r, 40, 40, 20, 20);
159
   eina_tiler_rect_del(tl, &r);
160

161
   it = eina_tiler_iterator_new(tl);
162
   fail_if(!it);
163

164
   EINA_ITERATOR_FOREACH(it, rp)
165
   {
166
      fail_if(rp->w <= 0);
167
      fail_if(rp->h <= 0);
168
      fail_if(rp->x < 0 || rp->x + rp->w > 640);
169
      fail_if(rp->y < 0 || rp->y + rp->h > 480);
170
      ++i;
171
   }
172

173
   fail_if(eina_iterator_container_get(it) != tl);
174

175
   eina_iterator_free(it);
176

177
   fail_if(i == 0);
178

179
   eina_tiler_clear(tl);
180

181
   eina_tiler_free(tl);
182

183
}
184
EFL_END_TEST
185

186
EFL_START_TEST(eina_test_tiler_stable)
187
{
188
   Eina_Tiler *tl;
189
   Eina_Rectangle *rp;
190
   Eina_Iterator *it;
191
   Eina_Rectangle r;
192
   int i = 0;
193

194

195
   tl = eina_tiler_new(640, 480);
196
   fail_if(!tl);
197

198
   eina_tiler_tile_size_set(tl, 1, 1);
199

200
   EINA_RECTANGLE_SET(&r, 50, 50, 20, 20);
201
   fail_if(!eina_tiler_rect_add(tl, &r));
202

203
   EINA_RECTANGLE_SET(&r, 40, 40, 20, 20);
204
   eina_tiler_rect_del(tl, &r);
205

206
   EINA_RECTANGLE_SET(&r, 50, 50, 20, 20);
207
   fail_if(!eina_tiler_rect_add(tl, &r));
208

209
   EINA_RECTANGLE_SET(&r, 40, 40, 20, 20);
210
   eina_tiler_rect_del(tl, &r);
211

212
   it = eina_tiler_iterator_new(tl);
213
   fail_if(!it);
214

215
   EINA_ITERATOR_FOREACH(it, rp)
216
     {
217
        EINA_RECTANGLE_SET(&r, 40, 40, 20, 20);
218
        fail_if(eina_rectangle_intersection(&r, rp));
219

220
        EINA_RECTANGLE_SET(&r, 50, 50, 20, 20);
221
        fail_if(!eina_rectangles_intersect(&r, rp));
222
        ++i;
223
     }
224

225
   fail_if(i != 2);
226

227
   eina_iterator_free(it);
228

229
   eina_tiler_free(tl);
230

231
}
232
EFL_END_TEST
233

234
EFL_START_TEST(eina_test_tiler_calculation)
235
{
236
   Eina_Tiler *t1, *t2, *t;
237
   Eina_Iterator *itr;
238
   Eina_Rectangle r1, r2, r3, *rp;
239
   int i = 0;
240

241

242
   t1 = eina_tiler_new(500, 500);
243
   fail_if(!t1);
244

245
   t2 = eina_tiler_new(500, 500);
246
   fail_if(!t2);
247

248
   eina_tiler_tile_size_set(t1, 1, 1);
249
   eina_tiler_tile_size_set(t2, 1, 1);
250

251
   EINA_RECTANGLE_SET(&r1, 0, 0, 500, 500);
252
   eina_tiler_rect_add(t1, &r1);
253

254
   EINA_RECTANGLE_SET(&r2, 100, 100, 300, 300);
255
   eina_tiler_rect_add(t2, &r2);
256

257
   fail_if(!eina_tiler_union(t1, t2));
258

259
   itr = eina_tiler_iterator_new(t1);
260
   EINA_ITERATOR_FOREACH(itr, rp)
261
     {
262
        fail_if(rp->w != 500);
263
        fail_if(rp->h != 500);
264
        fail_if(rp->x != 0);
265
        fail_if(rp->y != 0);
266
        ++i;
267
     }
268

269
   eina_iterator_free(itr);
270
   eina_tiler_clear(t1);
271

272
   fail_if(i != 1);
273

274
   eina_tiler_rect_add(t1, &r1);
275

276
   fail_if(!eina_tiler_subtract(t1, t2));
277

278
   i = 0;
279
   itr = eina_tiler_iterator_new(t1);
280
   EINA_ITERATOR_FOREACH(itr, rp)
281
     {
282
        fail_if(!eina_rectangles_intersect(&r1, rp));
283
        fail_if(eina_rectangles_intersect(&r2, rp));
284

285
        fail_if(rp->w <= 0);
286
        fail_if(rp->h <= 0);
287
        fail_if(rp->x < 0 || rp->x + rp->w > 500);
288
        fail_if(rp->y < 0 || rp->y + rp->h > 500);
289
        ++i;
290
     }
291

292
   eina_iterator_free(itr);
293
   eina_tiler_clear(t1);
294

295
   fail_if(i != 4);
296

297
   EINA_RECTANGLE_SET(&r3, 0, 0, 50, 50);
298
   eina_tiler_rect_add(t1, &r3);
299

300
   t = eina_tiler_intersection(t1, t2);
301
   fail_if(t);
302

303
   eina_tiler_clear(t1);
304

305
   eina_tiler_rect_add(t1, &r1);
306

307
   t = eina_tiler_intersection(t1, t2);
308
   fail_if(!t);
309

310
   i = 0;
311
   itr = eina_tiler_iterator_new(t);
312
   EINA_ITERATOR_FOREACH(itr, rp)
313
     {
314
        fail_if(!eina_rectangles_intersect(&r1, rp));
315
        fail_if(!eina_rectangles_intersect(&r2, rp));
316

317
        fail_if(rp->w <= 0);
318
        fail_if(rp->h <= 0);
319
        fail_if(rp->x < 0 || rp->x + rp->w > 500);
320
        fail_if(rp->y < 0 || rp->y + rp->h > 500);
321
        ++i;
322
     }
323

324
   eina_iterator_free(itr);
325
   eina_tiler_clear(t);
326

327
   fail_if(i != 1);
328

329
   eina_tiler_rect_add(t, &r1);
330

331
   fail_if(!eina_tiler_equal(t, t1));
332
   fail_if(!eina_tiler_equal(t1, t));
333
   EINA_RECTANGLE_SET(&r1, 0, 0, 250, 250);
334
   eina_tiler_rect_del(t, &r1);
335
   fail_if(eina_tiler_equal(t1, t));
336

337
   eina_tiler_free(t);
338
   eina_tiler_free(t1);
339
   eina_tiler_free(t2);
340

341
}
342
EFL_END_TEST
343

344
EFL_START_TEST(eina_test_tiler_size)
345
{
346
   Eina_Rectangle *r;
347
   Eina_Iterator *it;
348
   Eina_Tiler *t;
349
   Eina_Bool rects = EINA_FALSE;
350

351
   t = eina_tiler_new(131070, 131070);
352
   fail_if(!t);
353

354
   eina_tiler_tile_size_set(t, 1, 1);
355
   fail_if(!eina_tiler_rect_add(t, &(Eina_Rectangle){0, 0, 131070, 131070}));
356
   it = eina_tiler_iterator_new(t);
357
   fail_if(!it);
358
   EINA_ITERATOR_FOREACH(it, r)
359
     {
360
        rects = EINA_TRUE;
361
        fail_if(r->x);
362
        fail_if(r->y);
363
        fail_if(r->w != 131070);
364
        fail_if(r->h != 131070);
365
     }
366
   fail_if(!rects);
367
   eina_iterator_free(it);
368
   eina_tiler_free(t);
369
}
370
EFL_END_TEST
371

372
void
373
eina_test_tiler(TCase *tc)
374
{
375
   tcase_add_test(tc, eina_test_tile_grid_slicer_iterator);
376
   tcase_add_test(tc, eina_test_tiler_all);
377
   tcase_add_test(tc, eina_test_tiler_stable);
378
   tcase_add_test(tc, eina_test_tiler_calculation);
379
   tcase_add_test(tc, eina_test_tiler_size);
380
}
381