Mercurial > molko
comparison tests/test-action-script.c @ 136:30b68089ae70
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 } |