Mercurial > molko

comparison tests/test-drawable.c @ 143:4f4795cba52f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests: forgot to add file
author David Demelier <markand@malikania.fr>
date Wed, 14 Oct 2020 14:52:26 +0200
parents
children 196264679079
comparison
equal deleted inserted replaced
142:fea0cc899931 143:4f4795cba52f
1 /*
2 * test-action.c -- test actions
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/drawable.h>
23 #include <core/event.h>
24
25 struct invokes {
26 bool update;
27 bool draw;
28 bool end;
29 bool finish;
30 };
31
32 #define INIT(dat, up) { \
33 .data = (dat), \
34 .update = (up), \
35 .draw = my_draw, \
36 .end = my_end, \
37 .finish = my_finish \
38 }
39
40 static bool
41 my_update_false(struct drawable *dw, unsigned int ticks)
42 {
43 (void)ticks;
44
45 ((struct invokes *)dw->data)->update = true;
46
47 return false;
48 }
49
50 static bool
51 my_update_true(struct drawable *dw, unsigned int ticks)
52 {
53 (void)ticks;
54
55 ((struct invokes *)dw->data)->update = true;
56
57 return true;
58 }
59
60 static void
61 my_draw(struct drawable *dw)
62 {
63 ((struct invokes *)dw->data)->draw = true;
64 }
65
66 static void
67 my_end(struct drawable *dw)
68 {
69 ((struct invokes *)dw->data)->end = true;
70 }
71
72 static void
73 my_finish(struct drawable *dw)
74 {
75 ((struct invokes *)dw->data)->finish = true;
76 }
77
78 GREATEST_TEST
79 basics_update(void)
80 {
81 struct {
82 struct invokes inv;
83 struct drawable dw;
84 } table[] = {
85 { .dw = INIT(&table[0], my_update_true) },
86 { .dw = INIT(&table[1], my_update_false) }
87 };
88
89 /* True version. */
90 GREATEST_ASSERT(drawable_update(&table[0].dw, 0));
91 GREATEST_ASSERT(table[0].inv.update);
92 GREATEST_ASSERT(!table[0].inv.draw);
93 GREATEST_ASSERT(!table[0].inv.end);
94 GREATEST_ASSERT(!table[0].inv.finish);
95
96 /* False version. */
97 GREATEST_ASSERT(!drawable_update(&table[1].dw, 0));
98 GREATEST_ASSERT(table[1].inv.update);
99 GREATEST_ASSERT(!table[1].inv.draw);
100 GREATEST_ASSERT(!table[1].inv.end);
101 GREATEST_ASSERT(!table[1].inv.finish);
102
103 GREATEST_PASS();
104 }
105
106 GREATEST_TEST
107 basics_draw(void)
108 {
109 struct invokes inv = {0};
110 struct drawable dw = INIT(&inv, my_update_true);
111
112 drawable_draw(&dw);
113
114 GREATEST_ASSERT(!inv.update);
115 GREATEST_ASSERT(inv.draw);
116 GREATEST_ASSERT(!inv.end);
117 GREATEST_ASSERT(!inv.finish);
118 GREATEST_PASS();
119 }
120
121 GREATEST_TEST
122 basics_end(void)
123 {
124 struct invokes inv = {0};
125 struct drawable dw = INIT(&inv, my_update_true);
126
127 drawable_end(&dw);
128
129 GREATEST_ASSERT(!inv.update);
130 GREATEST_ASSERT(!inv.draw);
131 GREATEST_ASSERT(inv.end);
132 GREATEST_ASSERT(!inv.finish);
133 GREATEST_PASS();
134 }
135
136 GREATEST_TEST
137 basics_finish(void)
138 {
139 struct invokes inv = {0};
140 struct drawable dw = INIT(&inv, my_update_true);
141
142 drawable_finish(&dw);
143
144 GREATEST_ASSERT(!inv.update);
145 GREATEST_ASSERT(!inv.draw);
146 GREATEST_ASSERT(!inv.end);
147 GREATEST_ASSERT(inv.finish);
148 GREATEST_PASS();
149 }
150
151 GREATEST_SUITE(suite_basics)
152 {
153 GREATEST_RUN_TEST(basics_update);
154 GREATEST_RUN_TEST(basics_draw);
155 GREATEST_RUN_TEST(basics_end);
156 GREATEST_RUN_TEST(basics_finish);
157 }
158
159 GREATEST_TEST
160 stack_add(void)
161 {
162 struct drawable_stack st = {0};
163 struct drawable dw = {0};
164
165 GREATEST_ASSERT(drawable_stack_add(&st, &dw));
166
167 /* Now fill up. */
168 for (int i = 0; i < DRAWABLE_STACK_MAX - 1; ++i)
169 GREATEST_ASSERT(drawable_stack_add(&st, &dw));
170
171 /* This one should not fit in. */
172 GREATEST_ASSERT(!drawable_stack_add(&st, &dw));
173
174 GREATEST_PASS();
175 }
176
177 GREATEST_TEST
178 stack_update(void)
179 {
180 struct {
181 struct invokes inv;
182 struct drawable dw;
183 } table[] = {
184 { .dw = INIT(&table[0], my_update_false) },
185 { .dw = INIT(&table[1], my_update_true) },
186 { .dw = INIT(&table[2], my_update_false) },
187 { .dw = INIT(&table[3], my_update_false) },
188 { .dw = INIT(&table[4], my_update_true) },
189 { .dw = INIT(&table[5], my_update_true) },
190 { .dw = INIT(&table[6], my_update_false) },
191 };
192
193 struct drawable_stack st = {0};
194
195 drawable_stack_add(&st, &table[0].dw);
196 drawable_stack_add(&st, &table[1].dw);
197 drawable_stack_add(&st, &table[2].dw);
198 drawable_stack_add(&st, &table[3].dw);
199 drawable_stack_add(&st, &table[4].dw);
200 drawable_stack_add(&st, &table[5].dw);
201 drawable_stack_add(&st, &table[6].dw);
202
203 GREATEST_ASSERT(!drawable_stack_update(&st, 0));
204
205 GREATEST_ASSERT(table[0].inv.update);
206 GREATEST_ASSERT(table[1].inv.update);
207 GREATEST_ASSERT(table[2].inv.update);
208 GREATEST_ASSERT(table[3].inv.update);
209 GREATEST_ASSERT(table[4].inv.update);
210 GREATEST_ASSERT(table[5].inv.update);
211 GREATEST_ASSERT(table[6].inv.update);
212
213 GREATEST_ASSERT(!table[0].inv.draw);
214 GREATEST_ASSERT(!table[1].inv.draw);
215 GREATEST_ASSERT(!table[2].inv.draw);
216 GREATEST_ASSERT(!table[3].inv.draw);
217 GREATEST_ASSERT(!table[4].inv.draw);
218 GREATEST_ASSERT(!table[5].inv.draw);
219 GREATEST_ASSERT(!table[6].inv.draw);
220
221 GREATEST_ASSERT(!table[0].inv.end);
222 GREATEST_ASSERT(table[1].inv.end);
223 GREATEST_ASSERT(!table[2].inv.end);
224 GREATEST_ASSERT(!table[3].inv.end);
225 GREATEST_ASSERT(table[4].inv.end);
226 GREATEST_ASSERT(table[5].inv.end);
227 GREATEST_ASSERT(!table[6].inv.end);
228
229 GREATEST_ASSERT(!table[0].inv.finish);
230 GREATEST_ASSERT(table[1].inv.finish);
231 GREATEST_ASSERT(!table[2].inv.finish);
232 GREATEST_ASSERT(!table[3].inv.finish);
233 GREATEST_ASSERT(table[4].inv.finish);
234 GREATEST_ASSERT(table[5].inv.finish);
235 GREATEST_ASSERT(!table[6].inv.finish);
236
237 /* The following must still be there. */
238 GREATEST_ASSERT_EQ(st.objects[0], &table[0].dw);
239 GREATEST_ASSERT_EQ(st.objects[2], &table[2].dw);
240 GREATEST_ASSERT_EQ(st.objects[3], &table[3].dw);
241 GREATEST_ASSERT_EQ(st.objects[6], &table[6].dw);
242
243 /* The following must have been NULL-ed. */
244 GREATEST_ASSERT_EQ(st.objects[1], NULL);
245 GREATEST_ASSERT_EQ(st.objects[4], NULL);
246 GREATEST_ASSERT_EQ(st.objects[5], NULL);
247
248 /*
249 * Now make all actions to return true and check if it cleans the stack.
250 */
251 table[0].dw.update =
252 table[2].dw.update =
253 table[3].dw.update =
254 table[6].dw.update = my_update_true;
255
256 GREATEST_ASSERT(drawable_stack_update(&st, 0));
257 GREATEST_ASSERT_EQ(st.objects[0], NULL);
258 GREATEST_ASSERT_EQ(st.objects[1], NULL);
259 GREATEST_ASSERT_EQ(st.objects[2], NULL);
260 GREATEST_ASSERT_EQ(st.objects[3], NULL);
261 GREATEST_ASSERT_EQ(st.objects[4], NULL);
262 GREATEST_ASSERT_EQ(st.objects[5], NULL);
263 GREATEST_ASSERT_EQ(st.objects[6], NULL);
264
265 GREATEST_PASS();
266 }
267
268 GREATEST_TEST
269 stack_finish(void)
270 {
271 struct {
272 struct invokes inv;
273 struct drawable dw;
274 } table[] = {
275 { .dw = INIT(&table[0], my_update_true) },
276 { .dw = INIT(&table[0], my_update_false) },
277 };
278 struct drawable_stack st = {0};
279
280 drawable_stack_add(&st, &table[0].dw);
281 drawable_stack_add(&st, &table[1].dw);
282 drawable_stack_finish(&st);
283
284 GREATEST_ASSERT(!table[0].inv.update);
285 GREATEST_ASSERT(!table[0].inv.draw);
286 GREATEST_ASSERT(table[0].inv.end);
287 GREATEST_ASSERT(table[0].inv.finish);
288
289 GREATEST_ASSERT(!table[0].inv.update);
290 GREATEST_ASSERT(!table[0].inv.draw);
291 GREATEST_ASSERT(table[0].inv.end);
292 GREATEST_ASSERT(table[0].inv.finish);
293
294 /* They should also be NULL'ed. */
295 GREATEST_ASSERT_EQ(st.objects[0], NULL);
296 GREATEST_ASSERT_EQ(st.objects[1], NULL);
297
298 GREATEST_PASS();
299 }
300
301 GREATEST_SUITE(suite_stack)
302 {
303 GREATEST_RUN_TEST(stack_add);
304 GREATEST_RUN_TEST(stack_update);
305 GREATEST_RUN_TEST(stack_finish);
306 }
307
308 GREATEST_MAIN_DEFS();
309
310 int
311 main(int argc, char **argv)
312 {
313 GREATEST_MAIN_BEGIN();
314 GREATEST_RUN_SUITE(suite_basics);
315 GREATEST_RUN_SUITE(suite_stack);
316 GREATEST_MAIN_END();
317
318 return 0;
319 }