LCOV - code coverage report
Current view: top level - spdk/test/unit/lib/util/pipe.c - pipe_ut.c (source / functions) Hit Total Coverage
Test: Combined Lines: 408 408 100.0 %
Date: 2024-07-11 16:06:21 Functions: 7 7 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 41 80 51.2 %

           Branch data     Line data    Source code
       1                 :            : /*   SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  *   Copyright (C) 2019 Intel Corporation.
       3                 :            :  *   All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #include "spdk/stdinc.h"
       7                 :            : 
       8                 :            : #include "spdk_internal/cunit.h"
       9                 :            : 
      10                 :            : #include "util/pipe.c"
      11                 :            : #include "common/lib/test_env.c"
      12                 :            : 
      13                 :            : static void
      14                 :          6 : test_create_destroy(void)
      15                 :            : {
      16                 :            :         struct spdk_pipe *pipe;
      17                 :          5 :         uint8_t mem[10];
      18                 :            : 
      19                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
      20         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
      21                 :            : 
      22                 :          6 :         spdk_pipe_destroy(pipe);
      23                 :          6 : }
      24                 :            : 
      25                 :            : static void
      26                 :          6 : test_write_get_buffer(void)
      27                 :            : {
      28                 :            :         struct spdk_pipe *pipe;
      29                 :          5 :         uint8_t mem[10];
      30                 :          5 :         struct iovec iovs[2];
      31                 :            :         int rc;
      32                 :            : 
      33                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
      34         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
      35                 :            : 
      36                 :            :         /* Get some available memory. */
      37                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 5, iovs);
      38                 :          6 :         CU_ASSERT(rc == 5);
      39                 :          6 :         CU_ASSERT(iovs[0].iov_base == mem);
      40                 :          6 :         CU_ASSERT(iovs[0].iov_len == 5);
      41                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
      42                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
      43                 :          6 :         CU_ASSERT(pipe->write == 0);
      44                 :          6 :         CU_ASSERT(pipe->read == 0);
      45                 :            : 
      46         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
      47                 :            : 
      48                 :            :         /* Get 0 bytes. */
      49                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 0, iovs);
      50                 :          6 :         CU_ASSERT(rc == 0);
      51                 :          6 :         CU_ASSERT(iovs[0].iov_base == NULL);
      52                 :          6 :         CU_ASSERT(iovs[0].iov_len == 0);
      53                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
      54                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
      55                 :          6 :         CU_ASSERT(pipe->write == 0);
      56                 :          6 :         CU_ASSERT(pipe->read == 0);
      57                 :            : 
      58         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
      59                 :            : 
      60                 :            :         /* Get all available memory */
      61                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 10, iovs);
      62                 :          6 :         CU_ASSERT(rc == 10);
      63                 :          6 :         CU_ASSERT(iovs[0].iov_base == mem);
      64                 :          6 :         CU_ASSERT(iovs[0].iov_len == 10);
      65                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
      66                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
      67                 :          6 :         CU_ASSERT(pipe->write == 0);
      68                 :          6 :         CU_ASSERT(pipe->read == 0);
      69                 :            : 
      70         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
      71                 :            : 
      72                 :            :         /* Advance the write pointer 7 bytes in. */
      73                 :          6 :         pipe->write = 7;
      74                 :            : 
      75                 :            :         /* Get all of the available memory. */
      76                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 3, iovs);
      77                 :          6 :         CU_ASSERT(rc == 3);
      78                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
      79                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
      80                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
      81                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
      82                 :          6 :         CU_ASSERT(pipe->write == 7);
      83                 :          6 :         CU_ASSERT(pipe->read == 0);
      84                 :            : 
      85         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
      86                 :            : 
      87                 :            :         /* Get more than the available memory */
      88                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 4, iovs);
      89                 :          6 :         CU_ASSERT(rc == 3);
      90                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
      91                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
      92                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
      93                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
      94                 :          6 :         CU_ASSERT(pipe->write == 7);
      95                 :          6 :         CU_ASSERT(pipe->read == 0);
      96                 :            : 
      97         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
      98                 :            : 
      99                 :            :         /* Advance the read pointer 3 bytes in. */
     100                 :          6 :         pipe->read = 3;
     101                 :            : 
     102                 :            :         /* Get all of the available memory. */
     103                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 6, iovs);
     104                 :          6 :         CU_ASSERT(rc == 6);
     105                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
     106                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
     107                 :          6 :         CU_ASSERT(iovs[1].iov_base == mem);
     108                 :          6 :         CU_ASSERT(iovs[1].iov_len == 3);
     109                 :          6 :         CU_ASSERT(pipe->write == 7);
     110                 :          6 :         CU_ASSERT(pipe->read == 3);
     111                 :            : 
     112         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     113                 :            : 
     114                 :            :         /* Get more than the available memory */
     115                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 7, iovs);
     116                 :          6 :         CU_ASSERT(rc == 6);
     117                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
     118                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
     119                 :          6 :         CU_ASSERT(iovs[1].iov_base == mem);
     120                 :          6 :         CU_ASSERT(iovs[1].iov_len == 3);
     121                 :          6 :         CU_ASSERT(pipe->write == 7);
     122                 :          6 :         CU_ASSERT(pipe->read == 3);
     123                 :            : 
     124         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     125                 :            : 
     126                 :            :         /* Advance the read pointer past the write pointer */
     127                 :          6 :         pipe->read = 9;
     128                 :            : 
     129                 :            :         /* Get all of the available memory. */
     130                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 2, iovs);
     131                 :          6 :         CU_ASSERT(rc == 2);
     132                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
     133                 :          6 :         CU_ASSERT(iovs[0].iov_len == 2);
     134                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     135                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     136                 :          6 :         CU_ASSERT(pipe->write == 7);
     137                 :          6 :         CU_ASSERT(pipe->read == 9);
     138                 :            : 
     139         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     140                 :            : 
     141                 :            :         /* Get more than the available memory */
     142                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 3, iovs);
     143                 :          6 :         CU_ASSERT(rc == 2);
     144                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
     145                 :          6 :         CU_ASSERT(iovs[0].iov_len == 2);
     146                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     147                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     148                 :          6 :         CU_ASSERT(pipe->write == 7);
     149                 :          6 :         CU_ASSERT(pipe->read == 9);
     150                 :            : 
     151         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     152                 :            : 
     153                 :            :         /* Fill the pipe */
     154                 :          6 :         pipe->write = 9;
     155                 :          6 :         pipe->full = true;
     156                 :            : 
     157                 :            :         /* Get data while the pipe is full */
     158                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
     159                 :          6 :         CU_ASSERT(rc == 0);
     160                 :          6 :         CU_ASSERT(iovs[0].iov_base == NULL);
     161                 :          6 :         CU_ASSERT(iovs[0].iov_len == 0);
     162                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     163                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     164                 :          6 :         CU_ASSERT(pipe->write == 9);
     165                 :          6 :         CU_ASSERT(pipe->read == 9);
     166                 :            : 
     167                 :          6 :         spdk_pipe_destroy(pipe);
     168                 :          6 : }
     169                 :            : 
     170                 :            : static void
     171                 :          6 : test_write_advance(void)
     172                 :            : {
     173                 :            :         struct spdk_pipe *pipe;
     174                 :          5 :         uint8_t mem[10];
     175                 :            :         int rc;
     176                 :            : 
     177                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
     178         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
     179                 :            : 
     180                 :            :         /* Advance half way through the pipe */
     181                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 5);
     182                 :          6 :         CU_ASSERT(rc == 0);
     183                 :          6 :         CU_ASSERT(pipe->write == 5);
     184                 :          6 :         CU_ASSERT(pipe->read == 0);
     185         [ -  + ]:          6 :         CU_ASSERT(!pipe->full);
     186                 :            : 
     187                 :          6 :         pipe->write = 0;
     188                 :          6 :         pipe->full = false;
     189                 :            : 
     190                 :            :         /* Advance to the end of the pipe */
     191                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 10);
     192                 :          6 :         CU_ASSERT(rc == 0);
     193                 :          6 :         CU_ASSERT(pipe->write == 0);
     194                 :          6 :         CU_ASSERT(pipe->read == 0);
     195         [ -  + ]:          6 :         CU_ASSERT(pipe->full);
     196                 :            : 
     197                 :          6 :         pipe->write = 0;
     198                 :          6 :         pipe->full = false;
     199                 :            : 
     200                 :            :         /* Advance beyond the end */
     201                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 11);
     202                 :          6 :         CU_ASSERT(rc == -EINVAL);
     203                 :          6 :         CU_ASSERT(pipe->write == 0);
     204                 :          6 :         CU_ASSERT(pipe->read == 0);
     205         [ -  + ]:          6 :         CU_ASSERT(!pipe->full);
     206                 :            : 
     207                 :            :         /* Move the read pointer forward */
     208                 :          6 :         pipe->write = 0;
     209                 :          6 :         pipe->read = 5;
     210                 :          6 :         pipe->full = false;
     211                 :            : 
     212                 :            :         /* Advance to the end of the pipe */
     213                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 5);
     214                 :          6 :         CU_ASSERT(rc == 0);
     215                 :          6 :         CU_ASSERT(pipe->write == 5);
     216                 :          6 :         CU_ASSERT(pipe->read == 5);
     217         [ -  + ]:          6 :         CU_ASSERT(pipe->full);
     218                 :            : 
     219                 :          6 :         pipe->write = 0;
     220                 :          6 :         pipe->read = 5;
     221                 :          6 :         pipe->full = false;
     222                 :            : 
     223                 :            :         /* Advance beyond the end */
     224                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 6);
     225                 :          6 :         CU_ASSERT(rc == -EINVAL);
     226                 :          6 :         CU_ASSERT(pipe->write == 0);
     227                 :          6 :         CU_ASSERT(pipe->read == 5);
     228         [ -  + ]:          6 :         CU_ASSERT(!pipe->full);
     229                 :            : 
     230                 :            :         /* Test wrap around */
     231                 :          6 :         pipe->write = 7;
     232                 :          6 :         pipe->read = 3;
     233                 :          6 :         pipe->full = false;
     234                 :            : 
     235                 :            :         /* Advance to the end of the pipe */
     236                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 6);
     237                 :          6 :         CU_ASSERT(rc == 0);
     238                 :          6 :         CU_ASSERT(pipe->write == 3);
     239                 :          6 :         CU_ASSERT(pipe->read == 3);
     240         [ -  + ]:          6 :         CU_ASSERT(pipe->full);
     241                 :            : 
     242                 :          6 :         pipe->write = 7;
     243                 :          6 :         pipe->read = 3;
     244                 :          6 :         pipe->full = false;
     245                 :            : 
     246                 :            :         /* Advance beyond the end */
     247                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 7);
     248                 :          6 :         CU_ASSERT(rc == -EINVAL);
     249                 :          6 :         CU_ASSERT(pipe->write == 7);
     250                 :          6 :         CU_ASSERT(pipe->read == 3);
     251         [ -  + ]:          6 :         CU_ASSERT(!pipe->full);
     252                 :            : 
     253                 :          6 :         spdk_pipe_destroy(pipe);
     254                 :          6 : }
     255                 :            : 
     256                 :            : static void
     257                 :          6 : test_read_get_buffer(void)
     258                 :            : {
     259                 :            :         struct spdk_pipe *pipe;
     260                 :          5 :         uint8_t mem[10];
     261                 :          5 :         struct iovec iovs[2];
     262                 :            :         int rc;
     263                 :            : 
     264                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
     265         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
     266                 :            : 
     267                 :            :         /* Set the write pointer to the end, making all data available. */
     268                 :          6 :         pipe->write = 9;
     269                 :            : 
     270                 :            :         /* Get half the available memory. */
     271                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 5, iovs);
     272                 :          6 :         CU_ASSERT(rc == 5);
     273                 :          6 :         CU_ASSERT(iovs[0].iov_base == mem);
     274                 :          6 :         CU_ASSERT(iovs[0].iov_len == 5);
     275                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     276                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     277                 :          6 :         CU_ASSERT(pipe->write == 9);
     278                 :          6 :         CU_ASSERT(pipe->read == 0);
     279                 :            : 
     280         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     281                 :            : 
     282                 :            :         /* Get 0 bytes. */
     283                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 0, iovs);
     284                 :          6 :         CU_ASSERT(rc == 0);
     285                 :          6 :         CU_ASSERT(iovs[0].iov_base == NULL);
     286                 :          6 :         CU_ASSERT(iovs[0].iov_len == 0);
     287                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     288                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     289                 :          6 :         CU_ASSERT(pipe->write == 9);
     290                 :          6 :         CU_ASSERT(pipe->read == 0);
     291                 :            : 
     292         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     293                 :            : 
     294                 :            :         /* Get all available memory */
     295                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 9, iovs);
     296                 :          6 :         CU_ASSERT(rc == 9);
     297                 :          6 :         CU_ASSERT(iovs[0].iov_base == mem);
     298                 :          6 :         CU_ASSERT(iovs[0].iov_len == 9);
     299                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     300                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     301                 :          6 :         CU_ASSERT(pipe->write == 9);
     302                 :          6 :         CU_ASSERT(pipe->read == 0);
     303                 :            : 
     304         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     305                 :            : 
     306                 :            :         /* Get more bytes than exist */
     307                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 10, iovs);
     308                 :          6 :         CU_ASSERT(rc == 9);
     309                 :          6 :         CU_ASSERT(iovs[0].iov_base == mem);
     310                 :          6 :         CU_ASSERT(iovs[0].iov_len == 9);
     311                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     312                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     313                 :          6 :         CU_ASSERT(pipe->write == 9);
     314                 :          6 :         CU_ASSERT(pipe->read == 0);
     315                 :            : 
     316         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     317                 :            : 
     318                 :            :         /* Advance the read pointer 5 bytes in. */
     319                 :          6 :         pipe->read = 5;
     320                 :          6 :         pipe->write = 0;
     321                 :            : 
     322                 :            :         /* Get all of the available memory. */
     323                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 5, iovs);
     324                 :          6 :         CU_ASSERT(rc == 5);
     325                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 5));
     326                 :          6 :         CU_ASSERT(iovs[0].iov_len == 5);
     327                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     328                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     329                 :          6 :         CU_ASSERT(pipe->write == 0);
     330                 :          6 :         CU_ASSERT(pipe->read == 5);
     331                 :            : 
     332         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     333                 :            : 
     334                 :            :         /* Get more than the available memory */
     335                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 6, iovs);
     336                 :          6 :         CU_ASSERT(rc == 5);
     337                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 5));
     338                 :          6 :         CU_ASSERT(iovs[0].iov_len == 5);
     339                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     340                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     341                 :          6 :         CU_ASSERT(pipe->write == 0);
     342                 :          6 :         CU_ASSERT(pipe->read == 5);
     343                 :            : 
     344         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     345                 :            : 
     346                 :            :         /* Invert the write and read pointers */
     347                 :          6 :         pipe->read = 7;
     348                 :          6 :         pipe->write = 3;
     349                 :            : 
     350                 :            :         /* Get all of the available memory. */
     351                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 6, iovs);
     352                 :          6 :         CU_ASSERT(rc == 6);
     353                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
     354                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
     355                 :          6 :         CU_ASSERT(iovs[1].iov_base == mem);
     356                 :          6 :         CU_ASSERT(iovs[1].iov_len == 3);
     357                 :          6 :         CU_ASSERT(pipe->write == 3);
     358                 :          6 :         CU_ASSERT(pipe->read == 7);
     359                 :            : 
     360         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     361                 :            : 
     362                 :            :         /* Get more than the available memory */
     363                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 7, iovs);
     364                 :          6 :         CU_ASSERT(rc == 6);
     365                 :          6 :         CU_ASSERT(iovs[0].iov_base == (mem + 7));
     366                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
     367                 :          6 :         CU_ASSERT(iovs[1].iov_base == mem);
     368                 :          6 :         CU_ASSERT(iovs[1].iov_len == 3);
     369                 :          6 :         CU_ASSERT(pipe->write == 3);
     370                 :          6 :         CU_ASSERT(pipe->read == 7);
     371                 :            : 
     372         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     373                 :            : 
     374                 :            :         /* Empty the pipe */
     375                 :          6 :         pipe->read = 8;
     376                 :          6 :         pipe->write = 8;
     377                 :            : 
     378                 :            :         /* Get data while the pipe is empty */
     379                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 1, iovs);
     380                 :          6 :         CU_ASSERT(rc == 0);
     381                 :          6 :         CU_ASSERT(iovs[0].iov_base == NULL);
     382                 :          6 :         CU_ASSERT(iovs[0].iov_len == 0);
     383                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     384                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     385                 :          6 :         CU_ASSERT(pipe->write == 8);
     386                 :          6 :         CU_ASSERT(pipe->read == 8);
     387                 :            : 
     388                 :          6 :         spdk_pipe_destroy(pipe);
     389                 :          6 : }
     390                 :            : 
     391                 :            : static void
     392                 :          6 : test_read_advance(void)
     393                 :            : {
     394                 :            :         struct spdk_pipe *pipe;
     395                 :          5 :         uint8_t mem[10];
     396                 :            :         int rc;
     397                 :            : 
     398                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
     399         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
     400                 :            : 
     401                 :          6 :         pipe->read = 0;
     402                 :          6 :         pipe->write = 9;
     403                 :            : 
     404                 :            :         /* Advance half way through the pipe */
     405                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 5);
     406                 :          6 :         CU_ASSERT(rc == 0);
     407                 :          6 :         CU_ASSERT(pipe->read == 5);
     408                 :          6 :         CU_ASSERT(pipe->write == 9);
     409                 :            : 
     410                 :          6 :         pipe->read = 0;
     411                 :          6 :         pipe->write = 9;
     412                 :            : 
     413                 :            :         /* Advance to the end of the pipe, which resets
     414                 :            :          * it back to the beginning */
     415                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 9);
     416                 :          6 :         CU_ASSERT(rc == 0);
     417                 :          6 :         CU_ASSERT(pipe->read == 0);
     418                 :          6 :         CU_ASSERT(pipe->write == 0);
     419                 :            : 
     420                 :          6 :         pipe->read = 0;
     421                 :          6 :         pipe->write = 9;
     422                 :            : 
     423                 :            :         /* Advance beyond the end */
     424                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 10);
     425                 :          6 :         CU_ASSERT(rc == -EINVAL);
     426                 :          6 :         CU_ASSERT(pipe->read == 0);
     427                 :          6 :         CU_ASSERT(pipe->write == 9);
     428                 :            : 
     429                 :            :         /* Move the write pointer forward */
     430                 :          6 :         pipe->read = 0;
     431                 :          6 :         pipe->write = 5;
     432                 :            : 
     433                 :            :         /* Advance to the end of the pipe, which resets
     434                 :            :          * it back to the beginning */
     435                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 5);
     436                 :          6 :         CU_ASSERT(rc == 0);
     437                 :          6 :         CU_ASSERT(pipe->write == 0);
     438                 :          6 :         CU_ASSERT(pipe->read == 0);
     439                 :            : 
     440                 :          6 :         pipe->read = 0;
     441                 :          6 :         pipe->write = 5;
     442                 :            : 
     443                 :            :         /* Advance beyond the end */
     444                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 6);
     445                 :          6 :         CU_ASSERT(rc == -EINVAL);
     446                 :          6 :         CU_ASSERT(pipe->read == 0);
     447                 :          6 :         CU_ASSERT(pipe->write == 5);
     448                 :            : 
     449                 :            :         /* Test wrap around */
     450                 :          6 :         pipe->read = 7;
     451                 :          6 :         pipe->write = 3;
     452                 :            : 
     453                 :            :         /* Advance to the end of the pipe, which resets
     454                 :            :          * it back to the beginning */
     455                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 6);
     456                 :          6 :         CU_ASSERT(rc == 0);
     457                 :          6 :         CU_ASSERT(pipe->read == 0);
     458                 :          6 :         CU_ASSERT(pipe->write == 0);
     459                 :            : 
     460                 :          6 :         pipe->read = 7;
     461                 :          6 :         pipe->write = 3;
     462                 :            : 
     463                 :            :         /* Advance beyond the end */
     464                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 7);
     465                 :          6 :         CU_ASSERT(rc == -EINVAL);
     466                 :          6 :         CU_ASSERT(pipe->read == 7);
     467                 :          6 :         CU_ASSERT(pipe->write == 3);
     468                 :            : 
     469                 :          6 :         spdk_pipe_destroy(pipe);
     470                 :          6 : }
     471                 :            : 
     472                 :            : static void
     473                 :          6 : test_data(void)
     474                 :            : {
     475                 :            :         struct spdk_pipe *pipe;
     476                 :          5 :         uint8_t mem[10];
     477                 :          5 :         struct iovec iovs[2];
     478                 :            :         uint8_t *data;
     479                 :            :         int rc;
     480                 :            :         size_t i;
     481                 :            : 
     482         [ -  + ]:          6 :         memset(mem, 0, sizeof(mem));
     483         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     484                 :            : 
     485                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
     486         [ -  + ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
     487                 :            : 
     488                 :            :         /* Place 1 byte in the pipe */
     489                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
     490                 :          6 :         CU_ASSERT(rc == 1);
     491                 :          6 :         CU_ASSERT(iovs[0].iov_base == mem);
     492                 :          6 :         CU_ASSERT(iovs[0].iov_len == 1);
     493                 :            : 
     494         [ -  + ]:          6 :         memset(iovs[0].iov_base, 'A', 1);
     495                 :            : 
     496                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 1);
     497                 :          6 :         CU_ASSERT(rc == 0);
     498                 :            : 
     499                 :          6 :         CU_ASSERT(mem[0] == 'A');
     500                 :          6 :         CU_ASSERT(mem[1] == 0);
     501                 :          6 :         CU_ASSERT(mem[2] == 0);
     502                 :          6 :         CU_ASSERT(mem[3] == 0);
     503                 :          6 :         CU_ASSERT(mem[4] == 0);
     504                 :          6 :         CU_ASSERT(mem[5] == 0);
     505                 :          6 :         CU_ASSERT(mem[6] == 0);
     506                 :          6 :         CU_ASSERT(mem[7] == 0);
     507                 :          6 :         CU_ASSERT(mem[8] == 0);
     508                 :          6 :         CU_ASSERT(mem[9] == 0);
     509                 :            : 
     510         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     511                 :            : 
     512                 :            :         /* Get 1 byte from the pipe */
     513                 :          6 :         CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 1);
     514                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 10, iovs);
     515                 :          6 :         CU_ASSERT(rc == 1);
     516                 :            : 
     517                 :          6 :         data = iovs[0].iov_base;
     518                 :          6 :         CU_ASSERT(*data = 'A');
     519                 :            : 
     520                 :          6 :         spdk_pipe_reader_advance(pipe, 1);
     521                 :            : 
     522                 :            :         /* Put 9 more bytes in the pipe. The previous advance
     523                 :            :          * should have reset the pipe to the beginning. */
     524                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 9, iovs);
     525                 :          6 :         CU_ASSERT(rc == 9);
     526                 :          6 :         CU_ASSERT(iovs[0].iov_len == 9);
     527                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     528                 :            : 
     529         [ -  + ]:          6 :         memset(iovs[0].iov_base, 'B', iovs[0].iov_len);
     530                 :            : 
     531                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 9);
     532                 :          6 :         CU_ASSERT(rc == 0);
     533                 :            : 
     534                 :          6 :         CU_ASSERT(mem[0] == 'B');
     535                 :          6 :         CU_ASSERT(mem[1] == 'B');
     536                 :          6 :         CU_ASSERT(mem[2] == 'B');
     537                 :          6 :         CU_ASSERT(mem[3] == 'B');
     538                 :          6 :         CU_ASSERT(mem[4] == 'B');
     539                 :          6 :         CU_ASSERT(mem[5] == 'B');
     540                 :          6 :         CU_ASSERT(mem[6] == 'B');
     541                 :          6 :         CU_ASSERT(mem[7] == 'B');
     542                 :          6 :         CU_ASSERT(mem[8] == 'B');
     543                 :          6 :         CU_ASSERT(mem[9] == 0);
     544                 :            : 
     545         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     546                 :            : 
     547                 :            :         /* Get 7 bytes of the previously written 9. */
     548                 :          6 :         CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 9);
     549                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 7, iovs);
     550                 :          6 :         CU_ASSERT(rc == 7);
     551                 :            : 
     552                 :          6 :         CU_ASSERT(iovs[0].iov_len == 7);
     553                 :          6 :         data = iovs[0].iov_base;
     554         [ +  + ]:         48 :         for (i = 0; i < iovs[0].iov_len; i++) {
     555                 :         42 :                 CU_ASSERT(data[i] == 'B');
     556                 :            :         }
     557                 :            : 
     558                 :          6 :         spdk_pipe_reader_advance(pipe, 7);
     559                 :            : 
     560         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     561                 :            : 
     562                 :            :         /* Put 1 more byte in the pipe */
     563                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
     564                 :          6 :         CU_ASSERT(rc == 1);
     565                 :          6 :         CU_ASSERT(iovs[0].iov_len == 1);
     566                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     567                 :            : 
     568         [ -  + ]:          6 :         memset(iovs[0].iov_base, 'C', iovs[0].iov_len);
     569                 :            : 
     570                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 1);
     571                 :          6 :         CU_ASSERT(rc == 0);
     572                 :            : 
     573                 :          6 :         CU_ASSERT(mem[0] == 'B');
     574                 :          6 :         CU_ASSERT(mem[1] == 'B');
     575                 :          6 :         CU_ASSERT(mem[2] == 'B');
     576                 :          6 :         CU_ASSERT(mem[3] == 'B');
     577                 :          6 :         CU_ASSERT(mem[4] == 'B');
     578                 :          6 :         CU_ASSERT(mem[5] == 'B');
     579                 :          6 :         CU_ASSERT(mem[6] == 'B');
     580                 :          6 :         CU_ASSERT(mem[7] == 'B');
     581                 :          6 :         CU_ASSERT(mem[8] == 'B');
     582                 :          6 :         CU_ASSERT(mem[9] == 'C');
     583                 :            : 
     584         [ -  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     585                 :            : 
     586                 :            :         /* Get all of the data out of the pipe */
     587                 :          6 :         CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 3);
     588                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 3, iovs);
     589                 :          6 :         CU_ASSERT(rc == 3);
     590                 :          6 :         CU_ASSERT(iovs[0].iov_len == 3);
     591                 :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
     592                 :            : 
     593                 :          6 :         data = iovs[0].iov_base;
     594                 :          6 :         CU_ASSERT(data[0] == 'B');
     595                 :          6 :         CU_ASSERT(data[1] == 'B');
     596                 :          6 :         CU_ASSERT(data[2] == 'C');
     597                 :          6 :         CU_ASSERT(iovs[1].iov_base == NULL);
     598                 :            : 
     599                 :          6 :         spdk_pipe_reader_advance(pipe, 3);
     600                 :            : 
     601                 :          6 :         spdk_pipe_destroy(pipe);
     602                 :          6 : }
     603                 :            : 
     604                 :            : int
     605                 :          6 : main(int argc, char **argv)
     606                 :            : {
     607                 :          6 :         CU_pSuite       suite = NULL;
     608                 :            :         unsigned int    num_failures;
     609                 :            : 
     610                 :          6 :         CU_initialize_registry();
     611                 :            : 
     612                 :          6 :         suite = CU_add_suite("pipe", NULL, NULL);
     613                 :            : 
     614                 :          6 :         CU_ADD_TEST(suite, test_create_destroy);
     615                 :          6 :         CU_ADD_TEST(suite, test_write_get_buffer);
     616                 :          6 :         CU_ADD_TEST(suite, test_write_advance);
     617                 :          6 :         CU_ADD_TEST(suite, test_read_get_buffer);
     618                 :          6 :         CU_ADD_TEST(suite, test_read_advance);
     619                 :          6 :         CU_ADD_TEST(suite, test_data);
     620                 :            : 
     621                 :            : 
     622                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     623                 :            : 
     624                 :          6 :         CU_cleanup_registry();
     625                 :            : 
     626                 :          6 :         return num_failures;
     627                 :            : }

Generated by: LCOV version 1.14