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