1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * KUnit test for the linear_ranges helper. |
4 | * |
5 | * Copyright (C) 2020, ROHM Semiconductors. |
6 | * Author: Matti Vaittinen <matti.vaittien@fi.rohmeurope.com> |
7 | */ |
8 | #include <kunit/test.h> |
9 | |
10 | #include <linux/linear_range.h> |
11 | |
12 | /* First things first. I deeply dislike unit-tests. I have seen all the hell |
13 | * breaking loose when people who think the unit tests are "the silver bullet" |
14 | * to kill bugs get to decide how a company should implement testing strategy... |
15 | * |
16 | * Believe me, it may get _really_ ridiculous. It is tempting to think that |
17 | * walking through all the possible execution branches will nail down 100% of |
18 | * bugs. This may lead to ideas about demands to get certain % of "test |
19 | * coverage" - measured as line coverage. And that is one of the worst things |
20 | * you can do. |
21 | * |
22 | * Ask people to provide line coverage and they do. I've seen clever tools |
23 | * which generate test cases to test the existing functions - and by default |
24 | * these tools expect code to be correct and just generate checks which are |
25 | * passing when ran against current code-base. Run this generator and you'll get |
26 | * tests that do not test code is correct but just verify nothing changes. |
27 | * Problem is that testing working code is pointless. And if it is not |
28 | * working, your test must not assume it is working. You won't catch any bugs |
29 | * by such tests. What you can do is to generate a huge amount of tests. |
30 | * Especially if you were are asked to proivde 100% line-coverage x_x. So what |
31 | * does these tests - which are not finding any bugs now - do? |
32 | * |
33 | * They add inertia to every future development. I think it was Terry Pratchet |
34 | * who wrote someone having same impact as thick syrup has to chronometre. |
35 | * Excessive amount of unit-tests have this effect to development. If you do |
36 | * actually find _any_ bug from code in such environment and try fixing it... |
37 | * ...chances are you also need to fix the test cases. In sunny day you fix one |
38 | * test. But I've done refactoring which resulted 500+ broken tests (which had |
39 | * really zero value other than proving to managers that we do do "quality")... |
40 | * |
41 | * After this being said - there are situations where UTs can be handy. If you |
42 | * have algorithms which take some input and should produce output - then you |
43 | * can implement few, carefully selected simple UT-cases which test this. I've |
44 | * previously used this for example for netlink and device-tree data parsing |
45 | * functions. Feed some data examples to functions and verify the output is as |
46 | * expected. I am not covering all the cases but I will see the logic should be |
47 | * working. |
48 | * |
49 | * Here we also do some minor testing. I don't want to go through all branches |
50 | * or test more or less obvious things - but I want to see the main logic is |
51 | * working. And I definitely don't want to add 500+ test cases that break when |
52 | * some simple fix is done x_x. So - let's only add few, well selected tests |
53 | * which ensure as much logic is good as possible. |
54 | */ |
55 | |
56 | /* |
57 | * Test Range 1: |
58 | * selectors: 2 3 4 5 6 |
59 | * values (5): 10 20 30 40 50 |
60 | * |
61 | * Test Range 2: |
62 | * selectors: 7 8 9 10 |
63 | * values (4): 100 150 200 250 |
64 | */ |
65 | |
66 | #define RANGE1_MIN 10 |
67 | #define RANGE1_MIN_SEL 2 |
68 | #define RANGE1_STEP 10 |
69 | |
70 | /* 2, 3, 4, 5, 6 */ |
71 | static const unsigned int range1_sels[] = { RANGE1_MIN_SEL, RANGE1_MIN_SEL + 1, |
72 | RANGE1_MIN_SEL + 2, |
73 | RANGE1_MIN_SEL + 3, |
74 | RANGE1_MIN_SEL + 4 }; |
75 | /* 10, 20, 30, 40, 50 */ |
76 | static const unsigned int range1_vals[] = { RANGE1_MIN, RANGE1_MIN + |
77 | RANGE1_STEP, |
78 | RANGE1_MIN + RANGE1_STEP * 2, |
79 | RANGE1_MIN + RANGE1_STEP * 3, |
80 | RANGE1_MIN + RANGE1_STEP * 4 }; |
81 | |
82 | #define RANGE2_MIN 100 |
83 | #define RANGE2_MIN_SEL 7 |
84 | #define RANGE2_STEP 50 |
85 | |
86 | /* 7, 8, 9, 10 */ |
87 | static const unsigned int range2_sels[] = { RANGE2_MIN_SEL, RANGE2_MIN_SEL + 1, |
88 | RANGE2_MIN_SEL + 2, |
89 | RANGE2_MIN_SEL + 3 }; |
90 | /* 100, 150, 200, 250 */ |
91 | static const unsigned int range2_vals[] = { RANGE2_MIN, RANGE2_MIN + |
92 | RANGE2_STEP, |
93 | RANGE2_MIN + RANGE2_STEP * 2, |
94 | RANGE2_MIN + RANGE2_STEP * 3 }; |
95 | |
96 | #define RANGE1_NUM_VALS (ARRAY_SIZE(range1_vals)) |
97 | #define RANGE2_NUM_VALS (ARRAY_SIZE(range2_vals)) |
98 | #define RANGE_NUM_VALS (RANGE1_NUM_VALS + RANGE2_NUM_VALS) |
99 | |
100 | #define RANGE1_MAX_SEL (RANGE1_MIN_SEL + RANGE1_NUM_VALS - 1) |
101 | #define RANGE1_MAX_VAL (range1_vals[RANGE1_NUM_VALS - 1]) |
102 | |
103 | #define RANGE2_MAX_SEL (RANGE2_MIN_SEL + RANGE2_NUM_VALS - 1) |
104 | #define RANGE2_MAX_VAL (range2_vals[RANGE2_NUM_VALS - 1]) |
105 | |
106 | #define SMALLEST_SEL RANGE1_MIN_SEL |
107 | #define SMALLEST_VAL RANGE1_MIN |
108 | |
109 | static struct linear_range testr[] = { |
110 | LINEAR_RANGE(RANGE1_MIN, RANGE1_MIN_SEL, RANGE1_MAX_SEL, RANGE1_STEP), |
111 | LINEAR_RANGE(RANGE2_MIN, RANGE2_MIN_SEL, RANGE2_MAX_SEL, RANGE2_STEP), |
112 | }; |
113 | |
114 | static void range_test_get_value(struct kunit *test) |
115 | { |
116 | int ret, i; |
117 | unsigned int sel, val; |
118 | |
119 | for (i = 0; i < RANGE1_NUM_VALS; i++) { |
120 | sel = range1_sels[i]; |
121 | ret = linear_range_get_value_array(r: &testr[0], ranges: 2, selector: sel, val: &val); |
122 | KUNIT_EXPECT_EQ(test, 0, ret); |
123 | KUNIT_EXPECT_EQ(test, val, range1_vals[i]); |
124 | } |
125 | for (i = 0; i < RANGE2_NUM_VALS; i++) { |
126 | sel = range2_sels[i]; |
127 | ret = linear_range_get_value_array(r: &testr[0], ranges: 2, selector: sel, val: &val); |
128 | KUNIT_EXPECT_EQ(test, 0, ret); |
129 | KUNIT_EXPECT_EQ(test, val, range2_vals[i]); |
130 | } |
131 | ret = linear_range_get_value_array(r: &testr[0], ranges: 2, selector: sel + 1, val: &val); |
132 | KUNIT_EXPECT_NE(test, 0, ret); |
133 | } |
134 | |
135 | static void range_test_get_selector_high(struct kunit *test) |
136 | { |
137 | int ret, i; |
138 | unsigned int sel; |
139 | bool found; |
140 | |
141 | for (i = 0; i < RANGE1_NUM_VALS; i++) { |
142 | ret = linear_range_get_selector_high(r: &testr[0], val: range1_vals[i], |
143 | selector: &sel, found: &found); |
144 | KUNIT_EXPECT_EQ(test, 0, ret); |
145 | KUNIT_EXPECT_EQ(test, sel, range1_sels[i]); |
146 | KUNIT_EXPECT_TRUE(test, found); |
147 | } |
148 | |
149 | ret = linear_range_get_selector_high(r: &testr[0], RANGE1_MAX_VAL + 1, |
150 | selector: &sel, found: &found); |
151 | KUNIT_EXPECT_LE(test, ret, 0); |
152 | |
153 | ret = linear_range_get_selector_high(r: &testr[0], RANGE1_MIN - 1, |
154 | selector: &sel, found: &found); |
155 | KUNIT_EXPECT_EQ(test, 0, ret); |
156 | KUNIT_EXPECT_FALSE(test, found); |
157 | KUNIT_EXPECT_EQ(test, sel, range1_sels[0]); |
158 | } |
159 | |
160 | static void range_test_get_value_amount(struct kunit *test) |
161 | { |
162 | int ret; |
163 | |
164 | ret = linear_range_values_in_range_array(r: &testr[0], ranges: 2); |
165 | KUNIT_EXPECT_EQ(test, (int)RANGE_NUM_VALS, ret); |
166 | } |
167 | |
168 | static void range_test_get_selector_low(struct kunit *test) |
169 | { |
170 | int i, ret; |
171 | unsigned int sel; |
172 | bool found; |
173 | |
174 | for (i = 0; i < RANGE1_NUM_VALS; i++) { |
175 | ret = linear_range_get_selector_low_array(r: &testr[0], ranges: 2, |
176 | val: range1_vals[i], selector: &sel, |
177 | found: &found); |
178 | KUNIT_EXPECT_EQ(test, 0, ret); |
179 | KUNIT_EXPECT_EQ(test, sel, range1_sels[i]); |
180 | KUNIT_EXPECT_TRUE(test, found); |
181 | } |
182 | for (i = 0; i < RANGE2_NUM_VALS; i++) { |
183 | ret = linear_range_get_selector_low_array(r: &testr[0], ranges: 2, |
184 | val: range2_vals[i], selector: &sel, |
185 | found: &found); |
186 | KUNIT_EXPECT_EQ(test, 0, ret); |
187 | KUNIT_EXPECT_EQ(test, sel, range2_sels[i]); |
188 | KUNIT_EXPECT_TRUE(test, found); |
189 | } |
190 | |
191 | /* |
192 | * Seek value greater than range max => get_selector_*_low should |
193 | * return Ok - but set found to false as value is not in range |
194 | */ |
195 | ret = linear_range_get_selector_low_array(r: &testr[0], ranges: 2, |
196 | val: range2_vals[RANGE2_NUM_VALS - 1] + 1, |
197 | selector: &sel, found: &found); |
198 | |
199 | KUNIT_EXPECT_EQ(test, 0, ret); |
200 | KUNIT_EXPECT_EQ(test, sel, range2_sels[RANGE2_NUM_VALS - 1]); |
201 | KUNIT_EXPECT_FALSE(test, found); |
202 | } |
203 | |
204 | static struct kunit_case range_test_cases[] = { |
205 | KUNIT_CASE(range_test_get_value_amount), |
206 | KUNIT_CASE(range_test_get_selector_high), |
207 | KUNIT_CASE(range_test_get_selector_low), |
208 | KUNIT_CASE(range_test_get_value), |
209 | {}, |
210 | }; |
211 | |
212 | static struct kunit_suite range_test_module = { |
213 | .name = "linear-ranges-test" , |
214 | .test_cases = range_test_cases, |
215 | }; |
216 | |
217 | kunit_test_suites(&range_test_module); |
218 | |
219 | MODULE_LICENSE("GPL" ); |
220 | |