LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/util/bit_array.c - bit_array_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 206 206 100.0 %
Date: 2024-07-12 19:53:08 Functions: 9 9 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 52 72 72.2 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2016 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : 
       8                 :            : #include "spdk_internal/cunit.h"
       9                 :            : 
      10                 :            : #include "util/bit_array.c"
      11                 :            : #include "common/lib/test_env.c"
      12                 :            : 
      13                 :            : static void
      14                 :          4 : test_1bit(void)
      15                 :            : {
      16                 :          4 :         struct spdk_bit_array *ba;
      17                 :            : 
      18                 :          4 :         ba = spdk_bit_array_create(1);
      19         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
      20                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 1);
      21                 :            : 
      22                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
      23                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
      24                 :            : 
      25                 :            :         /* Set bit 0 */
      26                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 0) == 0);
      27                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
      28                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 0);
      29                 :            : 
      30                 :            :         /* Clear bit 0 */
      31                 :          4 :         spdk_bit_array_clear(ba, 0);
      32                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
      33                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
      34                 :            : 
      35                 :          4 :         spdk_bit_array_free(&ba);
      36                 :          4 :         CU_ASSERT(ba == NULL);
      37                 :          4 : }
      38                 :            : 
      39                 :            : static void
      40                 :          4 : test_64bit(void)
      41                 :            : {
      42                 :          4 :         struct spdk_bit_array *ba;
      43                 :            : 
      44                 :          4 :         ba = spdk_bit_array_create(64);
      45         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
      46                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 64);
      47                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
      48                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 63) == false);
      49                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 64) == false);
      50                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1000) == false);
      51                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
      52                 :            : 
      53                 :            :         /* Set bit 1 */
      54                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 1) == 0);
      55                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
      56                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == true);
      57                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 1);
      58                 :            : 
      59                 :            :         /* Set bit 63 (1 still set) */
      60                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 63) == 0);
      61                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
      62                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == true);
      63                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 63) == true);
      64                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 1);
      65                 :            : 
      66                 :            :         /* Clear bit 1 (63 still set) */
      67                 :          4 :         spdk_bit_array_clear(ba, 1);
      68                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
      69                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 63);
      70                 :            : 
      71                 :            :         /* Clear bit 63 (no bits set) */
      72                 :          4 :         spdk_bit_array_clear(ba, 63);
      73                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 63) == false);
      74                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
      75                 :            : 
      76                 :          4 :         spdk_bit_array_free(&ba);
      77                 :          4 : }
      78                 :            : 
      79                 :            : static void
      80                 :          4 : test_find(void)
      81                 :            : {
      82                 :          4 :         struct spdk_bit_array *ba;
      83                 :            :         uint32_t i;
      84                 :            : 
      85                 :          4 :         ba = spdk_bit_array_create(256);
      86         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
      87                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 256);
      88                 :            : 
      89                 :            :         /* Set all bits */
      90         [ +  + ]:       1028 :         for (i = 0; i < 256; i++) {
      91                 :       1024 :                 CU_ASSERT(spdk_bit_array_set(ba, i) == 0);
      92                 :            :         }
      93                 :            : 
      94                 :            :         /* Verify that find_first_set and find_first_clear work for each starting position */
      95         [ +  + ]:       1028 :         for (i = 0; i < 256; i++) {
      96                 :       1024 :                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == i);
      97                 :       1024 :                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == UINT32_MAX);
      98                 :            :         }
      99                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_set(ba, 256) == UINT32_MAX);
     100                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_clear(ba, 256) == UINT32_MAX);
     101                 :            : 
     102                 :            :         /* Clear bits 0 through 31 */
     103         [ +  + ]:        132 :         for (i = 0; i < 32; i++) {
     104                 :        128 :                 spdk_bit_array_clear(ba, i);
     105                 :            :         }
     106                 :            : 
     107         [ +  + ]:        132 :         for (i = 0; i < 32; i++) {
     108                 :        128 :                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == 32);
     109                 :        128 :                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == i);
     110                 :            :         }
     111                 :            : 
     112         [ +  + ]:        900 :         for (i = 32; i < 256; i++) {
     113                 :        896 :                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == i);
     114                 :        896 :                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == UINT32_MAX);
     115                 :            :         }
     116                 :            : 
     117                 :            :         /* Clear bit 255 */
     118                 :          4 :         spdk_bit_array_clear(ba, 255);
     119                 :            : 
     120         [ +  + ]:        132 :         for (i = 0; i < 32; i++) {
     121                 :        128 :                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == 32);
     122                 :        128 :                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == i);
     123                 :            :         }
     124                 :            : 
     125         [ +  + ]:        896 :         for (i = 32; i < 255; i++)  {
     126                 :        892 :                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == i);
     127                 :        892 :                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == 255);
     128                 :            :         }
     129                 :            : 
     130                 :          4 :         CU_ASSERT(spdk_bit_array_find_first_clear(ba, 256) == UINT32_MAX);
     131                 :            : 
     132                 :          4 :         spdk_bit_array_free(&ba);
     133                 :          4 : }
     134                 :            : 
     135                 :            : static void
     136                 :          4 : test_resize(void)
     137                 :            : {
     138                 :          4 :         struct spdk_bit_array *ba;
     139                 :            : 
     140                 :            :         /* Start with a 0 bit array */
     141                 :          4 :         ba = spdk_bit_array_create(0);
     142         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     143                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 0);
     144                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
     145                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 0) == -EINVAL);
     146                 :          4 :         spdk_bit_array_clear(ba, 0);
     147                 :            : 
     148                 :            :         /* Increase size to 1 bit */
     149         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 1) == 0);
     150         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     151                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 1);
     152                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
     153                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 0) == 0);
     154                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
     155                 :            : 
     156                 :            :         /* Increase size to 2 bits */
     157         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 2) == 0);
     158         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     159                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 2);
     160                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
     161                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 1) == 0);
     162                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == true);
     163                 :            : 
     164                 :            :         /* Shrink size back to 1 bit */
     165         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 1) == 0);
     166         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     167                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 1);
     168                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
     169                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
     170                 :            : 
     171                 :            :         /* Increase size to 65 bits */
     172         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 65) == 0);
     173         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     174                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 65);
     175                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
     176                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
     177                 :          4 :         CU_ASSERT(spdk_bit_array_set(ba, 64) == 0);
     178                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 64) == true);
     179                 :            : 
     180                 :            :         /* Shrink size back to 0 bits */
     181         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 0) == 0);
     182         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     183                 :          4 :         CU_ASSERT(spdk_bit_array_capacity(ba) == 0);
     184                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
     185                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
     186                 :            : 
     187                 :          4 :         spdk_bit_array_free(&ba);
     188                 :          4 : }
     189                 :            : 
     190                 :            : static void
     191                 :          4 : test_errors(void)
     192                 :            : {
     193                 :            :         /* Passing NULL to resize should fail. */
     194                 :          4 :         CU_ASSERT(spdk_bit_array_resize(NULL, 0) == -EINVAL);
     195                 :            : 
     196                 :            :         /* Passing NULL to free is a no-op. */
     197                 :          4 :         spdk_bit_array_free(NULL);
     198                 :          4 : }
     199                 :            : 
     200                 :            : static void
     201                 :          4 : test_count(void)
     202                 :            : {
     203                 :          4 :         struct spdk_bit_array *ba;
     204                 :            :         uint32_t i;
     205                 :            : 
     206                 :            :         /* 0-bit array should have 0 bits set and 0 bits clear */
     207                 :          4 :         ba = spdk_bit_array_create(0);
     208         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     209                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 0);
     210                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 0);
     211                 :          4 :         spdk_bit_array_free(&ba);
     212                 :            : 
     213                 :            :         /* 1-bit array */
     214                 :          4 :         ba = spdk_bit_array_create(1);
     215         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     216                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 0);
     217                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 1);
     218                 :          4 :         spdk_bit_array_set(ba, 0);
     219                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 1);
     220                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 0);
     221                 :          4 :         spdk_bit_array_free(&ba);
     222                 :            : 
     223                 :            :         /* 65-bit array */
     224                 :          4 :         ba = spdk_bit_array_create(65);
     225         [ -  + ]:          4 :         SPDK_CU_ASSERT_FATAL(ba != NULL);
     226                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 0);
     227                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 65);
     228                 :          4 :         spdk_bit_array_set(ba, 0);
     229                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 1);
     230                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 64);
     231                 :          4 :         spdk_bit_array_set(ba, 5);
     232                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 2);
     233                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 63);
     234                 :          4 :         spdk_bit_array_set(ba, 13);
     235                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 3);
     236                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 62);
     237                 :          4 :         spdk_bit_array_clear(ba, 0);
     238                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 2);
     239                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 63);
     240         [ +  + ]:        264 :         for (i = 0; i < 65; i++) {
     241                 :        260 :                 spdk_bit_array_set(ba, i);
     242                 :            :         }
     243                 :          4 :         CU_ASSERT(spdk_bit_array_count_set(ba) == 65);
     244                 :          4 :         CU_ASSERT(spdk_bit_array_count_clear(ba) == 0);
     245         [ +  + ]:        264 :         for (i = 0; i < 65; i++) {
     246                 :        260 :                 spdk_bit_array_clear(ba, i);
     247                 :        260 :                 CU_ASSERT(spdk_bit_array_count_set(ba) == 65 - i - 1);
     248                 :        260 :                 CU_ASSERT(spdk_bit_array_count_clear(ba) == i + 1);
     249                 :            :         }
     250                 :          4 :         spdk_bit_array_free(&ba);
     251                 :          4 : }
     252                 :            : 
     253                 :            : #define TEST_MASK_SIZE 128
     254                 :            : #define TEST_BITS_NUM (TEST_MASK_SIZE * 8 - 3)
     255                 :            : static void
     256                 :          4 : test_mask_store_load(void)
     257                 :            : {
     258                 :          4 :         struct spdk_bit_array *ba;
     259                 :          4 :         uint8_t mask[TEST_MASK_SIZE] = { 0 };
     260                 :            :         uint32_t i;
     261                 :            : 
     262                 :          4 :         ba = spdk_bit_array_create(TEST_BITS_NUM);
     263                 :            : 
     264                 :            :         /* Check if stored mask is consistent with bit array mask */
     265                 :          4 :         spdk_bit_array_set(ba, 0);
     266                 :          4 :         spdk_bit_array_set(ba, TEST_BITS_NUM / 2);
     267                 :          4 :         spdk_bit_array_set(ba, TEST_BITS_NUM - 1);
     268                 :            : 
     269                 :          4 :         spdk_bit_array_store_mask(ba, mask);
     270                 :            : 
     271         [ +  + ]:       4088 :         for (i = 0; i < TEST_BITS_NUM; i++) {
     272   [ +  +  +  +  :       4084 :                 if (i == 0 || i == TEST_BITS_NUM / 2 || i == TEST_BITS_NUM - 1) {
                   +  + ]
     273         [ -  + ]:         12 :                         CU_ASSERT((mask[i / 8] & (1U << (i % 8))));
     274                 :            :                 } else {
     275         [ -  + ]:       4072 :                         CU_ASSERT(!(mask[i / 8] & (1U << (i % 8))));
     276                 :            :                 }
     277                 :            :         }
     278                 :            : 
     279                 :            :         /* Check if loaded mask is consistent with bit array mask */
     280         [ -  + ]:          4 :         memset(mask, 0, TEST_MASK_SIZE);
     281                 :          4 :         mask[0] = 1;
     282                 :          4 :         mask[TEST_MASK_SIZE - 1] = 1U << 4;
     283                 :            : 
     284                 :          4 :         spdk_bit_array_load_mask(ba, mask);
     285                 :            : 
     286                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, 0));
     287                 :          4 :         CU_ASSERT(spdk_bit_array_get(ba, TEST_BITS_NUM - 1));
     288                 :            : 
     289                 :          4 :         spdk_bit_array_clear(ba, 0);
     290                 :          4 :         spdk_bit_array_clear(ba, TEST_BITS_NUM - 1);
     291                 :            : 
     292         [ +  + ]:       4088 :         for (i = 0; i < TEST_BITS_NUM; i++) {
     293                 :       4084 :                 CU_ASSERT(!spdk_bit_array_get(ba, i));
     294                 :            :         }
     295                 :            : 
     296                 :          4 :         spdk_bit_array_free(&ba);
     297                 :          4 : }
     298                 :            : 
     299                 :            : static void
     300                 :          4 : test_mask_clear(void)
     301                 :            : {
     302                 :          4 :         struct spdk_bit_array *ba;
     303                 :            :         uint32_t i;
     304                 :            : 
     305                 :          4 :         ba = spdk_bit_array_create(TEST_BITS_NUM);
     306                 :            : 
     307         [ +  + ]:       4088 :         for (i = 0; i < TEST_BITS_NUM; i++) {
     308                 :       4084 :                 spdk_bit_array_set(ba, i);
     309                 :            :         }
     310                 :            : 
     311                 :          4 :         spdk_bit_array_clear_mask(ba);
     312                 :            : 
     313         [ +  + ]:       4088 :         for (i = 0; i < TEST_BITS_NUM; i++) {
     314                 :       4084 :                 CU_ASSERT(!spdk_bit_array_get(ba, i));
     315                 :            :         }
     316                 :            : 
     317                 :          4 :         spdk_bit_array_free(&ba);
     318                 :          4 : }
     319                 :            : 
     320                 :            : int
     321                 :          4 : main(int argc, char **argv)
     322                 :            : {
     323                 :          4 :         CU_pSuite       suite = NULL;
     324                 :            :         unsigned int    num_failures;
     325                 :            : 
     326                 :          4 :         CU_initialize_registry();
     327                 :            : 
     328                 :          4 :         suite = CU_add_suite("bit_array", NULL, NULL);
     329                 :            : 
     330                 :          4 :         CU_ADD_TEST(suite, test_1bit);
     331                 :          4 :         CU_ADD_TEST(suite, test_64bit);
     332                 :          4 :         CU_ADD_TEST(suite, test_find);
     333                 :          4 :         CU_ADD_TEST(suite, test_resize);
     334                 :          4 :         CU_ADD_TEST(suite, test_errors);
     335                 :          4 :         CU_ADD_TEST(suite, test_count);
     336                 :          4 :         CU_ADD_TEST(suite, test_mask_store_load);
     337                 :          4 :         CU_ADD_TEST(suite, test_mask_clear);
     338                 :            : 
     339                 :            : 
     340                 :          4 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     341                 :            : 
     342                 :          4 :         CU_cleanup_registry();
     343                 :            : 
     344                 :          4 :         return num_failures;
     345                 :            : }

Generated by: LCOV version 1.14