1 /*
2 * Authors: Jan Zarsky <[email protected]>
3 *
4 * Copyright (C) 2019 Red Hat, Inc.
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "utilities.h"
22 #include "test_user.h"
23
24 #define USER_COUNT 3
25
26 /* user_record.h */
27 static void test_user_compare(void);
28 static void test_user_compare2(void);
29 static void test_user_key_create(void);
30 static void test_user_key_extract(void);
31 static void test_user_get_set_name(void);
32 static void test_user_get_set_prefix(void);
33 static void test_user_get_set_mlslevel(void);
34 static void test_user_get_set_mlsrange(void);
35 static void test_user_roles(void);
36 static void test_user_create(void);
37 static void test_user_clone(void);
38
39 /* users_policy.h */
40 static void test_user_query(void);
41 static void test_user_exists(void);
42 static void test_user_count(void);
43 static void test_user_iterate(void);
44 static void test_user_list(void);
45
46 /* users_local.h */
47 static void test_user_modify_del_query_local(void);
48 static void test_user_exists_local(void);
49 static void test_user_count_local(void);
50 static void test_user_iterate_local(void);
51 static void test_user_list_local(void);
52
53 extern semanage_handle_t *sh;
54
user_test_init(void)55 int user_test_init(void)
56 {
57 if (create_test_store() < 0) {
58 fprintf(stderr, "Could not create test store\n");
59 return 1;
60 }
61
62 if (write_test_policy_from_file("test_user.policy") < 0) {
63 fprintf(stderr, "Could not write test policy\n");
64 return 1;
65 }
66
67 return 0;
68 }
69
user_test_cleanup(void)70 int user_test_cleanup(void)
71 {
72 if (destroy_test_store() < 0) {
73 fprintf(stderr, "Could not destroy test store\n");
74 return 1;
75 }
76
77 return 0;
78 }
79
user_add_tests(CU_pSuite suite)80 int user_add_tests(CU_pSuite suite)
81 {
82 CU_add_test(suite, "user_compare", test_user_compare);
83 CU_add_test(suite, "user_compare2", test_user_compare2);
84 CU_add_test(suite, "user_key_create", test_user_key_create);
85 CU_add_test(suite, "user_key_extract", test_user_key_extract);
86 CU_add_test(suite, "user_get_set_name", test_user_get_set_name);
87 CU_add_test(suite, "user_get_set_prefix", test_user_get_set_prefix);
88 CU_add_test(suite, "user_get_set_mlslevel", test_user_get_set_mlslevel);
89 CU_add_test(suite, "user_get_set_mlsrange", test_user_get_set_mlsrange);
90 CU_add_test(suite, "user_roles", test_user_roles);
91 CU_add_test(suite, "user_create", test_user_create);
92 CU_add_test(suite, "user_clone", test_user_clone);
93
94 CU_add_test(suite, "user_query", test_user_query);
95 CU_add_test(suite, "user_exists", test_user_exists);
96 CU_add_test(suite, "user_count", test_user_count);
97 CU_add_test(suite, "user_iterate", test_user_iterate);
98 CU_add_test(suite, "user_list", test_user_list);
99
100 CU_add_test(suite, "user_modify_del_query_local",
101 test_user_modify_del_query_local);
102 CU_add_test(suite, "user_exists_local", test_user_exists_local);
103 CU_add_test(suite, "user_count_local", test_user_count_local);
104 CU_add_test(suite, "user_iterate_local", test_user_iterate_local);
105 CU_add_test(suite, "user_list_local", test_user_list_local);
106
107 return 0;
108 }
109
110 /* Helpers */
111
get_user_nth(int idx)112 static semanage_user_t *get_user_nth(int idx)
113 {
114 int res;
115 semanage_user_t **records;
116 semanage_user_t *user;
117 unsigned int count;
118
119 if (idx == I_NULL)
120 return NULL;
121
122 res = semanage_user_list(sh, &records, &count);
123
124 CU_ASSERT_FATAL(res >= 0);
125 CU_ASSERT_FATAL(count >= (unsigned int) idx + 1);
126
127 user = records[idx];
128
129 for (unsigned int i = 0; i < count; i++)
130 if (i != (unsigned int) idx)
131 semanage_user_free(records[i]);
132
133 free(records);
134
135 return user;
136 }
137
get_user_key_nth(int idx)138 static semanage_user_key_t *get_user_key_nth(int idx)
139 {
140 semanage_user_key_t *key;
141 semanage_user_t *user;
142 int res;
143
144 if (idx == I_NULL)
145 return NULL;
146
147 user = get_user_nth(idx);
148
149 res = semanage_user_key_extract(sh, user, &key);
150
151 CU_ASSERT_FATAL(res >= 0);
152 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
153
154 semanage_user_free(user);
155
156 return key;
157 }
158
add_local_user(int user_idx)159 static void add_local_user(int user_idx)
160 {
161 semanage_user_t *user;
162 semanage_user_key_t *key = NULL;
163
164 CU_ASSERT_FATAL(user_idx != I_NULL);
165
166 user = get_user_nth(user_idx);
167
168 CU_ASSERT_FATAL(semanage_user_key_extract(sh, user, &key) >= 0);
169 CU_ASSERT_PTR_NOT_NULL_FATAL(key);
170
171 CU_ASSERT_FATAL(semanage_user_modify_local(sh, key, user) >= 0);
172
173 semanage_user_key_free(key);
174 semanage_user_free(user);
175 }
176
delete_local_user(int user_idx)177 static void delete_local_user(int user_idx)
178 {
179 semanage_user_key_t *key = NULL;
180
181 CU_ASSERT_FATAL(user_idx != I_NULL);
182
183 key = get_user_key_nth(user_idx);
184
185 CU_ASSERT_FATAL(semanage_user_del_local(sh, key) >= 0);
186
187 semanage_user_key_free(key);
188 }
189
190 /* Function semanage_user_compare */
test_user_compare(void)191 static void test_user_compare(void)
192 {
193 semanage_user_t *user = NULL;
194 semanage_user_key_t *key1 = NULL;
195 semanage_user_key_t *key2 = NULL;
196 int res = 42;
197
198 /* setup */
199 setup_handle(SH_CONNECT);
200 user = get_user_nth(I_FIRST);
201 key1 = get_user_key_nth(I_FIRST);
202 key2 = get_user_key_nth(I_SECOND);
203
204 /* test */
205 res = semanage_user_compare(user, key1);
206 CU_ASSERT(res == 0);
207 res = semanage_user_compare(user, key2);
208 CU_ASSERT(res != 0);
209
210 /* cleanup */
211 semanage_user_free(user);
212 semanage_user_key_free(key1);
213 semanage_user_key_free(key2);
214 cleanup_handle(SH_CONNECT);
215 }
216
217 /* Function semanage_user_compare2 */
test_user_compare2(void)218 static void test_user_compare2(void)
219 {
220 semanage_user_t *user1 = NULL;
221 semanage_user_t *user2 = NULL;
222 semanage_user_t *user3 = NULL;
223 int res = 42;
224
225 /* setup */
226 setup_handle(SH_CONNECT);
227 user1 = get_user_nth(I_FIRST);
228 user2 = get_user_nth(I_FIRST);
229 user3 = get_user_nth(I_SECOND);
230
231 /* test */
232 res = semanage_user_compare2(user1, user2);
233 CU_ASSERT(res == 0);
234 res = semanage_user_compare2(user1, user3);
235 CU_ASSERT(res != 0);
236
237 /* cleanup */
238 semanage_user_free(user1);
239 semanage_user_free(user2);
240 semanage_user_free(user3);
241 cleanup_handle(SH_CONNECT);
242 }
243
244 /* Function semanage_user_key_create */
test_user_key_create(void)245 static void test_user_key_create(void)
246 {
247 semanage_user_key_t *key = NULL;
248
249 /* setup */
250 setup_handle(SH_CONNECT);
251
252 /* test */
253 CU_ASSERT(semanage_user_key_create(sh, "asdf", &key) >= 0);
254 CU_ASSERT_PTR_NOT_NULL(key);
255
256 /* cleanup */
257 semanage_user_key_free(key);
258 cleanup_handle(SH_CONNECT);
259 }
260
261 /* Function semanage_user_key_extract */
test_user_key_extract(void)262 static void test_user_key_extract(void)
263 {
264 semanage_user_t *user = NULL;
265 semanage_user_key_t *key = NULL;
266
267 /* setup */
268 setup_handle(SH_CONNECT);
269 user = get_user_nth(I_FIRST);
270
271 /* test */
272 CU_ASSERT(semanage_user_key_extract(sh, user, &key) >= 0);
273 CU_ASSERT_PTR_NOT_NULL(key);
274
275 /* cleanup */
276 semanage_user_free(user);
277 semanage_user_key_free(key);
278 cleanup_handle(SH_CONNECT);
279 }
280
281 /* Function semanage_user_get_name, semanage_user_set_name */
test_user_get_set_name(void)282 static void test_user_get_set_name(void)
283 {
284 semanage_user_t *user = NULL;
285
286 /* setup */
287 setup_handle(SH_CONNECT);
288 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
289
290 /* test */
291 CU_ASSERT(semanage_user_set_name(sh, user, "user_u") == 0);
292 CU_ASSERT_STRING_EQUAL(semanage_user_get_name(user), "user_u");
293
294 /* cleanup */
295 semanage_user_free(user);
296 cleanup_handle(SH_CONNECT);
297 }
298
299 /* Function semanage_user_get_prefix, semanage_user_set_prefix */
test_user_get_set_prefix(void)300 static void test_user_get_set_prefix(void)
301 {
302 semanage_user_t *user = NULL;
303
304 /* setup */
305 setup_handle(SH_CONNECT);
306 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
307
308 /* test */
309 CU_ASSERT(semanage_user_set_prefix(sh, user, "user") == 0);
310 CU_ASSERT_STRING_EQUAL(semanage_user_get_prefix(user), "user");
311
312 /* cleanup */
313 semanage_user_free(user);
314 cleanup_handle(SH_CONNECT);
315 }
316
317 /* Function semanage_user_get_mlslevel, semanage_user_set_mlslevel */
test_user_get_set_mlslevel(void)318 static void test_user_get_set_mlslevel(void)
319 {
320 semanage_user_t *user = NULL;
321
322 /* setup */
323 setup_handle(SH_CONNECT);
324 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
325
326 /* test */
327 CU_ASSERT(semanage_user_set_mlslevel(sh, user, "s0") == 0);
328 CU_ASSERT_STRING_EQUAL(semanage_user_get_mlslevel(user), "s0");
329
330 /* cleanup */
331 semanage_user_free(user);
332 cleanup_handle(SH_CONNECT);
333 }
334
335 /* Function semanage_user_get_mlsrange, semanage_user_set_mlsrange */
test_user_get_set_mlsrange(void)336 static void test_user_get_set_mlsrange(void)
337 {
338 semanage_user_t *user = NULL;
339
340 /* setup */
341 setup_handle(SH_CONNECT);
342 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
343
344 /* test */
345 CU_ASSERT(semanage_user_set_mlsrange(sh, user, "s0-s15") == 0);
346 CU_ASSERT_STRING_EQUAL(semanage_user_get_mlsrange(user), "s0-s15");
347
348 /* cleanup */
349 semanage_user_free(user);
350 cleanup_handle(SH_CONNECT);
351 }
352
353 /* Function semanage_user_get_num_roles, semanage_user_add_role,
354 * semanage_user_del_role, semanage_user_has_role, semanage_user_get_roles
355 * semanage_user_set_roles
356 */
test_user_roles(void)357 static void test_user_roles(void)
358 {
359 semanage_user_t *user = NULL;
360 const char **roles_arr = NULL;
361 unsigned int num_roles = 42;
362 const char *new_roles_arr[] = { "new_role_r", "new_my_role_r" };
363 unsigned int new_num_roles = 2;
364
365 /* setup */
366 setup_handle(SH_CONNECT);
367 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
368
369 /* test */
370 CU_ASSERT(semanage_user_get_num_roles(user) == 0);
371
372 CU_ASSERT(semanage_user_add_role(sh, user, "role_r") == 0);
373 CU_ASSERT(semanage_user_get_num_roles(user) == 1);
374
375 CU_ASSERT(semanage_user_has_role(user, "role_r"));
376 CU_ASSERT(!semanage_user_has_role(user, "my_role_r"));
377
378 CU_ASSERT(semanage_user_add_role(sh, user, "my_role_r") == 0);
379 CU_ASSERT(semanage_user_get_num_roles(user) == 2);
380
381 CU_ASSERT(semanage_user_get_roles(sh, user, &roles_arr,
382 &num_roles) >= 0);
383 CU_ASSERT(num_roles == 2);
384 CU_ASSERT_STRING_EQUAL(roles_arr[0], "role_r");
385 CU_ASSERT_STRING_EQUAL(roles_arr[1], "my_role_r");
386
387 CU_ASSERT(semanage_user_set_roles(sh, user, new_roles_arr,
388 new_num_roles) >= 0);
389
390 CU_ASSERT(semanage_user_has_role(user, "new_role_r"));
391 CU_ASSERT(semanage_user_has_role(user, "new_my_role_r"));
392
393 CU_ASSERT(!semanage_user_has_role(user, "role_r"));
394 CU_ASSERT(!semanage_user_has_role(user, "my_role_r"));
395
396 semanage_user_del_role(user, "new_my_role_r");
397 CU_ASSERT(semanage_user_get_num_roles(user) == 1);
398
399 semanage_user_del_role(user, "new_role_r");
400 CU_ASSERT(semanage_user_get_num_roles(user) == 0);
401
402 /* cleanup */
403 free(roles_arr);
404 semanage_user_free(user);
405 cleanup_handle(SH_CONNECT);
406 }
407
408 /* Function semanage_user_create */
test_user_create(void)409 static void test_user_create(void)
410 {
411 semanage_user_t *user = NULL;
412
413 /* setup */
414 setup_handle(SH_CONNECT);
415
416 /* test */
417 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
418 CU_ASSERT(semanage_user_set_name(sh, user, "user_u") >= 0);
419 CU_ASSERT(semanage_user_set_prefix(sh, user, "user") >= 0);
420 CU_ASSERT(semanage_user_set_mlslevel(sh, user, "s0") >= 0);
421 CU_ASSERT(semanage_user_set_mlsrange(sh, user, "s0-s15") >= 0);
422
423 /* cleanup */
424 semanage_user_free(user);
425 cleanup_handle(SH_CONNECT);
426 }
427
428 /* Function semanage_user_clone */
test_user_clone(void)429 static void test_user_clone(void)
430 {
431 semanage_user_t *user = NULL;
432 semanage_user_t *user_clone = NULL;
433
434 /* setup */
435 setup_handle(SH_CONNECT);
436 CU_ASSERT(semanage_user_create(sh, &user) >= 0);
437 CU_ASSERT(semanage_user_set_name(sh, user, "user_u") >= 0);
438 CU_ASSERT(semanage_user_set_prefix(sh, user, "user") >= 0);
439 CU_ASSERT(semanage_user_set_mlslevel(sh, user, "s0") >= 0);
440 CU_ASSERT(semanage_user_set_mlsrange(sh, user, "s0-s15") >= 0);
441
442 /* test */
443 CU_ASSERT(semanage_user_clone(sh, user, &user_clone) >= 0);
444 CU_ASSERT_STRING_EQUAL(semanage_user_get_name(user), "user_u");
445 CU_ASSERT_STRING_EQUAL(semanage_user_get_prefix(user), "user");
446 CU_ASSERT_STRING_EQUAL(semanage_user_get_mlslevel(user), "s0");
447 CU_ASSERT_STRING_EQUAL(semanage_user_get_mlsrange(user), "s0-s15");
448
449 /* cleanup */
450 semanage_user_free(user);
451 semanage_user_free(user_clone);
452 cleanup_handle(SH_CONNECT);
453 }
454
455 /* Function semanage_user_query */
test_user_query(void)456 static void test_user_query(void)
457 {
458 semanage_user_t *user = NULL;
459 semanage_user_key_t *key = NULL;
460
461 /* setup */
462 setup_handle(SH_CONNECT);
463 key = get_user_key_nth(I_FIRST);
464
465 /* test */
466 CU_ASSERT(semanage_user_query(sh, key, &user) >= 0);
467
468 /* TODO: test values */
469 CU_ASSERT_PTR_NOT_NULL(user);
470
471 /* cleanup */
472 semanage_user_key_free(key);
473 semanage_user_free(user);
474 cleanup_handle(SH_CONNECT);
475 }
476
477 /* Function semanage_user_exists */
test_user_exists(void)478 static void test_user_exists(void)
479 {
480 semanage_user_key_t *key1 = NULL;
481 semanage_user_key_t *key2 = NULL;
482 int resp = 42;
483
484 /* setup */
485 setup_handle(SH_CONNECT);
486 key1 = get_user_key_nth(I_FIRST);
487 CU_ASSERT(semanage_user_key_create(sh, "asdf", &key2) >= 0);
488
489 /* test */
490 CU_ASSERT(semanage_user_exists(sh, key1, &resp) >= 0);
491 CU_ASSERT(resp);
492 CU_ASSERT(semanage_user_exists(sh, key2, &resp) >= 0);
493 CU_ASSERT(!resp);
494
495 /* cleanup */
496 semanage_user_key_free(key1);
497 semanage_user_key_free(key2);
498 cleanup_handle(SH_CONNECT);
499 }
500
501 /* Function semanage_user_count */
test_user_count(void)502 static void test_user_count(void)
503 {
504 unsigned int count = 42;
505
506 /* setup */
507 setup_handle(SH_CONNECT);
508
509 /* test */
510 CU_ASSERT(semanage_user_count(sh, &count) >= 0);
511 CU_ASSERT(count == USER_COUNT);
512
513 /* cleanup */
514 cleanup_handle(SH_CONNECT);
515 }
516
517 /* Function semanage_user_iterate */
518 unsigned int counter_user_iterate = 0;
519
handler_user_iterate(const semanage_user_t * record,void * varg)520 static int handler_user_iterate(const semanage_user_t *record, void *varg)
521 {
522 counter_user_iterate++;
523 return 0;
524 }
525
test_user_iterate(void)526 static void test_user_iterate(void)
527 {
528 /* setup */
529 setup_handle(SH_CONNECT);
530
531 /* test */
532 semanage_user_iterate(sh, handler_user_iterate, NULL);
533 CU_ASSERT(counter_user_iterate == USER_COUNT);
534
535 /* cleanup */
536 cleanup_handle(SH_CONNECT);
537 }
538
539 /* Function semanage_user_list */
test_user_list(void)540 static void test_user_list(void)
541 {
542 semanage_user_t **records = NULL;
543 unsigned int count = 42;
544
545 /* setup */
546 setup_handle(SH_CONNECT);
547
548 /* test */
549 CU_ASSERT(semanage_user_list(sh, &records, &count) >= 0);
550 CU_ASSERT(count == USER_COUNT);
551
552 /* TODO: check real values */
553 for (unsigned int i = 0; i < count; i++)
554 CU_ASSERT_PTR_NOT_NULL(records[i]);
555
556 /* cleanup */
557 for (unsigned int i = 0; i < count; i++)
558 semanage_user_free(records[i]);
559
560 free(records);
561
562 cleanup_handle(SH_CONNECT);
563 }
564
565 /* Function semanage_user_modify_local, semanage_user_del_local,
566 * semanage_user_query_local
567 */
test_user_modify_del_query_local(void)568 static void test_user_modify_del_query_local(void)
569 {
570 semanage_user_t *user;
571 semanage_user_t *user_local;
572 semanage_user_key_t *key = NULL;
573
574 /* setup */
575 setup_handle(SH_TRANS);
576 user = get_user_nth(I_FIRST);
577 CU_ASSERT(semanage_user_key_extract(sh, user, &key) >= 0);
578 CU_ASSERT_PTR_NOT_NULL(key);
579
580 /* test */
581 CU_ASSERT(semanage_user_modify_local(sh, key, user) >= 0);
582
583 /* write changes to file */
584 helper_commit();
585 helper_begin_transaction();
586
587 CU_ASSERT(semanage_user_query_local(sh, key, &user_local) >= 0);
588 CU_ASSERT_PTR_NOT_NULL_FATAL(user_local);
589 semanage_user_free(user_local);
590 CU_ASSERT(semanage_user_del_local(sh, key) >= 0);
591 CU_ASSERT(semanage_user_query_local(sh, key, &user_local) < 0);
592
593 /* cleanup */
594 semanage_user_key_free(key);
595 semanage_user_free(user);
596 cleanup_handle(SH_TRANS);
597 }
598
599 /* Function semanage_user_exists_local */
test_user_exists_local(void)600 static void test_user_exists_local(void)
601 {
602 semanage_user_t *user = NULL;
603 semanage_user_key_t *key1 = NULL;
604 semanage_user_key_t *key2 = NULL;
605 int resp = 42;
606
607 /* setup */
608 setup_handle(SH_TRANS);
609 add_local_user(I_FIRST);
610 key1 = get_user_key_nth(I_FIRST);
611 CU_ASSERT(semanage_user_key_create(sh, "asdf", &key2) >= 0);
612 CU_ASSERT_PTR_NOT_NULL(key2);
613
614 /* test */
615 CU_ASSERT(semanage_user_exists_local(sh, key1, &resp) >= 0);
616 CU_ASSERT(resp);
617 CU_ASSERT(semanage_user_exists_local(sh, key2, &resp) >= 0);
618 CU_ASSERT(!resp);
619
620 /* cleanup */
621 CU_ASSERT(semanage_user_del_local(sh, key1) >= 0);
622 semanage_user_free(user);
623 semanage_user_key_free(key1);
624 semanage_user_key_free(key2);
625 cleanup_handle(SH_TRANS);
626 }
627
628 /* Function semanage_user_count_local */
test_user_count_local(void)629 static void test_user_count_local(void)
630 {
631 unsigned int count = 42;
632
633 /* setup */
634 setup_handle(SH_TRANS);
635 add_local_user(I_FIRST);
636 add_local_user(I_SECOND);
637 add_local_user(I_THIRD);
638
639 /* test */
640 CU_ASSERT(semanage_user_count_local(sh, &count) >= 0);
641 CU_ASSERT(count == 3);
642
643 /* cleanup */
644 delete_local_user(I_FIRST);
645 delete_local_user(I_SECOND);
646 delete_local_user(I_THIRD);
647 cleanup_handle(SH_TRANS);
648 }
649
650 /* Function semanage_user_iterate_local */
651 unsigned int counter_user_iterate_local = 0;
652
handler_user_iterate_local(const semanage_user_t * record,void * varg)653 static int handler_user_iterate_local(const semanage_user_t *record, void *varg)
654 {
655 counter_user_iterate_local++;
656 return 0;
657 }
658
test_user_iterate_local(void)659 static void test_user_iterate_local(void)
660 {
661 /* setup */
662 setup_handle(SH_TRANS);
663 add_local_user(I_FIRST);
664 add_local_user(I_SECOND);
665 add_local_user(I_THIRD);
666
667 /* test */
668 semanage_user_iterate_local(sh, handler_user_iterate_local, NULL);
669 CU_ASSERT(counter_user_iterate_local == 3);
670
671 /* cleanup */
672 delete_local_user(I_FIRST);
673 delete_local_user(I_SECOND);
674 delete_local_user(I_THIRD);
675 cleanup_handle(SH_TRANS);
676 }
677
678 /* Function semanage_user_list_local */
test_user_list_local(void)679 static void test_user_list_local(void)
680 {
681 semanage_user_t **records = NULL;
682 unsigned int count = 42;
683
684 /* setup */
685 setup_handle(SH_TRANS);
686 add_local_user(I_FIRST);
687 add_local_user(I_SECOND);
688 add_local_user(I_THIRD);
689
690 /* test */
691 CU_ASSERT(semanage_user_list_local(sh, &records, &count) >= 0);
692 CU_ASSERT(count == 3);
693
694 for (unsigned int i = 0; i < count; i++)
695 CU_ASSERT_PTR_NOT_NULL(records[i]);
696
697 /* cleanup */
698 for (unsigned int i = 0; i < count; i++)
699 semanage_user_free(records[i]);
700
701 free(records);
702
703 delete_local_user(I_FIRST);
704 delete_local_user(I_SECOND);
705 delete_local_user(I_THIRD);
706 cleanup_handle(SH_TRANS);
707 }
708