src/test/test_bitcoin.cpp

   1 // Copyright (c) 2011-2016 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_bitcoin.h"
   6
   7 #include "chainparams.h"
   8 #include "consensus/consensus.h"
   9 #include "consensus/validation.h"
  10 #include "fs.h"
  11 #include "key.h"
  12 #include "validation.h"
  13 #include "miner.h"
  14 #include "net_processing.h"
  15 #include "pubkey.h"
  16 #include "random.h"
  17 #include "txdb.h"
  18 #include "txmempool.h"
  19 #include "ui_interface.h"
  20 #include "rpc/server.h"
  21 #include "rpc/register.h"
  22 #include "script/sigcache.h"
  23
  24 #include "test/testutil.h"
  25
  26 #include <memory>
  27
  28 #include <boost/thread.hpp>
  29
  30 uint256 insecure_rand_seed = GetRandHash();
  31 FastRandomContext insecure_rand_ctx(insecure_rand_seed);
  32
  33 extern bool fPrintToConsole;
  34 extern void noui_connect();
  35
  36 BasicTestingSetup::BasicTestingSetup(const std::string& chainName)
  37 {
  38         RandomInit();
  39         ECC_Start();
  40         SetupEnvironment();
  41         SetupNetworking();
  42         InitSignatureCache();
  43         fPrintToDebugLog = false; // don't want to write to debug.log file
  44         fCheckBlockIndex = true;
  45         SelectParams(chainName);
  46         noui_connect();
  47 }
  48
  49 BasicTestingSetup::~BasicTestingSetup()
  50 {
  51         ECC_Stop();
  52         g_connman.reset();
  53 }
  54
  55 TestingSetup::TestingSetup(const std::string& chainName) : BasicTestingSetup(chainName)
  56 {
  57     const CChainParams& chainparams = Params();
  58         // Ideally we'd move all the RPC tests to the functional testing framework
  59         // instead of unit tests, but for now we need these here.
  60
  61         RegisterAllCoreRPCCommands(tableRPC);
  62         ClearDatadirCache();
  63         pathTemp = GetTempPath() / strprintf("test_bitcoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
  64         fs::create_directories(pathTemp);
  65         ForceSetArg("-datadir", pathTemp.string());
  66         mempool.setSanityCheck(1.0);
  67         pblocktree = new CBlockTreeDB(1 << 20, true);
  68         pcoinsdbview = new CCoinsViewDB(1 << 23, true);
  69         pcoinsTip = new CCoinsViewCache(pcoinsdbview);
  70         if (!InitBlockIndex(chainparams)) {
  71             throw std::runtime_error("InitBlockIndex failed.");
  72         }
  73         {
  74             CValidationState state;
  75             if (!ActivateBestChain(state, chainparams)) {
  76                 throw std::runtime_error("ActivateBestChain failed.");
  77             }
  78         }
  79         nScriptCheckThreads = 3;
  80         for (int i=0; i < nScriptCheckThreads-1; i++)
  81             threadGroup.create_thread(&ThreadScriptCheck);
  82         g_connman = std::unique_ptr<CConnman>(new CConnman(0x1337, 0x1337)); // Deterministic randomness for tests.
  83         connman = g_connman.get();
  84         RegisterNodeSignals(GetNodeSignals());
  85 }
  86
  87 TestingSetup::~TestingSetup()
  88 {
  89         UnregisterNodeSignals(GetNodeSignals());
  90         threadGroup.interrupt_all();
  91         threadGroup.join_all();
  92         UnloadBlockIndex();
  93         delete pcoinsTip;
  94         delete pcoinsdbview;
  95         delete pblocktree;
  96         fs::remove_all(pathTemp);
  97 }
  98
  99 TestChain100Setup::TestChain100Setup() : TestingSetup(CBaseChainParams::REGTEST)
 100 {
 101     // Generate a 100-block chain:
 102     coinbaseKey.MakeNewKey(true);
 103     CScript scriptPubKey = CScript() <<  ToByteVector(coinbaseKey.GetPubKey()) << OP_CHECKSIG;
 104     for (int i = 0; i < COINBASE_MATURITY; i++)
 105     {
 106         std::vector<CMutableTransaction> noTxns;
 107         CBlock b = CreateAndProcessBlock(noTxns, scriptPubKey);
 108         coinbaseTxns.push_back(*b.vtx[0]);
 109     }
 110 }
 111
 112 //
 113 // Create a new block with just given transactions, coinbase paying to
 114 // scriptPubKey, and try to add it to the current chain.
 115 //
 116 CBlock
 117 TestChain100Setup::CreateAndProcessBlock(const std::vector<CMutableTransaction>& txns, const CScript& scriptPubKey)
 118 {
 119     const CChainParams& chainparams = Params();
 120     std::unique_ptr<CBlockTemplate> pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
 121     CBlock& block = pblocktemplate->block;
 122
 123     // Replace mempool-selected txns with just coinbase plus passed-in txns:
 124     block.vtx.resize(1);
 125     BOOST_FOREACH(const CMutableTransaction& tx, txns)
 126         block.vtx.push_back(MakeTransactionRef(tx));
 127     // IncrementExtraNonce creates a valid coinbase and merkleRoot
 128     unsigned int extraNonce = 0;
 129     IncrementExtraNonce(&block, chainActive.Tip(), extraNonce);
 130
 131     while (!CheckProofOfWork(block.GetHash(), block.nBits, chainparams.GetConsensus())) ++block.nNonce;
 132
 133     std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(block);
 134     ProcessNewBlock(chainparams, shared_pblock, true, NULL);
 135
 136     CBlock result = block;
 137     return result;
 138 }
 139
 140 TestChain100Setup::~TestChain100Setup()
 141 {
 142 }
 143
 144
 145 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CMutableTransaction &tx) {
 146     CTransaction txn(tx);
 147     return FromTx(txn);
 148 }
 149
 150 CTxMemPoolEntry TestMemPoolEntryHelper::FromTx(const CTransaction &txn) {
 151     return CTxMemPoolEntry(MakeTransactionRef(txn), nFee, nTime, nHeight,
 152                            spendsCoinbase, sigOpCost, lp);
 153 }