839effd2a3130a002d84e19b7b4643179cd18382
[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, see <https://www.gnu.org/licenses/>.
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 /* multipath expects any trailing whitespace to be stripped off the basename,
78  * so that it will match pp->dev */
79 static void test_basenamecpy_good6(void **state)
80 {
81         char dst[6];
82
83         assert_int_equal(basenamecpy("/xyzzy/plugh   ", dst, sizeof(dst)), 5);
84         assert_string_equal(dst, "plugh");
85 }
86
87 static void test_basenamecpy_good7(void **state)
88 {
89         char src[] = "/foo/bar";
90         char dst[10];
91
92         assert_int_equal(basenamecpy(src, dst, sizeof(dst)), 3);
93
94         strcpy(src, "badbadno");
95         assert_string_equal(dst, "bar");
96 }
97
98 /* buffer too small */
99 static void test_basenamecpy_bad0(void **state)
100 {
101         char dst[3];
102
103         assert_int_equal(basenamecpy("baz", dst, sizeof(dst)), 0);
104 }
105
106 /* ends in slash */
107 static void test_basenamecpy_bad1(void **state)
108 {
109         char dst[10];
110
111         assert_int_equal(basenamecpy("foo/bar/", dst, sizeof(dst)), 0);
112 }
113
114 static void test_basenamecpy_bad2(void **state)
115 {
116         char dst[10];
117
118         assert_int_equal(basenamecpy(NULL, dst, sizeof(dst)), 0);
119 }
120
121 static void test_basenamecpy_bad3(void **state)
122 {
123         char dst[10];
124
125         assert_int_equal(basenamecpy("", dst, sizeof(dst)), 0);
126 }
127
128 static void test_basenamecpy_bad4(void **state)
129 {
130         char dst[10];
131
132         assert_int_equal(basenamecpy("/", dst, sizeof(dst)), 0);
133 }
134
135 static void test_basenamecpy_bad5(void **state)
136 {
137         char dst[10];
138
139         assert_int_equal(basenamecpy("baz/qux", NULL, sizeof(dst)), 0);
140 }
141
142 int test_basenamecpy(void)
143 {
144         const struct CMUnitTest tests[] = {
145                 cmocka_unit_test(test_basenamecpy_good0),
146                 cmocka_unit_test(test_basenamecpy_good1),
147                 cmocka_unit_test(test_basenamecpy_good2),
148                 cmocka_unit_test(test_basenamecpy_good3),
149                 cmocka_unit_test(test_basenamecpy_good4),
150                 cmocka_unit_test(test_basenamecpy_good5),
151                 cmocka_unit_test(test_basenamecpy_good6),
152                 cmocka_unit_test(test_basenamecpy_good7),
153                 cmocka_unit_test(test_basenamecpy_bad0),
154                 cmocka_unit_test(test_basenamecpy_bad1),
155                 cmocka_unit_test(test_basenamecpy_bad2),
156                 cmocka_unit_test(test_basenamecpy_bad3),
157                 cmocka_unit_test(test_basenamecpy_bad4),
158                 cmocka_unit_test(test_basenamecpy_bad5),
159         };
160         return cmocka_run_group_tests(tests, NULL, NULL);
161 }
162
163 int main(void)
164 {
165         int ret = 0;
166
167         ret += test_basenamecpy();
168         return ret;
169 }