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: 424 424 100.0 %
Date: 2024-11-17 06:36:47 Functions: 7 7 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 728 1386 52.5 %

           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                 :          1 :         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                 :          1 :         struct spdk_pipe *pipe;
      29                 :          5 :         uint8_t mem[10];
      30                 :          5 :         struct iovec iovs[2];
      31                 :          1 :         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                 :          1 :         struct spdk_pipe *pipe;
     174                 :          5 :         uint8_t mem[10];
     175                 :          1 :         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                 :          1 :         struct spdk_pipe *pipe;
     260                 :          5 :         uint8_t mem[10];
     261                 :          5 :         struct iovec iovs[2];
     262                 :          1 :         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                 :          1 :         struct spdk_pipe *pipe;
     395                 :          5 :         uint8_t mem[10];
     396                 :          1 :         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 */
     414                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 9);
     415                 :          6 :         CU_ASSERT(rc == 0);
     416   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->read == 9);
     417   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->write == 9);
     418                 :            : 
     419   [ +  -  +  - ]:          6 :         pipe->read = 0;
     420   [ +  -  +  - ]:          6 :         pipe->write = 9;
     421                 :            : 
     422                 :            :         /* Advance beyond the end */
     423                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 10);
     424                 :          6 :         CU_ASSERT(rc == -EINVAL);
     425   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->read == 0);
     426   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->write == 9);
     427                 :            : 
     428                 :            :         /* Move the write pointer forward */
     429   [ +  -  +  - ]:          6 :         pipe->read = 0;
     430   [ +  -  +  - ]:          6 :         pipe->write = 5;
     431                 :            : 
     432                 :            :         /* Advance to the end of the pipe */
     433                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 5);
     434                 :          6 :         CU_ASSERT(rc == 0);
     435   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->write == 5);
     436   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->read == 5);
     437                 :            : 
     438   [ +  -  +  - ]:          6 :         pipe->read = 0;
     439   [ +  -  +  - ]:          6 :         pipe->write = 5;
     440                 :            : 
     441                 :            :         /* Advance beyond the end */
     442                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 6);
     443                 :          6 :         CU_ASSERT(rc == -EINVAL);
     444   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->read == 0);
     445   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->write == 5);
     446                 :            : 
     447                 :            :         /* Test wrap around */
     448   [ +  -  +  - ]:          6 :         pipe->read = 7;
     449   [ +  -  +  - ]:          6 :         pipe->write = 3;
     450                 :            : 
     451                 :            :         /* Advance to the end of the pipe */
     452                 :          6 :         rc = spdk_pipe_reader_advance(pipe, 6);
     453                 :          6 :         CU_ASSERT(rc == 0);
     454   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->read == 3);
     455   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->write == 3);
     456                 :            : 
     457   [ +  -  +  - ]:          6 :         pipe->read = 7;
     458   [ +  -  +  - ]:          6 :         pipe->write = 3;
     459                 :            : 
     460                 :            :         /* Advance beyond the end */
     461                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 7);
     462                 :          6 :         CU_ASSERT(rc == -EINVAL);
     463   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->read == 7);
     464   [ +  -  +  - ]:          6 :         CU_ASSERT(pipe->write == 3);
     465                 :            : 
     466                 :          6 :         spdk_pipe_destroy(pipe);
     467                 :          6 : }
     468                 :            : 
     469                 :            : static void
     470                 :          6 : test_data(void)
     471                 :            : {
     472                 :          1 :         struct spdk_pipe *pipe;
     473                 :          5 :         uint8_t mem[10];
     474                 :          5 :         struct iovec iovs[2];
     475                 :          1 :         uint8_t *data;
     476                 :          1 :         int rc;
     477                 :          1 :         size_t i;
     478                 :            : 
     479         [ +  + ]:          6 :         memset(mem, 0, sizeof(mem));
     480         [ +  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     481                 :            : 
     482                 :          6 :         pipe = spdk_pipe_create(mem, sizeof(mem));
     483   [ +  +  #  # ]:          6 :         SPDK_CU_ASSERT_FATAL(pipe != NULL);
     484                 :            : 
     485                 :            :         /* Place 1 byte in the pipe */
     486                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
     487                 :          6 :         CU_ASSERT(rc == 1);
     488   [ +  -  +  - ]:          6 :         CU_ASSERT(iovs[0].iov_base != NULL);
     489   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[0].iov_len == 1);
                   +  - ]
     490                 :            : 
     491   [ +  +  +  -  :          6 :         memset(iovs[0].iov_base, 'A', 1);
                   +  - ]
     492                 :            : 
     493                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 1);
     494                 :          6 :         CU_ASSERT(rc == 0);
     495                 :            : 
     496   [ +  -  +  - ]:          6 :         CU_ASSERT(mem[0] == 'A');
     497   [ +  -  +  -  :          6 :         CU_ASSERT(mem[1] == 0);
                   +  - ]
     498   [ +  -  +  -  :          6 :         CU_ASSERT(mem[2] == 0);
                   +  - ]
     499   [ +  -  +  -  :          6 :         CU_ASSERT(mem[3] == 0);
                   +  - ]
     500   [ +  -  +  -  :          6 :         CU_ASSERT(mem[4] == 0);
                   +  - ]
     501   [ +  -  +  -  :          6 :         CU_ASSERT(mem[5] == 0);
                   +  - ]
     502   [ +  -  +  -  :          6 :         CU_ASSERT(mem[6] == 0);
                   +  - ]
     503   [ +  -  +  -  :          6 :         CU_ASSERT(mem[7] == 0);
                   +  - ]
     504   [ +  -  +  -  :          6 :         CU_ASSERT(mem[8] == 0);
                   +  - ]
     505   [ +  -  +  -  :          6 :         CU_ASSERT(mem[9] == 0);
                   +  - ]
     506                 :            : 
     507         [ +  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     508                 :            : 
     509                 :            :         /* Get 1 byte from the pipe */
     510                 :          6 :         CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 1);
     511                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 10, iovs);
     512                 :          6 :         CU_ASSERT(rc == 1);
     513                 :            : 
     514   [ +  -  +  - ]:          6 :         data = iovs[0].iov_base;
     515         [ +  - ]:          6 :         CU_ASSERT(*data = 'A');
     516                 :            : 
     517                 :          6 :         spdk_pipe_reader_advance(pipe, 1);
     518                 :            : 
     519                 :            :         /* Put 9 more bytes in the pipe, so every byte has
     520                 :            :          * been written */
     521                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 9, iovs);
     522                 :          6 :         CU_ASSERT(rc == 9);
     523   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[0].iov_len == 9);
                   +  - ]
     524   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
             +  -  +  - ]
     525                 :            : 
     526   [ +  +  +  -  :          6 :         memset(iovs[0].iov_base, 'B', iovs[0].iov_len);
          +  -  +  -  +  
                -  +  - ]
     527                 :            : 
     528                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 9);
     529                 :          6 :         CU_ASSERT(rc == 0);
     530                 :            : 
     531   [ +  -  +  - ]:          6 :         CU_ASSERT(mem[0] == 'A');
     532   [ +  -  +  -  :          6 :         CU_ASSERT(mem[1] == 'B');
                   +  - ]
     533   [ +  -  +  -  :          6 :         CU_ASSERT(mem[2] == 'B');
                   +  - ]
     534   [ +  -  +  -  :          6 :         CU_ASSERT(mem[3] == 'B');
                   +  - ]
     535   [ +  -  +  -  :          6 :         CU_ASSERT(mem[4] == 'B');
                   +  - ]
     536   [ +  -  +  -  :          6 :         CU_ASSERT(mem[5] == 'B');
                   +  - ]
     537   [ +  -  +  -  :          6 :         CU_ASSERT(mem[6] == 'B');
                   +  - ]
     538   [ +  -  +  -  :          6 :         CU_ASSERT(mem[7] == 'B');
                   +  - ]
     539   [ +  -  +  -  :          6 :         CU_ASSERT(mem[8] == 'B');
                   +  - ]
     540   [ +  -  +  -  :          6 :         CU_ASSERT(mem[9] == 'B');
                   +  - ]
     541                 :            : 
     542         [ +  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     543                 :            : 
     544                 :            :         /* Get 7 bytes of the previously written 9. */
     545                 :          6 :         CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 9);
     546                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 7, iovs);
     547                 :          6 :         CU_ASSERT(rc == 7);
     548                 :            : 
     549   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[0].iov_len == 7);
                   +  - ]
     550   [ +  -  +  - ]:          6 :         data = iovs[0].iov_base;
     551   [ +  +  +  -  :         48 :         for (i = 0; i < iovs[0].iov_len; i++) {
             +  -  +  + ]
     552   [ +  -  +  - ]:         42 :                 CU_ASSERT(data[i] == 'B');
     553                 :          7 :         }
     554                 :            : 
     555                 :          6 :         spdk_pipe_reader_advance(pipe, 7);
     556                 :            : 
     557         [ +  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     558                 :            : 
     559                 :            :         /* Put 1 more byte in the pipe, overwriting the original 'A' */
     560                 :          6 :         rc = spdk_pipe_writer_get_buffer(pipe, 1, iovs);
     561                 :          6 :         CU_ASSERT(rc == 1);
     562   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[0].iov_len == 1);
                   +  - ]
     563   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[1].iov_len == 0);
             +  -  +  - ]
     564                 :            : 
     565   [ +  +  +  -  :          6 :         memset(iovs[0].iov_base, 'C', iovs[0].iov_len);
          +  -  +  -  +  
                -  +  - ]
     566                 :            : 
     567                 :          6 :         rc = spdk_pipe_writer_advance(pipe, 1);
     568                 :          6 :         CU_ASSERT(rc == 0);
     569                 :            : 
     570   [ +  -  +  - ]:          6 :         CU_ASSERT(mem[0] == 'C');
     571   [ +  -  +  -  :          6 :         CU_ASSERT(mem[1] == 'B');
                   +  - ]
     572   [ +  -  +  -  :          6 :         CU_ASSERT(mem[2] == 'B');
                   +  - ]
     573   [ +  -  +  -  :          6 :         CU_ASSERT(mem[3] == 'B');
                   +  - ]
     574   [ +  -  +  -  :          6 :         CU_ASSERT(mem[4] == 'B');
                   +  - ]
     575   [ +  -  +  -  :          6 :         CU_ASSERT(mem[5] == 'B');
                   +  - ]
     576   [ +  -  +  -  :          6 :         CU_ASSERT(mem[6] == 'B');
                   +  - ]
     577   [ +  -  +  -  :          6 :         CU_ASSERT(mem[7] == 'B');
                   +  - ]
     578   [ +  -  +  -  :          6 :         CU_ASSERT(mem[8] == 'B');
                   +  - ]
     579   [ +  -  +  -  :          6 :         CU_ASSERT(mem[9] == 'B');
                   +  - ]
     580                 :            : 
     581         [ +  + ]:          6 :         memset(iovs, 0, sizeof(iovs));
     582                 :            : 
     583                 :            :         /* Get all of the data out of the pipe */
     584                 :          6 :         CU_ASSERT(spdk_pipe_reader_bytes_available(pipe) == 3);
     585                 :          6 :         rc = spdk_pipe_reader_get_buffer(pipe, 3, iovs);
     586                 :          6 :         CU_ASSERT(rc == 3);
     587   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[0].iov_len == 2);
                   +  - ]
     588   [ +  -  +  -  :          6 :         CU_ASSERT(iovs[1].iov_len == 1);
             +  -  +  - ]
     589                 :            : 
     590   [ +  -  +  - ]:          6 :         data = iovs[0].iov_base;
     591   [ +  -  +  - ]:          6 :         CU_ASSERT(data[0] == 'B');
     592   [ +  -  +  - ]:          6 :         CU_ASSERT(data[1] == 'B');
     593   [ +  -  +  -  :          6 :         data = iovs[1].iov_base;
             +  -  +  - ]
     594   [ +  -  +  - ]:          6 :         CU_ASSERT(data[0] == 'C');
     595                 :            : 
     596                 :          6 :         spdk_pipe_reader_advance(pipe, 3);
     597                 :            : 
     598                 :          6 :         spdk_pipe_destroy(pipe);
     599                 :          6 : }
     600                 :            : 
     601                 :            : int
     602                 :          6 : main(int argc, char **argv)
     603                 :            : {
     604                 :          6 :         CU_pSuite       suite = NULL;
     605                 :          1 :         unsigned int    num_failures;
     606                 :            : 
     607                 :          6 :         CU_initialize_registry();
     608                 :            : 
     609                 :          6 :         suite = CU_add_suite("pipe", NULL, NULL);
     610                 :            : 
     611                 :          6 :         CU_ADD_TEST(suite, test_create_destroy);
     612                 :          6 :         CU_ADD_TEST(suite, test_write_get_buffer);
     613                 :          6 :         CU_ADD_TEST(suite, test_write_advance);
     614                 :          6 :         CU_ADD_TEST(suite, test_read_get_buffer);
     615                 :          6 :         CU_ADD_TEST(suite, test_read_advance);
     616                 :          6 :         CU_ADD_TEST(suite, test_data);
     617                 :            : 
     618                 :            : 
     619                 :          6 :         num_failures = spdk_ut_run_tests(argc, argv, NULL);
     620                 :            : 
     621                 :          6 :         CU_cleanup_registry();
     622                 :            : 
     623                 :          7 :         return num_failures;
     624                 :          1 : }

Generated by: LCOV version 1.15