highperfocused/bitcoin
1
0
Fork 0
mirror of https://github.com/bitcoin/bitcoin.git synced 2025-06-20 22:04:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

test: Fix whitespace in prevector_tests.cpp

Browse Source 
Bitcoin Core uses 4 spaces indent, but the test was in some lines using
5 or more.

Just clang-format the whole file.
This commit is contained in:
MarcoFalke 2025-05-14 10:00:40 +02:00
parent fa7f04c8a7
commit faf9082a5f
No known key found for this signature in database
1 changed files with 57 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
src/test/prevector_tests.cpp
View File

@ -1,4 +1,4 @@
// Copyright (c) 2015-2022 The Bitcoin Core developers // Copyright (c) 2015-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying // Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@ -15,8 +15,9 @@
BOOST_FIXTURE_TEST_SUITE(prevector_tests, TestingSetup) BOOST_FIXTURE_TEST_SUITE(prevector_tests, TestingSetup)
template<unsigned int N, typename T> template <unsigned int N, typename T>
class prevector_tester { class prevector_tester
{
typedef std::vector<T> realtype; typedef std::vector<T> realtype;
realtype real_vector; realtype real_vector;
realtype real_vector_alt; realtype real_vector_alt;
@ -31,36 +32,37 @@ class prevector_tester {
template <typename A, typename B> template <typename A, typename B>
void local_check_equal(A a, B b) void local_check_equal(A a, B b)
{ {
local_check(a == b); local_check(a == b);
} }
void local_check(bool b) void local_check(bool b)
{ {
passed &= b; passed &= b;
} }
void test() { void test()
{
const pretype& const_pre_vector = pre_vector; const pretype& const_pre_vector = pre_vector;
local_check_equal(real_vector.size(), pre_vector.size()); local_check_equal(real_vector.size(), pre_vector.size());
local_check_equal(real_vector.empty(), pre_vector.empty()); local_check_equal(real_vector.empty(), pre_vector.empty());
for (Size s = 0; s < real_vector.size(); s++) { for (Size s = 0; s < real_vector.size(); s++) {
local_check(real_vector[s] == pre_vector[s]); local_check(real_vector[s] == pre_vector[s]);
local_check(&(pre_vector[s]) == &(pre_vector.begin()[s])); local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s)); local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
local_check(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size())); local_check(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
} }
// local_check(realtype(pre_vector) == real_vector); // local_check(realtype(pre_vector) == real_vector);
local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector); local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector); local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
size_t pos = 0; size_t pos = 0;
for (const T& v : pre_vector) { for (const T& v : pre_vector) {
local_check(v == real_vector[pos++]); local_check(v == real_vector[pos++]);
} }
for (const T& v : pre_vector | std::views::reverse) { for (const T& v : pre_vector | std::views::reverse) {
local_check(v == real_vector[--pos]); local_check(v == real_vector[--pos]);
} }
for (const T& v : const_pre_vector) { for (const T& v : const_pre_vector) {
local_check(v == real_vector[pos++]); local_check(v == real_vector[pos++]);
} }
for (const T& v : const_pre_vector | std::views::reverse) { for (const T& v : const_pre_vector | std::views::reverse) {
local_check(v == real_vector[--pos]); local_check(v == real_vector[--pos]);
@ -76,7 +78,8 @@ class prevector_tester {
} }
public: public:
void resize(Size s) { void resize(Size s)
{
real_vector.resize(s); real_vector.resize(s);
local_check_equal(real_vector.size(), s); local_check_equal(real_vector.size(), s);
pre_vector.resize(s); pre_vector.resize(s);
@ -84,7 +87,8 @@ public:
test(); test();
} }
void reserve(Size s) { void reserve(Size s)
{
real_vector.reserve(s); real_vector.reserve(s);
local_check(real_vector.capacity() >= s); local_check(real_vector.capacity() >= s);
pre_vector.reserve(s); pre_vector.reserve(s);
@ -92,74 +96,87 @@ public:
test(); test();
} }
void insert(Size position, const T& value) { void insert(Size position, const T& value)
{
real_vector.insert(real_vector.begin() + position, value); real_vector.insert(real_vector.begin() + position, value);
pre_vector.insert(pre_vector.begin() + position, value); pre_vector.insert(pre_vector.begin() + position, value);
test(); test();
} }
void insert(Size position, Size count, const T& value) { void insert(Size position, Size count, const T& value)
{
real_vector.insert(real_vector.begin() + position, count, value); real_vector.insert(real_vector.begin() + position, count, value);
pre_vector.insert(pre_vector.begin() + position, count, value); pre_vector.insert(pre_vector.begin() + position, count, value);
test(); test();
} }
template<typename I> template <typename I>
void insert_range(Size position, I first, I last) { void insert_range(Size position, I first, I last)
{
real_vector.insert(real_vector.begin() + position, first, last); real_vector.insert(real_vector.begin() + position, first, last);
pre_vector.insert(pre_vector.begin() + position, first, last); pre_vector.insert(pre_vector.begin() + position, first, last);
test(); test();
} }
void erase(Size position) { void erase(Size position)
{
real_vector.erase(real_vector.begin() + position); real_vector.erase(real_vector.begin() + position);
pre_vector.erase(pre_vector.begin() + position); pre_vector.erase(pre_vector.begin() + position);
test(); test();
} }
void erase(Size first, Size last) { void erase(Size first, Size last)
{
real_vector.erase(real_vector.begin() + first, real_vector.begin() + last); real_vector.erase(real_vector.begin() + first, real_vector.begin() + last);
pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last); pre_vector.erase(pre_vector.begin() + first, pre_vector.begin() + last);
test(); test();
} }
void update(Size pos, const T& value) { void update(Size pos, const T& value)
{
real_vector[pos] = value; real_vector[pos] = value;
pre_vector[pos] = value; pre_vector[pos] = value;
test(); test();
} }
void push_back(const T& value) { void push_back(const T& value)
{
real_vector.push_back(value); real_vector.push_back(value);
pre_vector.push_back(value); pre_vector.push_back(value);
test(); test();
} }
void pop_back() { void pop_back()
{
real_vector.pop_back(); real_vector.pop_back();
pre_vector.pop_back(); pre_vector.pop_back();
test(); test();
} }
void clear() { void clear()
{
real_vector.clear(); real_vector.clear();
pre_vector.clear(); pre_vector.clear();
} }
void assign(Size n, const T& value) { void assign(Size n, const T& value)
{
real_vector.assign(n, value); real_vector.assign(n, value);
pre_vector.assign(n, value); pre_vector.assign(n, value);
} }
Size size() const { Size size() const
{
return real_vector.size(); return real_vector.size();
} }
Size capacity() const { Size capacity() const
{
return pre_vector.capacity(); return pre_vector.capacity();
} }
void shrink_to_fit() { void shrink_to_fit()
{
pre_vector.shrink_to_fit(); pre_vector.shrink_to_fit();
test(); test();
} }
@ -171,19 +188,22 @@ public:
test(); test();
} }
void move() { void move()
{
real_vector = std::move(real_vector_alt); real_vector = std::move(real_vector_alt);
real_vector_alt.clear(); real_vector_alt.clear();
pre_vector = std::move(pre_vector_alt); pre_vector = std::move(pre_vector_alt);
pre_vector_alt.clear(); pre_vector_alt.clear();
} }
void copy() { void copy()
{
real_vector = real_vector_alt; real_vector = real_vector_alt;
pre_vector = pre_vector_alt; pre_vector = pre_vector_alt;
} }
void resize_uninitialized(realtype values) { void resize_uninitialized(realtype values)
{
size_t r = values.size(); size_t r = values.size();
size_t s = real_vector.size() / 2; size_t s = real_vector.size() / 2;
if (real_vector.capacity() < s + r) { if (real_vector.capacity() < s + r) {
@ -203,11 +223,13 @@ public:
test(); test();
} }
~prevector_tester() { ~prevector_tester()
{
BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString()); BOOST_CHECK_MESSAGE(passed, "insecure_rand: " + rand_seed.ToString());
} }
prevector_tester(FastRandomContext& rng) { prevector_tester(FastRandomContext& rng)
{
rand_seed = rng.rand256(); rand_seed = rng.rand256();
rng.Reseed(rand_seed); rng.Reseed(rand_seed);
} }