-
Notifications
You must be signed in to change notification settings - Fork 91
/
versionbits_tests.cpp
354 lines (326 loc) · 19.3 KB
/
versionbits_tests.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
// Copyright (c) 2014-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <chain.h>
#include <versionbits.h>
#include <test/test_veil.h>
#include <chainparams.h>
#include <validation.h>
#include <consensus/params.h>
#include <boost/test/unit_test.hpp>
/* Define a virtual block time, one block per 10 minutes after Nov 14 2014, 0:55:36am */
static int32_t TestTime(int nHeight) { return 1415926536 + 600 * nHeight; }
static const Consensus::Params paramsDummy = Consensus::Params();
class TestConditionChecker : public AbstractThresholdConditionChecker
{
private:
mutable ThresholdConditionCache cache;
public:
int64_t BeginTime(const Consensus::Params& params) const override { return TestTime(10000); }
int64_t EndTime(const Consensus::Params& params) const override { return TestTime(20000); }
int Period(const Consensus::Params& params) const override { return 1000; }
int Threshold(const Consensus::Params& params) const override { return 900; }
bool Condition(const CBlockIndex* pindex, const Consensus::Params& params) const override { return (pindex->nVersion & 0x100); }
ThresholdState GetStateFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateFor(pindexPrev, paramsDummy, cache); }
int GetStateSinceHeightFor(const CBlockIndex* pindexPrev) const { return AbstractThresholdConditionChecker::GetStateSinceHeightFor(pindexPrev, paramsDummy, cache); }
};
class TestAlwaysActiveConditionChecker : public TestConditionChecker
{
public:
int64_t BeginTime(const Consensus::Params& params) const override { return Consensus::BIP9Deployment::ALWAYS_ACTIVE; }
};
#define CHECKERS 6
class VersionBitsTester
{
// A fake blockchain
std::vector<CBlockIndex*> vpblock;
// 6 independent checkers for the same bit.
// The first one performs all checks, the second only 50%, the third only 25%, etc...
// This is to test whether lack of cached information leads to the same results.
TestConditionChecker checker[CHECKERS];
// Another 6 that assume always active activation
TestAlwaysActiveConditionChecker checker_always[CHECKERS];
// Test counter (to identify failures)
int num;
public:
VersionBitsTester() : num(0) {}
VersionBitsTester& Reset() {
for (unsigned int i = 0; i < vpblock.size(); i++) {
delete vpblock[i];
}
for (unsigned int i = 0; i < CHECKERS; i++) {
checker[i] = TestConditionChecker();
checker_always[i] = TestAlwaysActiveConditionChecker();
}
vpblock.clear();
return *this;
}
~VersionBitsTester() {
Reset();
}
VersionBitsTester& Mine(unsigned int height, int32_t nTime, int32_t nVersion) {
while (vpblock.size() < height) {
CBlockIndex* pindex = new CBlockIndex();
pindex->nHeight = vpblock.size();
pindex->pprev = vpblock.size() > 0 ? vpblock.back() : nullptr;
pindex->nTime = nTime;
pindex->nVersion = nVersion;
pindex->BuildSkip();
vpblock.push_back(pindex);
}
return *this;
}
VersionBitsTester& TestStateSinceHeight(int height) {
for (int i = 0; i < CHECKERS; i++) {
if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateSinceHeightFor(vpblock.empty() ? nullptr : vpblock.back()) == height, strprintf("Test %i for StateSinceHeight", num));
BOOST_CHECK_MESSAGE(checker_always[i].GetStateSinceHeightFor(vpblock.empty() ? nullptr : vpblock.back()) == 0, strprintf("Test %i for StateSinceHeight (always active)", num));
}
}
num++;
return *this;
}
VersionBitsTester& TestDefined() {
for (int i = 0; i < CHECKERS; i++) {
if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::DEFINED, strprintf("Test %i for DEFINED", num));
BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
}
}
num++;
return *this;
}
VersionBitsTester& TestStarted() {
for (int i = 0; i < CHECKERS; i++) {
if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::STARTED, strprintf("Test %i for STARTED", num));
BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
}
}
num++;
return *this;
}
VersionBitsTester& TestLockedIn() {
for (int i = 0; i < CHECKERS; i++) {
if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::LOCKED_IN, strprintf("Test %i for LOCKED_IN", num));
BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
}
}
num++;
return *this;
}
VersionBitsTester& TestActive() {
for (int i = 0; i < CHECKERS; i++) {
if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::ACTIVE, strprintf("Test %i for ACTIVE", num));
BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
}
}
num++;
return *this;
}
VersionBitsTester& TestFailed() {
for (int i = 0; i < CHECKERS; i++) {
if (InsecureRandBits(i) == 0) {
BOOST_CHECK_MESSAGE(checker[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::FAILED, strprintf("Test %i for FAILED", num));
BOOST_CHECK_MESSAGE(checker_always[i].GetStateFor(vpblock.empty() ? nullptr : vpblock.back()) == ThresholdState::ACTIVE, strprintf("Test %i for ACTIVE (always active)", num));
}
}
num++;
return *this;
}
CBlockIndex * Tip() { return vpblock.size() ? vpblock.back() : nullptr; }
};
BOOST_FIXTURE_TEST_SUITE(versionbits_tests, TestingSetup)
BOOST_AUTO_TEST_CASE(versionbits_test)
{
// for (int i = 0; i < 64; i++) {
// // DEFINED -> FAILED
// VersionBitsTester().TestDefined().TestStateSinceHeight(0)
// .Mine(1, TestTime(1), 0x100).TestDefined().TestStateSinceHeight(0)
// .Mine(11, TestTime(11), 0x100).TestDefined().TestStateSinceHeight(0)
// .Mine(989, TestTime(989), 0x100).TestDefined().TestStateSinceHeight(0)
// .Mine(999, TestTime(20000), 0x100).TestDefined().TestStateSinceHeight(0)
// .Mine(1000, TestTime(20000), 0x100).TestFailed().TestStateSinceHeight(1000)
// .Mine(1999, TestTime(30001), 0x100).TestFailed().TestStateSinceHeight(1000)
// .Mine(2000, TestTime(30002), 0x100).TestFailed().TestStateSinceHeight(1000)
// .Mine(2001, TestTime(30003), 0x100).TestFailed().TestStateSinceHeight(1000)
// .Mine(2999, TestTime(30004), 0x100).TestFailed().TestStateSinceHeight(1000)
// .Mine(3000, TestTime(30005), 0x100).TestFailed().TestStateSinceHeight(1000)
//
// // DEFINED -> STARTED -> FAILED
// .Reset().TestDefined().TestStateSinceHeight(0)
// .Mine(1, TestTime(1), 0).TestDefined().TestStateSinceHeight(0)
// .Mine(1000, TestTime(10000) - 1, 0x100).TestDefined().TestStateSinceHeight(0) // One second more and it would be defined
// .Mine(2000, TestTime(10000), 0x100).TestStarted().TestStateSinceHeight(2000) // So that's what happens the next period
// .Mine(2051, TestTime(10010), 0).TestStarted().TestStateSinceHeight(2000) // 51 old blocks
// .Mine(2950, TestTime(10020), 0x100).TestStarted().TestStateSinceHeight(2000) // 899 new blocks
// .Mine(3000, TestTime(20000), 0).TestFailed().TestStateSinceHeight(3000) // 50 old blocks (so 899 out of the past 1000)
// .Mine(4000, TestTime(20010), 0x100).TestFailed().TestStateSinceHeight(3000)
//
// // DEFINED -> STARTED -> FAILED while threshold reached
// .Reset().TestDefined().TestStateSinceHeight(0)
// .Mine(1, TestTime(1), 0).TestDefined().TestStateSinceHeight(0)
// .Mine(1000, TestTime(10000) - 1, 0x101).TestDefined().TestStateSinceHeight(0) // One second more and it would be defined
// .Mine(2000, TestTime(10000), 0x101).TestStarted().TestStateSinceHeight(2000) // So that's what happens the next period
// .Mine(2999, TestTime(30000), 0x100).TestStarted().TestStateSinceHeight(2000) // 999 new blocks
// .Mine(3000, TestTime(30000), 0x100).TestFailed().TestStateSinceHeight(3000) // 1 new block (so 1000 out of the past 1000 are new)
// .Mine(3999, TestTime(30001), 0).TestFailed().TestStateSinceHeight(3000)
// .Mine(4000, TestTime(30002), 0).TestFailed().TestStateSinceHeight(3000)
// .Mine(14333, TestTime(30003), 0).TestFailed().TestStateSinceHeight(3000)
// .Mine(24000, TestTime(40000), 0).TestFailed().TestStateSinceHeight(3000)
//
// // DEFINED -> STARTED -> LOCKEDIN at the last minute -> ACTIVE
// .Reset().TestDefined()
// .Mine(1, TestTime(1), 0).TestDefined().TestStateSinceHeight(0)
// .Mine(1000, TestTime(10000) - 1, 0x101).TestDefined().TestStateSinceHeight(0) // One second more and it would be defined
// .Mine(2000, TestTime(10000), 0x101).TestStarted().TestStateSinceHeight(2000) // So that's what happens the next period
// .Mine(2050, TestTime(10010), 0x200).TestStarted().TestStateSinceHeight(2000) // 50 old blocks
// .Mine(2950, TestTime(10020), 0x100).TestStarted().TestStateSinceHeight(2000) // 900 new blocks
// .Mine(2999, TestTime(19999), 0x200).TestStarted().TestStateSinceHeight(2000) // 49 old blocks
// .Mine(3000, TestTime(29999), 0x200).TestLockedIn().TestStateSinceHeight(3000) // 1 old block (so 900 out of the past 1000)
// .Mine(3999, TestTime(30001), 0).TestLockedIn().TestStateSinceHeight(3000)
// .Mine(4000, TestTime(30002), 0).TestActive().TestStateSinceHeight(4000)
// .Mine(14333, TestTime(30003), 0).TestActive().TestStateSinceHeight(4000)
// .Mine(24000, TestTime(40000), 0).TestActive().TestStateSinceHeight(4000)
//
// // DEFINED multiple periods -> STARTED multiple periods -> FAILED
// .Reset().TestDefined().TestStateSinceHeight(0)
// .Mine(999, TestTime(999), 0).TestDefined().TestStateSinceHeight(0)
// .Mine(1000, TestTime(1000), 0).TestDefined().TestStateSinceHeight(0)
// .Mine(2000, TestTime(2000), 0).TestDefined().TestStateSinceHeight(0)
// .Mine(3000, TestTime(10000), 0).TestStarted().TestStateSinceHeight(3000)
// .Mine(4000, TestTime(10000), 0).TestStarted().TestStateSinceHeight(3000)
// .Mine(5000, TestTime(10000), 0).TestStarted().TestStateSinceHeight(3000)
// .Mine(6000, TestTime(20000), 0).TestFailed().TestStateSinceHeight(6000)
// .Mine(7000, TestTime(20000), 0x100).TestFailed().TestStateSinceHeight(6000);
// }
//
// // Sanity checks of version bit deployments
// const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
// const Consensus::Params &mainnetParams = chainParams->GetConsensus();
// for (int i=0; i<(int) Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
// uint32_t bitmask = VersionBitsMask(mainnetParams, static_cast<Consensus::DeploymentPos>(i));
// // Make sure that no deployment tries to set an invalid bit.
// BOOST_CHECK_EQUAL(bitmask & ~(uint32_t)VERSIONBITS_TOP_MASK, bitmask);
//
// // Verify that the deployment windows of different deployment using the
// // same bit are disjoint.
// // This test may need modification at such time as a new deployment
// // is proposed that reuses the bit of an activated soft fork, before the
// // end time of that soft fork. (Alternatively, the end time of that
// // activated soft fork could be later changed to be earlier to avoid
// // overlap.)
// for (int j=i+1; j<(int) Consensus::MAX_VERSION_BITS_DEPLOYMENTS; j++) {
// if (VersionBitsMask(mainnetParams, static_cast<Consensus::DeploymentPos>(j)) == bitmask) {
// BOOST_CHECK(mainnetParams.vDeployments[j].nStartTime > mainnetParams.vDeployments[i].nTimeout ||
// mainnetParams.vDeployments[i].nStartTime > mainnetParams.vDeployments[j].nTimeout);
// }
// }
// }
}
BOOST_AUTO_TEST_CASE(versionbits_computeblockversion)
{
// // Check that ComputeBlockVersion will set the appropriate bit correctly
// // on mainnet.
// const auto chainParams = CreateChainParams(CBaseChainParams::MAIN);
// const Consensus::Params &mainnetParams = chainParams->GetConsensus();
//
// // Use the TESTDUMMY deployment for testing purposes.
// int64_t bit = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit;
// int64_t nStartTime = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime;
// int64_t nTimeout = mainnetParams.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout;
//
// assert(nStartTime < nTimeout);
//
// // In the first chain, test that the bit is set by CBV until it has failed.
// // In the second chain, test the bit is set by CBV while STARTED and
// // LOCKED-IN, and then no longer set while ACTIVE.
// VersionBitsTester firstChain, secondChain;
//
// // Start generating blocks before nStartTime
// int64_t nTime = nStartTime - 1;
//
// // Before MedianTimePast of the chain has crossed nStartTime, the bit
// // should not be set.
// CBlockIndex *lastBlock = nullptr;
// lastBlock = firstChain.Mine(2016, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
//
// // Mine 2011 more blocks at the old time, and check that CBV isn't setting the bit yet.
// for (int i=1; i<2012; i++) {
// lastBlock = firstChain.Mine(2016+i, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// // This works because VERSIONBITS_LAST_OLD_BLOCK_VERSION happens
// // to be 4, and the bit we're testing happens to be bit 28.
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
// }
// // Now mine 5 more blocks at the start time -- MTP should not have passed yet, so
// // CBV should still not yet set the bit.
// nTime = nStartTime;
// for (int i=2012; i<=2016; i++) {
// lastBlock = firstChain.Mine(2016+i, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
// }
//
// // Advance to the next period and transition to STARTED,
// lastBlock = firstChain.Mine(6048, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// // so ComputeBlockVersion should now set the bit,
// BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
// // and should also be using the VERSIONBITS_TOP_BITS.
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
//
// // Check that ComputeBlockVersion will set the bit until nTimeout
// nTime += 600;
// int blocksToMine = 4032; // test blocks for up to 2 time periods
// int nHeight = 6048;
// // These blocks are all before nTimeout is reached.
// while (nTime < nTimeout && blocksToMine > 0) {
// lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
// blocksToMine--;
// nTime += 600;
// nHeight += 1;
// }
//
// nTime = nTimeout;
// // FAILED is only triggered at the end of a period, so CBV should be setting
// // the bit until the period transition.
// for (int i=0; i<2015; i++) {
// lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
// nHeight += 1;
// }
// // The next block should trigger no longer setting the bit.
// lastBlock = firstChain.Mine(nHeight+1, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
//
// // On a new chain:
// // verify that the bit will be set after lock-in, and then stop being set
// // after activation.
// nTime = nStartTime;
//
// // Mine one period worth of blocks, and check that the bit will be on for the
// // next period.
// lastBlock = secondChain.Mine(2016, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
//
// // Mine another period worth of blocks, signaling the new bit.
// lastBlock = secondChain.Mine(4032, nTime, VERSIONBITS_TOP_BITS | (1<<bit)).Tip();
// // After one period of setting the bit on each block, it should have locked in.
// // We keep setting the bit for one more period though, until activation.
// BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
//
// // Now check that we keep mining the block until the end of this period, and
// // then stop at the beginning of the next period.
// lastBlock = secondChain.Mine(6047, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK((ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit)) != 0);
// lastBlock = secondChain.Mine(6048, nTime, VERSIONBITS_LAST_OLD_BLOCK_VERSION).Tip();
// BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & (1<<bit), 0);
//
// // Finally, verify that after a soft fork has activated, CBV no longer uses
// // VERSIONBITS_LAST_OLD_BLOCK_VERSION.
// //BOOST_CHECK_EQUAL(ComputeBlockVersion(lastBlock, mainnetParams) & VERSIONBITS_TOP_MASK, VERSIONBITS_TOP_BITS);
}
BOOST_AUTO_TEST_SUITE_END()