Line data Source code
1 : /*
2 : path_utils - unit tests
3 :
4 : Authors:
5 : Jakub Hrozek <jhrozek@redhat.com>
6 :
7 : Copyright (C) 2009 Red Hat
8 :
9 : This program is free software; you can redistribute it and/or modify
10 : it under the terms of the GNU General Public License as published by
11 : the Free Software Foundation; either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : This program is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU General Public License for more details.
18 :
19 : You should have received a copy of the GNU General Public License
20 : along with this program. If not, see <http://www.gnu.org/licenses/>.
21 : */
22 :
23 : #include "config.h"
24 :
25 : #include <check.h>
26 : #include <stdlib.h>
27 : #include <stdio.h>
28 : #include <unistd.h>
29 : #include <errno.h>
30 :
31 : #include "path_utils.h"
32 :
33 : #define fail_unless_str_equal(a, b) do { \
34 : fail_unless(strcmp(a, b) == 0, \
35 : "The strings '%s' and '%s' are different, expected same", \
36 : a, b); \
37 : } while(0);
38 :
39 : #define DIR_TEMPLATE "test-directory-list-dir-XXXXXX"
40 : #define SUBDIR "test-directory-list-subdir"
41 : #define SUBSUBDIR "test-directory-list-subsubdir"
42 : char *dlist_dir;
43 : char *dlist_subdir;
44 : char *dlist_subsubdir;
45 :
46 : /**** get_dirname ****/
47 1 : START_TEST(test_dirname)
48 : {
49 : char p[PATH_MAX];
50 : char cwd[PATH_MAX];
51 :
52 1 : fail_unless(get_dirname(p, PATH_MAX, "/foo/bar") == SUCCESS);
53 1 : fail_unless_str_equal(p, "/foo");
54 :
55 1 : fail_unless(get_dirname(p, PATH_MAX, "/") == SUCCESS);
56 1 : fail_unless_str_equal(p, "/");
57 :
58 1 : fail_unless(get_dirname(p, PATH_MAX, "/foo") == SUCCESS);
59 1 : fail_unless_str_equal(p, "/");
60 :
61 1 : fail_unless(get_dirname(p, PATH_MAX, "//foo//bar") == SUCCESS);
62 1 : fail_unless_str_equal(p, "//foo");
63 :
64 1 : fail_unless(get_dirname(p, PATH_MAX, "//foo//") == SUCCESS);
65 1 : fail_unless_str_equal(p, "//");
66 :
67 1 : fail_unless(get_dirname(p, PATH_MAX, "foo//bar") == SUCCESS);
68 1 : fail_unless_str_equal(p, "foo");
69 :
70 1 : fail_unless(get_dirname(p, PATH_MAX, "foo//////bar") == SUCCESS);
71 1 : fail_unless_str_equal(p, "foo");
72 :
73 : /* if pathname does not contain a slash, dirname returns cwd */
74 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
75 :
76 1 : fail_unless(get_dirname(p, PATH_MAX, "foo") == SUCCESS);
77 1 : fail_unless_str_equal(p, cwd);
78 :
79 1 : fail_unless(get_dirname(p, PATH_MAX, ".") == SUCCESS);
80 1 : fail_unless_str_equal(p, cwd);
81 :
82 1 : fail_unless(get_dirname(p, PATH_MAX, "..") == SUCCESS);
83 1 : fail_unless_str_equal(p, cwd);
84 :
85 1 : fail_unless(get_dirname(p, PATH_MAX, "") == SUCCESS);
86 1 : fail_unless_str_equal(p, cwd);
87 : }
88 1 : END_TEST
89 :
90 1 : START_TEST(test_dirname_neg)
91 : {
92 : char neg[3];
93 : char p[PATH_MAX];
94 :
95 1 : fail_if(get_dirname(neg, 3, "/foo/bar") == SUCCESS);
96 1 : fail_unless(get_dirname(p, PATH_MAX, NULL) == EINVAL);
97 : }
98 1 : END_TEST
99 :
100 : /**** get_basename ****/
101 1 : START_TEST(test_basename)
102 : {
103 : char p[PATH_MAX];
104 : char cwd[PATH_MAX];
105 :
106 1 : fail_unless(get_basename(p, PATH_MAX, "/foo/bar") == SUCCESS);
107 1 : fail_unless_str_equal(p, "bar");
108 :
109 1 : fail_unless(get_basename(p, PATH_MAX, "/foo/") == SUCCESS);
110 1 : fail_unless_str_equal(p, "foo");
111 :
112 1 : fail_unless(get_basename(p, PATH_MAX, "foo") == SUCCESS);
113 1 : fail_unless_str_equal(p, "foo");
114 :
115 1 : fail_unless(get_basename(p, PATH_MAX, "/") == SUCCESS);
116 1 : fail_unless_str_equal(p, "/");
117 :
118 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
119 :
120 1 : fail_unless(get_basename(p, PATH_MAX, ".") == SUCCESS);
121 1 : fail_unless_str_equal(p, cwd);
122 :
123 1 : fail_unless(get_basename(p, PATH_MAX, "") == SUCCESS);
124 1 : fail_unless_str_equal(p, cwd);
125 : }
126 1 : END_TEST
127 :
128 1 : START_TEST(test_basename_neg)
129 : {
130 : char neg[3];
131 : char p[PATH_MAX];
132 :
133 1 : fail_if(get_basename(neg, 3, "/foo/bar") == SUCCESS);
134 :
135 1 : fail_unless(get_basename(p, PATH_MAX, NULL) == EINVAL);
136 : }
137 1 : END_TEST
138 :
139 : /**** is_absolute_path ****/
140 1 : START_TEST(test_is_absolute_path)
141 : {
142 1 : fail_unless(is_absolute_path("") == false);
143 1 : fail_unless(is_absolute_path("foo/bar") == false);
144 :
145 1 : fail_unless(is_absolute_path("/foo/bar") == true);
146 1 : fail_unless(is_absolute_path("/foo") == true);
147 1 : fail_unless(is_absolute_path("/") == true);
148 : }
149 1 : END_TEST
150 :
151 : /**** get_dirname_and_basename ****/
152 : /* Just a couple of basic tests - get_dirname_and_basename()
153 : * uses get_dirname() and get_basename() under the hood which
154 : * are tested enough in their specific tests
155 : */
156 1 : START_TEST(test_dirname_and_basename)
157 : {
158 : char dir[PATH_MAX];
159 : char base[PATH_MAX];
160 : char cwd[PATH_MAX];
161 : int ret;
162 :
163 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, "/foo/bar");
164 1 : fail_unless(ret == SUCCESS);
165 1 : fail_unless_str_equal(dir, "/foo");
166 1 : fail_unless_str_equal(base, "bar");
167 :
168 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, "/foo");
169 1 : fail_unless(ret == SUCCESS);
170 1 : fail_unless_str_equal(dir, "/");
171 1 : fail_unless_str_equal(base, "foo");
172 :
173 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, "/");
174 1 : fail_unless(ret == SUCCESS);
175 1 : fail_unless_str_equal(dir, "/");
176 1 : fail_unless_str_equal(base, "/");
177 :
178 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
179 :
180 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, "foo");
181 1 : fail_unless(ret == SUCCESS);
182 1 : fail_unless_str_equal(dir, cwd);
183 1 : fail_unless_str_equal(base, "foo");
184 :
185 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, "");
186 1 : fail_unless(ret == SUCCESS);
187 1 : fail_unless_str_equal(dir, cwd);
188 1 : fail_unless_str_equal(base, "");
189 :
190 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, ".");
191 1 : fail_unless(ret == SUCCESS);
192 1 : fail_unless_str_equal(dir, cwd);
193 1 : fail_unless_str_equal(base, "");
194 : }
195 1 : END_TEST
196 :
197 1 : START_TEST(test_dirname_and_basename_neg)
198 : {
199 : char dir[PATH_MAX];
200 : char base[PATH_MAX];
201 : int ret;
202 :
203 1 : ret = get_directory_and_base_name(dir, PATH_MAX, base, PATH_MAX, NULL);
204 1 : fail_unless(ret == EINVAL);
205 : }
206 1 : END_TEST
207 :
208 : /**** path_concat ****/
209 1 : START_TEST(test_path_concat)
210 : {
211 : char p[PATH_MAX];
212 : char p2[9];
213 :
214 1 : fail_unless(path_concat(p, PATH_MAX, "/foo", "bar") == SUCCESS);
215 1 : fail_unless_str_equal(p, "/foo/bar");
216 :
217 1 : fail_unless(path_concat(p, PATH_MAX, "/foo", "/bar") == SUCCESS);
218 1 : fail_unless_str_equal(p, "/foo/bar");
219 :
220 1 : fail_unless(path_concat(p, PATH_MAX, "/foo/", "/bar") == SUCCESS);
221 1 : fail_unless_str_equal(p, "/foo/bar");
222 :
223 1 : fail_unless(path_concat(p, PATH_MAX, "/foo", "") == SUCCESS);
224 1 : fail_unless_str_equal(p, "/foo");
225 :
226 1 : fail_unless(path_concat(p, PATH_MAX, "foo", NULL) == SUCCESS);
227 1 : fail_unless_str_equal(p, "foo");
228 :
229 1 : fail_unless(path_concat(p, PATH_MAX, "", "foo") == SUCCESS);
230 1 : fail_unless_str_equal(p, "foo");
231 :
232 1 : fail_unless(path_concat(p, PATH_MAX, "/", "foo") == SUCCESS);
233 1 : fail_unless_str_equal(p, "/foo");
234 :
235 1 : fail_unless(path_concat(p, PATH_MAX, "/foo", "/") == SUCCESS);
236 1 : fail_unless_str_equal(p, "/foo/");
237 :
238 1 : fail_unless(path_concat(p, PATH_MAX, "/foo", "bar/") == SUCCESS);
239 1 : fail_unless_str_equal(p, "/foo/bar/");
240 :
241 1 : fail_unless(path_concat(p, PATH_MAX, NULL, "foo") == SUCCESS);
242 1 : fail_unless_str_equal(p, "foo");
243 :
244 : /* on-by-one */
245 1 : fail_unless(path_concat(p2, 9, "/foo", "bar") == SUCCESS);
246 1 : fail_unless_str_equal(p2, "/foo/bar");
247 : }
248 1 : END_TEST
249 :
250 1 : START_TEST(test_path_concat_neg)
251 : {
252 : char small[3];
253 : char small2[5];
254 : char small3[7];
255 : char p2[10];
256 :
257 : /* these two test different conditions */
258 :
259 : /* Test if head is longer than the buffer */
260 1 : fail_unless(path_concat(small, 3, "/foo", "bar") == ENOBUFS);
261 : /* On ENOBUFS, path should be empty */
262 1 : fail_unless_str_equal(small, "");
263 :
264 : /* Test if head is the same length as the buffer */
265 1 : fail_unless(path_concat(small2, 5, "/foo", "bar") == ENOBUFS);
266 : /* On ENOBUFS, path should be empty */
267 1 : fail_unless_str_equal(small2, "");
268 :
269 : /* Test if head+tail is the longer than the buffer */
270 1 : fail_unless(path_concat(small3, 7, "/foo", "bar") == ENOBUFS);
271 : /* On ENOBUFS, path should be empty */
272 1 : fail_unless_str_equal(small3, "");
273 :
274 : /* off-by-one */
275 : /* Fill with garbage data for now */
276 1 : memset(p2, 'Z', 9);
277 1 : p2[9] = '\0';
278 :
279 1 : fail_unless(path_concat(p2, 8, "/foo", "bar") == ENOBUFS);
280 : /* Make sure we don't write past the end of the buffer */
281 1 : fail_unless(p2[8] == 'Z', "Got [%d]", p2[8]);
282 : /* On ENOBUFS, path should be empty */
283 1 : fail_unless_str_equal(p2, "");
284 : }
285 1 : END_TEST
286 :
287 : /**** make_path_absolute ****/
288 1 : START_TEST(test_make_path_absolute)
289 : {
290 : char p[PATH_MAX];
291 : char p2[PATH_MAX];
292 : char cwd[PATH_MAX];
293 : char *buf;
294 : size_t buf_len;
295 :
296 1 : fail_unless(make_path_absolute(p, PATH_MAX, "/foo") == SUCCESS);
297 1 : fail_unless_str_equal(p, "/foo");
298 :
299 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
300 :
301 1 : fail_unless(make_path_absolute(p, PATH_MAX, "foo") == SUCCESS);
302 1 : snprintf(p2, PATH_MAX, "%s/foo", cwd);
303 1 : fail_unless_str_equal(p, p2);
304 :
305 1 : fail_unless(make_path_absolute(p, PATH_MAX, "") == SUCCESS);
306 1 : fail_unless_str_equal(p, cwd);
307 :
308 : /* on-by-one; 2 = terminating null + path delimeter */
309 1 : buf_len = strlen(cwd) + strlen("foo") + 2;
310 1 : buf = malloc(buf_len);
311 1 : fail_if(buf == NULL);
312 1 : fail_unless(make_path_absolute(buf, buf_len, "foo") == SUCCESS);
313 1 : free(buf);
314 : }
315 1 : END_TEST
316 :
317 1 : START_TEST(test_make_path_absolute_neg)
318 : {
319 : char small[1];
320 : char cwd[PATH_MAX];
321 : char *small2;
322 : int small_len;
323 :
324 1 : fail_unless(make_path_absolute(small, 1, "/foo") == ENOBUFS);
325 1 : fail_unless(make_path_absolute(NULL, 1, "/foo") == ENOBUFS);
326 :
327 : /* off-by-one */
328 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
329 1 : small_len = strlen(cwd) + strlen("foo") + 1;
330 1 : small2 = malloc(small_len);
331 1 : fail_if(small2 == NULL);
332 1 : fail_unless(make_path_absolute(small2, small_len, "foo") == ENOBUFS);
333 1 : free(small2);
334 :
335 : /* just enough space for cwd */
336 1 : small_len = strlen(cwd) + 1;
337 1 : small2 = malloc(small_len);
338 1 : fail_if(small2 == NULL);
339 1 : fail_unless(make_path_absolute(small2, small_len, "foo") == ENOBUFS);
340 1 : free(small2);
341 : }
342 1 : END_TEST
343 :
344 : /**** make_normalized_absolute_path ****/
345 1 : START_TEST(test_make_normalized_absolute_path)
346 : {
347 : char p[PATH_MAX];
348 : char p2[PATH_MAX];
349 : char cwd[PATH_MAX];
350 :
351 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
352 :
353 1 : fail_unless(make_normalized_absolute_path(p, PATH_MAX, "foo/baz/../bar") == SUCCESS);
354 1 : snprintf(p2, PATH_MAX, "%s/foo/bar", cwd);
355 1 : fail_unless_str_equal(p, p2);
356 :
357 1 : fail_unless(make_normalized_absolute_path(p, PATH_MAX, "/foo/../bar") == SUCCESS);
358 1 : fail_unless_str_equal(p, "/bar");
359 :
360 1 : fail_unless(make_normalized_absolute_path(p, PATH_MAX, "/foo/../baz/../bar") == SUCCESS);
361 1 : fail_unless_str_equal(p, "/bar");
362 : }
363 1 : END_TEST
364 :
365 1 : START_TEST(test_make_normalized_absolute_path_neg)
366 : {
367 : char small[1];
368 :
369 1 : fail_unless(make_path_absolute(small, 1, "/foo") == ENOBUFS);
370 1 : fail_unless(make_path_absolute(NULL, 1, "/foo") == ENOBUFS);
371 : }
372 1 : END_TEST
373 :
374 : /**** split_path ****/
375 1 : START_TEST(test_split_path)
376 : {
377 : char **array;
378 : int n;
379 :
380 1 : array = split_path("/foo/bar", &n);
381 1 : fail_if(array == NULL);
382 1 : fail_unless(n == 3);
383 1 : if (array) {
384 1 : fail_unless_str_equal(array[0], "/");
385 1 : fail_unless_str_equal(array[1], "foo");
386 1 : fail_unless_str_equal(array[2], "bar");
387 1 : free(array);
388 : }
389 :
390 1 : array = split_path("/foo/../bar", &n);
391 1 : fail_if(array == NULL);
392 1 : fail_unless(n == 4);
393 1 : if (array) {
394 1 : fail_unless_str_equal(array[0], "/");
395 1 : fail_unless_str_equal(array[1], "foo");
396 1 : fail_unless_str_equal(array[2], "..");
397 1 : fail_unless_str_equal(array[3], "bar");
398 1 : free(array);
399 : }
400 :
401 1 : array = split_path("/foo/bar", NULL);
402 1 : fail_if(array == NULL);
403 1 : if (array) {
404 1 : fail_unless_str_equal(array[0], "/");
405 1 : fail_unless_str_equal(array[1], "foo");
406 1 : fail_unless_str_equal(array[2], "bar");
407 1 : free(array);
408 : }
409 :
410 1 : array = split_path("foo/bar", &n);
411 1 : fail_if(array == NULL);
412 1 : fail_unless(n == 2);
413 1 : if (array) {
414 1 : fail_unless_str_equal(array[0], "foo");
415 1 : fail_unless_str_equal(array[1], "bar");
416 1 : free(array);
417 : }
418 :
419 1 : array = split_path(".", &n);
420 1 : fail_if(array == NULL);
421 1 : fail_unless(n == 1);
422 1 : if (array) {
423 1 : fail_unless_str_equal(array[0], ".");
424 1 : free(array);
425 : }
426 :
427 1 : array = split_path("foo", &n);
428 1 : fail_if(array == NULL);
429 1 : fail_unless(n == 1);
430 1 : if (array) {
431 1 : fail_unless_str_equal(array[0], "foo");
432 1 : free(array);
433 : }
434 :
435 : /* one might expect { "" } or outright NULL, but we agreed not to
436 : * do changes beyond bugfixes at this point */
437 1 : array = split_path("", &n);
438 1 : fail_if(array == NULL);
439 1 : fail_unless(n == 0);
440 1 : if (array) {
441 1 : fail_unless(array[0] == NULL);
442 1 : free(array);
443 : }
444 : }
445 1 : END_TEST
446 :
447 1 : START_TEST(test_split_path_neg)
448 : {
449 : char **array;
450 : int n;
451 :
452 1 : array = split_path(NULL, &n);
453 1 : fail_unless(array == NULL);
454 :
455 1 : array = split_path(NULL, NULL);
456 1 : fail_unless(array == NULL);
457 : }
458 1 : END_TEST
459 :
460 : /**** normalize_path ****/
461 1 : START_TEST(test_normalize_path)
462 : {
463 : char norm[PATH_MAX];
464 : char small[8];
465 :
466 1 : fail_unless(normalize_path(norm, PATH_MAX, "/foo/../bar") == SUCCESS);
467 1 : fail_unless_str_equal(norm, "/bar");
468 :
469 1 : fail_unless(normalize_path(norm, PATH_MAX, "/foo/../baz/../bar") == SUCCESS);
470 1 : fail_unless_str_equal(norm, "/bar");
471 :
472 1 : fail_unless(normalize_path(norm, PATH_MAX, "foo/baz/../bar") == SUCCESS);
473 1 : fail_unless_str_equal(norm, "foo/bar");
474 :
475 1 : fail_unless(normalize_path(norm, PATH_MAX, "/foo/./bar") == SUCCESS);
476 1 : fail_unless_str_equal(norm, "/foo/bar");
477 :
478 1 : fail_unless(normalize_path(norm, PATH_MAX, "/foo//bar") == SUCCESS);
479 1 : fail_unless_str_equal(norm, "/foo/bar");
480 :
481 1 : fail_unless(normalize_path(norm, PATH_MAX, "/foo//bar") == SUCCESS);
482 1 : fail_unless_str_equal(norm, "/foo/bar");
483 :
484 1 : fail_unless(normalize_path(norm, PATH_MAX, "") == SUCCESS);
485 1 : fail_unless_str_equal(norm, ".");
486 :
487 1 : fail_unless(normalize_path(norm, PATH_MAX, "/../..") == SUCCESS);
488 1 : fail_unless_str_equal(norm, "/");
489 :
490 : /* on-by-one */
491 1 : fail_unless(normalize_path(small, 8, "foo/baz/../bar") == SUCCESS);
492 1 : fail_unless_str_equal(small, "foo/bar");
493 : }
494 1 : END_TEST
495 :
496 1 : START_TEST(test_normalize_path_neg)
497 : {
498 : char norm[PATH_MAX];
499 : char small[4];
500 :
501 1 : fail_unless(normalize_path(norm, PATH_MAX, "foo/../..") == PATH_UTILS_ERROR_NOT_FULLY_NORMALIZED);
502 :
503 : /* with a buffer of 4 chars, this would test off-by-one error */
504 1 : fail_unless(normalize_path(small, 4, "/foo/../bar") == ENOBUFS);
505 : }
506 1 : END_TEST
507 :
508 : /**** common_path_prefix ****/
509 1 : START_TEST(test_common_path_prefix)
510 : {
511 : char common[PATH_MAX];
512 : char small[5];
513 : int count;
514 :
515 1 : fail_unless(common_path_prefix(common, PATH_MAX, &count, "/usr/lib", "/usr/share") == SUCCESS);
516 1 : fail_unless_str_equal(common, "/usr");
517 1 : fail_unless(count == 2);
518 :
519 1 : fail_unless(common_path_prefix(common, PATH_MAX, NULL, "/usr/lib", "/usr/share") == SUCCESS);
520 1 : fail_unless_str_equal(common, "/usr");
521 :
522 1 : fail_unless(common_path_prefix(common, PATH_MAX, &count, "/usr/lib", "/usr/lab") == SUCCESS);
523 1 : fail_unless_str_equal(common, "/usr");
524 1 : fail_unless(count == 2);
525 :
526 1 : fail_unless(common_path_prefix(common, PATH_MAX, &count, "foo", "bar") == SUCCESS);
527 1 : fail_unless_str_equal(common, "");
528 1 : fail_unless(count == 0);
529 :
530 1 : fail_unless(common_path_prefix(common, PATH_MAX, &count, "/", "/") == SUCCESS);
531 1 : fail_unless_str_equal(common, "/");
532 1 : fail_unless(count == 1);
533 :
534 1 : fail_unless(common_path_prefix(common, PATH_MAX, &count, NULL, "/usr/share") == SUCCESS);
535 1 : fail_unless_str_equal(common, "");
536 1 : fail_unless(count == 0);
537 :
538 : /* on-by-one */
539 1 : fail_unless(common_path_prefix(small, 5, NULL, "/usr/lib", "/usr/share") == SUCCESS);
540 1 : fail_unless_str_equal(small, "/usr");
541 : }
542 1 : END_TEST
543 :
544 1 : START_TEST(test_common_path_prefix_neg)
545 : {
546 : char small[1];
547 : char small2[4];
548 : int count;
549 :
550 1 : fail_unless(common_path_prefix(small, 1, &count, "/usr/lib", "/usr/share") == ENOBUFS);
551 1 : fail_unless(common_path_prefix(NULL, PATH_MAX, &count, "/usr/lib", "/usr/share") == ENOBUFS);
552 : /* off-by-one */
553 1 : fail_unless(common_path_prefix(small2, 4, NULL, "/usr/lib", "/usr/share") == ENOBUFS);
554 : }
555 1 : END_TEST
556 :
557 : /**** find_existing_directory_ancestor ****/
558 1 : START_TEST(test_find_existing_directory_ancestor)
559 : {
560 : char p[PATH_MAX];
561 : char cwd[PATH_MAX];
562 :
563 1 : fail_unless(find_existing_directory_ancestor(p, PATH_MAX, "/etc/passwd") == SUCCESS);
564 1 : fail_unless_str_equal(p, "/etc");
565 :
566 : /* if pathname does not contain a slash, the parent is cwd */
567 1 : fail_if(getcwd(cwd, PATH_MAX) == NULL, "getcwd failed");
568 :
569 1 : fail_unless(find_existing_directory_ancestor(p, PATH_MAX, "foo/bar") == SUCCESS);
570 1 : fail_unless_str_equal(p, cwd);
571 : }
572 1 : END_TEST
573 :
574 1 : START_TEST(test_find_existing_directory_ancestor_neg)
575 : {
576 : char small[4];
577 1 : fail_unless(find_existing_directory_ancestor(small, 4, "/etc/passwd") == ENOBUFS);
578 1 : fail_unless(find_existing_directory_ancestor(NULL, 4, "/etc/passwd") == ENOBUFS);
579 : }
580 1 : END_TEST
581 :
582 : /**** directory_list ****/
583 2 : static void setup_directory_list(void)
584 : {
585 2 : char *s = NULL;
586 : int ret;
587 :
588 2 : s = strdup(DIR_TEMPLATE);
589 2 : fail_unless(s != NULL, "strdup failed\n");
590 4 : if (!s) return;
591 2 : dlist_dir = mkdtemp(s);
592 2 : fail_unless(dlist_dir != NULL, "mkstemp failed [%d][%s]", errno, strerror(errno));
593 :
594 2 : ret = asprintf(&dlist_subdir, "%s/%s", dlist_dir, SUBDIR);
595 2 : fail_unless(ret != 1, "strdup failed\n");
596 2 : ret = mkdir(dlist_subdir, 0700);
597 2 : fail_unless(ret != -1, "mkdir %s failed [%d][%s]", dlist_subdir, errno, strerror(errno));
598 :
599 2 : ret = asprintf(&dlist_subsubdir, "%s/%s", dlist_subdir, SUBSUBDIR);
600 2 : fail_unless(ret != 1, "strdup failed\n");
601 2 : ret = mkdir(dlist_subsubdir, 0700);
602 2 : fail_unless(ret != -1, "mkdir %s failed [%d][%s]", dlist_subsubdir, errno, strerror(errno));
603 : }
604 :
605 2 : static void teardown_directory_list(void)
606 : {
607 : int ret;
608 :
609 2 : if (dlist_subsubdir) {
610 2 : ret = rmdir(dlist_subsubdir);
611 2 : fail_unless(ret != -1, "unlink %s failed [%d][%s]", dlist_subsubdir, errno, strerror(errno));
612 2 : free(dlist_subsubdir);
613 2 : dlist_subsubdir = NULL;
614 : }
615 :
616 2 : if (dlist_subdir) {
617 2 : ret = rmdir(dlist_subdir);
618 2 : fail_unless(ret != -1, "unlink %s failed [%d][%s]", dlist_subdir, errno, strerror(errno));
619 2 : free(dlist_subdir);
620 2 : dlist_subdir = NULL;
621 : }
622 :
623 2 : if (dlist_dir) {
624 2 : ret = rmdir(dlist_dir);
625 2 : fail_unless(ret != -1, "unlink %s failed [%d][%s]", dlist_dir, errno, strerror(errno));
626 2 : free(dlist_dir);
627 2 : dlist_dir = NULL;
628 : }
629 2 : }
630 :
631 1 : static bool dirlist_cb_nonrecursive(const char *directory,
632 : const char *base_name,
633 : const char *path,
634 : struct stat *info,
635 : void *user_data)
636 : {
637 1 : int *data = (int *) user_data;
638 :
639 1 : fail_unless_str_equal(path, dlist_subdir);
640 1 : fail_unless(*data == 123);
641 :
642 1 : return true;
643 : }
644 :
645 3 : static bool dirlist_cb_recursive(const char *directory, const char *base_name,
646 : const char *path, struct stat *info,
647 : void *user_data)
648 : {
649 3 : bool *seen_child = (bool *) user_data;
650 : static bool seen_parent = false;
651 :
652 3 : if (!seen_parent) {
653 2 : fail_unless_str_equal(path, dlist_subdir);
654 2 : seen_parent = true;
655 : } else {
656 1 : *seen_child = true;
657 1 : fail_unless_str_equal(path, dlist_subsubdir);
658 1 : seen_parent = false;
659 : }
660 :
661 3 : return true;
662 : }
663 :
664 1 : START_TEST(test_directory_list)
665 : {
666 1 : int data = 123;
667 : bool seen_child;
668 :
669 1 : fail_unless(directory_list(dlist_dir, false, dirlist_cb_nonrecursive, &data) == SUCCESS);
670 :
671 1 : seen_child = false;
672 1 : fail_unless(directory_list(dlist_dir, true, dirlist_cb_recursive, &seen_child) == SUCCESS);
673 1 : fail_unless(seen_child == true);
674 :
675 1 : seen_child = false;
676 1 : fail_unless(directory_list(dlist_dir, false, dirlist_cb_recursive, &seen_child) == SUCCESS);
677 1 : fail_unless(seen_child == false);
678 : }
679 1 : END_TEST
680 :
681 1 : START_TEST(test_directory_list_neg)
682 : {
683 1 : fail_if(directory_list("/not/here", false, dirlist_cb_nonrecursive, NULL) == SUCCESS);
684 1 : fail_if(directory_list("/etc/passwd", false, dirlist_cb_nonrecursive, NULL) == SUCCESS);
685 : }
686 1 : END_TEST
687 :
688 : /**** is_ancestor_path ****/
689 1 : START_TEST(test_is_ancestor_path)
690 : {
691 1 : fail_unless(is_ancestor_path("/a/b/c", "/a/b/c/d") == true);
692 : /* equal, not ancestor */
693 1 : fail_unless(is_ancestor_path("/a/b/c/d", "/a/b/c/d") == false);
694 1 : fail_unless(is_ancestor_path("/a/x/c", "/a/b/c/d") == false);
695 1 : fail_unless(is_ancestor_path(NULL, "/a/b/c/d") == false);
696 1 : fail_unless(is_ancestor_path("/a/x/c", NULL) == false);
697 1 : fail_unless(is_ancestor_path(NULL, NULL) == false);
698 1 : fail_unless(is_ancestor_path("", "") == false);
699 : }
700 1 : END_TEST
701 :
702 :
703 25 : static Suite *path_utils_suite(void)
704 : {
705 25 : Suite *s = suite_create("path_utils");
706 :
707 25 : TCase *tc_path_utils = tcase_create("path_utils");
708 25 : TCase *tc_directory_list = tcase_create("path_utils_directory_list");
709 :
710 25 : tcase_add_test(tc_path_utils, test_dirname);
711 25 : tcase_add_test(tc_path_utils, test_dirname_neg);
712 :
713 25 : tcase_add_test(tc_path_utils, test_basename);
714 25 : tcase_add_test(tc_path_utils, test_basename_neg);
715 :
716 25 : tcase_add_test(tc_path_utils, test_dirname_and_basename);
717 25 : tcase_add_test(tc_path_utils, test_dirname_and_basename_neg);
718 :
719 25 : tcase_add_test(tc_path_utils, test_is_absolute_path);
720 :
721 25 : tcase_add_test(tc_path_utils, test_path_concat);
722 25 : tcase_add_test(tc_path_utils, test_path_concat_neg);
723 :
724 25 : tcase_add_test(tc_path_utils, test_split_path);
725 25 : tcase_add_test(tc_path_utils, test_split_path_neg);
726 :
727 25 : tcase_add_test(tc_path_utils, test_make_path_absolute);
728 25 : tcase_add_test(tc_path_utils, test_make_path_absolute_neg);
729 :
730 25 : tcase_add_test(tc_path_utils, test_normalize_path);
731 25 : tcase_add_test(tc_path_utils, test_normalize_path_neg);
732 :
733 25 : tcase_add_test(tc_path_utils, test_make_normalized_absolute_path);
734 25 : tcase_add_test(tc_path_utils, test_make_normalized_absolute_path_neg);
735 :
736 25 : tcase_add_test(tc_path_utils, test_common_path_prefix);
737 25 : tcase_add_test(tc_path_utils, test_common_path_prefix_neg);
738 :
739 25 : tcase_add_test(tc_path_utils, test_find_existing_directory_ancestor);
740 25 : tcase_add_test(tc_path_utils, test_find_existing_directory_ancestor_neg);
741 :
742 25 : tcase_add_test(tc_path_utils, test_is_ancestor_path);
743 :
744 25 : tcase_add_checked_fixture(tc_directory_list,
745 : setup_directory_list,
746 : teardown_directory_list);
747 25 : tcase_add_test(tc_directory_list, test_directory_list);
748 25 : tcase_add_test(tc_directory_list, test_directory_list_neg);
749 :
750 25 : suite_add_tcase(s, tc_path_utils);
751 25 : suite_add_tcase(s, tc_directory_list);
752 :
753 25 : return s;
754 : }
755 :
756 25 : int main(void)
757 : {
758 : int number_failed;
759 :
760 25 : Suite *s = path_utils_suite();
761 25 : SRunner *sr = srunner_create(s);
762 : /* If CK_VERBOSITY is set, use that, otherwise it defaults to CK_NORMAL */
763 25 : srunner_run_all(sr, CK_ENV);
764 1 : number_failed = srunner_ntests_failed(sr);
765 1 : srunner_free(sr);
766 1 : return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
767 : }
768 :
|
