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