Introduce the ibmultipath/unaligned.h header file
[multipath-tools/.git] / tests / uevent.c
1 /*
2  * Copyright (c) 2018 SUSE Linux GmbH
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 "list.h"
26 #include "uevent.h"
27
28 #include "globals.c"
29
30 /* Private prototypes missing in uevent.h */
31 struct uevent * alloc_uevent(void);
32 void uevent_get_wwid(struct uevent *uev);
33
34 /* Stringify helpers */
35 #define _str_(x) #x
36 #define str(x) _str_(x)
37
38 #define MAJOR 17
39 #define MINOR 217
40 #define DISK_RO 0
41 #define DM_NAME "spam"
42 #define WWID "foo"
43
44 static int setup_uev(void **state)
45 {
46         struct uevent *uev = alloc_uevent();
47
48         if (uev == NULL)
49                 return -1;
50
51         *state = uev;
52         uev->kernel = "sdo";
53         uev->envp[0] = "MAJOR=" str(MAJOR);
54         uev->envp[1] = "ID_BOGUS=" WWID;
55         uev->envp[2] = "MINOR=" str(MINOR);
56         uev->envp[3] = "DM_NAME=" DM_NAME;
57         uev->envp[4] = "DISK_RO=" str(DISK_RO);
58         uev->envp[5] = NULL;
59         return 0;
60 }
61
62 static int teardown(void **state)
63 {
64         free(*state);
65         return 0;
66 }
67
68 static void test_major_good(void **state)
69 {
70         struct uevent *uev = *state;
71
72         assert_int_equal(uevent_get_major(uev), MAJOR);
73 }
74
75 static void test_minor_good(void **state)
76 {
77         struct uevent *uev = *state;
78
79         assert_int_equal(uevent_get_minor(uev), MINOR);
80 }
81
82 static void test_ro_good(void **state)
83 {
84         struct uevent *uev = *state;
85
86         assert_int_equal(uevent_get_disk_ro(uev), DISK_RO);
87 }
88
89 static void test_wwid(void **state)
90 {
91         struct uevent *uev = *state;
92         uevent_get_wwid(uev);
93
94         assert_string_equal(uev->wwid, WWID);
95 }
96
97 static void test_major_bad_0(void **state)
98 {
99         struct uevent *uev = *state;
100
101         uev->envp[0] = "MAJOR" str(MAJOR);
102         assert_int_equal(uevent_get_major(uev), -1);
103 }
104
105 static void test_major_bad_1(void **state)
106 {
107         struct uevent *uev = *state;
108
109         uev->envp[0] = "MAJOr=" str(MAJOR);
110         assert_int_equal(uevent_get_major(uev), -1);
111 }
112
113 static void test_major_bad_2(void **state)
114 {
115         struct uevent *uev = *state;
116
117         uev->envp[0] = "MAJORIE=" str(MAJOR);
118         assert_int_equal(uevent_get_major(uev), -1);
119 }
120
121 static void test_major_bad_3(void **state)
122 {
123         struct uevent *uev = *state;
124
125         uev->envp[0] = "MAJOR=max";
126         assert_int_equal(uevent_get_major(uev), -1);
127 }
128
129 static void test_major_bad_4(void **state)
130 {
131         struct uevent *uev = *state;
132
133         uev->envp[0] = "MAJOR=0x10";
134         assert_int_equal(uevent_get_major(uev), -1);
135 }
136
137 static void test_major_bad_5(void **state)
138 {
139         struct uevent *uev = *state;
140
141         uev->envp[0] = "MAJO=" str(MAJOR);
142         assert_int_equal(uevent_get_major(uev), -1);
143 }
144
145 static void test_major_bad_6(void **state)
146 {
147         struct uevent *uev = *state;
148
149         uev->envp[0] = "MAJOR=" str(-MAJOR);
150         assert_int_equal(uevent_get_major(uev), -1);
151 }
152
153 static void test_major_bad_7(void **state)
154 {
155         struct uevent *uev = *state;
156
157         uev->envp[0] = "MAJOR=";
158         assert_int_equal(uevent_get_major(uev), -1);
159 }
160
161 static void test_major_bad_8(void **state)
162 {
163         struct uevent *uev = *state;
164
165         uev->envp[0] = "MAJOR";
166         assert_int_equal(uevent_get_major(uev), -1);
167 }
168
169 static void test_dm_name_good(void **state)
170 {
171         struct uevent *uev = *state;
172         const char *name = uevent_get_dm_name(uev);
173
174         assert_string_equal(name, DM_NAME);
175         free((void*)name);
176 }
177
178 static void test_dm_name_bad_0(void **state)
179 {
180         struct uevent *uev = *state;
181         const char *name;
182
183         uev->envp[3] = "DM_NAME" DM_NAME;
184         name = uevent_get_dm_name(uev);
185         assert_ptr_equal(name, NULL);
186         free((void*)name);
187 }
188
189 static void test_dm_name_bad_1(void **state)
190 {
191         struct uevent *uev = *state;
192         const char *name;
193
194         uev->envp[3] = "DM_NAMES=" DM_NAME;
195         name = uevent_get_dm_name(uev);
196         assert_ptr_equal(name, NULL);
197         free((void*)name);
198 }
199
200 static void test_dm_name_good_1(void **state)
201 {
202         struct uevent *uev = *state;
203         const char *name;
204
205         /* Note we change index 2 here */
206         uev->envp[2] = "DM_NAME=" DM_NAME;
207         name = uevent_get_dm_name(uev);
208         assert_string_equal(name, DM_NAME);
209         free((void*)name);
210 }
211
212 static void test_dm_uuid_false_0(void **state)
213 {
214         struct uevent *uev = *state;
215
216         assert_false(uevent_is_mpath(uev));
217 }
218
219 static void test_dm_uuid_true_0(void **state)
220 {
221         struct uevent *uev = *state;
222
223         uev->envp[3] = "DM_UUID=mpath-foo";
224         assert_true(uevent_is_mpath(uev));
225 }
226
227 static void test_dm_uuid_false_1(void **state)
228 {
229         struct uevent *uev = *state;
230
231         uev->envp[3] = "DM_UUID.mpath-foo";
232         assert_false(uevent_is_mpath(uev));
233 }
234
235 static void test_dm_uuid_false_2(void **state)
236 {
237         struct uevent *uev = *state;
238
239         uev->envp[3] = "DM_UUID=mpath-";
240         assert_false(uevent_is_mpath(uev));
241 }
242
243 static void test_dm_uuid_false_3(void **state)
244 {
245         struct uevent *uev = *state;
246
247         uev->envp[3] = "DM_UU=mpath-foo";
248         assert_false(uevent_is_mpath(uev));
249 }
250
251 static void test_dm_uuid_false_4(void **state)
252 {
253         struct uevent *uev = *state;
254
255         uev->envp[3] = "DM_UUID=mpathfoo";
256         assert_false(uevent_is_mpath(uev));
257 }
258
259 static void test_dm_uuid_false_5(void **state)
260 {
261         struct uevent *uev = *state;
262
263         uev->envp[3] = "DM_UUID=";
264         assert_false(uevent_is_mpath(uev));
265 }
266
267 int test_uevent_get_XXX(void)
268 {
269         const struct CMUnitTest tests[] = {
270                 cmocka_unit_test(test_major_good),
271                 cmocka_unit_test(test_minor_good),
272                 cmocka_unit_test(test_ro_good),
273                 cmocka_unit_test(test_dm_name_good),
274                 cmocka_unit_test(test_wwid),
275                 cmocka_unit_test(test_major_bad_0),
276                 cmocka_unit_test(test_major_bad_1),
277                 cmocka_unit_test(test_major_bad_2),
278                 cmocka_unit_test(test_major_bad_3),
279                 cmocka_unit_test(test_major_bad_4),
280                 cmocka_unit_test(test_major_bad_5),
281                 cmocka_unit_test(test_major_bad_6),
282                 cmocka_unit_test(test_major_bad_7),
283                 cmocka_unit_test(test_major_bad_8),
284                 cmocka_unit_test(test_dm_name_bad_0),
285                 cmocka_unit_test(test_dm_name_bad_1),
286                 cmocka_unit_test(test_dm_name_good_1),
287                 cmocka_unit_test(test_dm_uuid_false_0),
288                 cmocka_unit_test(test_dm_uuid_true_0),
289                 cmocka_unit_test(test_dm_uuid_false_1),
290                 cmocka_unit_test(test_dm_uuid_false_2),
291                 cmocka_unit_test(test_dm_uuid_false_3),
292                 cmocka_unit_test(test_dm_uuid_false_4),
293                 cmocka_unit_test(test_dm_uuid_false_5),
294         };
295         return cmocka_run_group_tests(tests, setup_uev, teardown);
296 }
297
298 int main(void)
299 {
300         int ret = 0;
301
302         ret += test_uevent_get_XXX();
303         return ret;
304 }