tests/bitfield/test_bitfield.c

   1 /*
   2  * test-bitfield.c
   3  *
   4  * BabelTrace - bitfield test program
   5  *
   6  * Copyright 2010-2019 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   7  *
   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.
  11  *
  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.
  16  *
  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.
  20  */
  21
  22 #include "compat/bitfield.h"
  23 #include <time.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26
  27 #include <tap/tap.h>
  28
  29 unsigned int glob;
  30
  31 /*
  32  * This function is only declared to show the size of a bitfield write in
  33  * objdump.
  34  */
  35 void fct(void)
  36 {
  37         bt_bitfield_write(&glob, unsigned int, 12, 15, 0x12345678);
  38 }
  39
  40 /* Test array size, in bytes */
  41 #define TEST_LEN 128
  42 #define NR_TESTS 10
  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
  53
  54 static
  55 unsigned int fls_u64(uint64_t x)
  56 {
  57         unsigned int r = 64;
  58
  59         if (!x)
  60                 return 0;
  61
  62         if (!(x & 0xFFFFFFFF00000000ULL)) {
  63                 x <<= 32;
  64                 r -= 32;
  65         }
  66         if (!(x & 0xFFFF000000000000ULL)) {
  67                 x <<= 16;
  68                 r -= 16;
  69         }
  70         if (!(x & 0xFF00000000000000ULL)) {
  71                 x <<= 8;
  72                 r -= 8;
  73         }
  74         if (!(x & 0xF000000000000000ULL)) {
  75                 x <<= 4;
  76                 r -= 4;
  77         }
  78         if (!(x & 0xC000000000000000ULL)) {
  79                 x <<= 2;
  80                 r -= 2;
  81         }
  82         if (!(x & 0x8000000000000000ULL)) {
  83                 x <<= 1;
  84                 r -= 1;
  85         }
  86         return r;
  87 }
  88
  89 static
  90 unsigned int fls_u32(uint32_t x)
  91 {
  92         unsigned int r = 32;
  93
  94         if (!x)
  95                 return 0;
  96         if (!(x & 0xFFFF0000U)) {
  97                 x <<= 16;
  98                 r -= 16;
  99         }
 100         if (!(x & 0xFF000000U)) {
 101                 x <<= 8;
 102                 r -= 8;
 103         }
 104         if (!(x & 0xF0000000U)) {
 105                 x <<= 4;
 106                 r -= 4;
 107         }
 108         if (!(x & 0xC0000000U)) {
 109                 x <<= 2;
 110                 r -= 2;
 111         }
 112         if (!(x & 0x80000000U)) {
 113                 x <<= 1;
 114                 r -= 1;
 115         }
 116         return r;
 117 }
 118
 119 #define print_byte_array(c, len)        \
 120 do {                                    \
 121         unsigned long i;                \
 122                                         \
 123         for (i = 0; i < (len); i++) {   \
 124                 printf("0x%X", (c)[i]); \
 125                 if (i != (len) - 1)     \
 126                         printf(" ");    \
 127         }                               \
 128         printf("\n");                   \
 129 } while (0)
 130
 131 #define init_byte_array(c, len, val)    \
 132 do {                                    \
 133         unsigned long i;                \
 134                                         \
 135         for (i = 0; i < (len); i++)     \
 136                 (c)[i] = (val);         \
 137 } while (0)
 138
 139 #define check_result(ref, val, buffer, typename, start, len,                    \
 140                 desc_fmt_str, val_type_fmt)                                     \
 141 ({                                                                              \
 142         if ((val) != (ref)) {                                                   \
 143                 fail(desc_fmt_str, ref);                                        \
 144                 diag(DIAG_FMT_STR(val_type_fmt), #typename, start, len, val);   \
 145                 printf("# ");                                                   \
 146                 print_byte_array(buffer, TEST_LEN);                             \
 147         }                                                                       \
 148         (val) != (ref);                                                         \
 149 })
 150
 151 void run_test_unsigned_write(unsigned int src_ui, unsigned long long src_ull)
 152 {
 153         unsigned int nrbits_ui, nrbits_ull;
 154         union {
 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)];
 160         } target;
 161         unsigned long long readval;
 162         unsigned int s, l;
 163
 164         /* The number of bits needed to represent 0 is 0. */
 165         nrbits_ui = fls_u32(src_ui);
 166
 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,
 175                                         "%llX")) {
 176                                 return;
 177                         }
 178
 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,
 184                                         "%llX")) {
 185                                 return;
 186                         }
 187
 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,
 193                                         "%llX")) {
 194                                 return;
 195                         }
 196
 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,
 202                                         "%llX")) {
 203                                 return;
 204                         }
 205
 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,
 211                                         "%llX")) {
 212                                 return;
 213                         }
 214                 }
 215         }
 216         pass(UNSIGNED_INT_WRITE_TEST_DESC_FMT_STR, src_ui);
 217
 218         /* The number of bits needed to represent 0 is 0. */
 219         nrbits_ull = fls_u64(src_ull);
 220
 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,
 229                                         "%llX")) {
 230                                 return;
 231                         }
 232
 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,
 238                                         "%llX")) {
 239                                 return;
 240                         }
 241
 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,
 247                                         "%llX")) {
 248                                 return;
 249                         }
 250
 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,
 256                                         "%llX")) {
 257                                 return;
 258                         }
 259
 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,
 265                                         "%llX")) {
 266                                 return;
 267                         }
 268                 }
 269         }
 270         pass(UNSIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR, src_ull);
 271 }
 272
 273 void run_test_unsigned_read(unsigned int src_ui, unsigned long long src_ull)
 274 {
 275         unsigned int nrbits_ui, nrbits_ull, readval_ui;
 276         union {
 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)];
 282         } target;
 283         unsigned long long readval_ull;
 284         unsigned int s, l;
 285
 286         /* The number of bits needed to represent 0 is 0. */
 287         nrbits_ui = fls_u32(src_ui);
 288
 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,
 297                                         "%X")) {
 298                                 return;
 299                         }
 300
 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,
 306                                         "%X")) {
 307                                 return;
 308                         }
 309
 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,
 315                                         "%X")) {
 316                                 return;
 317                         }
 318
 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,
 324                                         "%X")) {
 325                                 return;
 326                         }
 327
 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,
 333                                         "%X")) {
 334                                 return;
 335                         }
 336                 }
 337         }
 338         pass(UNSIGNED_INT_READ_TEST_DESC_FMT_STR, src_ui);
 339
 340         /* The number of bits needed to represent 0 is 0. */
 341         nrbits_ull = fls_u64(src_ull);
 342
 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,
 351                                         "%llX")) {
 352                                 return;
 353                         }
 354
 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,
 360                                         "%llX")) {
 361                                 return;
 362                         }
 363
 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,
 369                                         "%llX")) {
 370                                 return;
 371                         }
 372
 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,
 378                                         "%llX")) {
 379                                 return;
 380                         }
 381
 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,
 387                                         "%llX")) {
 388                                 return;
 389                         }
 390                 }
 391         }
 392         pass(UNSIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR, src_ull);
 393 }
 394
 395 void run_test_unsigned(unsigned int src_ui, unsigned long long src_ull)
 396 {
 397         run_test_unsigned_write(src_ui, src_ull);
 398         run_test_unsigned_read(src_ui, src_ull);
 399 }
 400
 401 void run_test_signed_write(int src_i, long long src_ll)
 402 {
 403         unsigned int nrbits_i, nrbits_ll;
 404         union {
 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)];
 410         } target;
 411         long long readval;
 412         unsigned int s, l;
 413
 414         if (!src_i)
 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 */
 418         else
 419                 nrbits_i = fls_u32(src_i) + 1;  /* Keep sign at 0 */
 420
 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,
 429                                         "%llX")) {
 430                                 return;
 431                         }
 432
 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,
 438                                         "%llX")) {
 439                                 return;
 440                         }
 441
 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,
 447                                         "%llX")) {
 448                                 return;
 449                         }
 450
 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,
 456                                         "%llX")) {
 457                                 return;
 458                         }
 459
 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,
 465                                         "%llX")) {
 466                                 return;
 467                         }
 468                 }
 469         }
 470         pass(SIGNED_INT_WRITE_TEST_DESC_FMT_STR, src_i);
 471
 472         if (!src_ll)
 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 */
 476         else
 477                 nrbits_ll = fls_u64(src_ll) + 1;        /* Keep sign at 0 */
 478
 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,
 487                                         "%llX")) {
 488                                 return;
 489                         }
 490
 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,
 496                                         "%llX")) {
 497                                 return;
 498                         }
 499
 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,
 505                                         "%llX")) {
 506                                 return;
 507                         }
 508
 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,
 514                                         "%llX")) {
 515                                 return;
 516                         }
 517
 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,
 523                                         "%llX")) {
 524                                 return;
 525                         }
 526                 }
 527         }
 528         pass(SIGNED_LONG_LONG_WRITE_TEST_DESC_FMT_STR, src_ll);
 529 }
 530
 531 void run_test_signed_read(int src_i, long long src_ll)
 532 {
 533         unsigned int nrbits_i, nrbits_ll;
 534         int readval_i;
 535         union {
 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)];
 541         } target;
 542         long long readval_ll;
 543         unsigned int s, l;
 544
 545         if (!src_i)
 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 */
 549         else
 550                 nrbits_i = fls_u32(src_i) + 1;  /* Keep sign at 0 */
 551
 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,
 560                                         "%X")) {
 561                                 return;
 562                         }
 563
 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,
 569                                         "%X")) {
 570                                 return;
 571                         }
 572
 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,
 578                                         "%X")) {
 579                                 return;
 580                         }
 581
 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,
 587                                         "%X")) {
 588                                 return;
 589                         }
 590
 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,
 596                                         "%X")) {
 597                                 return;
 598                         }
 599                 }
 600         }
 601         pass(SIGNED_INT_READ_TEST_DESC_FMT_STR, src_i);
 602
 603         if (!src_ll)
 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 */
 607         else
 608                 nrbits_ll = fls_u64(src_ll) + 1;        /* Keep sign at 0 */
 609
 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,
 618                                         "%llX")) {
 619                                 return;
 620                         }
 621
 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,
 627                                         "%llX")) {
 628                                 return;
 629                         }
 630
 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,
 636                                         "%llX")) {
 637                                 return;
 638                         }
 639
 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,
 645                                         "%llX")) {
 646                                 return;
 647                         }
 648
 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,
 654                                         "%llX")) {
 655                                 return;
 656                         }
 657                 }
 658         }
 659         pass(SIGNED_LONG_LONG_READ_TEST_DESC_FMT_STR, src_ll);
 660 }
 661
 662 void run_test_signed(int src_i, long long src_ll)
 663 {
 664         run_test_signed_write(src_i, src_ll);
 665         run_test_signed_read(src_i, src_ll);
 666 }
 667
 668 void run_test(void)
 669 {
 670         int i;
 671
 672         plan_tests(NR_TESTS * 8 + 24);
 673
 674         srand(time(NULL));
 675
 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);
 682
 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();
 687
 688                 run_test_unsigned(src_ui, src_ull);
 689                 run_test_signed((int) src_ui, (long long) src_ull);
 690         }
 691 }
 692
 693 static
 694 int print_encodings(unsigned long src, unsigned int shift, unsigned int len)
 695 {
 696         union {
 697                 unsigned char c[8];
 698                 unsigned short s[4];
 699                 unsigned int i[2];
 700                 unsigned long l[2];
 701                 unsigned long long ll[1];
 702         } target;
 703         unsigned long long readval;
 704
 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);
 709
 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);
 714
 715         init_byte_array(target.c, 8, 0xFF);
 716         bt_bitfield_write(target.i, unsigned int, shift, len, src);
 717         printf("intwise\n");
 718         print_byte_array(target.c, 8);
 719
 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);
 724
 725         init_byte_array(target.c, 8, 0xFF);
 726         bt_bitfield_write(target.ll, unsigned long long, shift, len, src);
 727         printf("lluwise\n");
 728         print_byte_array(target.c, 8);
 729
 730         bt_bitfield_read(target.c, unsigned char, shift, len, &readval);
 731         printf("read: %llX\n", readval);
 732         print_byte_array(target.c, 8);
 733
 734         return 0;
 735 }
 736
 737 int main(int argc, char **argv)
 738 {
 739         if (argc > 1) {
 740                 /* Print encodings */
 741                 unsigned long src;
 742                 unsigned int shift, len;
 743
 744                 src = atoi(argv[1]);
 745                 if (argc > 2)
 746                         shift = atoi(argv[2]);
 747                 else
 748                         shift = 12;
 749                 if (argc > 3)
 750                         len = atoi(argv[3]);
 751                 else
 752                         len = 40;
 753                 return print_encodings(src, shift, len);
 754         }
 755
 756         /* Run tap-formated tests */
 757         run_test();
 758         return exit_status();
 759 }