tests/sys/sys/bitstring_test.c

   1 /*-
   2  * Copyright (c) 2014 Spectra Logic Corporation
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    substantially similar to the "NO WARRANTY" disclaimer below
  13  *    ("Disclaimer") and any redistribution must be conditioned upon
  14  *    including a substantially similar Disclaimer requirement for further
  15  *    binary redistribution.
  16  *
  17  * NO WARRANTY
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  27  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGES.
  29  *
  30  * $FreeBSD$
  31  */
  32 #include <sys/param.h>
  33
  34 #include <bitstring.h>
  35 #include <stdio.h>
  36
  37 #include <atf-c.h>
  38
  39 typedef void (testfunc_t)(bitstr_t *bstr, int nbits, const char *memloc);
  40
  41 static void
  42 bitstring_run_stack_test(testfunc_t *test, int nbits)
  43 {
  44         bitstr_t bit_decl(bitstr, nbits);
  45
  46         test(bitstr, nbits, "stack");
  47 }
  48
  49 static void
  50 bitstring_run_heap_test(testfunc_t *test, int nbits)
  51 {
  52         bitstr_t *bitstr = bit_alloc(nbits);
  53
  54         test(bitstr, nbits, "heap");
  55 }
  56
  57 static void
  58 bitstring_test_runner(testfunc_t *test)
  59 {
  60         const int bitstr_sizes[] = {
  61                 0,
  62                 1,
  63                 _BITSTR_BITS - 1,
  64                 _BITSTR_BITS,
  65                 _BITSTR_BITS + 1,
  66                 2 * _BITSTR_BITS - 1,
  67                 2 * _BITSTR_BITS,
  68                 1023,
  69                 1024
  70         };
  71
  72         for (unsigned long i = 0; i < nitems(bitstr_sizes); i++) {
  73                 bitstring_run_stack_test(test, bitstr_sizes[i]);
  74                 bitstring_run_heap_test(test, bitstr_sizes[i]);
  75         }
  76 }
  77
  78 #define BITSTRING_TC_DEFINE(name)                               \
  79 ATF_TC_WITHOUT_HEAD(name);                                      \
  80 static testfunc_t name ## _test;                                \
  81                                                                 \
  82 ATF_TC_BODY(name, tc)                                           \
  83 {                                                               \
  84         bitstring_test_runner(name ## _test);                   \
  85 }                                                               \
  86                                                                 \
  87 static void                                                     \
  88 name ## _test(bitstr_t *bitstr, int nbits, const char *memloc)
  89
  90 #define BITSTRING_TC_ADD(tp, name)                              \
  91 do {                                                            \
  92         ATF_TP_ADD_TC(tp, name);                                \
  93 } while (0)
  94
  95 ATF_TC_WITHOUT_HEAD(bitstr_in_struct);
  96 ATF_TC_BODY(bitstr_in_struct, tc)
  97 {
  98         struct bitstr_containing_struct {
  99                 bitstr_t bit_decl(bitstr, 8);
 100         } test_struct;
 101
 102         bit_nclear(test_struct.bitstr, 0, 8);
 103 }
 104
 105 ATF_TC_WITHOUT_HEAD(bitstr_size);
 106 ATF_TC_BODY(bitstr_size, tc)
 107 {
 108         size_t sob = sizeof(bitstr_t);
 109
 110         ATF_CHECK_EQ(0, bitstr_size(0));
 111         ATF_CHECK_EQ(sob, bitstr_size(1));
 112         ATF_CHECK_EQ(sob, bitstr_size(sob * 8));
 113         ATF_CHECK_EQ(2 * sob, bitstr_size(sob * 8 + 1));
 114 }
 115
 116 BITSTRING_TC_DEFINE(bit_set)
 117 /* bitstr_t *bitstr, int nbits, const char *memloc */
 118 {
 119         memset(bitstr, 0, bitstr_size(nbits));
 120
 121         for (int i = 0; i < nbits; i++) {
 122                 bit_set(bitstr, i);
 123
 124                 for (int j = 0; j < nbits; j++) {
 125                         ATF_REQUIRE_MSG(bit_test(bitstr, j) == (j == i) ? 1 : 0,
 126                             "bit_set_%d_%s: Failed on bit %d",
 127                             nbits, memloc, i);
 128                 }
 129
 130                 bit_clear(bitstr, i);
 131         }
 132 }
 133
 134 BITSTRING_TC_DEFINE(bit_clear)
 135 /* bitstr_t *bitstr, int nbits, const char *memloc */
 136 {
 137         int i, j;
 138
 139         memset(bitstr, 0xFF, bitstr_size(nbits));
 140         for (i = 0; i < nbits; i++) {
 141                 bit_clear(bitstr, i);
 142
 143                 for (j = 0; j < nbits; j++) {
 144                         ATF_REQUIRE_MSG(bit_test(bitstr, j) == (j == i) ? 0 : 1,
 145                             "bit_clear_%d_%s: Failed on bit %d",
 146                             nbits, memloc, i);
 147                 }
 148
 149                 bit_set(bitstr, i);
 150         }
 151 }
 152
 153 BITSTRING_TC_DEFINE(bit_ffs)
 154 /* bitstr_t *bitstr, int nbits, const char *memloc */
 155 {
 156         int i;
 157         int found_set_bit;
 158
 159         memset(bitstr, 0, bitstr_size(nbits));
 160         bit_ffs(bitstr, nbits, &found_set_bit);
 161         ATF_REQUIRE_MSG(found_set_bit == -1,
 162             "bit_ffs_%d_%s: Failed all clear bits.", nbits, memloc);
 163
 164         for (i = 0; i < nbits; i++) {
 165                 memset(bitstr, 0xFF, bitstr_size(nbits));
 166                 if (i > 0)
 167                         bit_nclear(bitstr, 0, i - 1);
 168
 169                 bit_ffs(bitstr, nbits, &found_set_bit);
 170                 ATF_REQUIRE_MSG(found_set_bit == i,
 171                     "bit_ffs_%d_%s: Failed on bit %d, Result %d",
 172                     nbits, memloc, i, found_set_bit);
 173         }
 174 }
 175
 176 BITSTRING_TC_DEFINE(bit_ffc)
 177 /* bitstr_t *bitstr, int nbits, const char *memloc */
 178 {
 179         int i;
 180         int found_clear_bit;
 181
 182         memset(bitstr, 0xFF, bitstr_size(nbits));
 183         bit_ffc(bitstr, nbits, &found_clear_bit);
 184         ATF_REQUIRE_MSG(found_clear_bit == -1,
 185             "bit_ffc_%d_%s: Failed all set bits.", nbits, memloc);
 186
 187         for (i = 0; i < nbits; i++) {
 188                 memset(bitstr, 0, bitstr_size(nbits));
 189                 if (i > 0)
 190                         bit_nset(bitstr, 0, i - 1);
 191
 192                 bit_ffc(bitstr, nbits, &found_clear_bit);
 193                 ATF_REQUIRE_MSG(found_clear_bit == i,
 194                     "bit_ffc_%d_%s: Failed on bit %d, Result %d",
 195                     nbits, memloc, i, found_clear_bit);
 196         }
 197 }
 198
 199 BITSTRING_TC_DEFINE(bit_ffs_at)
 200 /* bitstr_t *bitstr, int nbits, const char *memloc */
 201 {
 202         int i;
 203         int found_set_bit;
 204
 205         memset(bitstr, 0xFF, bitstr_size(nbits));
 206         for (i = 0; i < nbits; i++) {
 207                 bit_ffs_at(bitstr, i, nbits, &found_set_bit);
 208                 ATF_REQUIRE_MSG(found_set_bit == i,
 209                     "bit_ffs_at_%d_%s: Failed on bit %d, Result %d",
 210                     nbits, memloc, i, found_set_bit);
 211         }
 212
 213         memset(bitstr, 0, bitstr_size(nbits));
 214         for (i = 0; i < nbits; i++) {
 215                 bit_ffs_at(bitstr, i, nbits, &found_set_bit);
 216                 ATF_REQUIRE_MSG(found_set_bit == -1,
 217                     "bit_ffs_at_%d_%s: Failed on bit %d, Result %d",
 218                     nbits, memloc, i, found_set_bit);
 219         }
 220
 221         memset(bitstr, 0x55, bitstr_size(nbits));
 222         for (i = 0; i < nbits; i++) {
 223                 bit_ffs_at(bitstr, i, nbits, &found_set_bit);
 224                 if (i == nbits - 1 && (nbits & 1) == 0) {
 225                         ATF_REQUIRE_MSG(found_set_bit == -1,
 226                             "bit_ffs_at_%d_%s: Failed on bit %d, Result %d",
 227                             nbits, memloc, i, found_set_bit);
 228                 } else {
 229                         ATF_REQUIRE_MSG(found_set_bit == i + (i & 1),
 230                             "bit_ffs_at_%d_%s: Failed on bit %d, Result %d",
 231                             nbits, memloc, i, found_set_bit);
 232                 }
 233         }
 234
 235         memset(bitstr, 0xAA, bitstr_size(nbits));
 236         for (i = 0; i < nbits; i++) {
 237                 bit_ffs_at(bitstr, i, nbits, &found_set_bit);
 238                 if (i == nbits - 1 && (nbits & 1) != 0) {
 239                         ATF_REQUIRE_MSG(found_set_bit == -1,
 240                             "bit_ffs_at_%d_%s: Failed on bit %d, Result %d",
 241                             nbits, memloc, i, found_set_bit);
 242                 } else {
 243                         ATF_REQUIRE_MSG(
 244                             found_set_bit == i + ((i & 1) ? 0 : 1),
 245                             "bit_ffs_at_%d_%s: Failed on bit %d, Result %d",
 246                             nbits, memloc, i, found_set_bit);
 247                 }
 248         }
 249
 250         /* Pass a start value beyond the size of the bit string */
 251         bit_ffs_at(bitstr, nbits, nbits, &found_set_bit);
 252         ATF_REQUIRE_MSG(found_set_bit == -1,
 253                         "bit_ffs_at_%d_%s: Failed with high start value of %d, Result %d",
 254                         nbits, memloc, nbits, found_set_bit);
 255
 256         bit_ffs_at(bitstr, nbits + 3, nbits, &found_set_bit);
 257         ATF_REQUIRE_MSG(found_set_bit == -1,
 258                         "bit_ffs_at_%d_%s: Failed with high start value of %d, Result %d",
 259                         nbits, memloc, nbits + 3, found_set_bit);
 260 }
 261
 262 BITSTRING_TC_DEFINE(bit_ffc_at)
 263 /* bitstr_t *bitstr, int nbits, const char *memloc */
 264 {
 265         int i, found_clear_bit;
 266
 267         memset(bitstr, 0, bitstr_size(nbits));
 268         for (i = 0; i < nbits; i++) {
 269                 bit_ffc_at(bitstr, i, nbits, &found_clear_bit);
 270                 ATF_REQUIRE_MSG(found_clear_bit == i,
 271                     "bit_ffc_at_%d_%s: Failed on bit %d, Result %d",
 272                     nbits, memloc, i, found_clear_bit);
 273         }
 274
 275         memset(bitstr, 0xFF, bitstr_size(nbits));
 276         for (i = 0; i < nbits; i++) {
 277                 bit_ffc_at(bitstr, i, nbits, &found_clear_bit);
 278                 ATF_REQUIRE_MSG(found_clear_bit == -1,
 279                     "bit_ffc_at_%d_%s: Failed on bit %d, Result %d",
 280                     nbits, memloc, i, found_clear_bit);
 281         }
 282
 283         memset(bitstr, 0x55, bitstr_size(nbits));
 284         for (i = 0; i < nbits; i++) {
 285                 bit_ffc_at(bitstr, i, nbits, &found_clear_bit);
 286                 if (i == nbits - 1 && (nbits & 1) != 0) {
 287                         ATF_REQUIRE_MSG(found_clear_bit == -1,
 288                             "bit_ffc_at_%d_%s: Failed on bit %d, Result %d",
 289                             nbits, memloc, i, found_clear_bit);
 290                 } else {
 291                         ATF_REQUIRE_MSG(
 292                             found_clear_bit == i + ((i & 1) ? 0 : 1),
 293                             "bit_ffc_at_%d_%s: Failed on bit %d, Result %d",
 294                             nbits, memloc, i, found_clear_bit);
 295                 }
 296         }
 297
 298         memset(bitstr, 0xAA, bitstr_size(nbits));
 299         for (i = 0; i < nbits; i++) {
 300                 bit_ffc_at(bitstr, i, nbits, &found_clear_bit);
 301                 if (i == nbits - 1 && (nbits & 1) == 0) {
 302                         ATF_REQUIRE_MSG(found_clear_bit == -1,
 303                             "bit_ffc_at_%d_%s: Failed on bit %d, Result %d",
 304                             nbits, memloc, i, found_clear_bit);
 305                 } else {
 306                         ATF_REQUIRE_MSG(found_clear_bit == i + (i & 1),
 307                             "bit_ffc_at_%d_%s: Failed on bit %d, Result %d",
 308                             nbits, memloc, i, found_clear_bit);
 309                 }
 310         }
 311
 312         /* Pass a start value beyond the size of the bit string */
 313         bit_ffc_at(bitstr, nbits, nbits, &found_clear_bit);
 314         ATF_REQUIRE_MSG(found_clear_bit == -1,
 315                         "bit_ffc_at_%d_%s: Failed with high start value, Result %d",
 316                         nbits, memloc, found_clear_bit);
 317
 318         bit_ffc_at(bitstr, nbits + 3, nbits, &found_clear_bit);
 319         ATF_REQUIRE_MSG(found_clear_bit == -1,
 320                         "bit_ffc_at_%d_%s: Failed with high start value of %d, Result %d",
 321                         nbits, memloc, nbits + 3, found_clear_bit);
 322 }
 323
 324 BITSTRING_TC_DEFINE(bit_ffc_area_no_match)
 325 /* bitstr_t *bitstr, int nbits, const char *memloc */
 326 {
 327         int found_clear_bits;
 328
 329         memset(bitstr, 0xFF, bitstr_size(nbits));
 330         bit_ffc_area(bitstr, nbits, 2, &found_clear_bits);
 331         ATF_REQUIRE_EQ_MSG(-1, found_clear_bits,
 332                 "bit_ffc_area_%d_%s: Failed all set bits.", nbits, memloc);
 333 }
 334
 335 BITSTRING_TC_DEFINE(bit_ffs_area_no_match)
 336 /* bitstr_t *bitstr, int nbits, const char *memloc */
 337 {
 338         int found_clear_bits;
 339
 340         memset(bitstr, 0, bitstr_size(nbits));
 341         bit_ffs_area(bitstr, nbits, 2, &found_clear_bits);
 342         ATF_REQUIRE_EQ_MSG(-1, found_clear_bits,
 343                 "bit_ffs_area_%d_%s: Failed all clear bits.", nbits, memloc);
 344 }
 345
 346 ATF_TC_WITHOUT_HEAD(bit_ffs_area);
 347 ATF_TC_BODY(bit_ffs_area, tc)
 348 {
 349         const int nbits = 72;
 350         bitstr_t bit_decl(bitstr, nbits);
 351         int location;
 352
 353         memset(bitstr, 0, bitstr_size(nbits));
 354
 355         bit_set(bitstr, 5);
 356         bit_set(bitstr, 6);
 357
 358         location = 0;
 359         bit_ffs_area(bitstr, nbits, 3, &location);
 360         ATF_REQUIRE_EQ_MSG(-1, location,
 361                         "bit_ffs_area: found location of size 3 when only 2 bits are set");
 362
 363         bit_set(bitstr, 7);
 364
 365         location = 0;
 366         bit_ffs_area(bitstr, nbits, 3, &location);
 367         ATF_REQUIRE_EQ_MSG(5, location,
 368                         "bit_ffs_area: failed to find location of size 3");
 369
 370         bit_set(bitstr, 8);
 371
 372         location = 0;
 373         bit_ffs_area(bitstr, nbits, 3, &location);
 374         ATF_REQUIRE_EQ_MSG(5, location,
 375                         "bit_ffs_area: failed to find location of size 3");
 376
 377         location = 0;
 378         bit_ffs_area_at(bitstr, 2, nbits, 3, &location);
 379         ATF_REQUIRE_EQ_MSG(5, location,
 380                         "bit_ffs_area_at: failed to find location of size 3");
 381
 382         location = 0;
 383         bit_ffs_area_at(bitstr, 6, nbits, 3, &location);
 384         ATF_REQUIRE_EQ_MSG(6, location,
 385                         "bit_ffs_area_at: failed to find location of size 3");
 386
 387         location = 0;
 388         bit_ffs_area_at(bitstr, 8, nbits, 3, &location);
 389         ATF_REQUIRE_EQ_MSG(-1, location,
 390                         "bit_ffs_area_at: found invalid location");
 391
 392         bit_set(bitstr, 69);
 393         bit_set(bitstr, 70);
 394         bit_set(bitstr, 71);
 395
 396         location = 0;
 397         bit_ffs_area_at(bitstr, 8, nbits, 3, &location);
 398         ATF_REQUIRE_EQ_MSG(69, location,
 399                         "bit_ffs_area_at: failed to find location of size 3");
 400
 401         location = 0;
 402         bit_ffs_area_at(bitstr, 69, nbits, 3, &location);
 403         ATF_REQUIRE_EQ_MSG(69, location,
 404                         "bit_ffs_area_at: failed to find location of size 3");
 405
 406         location = 0;
 407         bit_ffs_area_at(bitstr, 70, nbits, 3, &location);
 408         ATF_REQUIRE_EQ_MSG(-1, location,
 409                         "bit_ffs_area_at: found invalid location");
 410
 411         location = 0;
 412         bit_ffs_area_at(bitstr, 72, nbits, 3, &location);
 413         ATF_REQUIRE_EQ_MSG(-1, location,
 414                         "bit_ffs_area_at: found invalid location");
 415 }
 416
 417 ATF_TC_WITHOUT_HEAD(bit_ffc_area);
 418 ATF_TC_BODY(bit_ffc_area, tc)
 419 {
 420         const int nbits = 80;
 421         bitstr_t bit_decl(bitstr, nbits);
 422         int location;
 423
 424         /* set all bits */
 425         memset(bitstr, 0xFF, bitstr_size(nbits));
 426
 427         bit_clear(bitstr, 7);
 428         bit_clear(bitstr, 8);
 429
 430         location = 0;
 431         bit_ffc_area(bitstr, nbits, 3, &location);
 432         ATF_REQUIRE_EQ_MSG(-1, location,
 433                         "bit_ffc_area: found location of size 3 when only 2 bits are set");
 434
 435         bit_clear(bitstr, 9);
 436
 437         location = 0;
 438         bit_ffc_area(bitstr, nbits, 3, &location);
 439         ATF_REQUIRE_EQ_MSG(7, location,
 440                         "bit_ffc_area: failed to find location of size 3");
 441
 442         bit_clear(bitstr, 10);
 443
 444         location = 0;
 445         bit_ffc_area(bitstr, nbits, 3, &location);
 446         ATF_REQUIRE_EQ_MSG(7, location,
 447                         "bit_ffc_area: failed to find location of size 3");
 448
 449         location = 0;
 450         bit_ffc_area_at(bitstr, 2, nbits, 3, &location);
 451         ATF_REQUIRE_EQ_MSG(7, location,
 452                         "bit_ffc_area_at: failed to find location of size 3");
 453
 454         location = 0;
 455         bit_ffc_area_at(bitstr, 8, nbits, 3, &location);
 456         ATF_REQUIRE_EQ_MSG(8, location,
 457                         "bit_ffc_area_at: failed to find location of size 3");
 458
 459         location = 0;
 460         bit_ffc_area_at(bitstr, 9, nbits, 3, &location);
 461         ATF_REQUIRE_EQ_MSG(-1, location,
 462                         "bit_ffc_area_at: found invalid bit location");
 463
 464         bit_clear(bitstr, 77);
 465         bit_clear(bitstr, 78);
 466         bit_clear(bitstr, 79);
 467
 468         location = 0;
 469         bit_ffc_area_at(bitstr, 12, nbits, 3, &location);
 470         ATF_REQUIRE_EQ_MSG(77, location,
 471                         "bit_ffc_area_at: failed to find location of size 3");
 472
 473         location = 0;
 474         bit_ffc_area_at(bitstr, 77, nbits, 3, &location);
 475         ATF_REQUIRE_EQ_MSG(77, location,
 476                         "bit_ffc_area_at: failed to find location of size 3");
 477
 478         location = 0;
 479         bit_ffc_area_at(bitstr, 78, nbits, 3, &location);
 480         ATF_REQUIRE_EQ_MSG(-1, location,
 481                         "bit_ffc_area_at: found invalid location");
 482
 483         location = 0;
 484         bit_ffc_area_at(bitstr, 85, nbits, 3, &location);
 485         ATF_REQUIRE_EQ_MSG(-1, location,
 486                         "bit_ffc_area_at: found invalid location");
 487 }
 488
 489 BITSTRING_TC_DEFINE(bit_nclear)
 490 /* bitstr_t *bitstr, int nbits, const char *memloc */
 491 {
 492         int i, j;
 493         int found_set_bit;
 494         int found_clear_bit;
 495
 496         for (i = 0; i < nbits; i++) {
 497                 for (j = i; j < nbits; j++) {
 498                         memset(bitstr, 0xFF, bitstr_size(nbits));
 499                         bit_nclear(bitstr, i, j);
 500
 501                         bit_ffc(bitstr, nbits, &found_clear_bit);
 502                         ATF_REQUIRE_MSG(
 503                             found_clear_bit == i,
 504                             "bit_nclear_%d_%d_%d%s: Failed with result %d",
 505                             nbits, i, j, memloc, found_clear_bit);
 506
 507                         bit_ffs_at(bitstr, i, nbits, &found_set_bit);
 508                         ATF_REQUIRE_MSG(
 509                             (j + 1 < nbits) ? found_set_bit == j + 1 : -1,
 510                             "bit_nset_%d_%d_%d%s: Failed with result %d",
 511                             nbits, i, j, memloc, found_set_bit);
 512                 }
 513         }
 514 }
 515
 516 BITSTRING_TC_DEFINE(bit_nset)
 517 /* bitstr_t *bitstr, int nbits, const char *memloc */
 518 {
 519         int i, j;
 520         int found_set_bit;
 521         int found_clear_bit;
 522
 523         for (i = 0; i < nbits; i++) {
 524                 for (j = i; j < nbits; j++) {
 525                         memset(bitstr, 0, bitstr_size(nbits));
 526                         bit_nset(bitstr, i, j);
 527
 528                         bit_ffs(bitstr, nbits, &found_set_bit);
 529                         ATF_REQUIRE_MSG(
 530                             found_set_bit == i,
 531                             "bit_nset_%d_%d_%d%s: Failed with result %d",
 532                             nbits, i, j, memloc, found_set_bit);
 533
 534                         bit_ffc_at(bitstr, i, nbits, &found_clear_bit);
 535                         ATF_REQUIRE_MSG(
 536                             (j + 1 < nbits) ? found_clear_bit == j + 1 : -1,
 537                             "bit_nset_%d_%d_%d%s: Failed with result %d",
 538                             nbits, i, j, memloc, found_clear_bit);
 539                 }
 540         }
 541 }
 542
 543 BITSTRING_TC_DEFINE(bit_count)
 544 /* bitstr_t *bitstr, int nbits, const char *memloc */
 545 {
 546         int result, s, e, expected;
 547
 548         /* Empty bitstr */
 549         memset(bitstr, 0, bitstr_size(nbits));
 550         bit_count(bitstr, 0, nbits, &result);
 551         ATF_CHECK_MSG(0 == result,
 552                         "bit_count_%d_%s_%s: Failed with result %d",
 553                         nbits, "clear", memloc, result);
 554
 555         /* Full bitstr */
 556         memset(bitstr, 0xFF, bitstr_size(nbits));
 557         bit_count(bitstr, 0, nbits, &result);
 558         ATF_CHECK_MSG(nbits == result,
 559                         "bit_count_%d_%s_%s: Failed with result %d",
 560                         nbits, "set", memloc, result);
 561
 562         /* Invalid _start value */
 563         memset(bitstr, 0xFF, bitstr_size(nbits));
 564         bit_count(bitstr, nbits, nbits, &result);
 565         ATF_CHECK_MSG(0 == result,
 566                         "bit_count_%d_%s_%s: Failed with result %d",
 567                         nbits, "invalid_start", memloc, result);
 568
 569         /* Alternating bitstr, starts with 0 */
 570         memset(bitstr, 0xAA, bitstr_size(nbits));
 571         bit_count(bitstr, 0, nbits, &result);
 572         ATF_CHECK_MSG(nbits / 2 == result,
 573                         "bit_count_%d_%s_%d_%s: Failed with result %d",
 574                         nbits, "alternating", 0, memloc, result);
 575
 576         /* Alternating bitstr, starts with 1 */
 577         memset(bitstr, 0x55, bitstr_size(nbits));
 578         bit_count(bitstr, 0, nbits, &result);
 579         ATF_CHECK_MSG((nbits + 1) / 2 == result,
 580                         "bit_count_%d_%s_%d_%s: Failed with result %d",
 581                         nbits, "alternating", 1, memloc, result);
 582
 583         /* Varying start location */
 584         memset(bitstr, 0xAA, bitstr_size(nbits));
 585         for (s = 0; s < nbits; s++) {
 586                 expected = s % 2 == 0 ? (nbits - s) / 2 : (nbits - s + 1) / 2;
 587                 bit_count(bitstr, s, nbits, &result);
 588                 ATF_CHECK_MSG(expected == result,
 589                                 "bit_count_%d_%s_%d_%s: Failed with result %d",
 590                                 nbits, "vary_start", s, memloc, result);
 591         }
 592
 593         /* Varying end location */
 594         memset(bitstr, 0xAA, bitstr_size(nbits));
 595         for (e = 0; e < nbits; e++) {
 596                 bit_count(bitstr, 0, e, &result);
 597                 ATF_CHECK_MSG(e / 2 == result,
 598                                 "bit_count_%d_%s_%d_%s: Failed with result %d",
 599                                 nbits, "vary_end", e, memloc, result);
 600         }
 601
 602 }
 603
 604 ATF_TP_ADD_TCS(tp)
 605 {
 606
 607         ATF_TP_ADD_TC(tp, bitstr_in_struct);
 608         ATF_TP_ADD_TC(tp, bitstr_size);
 609         ATF_TP_ADD_TC(tp, bit_ffc_area);
 610         ATF_TP_ADD_TC(tp, bit_ffs_area);
 611         BITSTRING_TC_ADD(tp, bit_set);
 612         BITSTRING_TC_ADD(tp, bit_clear);
 613         BITSTRING_TC_ADD(tp, bit_ffs);
 614         BITSTRING_TC_ADD(tp, bit_ffc);
 615         BITSTRING_TC_ADD(tp, bit_ffs_at);
 616         BITSTRING_TC_ADD(tp, bit_ffc_at);
 617         BITSTRING_TC_ADD(tp, bit_nclear);
 618         BITSTRING_TC_ADD(tp, bit_nset);
 619         BITSTRING_TC_ADD(tp, bit_count);
 620         BITSTRING_TC_ADD(tp, bit_ffs_area_no_match);
 621         BITSTRING_TC_ADD(tp, bit_ffc_area_no_match);
 622
 623         return (atf_no_error());
 624 }