Mercurial > molko

comparison tests/test-action-script.c @ 410:1bf7d6669f0a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests: switch to libdt
author David Demelier <markand@malikania.fr>
date Fri, 09 Sep 2022 13:30:34 +0200
parents 0ea90751a62d
children 8f59201dc76b
comparison
equal deleted inserted replaced
409:6011ad866e99 410:1bf7d6669f0a
18 18
19 #include <core/action.h> 19 #include <core/action.h>
20 #include <core/event.h> 20 #include <core/event.h>
21 #include <core/script.h> 21 #include <core/script.h>
22 22
23 #include "test.h" 23 #include <dt.h>
24 24
25 struct invokes { 25 struct invokes {
26 int handle; 26 int handle;
27 int update; 27 int update;
28 int draw; 28 int draw;
83 my_finish(struct action *act) 83 my_finish(struct action *act)
84 { 84 {
85 ((struct invokes *)act->data)->finish++; 85 ((struct invokes *)act->data)->finish++;
86 } 86 }
87 87
88 RX_TEST_CASE(basics, init) 88 static void
89 test_basics_init(void)
89 { 90 {
90 struct script sc; 91 struct script sc;
91 92
92 script_init(&sc); 93 script_init(&sc);
93 94
94 RX_UINT_REQUIRE_EQUAL(sc.actionsz, 0U); 95 DT_EQ_UINT(sc.actionsz, 0U);
95 RX_UINT_REQUIRE_EQUAL(sc.cur, 0U); 96 DT_EQ_UINT(sc.cur, 0U);
96 } 97 }
97 98
98 RX_TEST_CASE(basics, append) 99 static void
100 test_basics_append(void)
99 { 101 {
100 struct action act[3] = {0}; 102 struct action act[3] = {0};
101 struct script sc = {0}; 103 struct script sc = {0};
102 104
103 RX_REQUIRE(script_append(&sc, &act[0]) == 0); 105 DT_ASSERT(script_append(&sc, &act[0]) == 0);
104 RX_UINT_REQUIRE_EQUAL(sc.cur, 0U); 106 DT_EQ_UINT(sc.cur, 0U);
105 RX_UINT_REQUIRE_EQUAL(sc.actionsz, 1U); 107 DT_EQ_UINT(sc.actionsz, 1U);
106 RX_PTR_REQUIRE_EQUAL(sc.actions[0], &act[0]); 108 DT_EQ_PTR(sc.actions[0], &act[0]);
107 109
108 RX_REQUIRE(script_append(&sc, &act[1]) == 0); 110 DT_ASSERT(script_append(&sc, &act[1]) == 0);
109 RX_UINT_REQUIRE_EQUAL(sc.cur, 0U); 111 DT_EQ_UINT(sc.cur, 0U);
110 RX_UINT_REQUIRE_EQUAL(sc.actionsz, 2U); 112 DT_EQ_UINT(sc.actionsz, 2U);
111 RX_PTR_REQUIRE_EQUAL(sc.actions[0], &act[0]); 113 DT_EQ_PTR(sc.actions[0], &act[0]);
112 RX_PTR_REQUIRE_EQUAL(sc.actions[1], &act[1]); 114 DT_EQ_PTR(sc.actions[1], &act[1]);
113 115
114 RX_REQUIRE(script_append(&sc, &act[2]) == 0); 116 DT_ASSERT(script_append(&sc, &act[2]) == 0);
115 RX_UINT_REQUIRE_EQUAL(sc.cur, 0U); 117 DT_EQ_UINT(sc.cur, 0U);
116 RX_UINT_REQUIRE_EQUAL(sc.actionsz, 3U); 118 DT_EQ_UINT(sc.actionsz, 3U);
117 RX_PTR_REQUIRE_EQUAL(sc.actions[0], &act[0]); 119 DT_EQ_PTR(sc.actions[0], &act[0]);
118 RX_PTR_REQUIRE_EQUAL(sc.actions[1], &act[1]); 120 DT_EQ_PTR(sc.actions[1], &act[1]);
119 RX_PTR_REQUIRE_EQUAL(sc.actions[2], &act[2]); 121 DT_EQ_PTR(sc.actions[2], &act[2]);
120 122
121 script_finish(&sc); 123 script_finish(&sc);
122 } 124 }
123 125
124 RX_TEST_CASE(basics, handle) 126 static void
127 test_basics_handle(void)
125 { 128 {
126 struct { 129 struct {
127 struct invokes inv; 130 struct invokes inv;
128 struct action act; 131 struct action act;
129 } table[] = { 132 } table[] = {
132 { .act = INIT(&table[2].inv, my_update_false) } 135 { .act = INIT(&table[2].inv, my_update_false) }
133 }; 136 };
134 137
135 struct script sc = {0}; 138 struct script sc = {0};
136 139
137 RX_REQUIRE(script_append(&sc, &table[0].act) == 0); 140 DT_ASSERT(script_append(&sc, &table[0].act) == 0);
138 RX_REQUIRE(script_append(&sc, &table[1].act) == 0); 141 DT_ASSERT(script_append(&sc, &table[1].act) == 0);
139 RX_REQUIRE(script_append(&sc, &table[2].act) == 0); 142 DT_ASSERT(script_append(&sc, &table[2].act) == 0);
140 143
141 /* [0] */ 144 /* [0] */
142 script_handle(&sc, &(union event){0}); 145 script_handle(&sc, &(union event){0});
143 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 146 DT_EQ_INT(table[0].inv.handle, 1);
144 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 0); 147 DT_EQ_INT(table[0].inv.update, 0);
145 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 148 DT_EQ_INT(table[0].inv.draw, 0);
146 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 0); 149 DT_EQ_INT(table[0].inv.end, 0);
147 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 150 DT_EQ_INT(table[0].inv.finish, 0);
148 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 151 DT_EQ_INT(table[1].inv.handle, 0);
149 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 152 DT_EQ_INT(table[1].inv.update, 0);
150 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 153 DT_EQ_INT(table[1].inv.draw, 0);
151 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 154 DT_EQ_INT(table[1].inv.end, 0);
152 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 155 DT_EQ_INT(table[1].inv.finish, 0);
153 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 156 DT_EQ_INT(table[2].inv.handle, 0);
154 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 157 DT_EQ_INT(table[2].inv.update, 0);
155 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 158 DT_EQ_INT(table[2].inv.draw, 0);
156 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 159 DT_EQ_INT(table[2].inv.end, 0);
157 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 160 DT_EQ_INT(table[2].inv.finish, 0);
158 161
159 /* [0] -> [1] */ 162 /* [0] -> [1] */
160 RX_REQUIRE(!script_update(&sc, 0)); 163 DT_ASSERT(!script_update(&sc, 0));
161 script_handle(&sc, &(union event){0}); 164 script_handle(&sc, &(union event){0});
162 165
163 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 166 DT_EQ_INT(table[0].inv.handle, 1);
164 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 167 DT_EQ_INT(table[0].inv.update, 1);
165 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 168 DT_EQ_INT(table[0].inv.draw, 0);
166 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 169 DT_EQ_INT(table[0].inv.end, 1);
167 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 170 DT_EQ_INT(table[0].inv.finish, 0);
168 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 1); 171 DT_EQ_INT(table[1].inv.handle, 1);
169 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 172 DT_EQ_INT(table[1].inv.update, 0);
170 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 173 DT_EQ_INT(table[1].inv.draw, 0);
171 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 174 DT_EQ_INT(table[1].inv.end, 0);
172 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 175 DT_EQ_INT(table[1].inv.finish, 0);
173 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 176 DT_EQ_INT(table[2].inv.handle, 0);
174 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 177 DT_EQ_INT(table[2].inv.update, 0);
175 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 178 DT_EQ_INT(table[2].inv.draw, 0);
176 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 179 DT_EQ_INT(table[2].inv.end, 0);
177 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 180 DT_EQ_INT(table[2].inv.finish, 0);
178 181
179 /* [2] */ 182 /* [2] */
180 RX_REQUIRE(!script_update(&sc, 0)); 183 DT_ASSERT(!script_update(&sc, 0));
181 script_handle(&sc, &(union event){0}); 184 script_handle(&sc, &(union event){0});
182 185
183 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 186 DT_EQ_INT(table[0].inv.handle, 1);
184 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 187 DT_EQ_INT(table[0].inv.update, 1);
185 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 188 DT_EQ_INT(table[0].inv.draw, 0);
186 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 189 DT_EQ_INT(table[0].inv.end, 1);
187 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 190 DT_EQ_INT(table[0].inv.finish, 0);
188 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 1); 191 DT_EQ_INT(table[1].inv.handle, 1);
189 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 192 DT_EQ_INT(table[1].inv.update, 1);
190 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 193 DT_EQ_INT(table[1].inv.draw, 0);
191 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 194 DT_EQ_INT(table[1].inv.end, 1);
192 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 195 DT_EQ_INT(table[1].inv.finish, 0);
193 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 1); 196 DT_EQ_INT(table[2].inv.handle, 1);
194 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 197 DT_EQ_INT(table[2].inv.update, 0);
195 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 198 DT_EQ_INT(table[2].inv.draw, 0);
196 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 199 DT_EQ_INT(table[2].inv.end, 0);
197 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 200 DT_EQ_INT(table[2].inv.finish, 0);
198 } 201 }
199 202
200 RX_TEST_CASE(basics, update) 203 static void
204 test_basics_update(void)
201 { 205 {
202 struct { 206 struct {
203 struct invokes inv; 207 struct invokes inv;
204 struct action act; 208 struct action act;
205 } table[] = { 209 } table[] = {
208 { .act = INIT(&table[2].inv, my_update_false) } 212 { .act = INIT(&table[2].inv, my_update_false) }
209 }; 213 };
210 214
211 struct script sc = {0}; 215 struct script sc = {0};
212 216
213 RX_REQUIRE(script_append(&sc, &table[0].act) == 0); 217 DT_ASSERT(script_append(&sc, &table[0].act) == 0);
214 RX_REQUIRE(script_append(&sc, &table[1].act) == 0); 218 DT_ASSERT(script_append(&sc, &table[1].act) == 0);
215 RX_REQUIRE(script_append(&sc, &table[2].act) == 0); 219 DT_ASSERT(script_append(&sc, &table[2].act) == 0);
216 220
217 /* 0 -> 1 */ 221 /* 0 -> 1 */
218 RX_REQUIRE(!script_update(&sc, 0)); 222 DT_ASSERT(!script_update(&sc, 0));
219 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 223 DT_EQ_INT(table[0].inv.handle, 0);
220 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 224 DT_EQ_INT(table[0].inv.update, 1);
221 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 225 DT_EQ_INT(table[0].inv.draw, 0);
222 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 226 DT_EQ_INT(table[0].inv.end, 1);
223 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 227 DT_EQ_INT(table[0].inv.finish, 0);
224 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 228 DT_EQ_INT(table[1].inv.handle, 0);
225 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 229 DT_EQ_INT(table[1].inv.update, 0);
226 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 230 DT_EQ_INT(table[1].inv.draw, 0);
227 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 231 DT_EQ_INT(table[1].inv.end, 0);
228 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 232 DT_EQ_INT(table[1].inv.finish, 0);
229 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 233 DT_EQ_INT(table[2].inv.handle, 0);
230 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 234 DT_EQ_INT(table[2].inv.update, 0);
231 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 235 DT_EQ_INT(table[2].inv.draw, 0);
232 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 236 DT_EQ_INT(table[2].inv.end, 0);
233 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 237 DT_EQ_INT(table[2].inv.finish, 0);
234 238
235 /* 1 -> 2 */ 239 /* 1 -> 2 */
236 RX_REQUIRE(!script_update(&sc, 0)); 240 DT_ASSERT(!script_update(&sc, 0));
237 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 241 DT_EQ_INT(table[0].inv.handle, 0);
238 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 242 DT_EQ_INT(table[0].inv.update, 1);
239 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 243 DT_EQ_INT(table[0].inv.draw, 0);
240 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 244 DT_EQ_INT(table[0].inv.end, 1);
241 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 245 DT_EQ_INT(table[0].inv.finish, 0);
242 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 246 DT_EQ_INT(table[1].inv.handle, 0);
243 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 247 DT_EQ_INT(table[1].inv.update, 1);
244 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 248 DT_EQ_INT(table[1].inv.draw, 0);
245 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 249 DT_EQ_INT(table[1].inv.end, 1);
246 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 250 DT_EQ_INT(table[1].inv.finish, 0);
247 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 251 DT_EQ_INT(table[2].inv.handle, 0);
248 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 252 DT_EQ_INT(table[2].inv.update, 0);
249 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 253 DT_EQ_INT(table[2].inv.draw, 0);
250 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 254 DT_EQ_INT(table[2].inv.end, 0);
251 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 255 DT_EQ_INT(table[2].inv.finish, 0);
252 256
253 /* 2 stays, it never ends. */ 257 /* 2 stays, it never ends. */
254 RX_REQUIRE(!script_update(&sc, 0)); 258 DT_ASSERT(!script_update(&sc, 0));
255 RX_REQUIRE(!script_update(&sc, 0)); 259 DT_ASSERT(!script_update(&sc, 0));
256 RX_REQUIRE(!script_update(&sc, 0)); 260 DT_ASSERT(!script_update(&sc, 0));
257 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 261 DT_EQ_INT(table[0].inv.handle, 0);
258 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 262 DT_EQ_INT(table[0].inv.update, 1);
259 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 263 DT_EQ_INT(table[0].inv.draw, 0);
260 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 264 DT_EQ_INT(table[0].inv.end, 1);
261 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 265 DT_EQ_INT(table[0].inv.finish, 0);
262 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 266 DT_EQ_INT(table[1].inv.handle, 0);
263 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 267 DT_EQ_INT(table[1].inv.update, 1);
264 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 268 DT_EQ_INT(table[1].inv.draw, 0);
265 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 269 DT_EQ_INT(table[1].inv.end, 1);
266 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 270 DT_EQ_INT(table[1].inv.finish, 0);
267 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 271 DT_EQ_INT(table[2].inv.handle, 0);
268 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 3); 272 DT_EQ_INT(table[2].inv.update, 3);
269 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 273 DT_EQ_INT(table[2].inv.draw, 0);
270 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 274 DT_EQ_INT(table[2].inv.end, 0);
271 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 275 DT_EQ_INT(table[2].inv.finish, 0);
272 276
273 /* Now, change its update function to complete the script. */ 277 /* Now, change its update function to complete the script. */
274 table[2].act.update = my_update_true; 278 table[2].act.update = my_update_true;
275 RX_REQUIRE(script_update(&sc, 0)); 279 DT_ASSERT(script_update(&sc, 0));
276 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 280 DT_EQ_INT(table[0].inv.handle, 0);
277 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 281 DT_EQ_INT(table[0].inv.update, 1);
278 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 282 DT_EQ_INT(table[0].inv.draw, 0);
279 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 283 DT_EQ_INT(table[0].inv.end, 1);
280 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 284 DT_EQ_INT(table[0].inv.finish, 0);
281 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 285 DT_EQ_INT(table[1].inv.handle, 0);
282 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 286 DT_EQ_INT(table[1].inv.update, 1);
283 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 287 DT_EQ_INT(table[1].inv.draw, 0);
284 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 288 DT_EQ_INT(table[1].inv.end, 1);
285 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 289 DT_EQ_INT(table[1].inv.finish, 0);
286 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 290 DT_EQ_INT(table[2].inv.handle, 0);
287 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 4); 291 DT_EQ_INT(table[2].inv.update, 4);
288 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 292 DT_EQ_INT(table[2].inv.draw, 0);
289 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 1); 293 DT_EQ_INT(table[2].inv.end, 1);
290 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 294 DT_EQ_INT(table[2].inv.finish, 0);
291 } 295 }
292 296
293 RX_TEST_CASE(basics, draw) 297 static void
298 test_basics_draw(void)
294 { 299 {
295 struct { 300 struct {
296 struct invokes inv; 301 struct invokes inv;
297 struct action act; 302 struct action act;
298 } table[] = { 303 } table[] = {
301 { .act = INIT(&table[2].inv, my_update_false) } 306 { .act = INIT(&table[2].inv, my_update_false) }
302 }; 307 };
303 308
304 struct script sc = {0}; 309 struct script sc = {0};
305 310
306 RX_REQUIRE(script_append(&sc, &table[0].act) == 0); 311 DT_ASSERT(script_append(&sc, &table[0].act) == 0);
307 RX_REQUIRE(script_append(&sc, &table[1].act) == 0); 312 DT_ASSERT(script_append(&sc, &table[1].act) == 0);
308 RX_REQUIRE(script_append(&sc, &table[2].act) == 0); 313 DT_ASSERT(script_append(&sc, &table[2].act) == 0);
309 314
310 /* [0] */ 315 /* [0] */
311 script_draw(&sc); 316 script_draw(&sc);
312 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 317 DT_EQ_INT(table[0].inv.handle, 0);
313 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 0); 318 DT_EQ_INT(table[0].inv.update, 0);
314 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 319 DT_EQ_INT(table[0].inv.draw, 1);
315 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 0); 320 DT_EQ_INT(table[0].inv.end, 0);
316 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 321 DT_EQ_INT(table[0].inv.finish, 0);
317 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 322 DT_EQ_INT(table[1].inv.handle, 0);
318 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 323 DT_EQ_INT(table[1].inv.update, 0);
319 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 324 DT_EQ_INT(table[1].inv.draw, 0);
320 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 325 DT_EQ_INT(table[1].inv.end, 0);
321 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 326 DT_EQ_INT(table[1].inv.finish, 0);
322 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 327 DT_EQ_INT(table[2].inv.handle, 0);
323 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 328 DT_EQ_INT(table[2].inv.update, 0);
324 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 329 DT_EQ_INT(table[2].inv.draw, 0);
325 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 330 DT_EQ_INT(table[2].inv.end, 0);
326 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 331 DT_EQ_INT(table[2].inv.finish, 0);
327 332
328 /* [0] -> [1] */ 333 /* [0] -> [1] */
329 RX_REQUIRE(!script_update(&sc, 0)); 334 DT_ASSERT(!script_update(&sc, 0));
330 script_draw(&sc); 335 script_draw(&sc);
331 336
332 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 337 DT_EQ_INT(table[0].inv.handle, 0);
333 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 338 DT_EQ_INT(table[0].inv.update, 1);
334 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 339 DT_EQ_INT(table[0].inv.draw, 1);
335 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 340 DT_EQ_INT(table[0].inv.end, 1);
336 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 341 DT_EQ_INT(table[0].inv.finish, 0);
337 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 342 DT_EQ_INT(table[1].inv.handle, 0);
338 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 343 DT_EQ_INT(table[1].inv.update, 0);
339 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 1); 344 DT_EQ_INT(table[1].inv.draw, 1);
340 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 345 DT_EQ_INT(table[1].inv.end, 0);
341 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 346 DT_EQ_INT(table[1].inv.finish, 0);
342 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 347 DT_EQ_INT(table[2].inv.handle, 0);
343 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 348 DT_EQ_INT(table[2].inv.update, 0);
344 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 349 DT_EQ_INT(table[2].inv.draw, 0);
345 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 350 DT_EQ_INT(table[2].inv.end, 0);
346 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 351 DT_EQ_INT(table[2].inv.finish, 0);
347 352
348 /* [2] */ 353 /* [2] */
349 RX_REQUIRE(!script_update(&sc, 0)); 354 DT_ASSERT(!script_update(&sc, 0));
350 script_draw(&sc); 355 script_draw(&sc);
351 356
352 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 357 DT_EQ_INT(table[0].inv.handle, 0);
353 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 358 DT_EQ_INT(table[0].inv.update, 1);
354 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 359 DT_EQ_INT(table[0].inv.draw, 1);
355 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 360 DT_EQ_INT(table[0].inv.end, 1);
356 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 361 DT_EQ_INT(table[0].inv.finish, 0);
357 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 362 DT_EQ_INT(table[1].inv.handle, 0);
358 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 363 DT_EQ_INT(table[1].inv.update, 1);
359 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 1); 364 DT_EQ_INT(table[1].inv.draw, 1);
360 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 365 DT_EQ_INT(table[1].inv.end, 1);
361 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 366 DT_EQ_INT(table[1].inv.finish, 0);
362 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 367 DT_EQ_INT(table[2].inv.handle, 0);
363 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 368 DT_EQ_INT(table[2].inv.update, 0);
364 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 1); 369 DT_EQ_INT(table[2].inv.draw, 1);
365 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 370 DT_EQ_INT(table[2].inv.end, 0);
366 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 371 DT_EQ_INT(table[2].inv.finish, 0);
367 } 372 }
368 373
369 RX_TEST_CASE(basics, finish) 374 static void
375 test_basics_finish(void)
370 { 376 {
371 struct { 377 struct {
372 struct invokes inv; 378 struct invokes inv;
373 struct action act; 379 struct action act;
374 } table[] = { 380 } table[] = {
377 { .act = INIT(&table[2].inv, my_update_false) } 383 { .act = INIT(&table[2].inv, my_update_false) }
378 }; 384 };
379 385
380 struct script sc = {0}; 386 struct script sc = {0};
381 387
382 RX_REQUIRE(script_append(&sc, &table[0].act) == 0); 388 DT_ASSERT(script_append(&sc, &table[0].act) == 0);
383 RX_REQUIRE(script_append(&sc, &table[1].act) == 0); 389 DT_ASSERT(script_append(&sc, &table[1].act) == 0);
384 RX_REQUIRE(script_append(&sc, &table[2].act) == 0); 390 DT_ASSERT(script_append(&sc, &table[2].act) == 0);
385 391
386 /* Update once so that the current action goes to 1. */ 392 /* Update once so that the current action goes to 1. */
387 RX_REQUIRE(!script_update(&sc, 0)); 393 DT_ASSERT(!script_update(&sc, 0));
388 394
389 script_finish(&sc); 395 script_finish(&sc);
390 396
391 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 0); 397 DT_EQ_INT(table[0].inv.handle, 0);
392 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 398 DT_EQ_INT(table[0].inv.update, 1);
393 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 0); 399 DT_EQ_INT(table[0].inv.draw, 0);
394 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 400 DT_EQ_INT(table[0].inv.end, 1);
395 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 1); 401 DT_EQ_INT(table[0].inv.finish, 1);
396 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 402 DT_EQ_INT(table[1].inv.handle, 0);
397 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 403 DT_EQ_INT(table[1].inv.update, 0);
398 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 404 DT_EQ_INT(table[1].inv.draw, 0);
399 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 405 DT_EQ_INT(table[1].inv.end, 0);
400 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 1); 406 DT_EQ_INT(table[1].inv.finish, 1);
401 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 407 DT_EQ_INT(table[2].inv.handle, 0);
402 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 408 DT_EQ_INT(table[2].inv.update, 0);
403 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 409 DT_EQ_INT(table[2].inv.draw, 0);
404 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 410 DT_EQ_INT(table[2].inv.end, 0);
405 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 1); 411 DT_EQ_INT(table[2].inv.finish, 1);
406 } 412 }
407 413
408 RX_TEST_CASE(action, simple) 414 static void
415 test_action_simple(void)
409 { 416 {
410 struct { 417 struct {
411 struct invokes inv; 418 struct invokes inv;
412 struct action act; 419 struct action act;
413 } table[] = { 420 } table[] = {
417 }; 424 };
418 425
419 struct script sc = {0}; 426 struct script sc = {0};
420 struct action act; 427 struct action act;
421 428
422 RX_REQUIRE(script_append(&sc, &table[0].act) == 0); 429 DT_ASSERT(script_append(&sc, &table[0].act) == 0);
423 RX_REQUIRE(script_append(&sc, &table[1].act) == 0); 430 DT_ASSERT(script_append(&sc, &table[1].act) == 0);
424 RX_REQUIRE(script_append(&sc, &table[2].act) == 0); 431 DT_ASSERT(script_append(&sc, &table[2].act) == 0);
425 432
426 /* Now convert this script into an action itself. */ 433 /* Now convert this script into an action itself. */
427 script_action(&sc, &act); 434 script_action(&sc, &act);
428 435
429 /* Draw and input before updating. */ 436 /* Draw and input before updating. */
430 action_handle(&act, &(union event){0}); 437 action_handle(&act, &(union event){0});
431 action_draw(&act); 438 action_draw(&act);
432 439
433 /* [0] -> [1] */ 440 /* [0] -> [1] */
434 RX_REQUIRE(!action_update(&act, 0)); 441 DT_ASSERT(!action_update(&act, 0));
435 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 442 DT_EQ_INT(table[0].inv.handle, 1);
436 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 443 DT_EQ_INT(table[0].inv.update, 1);
437 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 444 DT_EQ_INT(table[0].inv.draw, 1);
438 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 445 DT_EQ_INT(table[0].inv.end, 1);
439 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 446 DT_EQ_INT(table[0].inv.finish, 0);
440 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 0); 447 DT_EQ_INT(table[1].inv.handle, 0);
441 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 0); 448 DT_EQ_INT(table[1].inv.update, 0);
442 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 0); 449 DT_EQ_INT(table[1].inv.draw, 0);
443 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 0); 450 DT_EQ_INT(table[1].inv.end, 0);
444 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 451 DT_EQ_INT(table[1].inv.finish, 0);
445 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 452 DT_EQ_INT(table[2].inv.handle, 0);
446 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 453 DT_EQ_INT(table[2].inv.update, 0);
447 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 454 DT_EQ_INT(table[2].inv.draw, 0);
448 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 455 DT_EQ_INT(table[2].inv.end, 0);
449 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 456 DT_EQ_INT(table[2].inv.finish, 0);
450 457
451 action_handle(&act, &(union event){0}); 458 action_handle(&act, &(union event){0});
452 action_draw(&act); 459 action_draw(&act);
453 460
454 /* [1] -> [2] */ 461 /* [1] -> [2] */
455 RX_REQUIRE(!action_update(&act, 0)); 462 DT_ASSERT(!action_update(&act, 0));
456 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 463 DT_EQ_INT(table[0].inv.handle, 1);
457 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 464 DT_EQ_INT(table[0].inv.update, 1);
458 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 465 DT_EQ_INT(table[0].inv.draw, 1);
459 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 466 DT_EQ_INT(table[0].inv.end, 1);
460 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 467 DT_EQ_INT(table[0].inv.finish, 0);
461 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 1); 468 DT_EQ_INT(table[1].inv.handle, 1);
462 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 469 DT_EQ_INT(table[1].inv.update, 1);
463 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 1); 470 DT_EQ_INT(table[1].inv.draw, 1);
464 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 471 DT_EQ_INT(table[1].inv.end, 1);
465 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 472 DT_EQ_INT(table[1].inv.finish, 0);
466 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 0); 473 DT_EQ_INT(table[2].inv.handle, 0);
467 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 0); 474 DT_EQ_INT(table[2].inv.update, 0);
468 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 0); 475 DT_EQ_INT(table[2].inv.draw, 0);
469 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 476 DT_EQ_INT(table[2].inv.end, 0);
470 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 477 DT_EQ_INT(table[2].inv.finish, 0);
471 478
472 action_handle(&act, &(union event){0}); 479 action_handle(&act, &(union event){0});
473 action_draw(&act); 480 action_draw(&act);
474 481
475 /* 2 stays, it never ends. */ 482 /* 2 stays, it never ends. */
476 RX_REQUIRE(!action_update(&act, 0)); 483 DT_ASSERT(!action_update(&act, 0));
477 RX_REQUIRE(!action_update(&act, 0)); 484 DT_ASSERT(!action_update(&act, 0));
478 RX_REQUIRE(!action_update(&act, 0)); 485 DT_ASSERT(!action_update(&act, 0));
479 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 486 DT_EQ_INT(table[0].inv.handle, 1);
480 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 487 DT_EQ_INT(table[0].inv.update, 1);
481 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 488 DT_EQ_INT(table[0].inv.draw, 1);
482 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 489 DT_EQ_INT(table[0].inv.end, 1);
483 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 490 DT_EQ_INT(table[0].inv.finish, 0);
484 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 1); 491 DT_EQ_INT(table[1].inv.handle, 1);
485 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 492 DT_EQ_INT(table[1].inv.update, 1);
486 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 1); 493 DT_EQ_INT(table[1].inv.draw, 1);
487 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 494 DT_EQ_INT(table[1].inv.end, 1);
488 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 495 DT_EQ_INT(table[1].inv.finish, 0);
489 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 1); 496 DT_EQ_INT(table[2].inv.handle, 1);
490 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 3); 497 DT_EQ_INT(table[2].inv.update, 3);
491 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 1); 498 DT_EQ_INT(table[2].inv.draw, 1);
492 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 0); 499 DT_EQ_INT(table[2].inv.end, 0);
493 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 500 DT_EQ_INT(table[2].inv.finish, 0);
494 501
495 table[2].act.update = my_update_true; 502 table[2].act.update = my_update_true;
496 RX_REQUIRE(action_update(&act, 0)); 503 DT_ASSERT(action_update(&act, 0));
497 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 504 DT_EQ_INT(table[0].inv.handle, 1);
498 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 505 DT_EQ_INT(table[0].inv.update, 1);
499 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 506 DT_EQ_INT(table[0].inv.draw, 1);
500 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 507 DT_EQ_INT(table[0].inv.end, 1);
501 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 0); 508 DT_EQ_INT(table[0].inv.finish, 0);
502 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 1); 509 DT_EQ_INT(table[1].inv.handle, 1);
503 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 510 DT_EQ_INT(table[1].inv.update, 1);
504 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 1); 511 DT_EQ_INT(table[1].inv.draw, 1);
505 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 512 DT_EQ_INT(table[1].inv.end, 1);
506 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 0); 513 DT_EQ_INT(table[1].inv.finish, 0);
507 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 1); 514 DT_EQ_INT(table[2].inv.handle, 1);
508 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 4); 515 DT_EQ_INT(table[2].inv.update, 4);
509 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 1); 516 DT_EQ_INT(table[2].inv.draw, 1);
510 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 1); 517 DT_EQ_INT(table[2].inv.end, 1);
511 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 0); 518 DT_EQ_INT(table[2].inv.finish, 0);
512 519
513 /* Also dispose resources. */ 520 /* Also dispose resources. */
514 action_finish(&act); 521 action_finish(&act);
515 RX_INT_REQUIRE_EQUAL(table[0].inv.handle, 1); 522 DT_EQ_INT(table[0].inv.handle, 1);
516 RX_INT_REQUIRE_EQUAL(table[0].inv.update, 1); 523 DT_EQ_INT(table[0].inv.update, 1);
517 RX_INT_REQUIRE_EQUAL(table[0].inv.draw, 1); 524 DT_EQ_INT(table[0].inv.draw, 1);
518 RX_INT_REQUIRE_EQUAL(table[0].inv.end, 1); 525 DT_EQ_INT(table[0].inv.end, 1);
519 RX_INT_REQUIRE_EQUAL(table[0].inv.finish, 1); 526 DT_EQ_INT(table[0].inv.finish, 1);
520 RX_INT_REQUIRE_EQUAL(table[1].inv.handle, 1); 527 DT_EQ_INT(table[1].inv.handle, 1);
521 RX_INT_REQUIRE_EQUAL(table[1].inv.update, 1); 528 DT_EQ_INT(table[1].inv.update, 1);
522 RX_INT_REQUIRE_EQUAL(table[1].inv.draw, 1); 529 DT_EQ_INT(table[1].inv.draw, 1);
523 RX_INT_REQUIRE_EQUAL(table[1].inv.end, 1); 530 DT_EQ_INT(table[1].inv.end, 1);
524 RX_INT_REQUIRE_EQUAL(table[1].inv.finish, 1); 531 DT_EQ_INT(table[1].inv.finish, 1);
525 RX_INT_REQUIRE_EQUAL(table[2].inv.handle, 1); 532 DT_EQ_INT(table[2].inv.handle, 1);
526 RX_INT_REQUIRE_EQUAL(table[2].inv.update, 4); 533 DT_EQ_INT(table[2].inv.update, 4);
527 RX_INT_REQUIRE_EQUAL(table[2].inv.draw, 1); 534 DT_EQ_INT(table[2].inv.draw, 1);
528 RX_INT_REQUIRE_EQUAL(table[2].inv.end, 1); 535 DT_EQ_INT(table[2].inv.end, 1);
529 RX_INT_REQUIRE_EQUAL(table[2].inv.finish, 1); 536 DT_EQ_INT(table[2].inv.finish, 1);
530 } 537 }
531
532 static const struct rx_test_case tests[] = {
533 TEST(basics, init),
534 TEST(basics, append),
535 TEST(basics, handle),
536 TEST(basics, update),
537 TEST(basics, draw),
538 TEST(basics, finish),
539 TEST(action, simple)
540 };
541 538
542 int 539 int
543 main(int argc, char **argv) 540 main(void)
544 { 541 {
545 return TEST_RUN_ALL(tests, argc, argv); 542 DT_RUN(test_basics_init);
546 } 543 DT_RUN(test_basics_append);
544 DT_RUN(test_basics_handle);
545 DT_RUN(test_basics_update);
546 DT_RUN(test_basics_draw);
547 DT_RUN(test_basics_finish);
548 DT_RUN(test_action_simple);
549 DT_SUMMARY();
550 }