Mercurial > molko

comparison tests/test-action-script.c @ 336:f5a5bbb77122

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