Unit tests for basenamecpy
[multipath-tools/.git] / tests / util.c
1 /*
2  * Copyright (c) 2018 Benjamin Marzinski, Redhat
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  *
17  */
18
19 #include <stdbool.h>
20 #include <stdarg.h>
21 #include <stddef.h>
22 #include <setjmp.h>
23 #include <stdlib.h>
24 #include <cmocka.h>
25 #include "util.h"
26
27 #include "globals.c"
28
29 static void test_basenamecpy_good0(void **state)
30 {
31         char dst[10];
32
33         assert_int_equal(basenamecpy("foobar", dst, sizeof(dst)), 6);
34         assert_string_equal(dst, "foobar");
35 }
36
37 static void test_basenamecpy_good1(void **state)
38 {
39         char dst[10];
40
41         assert_int_equal(basenamecpy("foo/bar", dst, sizeof(dst)), 3);
42         assert_string_equal(dst, "bar");
43 }
44
45 static void test_basenamecpy_good2(void **state)
46 {
47         char dst[10];
48
49         assert_int_equal(basenamecpy("/thud/blat", dst, sizeof(dst)), 4);
50         assert_string_equal(dst, "blat");
51 }
52
53 static void test_basenamecpy_good3(void **state)
54 {
55         char dst[4];
56
57         assert_int_equal(basenamecpy("foo/bar", dst, sizeof(dst)), 3);
58         assert_string_equal(dst, "bar");
59 }
60
61 static void test_basenamecpy_good4(void **state)
62 {
63         char dst[10];
64
65         assert_int_equal(basenamecpy("/xyzzy", dst, sizeof(dst)), 5);
66         assert_string_equal(dst, "xyzzy");
67 }
68
69 static void test_basenamecpy_good5(void **state)
70 {
71         char dst[4];
72
73         assert_int_equal(basenamecpy("/foo/bar\n", dst, sizeof(dst)), 3);
74         assert_string_equal(dst, "bar");
75 }
76
77 static void test_basenamecpy_good6(void **state)
78 {
79         char dst[6];
80
81         assert_int_equal(basenamecpy("/xyzzy/plugh   ", dst, sizeof(dst)), 5);
82         assert_string_equal(dst, "plugh");
83 }
84
85 static void test_basenamecpy_good7(void **state)
86 {
87         char src[] = "/foo/bar";
88         char dst[10];
89
90         assert_int_equal(basenamecpy(src, dst, sizeof(dst)), 3);
91
92         strcpy(src, "badbadno");
93         assert_string_equal(dst, "bar");
94 }
95
96 /* buffer too small */
97 static void test_basenamecpy_bad0(void **state)
98 {
99         char dst[3];
100
101         assert_int_equal(basenamecpy("baz", dst, sizeof(dst)), 0);
102 }
103
104 /* ends in slash */
105 static void test_basenamecpy_bad1(void **state)
106 {
107         char dst[10];
108
109         assert_int_equal(basenamecpy("foo/bar/", dst, sizeof(dst)), 0);
110 }
111
112 static void test_basenamecpy_bad2(void **state)
113 {
114         char dst[10];
115
116         assert_int_equal(basenamecpy(NULL, dst, sizeof(dst)), 0);
117 }
118
119 static void test_basenamecpy_bad3(void **state)
120 {
121         char dst[10];
122
123         assert_int_equal(basenamecpy("", dst, sizeof(dst)), 0);
124 }
125
126 static void test_basenamecpy_bad4(void **state)
127 {
128         char dst[10];
129
130         assert_int_equal(basenamecpy("/", dst, sizeof(dst)), 0);
131 }
132
133 static void test_basenamecpy_bad5(void **state)
134 {
135         char dst[10];
136
137         assert_int_equal(basenamecpy("baz/qux", NULL, sizeof(dst)), 0);
138 }
139
140 int test_basenamecpy(void)
141 {
142         const struct CMUnitTest tests[] = {
143                 cmocka_unit_test(test_basenamecpy_good0),
144                 cmocka_unit_test(test_basenamecpy_good1),
145                 cmocka_unit_test(test_basenamecpy_good2),
146                 cmocka_unit_test(test_basenamecpy_good3),
147                 cmocka_unit_test(test_basenamecpy_good4),
148                 cmocka_unit_test(test_basenamecpy_good5),
149                 cmocka_unit_test(test_basenamecpy_good6),
150                 cmocka_unit_test(test_basenamecpy_good7),
151                 cmocka_unit_test(test_basenamecpy_bad0),
152                 cmocka_unit_test(test_basenamecpy_bad1),
153                 cmocka_unit_test(test_basenamecpy_bad2),
154                 cmocka_unit_test(test_basenamecpy_bad3),
155                 cmocka_unit_test(test_basenamecpy_bad4),
156                 cmocka_unit_test(test_basenamecpy_bad5),
157         };
158         return cmocka_run_group_tests(tests, NULL, NULL);
159 }
160
161 int main(void)
162 {
163         int ret = 0;
164
165         ret += test_basenamecpy();
166         return ret;
167 }