LCOV - code coverage report
Current view: top level - src/test/fuzz - prevector.cpp (source / functions) Hit Total Coverage
Test: fuzz_coverage.info Lines: 2 175 1.1 %
Date: 2023-10-05 12:38:51 Functions: 2 24 8.3 %
Branches: 2 210 1.0 %

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

Generated by: LCOV version 1.14