8 #if !defined(ck_assert_ptr_null)
9 # define ck_assert_ptr_null(X) ck_assert_ptr_eq(X, NULL)
10 # define ck_assert_ptr_nonnull(X) ck_assert_ptr_ne(X, NULL)
14 #include "afb-apiset.h"
16 const char *names[] = {
32 const char *aliases[] = {
44 const char *extras[] = {
58 struct afb_api_itf api_itf_null = {
60 .service_start = NULL,
71 /*********************************************************************/
72 /* check the initialisation */
73 START_TEST (check_initialisation)
75 const char name[] = "name";
76 const char noname[] = "";
79 struct afb_apiset *a, *b;
81 a = afb_apiset_create(NULL, noto);
82 ck_assert_ptr_nonnull(a);
83 ck_assert_str_eq(noname, afb_apiset_name(a));
84 ck_assert_int_eq(noto, afb_apiset_timeout_get(a));
85 afb_apiset_timeout_set(a, to);
86 ck_assert_int_eq(to, afb_apiset_timeout_get(a));
87 b = afb_apiset_addref(a);
88 ck_assert_ptr_eq(a, b);
92 a = afb_apiset_create(name, to);
93 ck_assert_ptr_nonnull(a);
94 ck_assert_str_eq(name, afb_apiset_name(a));
95 ck_assert_int_eq(to, afb_apiset_timeout_get(a));
96 afb_apiset_timeout_set(a, noto);
97 ck_assert_int_eq(noto, afb_apiset_timeout_get(a));
98 b = afb_apiset_addref(a);
99 ck_assert_ptr_eq(a, b);
105 /*********************************************************************/
106 /* check that NULL is a valid value for addref/unref */
107 START_TEST (check_sanity)
109 struct afb_apiset *a;
111 a = afb_apiset_addref(NULL);
112 ck_assert_ptr_null(a);
113 afb_apiset_unref(NULL);
118 /*********************************************************************/
119 /* check creation and retrieval of apis */
121 START_TEST (check_creation)
124 struct afb_apiset *a;
125 struct afb_api_item sa;
126 const char *x, *y, **set;
127 const struct afb_api_item *pa;
129 /* create a apiset */
130 a = afb_apiset_create(NULL, 0);
131 ck_assert_ptr_nonnull(a);
134 for (i = 0 ; names[i] != NULL ; i++) {
135 sa.itf = &api_itf_null;
136 sa.closure = (void*)names[i];
138 ck_assert_int_eq(0, afb_apiset_add(a, names[i], sa));
139 pa = afb_apiset_lookup(a, names[i], 1);
140 ck_assert_ptr_nonnull(pa);
141 ck_assert_ptr_eq(sa.itf, pa->itf);
142 ck_assert_ptr_eq(sa.closure, pa->closure);
143 ck_assert_ptr_eq(sa.group, pa->group);
144 ck_assert_int_eq(0, afb_apiset_is_alias(a, names[i]));
145 ck_assert_str_eq(names[i], afb_apiset_unalias(a, names[i]));
146 ck_assert_int_eq(-1, afb_apiset_add(a, names[i], sa));
147 ck_assert_int_eq(errno, EEXIST);
152 for (i = 0 ; aliases[i] != NULL ; i += 2) {
153 ck_assert_int_eq(-1, afb_apiset_add_alias(a, extras[0], aliases[i]));
154 ck_assert_int_eq(errno, ENOENT);
155 ck_assert_int_eq(0, afb_apiset_add_alias(a, aliases[i + 1], aliases[i]));
156 ck_assert_ptr_nonnull(afb_apiset_lookup(a, aliases[i], 1));
157 ck_assert_int_eq(1, afb_apiset_is_alias(a, aliases[i]));
158 x = afb_apiset_unalias(a, aliases[i]);
159 y = afb_apiset_unalias(a, aliases[i + 1]);
160 ck_assert_int_eq(0, strcasecmp(x, y));
161 ck_assert_int_eq(-1, afb_apiset_add_alias(a, aliases[i + 1], aliases[i]));
162 ck_assert_int_eq(errno, EEXIST);
167 for (i = 0 ; extras[i] != NULL ; i++) {
168 pa = afb_apiset_lookup(a, extras[i], 1);
169 ck_assert_ptr_null(pa);
170 ck_assert_int_eq(errno, ENOENT);
174 set = afb_apiset_get_names(a, 0, 1);
175 ck_assert_ptr_nonnull(set);
176 for (i = 0 ; set[i] != NULL ; i++) {
177 ck_assert_ptr_nonnull(afb_apiset_lookup(a, set[i], 0));
178 ck_assert_int_eq(0, afb_apiset_is_alias(a, set[i]));
180 ck_assert_int_gt(0, strcasecmp(set[i-1], set[i]));
182 ck_assert_int_eq(i, nn);
184 set = afb_apiset_get_names(a, 0, 2);
185 ck_assert_ptr_nonnull(set);
186 for (i = 0 ; set[i] != NULL ; i++) {
187 ck_assert_ptr_nonnull(afb_apiset_lookup(a, set[i], 0));
188 ck_assert_int_eq(1, afb_apiset_is_alias(a, set[i]));
190 ck_assert_int_gt(0, strcasecmp(set[i-1], set[i]));
192 ck_assert_int_eq(i, na);
194 set = afb_apiset_get_names(a, 0, 3);
195 ck_assert_ptr_nonnull(set);
196 for (i = 0 ; set[i] != NULL ; i++) {
197 ck_assert_ptr_nonnull(afb_apiset_lookup(a, set[i], 0));
199 ck_assert_int_gt(0, strcasecmp(set[i-1], set[i]));
201 ck_assert_int_eq(i, nn + na);
203 /* removes the apis to check deletion */
204 for (i = 0 ; i < nn + na ; i++) {
208 /* should be present */
209 ck_assert_ptr_nonnull(afb_apiset_lookup(a, set[i], 0));
211 /* deleting a non aliased api removes the aliases! */
212 if (!afb_apiset_is_alias(a, set[i])) {
213 for (j = i + 1 ; j < nn + na ; j++) {
216 ck_assert_ptr_nonnull(afb_apiset_lookup(a, set[j], 0));
217 if (afb_apiset_is_alias(a, set[j])
218 && afb_apiset_lookup(a, set[i], 0) == afb_apiset_lookup(a, set[j], 0)) {
219 ck_assert(set[j][0] > 0);
220 ((char*)set[j])[0] = (char)-set[j][0];
226 ck_assert_int_eq(0, afb_apiset_del(a, set[i]));
227 ck_assert_ptr_null(afb_apiset_lookup(a, set[i], 0));
229 /* check other not removed except aliases */
230 for (j = i + 1 ; j < nn + na ; j++) {
234 ck_assert_ptr_nonnull(afb_apiset_lookup(a, set[j], 0));
236 ((char*)set[j])[0] = (char)-set[j][0];
237 ck_assert_ptr_null(afb_apiset_lookup(a, set[j], 0));
248 /*********************************************************************/
249 /* check onlack behaviour */
253 static void onlackcleanup(void *closure)
255 int *count = closure;
256 ck_assert_ptr_eq(count, &onlackcount);
259 static int onlack(void *closure, struct afb_apiset *a, const char *name)
261 int *count = closure;
262 struct afb_api_item sa;
264 ck_assert_ptr_eq(count, &onlackcount);
267 sa.itf = &api_itf_null;
268 sa.closure = (void*)name;
271 ck_assert_int_eq(0, afb_apiset_add(a, name, sa));
275 START_TEST (check_onlack)
278 struct afb_apiset *a;
279 struct afb_api_item sa;
281 const struct afb_api_item *pa;
283 /* create a apiset */
284 a = afb_apiset_create(NULL, 0);
285 ck_assert_ptr_nonnull(a);
288 for (i = 0 ; names[i] != NULL ; i++) {
289 sa.itf = &api_itf_null;
290 sa.closure = (void*)names[i];
292 ck_assert_int_eq(0, afb_apiset_add(a, names[i], sa));
293 pa = afb_apiset_lookup(a, names[i], 1);
294 ck_assert_ptr_nonnull(pa);
295 ck_assert_ptr_eq(sa.itf, pa->itf);
296 ck_assert_ptr_eq(sa.closure, pa->closure);
297 ck_assert_ptr_eq(sa.group, pa->group);
298 ck_assert_int_eq(0, afb_apiset_is_alias(a, names[i]));
299 ck_assert_str_eq(names[i], afb_apiset_unalias(a, names[i]));
300 ck_assert_int_eq(-1, afb_apiset_add(a, names[i], sa));
301 ck_assert_int_eq(errno, EEXIST);
305 for (i = 0 ; aliases[i] != NULL ; i += 2) {
306 ck_assert_int_eq(-1, afb_apiset_add_alias(a, extras[0], aliases[i]));
307 ck_assert_int_eq(errno, ENOENT);
308 ck_assert_int_eq(0, afb_apiset_add_alias(a, aliases[i + 1], aliases[i]));
309 ck_assert_ptr_nonnull(afb_apiset_lookup(a, aliases[i], 1));
310 ck_assert_int_eq(1, afb_apiset_is_alias(a, aliases[i]));
311 x = afb_apiset_unalias(a, aliases[i]);
312 y = afb_apiset_unalias(a, aliases[i + 1]);
313 ck_assert_int_eq(0, strcasecmp(x, y));
314 ck_assert_int_eq(-1, afb_apiset_add_alias(a, aliases[i + 1], aliases[i]));
315 ck_assert_int_eq(errno, EEXIST);
319 for (i = 0 ; extras[i] != NULL ; i++) {
320 pa = afb_apiset_lookup(a, extras[i], 1);
321 ck_assert_ptr_null(pa);
322 ck_assert_int_eq(errno, ENOENT);
325 /* put the onlack feature */
326 afb_apiset_onlack_set(a, onlack, &onlackcount, onlackcleanup);
330 for (i = 0 ; extras[i] != NULL ; i++) {
331 ck_assert_int_eq(onlackcount, i);
332 pa = afb_apiset_lookup(a, extras[i], 1);
333 ck_assert_int_eq(onlackcount, i + 1);
334 ck_assert_ptr_nonnull(pa);
335 ck_assert_ptr_eq(&api_itf_null, pa->itf);
336 ck_assert_ptr_eq(extras[i], pa->closure);
337 ck_assert_ptr_eq(extras[i], pa->group);
340 ck_assert_int_eq(onlackcount, i);
342 ck_assert_int_eq(onlackcount, 0);
346 /*********************************************************************/
358 { "Clarence", 0, 0 },
369 struct set_api *set_last_api;
371 void set_cb0(void *closure)
373 set_last_api = closure;
377 void set_cb_setmask(void *closure, int mask)
380 set_last_api->mask = mask;
383 int set_cb_getmask(void *closure)
386 return set_last_api->mask;
389 int set_cb_start(void *closure)
392 ck_assert_int_eq(0, set_last_api->init);
393 set_last_api->init = 1;
397 struct afb_api_itf set_api_itf = {
399 .service_start = set_cb_start,
401 .update_hooks = set_cb0,
403 .get_logmask = set_cb_getmask,
404 .set_logmask = set_cb_setmask,
409 START_TEST (check_settings)
412 struct afb_apiset *a;
413 struct afb_api_item sa;
415 /* create a apiset */
416 a = afb_apiset_create(NULL, 0);
417 ck_assert_ptr_nonnull(a);
420 for (i = 0 ; set_apis[i].name != NULL ; i++) {
421 sa.itf = &set_api_itf;
422 sa.closure = &set_apis[i];
424 ck_assert_int_eq(0, afb_apiset_add(a, set_apis[i].name, sa));
429 afb_apiset_start_all_services(a);
430 ck_assert_int_eq(nn, set_count);
434 afb_apiset_update_hooks(a, NULL);
435 ck_assert_int_eq(nn, set_count);
438 for (mask = 1 ; !(mask >> 10) ; mask <<= 1) {
440 afb_apiset_set_logmask(a, NULL, mask);
441 ck_assert_int_eq(nn, set_count);
443 for (i = 0 ; set_apis[i].name != NULL ; i++) {
444 ck_assert_int_eq(mask, afb_apiset_get_logmask(a, set_apis[i].name));
445 ck_assert_ptr_eq(set_last_api, &set_apis[i]);
446 ck_assert_int_eq(i + 1, set_count);
452 ck_assert_int_eq(nn, set_count);
456 /*********************************************************************/
469 const char *provides;
470 const char *requires;
475 { "Carma", "", "Sadie", "", 0, 9 },
476 { "Cory", "Milford", "", "Clarence", 0, 3 },
477 { "Clarence", "Milford", "", "Jeffery", 0, 2 },
478 { "Jeffery", "Milford", "", "", 0, 1 },
479 { "Molly", "Yvette", "", "Corey", 0, 6 },
480 { "Sheba", "Yvette", "Milford", "Molly", 0, 7 },
481 { "Tasha", "Sadie", "Yvette", "", 0, 8 },
482 { "Corey", "Sadie", "Milford", "Gerry", 0, 5 },
483 { "Gerry", "Sadie", "Milford", "", 0, 4 },
484 { NULL, NULL, NULL, NULL, 0, 0 }
489 int clacb_start(void *closure)
491 struct clapi *a = closure;
494 ck_assert_int_eq(0, a->init);
496 for (i = 0 ; clapi[i].name ; i++) {
497 if (a->requires && a->requires[0]
498 && clapi[i].provides && clapi[i].provides[0]
499 && !strcmp(a->requires, clapi[i].provides))
500 ck_assert_int_ne(0, clapi[i].init);
501 if (a->apireq && a->apireq[0]
502 && !strcmp(a->apireq, clapi[i].name))
503 ck_assert_int_ne(0, clapi[i].init);
506 ck_assert_int_eq(a->init, a->expect);
511 struct afb_api_itf clitf = {
513 .service_start = clacb_start,
515 .update_hooks = NULL,
523 START_TEST (check_classes)
526 struct afb_apiset *a;
527 struct afb_api_item sa;
529 /* create a apiset */
530 a = afb_apiset_create(NULL, 0);
531 ck_assert_ptr_nonnull(a);
534 for (i = 0 ; clapi[i].name != NULL ; i++) {
536 sa.closure = &clapi[i];
538 ck_assert_int_eq(0, afb_apiset_add(a, clapi[i].name, sa));
541 /* add constraints */
542 for (i = 0 ; clapi[i].name != NULL ; i++) {
543 if (clapi[i].provides && clapi[i].provides[0])
544 ck_assert_int_eq(0, afb_apiset_provide_class(a, clapi[i].name, clapi[i].provides));
545 if (clapi[i].requires && clapi[i].requires[0])
546 ck_assert_int_eq(0, afb_apiset_require_class(a, clapi[i].name, clapi[i].requires));
547 if (clapi[i].apireq && clapi[i].apireq[0])
548 ck_assert_int_eq(0, afb_apiset_require(a, clapi[i].name, clapi[i].apireq));
552 ck_assert_int_eq(0, afb_apiset_start_all_services(a));
558 /*********************************************************************/
560 START_TEST (check_subset)
563 struct afb_apiset *a, *b, *c, *d;
565 a = afb_apiset_create_subset_first(NULL, "a", 0);
566 ck_assert_ptr_nonnull(a);
567 ck_assert_str_eq("a", afb_apiset_name(a));
568 ck_assert_ptr_null(afb_apiset_subset_get(a));
570 b = afb_apiset_create_subset_first(a, "b", 0);
571 ck_assert_ptr_nonnull(b);
572 ck_assert_str_eq("b", afb_apiset_name(b));
573 ck_assert_ptr_eq(b, afb_apiset_subset_get(a));
574 ck_assert_ptr_null(afb_apiset_subset_get(b));
576 c = afb_apiset_create_subset_first(a, "c", 0);
577 ck_assert_ptr_nonnull(c);
578 ck_assert_str_eq("c", afb_apiset_name(c));
579 ck_assert_ptr_eq(c, afb_apiset_subset_get(a));
580 ck_assert_ptr_eq(b, afb_apiset_subset_get(c));
581 ck_assert_ptr_null(afb_apiset_subset_get(b));
583 d = afb_apiset_create_subset_last(a, "d", 0);
584 ck_assert_ptr_nonnull(d);
585 ck_assert_str_eq("d", afb_apiset_name(d));
586 ck_assert_ptr_eq(c, afb_apiset_subset_get(a));
587 ck_assert_ptr_eq(b, afb_apiset_subset_get(c));
588 ck_assert_ptr_eq(d, afb_apiset_subset_get(b));
589 ck_assert_ptr_null(afb_apiset_subset_get(d));
591 rc = afb_apiset_subset_set(a, b);
593 ck_assert_ptr_eq(b, afb_apiset_subset_get(a));
594 ck_assert_ptr_eq(d, afb_apiset_subset_get(b));
595 ck_assert_ptr_null(afb_apiset_subset_get(d));
601 /*********************************************************************/
606 void mksuite(const char *name) { suite = suite_create(name); }
607 void addtcase(const char *name) { tcase = tcase_create(name); suite_add_tcase(suite, tcase); }
608 void addtest(TFun fun) { tcase_add_test(tcase, fun); }
612 SRunner *srunner = srunner_create(suite);
613 srunner_run_all(srunner, CK_NORMAL);
614 nerr = srunner_ntests_failed(srunner);
615 srunner_free(srunner);
619 int main(int ac, char **av)
623 addtest(check_initialisation);
624 addtest(check_sanity);
625 addtest(check_creation);
626 addtest(check_onlack);
627 addtest(check_settings);
628 addtest(check_classes);
629 addtest(check_subset);