tests: cmocka-based unit test for uevent_get_XXX
[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 <stdarg.h>
20 #include <stddef.h>
21 #include <setjmp.h>
22 #include <stdlib.h>
23 #include <cmocka.h>
24 #include "list.h"
25 #include "uevent.h"
26
27 #include "globals.c"
28
29 /* Private prototypes missing in uevent.h */
30 struct uevent * alloc_uevent(void);
31 void uevent_get_wwid(struct uevent *uev);
32
33 /* Stringify helpers */
34 #define _str_(x) #x
35 #define str(x) _str_(x)
36
37 #define MAJOR 17
38 #define MINOR 217
39 #define DISK_RO 0
40 #define DM_NAME "spam"
41 #define WWID "foo"
42
43 static int setup_uev(void **state)
44 {
45         struct uevent *uev = alloc_uevent();
46
47         if (uev == NULL)
48                 return -1;
49
50         *state = uev;
51         uev->kernel = "sdo";
52         uev->envp[0] = "MAJOR=" str(MAJOR);
53         uev->envp[1] = "ID_BOGUS=" WWID;
54         uev->envp[2] = "MINOR=" str(MINOR);
55         uev->envp[3] = "DM_NAME=" DM_NAME;
56         uev->envp[4] = "DISK_RO=" str(DISK_RO);
57         uev->envp[5] = NULL;
58         return 0;
59 }
60
61 static int teardown(void **state)
62 {
63         free(*state);
64         return 0;
65 }
66
67 static void test_major_good(void **state)
68 {
69         struct uevent *uev = *state;
70
71         assert_int_equal(uevent_get_major(uev), MAJOR);
72 }
73
74 static void test_minor_good(void **state)
75 {
76         struct uevent *uev = *state;
77
78         assert_int_equal(uevent_get_minor(uev), MINOR);
79 }
80
81 static void test_ro_good(void **state)
82 {
83         struct uevent *uev = *state;
84
85         assert_int_equal(uevent_get_disk_ro(uev), DISK_RO);
86 }
87
88 static void test_wwid(void **state)
89 {
90         struct uevent *uev = *state;
91         uevent_get_wwid(uev);
92
93         assert_string_equal(uev->wwid, WWID);
94 }
95
96 static void test_major_bad_0(void **state)
97 {
98         struct uevent *uev = *state;
99
100         uev->envp[0] = "MAJOR" str(MAJOR);
101         assert_int_equal(uevent_get_major(uev), -1);
102 }
103
104 static void test_major_bad_1(void **state)
105 {
106         struct uevent *uev = *state;
107
108         uev->envp[0] = "MAJOr=" str(MAJOR);
109         assert_int_equal(uevent_get_major(uev), -1);
110 }
111
112 static void test_major_bad_2(void **state)
113 {
114         struct uevent *uev = *state;
115
116         uev->envp[0] = "MAJORIE=" str(MAJOR);
117         assert_int_equal(uevent_get_major(uev), -1);
118 }
119
120 static void test_major_bad_3(void **state)
121 {
122         struct uevent *uev = *state;
123
124         uev->envp[0] = "MAJOR=max";
125         assert_int_equal(uevent_get_major(uev), -1);
126 }
127
128 static void test_major_bad_4(void **state)
129 {
130         struct uevent *uev = *state;
131
132         uev->envp[0] = "MAJOR=0x10";
133         assert_int_equal(uevent_get_major(uev), -1);
134 }
135
136 static void test_major_bad_5(void **state)
137 {
138         struct uevent *uev = *state;
139
140         uev->envp[0] = "MAJO=" str(MAJOR);
141         assert_int_equal(uevent_get_major(uev), -1);
142 }
143
144 static void test_major_bad_6(void **state)
145 {
146         struct uevent *uev = *state;
147
148         uev->envp[0] = "MAJOR=" str(-MAJOR);
149         assert_int_equal(uevent_get_major(uev), -1);
150 }
151
152 static void test_major_bad_7(void **state)
153 {
154         struct uevent *uev = *state;
155
156         uev->envp[0] = "MAJOR=";
157         assert_int_equal(uevent_get_major(uev), -1);
158 }
159
160 static void test_major_bad_8(void **state)
161 {
162         struct uevent *uev = *state;
163
164         uev->envp[0] = "MAJOR";
165         assert_int_equal(uevent_get_major(uev), -1);
166 }
167
168 static void test_dm_name_good(void **state)
169 {
170         struct uevent *uev = *state;
171         const char *name = uevent_get_dm_name(uev);
172
173         assert_string_equal(name, DM_NAME);
174         free((void*)name);
175 }
176
177 static void test_dm_name_bad_0(void **state)
178 {
179         struct uevent *uev = *state;
180         const char *name;
181
182         uev->envp[3] = "DM_NAME" DM_NAME;
183         name = uevent_get_dm_name(uev);
184         assert_ptr_equal(name, NULL);
185         free((void*)name);
186 }
187
188 static void test_dm_name_bad_1(void **state)
189 {
190         struct uevent *uev = *state;
191         const char *name;
192
193         uev->envp[3] = "DM_NAMES=" DM_NAME;
194         name = uevent_get_dm_name(uev);
195         assert_ptr_equal(name, NULL);
196         free((void*)name);
197 }
198
199 static void test_dm_name_good_1(void **state)
200 {
201         struct uevent *uev = *state;
202         const char *name;
203
204         /* Note we change index 2 here */
205         uev->envp[2] = "DM_NAME=" DM_NAME;
206         name = uevent_get_dm_name(uev);
207         assert_string_equal(name, DM_NAME);
208         free((void*)name);
209 }
210
211 int test_uevent_get_XXX(void)
212 {
213         const struct CMUnitTest tests[] = {
214                 cmocka_unit_test(test_major_good),
215                 cmocka_unit_test(test_minor_good),
216                 cmocka_unit_test(test_ro_good),
217                 cmocka_unit_test(test_dm_name_good),
218                 cmocka_unit_test(test_wwid),
219                 cmocka_unit_test(test_major_bad_0),
220                 cmocka_unit_test(test_major_bad_1),
221                 cmocka_unit_test(test_major_bad_2),
222                 cmocka_unit_test(test_major_bad_3),
223                 cmocka_unit_test(test_major_bad_4),
224                 cmocka_unit_test(test_major_bad_5),
225                 cmocka_unit_test(test_major_bad_6),
226                 cmocka_unit_test(test_major_bad_7),
227                 cmocka_unit_test(test_major_bad_8),
228                 cmocka_unit_test(test_dm_name_bad_0),
229                 cmocka_unit_test(test_dm_name_bad_1),
230                 cmocka_unit_test(test_dm_name_good_1),
231         };
232         return cmocka_run_group_tests(tests, setup_uev, teardown);
233 }
234
235 int main(void)
236 {
237         int ret = 0;
238
239         ret += test_uevent_get_XXX();
240         return ret;
241 }