1 /*
2 * Copyright (c) 2016,2021 Intel Corporation
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6 #include <errno.h>
7
8 #include <zephyr/kernel.h>
9 #include <zephyr/ztest.h>
10 #include <zephyr/arch/cpu.h>
11
12 #include <zephyr/tc_util.h>
13 #include <zephyr/sys/bitarray.h>
14 #include <zephyr/sys/util.h>
15
16 #ifdef CONFIG_BIG_ENDIAN
17 #define BIT_INDEX(bit) ((3 - ((bit >> 3) & 0x3)) + 4*(bit >> 5))
18 #else
19 #define BIT_INDEX(bit) (bit >> 3)
20 #endif
21 #define BIT_VAL(bit) (1 << (bit & 0x7))
22 #define BITFIELD_SIZE 512
23
24 /**
25 * @defgroup kernel_bitarray_tests Bit Arrays
26 * @ingroup all_tests
27 * @{
28 * @}
29 *
30 * @addtogroup kernel_bitarray_tests
31 * @{
32 */
33
34 /* Helper function to compare two bitarrays */
cmp_u32_arrays(uint32_t * a1,uint32_t * a2,size_t sz)35 static bool cmp_u32_arrays(uint32_t *a1, uint32_t *a2, size_t sz)
36 {
37 bool are_equal = true;
38 size_t i;
39
40 for (i = 0; i < sz; i++) {
41 if (a1[i] != a2[i]) {
42 are_equal = false;
43 printk("%s: [%zu] 0x%x != 0x%x", __func__,
44 i, a1[i], a2[i]);
45 break;
46 }
47 }
48
49 return are_equal;
50 }
51
52 #define FAIL_ALLOC_MSG_FMT "sys_bitarray_alloc with region size %i allocated incorrectly"
53 #define FAIL_ALLOC_RET_MSG_FMT "sys_bitarray_alloc with region size %i returned incorrect result"
54 #define FAIL_ALLOC_OFFSET_MSG_FMT "sys_bitarray_alloc with region size %i gave incorrect offset"
55 #define FAIL_FREE_MSG_FMT "sys_bitarray_free with region size %i and offset %i failed"
56 #define FREE 0U
57
validate_bitarray_define(sys_bitarray_t * ba,size_t num_bits)58 void validate_bitarray_define(sys_bitarray_t *ba, size_t num_bits)
59 {
60 size_t num_bundles;
61 int i;
62
63 num_bundles = ROUND_UP(ROUND_UP(num_bits, 8) / 8, sizeof(uint32_t))
64 / sizeof(uint32_t);
65
66 zassert_equal(ba->num_bits, num_bits,
67 "SYS_BITARRAY_DEFINE num_bits expected %zu, got %u",
68 num_bits, ba->num_bits);
69
70 zassert_equal(ba->num_bundles, num_bundles,
71 "SYS_BITARRAY_DEFINE num_bundles expected %zu, got %u",
72 num_bundles, ba->num_bundles);
73
74 for (i = 0; i < num_bundles; i++) {
75 zassert_equal(ba->bundles[i], FREE,
76 "SYS_BITARRAY_DEFINE bundles[%u] not free for num_bits %zu",
77 i, num_bits);
78 }
79 }
80
81 /**
82 * @brief Test defining of bitarrays
83 *
84 * @see SYS_BITARRAY_DEFINE()
85 */
ZTEST(bitarray,test_bitarray_declare)86 ZTEST(bitarray, test_bitarray_declare)
87 {
88 SYS_BITARRAY_DEFINE(ba_1_bit, 1);
89 SYS_BITARRAY_DEFINE(ba_32_bit, 32);
90 SYS_BITARRAY_DEFINE(ba_33_bit, 33);
91 SYS_BITARRAY_DEFINE(ba_64_bit, 64);
92 SYS_BITARRAY_DEFINE(ba_65_bit, 65);
93 SYS_BITARRAY_DEFINE(ba_128_bit, 128);
94 SYS_BITARRAY_DEFINE(ba_129_bit, 129);
95
96 /* Test SYS_BITFIELD_DECLARE by asserting that a sufficient number of uint32_t
97 * in the declared array are set as free to represent the number of bits
98 */
99
100 validate_bitarray_define(&ba_1_bit, 1);
101 validate_bitarray_define(&ba_32_bit, 32);
102 validate_bitarray_define(&ba_33_bit, 33);
103 validate_bitarray_define(&ba_64_bit, 64);
104 validate_bitarray_define(&ba_65_bit, 65);
105 validate_bitarray_define(&ba_128_bit, 128);
106 validate_bitarray_define(&ba_129_bit, 129);
107 }
108
bitarray_bundles_is_zero(sys_bitarray_t * ba)109 bool bitarray_bundles_is_zero(sys_bitarray_t *ba)
110 {
111 bool ret = true;
112 unsigned int i;
113
114 for (i = 0; i < ba->num_bundles; i++) {
115 if (ba->bundles[i] != 0) {
116 ret = false;
117 break;
118 }
119 }
120
121 return ret;
122 }
123
124 /**
125 * @brief Test bitarrays set and clear
126 *
127 * @see sys_bitarray_set_bit()
128 * @see sys_bitarray_clear_bit()
129 * @see sys_bitarray_test_bit()
130 * @see sys_bitarray_test_and_set_bit()
131 * @see sys_bitarray_test_and_clear_bit()
132 */
ZTEST(bitarray,test_bitarray_set_clear)133 ZTEST(bitarray, test_bitarray_set_clear)
134 {
135 int ret;
136 int bit_val;
137 size_t bit, bundle_idx, bit_idx_in_bundle;
138
139 /* Bitarrays have embedded spinlocks and can't on the stack. */
140 if (IS_ENABLED(CONFIG_KERNEL_COHERENCE)) {
141 ztest_test_skip();
142 }
143
144 SYS_BITARRAY_DEFINE(ba, 234);
145
146 for (bit = 0U; bit < ba.num_bits; ++bit) {
147 bundle_idx = bit / (sizeof(ba.bundles[0]) * 8);
148 bit_idx_in_bundle = bit % (sizeof(ba.bundles[0]) * 8);
149
150 ret = sys_bitarray_set_bit(&ba, bit);
151 zassert_equal(ret, 0,
152 "sys_bitarray_set_bit failed on bit %zu", bit);
153 zassert_equal(ba.bundles[bundle_idx], BIT(bit_idx_in_bundle),
154 "sys_bitarray_set_bit did not set bit %zu\n", bit);
155 zassert_not_equal(sys_bitfield_test_bit((mem_addr_t)ba.bundles, bit),
156 0, "sys_bitarray_set_bit did not set bit %zu\n", bit);
157
158 ret = sys_bitarray_test_bit(&ba, bit, &bit_val);
159 zassert_equal(ret, 0,
160 "sys_bitarray_test_bit failed at bit %zu", bit);
161 zassert_equal(bit_val, 1,
162 "sys_bitarray_test_bit did not detect bit %zu\n", bit);
163
164 ret = sys_bitarray_clear_bit(&ba, bit);
165 zassert_equal(ret, 0,
166 "sys_bitarray_clear_bit failed at bit %zu", bit);
167 zassert_equal(ba.bundles[bundle_idx], 0,
168 "sys_bitarray_clear_bit did not clear bit %zu\n", bit);
169 zassert_equal(sys_bitfield_test_bit((mem_addr_t)ba.bundles, bit),
170 0, "sys_bitarray_set_bit did not set bit %zu\n", bit);
171
172 ret = sys_bitarray_test_bit(&ba, bit, &bit_val);
173 zassert_equal(ret, 0,
174 "sys_bitarray_test_bit failed at bit %zu", bit);
175 zassert_equal(bit_val, 0,
176 "sys_bitarray_test_bit erroneously detected bit %zu\n",
177 bit);
178
179 ret = sys_bitarray_test_and_set_bit(&ba, bit, &bit_val);
180 zassert_equal(ret, 0,
181 "sys_bitarray_test_and_set_bit failed at bit %zu", bit);
182 zassert_equal(bit_val, 0,
183 "sys_bitarray_test_and_set_bit erroneously detected bit %zu\n",
184 bit);
185 zassert_equal(ba.bundles[bundle_idx], BIT(bit_idx_in_bundle),
186 "sys_bitarray_test_and_set_bit did not set bit %zu\n", bit);
187 zassert_not_equal(sys_bitfield_test_bit((mem_addr_t)ba.bundles, bit),
188 0, "sys_bitarray_set_bit did not set bit %zu\n", bit);
189
190 ret = sys_bitarray_test_and_set_bit(&ba, bit, &bit_val);
191 zassert_equal(ret, 0,
192 "sys_bitarray_test_and_set_bit failed at bit %zu", bit);
193 zassert_equal(bit_val, 1,
194 "sys_bitarray_test_and_set_bit did not detect bit %zu\n",
195 bit);
196 zassert_equal(ba.bundles[bundle_idx], BIT(bit_idx_in_bundle),
197 "sys_bitarray_test_and_set_bit cleared bit %zu\n", bit);
198 zassert_not_equal(sys_bitfield_test_bit((mem_addr_t)ba.bundles, bit),
199 0, "sys_bitarray_set_bit did not set bit %zu\n", bit);
200
201 ret = sys_bitarray_test_and_clear_bit(&ba, bit, &bit_val);
202 zassert_equal(ret, 0,
203 "sys_bitarray_test_and_clear_bit failed at bit %zu", bit);
204 zassert_equal(bit_val, 1,
205 "sys_bitarray_test_and_clear_bit did not detect bit %zu\n",
206 bit);
207 zassert_equal(ba.bundles[bundle_idx], 0,
208 "sys_bitarray_test_and_clear_bit did not clear bit %zu\n",
209 bit);
210 zassert_equal(sys_bitfield_test_bit((mem_addr_t)ba.bundles, bit),
211 0, "sys_bitarray_set_bit did not set bit %zu\n", bit);
212
213 ret = sys_bitarray_test_and_clear_bit(&ba, bit, &bit_val);
214 zassert_equal(ret, 0,
215 "sys_bitarray_test_and_clear_bit failed at bit %zu", bit);
216 zassert_equal(bit_val, 0,
217 "sys_bitarray_test_and_clear_bit erroneously detected bit %zu\n",
218 bit);
219 zassert_equal(ba.bundles[bundle_idx], 0,
220 "sys_bitarray_test_and_clear_bit set bit %zu\n",
221 bit);
222 zassert_equal(sys_bitfield_test_bit((mem_addr_t)ba.bundles, bit),
223 0, "sys_bitarray_set_bit did not set bit %zu\n", bit);
224 }
225
226 /* All this should fail because we go outside of
227 * total bits in bit array. Also needs to make sure bits
228 * are not changed.
229 */
230 ret = sys_bitarray_set_bit(&ba, ba.num_bits);
231 zassert_not_equal(ret, 0, "sys_bitarray_set_bit() should fail but not");
232 zassert_true(bitarray_bundles_is_zero(&ba),
233 "sys_bitarray_set_bit() erroneously changed bitarray");
234
235 ret = sys_bitarray_clear_bit(&ba, ba.num_bits);
236 zassert_not_equal(ret, 0, "sys_bitarray_clear_bit() should fail but not");
237 zassert_true(bitarray_bundles_is_zero(&ba),
238 "sys_bitarray_clear_bit() erroneously changed bitarray");
239
240 ret = sys_bitarray_test_bit(&ba, ba.num_bits, &bit_val);
241 zassert_not_equal(ret, 0, "sys_bitarray_test_bit() should fail but not");
242 zassert_true(bitarray_bundles_is_zero(&ba),
243 "sys_bitarray_test_bit() erroneously changed bitarray");
244
245 ret = sys_bitarray_test_and_set_bit(&ba, ba.num_bits, &bit_val);
246 zassert_not_equal(ret, 0,
247 "sys_bitarray_test_and_set_bit() should fail but not");
248 zassert_true(bitarray_bundles_is_zero(&ba),
249 "sys_bitarray_test_and_set_bit() erroneously changed bitarray");
250
251 ret = sys_bitarray_test_and_clear_bit(&ba, ba.num_bits, &bit_val);
252 zassert_not_equal(ret, 0,
253 "sys_bitarray_test_and_clear_bit() should fail but not");
254 zassert_true(bitarray_bundles_is_zero(&ba),
255 "sys_bitarray_test_and_clear_bit() erroneously changed bitarray");
256
257 ret = sys_bitarray_set_bit(&ba, -1);
258 zassert_not_equal(ret, 0, "sys_bitarray_set_bit() should fail but not");
259 zassert_true(bitarray_bundles_is_zero(&ba),
260 "sys_bitarray_set_bit() erroneously changed bitarray");
261
262 ret = sys_bitarray_clear_bit(&ba, -1);
263 zassert_not_equal(ret, 0, "sys_bitarray_clear_bit() should fail but not");
264 zassert_true(bitarray_bundles_is_zero(&ba),
265 "sys_bitarray_clear_bit() erroneously changed bitarray");
266
267 ret = sys_bitarray_test_bit(&ba, -1, &bit_val);
268 zassert_not_equal(ret, 0, "sys_bitarray_test_bit() should fail but not");
269 zassert_true(bitarray_bundles_is_zero(&ba),
270 "sys_bitarray_test_bit() erroneously changed bitarray");
271
272 ret = sys_bitarray_test_and_set_bit(&ba, -1, &bit_val);
273 zassert_not_equal(ret, 0,
274 "sys_bitarray_test_and_set_bit() should fail but not");
275 zassert_true(bitarray_bundles_is_zero(&ba),
276 "sys_bitarray_test_and_set_bit() erroneously changed bitarray");
277
278 ret = sys_bitarray_test_and_clear_bit(&ba, -1, &bit_val);
279 zassert_not_equal(ret, 0,
280 "sys_bitarray_test_and_clear_bit() should fail but not");
281 zassert_true(bitarray_bundles_is_zero(&ba),
282 "sys_bitarray_test_and_clear_bit() erroneously changed bitarray");
283 }
284
test_alloc_free_32(uint32_t mask,uint32_t mask_after,size_t num_bits,size_t exp_offset,int exp_ret)285 static void test_alloc_free_32(uint32_t mask, uint32_t mask_after, size_t num_bits,
286 size_t exp_offset, int exp_ret)
287 {
288 int ret;
289 size_t offset;
290
291 SYS_BITARRAY_DEFINE(ba_32, 32);
292
293 ba_32.bundles[0] = mask;
294
295 ret = sys_bitarray_alloc(&ba_32, num_bits, &offset);
296 zassert_equal(ret, exp_ret, "sys_bitarray_alloc() failed: %d", ret);
297 if (exp_ret < 0) {
298 return;
299 }
300 zassert_equal(offset, exp_offset,
301 "sys_bitarray_alloc() offset expected %zu, got %zu", exp_offset, offset);
302 zassert_equal(ba_32.bundles[0], mask_after, "sys_bitarray_alloc() failed bits comparison");
303
304 ret = sys_bitarray_free(&ba_32, num_bits, offset);
305 zassert_equal(ret, 0, "sys_bitarray_free() failed: %d", ret);
306 zassert_equal(ba_32.bundles[0], mask, "sys_bitarray_alloc() failed bits comparison");
307 }
308
alloc_and_free_32_predefined(void)309 static void alloc_and_free_32_predefined(void)
310 {
311 printk("Testing bit array alloc and free with predefined patterns using 32 bit array\n");
312
313 test_alloc_free_32(0x0F0F070F, 0x0F0FFF0F, 5, 11, 0);
314 test_alloc_free_32(0x33333333, 0xF3333333, 3, 0, -ENOSPC);
315 test_alloc_free_32(0x33333333, 0xF3333333, 2, 30, 0);
316 }
317
alloc_and_free_predefined(void)318 void alloc_and_free_predefined(void)
319 {
320 int ret;
321 size_t offset;
322
323 uint32_t ba_128_expected[4];
324
325 SYS_BITARRAY_DEFINE(ba_128, 128);
326
327 printk("Testing bit array alloc and free with predefined patterns using 128 bit array\n");
328
329 /* Pre-populate the bits */
330 ba_128.bundles[0] = 0x0F0F070F;
331 ba_128.bundles[1] = 0x0F0F0F0F;
332 ba_128.bundles[2] = 0x0F0F0F0F;
333 ba_128.bundles[3] = 0x0F0F0000;
334
335 /* Expected values */
336 ba_128_expected[0] = 0x0F0FFF0F;
337 ba_128_expected[1] = 0x0F0F0F0F;
338 ba_128_expected[2] = 0x0F0F0F0F;
339 ba_128_expected[3] = 0x0F0F0000;
340
341 ret = sys_bitarray_alloc(&ba_128, 5, &offset);
342 zassert_equal(ret, 0, "sys_bitarray_alloc() failed: %d", ret);
343 zassert_equal(offset, 11, "sys_bitarray_alloc() offset expected %d, got %zu", 11, offset);
344 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
345 "sys_bitarray_alloc() failed bits comparison");
346
347 ret = sys_bitarray_alloc(&ba_128, 16, &offset);
348 ba_128_expected[2] = 0xFF0F0F0F;
349 ba_128_expected[3] = 0x0F0F0FFF;
350 zassert_equal(ret, 0, "sys_bitarray_alloc() failed: %d", ret);
351 zassert_equal(offset, 92, "sys_bitarray_alloc() offset expected %d, got %zu", 92, offset);
352 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
353 "sys_bitarray_alloc() failed bits comparison");
354
355 ret = sys_bitarray_free(&ba_128, 5, 11);
356 ba_128_expected[0] = 0x0F0F070F;
357 zassert_equal(ret, 0, "sys_bitarray_free() failed: %d", ret);
358 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
359 "sys_bitarray_free() failed bits comparison");
360
361 ret = sys_bitarray_free(&ba_128, 5, 0);
362 zassert_not_equal(ret, 0, "sys_bitarray_free() should fail but not");
363 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
364 "sys_bitarray_free() failed bits comparison");
365
366 ret = sys_bitarray_free(&ba_128, 24, 92);
367 zassert_not_equal(ret, 0, "sys_bitarray_free() should fail but not");
368 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
369 "sys_bitarray_free() failed bits comparison");
370
371 ret = sys_bitarray_free(&ba_128, 16, 92);
372 ba_128_expected[2] = 0x0F0F0F0F;
373 ba_128_expected[3] = 0x0F0F0000;
374 zassert_equal(ret, 0, "sys_bitarray_free() failed: %d", ret);
375 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
376 "sys_bitarray_free() failed bits comparison");
377
378 /* test in-between bundles */
379 ba_128.bundles[0] = 0x7FFFFFFF;
380 ba_128.bundles[1] = 0xFFFFFFFF;
381 ba_128.bundles[2] = 0x00000000;
382 ba_128.bundles[3] = 0x00000000;
383
384 ba_128_expected[0] = 0x7FFFFFFF;
385 ba_128_expected[1] = 0xFFFFFFFF;
386 ba_128_expected[2] = 0xFFFFFFFF;
387 ba_128_expected[3] = 0x00000003;
388
389 ret = sys_bitarray_alloc(&ba_128, 34, &offset);
390 zassert_equal(ret, 0, "sys_bitarray_alloc() failed: %d", ret);
391 zassert_equal(offset, 64, "sys_bitarray_alloc() offset expected %d, got %zu", 64, offset);
392 zassert_true(cmp_u32_arrays(ba_128.bundles, ba_128_expected, ba_128.num_bundles),
393 "sys_bitarray_alloc() failed bits comparison");
394 }
395
get_bitarray_popcnt(sys_bitarray_t * ba)396 size_t get_bitarray_popcnt(sys_bitarray_t *ba)
397 {
398 size_t popcnt = 0;
399 unsigned int idx;
400
401 for (idx = 0; idx < ba->num_bundles; idx++) {
402 popcnt += sys_count_bits(&ba->bundles[idx], sizeof(uint32_t));
403 }
404
405 return popcnt;
406 }
407
alloc_and_free_loop(int divisor)408 void alloc_and_free_loop(int divisor)
409 {
410 int ret;
411 size_t offset;
412 size_t bit;
413 size_t num_bits;
414 size_t cur_popcnt;
415 size_t expected_popcnt = 0;
416
417 SYS_BITARRAY_DEFINE(ba, 234);
418
419 printk("Testing bit array alloc and free with divisor %d\n", divisor);
420
421 for (bit = 0U; bit < ba.num_bits; ++bit) {
422 cur_popcnt = get_bitarray_popcnt(&ba);
423 zassert_equal(cur_popcnt, expected_popcnt,
424 "bit count expected %zu, got %zu (at bit %zu)",
425 expected_popcnt, cur_popcnt, bit);
426
427 /* Allocate half of remaining bits */
428 num_bits = (ba.num_bits - bit) / divisor;
429
430 ret = sys_bitarray_alloc(&ba, num_bits, &offset);
431 if (num_bits == 0) {
432 zassert_not_equal(ret, 0,
433 "sys_bitarray_free() should fail but not (bit %zu)",
434 bit);
435 } else {
436 zassert_equal(ret, 0,
437 "sys_bitarray_alloc() failed (%d) at bit %zu",
438 ret, bit);
439 zassert_equal(offset, bit,
440 "sys_bitarray_alloc() offset expected %zu, got %zu",
441 bit, offset);
442
443 expected_popcnt += num_bits;
444 }
445
446 cur_popcnt = get_bitarray_popcnt(&ba);
447 zassert_equal(cur_popcnt, expected_popcnt,
448 "bit count expected %zu, got %zu (at bit %zu)",
449 expected_popcnt, cur_popcnt, bit);
450
451 /* Free all but the first bit of allocated region */
452 ret = sys_bitarray_free(&ba, (num_bits - 1), (bit + 1));
453 if ((num_bits == 0) || ((num_bits - 1) == 0)) {
454 zassert_not_equal(ret, 0,
455 "sys_bitarray_free() should fail but not (bit %zu)",
456 bit);
457 } else {
458 zassert_equal(ret, 0,
459 "sys_bitarray_free() failed (%d) at bit %zu",
460 ret, (bit + 1));
461
462 expected_popcnt -= num_bits - 1;
463 }
464 }
465 }
466
alloc_and_free_interval(void)467 void alloc_and_free_interval(void)
468 {
469 int ret;
470 size_t cnt;
471 size_t offset;
472 size_t expected_offset;
473 size_t expected_popcnt, cur_popcnt;
474
475 /* Make sure number of bits is multiple of 8 */
476 SYS_BITARRAY_DEFINE(ba, 152);
477
478 printk("Testing bit array interval alloc and free\n");
479
480 /* Pre-populate the bits so that 4-bit already allocated,
481 * then 4 free bits, and repeat.
482 */
483 for (cnt = 0; cnt < ba.num_bundles; cnt++) {
484 ba.bundles[cnt] = 0x0F0F0F0F;
485 }
486
487 expected_offset = 4;
488 expected_popcnt = get_bitarray_popcnt(&ba);
489 for (cnt = 0; cnt <= (ba.num_bits / 8); cnt++) {
490
491 ret = sys_bitarray_alloc(&ba, 4, &offset);
492 if (cnt == (ba.num_bits / 8)) {
493 zassert_not_equal(ret, 0,
494 "sys_bitarray_free() should fail but not (cnt %zu)",
495 cnt);
496 } else {
497 zassert_equal(ret, 0,
498 "sys_bitarray_alloc() failed (%d) (cnt %zu)",
499 ret, cnt);
500
501 zassert_equal(offset, expected_offset,
502 "offset expected %zu, got %zu (cnt %zu)",
503 expected_offset, offset, cnt);
504
505 expected_popcnt += 4;
506
507 cur_popcnt = get_bitarray_popcnt(&ba);
508 zassert_equal(cur_popcnt, expected_popcnt,
509 "bit count expected %zu, got %zu (cnt %zu)",
510 expected_popcnt, cur_popcnt, cnt);
511
512
513 expected_offset += 8;
514 }
515 }
516 }
517
518 /**
519 * @brief Test bitarrays allocation and free
520 *
521 * @see sys_bitarray_alloc()
522 * @see sys_bitarray_free()
523 */
ZTEST(bitarray,test_bitarray_alloc_free)524 ZTEST(bitarray, test_bitarray_alloc_free)
525 {
526 int i;
527
528 /* Bitarrays have embedded spinlocks and can't on the stack. */
529 if (IS_ENABLED(CONFIG_KERNEL_COHERENCE)) {
530 ztest_test_skip();
531 }
532
533 alloc_and_free_predefined();
534 alloc_and_free_32_predefined();
535
536 i = 1;
537 while (i < 65) {
538 alloc_and_free_loop(i);
539
540 i *= 2;
541 }
542
543 alloc_and_free_interval();
544 }
545
ZTEST(bitarray,test_bitarray_popcount_region)546 ZTEST(bitarray, test_bitarray_popcount_region)
547 {
548 int ret;
549 size_t count;
550
551 /* Bitarrays have embedded spinlocks and can't on the stack. */
552 if (IS_ENABLED(CONFIG_KERNEL_COHERENCE)) {
553 ztest_test_skip();
554 }
555
556 SYS_BITARRAY_DEFINE(ba, 128);
557
558 printk("Testing bit array region popcount spanning single bundle\n");
559
560 /* Pre-populate the bits */
561 ba.bundles[0] = 0x00000005;
562 ba.bundles[1] = 0x00000000;
563 ba.bundles[2] = 0x00000000;
564 ba.bundles[3] = 0x00000000;
565
566 ret = sys_bitarray_popcount_region(&ba, 1, 0, &count);
567 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
568 zassert_equal(count, 1, "sys_bitarray_popcount_region() returned unexpected count: %zu",
569 count);
570
571 ret = sys_bitarray_popcount_region(&ba, 1, 1, &count);
572 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
573 zassert_equal(count, 0, "sys_bitarray_popcount_region() returned unexpected count: %zu",
574 count);
575
576 ret = sys_bitarray_popcount_region(&ba, 2, 0, &count);
577 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
578 zassert_equal(count, 1, "sys_bitarray_popcount_region() returned unexpected count: %zu",
579 count);
580
581 ret = sys_bitarray_popcount_region(&ba, 3, 0, &count);
582 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
583 zassert_equal(count, 2, "sys_bitarray_popcount_region() returned unexpected count: %zu",
584 count);
585
586 ret = sys_bitarray_popcount_region(&ba, 3, 1, &count);
587 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
588 zassert_equal(count, 1, "sys_bitarray_popcount_region() returned unexpected count: %zu",
589 count);
590
591 printk("Testing bit array region popcount spanning multiple bundles\n");
592
593 /* Pre-populate the bits.
594 * First and last bit of bitarray are set
595 */
596 ba.bundles[0] = 0x00000001;
597 ba.bundles[1] = 0x00000000;
598 ba.bundles[2] = 0x00000000;
599 ba.bundles[3] = 0x80000000;
600
601 ret = sys_bitarray_popcount_region(&ba, 126, 1, &count);
602 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
603 zassert_equal(count, 0, "sys_bitarray_popcount_region() returned unexpected count: %zu",
604 count);
605
606 ret = sys_bitarray_popcount_region(&ba, 126, 0, &count);
607 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
608 zassert_equal(count, 1, "sys_bitarray_popcount_region() returned unexpected count: %zu",
609 count);
610
611 ret = sys_bitarray_popcount_region(&ba, 127, 1, &count);
612 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
613 zassert_equal(count, 1, "sys_bitarray_popcount_region() returned unexpected count: %zu",
614 count);
615 ret = sys_bitarray_popcount_region(&ba, 1, 127, &count);
616 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
617 zassert_equal(count, 1, "sys_bitarray_popcount_region() returned unexpected count: %zu",
618 count);
619
620 ret = sys_bitarray_popcount_region(&ba, 128, 0, &count);
621 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
622 zassert_equal(count, 2, "sys_bitarray_popcount_region() returned unexpected count: %zu",
623 count);
624
625 printk("Testing edge/error cases\n");
626 ret = sys_bitarray_popcount_region(&ba, 0, 0, &count);
627 zassert_equal(ret, -EINVAL, "sys_bitarray_popcount_region() returned unexpected value: %d",
628 ret);
629 ret = sys_bitarray_popcount_region(&ba, 0, 128, &count);
630 zassert_equal(ret, -EINVAL, "sys_bitarray_popcount_region() returned unexpected value: %d",
631 ret);
632 ret = sys_bitarray_popcount_region(&ba, 128, 0, &count);
633 zassert_equal(ret, 0, "sys_bitarray_popcount_region() returned unexpected value: %d", ret);
634
635 ret = sys_bitarray_popcount_region(&ba, 128, 1, &count);
636 zassert_equal(ret, -EINVAL, "sys_bitarray_popcount_region() returned unexpected value: %d",
637 ret);
638 ret = sys_bitarray_popcount_region(&ba, 129, 0, &count);
639 zassert_equal(ret, -EINVAL, "sys_bitarray_popcount_region() returned unexpected value: %d",
640 ret);
641 }
642
ZTEST(bitarray,test_bitarray_xor)643 ZTEST(bitarray, test_bitarray_xor)
644 {
645 int ret;
646
647 /* Bitarrays have embedded spinlocks and can't on the stack. */
648 if (IS_ENABLED(CONFIG_KERNEL_COHERENCE)) {
649 ztest_test_skip();
650 }
651
652 SYS_BITARRAY_DEFINE(ba, 128);
653 SYS_BITARRAY_DEFINE(bb, 128);
654 SYS_BITARRAY_DEFINE(bc, 129);
655
656 printk("Testing bit array region xor spanning single bundle\n");
657
658 /* Pre-populate the bits */
659 ba.bundles[0] = 0x80001001;
660 ba.bundles[1] = 0x10000008;
661 ba.bundles[2] = 0xFFFFFFFF;
662 ba.bundles[3] = 0x00000000;
663
664 bb.bundles[0] = 0x80010001;
665 bb.bundles[1] = 0x10000008;
666 bb.bundles[2] = 0xFFFFFFFF;
667 bb.bundles[3] = 0x00000000;
668
669 ret = sys_bitarray_xor(&ba, &bb, 32, 0);
670 zassert_equal(ret, 0, "sys_bitarray_xor() returned unexpected value: %d", ret);
671 zassert_equal(ba.bundles[0], 0x00011000, "sys_bitarray_xor() result unexpected: %x",
672 ba.bundles[0]);
673 zassert_equal(bb.bundles[0], 0x80010001, "sys_bitarray_xor() result unexpected: %x",
674 bb.bundles[0]);
675
676 zassert_equal(ba.bundles[1], 0x10000008, "sys_bitarray_xor() result unexpected: %x",
677 ba.bundles[1]);
678 zassert_equal(bb.bundles[1], 0x10000008, "sys_bitarray_xor() result unexpected: %x",
679 bb.bundles[1]);
680
681 zassert_equal(ba.bundles[2], 0xFFFFFFFF, "sys_bitarray_xor() result unexpected: %x",
682 ba.bundles[2]);
683 zassert_equal(bb.bundles[2], 0xFFFFFFFF, "sys_bitarray_xor() result unexpected: %x",
684 bb.bundles[2]);
685
686 zassert_equal(ba.bundles[3], 0x00000000, "sys_bitarray_xor() result unexpected: %x",
687 ba.bundles[3]);
688 zassert_equal(bb.bundles[3], 0x00000000, "sys_bitarray_xor() result unexpected: %x",
689 bb.bundles[3]);
690
691 /* Pre-populate the bits */
692 ba.bundles[0] = 0x80001001;
693 ba.bundles[1] = 0x10000008;
694 ba.bundles[2] = 0xFFFFFFFF;
695 ba.bundles[3] = 0x00000000;
696
697 bb.bundles[0] = 0x80010001;
698 bb.bundles[1] = 0x10000008;
699 bb.bundles[2] = 0xFFFFFFFF;
700 bb.bundles[3] = 0x00000000;
701
702 ret = sys_bitarray_xor(&ba, &bb, 16, 0);
703 zassert_equal(ret, 0, "sys_bitarray_xor() returned unexpected value: %d", ret);
704 zassert_equal(ba.bundles[0], 0x80001000, "sys_bitarray_xor() result unexpected: %x",
705 ba.bundles[0]);
706 zassert_equal(bb.bundles[0], 0x80010001, "sys_bitarray_xor() result unexpected: %x",
707 bb.bundles[0]);
708
709 /* Pre-populate the bits */
710 ba.bundles[0] = 0x80001001;
711 ba.bundles[1] = 0x10000008;
712 ba.bundles[2] = 0xFFFFFFFF;
713 ba.bundles[3] = 0x00000000;
714
715 bb.bundles[0] = 0x80010001;
716 bb.bundles[1] = 0x10000008;
717 bb.bundles[2] = 0xFFFFFFFF;
718 bb.bundles[3] = 0x00000000;
719
720 ret = sys_bitarray_xor(&ba, &bb, 16, 16);
721 zassert_equal(ret, 0, "sys_bitarray_xor() returned unexpected value: %d", ret);
722 zassert_equal(ba.bundles[0], 0x00011001, "sys_bitarray_xor() result unexpected: %x",
723 ba.bundles[0]);
724 zassert_equal(bb.bundles[0], 0x80010001, "sys_bitarray_xor() result unexpected: %x",
725 bb.bundles[0]);
726
727 printk("Testing bit array region xor spanning multiple bundles\n");
728
729 /* Pre-populate the bits */
730 ba.bundles[0] = 0x00000000;
731 ba.bundles[1] = 0xFFFFFFFF;
732 ba.bundles[2] = 0xFFFFFFFF;
733 ba.bundles[3] = 0xFFFFFFFF;
734
735 bb.bundles[0] = 0x00000000;
736 bb.bundles[1] = 0xFFFFFFFF;
737 bb.bundles[2] = 0xFFFFFFFF;
738 bb.bundles[3] = 0xFFFFFFFF;
739
740 ret = sys_bitarray_xor(&ba, &bb, 32*3 - 2, 32 + 1);
741 zassert_equal(ret, 0, "sys_bitarray_xor() returned unexpected value: %d", ret);
742 zassert_equal(ba.bundles[0], 0x00000000, "sys_bitarray_xor() result unexpected: %x",
743 ba.bundles[0]);
744 zassert_equal(ba.bundles[1], 0x00000001, "sys_bitarray_xor() result unexpected: %x",
745 ba.bundles[1]);
746 zassert_equal(ba.bundles[2], 0x00000000, "sys_bitarray_xor() result unexpected: %x",
747 ba.bundles[2]);
748 zassert_equal(ba.bundles[3], 0x80000000, "sys_bitarray_xor() result unexpected: %x",
749 ba.bundles[3]);
750
751 printk("Testing error cases\n");
752 /* Pre-populate the bits */
753 ba.bundles[0] = 0x00000000;
754 ba.bundles[1] = 0x00000000;
755 ba.bundles[2] = 0x00000000;
756 ba.bundles[3] = 0x00000000;
757
758 bb.bundles[0] = 0x00000000;
759 bb.bundles[1] = 0x00000000;
760 bb.bundles[2] = 0x00000000;
761 bb.bundles[3] = 0x00000000;
762
763 bc.bundles[0] = 0x00000000;
764 bc.bundles[1] = 0x00000000;
765 bc.bundles[2] = 0x00000000;
766 bc.bundles[3] = 0x00000000;
767 bc.bundles[4] = 0x00000000;
768
769 ret = sys_bitarray_xor(&ba, &bb, 32, 0);
770 zassert_equal(ret, 0, "sys_bitarray_xor() returned unexpected value: %d", ret);
771 ret = sys_bitarray_xor(&ba, &bc, 32, 0);
772 zassert_equal(ret, -EINVAL, "sys_bitarray_xor() returned unexpected value: %d", ret);
773 ret = sys_bitarray_xor(&bc, &ba, 32, 0);
774 zassert_equal(ret, -EINVAL, "sys_bitarray_xor() returned unexpected value: %d", ret);
775
776 ret = sys_bitarray_xor(&ba, &bb, 128, 0);
777 zassert_equal(ret, 0, "sys_bitarray_xor() returned unexpected value: %d", ret);
778 ret = sys_bitarray_xor(&ba, &bb, 128, 1);
779 zassert_equal(ret, -EINVAL, "sys_bitarray_xor() returned unexpected value: %d", ret);
780 ret = sys_bitarray_xor(&ba, &bb, 129, 0);
781 zassert_equal(ret, -EINVAL, "sys_bitarray_xor() returned unexpected value: %d", ret);
782 ret = sys_bitarray_xor(&ba, &bb, 0, 0);
783 zassert_equal(ret, -EINVAL, "sys_bitarray_xor() returned unexpected value: %d", ret);
784 }
785
ZTEST(bitarray,test_bitarray_find_nth_set)786 ZTEST(bitarray, test_bitarray_find_nth_set)
787 {
788 int ret;
789 size_t found_at;
790
791 /* Bitarrays have embedded spinlocks and can't on the stack. */
792 if (IS_ENABLED(CONFIG_KERNEL_COHERENCE)) {
793 ztest_test_skip();
794 }
795
796 SYS_BITARRAY_DEFINE(ba, 128);
797
798 printk("Testing bit array nth bit set finding spanning single bundle\n");
799
800 /* Pre-populate the bits */
801 ba.bundles[0] = 0x80000001;
802 ba.bundles[1] = 0x80000001;
803 ba.bundles[2] = 0x80000001;
804 ba.bundles[3] = 0x80000001;
805
806 ret = sys_bitarray_find_nth_set(&ba, 1, 1, 0, &found_at);
807 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
808 zassert_equal(found_at, 0, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
809 found_at);
810
811 ret = sys_bitarray_find_nth_set(&ba, 1, 32, 0, &found_at);
812 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
813 zassert_equal(found_at, 0, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
814 found_at);
815
816 ret = sys_bitarray_find_nth_set(&ba, 2, 32, 0, &found_at);
817 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
818 zassert_equal(found_at, 31, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
819 found_at);
820
821 ret = sys_bitarray_find_nth_set(&ba, 1, 31, 1, &found_at);
822 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
823 zassert_equal(found_at, 31, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
824 found_at);
825
826 ret = sys_bitarray_find_nth_set(&ba, 2, 31, 1, &found_at);
827 zassert_equal(ret, 1, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
828
829 printk("Testing bit array nth bit set finding spanning multiple bundles\n");
830
831 ret = sys_bitarray_find_nth_set(&ba, 1, 128, 0, &found_at);
832 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
833 zassert_equal(found_at, 0, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
834 found_at);
835
836 ret = sys_bitarray_find_nth_set(&ba, 8, 128, 0, &found_at);
837 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
838 zassert_equal(found_at, 127,
839 "sys_bitarray_find_nth_set() returned unexpected found_at: %zu", found_at);
840
841 ret = sys_bitarray_find_nth_set(&ba, 8, 128, 1, &found_at);
842 zassert_equal(ret, -EINVAL, "sys_bitarray_find_nth_set() returned unexpected value: %d",
843 ret);
844
845 ret = sys_bitarray_find_nth_set(&ba, 7, 127, 1, &found_at);
846 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
847 zassert_equal(found_at, 127,
848 "sys_bitarray_find_nth_set() returned unexpected found_at: %zu", found_at);
849
850 ret = sys_bitarray_find_nth_set(&ba, 7, 127, 0, &found_at);
851 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
852 zassert_equal(found_at, 96, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
853 found_at);
854
855 ret = sys_bitarray_find_nth_set(&ba, 6, 127, 1, &found_at);
856 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
857 zassert_equal(found_at, 96, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
858 found_at);
859
860 ret = sys_bitarray_find_nth_set(&ba, 6, 127, 1, &found_at);
861 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
862 zassert_equal(found_at, 96, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
863 found_at);
864
865 ret = sys_bitarray_find_nth_set(&ba, 1, 32, 48, &found_at);
866 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
867 zassert_equal(found_at, 63, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
868 found_at);
869
870 ret = sys_bitarray_find_nth_set(&ba, 2, 32, 48, &found_at);
871 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
872 zassert_equal(found_at, 64, "sys_bitarray_find_nth_set() returned unexpected found_at: %zu",
873 found_at);
874
875 printk("Testing error cases\n");
876
877 ret = sys_bitarray_find_nth_set(&ba, 1, 128, 0, &found_at);
878 zassert_equal(ret, 0, "sys_bitarray_find_nth_set() returned unexpected value: %d", ret);
879
880 ret = sys_bitarray_find_nth_set(&ba, 1, 128, 1, &found_at);
881 zassert_equal(ret, -EINVAL, "sys_bitarray_find_nth_set() returned unexpected value: %d",
882 ret);
883
884 ret = sys_bitarray_find_nth_set(&ba, 1, 129, 0, &found_at);
885 zassert_equal(ret, -EINVAL, "sys_bitarray_find_nth_set() returned unexpected value: %d",
886 ret);
887
888 ret = sys_bitarray_find_nth_set(&ba, 0, 128, 0, &found_at);
889 zassert_equal(ret, -EINVAL, "sys_bitarray_find_nth_set() returned unexpected value: %d",
890 ret);
891 }
892
ZTEST(bitarray,test_bitarray_region_set_clear)893 ZTEST(bitarray, test_bitarray_region_set_clear)
894 {
895 int ret;
896
897 /* Bitarrays have embedded spinlocks and can't on the stack. */
898 if (IS_ENABLED(CONFIG_KERNEL_COHERENCE)) {
899 ztest_test_skip();
900 }
901
902 uint32_t ba_expected[4];
903
904 SYS_BITARRAY_DEFINE(ba, 64);
905
906 printk("Testing bit array region bit tests\n");
907
908 /* Pre-populate the bits */
909 ba.bundles[0] = 0xFF0F0F0F;
910 ba.bundles[1] = 0x0F0F0FFF;
911
912 zassert_true(sys_bitarray_is_region_set(&ba, 4, 0));
913 zassert_true(sys_bitarray_is_region_set(&ba, 12, 32));
914 zassert_true(sys_bitarray_is_region_set(&ba, 8, 32));
915 zassert_true(sys_bitarray_is_region_set(&ba, 14, 30));
916 zassert_true(sys_bitarray_is_region_set(&ba, 20, 24));
917
918 zassert_false(sys_bitarray_is_region_cleared(&ba, 4, 0));
919 zassert_false(sys_bitarray_is_region_cleared(&ba, 12, 32));
920 zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 32));
921 zassert_false(sys_bitarray_is_region_cleared(&ba, 14, 30));
922 zassert_false(sys_bitarray_is_region_cleared(&ba, 20, 24));
923
924 ba.bundles[0] = ~ba.bundles[0];
925 ba.bundles[1] = ~ba.bundles[1];
926
927 zassert_true(sys_bitarray_is_region_cleared(&ba, 4, 0));
928 zassert_true(sys_bitarray_is_region_cleared(&ba, 12, 32));
929 zassert_true(sys_bitarray_is_region_cleared(&ba, 8, 32));
930 zassert_true(sys_bitarray_is_region_cleared(&ba, 14, 30));
931 zassert_true(sys_bitarray_is_region_cleared(&ba, 20, 24));
932
933 zassert_false(sys_bitarray_is_region_set(&ba, 4, 0));
934 zassert_false(sys_bitarray_is_region_set(&ba, 12, 32));
935 zassert_false(sys_bitarray_is_region_set(&ba, 8, 32));
936 zassert_false(sys_bitarray_is_region_set(&ba, 14, 30));
937 zassert_false(sys_bitarray_is_region_set(&ba, 20, 24));
938
939 zassert_false(sys_bitarray_is_region_set(&ba, 10, 60));
940 zassert_false(sys_bitarray_is_region_cleared(&ba, 10, 60));
941 zassert_false(sys_bitarray_is_region_set(&ba, 8, 120));
942 zassert_false(sys_bitarray_is_region_cleared(&ba, 8, 120));
943
944 printk("Testing bit array region bit manipulations\n");
945
946 /* Pre-populate the bits */
947 ba.bundles[0] = 0xFF0F0F0F;
948 ba.bundles[1] = 0x0F0F0FFF;
949
950 /* Expected values */
951 ba_expected[0] = 0xFF0F0F0F;
952 ba_expected[1] = 0x0F0F0FFF;
953
954 ret = sys_bitarray_set_region(&ba, 4, 0);
955 zassert_equal(ret, 0, "sys_bitarray_set_region() failed: %d", ret);
956 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
957 "sys_bitarray_set_region() failed bits comparison");
958
959 ret = sys_bitarray_set_region(&ba, 4, 4);
960 ba_expected[0] = 0xFF0F0FFF;
961 zassert_equal(ret, 0, "sys_bitarray_set_region() failed: %d", ret);
962 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
963 "sys_bitarray_set_region() failed bits comparison");
964
965 ret = sys_bitarray_clear_region(&ba, 4, 4);
966 ba_expected[0] = 0xFF0F0F0F;
967 zassert_equal(ret, 0, "sys_bitarray_clear_region() failed: %d", ret);
968 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
969 "sys_bitarray_clear_region() failed bits comparison");
970
971 ret = sys_bitarray_clear_region(&ba, 14, 30);
972 ba_expected[0] = 0x3F0F0F0F;
973 ba_expected[1] = 0x0F0F0000;
974 zassert_equal(ret, 0, "sys_bitarray_clear_region() failed: %d", ret);
975 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
976 "sys_bitarray_clear_region() failed bits comparison");
977
978 ret = sys_bitarray_set_region(&ba, 14, 30);
979 ba_expected[0] = 0xFF0F0F0F;
980 ba_expected[1] = 0x0F0F0FFF;
981 zassert_equal(ret, 0, "sys_bitarray_set_region() failed: %d", ret);
982 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
983 "sys_bitarray_set_region() failed bits comparison");
984
985 ret = sys_bitarray_set_region(&ba, 10, 60);
986 zassert_equal(ret, -EINVAL, "sys_bitarray_set_region() should fail but not");
987 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
988 "sys_bitarray_set_region() failed bits comparison");
989
990 ret = sys_bitarray_set_region(&ba, 8, 120);
991 zassert_equal(ret, -EINVAL, "sys_bitarray_set_region() should fail but not");
992 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
993 "sys_bitarray_set_region() failed bits comparison");
994
995 ret = sys_bitarray_clear_region(&ba, 10, 60);
996 zassert_equal(ret, -EINVAL, "sys_bitarray_clear_region() should fail but not");
997 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
998 "sys_bitarray_clear_region() failed bits comparison");
999
1000 ret = sys_bitarray_clear_region(&ba, 8, 120);
1001 zassert_equal(ret, -EINVAL, "sys_bitarray_clear_region() should fail but not");
1002 zassert_true(cmp_u32_arrays(ba.bundles, ba_expected, ba.num_bundles),
1003 "sys_bitarray_clear_region() failed bits comparison");
1004
1005 SYS_BITARRAY_DEFINE(bw, 128);
1006
1007 /* Pre-populate the bits */
1008 bw.bundles[0] = 0xFF0F0F0F;
1009 bw.bundles[1] = 0xF0000000;
1010 bw.bundles[2] = 0xFFFFFFFF;
1011 bw.bundles[3] = 0x0000000F;
1012
1013 zassert_true(sys_bitarray_is_region_set(&bw, 40, 60));
1014 zassert_false(sys_bitarray_is_region_cleared(&bw, 40, 60));
1015
1016 bw.bundles[2] = 0xFFFEEFFF;
1017
1018 zassert_false(sys_bitarray_is_region_set(&bw, 40, 60));
1019 zassert_false(sys_bitarray_is_region_cleared(&bw, 40, 60));
1020
1021 bw.bundles[1] = 0x0FFFFFFF;
1022 bw.bundles[2] = 0x00000000;
1023 bw.bundles[3] = 0xFFFFFFF0;
1024
1025 zassert_true(sys_bitarray_is_region_cleared(&bw, 40, 60));
1026 zassert_false(sys_bitarray_is_region_set(&bw, 40, 60));
1027
1028 bw.bundles[2] = 0x00011000;
1029
1030 zassert_false(sys_bitarray_is_region_cleared(&bw, 40, 60));
1031 zassert_false(sys_bitarray_is_region_set(&bw, 40, 60));
1032 }
1033
1034 /**
1035 * @brief Test find MSB and LSB operations
1036 *
1037 * @details Verify the functions that find out the most significant
1038 * bit and least significant bit work as expected.
1039 *
1040 * @see find_msb_set(), find_lsb_set()
1041 */
ZTEST(bitarray,test_ffs)1042 ZTEST(bitarray, test_ffs)
1043 {
1044 uint32_t value;
1045 unsigned int bit;
1046
1047 /* boundary test, input is min */
1048 value = 0x0;
1049 zassert_equal(find_msb_set(value), 0, "MSB is not matched");
1050 zassert_equal(find_lsb_set(value), 0, "LSB is not matched");
1051
1052 /* boundary test, input is min + 1 */
1053 value = 0x00000001;
1054 zassert_equal(find_msb_set(value), 1, "MSB is not matched");
1055 zassert_equal(find_lsb_set(value), 1, "LSB is not matched");
1056
1057 /* average value test */
1058 value = 0x80000000;
1059 zassert_equal(find_msb_set(value), 32, "MSB is not matched");
1060 zassert_equal(find_lsb_set(value), 32, "LSB is not matched");
1061
1062 /* mediate value test */
1063 value = 0x000FF000;
1064 zassert_equal(find_msb_set(value), 20, "MSB is not matched");
1065 zassert_equal(find_lsb_set(value), 13, "LSB is not matched");
1066
1067 /* boundary test, input is max */
1068 value = 0xffffffff;
1069 zassert_equal(find_msb_set(value), 32, "MSB is not matched");
1070 zassert_equal(find_lsb_set(value), 1, "LSB is not matched");
1071
1072 /* boundary test, input is max - 1 */
1073 value = 0xfffffffe;
1074 zassert_equal(find_msb_set(value), 32, "MSB is not matched");
1075 zassert_equal(find_lsb_set(value), 2, "LSB is not matched");
1076
1077 /* equivalent class testing, each bit means a class */
1078 for (bit = 0; bit < 32 ; bit++) {
1079 value = 1UL << bit;
1080 zassert_equal(find_msb_set(value), bit + 1, "MSB is not matched");
1081 zassert_equal(find_lsb_set(value), bit + 1, "LSB is not matched");
1082 }
1083 }
1084 /**
1085 * @}
1086 */
1087 extern void *common_setup(void);
1088 ZTEST_SUITE(bitarray, NULL, common_setup, NULL, NULL, NULL);
1089
