LCOV - code coverage report
Current view: top level - src/test/fuzz - prevector.cpp (source / functions) Coverage Total Hit
Test: fuzz_coverage.info Lines: 100.0 % 181 181
Test Date: 2026-11-21 05:38:30 Functions: 100.0 % 18 18
Branches: 72.0 % 186 134

             Branch data     Line data    Source code
       1                 :             : // Copyright (c) 2015-present The Bitcoin Core developers
       2                 :             : // Distributed under the MIT software license, see the accompanying
       3                 :             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       4                 :             : 
       5                 :             : #include <prevector.h>
       6                 :             : 
       7                 :             : #include <serialize.h>
       8                 :             : #include <streams.h>
       9                 :             : #include <test/fuzz/FuzzedDataProvider.h>
      10                 :             : #include <test/fuzz/fuzz.h>
      11                 :             : #include <util/check.h>
      12                 :             : 
      13                 :             : #include <ranges>
      14                 :             : #include <vector>
      15                 :             : namespace {
      16                 :             : 
      17                 :             : template <unsigned int N, typename T>
      18                 :             : class prevector_tester
      19                 :             : {
      20                 :             :     typedef std::vector<T> realtype;
      21                 :             :     realtype real_vector;
      22                 :             :     realtype real_vector_alt;
      23                 :             : 
      24                 :             :     typedef prevector<N, T> pretype;
      25                 :             :     pretype pre_vector;
      26                 :             :     pretype pre_vector_alt;
      27                 :             : 
      28                 :             :     typedef typename pretype::size_type Size;
      29                 :             : 
      30                 :             : public:
      31                 :         249 :     void test() const
      32                 :             :     {
      33                 :         249 :         const pretype& const_pre_vector = pre_vector;
      34   [ -  +  +  +  :         415 :         assert(real_vector.size() == pre_vector.size());
                   -  + ]
      35         [ -  + ]:         249 :         assert(real_vector.empty() == pre_vector.empty());
      36         [ +  + ]:      760605 :         for (Size s = 0; s < real_vector.size(); s++) {
      37   [ +  +  -  + ]:     1520712 :             assert(real_vector[s] == pre_vector[s]);
      38   [ +  +  -  + ]:     1520712 :             assert(&(pre_vector[s]) == &(pre_vector.begin()[s]));
      39         [ -  + ]:      760356 :             assert(&(pre_vector[s]) == &*(pre_vector.begin() + s));
      40         [ -  + ]:      760356 :             assert(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
      41                 :             :         }
      42                 :             :         // assert(realtype(pre_vector) == real_vector);
      43         [ -  + ]:         249 :         assert(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
      44   [ +  +  -  + ]:         498 :         assert(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
      45                 :         249 :         size_t pos = 0;
      46   [ +  +  +  + ]:      760854 :         for (const T& v : pre_vector) {
      47         [ -  + ]:      760356 :             assert(v == real_vector[pos]);
      48                 :      760356 :             ++pos;
      49                 :             :         }
      50         [ +  + ]:      760605 :         for (const T& v : pre_vector | std::views::reverse) {
      51                 :      760356 :             --pos;
      52         [ -  + ]:      760356 :             assert(v == real_vector[pos]);
      53                 :             :         }
      54         [ +  + ]:      760605 :         for (const T& v : const_pre_vector) {
      55         [ -  + ]:      760356 :             assert(v == real_vector[pos]);
      56                 :      760356 :             ++pos;
      57                 :             :         }
      58         [ +  + ]:      760605 :         for (const T& v : const_pre_vector | std::views::reverse) {
      59                 :      760356 :             --pos;
      60         [ -  + ]:      760356 :             assert(v == real_vector[pos]);
      61                 :             :         }
      62                 :         249 :         DataStream ss1{};
      63                 :         249 :         DataStream ss2{};
      64         [ +  - ]:         249 :         ss1 << real_vector;
      65   [ +  -  -  + ]:         498 :         ss2 << pre_vector;
      66   [ -  +  -  + ]:         249 :         assert(ss1.size() == ss2.size());
      67         [ +  + ]:     3042016 :         for (Size s = 0; s < ss1.size(); s++) {
      68         [ -  + ]:     3041767 :             assert(ss1[s] == ss2[s]);
      69                 :             :         }
      70                 :         249 :     }
      71                 :             : 
      72                 :       13111 :     void resize(Size s)
      73                 :             :     {
      74                 :       13111 :         real_vector.resize(s);
      75   [ -  +  -  + ]:       13111 :         assert(real_vector.size() == s);
      76                 :       13111 :         pre_vector.resize(s);
      77   [ +  +  -  + ]:       19110 :         assert(pre_vector.size() == s);
      78                 :       13111 :     }
      79                 :             : 
      80                 :        6706 :     void reserve(Size s)
      81                 :             :     {
      82                 :        6706 :         real_vector.reserve(s);
      83   [ -  +  -  + ]:        6706 :         assert(real_vector.capacity() >= s);
      84                 :        6706 :         pre_vector.reserve(s);
      85   [ +  +  -  + ]:       12913 :         assert(pre_vector.capacity() >= s);
      86                 :        6706 :     }
      87                 :             : 
      88                 :       19816 :     void insert(Size position, const T& value)
      89                 :             :     {
      90                 :       19816 :         real_vector.insert(real_vector.begin() + position, value);
      91         [ +  + ]:       39632 :         pre_vector.insert(pre_vector.begin() + position, value);
      92                 :       19816 :     }
      93                 :             : 
      94                 :       17064 :     void insert(Size position, Size count, const T& value)
      95                 :             :     {
      96                 :       17064 :         real_vector.insert(real_vector.begin() + position, count, value);
      97         [ +  + ]:       34128 :         pre_vector.insert(pre_vector.begin() + position, count, value);
      98                 :       17064 :     }
      99                 :             : 
     100                 :             :     template <typename I>
     101                 :       10568 :     void insert_range(Size position, I first, I last)
     102                 :             :     {
     103                 :       10568 :         real_vector.insert(real_vector.begin() + position, first, last);
     104         [ +  + ]:       21136 :         pre_vector.insert(pre_vector.begin() + position, first, last);
     105                 :       10568 :     }
     106                 :             : 
     107                 :        4402 :     void erase(Size position)
     108                 :             :     {
     109                 :        4402 :         real_vector.erase(real_vector.begin() + position);
     110         [ +  + ]:        8804 :         pre_vector.erase(pre_vector.begin() + position);
     111                 :        4402 :     }
     112                 :             : 
     113                 :        8471 :     void erase(Size first, Size last)
     114                 :             :     {
     115                 :        8471 :         real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
     116         [ +  + ]:       16942 :         pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
     117                 :        8471 :     }
     118                 :             : 
     119                 :        4047 :     void update(Size pos, const T& value)
     120                 :             :     {
     121         [ +  + ]:        4047 :         real_vector[pos] = value;
     122         [ +  + ]:        4047 :         pre_vector[pos] = value;
     123                 :        4047 :     }
     124                 :             : 
     125                 :        6338 :     void push_back(const T& value)
     126                 :             :     {
     127                 :        6338 :         real_vector.push_back(value);
     128                 :        6338 :         pre_vector.push_back(value);
     129                 :        6338 :     }
     130                 :             : 
     131                 :        7006 :     void pop_back()
     132                 :             :     {
     133                 :        7006 :         real_vector.pop_back();
     134                 :        7006 :         pre_vector.pop_back();
     135                 :        7006 :     }
     136                 :             : 
     137                 :        7212 :     void clear()
     138                 :             :     {
     139         [ +  + ]:        7212 :         real_vector.clear();
     140                 :        7212 :         pre_vector.clear();
     141                 :        7212 :     }
     142                 :             : 
     143                 :       14046 :     void assign(Size n, const T& value)
     144                 :             :     {
     145                 :       14046 :         real_vector.assign(n, value);
     146                 :       14046 :         pre_vector.assign(n, value);
     147                 :       14046 :     }
     148                 :             : 
     149                 :      265422 :     Size size() const
     150                 :             :     {
     151                 :      530844 :         return real_vector.size();
     152                 :             :     }
     153                 :             : 
     154                 :             :     Size capacity() const
     155                 :             :     {
     156                 :             :         return pre_vector.capacity();
     157                 :             :     }
     158                 :             : 
     159                 :       12318 :     void shrink_to_fit()
     160                 :             :     {
     161                 :       12318 :         pre_vector.shrink_to_fit();
     162                 :       12318 :     }
     163                 :             : 
     164                 :        9616 :     void swap() noexcept
     165                 :             :     {
     166                 :        9616 :         real_vector.swap(real_vector_alt);
     167                 :        9616 :         pre_vector.swap(pre_vector_alt);
     168                 :        9616 :     }
     169                 :             : 
     170                 :       17293 :     void move()
     171                 :             :     {
     172                 :       17293 :         real_vector = std::move(real_vector_alt);
     173         [ -  + ]:       17293 :         real_vector_alt.clear();
     174                 :       17293 :         pre_vector = std::move(pre_vector_alt);
     175                 :       17293 :         pre_vector_alt.clear();
     176                 :       17293 :     }
     177                 :             : 
     178                 :       17345 :     void copy()
     179                 :             :     {
     180                 :       17345 :         real_vector = real_vector_alt;
     181                 :       17345 :         pre_vector = pre_vector_alt;
     182                 :       17345 :     }
     183                 :             : 
     184         [ -  + ]:        4113 :     void resize_uninitialized(realtype values)
     185                 :             :     {
     186                 :        4113 :         size_t r = values.size();
     187         [ -  + ]:        4113 :         size_t s = real_vector.size() / 2;
     188   [ -  +  +  + ]:        4113 :         if (real_vector.capacity() < s + r) {
     189                 :        1657 :             real_vector.reserve(s + r);
     190                 :             :         }
     191                 :        4113 :         real_vector.resize(s);
     192                 :        4113 :         pre_vector.resize_uninitialized(s);
     193         [ +  + ]:       32523 :         for (auto v : values) {
     194                 :       28410 :             real_vector.push_back(v);
     195                 :             :         }
     196         [ +  + ]:        4113 :         auto p = pre_vector.size();
     197                 :        4113 :         pre_vector.resize_uninitialized(p + r);
     198         [ +  + ]:       32523 :         for (auto v : values) {
     199         [ +  + ]:       28410 :             pre_vector[p] = v;
     200                 :       28410 :             ++p;
     201                 :             :         }
     202                 :        4113 :     }
     203                 :             : };
     204                 :             : 
     205                 :             : } // namespace
     206                 :             : 
     207         [ +  - ]:         725 : FUZZ_TARGET(prevector)
     208                 :             : {
     209                 :         249 :     FuzzedDataProvider prov(buffer.data(), buffer.size());
     210                 :         249 :     prevector_tester<8, int> test;
     211                 :             : 
     212   [ +  +  +  + ]:      179721 :     LIMITED_WHILE (prov.remaining_bytes(), 3000) {
     213                 :      227281 :         switch (prov.ConsumeIntegralInRange<int>(0, 13 + 3 * (test.size() > 0))) {
           [ +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
                -  -  + ]
     214                 :       19816 :         case 0: {
     215         [ -  + ]:       19816 :             auto position = prov.ConsumeIntegralInRange<size_t>(0, test.size());
     216                 :       19816 :             auto value = prov.ConsumeIntegral<int>();
     217         [ +  - ]:       19816 :             test.insert(position, value);
     218                 :             :         } break;
     219                 :       13111 :         case 1:
     220   [ -  +  +  +  :       35676 :             test.resize(std::max(0, std::min(30, (int)test.size() + prov.ConsumeIntegralInRange<int>(0, 4) - 2)));
             +  +  +  - ]
     221                 :             :             break;
     222                 :       17064 :         case 2: {
     223         [ -  + ]:       17064 :             auto position = prov.ConsumeIntegralInRange<size_t>(0, test.size());
     224                 :       17064 :             auto count = 1 + prov.ConsumeBool();
     225                 :       17064 :             auto value = prov.ConsumeIntegral<int>();
     226         [ +  - ]:       17064 :             test.insert(position, count, value);
     227                 :             :         } break;
     228                 :        8471 :         case 3: {
     229         [ -  + ]:        8471 :             int del = prov.ConsumeIntegralInRange<int>(0, test.size());
     230         [ -  + ]:        8471 :             int beg = prov.ConsumeIntegralInRange<int>(0, test.size() - del);
     231                 :        8471 :             test.erase(beg, beg + del);
     232                 :             :             break;
     233                 :             :         }
     234                 :        6338 :         case 4:
     235         [ +  - ]:        6338 :             test.push_back(prov.ConsumeIntegral<int>());
     236                 :             :             break;
     237                 :       10568 :         case 5: {
     238                 :       10568 :             int values[4];
     239                 :       10568 :             int num = 1 + prov.ConsumeIntegralInRange<int>(0, 3);
     240         [ +  + ]:       33330 :             for (int k = 0; k < num; ++k) {
     241                 :       22762 :                 values[k] = prov.ConsumeIntegral<int>();
     242                 :             :             }
     243   [ -  +  +  - ]:       10568 :             test.insert_range(prov.ConsumeIntegralInRange<size_t>(0, test.size()), values, values + num);
     244                 :             :             break;
     245                 :             :         }
     246                 :        4113 :         case 6: {
     247                 :        4113 :             int num = 1 + prov.ConsumeIntegralInRange<int>(0, 15);
     248         [ +  - ]:        4113 :             std::vector<int> values(num);
     249         [ +  + ]:       32523 :             for (auto& v : values) {
     250                 :       28410 :                 v = prov.ConsumeIntegral<int>();
     251                 :             :             }
     252   [ +  -  +  - ]:        4113 :             test.resize_uninitialized(values);
     253                 :        4113 :             break;
     254                 :        4113 :         }
     255                 :        6706 :         case 7:
     256         [ +  - ]:        6706 :             test.reserve(prov.ConsumeIntegralInRange<size_t>(0, 32767));
     257                 :             :             break;
     258                 :       12318 :         case 8:
     259                 :       12318 :             test.shrink_to_fit();
     260                 :             :             break;
     261                 :        7212 :         case 9:
     262                 :        7212 :             test.clear();
     263                 :             :             break;
     264                 :       14046 :         case 10: {
     265                 :       14046 :             auto n = prov.ConsumeIntegralInRange<size_t>(0, 32767);
     266                 :       14046 :             auto value = prov.ConsumeIntegral<int>();
     267         [ +  - ]:       14046 :             test.assign(n, value);
     268                 :             :         } break;
     269                 :        9616 :         case 11:
     270                 :        9616 :             test.swap();
     271                 :        9616 :             break;
     272                 :       17345 :         case 12:
     273         [ +  - ]:       17345 :             test.copy();
     274                 :             :             break;
     275                 :       17293 :         case 13:
     276                 :       17293 :             test.move();
     277                 :             :             break;
     278                 :        4047 :         case 14: {
     279         [ -  + ]:        4047 :             auto pos = prov.ConsumeIntegralInRange<size_t>(0, test.size() - 1);
     280                 :        4047 :             auto value = prov.ConsumeIntegral<int>();
     281                 :        4047 :             test.update(pos, value);
     282                 :             :         } break;
     283                 :        4402 :         case 15:
     284         [ -  + ]:        4402 :             test.erase(prov.ConsumeIntegralInRange<size_t>(0, test.size() - 1));
     285                 :             :             break;
     286                 :        7006 :         case 16:
     287                 :        7006 :             test.pop_back();
     288                 :             :             break;
     289                 :             :         }
     290                 :             :     }
     291                 :             : 
     292         [ +  - ]:         249 :     test.test();
     293                 :         249 : }
        

Generated by: LCOV version 2.5.0-full