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
33 * objdump. The declaration is there to avoid a -Wmissing-prototypes warning.
38 bt_bitfield_write(&glob
, unsigned int, 12, 15, 0x12345678);
41 /* Test array size, in bytes */
44 #define SIGNED_INT_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%X, signed int dest, varying read unit size"
45 #define SIGNED_INT_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%X, signed int source, varying write unit size"
46 #define SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, signed long long dest, varying read unit size"
47 #define SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, signed long long source, varying write unit size"
48 #define UNSIGNED_INT_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%X, unsigned int dest, varying read unit size"
49 #define UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%X, unsigned int source, varying write unit size"
50 #define UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, unsigned long long dest, varying read unit size"
51 #define UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR "Writing and reading back 0x%llX, unsigned long long source, varying write unit size"
52 #define DIAG_FMT_STR(val_type_fmt) "Failed reading value written \"%s\"-wise, with start=%i" \
53 " and length=%i. Read 0x" val_type_fmt
56 unsigned int fls_u64(uint64_t x
)
63 if (!(x
& 0xFFFFFFFF00000000ULL
)) {
67 if (!(x
& 0xFFFF000000000000ULL
)) {
71 if (!(x
& 0xFF00000000000000ULL
)) {
75 if (!(x
& 0xF000000000000000ULL
)) {
79 if (!(x
& 0xC000000000000000ULL
)) {
83 if (!(x
& 0x8000000000000000ULL
)) {
91 unsigned int fls_u32(uint32_t x
)
97 if (!(x
& 0xFFFF0000U
)) {
101 if (!(x
& 0xFF000000U
)) {
105 if (!(x
& 0xF0000000U
)) {
109 if (!(x
& 0xC0000000U
)) {
113 if (!(x
& 0x80000000U
)) {
120 #define print_byte_array(c, len) \
124 for (i = 0; i < (len); i++) { \
125 printf("0x%X", (c)[i]); \
126 if (i != (len) - 1) \
132 #define init_byte_array(c, len, val) \
136 for (i = 0; i < (len); i++) \
140 #define check_result(ref, val, buffer, typename, start, len, \
141 desc_fmt_str, val_type_fmt) \
143 if ((val) != (ref)) { \
144 fail(desc_fmt_str, ref); \
145 diag(DIAG_FMT_STR(val_type_fmt), #typename, start, len, val); \
147 print_byte_array(buffer, TEST_LEN); \
153 void run_test_unsigned_write(unsigned int src_ui
, unsigned long long src_ull
)
155 unsigned int nrbits_ui
, nrbits_ull
;
157 unsigned char c
[TEST_LEN
];
158 unsigned short s
[TEST_LEN
/sizeof(unsigned short)];
159 unsigned int i
[TEST_LEN
/sizeof(unsigned int)];
160 unsigned long l
[TEST_LEN
/sizeof(unsigned long)];
161 unsigned long long ll
[TEST_LEN
/sizeof(unsigned long long)];
163 unsigned long long readval
;
166 /* The number of bits needed to represent 0 is 0. */
167 nrbits_ui
= fls_u32(src_ui
);
169 /* Write from unsigned integer src input. */
170 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
171 for (l
= nrbits_ui
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
172 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
173 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
174 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
175 if (check_result(src_ui
, readval
, target
.c
, unsigned char,
176 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
181 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
182 bt_bitfield_write(target
.s
, unsigned short, s
, l
, src_ui
);
183 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
184 if (check_result(src_ui
, readval
, target
.c
, unsigned short,
185 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
190 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
191 bt_bitfield_write(target
.i
, unsigned int, s
, l
, src_ui
);
192 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
193 if (check_result(src_ui
, readval
, target
.c
, unsigned int,
194 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
199 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
200 bt_bitfield_write(target
.l
, unsigned long, s
, l
, src_ui
);
201 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
202 if (check_result(src_ui
, readval
, target
.c
, unsigned long,
203 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
208 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
209 bt_bitfield_write(target
.ll
, unsigned long long, s
, l
, src_ui
);
210 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
211 if (check_result(src_ui
, readval
, target
.c
, unsigned long long,
212 s
, l
, UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
218 pass(UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR
, src_ui
);
220 /* The number of bits needed to represent 0 is 0. */
221 nrbits_ull
= fls_u64(src_ull
);
223 /* Write from unsigned long long src input. */
224 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
225 for (l
= nrbits_ull
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
226 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
227 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
228 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
229 if (check_result(src_ull
, readval
, target
.c
, unsigned char,
230 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
235 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
236 bt_bitfield_write(target
.s
, unsigned short, s
, l
, src_ull
);
237 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
238 if (check_result(src_ull
, readval
, target
.c
, unsigned short,
239 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
244 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
245 bt_bitfield_write(target
.i
, unsigned int, s
, l
, src_ull
);
246 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
247 if (check_result(src_ull
, readval
, target
.c
, unsigned int,
248 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
253 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
254 bt_bitfield_write(target
.l
, unsigned long, s
, l
, src_ull
);
255 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
256 if (check_result(src_ull
, readval
, target
.c
, unsigned long,
257 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
262 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
263 bt_bitfield_write(target
.ll
, unsigned long long, s
, l
, src_ull
);
264 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval
);
265 if (check_result(src_ull
, readval
, target
.c
, unsigned long long,
266 s
, l
, UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
272 pass(UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
, src_ull
);
276 void run_test_unsigned_read(unsigned int src_ui
, unsigned long long src_ull
)
278 unsigned int nrbits_ui
, nrbits_ull
, readval_ui
;
280 unsigned char c
[TEST_LEN
];
281 unsigned short s
[TEST_LEN
/sizeof(unsigned short)];
282 unsigned int i
[TEST_LEN
/sizeof(unsigned int)];
283 unsigned long l
[TEST_LEN
/sizeof(unsigned long)];
284 unsigned long long ll
[TEST_LEN
/sizeof(unsigned long long)];
286 unsigned long long readval_ull
;
289 /* The number of bits needed to represent 0 is 0. */
290 nrbits_ui
= fls_u32(src_ui
);
292 /* Read to unsigned integer readval output. */
293 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
294 for (l
= nrbits_ui
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
295 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
296 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
297 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval_ui
);
298 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned char,
299 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
304 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
305 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
306 bt_bitfield_read(target
.s
, unsigned short, s
, l
, &readval_ui
);
307 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned short,
308 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
313 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
314 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
315 bt_bitfield_read(target
.i
, unsigned int, s
, l
, &readval_ui
);
316 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned int,
317 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
322 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
323 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
324 bt_bitfield_read(target
.l
, unsigned long, s
, l
, &readval_ui
);
325 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned long,
326 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
331 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
332 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ui
);
333 bt_bitfield_read(target
.ll
, unsigned long long, s
, l
, &readval_ui
);
334 if (check_result(src_ui
, readval_ui
, target
.c
, unsigned long long,
335 s
, l
, UNSIGNED_INT_READ_TEST_DESC_FMT_STR
,
341 pass(UNSIGNED_INT_READ_TEST_DESC_FMT_STR
, src_ui
);
343 /* The number of bits needed to represent 0 is 0. */
344 nrbits_ull
= fls_u64(src_ull
);
346 /* Read to unsigned long long readval output. */
347 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
348 for (l
= nrbits_ull
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
349 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
350 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
351 bt_bitfield_read(target
.c
, unsigned char, s
, l
, &readval_ull
);
352 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned char,
353 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
358 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
359 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
360 bt_bitfield_read(target
.s
, unsigned short, s
, l
, &readval_ull
);
361 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned short,
362 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
367 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
368 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
369 bt_bitfield_read(target
.i
, unsigned int, s
, l
, &readval_ull
);
370 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned int,
371 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
376 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
377 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
378 bt_bitfield_read(target
.l
, unsigned long, s
, l
, &readval_ull
);
379 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned long,
380 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
385 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
386 bt_bitfield_write(target
.c
, unsigned char, s
, l
, src_ull
);
387 bt_bitfield_read(target
.ll
, unsigned long long, s
, l
, &readval_ull
);
388 if (check_result(src_ull
, readval_ull
, target
.c
, unsigned long long,
389 s
, l
, UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
395 pass(UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
, src_ull
);
399 void run_test_unsigned(unsigned int src_ui
, unsigned long long src_ull
)
401 run_test_unsigned_write(src_ui
, src_ull
);
402 run_test_unsigned_read(src_ui
, src_ull
);
406 void run_test_signed_write(int src_i
, long long src_ll
)
408 unsigned int nrbits_i
, nrbits_ll
;
410 signed char c
[TEST_LEN
];
411 short s
[TEST_LEN
/sizeof(short)];
412 int i
[TEST_LEN
/sizeof(int)];
413 long l
[TEST_LEN
/sizeof(long)];
414 long long ll
[TEST_LEN
/sizeof(long long)];
420 nrbits_i
= 0; /* The number of bits needed to represent 0 is 0. */
421 else if (src_i
& 0x80000000U
)
422 nrbits_i
= fls_u32(~src_i
) + 1; /* Find least significant bit conveying sign */
424 nrbits_i
= fls_u32(src_i
) + 1; /* Keep sign at 0 */
426 /* Write from signed integer src input. */
427 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
428 for (l
= nrbits_i
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
429 init_byte_array(target
.c
, TEST_LEN
, 0x0);
430 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
431 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
432 if (check_result(src_i
, readval
, target
.c
, signed char,
433 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
438 init_byte_array(target
.c
, TEST_LEN
, 0x0);
439 bt_bitfield_write(target
.s
, short, s
, l
, src_i
);
440 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
441 if (check_result(src_i
, readval
, target
.c
, short,
442 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
447 init_byte_array(target
.c
, TEST_LEN
, 0x0);
448 bt_bitfield_write(target
.i
, int, s
, l
, src_i
);
449 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
450 if (check_result(src_i
, readval
, target
.c
, int,
451 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
456 init_byte_array(target
.c
, TEST_LEN
, 0x0);
457 bt_bitfield_write(target
.l
, long, s
, l
, src_i
);
458 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
459 if (check_result(src_i
, readval
, target
.c
, long,
460 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
465 init_byte_array(target
.c
, TEST_LEN
, 0x0);
466 bt_bitfield_write(target
.ll
, long long, s
, l
, src_i
);
467 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
468 if (check_result(src_i
, readval
, target
.c
, long long,
469 s
, l
, SIGNED_INT_WRITE_TEST_DESC_FMT_STR
,
475 pass(SIGNED_INT_WRITE_TEST_DESC_FMT_STR
, src_i
);
478 nrbits_ll
= 0; /* The number of bits needed to represent 0 is 0. */
479 else if (src_ll
& 0x8000000000000000ULL
)
480 nrbits_ll
= fls_u64(~src_ll
) + 1; /* Find least significant bit conveying sign */
482 nrbits_ll
= fls_u64(src_ll
) + 1; /* Keep sign at 0 */
484 /* Write from signed long long src input. */
485 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
486 for (l
= nrbits_ll
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
487 init_byte_array(target
.c
, TEST_LEN
, 0x0);
488 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
489 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
490 if (check_result(src_ll
, readval
, target
.c
, signed char,
491 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
496 init_byte_array(target
.c
, TEST_LEN
, 0x0);
497 bt_bitfield_write(target
.s
, short, s
, l
, src_ll
);
498 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
499 if (check_result(src_ll
, readval
, target
.c
, short,
500 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
505 init_byte_array(target
.c
, TEST_LEN
, 0x0);
506 bt_bitfield_write(target
.i
, int, s
, l
, src_ll
);
507 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
508 if (check_result(src_ll
, readval
, target
.c
, int,
509 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
514 init_byte_array(target
.c
, TEST_LEN
, 0x0);
515 bt_bitfield_write(target
.l
, long, s
, l
, src_ll
);
516 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
517 if (check_result(src_ll
, readval
, target
.c
, long,
518 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
523 init_byte_array(target
.c
, TEST_LEN
, 0x0);
524 bt_bitfield_write(target
.ll
, long long, s
, l
, src_ll
);
525 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval
);
526 if (check_result(src_ll
, readval
, target
.c
, long long,
527 s
, l
, SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
,
533 pass(SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR
, src_ll
);
537 void run_test_signed_read(int src_i
, long long src_ll
)
539 unsigned int nrbits_i
, nrbits_ll
;
542 unsigned char c
[TEST_LEN
];
543 unsigned short s
[TEST_LEN
/sizeof(unsigned short)];
544 unsigned int i
[TEST_LEN
/sizeof(unsigned int)];
545 unsigned long l
[TEST_LEN
/sizeof(unsigned long)];
546 unsigned long long ll
[TEST_LEN
/sizeof(unsigned long long)];
548 long long readval_ll
;
552 nrbits_i
= 0; /* The number of bits needed to represent 0 is 0. */
553 else if (src_i
& 0x80000000U
)
554 nrbits_i
= fls_u32(~src_i
) + 1; /* Find least significant bit conveying sign */
556 nrbits_i
= fls_u32(src_i
) + 1; /* Keep sign at 0 */
558 /* Read to signed integer readval output. */
559 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
560 for (l
= nrbits_i
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
561 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
562 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
563 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval_i
);
564 if (check_result(src_i
, readval_i
, target
.c
, signed char,
565 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
570 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
571 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
572 bt_bitfield_read(target
.s
, short, s
, l
, &readval_i
);
573 if (check_result(src_i
, readval_i
, target
.c
, short,
574 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
579 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
580 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
581 bt_bitfield_read(target
.i
, int, s
, l
, &readval_i
);
582 if (check_result(src_i
, readval_i
, target
.c
, int,
583 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
588 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
589 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
590 bt_bitfield_read(target
.l
, long, s
, l
, &readval_i
);
591 if (check_result(src_i
, readval_i
, target
.c
, long,
592 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
597 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
598 bt_bitfield_write(target
.c
, signed char, s
, l
, src_i
);
599 bt_bitfield_read(target
.ll
, long long, s
, l
, &readval_i
);
600 if (check_result(src_i
, readval_i
, target
.c
, long long,
601 s
, l
, SIGNED_INT_READ_TEST_DESC_FMT_STR
,
607 pass(SIGNED_INT_READ_TEST_DESC_FMT_STR
, src_i
);
610 nrbits_ll
= 0; /* The number of bits needed to represent 0 is 0. */
611 if (src_ll
& 0x8000000000000000ULL
)
612 nrbits_ll
= fls_u64(~src_ll
) + 1; /* Find least significant bit conveying sign */
614 nrbits_ll
= fls_u64(src_ll
) + 1; /* Keep sign at 0 */
616 /* Read to signed long long readval output. */
617 for (s
= 0; s
< CHAR_BIT
* TEST_LEN
; s
++) {
618 for (l
= nrbits_ll
; l
<= (CHAR_BIT
* TEST_LEN
) - s
; l
++) {
619 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
620 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
621 bt_bitfield_read(target
.c
, signed char, s
, l
, &readval_ll
);
622 if (check_result(src_ll
, readval_ll
, target
.c
, signed char,
623 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
628 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
629 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
630 bt_bitfield_read(target
.s
, short, s
, l
, &readval_ll
);
631 if (check_result(src_ll
, readval_ll
, target
.c
, short,
632 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
637 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
638 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
639 bt_bitfield_read(target
.i
, int, s
, l
, &readval_ll
);
640 if (check_result(src_ll
, readval_ll
, target
.c
, int,
641 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
646 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
647 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
648 bt_bitfield_read(target
.l
, long, s
, l
, &readval_ll
);
649 if (check_result(src_ll
, readval_ll
, target
.c
, long,
650 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
655 init_byte_array(target
.c
, TEST_LEN
, 0xFF);
656 bt_bitfield_write(target
.c
, signed char, s
, l
, src_ll
);
657 bt_bitfield_read(target
.ll
, long long, s
, l
, &readval_ll
);
658 if (check_result(src_ll
, readval_ll
, target
.c
, long long,
659 s
, l
, SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
,
665 pass(SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR
, src_ll
);
669 void run_test_signed(int src_i
, long long src_ll
)
671 run_test_signed_write(src_i
, src_ll
);
672 run_test_signed_read(src_i
, src_ll
);
680 plan_tests(NR_TESTS
* 8 + 24);
684 run_test_unsigned(0, 0);
685 run_test_signed(0, 0);
686 run_test_unsigned(1, 1);
687 run_test_unsigned(~0U, ~0ULL);
688 run_test_signed(-1U, -1ULL);
689 run_test_signed(0x80000000U
, 0x8000000000000000ULL
);
691 for (i
= 0; i
< NR_TESTS
; i
++) {
692 unsigned int src_ui
= rand();
693 unsigned long long src_ull
= ((unsigned long long) (unsigned int) rand() << 32) |
694 (unsigned long long) (unsigned int) rand();
696 run_test_unsigned(src_ui
, src_ull
);
697 run_test_signed((int) src_ui
, (long long) src_ull
);
702 int print_encodings(unsigned long src
, unsigned int shift
, unsigned int len
)
709 unsigned long long ll
[1];
711 unsigned long long readval
;
713 init_byte_array(target
.c
, 8, 0xFF);
714 bt_bitfield_write(target
.c
, unsigned char, shift
, len
, src
);
715 printf("bytewise\n");
716 print_byte_array(target
.c
, 8);
718 init_byte_array(target
.c
, 8, 0xFF);
719 bt_bitfield_write(target
.s
, unsigned short, shift
, len
, src
);
720 printf("shortwise\n");
721 print_byte_array(target
.c
, 8);
723 init_byte_array(target
.c
, 8, 0xFF);
724 bt_bitfield_write(target
.i
, unsigned int, shift
, len
, src
);
726 print_byte_array(target
.c
, 8);
728 init_byte_array(target
.c
, 8, 0xFF);
729 bt_bitfield_write(target
.l
, unsigned long, shift
, len
, src
);
730 printf("longwise\n");
731 print_byte_array(target
.c
, 8);
733 init_byte_array(target
.c
, 8, 0xFF);
734 bt_bitfield_write(target
.ll
, unsigned long long, shift
, len
, src
);
736 print_byte_array(target
.c
, 8);
738 bt_bitfield_read(target
.c
, unsigned char, shift
, len
, &readval
);
739 printf("read: %llX\n", readval
);
740 print_byte_array(target
.c
, 8);
745 int main(int argc
, char **argv
)
748 /* Print encodings */
750 unsigned int shift
, len
;
754 shift
= atoi(argv
[2]);
761 return print_encodings(src
, shift
, len
);
764 /* Run tap-formated tests */
766 return exit_status();