LCOV - code coverage report
Current view: top level - src/test - prevector_tests.cpp (source / functions) Hit Total Coverage
Test: total_coverage.info Lines: 186 191 97.4 %
Date: 2025-02-23 09:33:43 Functions: 18 18 100.0 %

          Line data    Source code
       1             : // Copyright (c) 2015 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 <vector>
       6             : #include "prevector.h"
       7             : #include "random.h"
       8             : 
       9             : #include "serialize.h"
      10             : #include "streams.h"
      11             : 
      12             : #include "test/test_pivx.h"
      13             : 
      14             : #include <boost/test/unit_test.hpp>
      15             : 
      16             : BOOST_FIXTURE_TEST_SUITE(PrevectorTests, TestingSetup)
      17             : 
      18             : template<unsigned int N, typename T>
      19             : class prevector_tester {
      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             :     bool passed = true;
      30             :     FastRandomContext rand_cache;
      31             :     uint256 rand_seed;
      32             : 
      33             :     template <typename A, typename B>
      34    13317900 :         void local_check_equal(A a, B b)
      35             :         {
      36    13317900 :             local_check(a == b);
      37             :         }
      38    29562400 :     void local_check(bool b)
      39             :     {
      40     6320380 :         passed &= b;
      41             :     }
      42      219648 :     void test() {
      43      219648 :         const pretype& const_pre_vector = pre_vector;
      44      429824 :         local_check_equal(real_vector.size(), pre_vector.size());
      45      219648 :         local_check_equal(real_vector.empty(), pre_vector.empty());
      46     3379840 :         for (Size s = 0; s < real_vector.size(); s++) {
      47     3160190 :              local_check(real_vector[s] == pre_vector[s]);
      48     6320380 :              local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
      49     3160190 :              local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
      50     6320380 :              local_check(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
      51             :         }
      52             :         // local_check(realtype(pre_vector) == real_vector);
      53      219648 :         local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
      54      658944 :         local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
      55      219648 :         size_t pos = 0;
      56             : 
      57     3819140 :         for (const T& v  : pre_vector) {
      58     3160190 :             local_check(v == real_vector[pos++]);
      59             :         }
      60      219648 :         pos = 0;
      61     3379840 :         for (const T& v : const_pre_vector) {
      62     3160190 :             local_check(v == real_vector[pos++]);
      63             :         }
      64             : 
      65      439296 :         CDataStream ss1(SER_DISK, 0);
      66      219648 :         CDataStream ss2(SER_DISK, 0);
      67      219648 :         ss1 << real_vector;
      68      219648 :         ss2 << pre_vector;
      69      219648 :         local_check_equal(ss1.size(), ss2.size());
      70    13080100 :         for (Size s = 0; s < ss1.size(); s++) {
      71    12860400 :             local_check_equal(ss1[s], ss2[s]);
      72             :         }
      73      219648 :     }
      74             : 
      75             : public:
      76        9088 :     void resize(Size s) {
      77        9088 :         real_vector.resize(s);
      78        9088 :         local_check_equal(real_vector.size(), s);
      79        9088 :         pre_vector.resize(s);
      80        9088 :         local_check_equal(pre_vector.size(), s);
      81        9088 :         test();
      82        9088 :     }
      83             : 
      84        2112 :     void reserve(Size s) {
      85        2112 :         real_vector.reserve(s);
      86        2112 :         local_check(real_vector.capacity() >= s);
      87        2112 :         pre_vector.reserve(s);
      88        2112 :         local_check(pre_vector.capacity() >= s);
      89        2112 :         test();
      90        2112 :     }
      91             : 
      92       31616 :     void insert(Size position, const T& value) {
      93       31616 :         real_vector.insert(real_vector.begin() + position, value);
      94       63232 :         pre_vector.insert(pre_vector.begin() + position, value);
      95       31616 :         test();
      96       31616 :     }
      97             : 
      98        8512 :     void insert(Size position, Size count, const T& value) {
      99        8512 :         real_vector.insert(real_vector.begin() + position, count, value);
     100       17024 :         pre_vector.insert(pre_vector.begin() + position, count, value);
     101        8512 :         test();
     102        8512 :     }
     103             : 
     104             :     template<typename I>
     105        2240 :     void insert_range(Size position, I first, I last) {
     106        2240 :         real_vector.insert(real_vector.begin() + position, first, last);
     107        4480 :         pre_vector.insert(pre_vector.begin() + position, first, last);
     108        2240 :         test();
     109        2240 :     }
     110             : 
     111       15680 :     void erase(Size position) {
     112       15680 :         real_vector.erase(real_vector.begin() + position);
     113       31360 :         pre_vector.erase(pre_vector.begin() + position);
     114       15680 :         test();
     115       15680 :     }
     116             : 
     117        9920 :     void erase(Size first, Size last) {
     118        9920 :         real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
     119       19840 :         pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
     120        9920 :         test();
     121        9920 :     }
     122             : 
     123      118400 :     void update(Size pos, const T& value) {
     124      118400 :         real_vector[pos] = value;
     125      118400 :         pre_vector[pos] = value;
     126      118400 :         test();
     127      118400 :     }
     128             : 
     129        4288 :     void push_back(const T& value) {
     130        4288 :         real_vector.push_back(value);
     131        4288 :         pre_vector.push_back(value);
     132        4288 :         test();
     133        4288 :     }
     134             : 
     135        3456 :     void pop_back() {
     136        3456 :         real_vector.pop_back();
     137        3456 :         pre_vector.pop_back();
     138        3456 :         test();
     139        3456 :     }
     140             : 
     141           0 :     void clear() {
     142           0 :         real_vector.clear();
     143           0 :         pre_vector.clear();
     144           0 :     }
     145             : 
     146         128 :     void assign(Size n, const T& value) {
     147         256 :         real_vector.assign(n, value);
     148         128 :         pre_vector.assign(n, value);
     149             :     }
     150             : 
     151      598592 :     Size size() {
     152      598592 :         return real_vector.size();
     153             :     }
     154             : 
     155             :     Size capacity() {
     156             :         return pre_vector.capacity();
     157             :     }
     158             : 
     159        1216 :     void shrink_to_fit() {
     160        1216 :         pre_vector.shrink_to_fit();
     161        1216 :         test();
     162        1216 :     }
     163             : 
     164        8000 :     void swap() {
     165        8000 :         real_vector.swap(real_vector_alt);
     166        8000 :         pre_vector.swap(pre_vector_alt);
     167        8000 :         test();
     168        8000 :     }
     169             : 
     170        1856 :     void move() {
     171        1856 :         real_vector = std::move(real_vector_alt);
     172        1856 :         real_vector_alt.clear();
     173        1856 :         pre_vector = std::move(pre_vector_alt);
     174        1856 :         pre_vector_alt.clear();
     175        1856 :     }
     176             : 
     177        4096 :     void copy() {
     178        4096 :         real_vector = real_vector_alt;
     179        4096 :         pre_vector = pre_vector_alt;
     180        4096 :     }
     181             : 
     182        5120 :     void resize_uninitialized(realtype values) {
     183        5120 :         size_t r = values.size();
     184        5120 :         size_t s = real_vector.size() / 2;
     185        5120 :         if (real_vector.capacity() < s + r) {
     186        1344 :             real_vector.reserve(s + r);
     187             :         }
     188        5120 :         real_vector.resize(s);
     189        5120 :         pre_vector.resize_uninitialized(s);
     190       49600 :         for (auto v : values) {
     191       44480 :             real_vector.push_back(v);
     192             :         }
     193        5120 :         auto p = pre_vector.size();
     194        5120 :         pre_vector.resize_uninitialized(p + r);
     195       49600 :         for (auto v : values) {
     196       44480 :             pre_vector[p] = v;
     197       44480 :             ++p;
     198             :         }
     199        5120 :         test();
     200        5120 :     }
     201             : 
     202          64 :     ~prevector_tester() {
     203         128 :         BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString());
     204         256 :     }
     205         128 :     prevector_tester() {
     206          64 :         SeedInsecureRand();
     207          64 :         rand_seed = InsecureRand256();
     208          64 :         rand_cache = FastRandomContext(rand_seed);
     209          64 :     }
     210             : };
     211             : 
     212           2 : BOOST_AUTO_TEST_CASE(PrevectorTestInt)
     213             : {
     214          65 :     for (int j = 0; j < 64; j++) {
     215         128 :         prevector_tester<8, int> test;
     216      131136 :         for (int i = 0; i < 2048; i++) {
     217      131072 :             int r = InsecureRand32();
     218      131072 :             if ((r % 4) == 0) {
     219       31616 :                 test.insert(InsecureRand32() % (test.size() + 1), InsecureRand32());
     220             :             }
     221      131072 :             if (test.size() > 0 && ((r >> 2) % 4) == 1) {
     222       15680 :                 test.erase(InsecureRand32() % test.size());
     223             :             }
     224      131072 :             if (((r >> 4) % 8) == 2) {
     225       17600 :                 int new_size = std::max<int>(0, std::min<int>(30, test.size() + (InsecureRand32() % 5) - 2));
     226        9088 :                 test.resize(new_size);
     227             :             }
     228      131072 :             if (((r >> 7) % 8) == 3) {
     229        8512 :                 test.insert(InsecureRand32() % (test.size() + 1), 1 + (InsecureRand32() % 2), InsecureRand32());
     230             :             }
     231      131072 :             if (((r >> 10) % 8) == 4) {
     232        8064 :                 int del = std::min<int>(test.size(), 1 + (InsecureRand32() % 2));
     233        8064 :                 int beg = InsecureRand32() % (test.size() + 1 - del);
     234        8064 :                 test.erase(beg, beg + del);
     235             :             }
     236      131072 :             if (((r >> 13) % 16) == 5) {
     237        4288 :                 test.push_back(InsecureRand32());
     238             :             }
     239      131072 :             if (test.size() > 0 && ((r >> 17) % 16) == 6) {
     240        3456 :                 test.pop_back();
     241             :             }
     242      131072 :             if (((r >> 21) % 32) == 7) {
     243        2240 :                 int values[4];
     244        2240 :                 int num = 1 + (InsecureRand32() % 4);
     245        7360 :                 for (int i = 0; i < num; i++) {
     246        5120 :                     values[i] = InsecureRand32();
     247             :                 }
     248        2240 :                 test.insert_range(InsecureRand32() % (test.size() + 1), values, values + num);
     249             :             }
     250      131072 :             if (((r >> 26) % 32) == 8) {
     251        1856 :                 int del = std::min<int>(test.size(), 1 + (InsecureRand32() % 4));
     252        1856 :                 int beg = InsecureRand32() % (test.size() + 1 - del);
     253        1856 :                 test.erase(beg, beg + del);
     254             :             }
     255      131072 :             r = InsecureRand32();
     256      131072 :             if (r % 32 == 9) {
     257        2112 :                 test.reserve(InsecureRand32() % 32);
     258             :             }
     259      131072 :             if ((r >> 5) % 64 == 10) {
     260        1216 :                 test.shrink_to_fit();
     261             :             }
     262      131072 :             if (test.size() > 0) {
     263      118400 :                 test.update(InsecureRand32() % test.size(), InsecureRand32());
     264             :             }
     265      131072 :             if (((r >> 11) % 1024) == 11) {
     266           0 :                 test.clear();
     267             :             }
     268      131072 :             if (((r >> 21) % 512) == 12) {
     269         256 :                 test.assign(InsecureRand32() % 32, InsecureRand32());
     270             :             }
     271      131072 :             if (((r >> 15) % 8) == 3) {
     272        8000 :                 test.swap();
     273             :             }
     274      131072 :             if (((r >> 15) % 16) == 8) {
     275        4096 :                 test.copy();
     276             :             }
     277      131072 :             if (((r >> 15) % 32) == 18) {
     278        1856 :                 test.move();
     279             :             }
     280      131072 :             if (InsecureRandBits(5) == 19) {
     281        5120 :                 unsigned int num = 1 + (InsecureRandBits(4));
     282       10240 :                 std::vector<int> values(num);
     283       49600 :                 for (auto &v : values) {
     284       44480 :                     v = InsecureRand32();
     285             :                 }
     286       10240 :                 test.resize_uninitialized(values);
     287             :             }
     288             :         }
     289             :     }
     290           1 : }
     291             : 
     292             : BOOST_AUTO_TEST_SUITE_END()

Generated by: LCOV version 1.14