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(&testr[0], 2, sel, &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(&testr[0], 2, sel, &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(&testr[0], 2, sel + 1, &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(&testr[0], range1_vals[i], 143 &sel, &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(&testr[0], RANGE1_MAX_VAL + 1, 150 &sel, &found); 151 KUNIT_EXPECT_LE(test, ret, 0); 152 153 ret = linear_range_get_selector_high(&testr[0], RANGE1_MIN - 1, 154 &sel, &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(&testr[0], 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(&testr[0], 2, 176 range1_vals[i], &sel, 177 &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(&testr[0], 2, 184 range2_vals[i], &sel, 185 &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(&testr[0], 2, 196 range2_vals[RANGE2_NUM_VALS - 1] + 1, 197 &sel, &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_DESCRIPTION("KUnit test for the linear_ranges helper"); 220 MODULE_LICENSE("GPL"); 221