1 /* Authors: Mark Goldman <mgoldman@tresys.com>
2 *
3 * Copyright (C) 2007 Tresys Technology, LLC
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 /* The purpose of this file is to provide unit tests of the functions in:
21 *
22 * libsemanage/src/utilities.c
23 *
24 */
25
26 #include <CUnit/Basic.h>
27 #include <CUnit/Console.h>
28 #include <CUnit/TestDB.h>
29
30 #include <utilities.h>
31 #include <stdio.h>
32 #include <getopt.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <unistd.h>
36
37 #include "utilities.h"
38
39 void test_semanage_is_prefix(void);
40 void test_semanage_split_on_space(void);
41 void test_semanage_split(void);
42 void test_semanage_list(void);
43 void test_semanage_str_count(void);
44 void test_semanage_rtrim(void);
45 void test_semanage_str_replace(void);
46 void test_semanage_findval(void);
47 void test_slurp_file_filter(void);
48
49 char fname[] = {
50 'T', 'E', 'S', 'T', '_', 'T', 'E', 'M', 'P', '_', 'X', 'X', 'X', 'X',
51 'X', 'X', '\0'
52 };
53 int fd;
54 FILE *fptr;
55
semanage_utilities_test_init(void)56 int semanage_utilities_test_init(void)
57 {
58 fd = mkstemp(fname);
59
60 if (fd < 0) {
61 perror("test_semanage_findval: ");
62 CU_FAIL_FATAL
63 ("Error opening temporary file, test cannot start.");
64 }
65
66 fptr = fdopen(fd, "w+");
67 if (!fptr) {
68 perror("test_semanage_findval file: ");
69 CU_FAIL_FATAL("Error opening file stream, test cannot start.");
70 }
71
72 fprintf(fptr, "one\ntwo\nthree\nsigma=foo\n#boo\n#bar\n");
73
74 rewind(fptr);
75 return 0;
76 }
77
semanage_utilities_test_cleanup(void)78 int semanage_utilities_test_cleanup(void)
79 {
80 unlink(fname);
81 return 0;
82 }
83
semanage_utilities_add_tests(CU_pSuite suite)84 int semanage_utilities_add_tests(CU_pSuite suite)
85 {
86 if (NULL == CU_add_test(suite, "semanage_is_prefix",
87 test_semanage_is_prefix)) {
88 goto err;
89 }
90 if (NULL == CU_add_test(suite, "semanage_split_on_space",
91 test_semanage_split_on_space)) {
92 goto err;
93 }
94 if (NULL == CU_add_test(suite, "semanage_split", test_semanage_split)) {
95 goto err;
96 }
97 if (NULL == CU_add_test(suite, "semanage_list", test_semanage_list)) {
98 goto err;
99 }
100 if (NULL == CU_add_test(suite, "semanage_str_count",
101 test_semanage_str_count)) {
102 goto err;
103 }
104 if (NULL == CU_add_test(suite, "semanage_rtrim", test_semanage_rtrim)) {
105 goto err;
106 }
107 if (NULL == CU_add_test(suite, "semanage_str_replace",
108 test_semanage_str_replace)) {
109 goto err;
110 }
111 if (NULL == CU_add_test(suite, "semanage_findval",
112 test_semanage_findval)) {
113 goto err;
114 }
115 if (NULL == CU_add_test(suite, "slurp_file_filter",
116 test_slurp_file_filter)) {
117 goto err;
118 }
119 return 0;
120 err:
121 CU_cleanup_registry();
122 return CU_get_error();
123 }
124
test_semanage_is_prefix(void)125 void test_semanage_is_prefix(void)
126 {
127 const char *str = "some string";
128 const char *pre = "some";
129 const char *not_pre = "not this";
130
131 CU_ASSERT_TRUE(semanage_is_prefix(str, pre));
132 CU_ASSERT_TRUE(semanage_is_prefix(str, ""));
133 CU_ASSERT_TRUE(semanage_is_prefix(str, NULL));
134 CU_ASSERT_FALSE(semanage_is_prefix(str, not_pre));
135 }
136
test_semanage_split_on_space(void)137 void test_semanage_split_on_space(void)
138 {
139 char *str = strdup(" foo bar baz");
140 char *temp;
141
142 if (!str) {
143 CU_FAIL
144 ("semanage_split_on_space: unable to perform test, no memory");
145 return;
146 }
147 temp = semanage_split_on_space(str);
148 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
149 CU_ASSERT_STRING_EQUAL(temp, "bar baz");
150 free(str);
151 str = temp;
152
153 temp = semanage_split_on_space(str);
154 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
155 CU_ASSERT_STRING_EQUAL(temp, "baz");
156 free(str);
157 str = temp;
158
159 temp = semanage_split_on_space(str);
160 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
161 CU_ASSERT_STRING_EQUAL(temp, "");
162 free(str);
163 free(temp);
164 }
165
test_semanage_split(void)166 void test_semanage_split(void)
167 {
168 char *str = strdup("foo1 foo2 foo:bar:");
169 char *temp;
170
171 if (!str) {
172 CU_FAIL
173 ("semanage_split_on_space: unable to perform test, no memory");
174 return;
175 }
176 temp = semanage_split(str, NULL);
177 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
178 CU_ASSERT_STRING_EQUAL(temp, "foo2 foo:bar:");
179 free(str);
180 str = temp;
181
182 temp = semanage_split(str, "");
183 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
184 CU_ASSERT_STRING_EQUAL(temp, "foo:bar:");
185 free(str);
186 str = temp;
187
188 temp = semanage_split(str, ":");
189 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
190 CU_ASSERT_STRING_EQUAL(temp, "bar:");
191 free(str);
192 str = temp;
193
194 temp = semanage_split(str, ":");
195 CU_ASSERT_PTR_NOT_NULL_FATAL(temp);
196 CU_ASSERT_STRING_EQUAL(temp, "");
197 free(str);
198 free(temp);
199 }
200
test_semanage_list(void)201 void test_semanage_list(void)
202 {
203 semanage_list_t *list = NULL;
204 semanage_list_t *ptr = NULL;
205 char *temp = NULL;
206 int retval = 0;
207
208 CU_ASSERT_FALSE(semanage_list_push(&list, "foo"));
209 CU_ASSERT_PTR_NOT_NULL(list);
210 CU_ASSERT_FALSE(semanage_list_push(&list, "bar"));
211 CU_ASSERT_FALSE(semanage_list_push(&list, "gonk"));
212 CU_ASSERT_FALSE(semanage_list_push(&list, "zebra"));
213
214 for (ptr = list; ptr; ptr = ptr->next)
215 retval++;
216 CU_ASSERT_EQUAL(retval, 4);
217
218 temp = semanage_list_pop(&list);
219 CU_ASSERT_STRING_EQUAL(temp, "zebra");
220 CU_ASSERT_FALSE(semanage_list_push(&list, temp));
221 free(temp);
222 temp = NULL;
223
224 retval = 0;
225 for (ptr = list; ptr; ptr = ptr->next)
226 retval++;
227 CU_ASSERT_EQUAL(retval, 4);
228
229 retval = semanage_list_sort(&list);
230 if (retval) {
231 CU_FAIL
232 ("semanage_list_sort: error unrelated to sort (memory?)");
233 goto past_sort;
234 }
235 CU_ASSERT_STRING_EQUAL(list->data, "bar");
236 CU_ASSERT_STRING_EQUAL(list->next->data, "foo");
237 CU_ASSERT_STRING_EQUAL(list->next->next->data, "gonk");
238 CU_ASSERT_STRING_EQUAL(list->next->next->next->data, "zebra");
239
240 past_sort:
241 ptr = semanage_list_find(list, "zebra");
242 CU_ASSERT_PTR_NOT_NULL(ptr);
243 ptr = semanage_list_find(list, "bogus");
244 CU_ASSERT_PTR_NULL(ptr);
245
246 semanage_list_destroy(&list);
247 CU_ASSERT_PTR_NULL(list);
248 }
249
test_semanage_str_count(void)250 void test_semanage_str_count(void)
251 {
252 const char *test_string = "abaababbaaaba";
253
254 CU_ASSERT_EQUAL(semanage_str_count(test_string, 'z'), 0);
255 CU_ASSERT_EQUAL(semanage_str_count(test_string, 'a'), 8);
256 CU_ASSERT_EQUAL(semanage_str_count(test_string, 'b'), 5);
257 }
258
test_semanage_rtrim(void)259 void test_semanage_rtrim(void)
260 {
261 char *str = strdup("/blah/foo/bar/baz/");
262
263 CU_ASSERT_PTR_NOT_NULL_FATAL(str);
264
265 semanage_rtrim(str, 'Q');
266 CU_ASSERT_STRING_EQUAL(str, "/blah/foo/bar/baz/");
267 semanage_rtrim(str, 'a');
268 CU_ASSERT_STRING_EQUAL(str, "/blah/foo/bar/b");
269 semanage_rtrim(str, '/');
270 CU_ASSERT_STRING_EQUAL(str, "/blah/foo/bar");
271
272 free(str);
273 }
274
test_semanage_str_replace(void)275 void test_semanage_str_replace(void)
276 {
277 const char *test_str = "Hello, I am %{USERNAME} and my id is %{USERID}";
278 char *str1, *str2;
279
280 str1 = semanage_str_replace("%{USERNAME}", "root", test_str, 0);
281 CU_ASSERT_STRING_EQUAL(str1, "Hello, I am root and my id is %{USERID}");
282
283 str2 = semanage_str_replace("%{USERID}", "0", str1, 1);
284 CU_ASSERT_STRING_EQUAL(str2, "Hello, I am root and my id is 0");
285 free(str1);
286 free(str2);
287
288 str1 = semanage_str_replace(":(", ";)", "Test :( :) ! :(:(:))(:(", 0);
289 CU_ASSERT_STRING_EQUAL(str1, "Test ;) :) ! ;);):))(;)");
290 free(str1);
291
292 str1 = semanage_str_replace(":(", ";)", "Test :( :) ! :(:(:))(:(", 3);
293 CU_ASSERT_STRING_EQUAL(str1, "Test ;) :) ! ;);):))(:(");
294 free(str1);
295
296 str1 = semanage_str_replace("", "empty search string", "test", 0);
297 CU_ASSERT_EQUAL(str1, NULL);
298
299 str1 = semanage_str_replace("a", "", "abracadabra", 0);
300 CU_ASSERT_STRING_EQUAL(str1, "brcdbr");
301 free(str1);
302 }
303
test_semanage_findval(void)304 void test_semanage_findval(void)
305 {
306 char *tok;
307 if (!fptr) {
308 CU_FAIL_FATAL("Temporary file was not created, aborting test.");
309 }
310 tok = semanage_findval(fname, "one", NULL);
311 CU_ASSERT_PTR_NOT_NULL_FATAL(tok);
312 CU_ASSERT_STRING_EQUAL(tok, "");
313 free(tok);
314 rewind(fptr);
315 tok = semanage_findval(fname, "one", "");
316 CU_ASSERT_PTR_NOT_NULL_FATAL(tok);
317 CU_ASSERT_STRING_EQUAL(tok, "");
318 free(tok);
319 rewind(fptr);
320 tok = semanage_findval(fname, "sigma", "=");
321 CU_ASSERT_PTR_NOT_NULL_FATAL(tok);
322 CU_ASSERT_STRING_EQUAL(tok, "foo");
323 free(tok);
324 }
325
PREDICATE(const char * str)326 int PREDICATE(const char *str)
327 {
328 return semanage_is_prefix(str, "#");
329 }
330
test_slurp_file_filter(void)331 void test_slurp_file_filter(void)
332 {
333 semanage_list_t *data, *tmp;
334 int cnt = 0;
335
336 if (!fptr) {
337 CU_FAIL_FATAL("Temporary file was not created, aborting test.");
338 }
339 rewind(fptr);
340 data = semanage_slurp_file_filter(fptr, PREDICATE);
341 CU_ASSERT_PTR_NOT_NULL_FATAL(data);
342 for (tmp = data; tmp; tmp = tmp->next)
343 cnt++;
344 CU_ASSERT_EQUAL(cnt, 2);
345
346 semanage_list_destroy(&data);
347 }
348