ceph/src/spdk/test/lib/util/bit_array/bit_array_ut.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (c) Intel Corporation.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <stdio.h>
  35
  36 #include "spdk_cunit.h"
  37
  38 #include "bit_array.c"
  39
  40 void *
  41 spdk_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)
  42 {
  43         return realloc(buf, size);
  44 }
  45
  46 void
  47 spdk_free(void *buf)
  48 {
  49         free(buf);
  50 }
  51
  52 static void
  53 test_1bit(void)
  54 {
  55         struct spdk_bit_array *ba;
  56
  57         ba = spdk_bit_array_create(1);
  58         SPDK_CU_ASSERT_FATAL(ba != NULL);
  59         CU_ASSERT(spdk_bit_array_capacity(ba) == 1);
  60
  61         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
  62         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
  63
  64         /* Set bit 0 */
  65         CU_ASSERT(spdk_bit_array_set(ba, 0) == 0);
  66         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
  67         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 0);
  68
  69         /* Clear bit 0 */
  70         spdk_bit_array_clear(ba, 0);
  71         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
  72         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
  73
  74         spdk_bit_array_free(&ba);
  75         CU_ASSERT(ba == NULL);
  76 }
  77
  78 static void
  79 test_64bit(void)
  80 {
  81         struct spdk_bit_array *ba;
  82
  83         ba = spdk_bit_array_create(64);
  84         SPDK_CU_ASSERT_FATAL(ba != NULL);
  85         CU_ASSERT(spdk_bit_array_capacity(ba) == 64);
  86         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
  87         CU_ASSERT(spdk_bit_array_get(ba, 63) == false);
  88         CU_ASSERT(spdk_bit_array_get(ba, 64) == false);
  89         CU_ASSERT(spdk_bit_array_get(ba, 1000) == false);
  90         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
  91
  92         /* Set bit 1 */
  93         CU_ASSERT(spdk_bit_array_set(ba, 1) == 0);
  94         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
  95         CU_ASSERT(spdk_bit_array_get(ba, 1) == true);
  96         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 1);
  97
  98         /* Set bit 63 (1 still set) */
  99         CU_ASSERT(spdk_bit_array_set(ba, 63) == 0);
 100         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
 101         CU_ASSERT(spdk_bit_array_get(ba, 1) == true);
 102         CU_ASSERT(spdk_bit_array_get(ba, 63) == true);
 103         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 1);
 104
 105         /* Clear bit 1 (63 still set) */
 106         spdk_bit_array_clear(ba, 1);
 107         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
 108         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == 63);
 109
 110         /* Clear bit 63 (no bits set) */
 111         spdk_bit_array_clear(ba, 63);
 112         CU_ASSERT(spdk_bit_array_get(ba, 63) == false);
 113         CU_ASSERT(spdk_bit_array_find_first_set(ba, 0) == UINT32_MAX);
 114
 115         spdk_bit_array_free(&ba);
 116 }
 117
 118 static void
 119 test_find(void)
 120 {
 121         struct spdk_bit_array *ba;
 122         uint32_t i;
 123
 124         ba = spdk_bit_array_create(256);
 125         SPDK_CU_ASSERT_FATAL(ba != NULL);
 126         CU_ASSERT(spdk_bit_array_capacity(ba) == 256);
 127
 128         /* Set all bits */
 129         for (i = 0; i < 256; i++) {
 130                 CU_ASSERT(spdk_bit_array_set(ba, i) == 0);
 131         }
 132
 133         /* Verify that find_first_set and find_first_clear work for each starting position */
 134         for (i = 0; i < 256; i++) {
 135                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == i);
 136                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == 256);
 137         }
 138         CU_ASSERT(spdk_bit_array_find_first_set(ba, 256) == UINT32_MAX);
 139         CU_ASSERT(spdk_bit_array_find_first_clear(ba, 256) == 256);
 140
 141         /* Clear bits 0 through 31 */
 142         for (i = 0; i < 32; i++) {
 143                 spdk_bit_array_clear(ba, i);
 144         }
 145
 146         for (i = 0; i < 32; i++) {
 147                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == 32);
 148                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == i);
 149         }
 150
 151         for (i = 32; i < 256; i++) {
 152                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == i);
 153                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == 256);
 154         }
 155
 156         /* Clear bit 255 */
 157         spdk_bit_array_clear(ba, 255);
 158
 159         for (i = 0; i < 32; i++) {
 160                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == 32);
 161                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == i);
 162         }
 163
 164         for (i = 32; i < 255; i++)  {
 165                 CU_ASSERT(spdk_bit_array_find_first_set(ba, i) == i);
 166                 CU_ASSERT(spdk_bit_array_find_first_clear(ba, i) == 255);
 167         }
 168
 169         CU_ASSERT(spdk_bit_array_find_first_clear(ba, 256) == 256);
 170
 171         spdk_bit_array_free(&ba);
 172 }
 173
 174 static void
 175 test_resize(void)
 176 {
 177         struct spdk_bit_array *ba;
 178
 179         /* Start with a 0 bit array */
 180         ba = spdk_bit_array_create(0);
 181         SPDK_CU_ASSERT_FATAL(ba != NULL);
 182         CU_ASSERT(spdk_bit_array_capacity(ba) == 0);
 183         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
 184         CU_ASSERT(spdk_bit_array_set(ba, 0) == -EINVAL);
 185         spdk_bit_array_clear(ba, 0);
 186
 187         /* Increase size to 1 bit */
 188         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 1) == 0);
 189         SPDK_CU_ASSERT_FATAL(ba != NULL);
 190         CU_ASSERT(spdk_bit_array_capacity(ba) == 1);
 191         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
 192         CU_ASSERT(spdk_bit_array_set(ba, 0) == 0);
 193         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
 194
 195         /* Increase size to 2 bits */
 196         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 2) == 0);
 197         SPDK_CU_ASSERT_FATAL(ba != NULL);
 198         CU_ASSERT(spdk_bit_array_capacity(ba) == 2);
 199         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
 200         CU_ASSERT(spdk_bit_array_set(ba, 1) == 0);
 201         CU_ASSERT(spdk_bit_array_get(ba, 1) == true);
 202
 203         /* Shrink size back to 1 bit */
 204         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 1) == 0);
 205         SPDK_CU_ASSERT_FATAL(ba != NULL);
 206         CU_ASSERT(spdk_bit_array_capacity(ba) == 1);
 207         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
 208         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
 209
 210         /* Increase size to 65 bits */
 211         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 65) == 0);
 212         SPDK_CU_ASSERT_FATAL(ba != NULL);
 213         CU_ASSERT(spdk_bit_array_capacity(ba) == 65);
 214         CU_ASSERT(spdk_bit_array_get(ba, 0) == true);
 215         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
 216         CU_ASSERT(spdk_bit_array_set(ba, 64) == 0);
 217         CU_ASSERT(spdk_bit_array_get(ba, 64) == true);
 218
 219         /* Shrink size back to 0 bits */
 220         SPDK_CU_ASSERT_FATAL(spdk_bit_array_resize(&ba, 0) == 0);
 221         SPDK_CU_ASSERT_FATAL(ba != NULL);
 222         CU_ASSERT(spdk_bit_array_capacity(ba) == 0);
 223         CU_ASSERT(spdk_bit_array_get(ba, 0) == false);
 224         CU_ASSERT(spdk_bit_array_get(ba, 1) == false);
 225
 226         spdk_bit_array_free(&ba);
 227 }
 228
 229 static void
 230 test_errors(void)
 231 {
 232         /* Passing NULL to resize should fail. */
 233         CU_ASSERT(spdk_bit_array_resize(NULL, 0) == -EINVAL);
 234
 235         /* Passing NULL to free is a no-op. */
 236         spdk_bit_array_free(NULL);
 237 }
 238
 239 int
 240 main(int argc, char **argv)
 241 {
 242         CU_pSuite       suite = NULL;
 243         unsigned int    num_failures;
 244
 245         if (CU_initialize_registry() != CUE_SUCCESS) {
 246                 return CU_get_error();
 247         }
 248
 249         suite = CU_add_suite("bit_array", NULL, NULL);
 250         if (suite == NULL) {
 251                 CU_cleanup_registry();
 252                 return CU_get_error();
 253         }
 254
 255         if (
 256                 CU_add_test(suite, "test_1bit", test_1bit) == NULL ||
 257                 CU_add_test(suite, "test_64bit", test_64bit) == NULL ||
 258                 CU_add_test(suite, "test_find", test_find) == NULL ||
 259                 CU_add_test(suite, "test_resize", test_resize) == NULL ||
 260                 CU_add_test(suite, "test_errors", test_errors) == NULL) {
 261                 CU_cleanup_registry();
 262                 return CU_get_error();
 263         }
 264
 265         CU_basic_set_mode(CU_BRM_VERBOSE);
 266
 267         CU_basic_run_tests();
 268
 269         num_failures = CU_get_number_of_failures();
 270         CU_cleanup_registry();
 271
 272         return num_failures;
 273 }