4 * BabelTrace - bitfield test program
6 * Copyright 2010-2019 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; under version 2 of the License.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include "compat/bitfield.h"
32 * This function is only declared to show the size of a bitfield write in
37 bt_bitfield_write(&glob
, unsigned int, 12, 15, 0x12345678);
40 /* Test array size, in bytes */
43 #define SIGNED_INT_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%X, signed int dest, varying read unit size"
44 #define SIGNED_INT_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%X, signed int source, varying write unit size"
45 #define SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, signed long long dest, varying read unit size"
46 #define SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, signed long long source, varying write unit size"
47 #define UNSIGNED_INT_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%X, unsigned int dest, varying read unit size"
48 #define UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%X, unsigned int source, varying write unit size"
49 #define UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, unsigned long long dest, varying read unit size"
50 #define UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, unsigned long long source, varying write unit size"
51 #define DIAG_FMT_STR(val_type_fmt) "Failed reading value written \"%s\"-wise, with start=%i" \
52 " and length=%i. Read 0x" val_type_fmt
55 unsigned int fls_u64(uint64_t x
)
62 if (!(x
& 0xFFFFFFFF00000000ULL
)) {
66 if (!(x
& 0xFFFF000000000000ULL
)) {
70 if (!(x
& 0xFF00000000000000ULL
)) {
74 if (!(x
& 0xF000000000000000ULL
)) {
78 if (!(x
& 0xC000000000000000ULL
)) {
82 if (!(x
& 0x8000000000000000ULL
)) {
90 unsigned int fls_u32(uint32_t x
)
96 if (!(x
& 0xFFFF0000U
)) {
100 if (!(x
& 0xFF000000U
)) {
104 if (!(x
& 0xF0000000U
)) {
108 if (!(x
& 0xC0000000U
)) {
112 if (!(x
& 0x80000000U
)) {
119 #define print_byte_array(c, len) \
123 for (i = 0; i < (len); i++) { \
124 printf("0x%X", (c)[i]); \
125 if (i != (len) - 1) \
131 #define init_byte_array(c, len, val) \
135 for (i = 0; i < (len); i++) \
139 #define check_result(ref, val, buffer, typename, start, len, \
140 desc_fmt_str, val_type_fmt) \
142 if ((val) != (ref)) { \
143 fail(desc_fmt_str, ref); \
144 diag(DIAG_FMT_STR(val_type_fmt), #typename, start, len, val); \
146 print_byte_array(buffer, TEST_LEN); \
151 void run_test_unsigned_write(unsigned int src_ui
, unsigned long long src_ull
)
153 unsigned int nrbits_ui
, nrbits_ull
;
155 unsigned char c
[TEST_LEN
];
156 unsigned short s
[TEST_LEN
/sizeof(unsigned short)];
157 unsigned int i
[TEST_LEN
/sizeof(unsigned int)];
158 unsigned long l
[TEST_LEN
/sizeof(unsigned long)];
159 unsigned long long ll
[TEST_LEN
/sizeof(unsigned long long)];
161 unsigned long long readval
;
164 /* The number of bits needed to represent 0 is 0. */
165 nrbits_ui
= fls_u32(src_ui
);
167 /* Write from unsigned integer src input. */
168 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
169 for (l
= nrbits_ui
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
170 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
171 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
172 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
173 if (check_result(src_ui
, readval
, target
.c
, unsigned char,
174 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
179 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
180 bt_bitfield_write(target
.s
, unsigned short, s
, l
, src_ui
);
181 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
182 if (check_result(src_ui
, readval
, target
.c
, unsigned short,
183 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
188 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
189 bt_bitfield_write(target
.i
, unsigned int, s
, l
, src_ui
);
190 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
191 if (check_result(src_ui
, readval
, target
.c
, unsigned int,
192 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
197 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
198 bt_bitfield_write(target
.l
, unsigned long, s
, l
, src_ui
);
199 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
200 if (check_result(src_ui
, readval
, target
.c
, unsigned long,
201 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
206 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
207 bt_bitfield_write(target
.ll
, unsigned long long, s
, l
, src_ui
);
208 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
209 if (check_result(src_ui
, readval
, target
.c
, unsigned long long,
210 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
216 pass(UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
, src_ui
);
218 /* The number of bits needed to represent 0 is 0. */
219 nrbits_ull
= fls_u64(src_ull
);
221 /* Write from unsigned long long src input. */
222 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
223 for (l
= nrbits_ull
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
224 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
225 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
226 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
227 if (check_result(src_ull
, readval
, target
.c
, unsigned char,
228 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
233 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
234 bt_bitfield_write(target
.s
, unsigned short, s
, l
, src_ull
);
235 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
236 if (check_result(src_ull
, readval
, target
.c
, unsigned short,
237 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
242 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
243 bt_bitfield_write(target
.i
, unsigned int, s
, l
, src_ull
);
244 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
245 if (check_result(src_ull
, readval
, target
.c
, unsigned int,
246 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
251 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
252 bt_bitfield_write(target
.l
, unsigned long, s
, l
, src_ull
);
253 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
254 if (check_result(src_ull
, readval
, target
.c
, unsigned long,
255 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
260 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
261 bt_bitfield_write(target
.ll
, unsigned long long, s
, l
, src_ull
);
262 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
263 if (check_result(src_ull
, readval
, target
.c
, unsigned long long,
264 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
270 pass(UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
, src_ull
);
273 void run_test_unsigned_read(unsigned int src_ui
, unsigned long long src_ull
)
275 unsigned int nrbits_ui
, nrbits_ull
, readval_ui
;
277 unsigned char c
[TEST_LEN
];
278 unsigned short s
[TEST_LEN
/sizeof(unsigned short)];
279 unsigned int i
[TEST_LEN
/sizeof(unsigned int)];
280 unsigned long l
[TEST_LEN
/sizeof(unsigned long)];
281 unsigned long long ll
[TEST_LEN
/sizeof(unsigned long long)];
283 unsigned long long readval_ull
;
286 /* The number of bits needed to represent 0 is 0. */
287 nrbits_ui
= fls_u32(src_ui
);
289 /* Read to unsigned integer readval output. */
290 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
291 for (l
= nrbits_ui
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
292 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
293 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
294 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval_ui
);
295 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned char,
296 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
301 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
302 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
303 bt_bitfield_read(target
.s
, unsigned short, s
, l
, &readval_ui
);
304 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned short,
305 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
310 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
311 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
312 bt_bitfield_read(target
.i
, unsigned int, s
, l
, &readval_ui
);
313 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned int,
314 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
319 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
320 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
321 bt_bitfield_read(target
.l
, unsigned long, s
, l
, &readval_ui
);
322 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned long,
323 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
328 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
329 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
330 bt_bitfield_read(target
.ll
, unsigned long long, s
, l
, &readval_ui
);
331 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned long long,
332 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
338 pass(UNSIGNED_INT_READ_TEST_DESC_FMT_STR
, src_ui
);
340 /* The number of bits needed to represent 0 is 0. */
341 nrbits_ull
= fls_u64(src_ull
);
343 /* Read to unsigned long long readval output. */
344 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
345 for (l
= nrbits_ull
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
346 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
347 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
348 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval_ull
);
349 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned char,
350 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
355 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
356 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
357 bt_bitfield_read(target
.s
, unsigned short, s
, l
, &readval_ull
);
358 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned short,
359 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
364 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
365 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
366 bt_bitfield_read(target
.i
, unsigned int, s
, l
, &readval_ull
);
367 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned int,
368 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
373 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
374 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
375 bt_bitfield_read(target
.l
, unsigned long, s
, l
, &readval_ull
);
376 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned long,
377 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
382 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
383 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
384 bt_bitfield_read(target
.ll
, unsigned long long, s
, l
, &readval_ull
);
385 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned long long,
386 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
392 pass(UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
, src_ull
);
395 void run_test_unsigned(unsigned int src_ui
, unsigned long long src_ull
)
397 run_test_unsigned_write(src_ui
, src_ull
);
398 run_test_unsigned_read(src_ui
, src_ull
);
401 void run_test_signed_write(int src_i
, long long src_ll
)
403 unsigned int nrbits_i
, nrbits_ll
;
405 signed char c
[TEST_LEN
];
406 short s
[TEST_LEN
/sizeof(short)];
407 int i
[TEST_LEN
/sizeof(int)];
408 long l
[TEST_LEN
/sizeof(long)];
409 long long ll
[TEST_LEN
/sizeof(long long)];
415 nrbits_i
= 0; /* The number of bits needed to represent 0 is 0. */
416 else if (src_i
& 0x80000000U
)
417 nrbits_i
= fls_u32(~src_i
) + 1; /* Find least significant bit conveying sign */
419 nrbits_i
= fls_u32(src_i
) + 1; /* Keep sign at 0 */
421 /* Write from signed integer src input. */
422 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
423 for (l
= nrbits_i
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
424 init_byte_array(target
.c
, TEST_LEN
, 0x0);
425 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
426 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
427 if (check_result(src_i
, readval
, target
.c
, signed char,
428 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
433 init_byte_array(target
.c
, TEST_LEN
, 0x0);
434 bt_bitfield_write(target
.s
, short, s
, l
, src_i
);
435 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
436 if (check_result(src_i
, readval
, target
.c
, short,
437 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
442 init_byte_array(target
.c
, TEST_LEN
, 0x0);
443 bt_bitfield_write(target
.i
, int, s
, l
, src_i
);
444 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
445 if (check_result(src_i
, readval
, target
.c
, int,
446 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
451 init_byte_array(target
.c
, TEST_LEN
, 0x0);
452 bt_bitfield_write(target
.l
, long, s
, l
, src_i
);
453 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
454 if (check_result(src_i
, readval
, target
.c
, long,
455 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
460 init_byte_array(target
.c
, TEST_LEN
, 0x0);
461 bt_bitfield_write(target
.ll
, long long, s
, l
, src_i
);
462 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
463 if (check_result(src_i
, readval
, target
.c
, long long,
464 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
470 pass(SIGNED_INT_WRITE_TEST_DESC_FMT_STR
, src_i
);
473 nrbits_ll
= 0; /* The number of bits needed to represent 0 is 0. */
474 else if (src_ll
& 0x8000000000000000ULL
)
475 nrbits_ll
= fls_u64(~src_ll
) + 1; /* Find least significant bit conveying sign */
477 nrbits_ll
= fls_u64(src_ll
) + 1; /* Keep sign at 0 */
479 /* Write from signed long long src input. */
480 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
481 for (l
= nrbits_ll
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
482 init_byte_array(target
.c
, TEST_LEN
, 0x0);
483 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
484 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
485 if (check_result(src_ll
, readval
, target
.c
, signed char,
486 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
491 init_byte_array(target
.c
, TEST_LEN
, 0x0);
492 bt_bitfield_write(target
.s
, short, s
, l
, src_ll
);
493 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
494 if (check_result(src_ll
, readval
, target
.c
, short,
495 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
500 init_byte_array(target
.c
, TEST_LEN
, 0x0);
501 bt_bitfield_write(target
.i
, int, s
, l
, src_ll
);
502 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
503 if (check_result(src_ll
, readval
, target
.c
, int,
504 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
509 init_byte_array(target
.c
, TEST_LEN
, 0x0);
510 bt_bitfield_write(target
.l
, long, s
, l
, src_ll
);
511 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
512 if (check_result(src_ll
, readval
, target
.c
, long,
513 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
518 init_byte_array(target
.c
, TEST_LEN
, 0x0);
519 bt_bitfield_write(target
.ll
, long long, s
, l
, src_ll
);
520 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
521 if (check_result(src_ll
, readval
, target
.c
, long long,
522 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
528 pass(SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
, src_ll
);
531 void run_test_signed_read(int src_i
, long long src_ll
)
533 unsigned int nrbits_i
, nrbits_ll
;
536 unsigned char c
[TEST_LEN
];
537 unsigned short s
[TEST_LEN
/sizeof(unsigned short)];
538 unsigned int i
[TEST_LEN
/sizeof(unsigned int)];
539 unsigned long l
[TEST_LEN
/sizeof(unsigned long)];
540 unsigned long long ll
[TEST_LEN
/sizeof(unsigned long long)];
542 long long readval_ll
;
546 nrbits_i
= 0; /* The number of bits needed to represent 0 is 0. */
547 else if (src_i
& 0x80000000U
)
548 nrbits_i
= fls_u32(~src_i
) + 1; /* Find least significant bit conveying sign */
550 nrbits_i
= fls_u32(src_i
) + 1; /* Keep sign at 0 */
552 /* Read to signed integer readval output. */
553 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
554 for (l
= nrbits_i
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
555 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
556 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
557 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval_i
);
558 if (check_result(src_i
, readval_i
, target
.c
, signed char,
559 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
564 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
565 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
566 bt_bitfield_read(target
.s
, short, s
, l
, &readval_i
);
567 if (check_result(src_i
, readval_i
, target
.c
, short,
568 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
573 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
574 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
575 bt_bitfield_read(target
.i
, int, s
, l
, &readval_i
);
576 if (check_result(src_i
, readval_i
, target
.c
, int,
577 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
582 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
583 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
584 bt_bitfield_read(target
.l
, long, s
, l
, &readval_i
);
585 if (check_result(src_i
, readval_i
, target
.c
, long,
586 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
591 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
592 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
593 bt_bitfield_read(target
.ll
, long long, s
, l
, &readval_i
);
594 if (check_result(src_i
, readval_i
, target
.c
, long long,
595 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
601 pass(SIGNED_INT_READ_TEST_DESC_FMT_STR
, src_i
);
604 nrbits_ll
= 0; /* The number of bits needed to represent 0 is 0. */
605 if (src_ll
& 0x8000000000000000ULL
)
606 nrbits_ll
= fls_u64(~src_ll
) + 1; /* Find least significant bit conveying sign */
608 nrbits_ll
= fls_u64(src_ll
) + 1; /* Keep sign at 0 */
610 /* Read to signed long long readval output. */
611 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
612 for (l
= nrbits_ll
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
613 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
614 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
615 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval_ll
);
616 if (check_result(src_ll
, readval_ll
, target
.c
, signed char,
617 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
622 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
623 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
624 bt_bitfield_read(target
.s
, short, s
, l
, &readval_ll
);
625 if (check_result(src_ll
, readval_ll
, target
.c
, short,
626 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
631 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
632 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
633 bt_bitfield_read(target
.i
, int, s
, l
, &readval_ll
);
634 if (check_result(src_ll
, readval_ll
, target
.c
, int,
635 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
640 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
641 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
642 bt_bitfield_read(target
.l
, long, s
, l
, &readval_ll
);
643 if (check_result(src_ll
, readval_ll
, target
.c
, long,
644 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
649 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
650 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
651 bt_bitfield_read(target
.ll
, long long, s
, l
, &readval_ll
);
652 if (check_result(src_ll
, readval_ll
, target
.c
, long long,
653 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
659 pass(SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
, src_ll
);
662 void run_test_signed(int src_i
, long long src_ll
)
664 run_test_signed_write(src_i
, src_ll
);
665 run_test_signed_read(src_i
, src_ll
);
672 plan_tests(NR_TESTS
* 8 + 24);
676 run_test_unsigned(0, 0);
677 run_test_signed(0, 0);
678 run_test_unsigned(1, 1);
679 run_test_unsigned(~0U, ~0ULL);
680 run_test_signed(-1U, -1ULL);
681 run_test_signed(0x80000000U
, 0x8000000000000000ULL
);
683 for (i
= 0; i
< NR_TESTS
; i
++) {
684 unsigned int src_ui
= rand();
685 unsigned long long src_ull
= ((unsigned long long) (unsigned int) rand() << 32) |
686 (unsigned long long) (unsigned int) rand();
688 run_test_unsigned(src_ui
, src_ull
);
689 run_test_signed((int) src_ui
, (long long) src_ull
);
694 int print_encodings(unsigned long src
, unsigned int shift
, unsigned int len
)
701 unsigned long long ll
[1];
703 unsigned long long readval
;
705 init_byte_array(target
.c
, 8, 0xFF);
706 bt_bitfield_write(target
.c
, unsigned char, shift
, len
, src
);
707 printf("bytewise\n");
708 print_byte_array(target
.c
, 8);
710 init_byte_array(target
.c
, 8, 0xFF);
711 bt_bitfield_write(target
.s
, unsigned short, shift
, len
, src
);
712 printf("shortwise\n");
713 print_byte_array(target
.c
, 8);
715 init_byte_array(target
.c
, 8, 0xFF);
716 bt_bitfield_write(target
.i
, unsigned int, shift
, len
, src
);
718 print_byte_array(target
.c
, 8);
720 init_byte_array(target
.c
, 8, 0xFF);
721 bt_bitfield_write(target
.l
, unsigned long, shift
, len
, src
);
722 printf("longwise\n");
723 print_byte_array(target
.c
, 8);
725 init_byte_array(target
.c
, 8, 0xFF);
726 bt_bitfield_write(target
.ll
, unsigned long long, shift
, len
, src
);
728 print_byte_array(target
.c
, 8);
730 bt_bitfield_read(target
.c
, unsigned char, shift
, len
, &readval
);
731 printf("read: %llX\n", readval
);
732 print_byte_array(target
.c
, 8);
737 int main(int argc
, char **argv
)
740 /* Print encodings */
742 unsigned int shift
, len
;
746 shift
= atoi(argv
[2]);
753 return print_encodings(src
, shift
, len
);
756 /* Run tap-formated tests */
758 return exit_status();