Mercurial > molko

comparison tests/test-action-script.c @ 136:30b68089ae70

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
core: rework actions and a bit of drawables, closes #2492 In the effort of having as less as possible memory allocation in libcore, the usage of actions and drawable no longer copy the original source parameter to let user pass a heap allocated variable or a static storage one. Update predefined drawable and actions to match these new needs.
author David Demelier <markand@malikania.fr>
date Tue, 13 Oct 2020 09:38:44 +0200
parents tests/test-script.c@789b23e01f52
children 196264679079
comparison
equal deleted inserted replaced
135:eadfed7674ac 136:30b68089ae70
1 /*
2 * test-script.c -- test script action
3 *
4 * Copyright (c) 2020 David Demelier <markand@malikania.fr>
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19 #define GREATEST_USE_ABBREVS 0
20 #include <greatest.h>
21
22 #include <core/action.h>
23 #include <core/event.h>
24 #include <core/script.h>
25
26 struct invokes {
27 int handle;
28 int update;
29 int draw;
30 int end;
31 int finish;
32 };
33
34 #define INIT(dat, up) { \
35 .data = (dat), \
36 .handle = my_handle, \
37 .update = (up), \
38 .draw = my_draw, \
39 .end = my_end, \
40 .finish = my_finish \
41 }
42
43 static void
44 my_handle(struct action *act, const union event *ev)
45 {
46 (void)ev;
47
48 ((struct invokes *)act->data)->handle++;
49 }
50
51 static bool
52 my_update_false(struct action *act, unsigned int ticks)
53 {
54 (void)ticks;
55
56 ((struct invokes *)act->data)->update++;
57
58 return false;
59 }
60
61 static bool
62 my_update_true(struct action *act, unsigned int ticks)
63 {
64 (void)ticks;
65
66 ((struct invokes *)act->data)->update++;
67
68 return true;
69 }
70
71 static void
72 my_draw(struct action *act)
73 {
74 ((struct invokes *)act->data)->draw++;
75 }
76
77 static void
78 my_end(struct action *act)
79 {
80 ((struct invokes *)act->data)->end++;
81 }
82
83 static void
84 my_finish(struct action *act)
85 {
86 ((struct invokes *)act->data)->finish++;
87 }
88
89 GREATEST_TEST
90 basics_init(void)
91 {
92 struct script sc;
93
94 script_init(&sc);
95
96 GREATEST_ASSERT_EQ(sc.actionsz, 0U);
97 GREATEST_ASSERT_EQ(sc.cur, 0U);
98
99 GREATEST_PASS();
100 }
101
102 GREATEST_TEST
103 basics_append(void)
104 {
105 struct action act[3] = {0};
106 struct script sc = {0};
107
108 GREATEST_ASSERT(script_append(&sc, &act[0]));
109 GREATEST_ASSERT_EQ(sc.cur, 0U);
110 GREATEST_ASSERT_EQ(sc.actionsz, 1U);
111 GREATEST_ASSERT_EQ(sc.actions[0], &act[0]);
112
113 GREATEST_ASSERT(script_append(&sc, &act[1]));
114 GREATEST_ASSERT_EQ(sc.cur, 0U);
115 GREATEST_ASSERT_EQ(sc.actionsz, 2U);
116 GREATEST_ASSERT_EQ(sc.actions[0], &act[0]);
117 GREATEST_ASSERT_EQ(sc.actions[1], &act[1]);
118
119 GREATEST_ASSERT(script_append(&sc, &act[2]));
120 GREATEST_ASSERT_EQ(sc.cur, 0U);
121 GREATEST_ASSERT_EQ(sc.actionsz, 3U);
122 GREATEST_ASSERT_EQ(sc.actions[0], &act[0]);
123 GREATEST_ASSERT_EQ(sc.actions[1], &act[1]);
124 GREATEST_ASSERT_EQ(sc.actions[2], &act[2]);
125
126 script_finish(&sc);
127
128 GREATEST_PASS();
129 }
130
131 GREATEST_TEST
132 basics_handle(void)
133 {
134 struct {
135 struct invokes inv;
136 struct action act;
137 } table[] = {
138 { .act = INIT(&table[0].inv, my_update_true) },
139 { .act = INIT(&table[1].inv, my_update_true) },
140 { .act = INIT(&table[2].inv, my_update_false) }
141 };
142
143 struct script sc = {0};
144
145 GREATEST_ASSERT(script_append(&sc, &table[0].act));
146 GREATEST_ASSERT(script_append(&sc, &table[1].act));
147 GREATEST_ASSERT(script_append(&sc, &table[2].act));
148
149 /* [0] */
150 script_handle(&sc, &(union event){0});
151 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
152 GREATEST_ASSERT_EQ(table[0].inv.update, 0);
153 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
154 GREATEST_ASSERT_EQ(table[0].inv.end, 0);
155 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
156 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
157 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
158 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
159 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
160 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
161 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
162 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
163 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
164 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
165 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
166
167 /* [0] -> [1] */
168 GREATEST_ASSERT(!script_update(&sc, 0));
169 script_handle(&sc, &(union event){0});
170
171 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
172 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
173 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
174 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
175 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
176 GREATEST_ASSERT_EQ(table[1].inv.handle, 1);
177 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
178 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
179 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
180 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
181 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
182 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
183 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
184 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
185 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
186
187 /* [2] */
188 GREATEST_ASSERT(!script_update(&sc, 0));
189 script_handle(&sc, &(union event){0});
190
191 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
192 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
193 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
194 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
195 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
196 GREATEST_ASSERT_EQ(table[1].inv.handle, 1);
197 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
198 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
199 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
200 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
201 GREATEST_ASSERT_EQ(table[2].inv.handle, 1);
202 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
203 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
204 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
205 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
206
207 GREATEST_PASS();
208 }
209
210 GREATEST_TEST
211 basics_update(void)
212 {
213 struct {
214 struct invokes inv;
215 struct action act;
216 } table[] = {
217 { .act = INIT(&table[0].inv, my_update_true) },
218 { .act = INIT(&table[1].inv, my_update_true) },
219 { .act = INIT(&table[2].inv, my_update_false) }
220 };
221
222 struct script sc = {0};
223
224 GREATEST_ASSERT(script_append(&sc, &table[0].act));
225 GREATEST_ASSERT(script_append(&sc, &table[1].act));
226 GREATEST_ASSERT(script_append(&sc, &table[2].act));
227
228 /* 0 -> 1 */
229 GREATEST_ASSERT(!script_update(&sc, 0));
230 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
231 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
232 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
233 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
234 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
235 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
236 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
237 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
238 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
239 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
240 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
241 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
242 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
243 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
244 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
245
246 /* 1 -> 2 */
247 GREATEST_ASSERT(!script_update(&sc, 0));
248 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
249 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
250 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
251 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
252 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
253 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
254 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
255 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
256 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
257 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
258 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
259 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
260 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
261 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
262 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
263
264 /* 2 stays, it never ends. */
265 GREATEST_ASSERT(!script_update(&sc, 0));
266 GREATEST_ASSERT(!script_update(&sc, 0));
267 GREATEST_ASSERT(!script_update(&sc, 0));
268 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
269 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
270 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
271 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
272 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
273 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
274 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
275 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
276 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
277 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
278 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
279 GREATEST_ASSERT_EQ(table[2].inv.update, 3);
280 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
281 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
282 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
283
284 /* Now, change its update function to complete the script. */
285 table[2].act.update = my_update_true;
286 GREATEST_ASSERT(script_update(&sc, 0));
287 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
288 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
289 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
290 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
291 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
292 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
293 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
294 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
295 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
296 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
297 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
298 GREATEST_ASSERT_EQ(table[2].inv.update, 4);
299 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
300 GREATEST_ASSERT_EQ(table[2].inv.end, 1);
301 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
302
303 GREATEST_PASS();
304 }
305
306 GREATEST_TEST
307 basics_draw(void)
308 {
309 struct {
310 struct invokes inv;
311 struct action act;
312 } table[] = {
313 { .act = INIT(&table[0].inv, my_update_true) },
314 { .act = INIT(&table[1].inv, my_update_true) },
315 { .act = INIT(&table[2].inv, my_update_false) }
316 };
317
318 struct script sc = {0};
319
320 GREATEST_ASSERT(script_append(&sc, &table[0].act));
321 GREATEST_ASSERT(script_append(&sc, &table[1].act));
322 GREATEST_ASSERT(script_append(&sc, &table[2].act));
323
324 /* [0] */
325 script_draw(&sc);
326 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
327 GREATEST_ASSERT_EQ(table[0].inv.update, 0);
328 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
329 GREATEST_ASSERT_EQ(table[0].inv.end, 0);
330 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
331 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
332 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
333 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
334 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
335 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
336 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
337 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
338 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
339 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
340 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
341
342 /* [0] -> [1] */
343 GREATEST_ASSERT(!script_update(&sc, 0));
344 script_draw(&sc);
345
346 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
347 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
348 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
349 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
350 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
351 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
352 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
353 GREATEST_ASSERT_EQ(table[1].inv.draw, 1);
354 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
355 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
356 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
357 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
358 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
359 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
360 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
361
362 /* [2] */
363 GREATEST_ASSERT(!script_update(&sc, 0));
364 script_draw(&sc);
365
366 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
367 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
368 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
369 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
370 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
371 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
372 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
373 GREATEST_ASSERT_EQ(table[1].inv.draw, 1);
374 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
375 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
376 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
377 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
378 GREATEST_ASSERT_EQ(table[2].inv.draw, 1);
379 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
380 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
381
382 GREATEST_PASS();
383 }
384
385 GREATEST_TEST
386 basics_finish(void)
387 {
388 struct {
389 struct invokes inv;
390 struct action act;
391 } table[] = {
392 { .act = INIT(&table[0].inv, my_update_true) },
393 { .act = INIT(&table[1].inv, my_update_true) },
394 { .act = INIT(&table[2].inv, my_update_false) }
395 };
396
397 struct script sc = {0};
398
399 GREATEST_ASSERT(script_append(&sc, &table[0].act));
400 GREATEST_ASSERT(script_append(&sc, &table[1].act));
401 GREATEST_ASSERT(script_append(&sc, &table[2].act));
402
403 /* Update once so that the current action goes to 1. */
404 GREATEST_ASSERT(!script_update(&sc, 0));
405
406 script_finish(&sc);
407
408 GREATEST_ASSERT_EQ(table[0].inv.handle, 0);
409 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
410 GREATEST_ASSERT_EQ(table[0].inv.draw, 0);
411 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
412 GREATEST_ASSERT_EQ(table[0].inv.finish, 1);
413 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
414 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
415 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
416 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
417 GREATEST_ASSERT_EQ(table[1].inv.finish, 1);
418 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
419 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
420 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
421 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
422 GREATEST_ASSERT_EQ(table[2].inv.finish, 1);
423
424 GREATEST_PASS();
425 }
426
427 GREATEST_SUITE(suite_basics)
428 {
429 GREATEST_RUN_TEST(basics_init);
430 GREATEST_RUN_TEST(basics_append);
431 GREATEST_RUN_TEST(basics_handle);
432 GREATEST_RUN_TEST(basics_update);
433 GREATEST_RUN_TEST(basics_draw);
434 GREATEST_RUN_TEST(basics_finish);
435 }
436
437 GREATEST_TEST
438 action_simple(void)
439 {
440 struct {
441 struct invokes inv;
442 struct action act;
443 } table[] = {
444 { .act = INIT(&table[0].inv, my_update_true) },
445 { .act = INIT(&table[1].inv, my_update_true) },
446 { .act = INIT(&table[2].inv, my_update_false) }
447 };
448
449 struct script sc = {0};
450 struct action act;
451
452 GREATEST_ASSERT(script_append(&sc, &table[0].act));
453 GREATEST_ASSERT(script_append(&sc, &table[1].act));
454 GREATEST_ASSERT(script_append(&sc, &table[2].act));
455
456 /* Now convert this script into an action itself. */
457 script_action(&sc, &act);
458
459 /* Draw and input before updating. */
460 action_handle(&act, &(union event){0});
461 action_draw(&act);
462
463 /* [0] -> [1] */
464 GREATEST_ASSERT(!action_update(&act, 0));
465 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
466 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
467 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
468 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
469 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
470 GREATEST_ASSERT_EQ(table[1].inv.handle, 0);
471 GREATEST_ASSERT_EQ(table[1].inv.update, 0);
472 GREATEST_ASSERT_EQ(table[1].inv.draw, 0);
473 GREATEST_ASSERT_EQ(table[1].inv.end, 0);
474 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
475 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
476 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
477 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
478 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
479 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
480
481 action_handle(&act, &(union event){0});
482 action_draw(&act);
483
484 /* [1] -> [2] */
485 GREATEST_ASSERT(!action_update(&act, 0));
486 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
487 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
488 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
489 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
490 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
491 GREATEST_ASSERT_EQ(table[1].inv.handle, 1);
492 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
493 GREATEST_ASSERT_EQ(table[1].inv.draw, 1);
494 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
495 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
496 GREATEST_ASSERT_EQ(table[2].inv.handle, 0);
497 GREATEST_ASSERT_EQ(table[2].inv.update, 0);
498 GREATEST_ASSERT_EQ(table[2].inv.draw, 0);
499 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
500 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
501
502 action_handle(&act, &(union event){0});
503 action_draw(&act);
504
505 /* 2 stays, it never ends. */
506 GREATEST_ASSERT(!action_update(&act, 0));
507 GREATEST_ASSERT(!action_update(&act, 0));
508 GREATEST_ASSERT(!action_update(&act, 0));
509 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
510 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
511 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
512 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
513 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
514 GREATEST_ASSERT_EQ(table[1].inv.handle, 1);
515 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
516 GREATEST_ASSERT_EQ(table[1].inv.draw, 1);
517 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
518 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
519 GREATEST_ASSERT_EQ(table[2].inv.handle, 1);
520 GREATEST_ASSERT_EQ(table[2].inv.update, 3);
521 GREATEST_ASSERT_EQ(table[2].inv.draw, 1);
522 GREATEST_ASSERT_EQ(table[2].inv.end, 0);
523 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
524
525 table[2].act.update = my_update_true;
526 GREATEST_ASSERT(action_update(&act, 0));
527 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
528 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
529 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
530 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
531 GREATEST_ASSERT_EQ(table[0].inv.finish, 0);
532 GREATEST_ASSERT_EQ(table[1].inv.handle, 1);
533 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
534 GREATEST_ASSERT_EQ(table[1].inv.draw, 1);
535 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
536 GREATEST_ASSERT_EQ(table[1].inv.finish, 0);
537 GREATEST_ASSERT_EQ(table[2].inv.handle, 1);
538 GREATEST_ASSERT_EQ(table[2].inv.update, 4);
539 GREATEST_ASSERT_EQ(table[2].inv.draw, 1);
540 GREATEST_ASSERT_EQ(table[2].inv.end, 1);
541 GREATEST_ASSERT_EQ(table[2].inv.finish, 0);
542
543 /* Also dispose resources. */
544 action_finish(&act);
545 GREATEST_ASSERT_EQ(table[0].inv.handle, 1);
546 GREATEST_ASSERT_EQ(table[0].inv.update, 1);
547 GREATEST_ASSERT_EQ(table[0].inv.draw, 1);
548 GREATEST_ASSERT_EQ(table[0].inv.end, 1);
549 GREATEST_ASSERT_EQ(table[0].inv.finish, 1);
550 GREATEST_ASSERT_EQ(table[1].inv.handle, 1);
551 GREATEST_ASSERT_EQ(table[1].inv.update, 1);
552 GREATEST_ASSERT_EQ(table[1].inv.draw, 1);
553 GREATEST_ASSERT_EQ(table[1].inv.end, 1);
554 GREATEST_ASSERT_EQ(table[1].inv.finish, 1);
555 GREATEST_ASSERT_EQ(table[2].inv.handle, 1);
556 GREATEST_ASSERT_EQ(table[2].inv.update, 4);
557 GREATEST_ASSERT_EQ(table[2].inv.draw, 1);
558 GREATEST_ASSERT_EQ(table[2].inv.end, 1);
559 GREATEST_ASSERT_EQ(table[2].inv.finish, 1);
560
561 GREATEST_PASS();
562 }
563
564 GREATEST_SUITE(suite_action)
565 {
566 GREATEST_RUN_TEST(action_simple);
567 }
568
569 GREATEST_MAIN_DEFS();
570
571 int
572 main(int argc, char **argv)
573 {
574 GREATEST_MAIN_BEGIN();
575 GREATEST_RUN_SUITE(suite_basics);
576 GREATEST_RUN_SUITE(suite_action);
577 GREATEST_MAIN_END();
578 }