Refactoring: Removed using namespace <xxx> from bench/ and test/ source files.
This commit is contained in:
Karl-Johan Alm
Kalle Alm
parent
53442af0aa
commit
73f41190b9
22 changed files with 244 additions and 289 deletions
|
|
@ -9,9 +9,7 @@
|
|||
#include <iomanip>
|
||||
#include <sys/time.h>
|
||||
|
||||
using namespace benchmark;
|
||||
|
||||
std::map<std::string, BenchFunction> BenchRunner::benchmarks;
|
||||
std::map<std::string, benchmark::BenchFunction> benchmark::BenchRunner::benchmarks;
|
||||
|
||||
static double gettimedouble(void) {
|
||||
struct timeval tv;
|
||||
|
|
@ -19,29 +17,29 @@ static double gettimedouble(void) {
|
|||
return tv.tv_usec * 0.000001 + tv.tv_sec;
|
||||
}
|
||||
|
||||
BenchRunner::BenchRunner(std::string name, BenchFunction func)
|
||||
benchmark::BenchRunner::BenchRunner(std::string name, benchmark::BenchFunction func)
|
||||
{
|
||||
benchmarks.insert(std::make_pair(name, func));
|
||||
}
|
||||
|
||||
void
|
||||
BenchRunner::RunAll(double elapsedTimeForOne)
|
||||
benchmark::BenchRunner::RunAll(double elapsedTimeForOne)
|
||||
{
|
||||
perf_init();
|
||||
std::cout << "#Benchmark" << "," << "count" << "," << "min" << "," << "max" << "," << "average" << ","
|
||||
<< "min_cycles" << "," << "max_cycles" << "," << "average_cycles" << "\n";
|
||||
|
||||
for (std::map<std::string,BenchFunction>::iterator it = benchmarks.begin();
|
||||
for (std::map<std::string,benchmark::BenchFunction>::iterator it = benchmarks.begin();
|
||||
it != benchmarks.end(); ++it) {
|
||||
|
||||
State state(it->first, elapsedTimeForOne);
|
||||
BenchFunction& func = it->second;
|
||||
benchmark::BenchFunction& func = it->second;
|
||||
func(state);
|
||||
}
|
||||
perf_fini();
|
||||
}
|
||||
|
||||
bool State::KeepRunning()
|
||||
bool benchmark::State::KeepRunning()
|
||||
{
|
||||
if (count & countMask) {
|
||||
++count;
|
||||
|
|
|
|||
|
|
@ -8,9 +8,7 @@
|
|||
#include <boost/foreach.hpp>
|
||||
#include <set>
|
||||
|
||||
using namespace std;
|
||||
|
||||
static void addCoin(const CAmount& nValue, const CWallet& wallet, vector<COutput>& vCoins)
|
||||
static void addCoin(const CAmount& nValue, const CWallet& wallet, std::vector<COutput>& vCoins)
|
||||
{
|
||||
int nInput = 0;
|
||||
|
||||
|
|
@ -36,7 +34,7 @@ static void addCoin(const CAmount& nValue, const CWallet& wallet, vector<COutput
|
|||
static void CoinSelection(benchmark::State& state)
|
||||
{
|
||||
const CWallet wallet;
|
||||
vector<COutput> vCoins;
|
||||
std::vector<COutput> vCoins;
|
||||
LOCK(wallet.cs_wallet);
|
||||
|
||||
while (state.KeepRunning()) {
|
||||
|
|
@ -50,7 +48,7 @@ static void CoinSelection(benchmark::State& state)
|
|||
addCoin(1000 * COIN, wallet, vCoins);
|
||||
addCoin(3 * COIN, wallet, vCoins);
|
||||
|
||||
set<pair<const CWalletTx*, unsigned int> > setCoinsRet;
|
||||
std::set<std::pair<const CWalletTx*, unsigned int> > setCoinsRet;
|
||||
CAmount nValueRet;
|
||||
bool success = wallet.SelectCoinsMinConf(1003 * COIN, 1, 6, 0, vCoins, setCoinsRet, nValueRet);
|
||||
assert(success);
|
||||
|
|
|
|||
|
|
@ -10,8 +10,6 @@
|
|||
#include "netbase.h"
|
||||
#include "random.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
class CAddrManTest : public CAddrMan
|
||||
{
|
||||
uint64_t state;
|
||||
|
|
@ -365,7 +363,7 @@ BOOST_AUTO_TEST_CASE(addrman_getaddr)
|
|||
// Test 22: Sanity check, GetAddr should never return anything if addrman
|
||||
// is empty.
|
||||
BOOST_CHECK(addrman.size() == 0);
|
||||
vector<CAddress> vAddr1 = addrman.GetAddr();
|
||||
std::vector<CAddress> vAddr1 = addrman.GetAddr();
|
||||
BOOST_CHECK(vAddr1.size() == 0);
|
||||
|
||||
CAddress addr1 = CAddress(ResolveService("250.250.2.1", 8333), NODE_NONE);
|
||||
|
|
@ -401,7 +399,7 @@ BOOST_AUTO_TEST_CASE(addrman_getaddr)
|
|||
int octet1 = i % 256;
|
||||
int octet2 = (i / 256) % 256;
|
||||
int octet3 = (i / (256 * 2)) % 256;
|
||||
string strAddr = boost::to_string(octet1) + "." + boost::to_string(octet2) + "." + boost::to_string(octet3) + ".23";
|
||||
std::string strAddr = boost::to_string(octet1) + "." + boost::to_string(octet2) + "." + boost::to_string(octet3) + ".23";
|
||||
CAddress addr = CAddress(ResolveService(strAddr), NODE_NONE);
|
||||
|
||||
// Ensure that for all addrs in addrman, isTerrible == false.
|
||||
|
|
@ -410,7 +408,7 @@ BOOST_AUTO_TEST_CASE(addrman_getaddr)
|
|||
if (i % 8 == 0)
|
||||
addrman.Good(addr);
|
||||
}
|
||||
vector<CAddress> vAddr = addrman.GetAddr();
|
||||
std::vector<CAddress> vAddr = addrman.GetAddr();
|
||||
|
||||
size_t percent23 = (addrman.size() * 23) / 100;
|
||||
BOOST_CHECK(vAddr.size() == percent23);
|
||||
|
|
@ -452,7 +450,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_tried_bucket)
|
|||
BOOST_CHECK(info1.GetKey() != info2.GetKey());
|
||||
BOOST_CHECK(info1.GetTriedBucket(nKey1) != info2.GetTriedBucket(nKey1));
|
||||
|
||||
set<int> buckets;
|
||||
std::set<int> buckets;
|
||||
for (int i = 0; i < 255; i++) {
|
||||
CAddrInfo infoi = CAddrInfo(
|
||||
CAddress(ResolveService("250.1.1." + boost::to_string(i)), NODE_NONE),
|
||||
|
|
@ -505,7 +503,7 @@ BOOST_AUTO_TEST_CASE(caddrinfo_get_new_bucket)
|
|||
BOOST_CHECK(info1.GetKey() != info2.GetKey());
|
||||
BOOST_CHECK(info1.GetNewBucket(nKey1) == info2.GetNewBucket(nKey1));
|
||||
|
||||
set<int> buckets;
|
||||
std::set<int> buckets;
|
||||
for (int i = 0; i < 255; i++) {
|
||||
CAddrInfo infoi = CAddrInfo(
|
||||
CAddress(ResolveService("250.1.1." + boost::to_string(i)), NODE_NONE),
|
||||
|
|
|
|||
|
|
@ -21,8 +21,6 @@
|
|||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/tuple/tuple.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(bloom_tests, BasicTestingSetup)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
|
||||
|
|
@ -43,8 +41,8 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize)
|
|||
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
|
||||
stream << filter;
|
||||
|
||||
vector<unsigned char> vch = ParseHex("03614e9b050000000000000001");
|
||||
vector<char> expected(vch.size());
|
||||
std::vector<unsigned char> vch = ParseHex("03614e9b050000000000000001");
|
||||
std::vector<char> expected(vch.size());
|
||||
|
||||
for (unsigned int i = 0; i < vch.size(); i++)
|
||||
expected[i] = (char)vch[i];
|
||||
|
|
@ -75,8 +73,8 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
|
|||
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
|
||||
stream << filter;
|
||||
|
||||
vector<unsigned char> vch = ParseHex("03ce4299050000000100008001");
|
||||
vector<char> expected(vch.size());
|
||||
std::vector<unsigned char> vch = ParseHex("03ce4299050000000100008001");
|
||||
std::vector<char> expected(vch.size());
|
||||
|
||||
for (unsigned int i = 0; i < vch.size(); i++)
|
||||
expected[i] = (char)vch[i];
|
||||
|
|
@ -86,24 +84,24 @@ BOOST_AUTO_TEST_CASE(bloom_create_insert_serialize_with_tweak)
|
|||
|
||||
BOOST_AUTO_TEST_CASE(bloom_create_insert_key)
|
||||
{
|
||||
string strSecret = string("5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C");
|
||||
std::string strSecret = std::string("5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C");
|
||||
CBitcoinSecret vchSecret;
|
||||
BOOST_CHECK(vchSecret.SetString(strSecret));
|
||||
|
||||
CKey key = vchSecret.GetKey();
|
||||
CPubKey pubkey = key.GetPubKey();
|
||||
vector<unsigned char> vchPubKey(pubkey.begin(), pubkey.end());
|
||||
std::vector<unsigned char> vchPubKey(pubkey.begin(), pubkey.end());
|
||||
|
||||
CBloomFilter filter(2, 0.001, 0, BLOOM_UPDATE_ALL);
|
||||
filter.insert(vchPubKey);
|
||||
uint160 hash = pubkey.GetID();
|
||||
filter.insert(vector<unsigned char>(hash.begin(), hash.end()));
|
||||
filter.insert(std::vector<unsigned char>(hash.begin(), hash.end()));
|
||||
|
||||
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
|
||||
stream << filter;
|
||||
|
||||
vector<unsigned char> vch = ParseHex("038fc16b080000000000000001");
|
||||
vector<char> expected(vch.size());
|
||||
std::vector<unsigned char> vch = ParseHex("038fc16b080000000000000001");
|
||||
std::vector<char> expected(vch.size());
|
||||
|
||||
for (unsigned int i = 0; i < vch.size(); i++)
|
||||
expected[i] = (char)vch[i];
|
||||
|
|
@ -119,7 +117,7 @@ BOOST_AUTO_TEST_CASE(bloom_match)
|
|||
|
||||
// and one which spends it (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
|
||||
unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||||
vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
|
||||
std::vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
|
||||
CDataStream spendStream(vch, SER_DISK, CLIENT_VERSION);
|
||||
CTransaction spendingTx(deserialize, spendStream);
|
||||
|
||||
|
|
@ -156,7 +154,7 @@ BOOST_AUTO_TEST_CASE(bloom_match)
|
|||
filter = CBloomFilter(10, 0.000001, 0, BLOOM_UPDATE_ALL);
|
||||
COutPoint prevOutPoint(uint256S("0x90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"), 0);
|
||||
{
|
||||
vector<unsigned char> data(32 + sizeof(unsigned int));
|
||||
std::vector<unsigned char> data(32 + sizeof(unsigned int));
|
||||
memcpy(&data[0], prevOutPoint.hash.begin(), 32);
|
||||
memcpy(&data[32], &prevOutPoint.n, sizeof(unsigned int));
|
||||
filter.insert(data);
|
||||
|
|
@ -196,13 +194,13 @@ BOOST_AUTO_TEST_CASE(merkle_block_1)
|
|||
BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
|
||||
pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x74d681e0e03bafa802c8aa084379aa98d9fcd632ddc2ed9782b586ec87451f20"));
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 8);
|
||||
|
||||
vector<uint256> vMatched;
|
||||
vector<unsigned int> vIndex;
|
||||
std::vector<uint256> vMatched;
|
||||
std::vector<unsigned int> vIndex;
|
||||
BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
|
||||
BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
|
||||
for (unsigned int i = 0; i < vMatched.size(); i++)
|
||||
|
|
@ -242,13 +240,13 @@ BOOST_AUTO_TEST_CASE(merkle_block_2)
|
|||
BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
|
||||
pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
|
||||
|
||||
vector<uint256> vMatched;
|
||||
vector<unsigned int> vIndex;
|
||||
std::vector<uint256> vMatched;
|
||||
std::vector<unsigned int> vIndex;
|
||||
BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
|
||||
BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
|
||||
for (unsigned int i = 0; i < vMatched.size(); i++)
|
||||
|
|
@ -297,13 +295,13 @@ BOOST_AUTO_TEST_CASE(merkle_block_2_with_update_none)
|
|||
BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
|
||||
pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0xe980fe9f792d014e73b95203dc1335c5f9ce19ac537a419e6df5b47aecb93b70"));
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
|
||||
|
||||
vector<uint256> vMatched;
|
||||
vector<unsigned int> vIndex;
|
||||
std::vector<uint256> vMatched;
|
||||
std::vector<unsigned int> vIndex;
|
||||
BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
|
||||
BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
|
||||
for (unsigned int i = 0; i < vMatched.size(); i++)
|
||||
|
|
@ -353,8 +351,8 @@ BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize)
|
|||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x63194f18be0af63f2c6bc9dc0f777cbefed3d9415c4af83f3ee3a3d669c00cb5"));
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 0);
|
||||
|
||||
vector<uint256> vMatched;
|
||||
vector<unsigned int> vIndex;
|
||||
std::vector<uint256> vMatched;
|
||||
std::vector<unsigned int> vIndex;
|
||||
BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
|
||||
BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
|
||||
for (unsigned int i = 0; i < vMatched.size(); i++)
|
||||
|
|
@ -363,8 +361,8 @@ BOOST_AUTO_TEST_CASE(merkle_block_3_and_serialize)
|
|||
CDataStream merkleStream(SER_NETWORK, PROTOCOL_VERSION);
|
||||
merkleStream << merkleBlock;
|
||||
|
||||
vector<unsigned char> vch = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");
|
||||
vector<char> expected(vch.size());
|
||||
std::vector<unsigned char> vch = ParseHex("0100000079cda856b143d9db2c1caff01d1aecc8630d30625d10e8b4b8b0000000000000b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f196367291b4d4c86041b8fa45d630100000001b50cc069d6a3e33e3ff84a5c41d9d3febe7c770fdcc96b2c3ff60abe184f19630101");
|
||||
std::vector<char> expected(vch.size());
|
||||
|
||||
for (unsigned int i = 0; i < vch.size(); i++)
|
||||
expected[i] = (char)vch[i];
|
||||
|
|
@ -388,13 +386,13 @@ BOOST_AUTO_TEST_CASE(merkle_block_4)
|
|||
BOOST_CHECK(merkleBlock.header.GetHash() == block.GetHash());
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn.size() == 1);
|
||||
pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
std::pair<unsigned int, uint256> pair = merkleBlock.vMatchedTxn[0];
|
||||
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].second == uint256S("0x0a2a92f0bda4727d0a13eaddf4dd9ac6b5c61a1429e6b2b818f19b15df0ac154"));
|
||||
BOOST_CHECK(merkleBlock.vMatchedTxn[0].first == 6);
|
||||
|
||||
vector<uint256> vMatched;
|
||||
vector<unsigned int> vIndex;
|
||||
std::vector<uint256> vMatched;
|
||||
std::vector<unsigned int> vIndex;
|
||||
BOOST_CHECK(merkleBlock.txn.ExtractMatches(vMatched, vIndex) == block.hashMerkleRoot);
|
||||
BOOST_CHECK(vMatched.size() == merkleBlock.vMatchedTxn.size());
|
||||
for (unsigned int i = 0; i < vMatched.size(); i++)
|
||||
|
|
|
|||
|
|
@ -11,12 +11,8 @@
|
|||
#include <boost/assert.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost::assign; // bring 'operator+=()' into scope
|
||||
using namespace boost::filesystem;
|
||||
|
||||
// Test if a string consists entirely of null characters
|
||||
bool is_null_key(const vector<unsigned char>& key) {
|
||||
bool is_null_key(const std::vector<unsigned char>& key) {
|
||||
bool isnull = true;
|
||||
|
||||
for (unsigned int i = 0; i < key.size(); i++)
|
||||
|
|
@ -32,7 +28,7 @@ BOOST_AUTO_TEST_CASE(dbwrapper)
|
|||
// Perform tests both obfuscated and non-obfuscated.
|
||||
for (int i = 0; i < 2; i++) {
|
||||
bool obfuscate = (bool)i;
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
|
||||
char key = 'k';
|
||||
uint256 in = GetRandHash();
|
||||
|
|
@ -53,7 +49,7 @@ BOOST_AUTO_TEST_CASE(dbwrapper_batch)
|
|||
// Perform tests both obfuscated and non-obfuscated.
|
||||
for (int i = 0; i < 2; i++) {
|
||||
bool obfuscate = (bool)i;
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
|
||||
|
||||
char key = 'i';
|
||||
|
|
@ -90,7 +86,7 @@ BOOST_AUTO_TEST_CASE(dbwrapper_iterator)
|
|||
// Perform tests both obfuscated and non-obfuscated.
|
||||
for (int i = 0; i < 2; i++) {
|
||||
bool obfuscate = (bool)i;
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
CDBWrapper dbw(ph, (1 << 20), true, false, obfuscate);
|
||||
|
||||
// The two keys are intentionally chosen for ordering
|
||||
|
|
@ -129,8 +125,8 @@ BOOST_AUTO_TEST_CASE(dbwrapper_iterator)
|
|||
// Test that we do not obfuscation if there is existing data.
|
||||
BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
|
||||
{
|
||||
// We're going to share this path between two wrappers
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
// We're going to share this boost::filesystem::path between two wrappers
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
create_directories(ph);
|
||||
|
||||
// Set up a non-obfuscated wrapper to write some initial data.
|
||||
|
|
@ -170,8 +166,8 @@ BOOST_AUTO_TEST_CASE(existing_data_no_obfuscate)
|
|||
// Ensure that we start obfuscating during a reindex.
|
||||
BOOST_AUTO_TEST_CASE(existing_data_reindex)
|
||||
{
|
||||
// We're going to share this path between two wrappers
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
// We're going to share this boost::filesystem::path between two wrappers
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
create_directories(ph);
|
||||
|
||||
// Set up a non-obfuscated wrapper to write some initial data.
|
||||
|
|
@ -206,7 +202,7 @@ BOOST_AUTO_TEST_CASE(existing_data_reindex)
|
|||
|
||||
BOOST_AUTO_TEST_CASE(iterator_ordering)
|
||||
{
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
CDBWrapper dbw(ph, (1 << 20), true, false, false);
|
||||
for (int x=0x00; x<256; ++x) {
|
||||
uint8_t key = x;
|
||||
|
|
@ -241,11 +237,11 @@ BOOST_AUTO_TEST_CASE(iterator_ordering)
|
|||
struct StringContentsSerializer {
|
||||
// Used to make two serialized objects the same while letting them have a different lengths
|
||||
// This is a terrible idea
|
||||
string str;
|
||||
std::string str;
|
||||
StringContentsSerializer() {}
|
||||
StringContentsSerializer(const string& inp) : str(inp) {}
|
||||
StringContentsSerializer(const std::string& inp) : str(inp) {}
|
||||
|
||||
StringContentsSerializer& operator+=(const string& s) {
|
||||
StringContentsSerializer& operator+=(const std::string& s) {
|
||||
str += s;
|
||||
return *this;
|
||||
}
|
||||
|
|
@ -277,7 +273,7 @@ BOOST_AUTO_TEST_CASE(iterator_string_ordering)
|
|||
{
|
||||
char buf[10];
|
||||
|
||||
path ph = temp_directory_path() / unique_path();
|
||||
boost::filesystem::path ph = boost::filesystem::temp_directory_path() / boost::filesystem::unique_path();
|
||||
CDBWrapper dbw(ph, (1 << 20), true, false, false);
|
||||
for (int x=0x00; x<10; ++x) {
|
||||
for (int y = 0; y < 10; y++) {
|
||||
|
|
@ -303,7 +299,7 @@ BOOST_AUTO_TEST_CASE(iterator_string_ordering)
|
|||
for (int x=seek_start; x<10; ++x) {
|
||||
for (int y = 0; y < 10; y++) {
|
||||
sprintf(buf, "%d", x);
|
||||
string exp_key(buf);
|
||||
std::string exp_key(buf);
|
||||
for (int z = 0; z < y; z++)
|
||||
exp_key += exp_key;
|
||||
StringContentsSerializer key;
|
||||
|
|
|
|||
|
|
@ -10,8 +10,6 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(hash_tests, BasicTestingSetup)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(murmurhash3)
|
||||
|
|
|
|||
|
|
@ -16,19 +16,17 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
static const string strSecret1 ("5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj");
|
||||
static const string strSecret2 ("5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3");
|
||||
static const string strSecret1C ("Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw");
|
||||
static const string strSecret2C ("L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g");
|
||||
static const std::string strSecret1 ("5HxWvvfubhXpYYpS3tJkw6fq9jE9j18THftkZjHHfmFiWtmAbrj");
|
||||
static const std::string strSecret2 ("5KC4ejrDjv152FGwP386VD1i2NYc5KkfSMyv1nGy1VGDxGHqVY3");
|
||||
static const std::string strSecret1C ("Kwr371tjA9u2rFSMZjTNun2PXXP3WPZu2afRHTcta6KxEUdm1vEw");
|
||||
static const std::string strSecret2C ("L3Hq7a8FEQwJkW1M2GNKDW28546Vp5miewcCzSqUD9kCAXrJdS3g");
|
||||
static const CBitcoinAddress addr1 ("1QFqqMUD55ZV3PJEJZtaKCsQmjLT6JkjvJ");
|
||||
static const CBitcoinAddress addr2 ("1F5y5E5FMc5YzdJtB9hLaUe43GDxEKXENJ");
|
||||
static const CBitcoinAddress addr1C("1NoJrossxPBKfCHuJXT4HadJrXRE9Fxiqs");
|
||||
static const CBitcoinAddress addr2C("1CRj2HyM1CXWzHAXLQtiGLyggNT9WQqsDs");
|
||||
|
||||
|
||||
static const string strAddressBad("1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF");
|
||||
static const std::string strAddressBad("1HV9Lc3sNHZxwj4Zk6fB38tEmBryq2cBiF");
|
||||
|
||||
|
||||
#ifdef KEY_TESTS_DUMPINFO
|
||||
|
|
@ -37,7 +35,7 @@ void dumpKeyInfo(uint256 privkey)
|
|||
CKey key;
|
||||
key.resize(32);
|
||||
memcpy(&secret[0], &privkey, 32);
|
||||
vector<unsigned char> sec;
|
||||
std::vector<unsigned char> sec;
|
||||
sec.resize(32);
|
||||
memcpy(&sec[0], &secret[0], 32);
|
||||
printf(" * secret (hex): %s\n", HexStr(sec).c_str());
|
||||
|
|
@ -51,7 +49,7 @@ void dumpKeyInfo(uint256 privkey)
|
|||
printf(" * secret (base58): %s\n", bsecret.ToString().c_str());
|
||||
CKey key;
|
||||
key.SetSecret(secret, fCompressed);
|
||||
vector<unsigned char> vchPubKey = key.GetPubKey();
|
||||
std::vector<unsigned char> vchPubKey = key.GetPubKey();
|
||||
printf(" * pubkey (hex): %s\n", HexStr(vchPubKey).c_str());
|
||||
printf(" * address (base58): %s\n", CBitcoinAddress(vchPubKey).ToString().c_str());
|
||||
}
|
||||
|
|
@ -111,12 +109,12 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
|||
|
||||
for (int n=0; n<16; n++)
|
||||
{
|
||||
string strMsg = strprintf("Very secret message %i: 11", n);
|
||||
std::string strMsg = strprintf("Very secret message %i: 11", n);
|
||||
uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
|
||||
|
||||
// normal signatures
|
||||
|
||||
vector<unsigned char> sign1, sign2, sign1C, sign2C;
|
||||
std::vector<unsigned char> sign1, sign2, sign1C, sign2C;
|
||||
|
||||
BOOST_CHECK(key1.Sign (hashMsg, sign1));
|
||||
BOOST_CHECK(key2.Sign (hashMsg, sign2));
|
||||
|
|
@ -145,7 +143,7 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
|||
|
||||
// compact signatures (with key recovery)
|
||||
|
||||
vector<unsigned char> csign1, csign2, csign1C, csign2C;
|
||||
std::vector<unsigned char> csign1, csign2, csign1C, csign2C;
|
||||
|
||||
BOOST_CHECK(key1.SignCompact (hashMsg, csign1));
|
||||
BOOST_CHECK(key2.SignCompact (hashMsg, csign2));
|
||||
|
|
@ -168,7 +166,7 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
|||
// test deterministic signing
|
||||
|
||||
std::vector<unsigned char> detsig, detsigc;
|
||||
string strMsg = "Very deterministic message";
|
||||
std::string strMsg = "Very deterministic message";
|
||||
uint256 hashMsg = Hash(strMsg.begin(), strMsg.end());
|
||||
BOOST_CHECK(key1.Sign(hashMsg, detsig));
|
||||
BOOST_CHECK(key1C.Sign(hashMsg, detsigc));
|
||||
|
|
|
|||
|
|
@ -17,14 +17,12 @@
|
|||
#include <boost/foreach.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
typedef vector<unsigned char> valtype;
|
||||
typedef std::vector<unsigned char> valtype;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(multisig_tests, BasicTestingSetup)
|
||||
|
||||
CScript
|
||||
sign_multisig(CScript scriptPubKey, vector<CKey> keys, CTransaction transaction, int whichIn)
|
||||
sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transaction, int whichIn)
|
||||
{
|
||||
uint256 hash = SignatureHash(scriptPubKey, transaction, whichIn, SIGHASH_ALL, 0, SIGVERSION_BASE);
|
||||
|
||||
|
|
@ -32,7 +30,7 @@ sign_multisig(CScript scriptPubKey, vector<CKey> keys, CTransaction transaction,
|
|||
result << OP_0; // CHECKMULTISIG bug workaround
|
||||
BOOST_FOREACH(const CKey &key, keys)
|
||||
{
|
||||
vector<unsigned char> vchSig;
|
||||
std::vector<unsigned char> vchSig;
|
||||
BOOST_CHECK(key.Sign(hash, vchSig));
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
result << vchSig;
|
||||
|
|
@ -75,7 +73,7 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
|||
txTo[i].vout[0].nValue = 1;
|
||||
}
|
||||
|
||||
vector<CKey> keys;
|
||||
std::vector<CKey> keys;
|
||||
CScript s;
|
||||
|
||||
// Test a AND b:
|
||||
|
|
@ -200,7 +198,7 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
|||
partialkeystore.AddKey(key[0]);
|
||||
|
||||
{
|
||||
vector<valtype> solutions;
|
||||
std::vector<valtype> solutions;
|
||||
txnouttype whichType;
|
||||
CScript s;
|
||||
s << ToByteVector(key[0].GetPubKey()) << OP_CHECKSIG;
|
||||
|
|
@ -213,7 +211,7 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
|||
BOOST_CHECK(!IsMine(emptykeystore, s));
|
||||
}
|
||||
{
|
||||
vector<valtype> solutions;
|
||||
std::vector<valtype> solutions;
|
||||
txnouttype whichType;
|
||||
CScript s;
|
||||
s << OP_DUP << OP_HASH160 << ToByteVector(key[0].GetPubKey().GetID()) << OP_EQUALVERIFY << OP_CHECKSIG;
|
||||
|
|
@ -226,7 +224,7 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
|||
BOOST_CHECK(!IsMine(emptykeystore, s));
|
||||
}
|
||||
{
|
||||
vector<valtype> solutions;
|
||||
std::vector<valtype> solutions;
|
||||
txnouttype whichType;
|
||||
CScript s;
|
||||
s << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
|
||||
|
|
@ -239,13 +237,13 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
|||
BOOST_CHECK(!IsMine(partialkeystore, s));
|
||||
}
|
||||
{
|
||||
vector<valtype> solutions;
|
||||
std::vector<valtype> solutions;
|
||||
txnouttype whichType;
|
||||
CScript s;
|
||||
s << OP_1 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << OP_2 << OP_CHECKMULTISIG;
|
||||
BOOST_CHECK(Solver(s, whichType, solutions));
|
||||
BOOST_CHECK_EQUAL(solutions.size(), 4U);
|
||||
vector<CTxDestination> addrs;
|
||||
std::vector<CTxDestination> addrs;
|
||||
int nRequired;
|
||||
BOOST_CHECK(ExtractDestinations(s, whichType, addrs, nRequired));
|
||||
BOOST_CHECK(addrs[0] == keyaddr[0]);
|
||||
|
|
@ -256,7 +254,7 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
|||
BOOST_CHECK(!IsMine(partialkeystore, s));
|
||||
}
|
||||
{
|
||||
vector<valtype> solutions;
|
||||
std::vector<valtype> solutions;
|
||||
txnouttype whichType;
|
||||
CScript s;
|
||||
s << OP_2 << ToByteVector(key[0].GetPubKey()) << ToByteVector(key[1].GetPubKey()) << ToByteVector(key[2].GetPubKey()) << OP_3 << OP_CHECKMULTISIG;
|
||||
|
|
|
|||
|
|
@ -12,8 +12,6 @@
|
|||
#include "netbase.h"
|
||||
#include "chainparams.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
class CAddrManSerializationMock : public CAddrMan
|
||||
{
|
||||
public:
|
||||
|
|
@ -68,7 +66,7 @@ CDataStream AddrmanToStream(CAddrManSerializationMock& _addrman)
|
|||
ssPeersIn << FLATDATA(Params().MessageStart());
|
||||
ssPeersIn << _addrman;
|
||||
std::string str = ssPeersIn.str();
|
||||
vector<unsigned char> vchData(str.begin(), str.end());
|
||||
std::vector<unsigned char> vchData(str.begin(), str.end());
|
||||
return CDataStream(vchData, SER_DISK, CLIENT_VERSION);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -10,8 +10,6 @@
|
|||
#include <boost/assign/list_of.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(netbase_tests, BasicTestingSetup)
|
||||
|
||||
static CNetAddr ResolveIP(const char* ip)
|
||||
|
|
@ -64,9 +62,9 @@ BOOST_AUTO_TEST_CASE(netbase_properties)
|
|||
|
||||
}
|
||||
|
||||
bool static TestSplitHost(string test, string host, int port)
|
||||
bool static TestSplitHost(std::string test, std::string host, int port)
|
||||
{
|
||||
string hostOut;
|
||||
std::string hostOut;
|
||||
int portOut = -1;
|
||||
SplitHostPort(test, portOut, hostOut);
|
||||
return hostOut == host && port == portOut;
|
||||
|
|
@ -91,7 +89,7 @@ BOOST_AUTO_TEST_CASE(netbase_splithost)
|
|||
BOOST_CHECK(TestSplitHost("", "", -1));
|
||||
}
|
||||
|
||||
bool static TestParse(string src, string canon)
|
||||
bool static TestParse(std::string src, std::string canon)
|
||||
{
|
||||
CService addr(LookupNumeric(src.c_str(), 65535));
|
||||
return canon == addr.ToString();
|
||||
|
|
|
|||
|
|
@ -17,8 +17,6 @@
|
|||
#include <boost/assign/list_of.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class CPartialMerkleTreeTester : public CPartialMerkleTree
|
||||
{
|
||||
public:
|
||||
|
|
|
|||
|
|
@ -11,8 +11,6 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(pow_tests, BasicTestingSetup)
|
||||
|
||||
/* Test calculation of next difficulty target with no constraints applying */
|
||||
|
|
|
|||
|
|
@ -16,13 +16,11 @@
|
|||
|
||||
#include <univalue.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
UniValue CallRPC(string args)
|
||||
UniValue CallRPC(std::string args)
|
||||
{
|
||||
vector<string> vArgs;
|
||||
std::vector<std::string> vArgs;
|
||||
boost::split(vArgs, args, boost::is_any_of(" \t"));
|
||||
string strMethod = vArgs[0];
|
||||
std::string strMethod = vArgs[0];
|
||||
vArgs.erase(vArgs.begin());
|
||||
JSONRPCRequest request;
|
||||
request.strMethod = strMethod;
|
||||
|
|
@ -35,7 +33,7 @@ UniValue CallRPC(string args)
|
|||
return result;
|
||||
}
|
||||
catch (const UniValue& objError) {
|
||||
throw runtime_error(find_value(objError, "message").get_str());
|
||||
throw std::runtime_error(find_value(objError, "message").get_str());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -47,41 +45,41 @@ BOOST_AUTO_TEST_CASE(rpc_rawparams)
|
|||
// Test raw transaction API argument handling
|
||||
UniValue r;
|
||||
|
||||
BOOST_CHECK_THROW(CallRPC("getrawtransaction"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("getrawtransaction not_hex"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("getrawtransaction a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed not_int"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("getrawtransaction"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("getrawtransaction not_hex"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("getrawtransaction a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed not_int"), std::runtime_error);
|
||||
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction null null"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction not_array"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [] []"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction {} {}"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction null null"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction not_array"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [] []"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction {} {}"), std::runtime_error);
|
||||
BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [] {}"));
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"), std::runtime_error);
|
||||
|
||||
BOOST_CHECK_THROW(CallRPC("decoderawtransaction"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("decoderawtransaction null"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("decoderawtransaction DEADBEEF"), runtime_error);
|
||||
string rawtx = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("decoderawtransaction ")+rawtx));
|
||||
BOOST_CHECK_THROW(CallRPC("decoderawtransaction"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("decoderawtransaction null"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("decoderawtransaction DEADBEEF"), std::runtime_error);
|
||||
std::string rawtx = "0100000001a15d57094aa7a21a28cb20b59aab8fc7d1149a3bdbcddba9c622e4f5f6a99ece010000006c493046022100f93bb0e7d8db7bd46e40132d1f8242026e045f03a0efe71bbb8e3f475e970d790221009337cd7f1f929f00cc6ff01f03729b069a7c21b59b1736ddfee5db5946c5da8c0121033b9b137ee87d5a812d6f506efdd37f0affa7ffc310711c06c7f3e097c9447c52ffffffff0100e1f505000000001976a9140389035a9225b3839e2bbf32d826a1e222031fd888ac00000000";
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx));
|
||||
BOOST_CHECK_EQUAL(find_value(r.get_obj(), "size").get_int(), 193);
|
||||
BOOST_CHECK_EQUAL(find_value(r.get_obj(), "version").get_int(), 1);
|
||||
BOOST_CHECK_EQUAL(find_value(r.get_obj(), "locktime").get_int(), 0);
|
||||
BOOST_CHECK_THROW(r = CallRPC(string("decoderawtransaction ")+rawtx+" extra"), runtime_error);
|
||||
BOOST_CHECK_THROW(r = CallRPC(std::string("decoderawtransaction ")+rawtx+" extra"), std::runtime_error);
|
||||
|
||||
BOOST_CHECK_THROW(CallRPC("signrawtransaction"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("signrawtransaction null"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("signrawtransaction ff00"), runtime_error);
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("signrawtransaction ")+rawtx));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("signrawtransaction ")+rawtx+" null null NONE|ANYONECANPAY"));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("signrawtransaction ")+rawtx+" [] [] NONE|ANYONECANPAY"));
|
||||
BOOST_CHECK_THROW(CallRPC(string("signrawtransaction ")+rawtx+" null null badenum"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("signrawtransaction"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("signrawtransaction null"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("signrawtransaction ff00"), std::runtime_error);
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("signrawtransaction ")+rawtx));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("signrawtransaction ")+rawtx+" null null NONE|ANYONECANPAY"));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("signrawtransaction ")+rawtx+" [] [] NONE|ANYONECANPAY"));
|
||||
BOOST_CHECK_THROW(CallRPC(std::string("signrawtransaction ")+rawtx+" null null badenum"), std::runtime_error);
|
||||
|
||||
// Only check failure cases for sendrawtransaction, there's no network to send to...
|
||||
BOOST_CHECK_THROW(CallRPC("sendrawtransaction"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("sendrawtransaction null"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("sendrawtransaction DEADBEEF"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC(string("sendrawtransaction ")+rawtx+" extra"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("sendrawtransaction"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("sendrawtransaction null"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("sendrawtransaction DEADBEEF"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC(std::string("sendrawtransaction ")+rawtx+" extra"), std::runtime_error);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(rpc_togglenetwork)
|
||||
|
|
@ -110,18 +108,18 @@ BOOST_AUTO_TEST_CASE(rpc_rawsign)
|
|||
{
|
||||
UniValue r;
|
||||
// input is a 1-of-2 multisig (so is output):
|
||||
string prevout =
|
||||
std::string prevout =
|
||||
"[{\"txid\":\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b7248f50977c8493f3\","
|
||||
"\"vout\":1,\"scriptPubKey\":\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
|
||||
"\"redeemScript\":\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ecefca5b94d6df834e77e108f68e66f126044c052ae\"}]";
|
||||
r = CallRPC(string("createrawtransaction ")+prevout+" "+
|
||||
r = CallRPC(std::string("createrawtransaction ")+prevout+" "+
|
||||
"{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
|
||||
string notsigned = r.get_str();
|
||||
string privkey1 = "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
|
||||
string privkey2 = "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
|
||||
r = CallRPC(string("signrawtransaction ")+notsigned+" "+prevout+" "+"[]");
|
||||
std::string notsigned = r.get_str();
|
||||
std::string privkey1 = "\"KzsXybp9jX64P5ekX1KUxRQ79Jht9uzW7LorgwE65i5rWACL6LQe\"";
|
||||
std::string privkey2 = "\"Kyhdf5LuKTRx4ge69ybABsiUAWjVRK4XGxAKk2FQLp2HjGMy87Z4\"";
|
||||
r = CallRPC(std::string("signrawtransaction ")+notsigned+" "+prevout+" "+"[]");
|
||||
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
|
||||
r = CallRPC(string("signrawtransaction ")+notsigned+" "+prevout+" "+"["+privkey1+","+privkey2+"]");
|
||||
r = CallRPC(std::string("signrawtransaction ")+notsigned+" "+prevout+" "+"["+privkey1+","+privkey2+"]");
|
||||
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
|
||||
}
|
||||
|
||||
|
|
@ -133,11 +131,11 @@ BOOST_AUTO_TEST_CASE(rpc_createraw_op_return)
|
|||
BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"68656c6c6f776f726c64\",\"data\":\"68656c6c6f776f726c64\"}"));
|
||||
|
||||
// Key not "data" (bad address)
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"somedata\":\"68656c6c6f776f726c64\"}"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"somedata\":\"68656c6c6f776f726c64\"}"), std::runtime_error);
|
||||
|
||||
// Bad hex encoding of data output
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345\"}"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345g\"}"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345\"}"), std::runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"12345g\"}"), std::runtime_error);
|
||||
|
||||
// Data 81 bytes long
|
||||
BOOST_CHECK_NO_THROW(CallRPC("createrawtransaction [{\"txid\":\"a3b807410df0b60fcb9736768df5823938b2f838694939ba45f3c0a1bff150ed\",\"vout\":0}] {\"data\":\"010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081\"}"));
|
||||
|
|
@ -241,23 +239,23 @@ BOOST_AUTO_TEST_CASE(json_parse_errors)
|
|||
|
||||
BOOST_AUTO_TEST_CASE(rpc_ban)
|
||||
{
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
|
||||
|
||||
UniValue r;
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban 127.0.0.0 add")));
|
||||
BOOST_CHECK_THROW(r = CallRPC(string("setban 127.0.0.0:8334")), runtime_error); //portnumber for setban not allowed
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0 add")));
|
||||
BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.0:8334")), std::runtime_error); //portnumber for setban not allowed
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
UniValue ar = r.get_array();
|
||||
UniValue o1 = ar[0].get_obj();
|
||||
UniValue adr = find_value(o1, "address");
|
||||
BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/32");
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("setban 127.0.0.0 remove")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0 remove")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
BOOST_CHECK_EQUAL(ar.size(), 0);
|
||||
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban 127.0.0.0/24 add 1607731200 true")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 1607731200 true")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
o1 = ar[0].get_obj();
|
||||
adr = find_value(o1, "address");
|
||||
|
|
@ -265,10 +263,10 @@ BOOST_AUTO_TEST_CASE(rpc_ban)
|
|||
BOOST_CHECK_EQUAL(adr.get_str(), "127.0.0.0/24");
|
||||
BOOST_CHECK_EQUAL(banned_until.get_int64(), 1607731200); // absolute time check
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
|
||||
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban 127.0.0.0/24 add 200")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/24 add 200")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
o1 = ar[0].get_obj();
|
||||
adr = find_value(o1, "address");
|
||||
|
|
@ -279,43 +277,43 @@ BOOST_AUTO_TEST_CASE(rpc_ban)
|
|||
BOOST_CHECK(banned_until.get_int64()-now <= 200);
|
||||
|
||||
// must throw an exception because 127.0.0.1 is in already banned suubnet range
|
||||
BOOST_CHECK_THROW(r = CallRPC(string("setban 127.0.0.1 add")), runtime_error);
|
||||
BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.0.1 add")), std::runtime_error);
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("setban 127.0.0.0/24 remove")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("setban 127.0.0.0/24 remove")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
BOOST_CHECK_EQUAL(ar.size(), 0);
|
||||
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban 127.0.0.0/255.255.0.0 add")));
|
||||
BOOST_CHECK_THROW(r = CallRPC(string("setban 127.0.1.1 add")), runtime_error);
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 127.0.0.0/255.255.0.0 add")));
|
||||
BOOST_CHECK_THROW(r = CallRPC(std::string("setban 127.0.1.1 add")), std::runtime_error);
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
BOOST_CHECK_EQUAL(ar.size(), 0);
|
||||
|
||||
|
||||
BOOST_CHECK_THROW(r = CallRPC(string("setban test add")), runtime_error); //invalid IP
|
||||
BOOST_CHECK_THROW(r = CallRPC(std::string("setban test add")), std::runtime_error); //invalid IP
|
||||
|
||||
//IPv6 tests
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban FE80:0000:0000:0000:0202:B3FF:FE1E:8329 add")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
o1 = ar[0].get_obj();
|
||||
adr = find_value(o1, "address");
|
||||
BOOST_CHECK_EQUAL(adr.get_str(), "fe80::202:b3ff:fe1e:8329/128");
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:db8::/ffff:fffc:0:0:0:0:0:0 add")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
o1 = ar[0].get_obj();
|
||||
adr = find_value(o1, "address");
|
||||
BOOST_CHECK_EQUAL(adr.get_str(), "2001:db8::/30");
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC(string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(string("listbanned")));
|
||||
BOOST_CHECK_NO_THROW(CallRPC(std::string("clearbanned")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("setban 2001:4d48:ac57:400:cacf:e9ff:fe1d:9c63/128 add")));
|
||||
BOOST_CHECK_NO_THROW(r = CallRPC(std::string("listbanned")));
|
||||
ar = r.get_array();
|
||||
o1 = ar[0].get_obj();
|
||||
adr = find_value(o1, "address");
|
||||
|
|
|
|||
|
|
@ -17,8 +17,6 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
// Helpers:
|
||||
static std::vector<unsigned char>
|
||||
Serialize(const CScript& s)
|
||||
|
|
@ -80,7 +78,7 @@ BOOST_AUTO_TEST_CASE(sign)
|
|||
}
|
||||
|
||||
CMutableTransaction txFrom; // Funding transaction:
|
||||
string reason;
|
||||
std::string reason;
|
||||
txFrom.vout.resize(8);
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
|
|
@ -178,7 +176,7 @@ BOOST_AUTO_TEST_CASE(set)
|
|||
}
|
||||
|
||||
CMutableTransaction txFrom; // Funding transaction:
|
||||
string reason;
|
||||
std::string reason;
|
||||
txFrom.vout.resize(4);
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
|
|
@ -263,7 +261,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
|||
CCoinsViewCache coins(&coinsDummy);
|
||||
CBasicKeyStore keystore;
|
||||
CKey key[6];
|
||||
vector<CPubKey> keys;
|
||||
std::vector<CPubKey> keys;
|
||||
for (int i = 0; i < 6; i++)
|
||||
{
|
||||
key[i].MakeNewKey(true);
|
||||
|
|
@ -335,8 +333,8 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
|||
// SignSignature doesn't know how to sign these. We're
|
||||
// not testing validating signatures, so just create
|
||||
// dummy signatures that DO include the correct P2SH scripts:
|
||||
txTo.vin[3].scriptSig << OP_11 << OP_11 << vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
|
||||
txTo.vin[4].scriptSig << vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
|
||||
txTo.vin[3].scriptSig << OP_11 << OP_11 << std::vector<unsigned char>(oneAndTwo.begin(), oneAndTwo.end());
|
||||
txTo.vin[4].scriptSig << std::vector<unsigned char>(fifteenSigops.begin(), fifteenSigops.end());
|
||||
|
||||
BOOST_CHECK(::AreInputsStandard(txTo, coins));
|
||||
// 22 P2SH sigops for all inputs (1 for vin[0], 6 for vin[3], 15 for vin[4]
|
||||
|
|
@ -349,7 +347,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
|||
txToNonStd1.vin.resize(1);
|
||||
txToNonStd1.vin[0].prevout.n = 5;
|
||||
txToNonStd1.vin[0].prevout.hash = txFrom.GetHash();
|
||||
txToNonStd1.vin[0].scriptSig << vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
|
||||
txToNonStd1.vin[0].scriptSig << std::vector<unsigned char>(sixteenSigops.begin(), sixteenSigops.end());
|
||||
|
||||
BOOST_CHECK(!::AreInputsStandard(txToNonStd1, coins));
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txToNonStd1, coins), 16U);
|
||||
|
|
@ -361,7 +359,7 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
|||
txToNonStd2.vin.resize(1);
|
||||
txToNonStd2.vin[0].prevout.n = 6;
|
||||
txToNonStd2.vin[0].prevout.hash = txFrom.GetHash();
|
||||
txToNonStd2.vin[0].scriptSig << vector<unsigned char>(twentySigops.begin(), twentySigops.end());
|
||||
txToNonStd2.vin[0].scriptSig << std::vector<unsigned char>(twentySigops.begin(), twentySigops.end());
|
||||
|
||||
BOOST_CHECK(!::AreInputsStandard(txToNonStd2, coins));
|
||||
BOOST_CHECK_EQUAL(GetP2SHSigOpCount(txToNonStd2, coins), 20U);
|
||||
|
|
|
|||
|
|
@ -29,15 +29,13 @@
|
|||
|
||||
#include <univalue.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
// Uncomment if you want to output updated JSON tests.
|
||||
// #define UPDATE_JSON_TESTS
|
||||
|
||||
static const unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
|
||||
|
||||
unsigned int ParseScriptFlags(string strFlags);
|
||||
string FormatScriptFlags(unsigned int flags);
|
||||
unsigned int ParseScriptFlags(std::string strFlags);
|
||||
std::string FormatScriptFlags(unsigned int flags);
|
||||
|
||||
UniValue
|
||||
read_json(const std::string& jsondata)
|
||||
|
|
@ -800,7 +798,7 @@ BOOST_AUTO_TEST_CASE(script_build)
|
|||
CScript witscript = CScript() << ToByteVector(keys.pubkey0);
|
||||
uint256 hash;
|
||||
CSHA256().Write(&witscript[0], witscript.size()).Finalize(hash.begin());
|
||||
vector<unsigned char> hashBytes = ToByteVector(hash);
|
||||
std::vector<unsigned char> hashBytes = ToByteVector(hash);
|
||||
hashBytes.pop_back();
|
||||
tests.push_back(TestBuilder(CScript() << OP_0 << hashBytes,
|
||||
"P2WPKH with wrong witness program length", SCRIPT_VERIFY_WITNESS | SCRIPT_VERIFY_P2SH, false
|
||||
|
|
@ -965,7 +963,7 @@ BOOST_AUTO_TEST_CASE(script_json_test)
|
|||
|
||||
for (unsigned int idx = 0; idx < tests.size(); idx++) {
|
||||
UniValue test = tests[idx];
|
||||
string strTest = test.write();
|
||||
std::string strTest = test.write();
|
||||
CScriptWitness witness;
|
||||
CAmount nValue = 0;
|
||||
unsigned int pos = 0;
|
||||
|
|
@ -984,9 +982,9 @@ BOOST_AUTO_TEST_CASE(script_json_test)
|
|||
}
|
||||
continue;
|
||||
}
|
||||
string scriptSigString = test[pos++].get_str();
|
||||
std::string scriptSigString = test[pos++].get_str();
|
||||
CScript scriptSig = ParseScript(scriptSigString);
|
||||
string scriptPubKeyString = test[pos++].get_str();
|
||||
std::string scriptPubKeyString = test[pos++].get_str();
|
||||
CScript scriptPubKey = ParseScript(scriptPubKeyString);
|
||||
unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
|
||||
int scriptError = ParseScriptError(test[pos++].get_str());
|
||||
|
|
@ -1005,21 +1003,21 @@ BOOST_AUTO_TEST_CASE(script_PushData)
|
|||
static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
|
||||
|
||||
ScriptError err;
|
||||
vector<vector<unsigned char> > directStack;
|
||||
std::vector<std::vector<unsigned char> > directStack;
|
||||
BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
vector<vector<unsigned char> > pushdata1Stack;
|
||||
std::vector<std::vector<unsigned char> > pushdata1Stack;
|
||||
BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
|
||||
BOOST_CHECK(pushdata1Stack == directStack);
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
vector<vector<unsigned char> > pushdata2Stack;
|
||||
std::vector<std::vector<unsigned char> > pushdata2Stack;
|
||||
BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
|
||||
BOOST_CHECK(pushdata2Stack == directStack);
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
||||
vector<vector<unsigned char> > pushdata4Stack;
|
||||
std::vector<std::vector<unsigned char> > pushdata4Stack;
|
||||
BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), SIGVERSION_BASE, &err));
|
||||
BOOST_CHECK(pushdata4Stack == directStack);
|
||||
BOOST_CHECK_MESSAGE(err == SCRIPT_ERR_OK, ScriptErrorString(err));
|
||||
|
|
@ -1042,7 +1040,7 @@ sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transac
|
|||
result << OP_0;
|
||||
BOOST_FOREACH(const CKey &key, keys)
|
||||
{
|
||||
vector<unsigned char> vchSig;
|
||||
std::vector<unsigned char> vchSig;
|
||||
BOOST_CHECK(key.Sign(hash, vchSig));
|
||||
vchSig.push_back((unsigned char)SIGHASH_ALL);
|
||||
result << vchSig;
|
||||
|
|
@ -1161,8 +1159,8 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
|||
// Test the CombineSignatures function
|
||||
CAmount amount = 0;
|
||||
CBasicKeyStore keystore;
|
||||
vector<CKey> keys;
|
||||
vector<CPubKey> pubkeys;
|
||||
std::vector<CKey> keys;
|
||||
std::vector<CPubKey> pubkeys;
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
CKey key;
|
||||
|
|
@ -1223,15 +1221,15 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
|||
BOOST_CHECK(combined.scriptSig == scriptSig);
|
||||
|
||||
// A couple of partially-signed versions:
|
||||
vector<unsigned char> sig1;
|
||||
std::vector<unsigned char> sig1;
|
||||
uint256 hash1 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_ALL, 0, SIGVERSION_BASE);
|
||||
BOOST_CHECK(keys[0].Sign(hash1, sig1));
|
||||
sig1.push_back(SIGHASH_ALL);
|
||||
vector<unsigned char> sig2;
|
||||
std::vector<unsigned char> sig2;
|
||||
uint256 hash2 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_NONE, 0, SIGVERSION_BASE);
|
||||
BOOST_CHECK(keys[1].Sign(hash2, sig2));
|
||||
sig2.push_back(SIGHASH_NONE);
|
||||
vector<unsigned char> sig3;
|
||||
std::vector<unsigned char> sig3;
|
||||
uint256 hash3 = SignatureHash(scriptPubKey, txTo, 0, SIGHASH_SINGLE, 0, SIGVERSION_BASE);
|
||||
BOOST_CHECK(keys[2].Sign(hash3, sig3));
|
||||
sig3.push_back(SIGHASH_SINGLE);
|
||||
|
|
@ -1305,9 +1303,9 @@ BOOST_AUTO_TEST_CASE(script_GetScriptAsm)
|
|||
BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_NOP2));
|
||||
BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY", ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
|
||||
|
||||
string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
|
||||
string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
|
||||
vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
|
||||
std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38d782e53023ee313d741ad0cfbc0c5090");
|
||||
std::string pubKey("03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
|
||||
std::vector<unsigned char> vchPubKey = ToByteVector(ParseHex(pubKey));
|
||||
|
||||
BOOST_CHECK_EQUAL(derSig + "00 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00")) << vchPubKey, true));
|
||||
BOOST_CHECK_EQUAL(derSig + "80 " + pubKey, ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80")) << vchPubKey, true));
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@
|
|||
#include <stdint.h>
|
||||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(serialize_tests, BasicTestingSetup)
|
||||
|
||||
|
|
@ -227,7 +226,7 @@ BOOST_AUTO_TEST_CASE(varints_bitpatterns)
|
|||
BOOST_AUTO_TEST_CASE(compactsize)
|
||||
{
|
||||
CDataStream ss(SER_DISK, 0);
|
||||
vector<char>::size_type i, j;
|
||||
std::vector<char>::size_type i, j;
|
||||
|
||||
for (i = 1; i <= MAX_SIZE; i *= 2)
|
||||
{
|
||||
|
|
@ -260,7 +259,7 @@ BOOST_AUTO_TEST_CASE(noncanonical)
|
|||
// Write some non-canonical CompactSize encodings, and
|
||||
// make sure an exception is thrown when read back.
|
||||
CDataStream ss(SER_DISK, 0);
|
||||
vector<char>::size_type n;
|
||||
std::vector<char>::size_type n;
|
||||
|
||||
// zero encoded with three bytes:
|
||||
ss.write("\xfd\x00\x00", 3);
|
||||
|
|
|
|||
|
|
@ -15,8 +15,6 @@
|
|||
#include <boost/foreach.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
// Helpers:
|
||||
static std::vector<unsigned char>
|
||||
Serialize(const CScript& s)
|
||||
|
|
@ -160,8 +158,8 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
|
|||
CScript scriptPubKey = GetScriptForWitness(p2pk);
|
||||
CScript scriptSig = CScript();
|
||||
CScriptWitness scriptWitness;
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
|
||||
|
||||
BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
|
||||
|
|
@ -190,8 +188,8 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
|
|||
CScript scriptPubKey = GetScriptForDestination(CScriptID(scriptSig));
|
||||
scriptSig = CScript() << ToByteVector(scriptSig);
|
||||
CScriptWitness scriptWitness;
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
|
||||
BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
|
||||
assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 1);
|
||||
|
|
@ -204,9 +202,9 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
|
|||
CScript scriptPubKey = GetScriptForWitness(witnessScript);
|
||||
CScript scriptSig = CScript();
|
||||
CScriptWitness scriptWitness;
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(witnessScript.begin(), witnessScript.end()));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(witnessScript.begin(), witnessScript.end()));
|
||||
|
||||
BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
|
||||
assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2);
|
||||
|
|
@ -221,9 +219,9 @@ BOOST_AUTO_TEST_CASE(GetTxSigOpCost)
|
|||
CScript scriptPubKey = GetScriptForDestination(CScriptID(redeemScript));
|
||||
CScript scriptSig = CScript() << ToByteVector(redeemScript);
|
||||
CScriptWitness scriptWitness;
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(vector<unsigned char>(witnessScript.begin(), witnessScript.end()));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(0));
|
||||
scriptWitness.stack.push_back(std::vector<unsigned char>(witnessScript.begin(), witnessScript.end()));
|
||||
|
||||
BuildTxs(spendingTx, coins, creationTx, scriptPubKey, scriptSig, scriptWitness);
|
||||
assert(GetTransactionSigOpCost(CTransaction(spendingTx), coins, flags) == 2);
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@
|
|||
#include <boost/assert.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
using namespace boost::assign; // bring 'operator+=()' into scope
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(streams_tests, BasicTestingSetup)
|
||||
|
|
|
|||
|
|
@ -7,8 +7,6 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(timedata_tests, BasicTestingSetup)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(util_MedianFilter)
|
||||
|
|
|
|||
|
|
@ -32,42 +32,40 @@
|
|||
|
||||
#include <univalue.h>
|
||||
|
||||
using namespace std;
|
||||
|
||||
typedef vector<unsigned char> valtype;
|
||||
typedef std::vector<unsigned char> valtype;
|
||||
|
||||
// In script_tests.cpp
|
||||
extern UniValue read_json(const std::string& jsondata);
|
||||
|
||||
static std::map<string, unsigned int> mapFlagNames = boost::assign::map_list_of
|
||||
(string("NONE"), (unsigned int)SCRIPT_VERIFY_NONE)
|
||||
(string("P2SH"), (unsigned int)SCRIPT_VERIFY_P2SH)
|
||||
(string("STRICTENC"), (unsigned int)SCRIPT_VERIFY_STRICTENC)
|
||||
(string("DERSIG"), (unsigned int)SCRIPT_VERIFY_DERSIG)
|
||||
(string("LOW_S"), (unsigned int)SCRIPT_VERIFY_LOW_S)
|
||||
(string("SIGPUSHONLY"), (unsigned int)SCRIPT_VERIFY_SIGPUSHONLY)
|
||||
(string("MINIMALDATA"), (unsigned int)SCRIPT_VERIFY_MINIMALDATA)
|
||||
(string("NULLDUMMY"), (unsigned int)SCRIPT_VERIFY_NULLDUMMY)
|
||||
(string("DISCOURAGE_UPGRADABLE_NOPS"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
|
||||
(string("CLEANSTACK"), (unsigned int)SCRIPT_VERIFY_CLEANSTACK)
|
||||
(string("MINIMALIF"), (unsigned int)SCRIPT_VERIFY_MINIMALIF)
|
||||
(string("NULLFAIL"), (unsigned int)SCRIPT_VERIFY_NULLFAIL)
|
||||
(string("CHECKLOCKTIMEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)
|
||||
(string("CHECKSEQUENCEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)
|
||||
(string("WITNESS"), (unsigned int)SCRIPT_VERIFY_WITNESS)
|
||||
(string("DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)
|
||||
(string("WITNESS_PUBKEYTYPE"), (unsigned int)SCRIPT_VERIFY_WITNESS_PUBKEYTYPE);
|
||||
static std::map<std::string, unsigned int> mapFlagNames = boost::assign::map_list_of
|
||||
(std::string("NONE"), (unsigned int)SCRIPT_VERIFY_NONE)
|
||||
(std::string("P2SH"), (unsigned int)SCRIPT_VERIFY_P2SH)
|
||||
(std::string("STRICTENC"), (unsigned int)SCRIPT_VERIFY_STRICTENC)
|
||||
(std::string("DERSIG"), (unsigned int)SCRIPT_VERIFY_DERSIG)
|
||||
(std::string("LOW_S"), (unsigned int)SCRIPT_VERIFY_LOW_S)
|
||||
(std::string("SIGPUSHONLY"), (unsigned int)SCRIPT_VERIFY_SIGPUSHONLY)
|
||||
(std::string("MINIMALDATA"), (unsigned int)SCRIPT_VERIFY_MINIMALDATA)
|
||||
(std::string("NULLDUMMY"), (unsigned int)SCRIPT_VERIFY_NULLDUMMY)
|
||||
(std::string("DISCOURAGE_UPGRADABLE_NOPS"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS)
|
||||
(std::string("CLEANSTACK"), (unsigned int)SCRIPT_VERIFY_CLEANSTACK)
|
||||
(std::string("MINIMALIF"), (unsigned int)SCRIPT_VERIFY_MINIMALIF)
|
||||
(std::string("NULLFAIL"), (unsigned int)SCRIPT_VERIFY_NULLFAIL)
|
||||
(std::string("CHECKLOCKTIMEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)
|
||||
(std::string("CHECKSEQUENCEVERIFY"), (unsigned int)SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)
|
||||
(std::string("WITNESS"), (unsigned int)SCRIPT_VERIFY_WITNESS)
|
||||
(std::string("DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM"), (unsigned int)SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_WITNESS_PROGRAM)
|
||||
(std::string("WITNESS_PUBKEYTYPE"), (unsigned int)SCRIPT_VERIFY_WITNESS_PUBKEYTYPE);
|
||||
|
||||
unsigned int ParseScriptFlags(string strFlags)
|
||||
unsigned int ParseScriptFlags(std::string strFlags)
|
||||
{
|
||||
if (strFlags.empty()) {
|
||||
return 0;
|
||||
}
|
||||
unsigned int flags = 0;
|
||||
vector<string> words;
|
||||
std::vector<std::string> words;
|
||||
boost::algorithm::split(words, strFlags, boost::algorithm::is_any_of(","));
|
||||
|
||||
BOOST_FOREACH(string word, words)
|
||||
BOOST_FOREACH(std::string word, words)
|
||||
{
|
||||
if (!mapFlagNames.count(word))
|
||||
BOOST_ERROR("Bad test: unknown verification flag '" << word << "'");
|
||||
|
|
@ -77,13 +75,13 @@ unsigned int ParseScriptFlags(string strFlags)
|
|||
return flags;
|
||||
}
|
||||
|
||||
string FormatScriptFlags(unsigned int flags)
|
||||
std::string FormatScriptFlags(unsigned int flags)
|
||||
{
|
||||
if (flags == 0) {
|
||||
return "";
|
||||
}
|
||||
string ret;
|
||||
std::map<string, unsigned int>::const_iterator it = mapFlagNames.begin();
|
||||
std::string ret;
|
||||
std::map<std::string, unsigned int>::const_iterator it = mapFlagNames.begin();
|
||||
while (it != mapFlagNames.end()) {
|
||||
if (flags & it->second) {
|
||||
ret += it->first + ",";
|
||||
|
|
@ -109,7 +107,7 @@ BOOST_AUTO_TEST_CASE(tx_valid)
|
|||
ScriptError err;
|
||||
for (unsigned int idx = 0; idx < tests.size(); idx++) {
|
||||
UniValue test = tests[idx];
|
||||
string strTest = test.write();
|
||||
std::string strTest = test.write();
|
||||
if (test[0].isArray())
|
||||
{
|
||||
if (test.size() != 3 || !test[1].isStr() || !test[2].isStr())
|
||||
|
|
@ -118,8 +116,8 @@ BOOST_AUTO_TEST_CASE(tx_valid)
|
|||
continue;
|
||||
}
|
||||
|
||||
map<COutPoint, CScript> mapprevOutScriptPubKeys;
|
||||
map<COutPoint, int64_t> mapprevOutValues;
|
||||
std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
|
||||
std::map<COutPoint, int64_t> mapprevOutValues;
|
||||
UniValue inputs = test[0].get_array();
|
||||
bool fValid = true;
|
||||
for (unsigned int inpIdx = 0; inpIdx < inputs.size(); inpIdx++) {
|
||||
|
|
@ -148,7 +146,7 @@ BOOST_AUTO_TEST_CASE(tx_valid)
|
|||
continue;
|
||||
}
|
||||
|
||||
string transaction = test[1].get_str();
|
||||
std::string transaction = test[1].get_str();
|
||||
CDataStream stream(ParseHex(transaction), SER_NETWORK, PROTOCOL_VERSION);
|
||||
CTransaction tx(deserialize, stream);
|
||||
|
||||
|
|
@ -194,7 +192,7 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
|
|||
ScriptError err;
|
||||
for (unsigned int idx = 0; idx < tests.size(); idx++) {
|
||||
UniValue test = tests[idx];
|
||||
string strTest = test.write();
|
||||
std::string strTest = test.write();
|
||||
if (test[0].isArray())
|
||||
{
|
||||
if (test.size() != 3 || !test[1].isStr() || !test[2].isStr())
|
||||
|
|
@ -203,8 +201,8 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
|
|||
continue;
|
||||
}
|
||||
|
||||
map<COutPoint, CScript> mapprevOutScriptPubKeys;
|
||||
map<COutPoint, int64_t> mapprevOutValues;
|
||||
std::map<COutPoint, CScript> mapprevOutScriptPubKeys;
|
||||
std::map<COutPoint, int64_t> mapprevOutValues;
|
||||
UniValue inputs = test[0].get_array();
|
||||
bool fValid = true;
|
||||
for (unsigned int inpIdx = 0; inpIdx < inputs.size(); inpIdx++) {
|
||||
|
|
@ -233,7 +231,7 @@ BOOST_AUTO_TEST_CASE(tx_invalid)
|
|||
continue;
|
||||
}
|
||||
|
||||
string transaction = test[1].get_str();
|
||||
std::string transaction = test[1].get_str();
|
||||
CDataStream stream(ParseHex(transaction), SER_NETWORK, PROTOCOL_VERSION );
|
||||
CTransaction tx(deserialize, stream);
|
||||
|
||||
|
|
@ -268,7 +266,7 @@ BOOST_AUTO_TEST_CASE(basic_transaction_tests)
|
|||
{
|
||||
// Random real transaction (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
|
||||
unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
|
||||
vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
|
||||
std::vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
|
||||
CDataStream stream(vch, SER_DISK, CLIENT_VERSION);
|
||||
CMutableTransaction tx;
|
||||
stream >> tx;
|
||||
|
|
@ -390,7 +388,7 @@ void CheckWithFlag(const CTransactionRef& output, const CMutableTransaction& inp
|
|||
assert(ret == success);
|
||||
}
|
||||
|
||||
static CScript PushAll(const vector<valtype>& values)
|
||||
static CScript PushAll(const std::vector<valtype>& values)
|
||||
{
|
||||
CScript result;
|
||||
BOOST_FOREACH(const valtype& v, values) {
|
||||
|
|
@ -407,7 +405,7 @@ static CScript PushAll(const vector<valtype>& values)
|
|||
|
||||
void ReplaceRedeemScript(CScript& script, const CScript& redeemScript)
|
||||
{
|
||||
vector<valtype> stack;
|
||||
std::vector<valtype> stack;
|
||||
EvalScript(stack, script, SCRIPT_VERIFY_STRICTENC, BaseSignatureChecker(), SIGVERSION_BASE);
|
||||
assert(stack.size() > 0);
|
||||
stack.back() = std::vector<unsigned char>(redeemScript.begin(), redeemScript.end());
|
||||
|
|
@ -425,7 +423,7 @@ BOOST_AUTO_TEST_CASE(test_big_witness_transaction) {
|
|||
CKeyID hash = key.GetPubKey().GetID();
|
||||
CScript scriptPubKey = CScript() << OP_0 << std::vector<unsigned char>(hash.begin(), hash.end());
|
||||
|
||||
vector<int> sigHashes;
|
||||
std::vector<int> sigHashes;
|
||||
sigHashes.push_back(SIGHASH_NONE | SIGHASH_ANYONECANPAY);
|
||||
sigHashes.push_back(SIGHASH_SINGLE | SIGHASH_ANYONECANPAY);
|
||||
sigHashes.push_back(SIGHASH_ALL | SIGHASH_ANYONECANPAY);
|
||||
|
|
@ -688,7 +686,7 @@ BOOST_AUTO_TEST_CASE(test_IsStandard)
|
|||
key.MakeNewKey(true);
|
||||
t.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
|
||||
|
||||
string reason;
|
||||
std::string reason;
|
||||
BOOST_CHECK(IsStandardTx(t, reason));
|
||||
|
||||
// Check dust with default relay fee:
|
||||
|
|
|
|||
|
|
@ -12,8 +12,6 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(univalue_tests, BasicTestingSetup)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_constructor)
|
||||
|
|
@ -53,7 +51,7 @@ BOOST_AUTO_TEST_CASE(univalue_constructor)
|
|||
BOOST_CHECK(v7.isNum());
|
||||
BOOST_CHECK_EQUAL(v7.getValStr(), "-7.21");
|
||||
|
||||
string vs("yawn");
|
||||
std::string vs("yawn");
|
||||
UniValue v8(vs);
|
||||
BOOST_CHECK(v8.isStr());
|
||||
BOOST_CHECK_EQUAL(v8.getValStr(), "yawn");
|
||||
|
|
@ -69,41 +67,41 @@ BOOST_AUTO_TEST_CASE(univalue_typecheck)
|
|||
UniValue v1;
|
||||
BOOST_CHECK(v1.setNumStr("1"));
|
||||
BOOST_CHECK(v1.isNum());
|
||||
BOOST_CHECK_THROW(v1.get_bool(), runtime_error);
|
||||
BOOST_CHECK_THROW(v1.get_bool(), std::runtime_error);
|
||||
|
||||
UniValue v2;
|
||||
BOOST_CHECK(v2.setBool(true));
|
||||
BOOST_CHECK_EQUAL(v2.get_bool(), true);
|
||||
BOOST_CHECK_THROW(v2.get_int(), runtime_error);
|
||||
BOOST_CHECK_THROW(v2.get_int(), std::runtime_error);
|
||||
|
||||
UniValue v3;
|
||||
BOOST_CHECK(v3.setNumStr("32482348723847471234"));
|
||||
BOOST_CHECK_THROW(v3.get_int64(), runtime_error);
|
||||
BOOST_CHECK_THROW(v3.get_int64(), std::runtime_error);
|
||||
BOOST_CHECK(v3.setNumStr("1000"));
|
||||
BOOST_CHECK_EQUAL(v3.get_int64(), 1000);
|
||||
|
||||
UniValue v4;
|
||||
BOOST_CHECK(v4.setNumStr("2147483648"));
|
||||
BOOST_CHECK_EQUAL(v4.get_int64(), 2147483648);
|
||||
BOOST_CHECK_THROW(v4.get_int(), runtime_error);
|
||||
BOOST_CHECK_THROW(v4.get_int(), std::runtime_error);
|
||||
BOOST_CHECK(v4.setNumStr("1000"));
|
||||
BOOST_CHECK_EQUAL(v4.get_int(), 1000);
|
||||
BOOST_CHECK_THROW(v4.get_str(), runtime_error);
|
||||
BOOST_CHECK_THROW(v4.get_str(), std::runtime_error);
|
||||
BOOST_CHECK_EQUAL(v4.get_real(), 1000);
|
||||
BOOST_CHECK_THROW(v4.get_array(), runtime_error);
|
||||
BOOST_CHECK_THROW(v4.getKeys(), runtime_error);
|
||||
BOOST_CHECK_THROW(v4.getValues(), runtime_error);
|
||||
BOOST_CHECK_THROW(v4.get_obj(), runtime_error);
|
||||
BOOST_CHECK_THROW(v4.get_array(), std::runtime_error);
|
||||
BOOST_CHECK_THROW(v4.getKeys(), std::runtime_error);
|
||||
BOOST_CHECK_THROW(v4.getValues(), std::runtime_error);
|
||||
BOOST_CHECK_THROW(v4.get_obj(), std::runtime_error);
|
||||
|
||||
UniValue v5;
|
||||
BOOST_CHECK(v5.read("[true, 10]"));
|
||||
BOOST_CHECK_NO_THROW(v5.get_array());
|
||||
std::vector<UniValue> vals = v5.getValues();
|
||||
BOOST_CHECK_THROW(vals[0].get_int(), runtime_error);
|
||||
BOOST_CHECK_THROW(vals[0].get_int(), std::runtime_error);
|
||||
BOOST_CHECK_EQUAL(vals[0].get_bool(), true);
|
||||
|
||||
BOOST_CHECK_EQUAL(vals[1].get_int(), 10);
|
||||
BOOST_CHECK_THROW(vals[1].get_bool(), runtime_error);
|
||||
BOOST_CHECK_THROW(vals[1].get_bool(), std::runtime_error);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(univalue_set)
|
||||
|
|
@ -172,13 +170,13 @@ BOOST_AUTO_TEST_CASE(univalue_array)
|
|||
UniValue v((int64_t)1023LL);
|
||||
BOOST_CHECK(arr.push_back(v));
|
||||
|
||||
string vStr("zippy");
|
||||
std::string vStr("zippy");
|
||||
BOOST_CHECK(arr.push_back(vStr));
|
||||
|
||||
const char *s = "pippy";
|
||||
BOOST_CHECK(arr.push_back(s));
|
||||
|
||||
vector<UniValue> vec;
|
||||
std::vector<UniValue> vec;
|
||||
v.setStr("boing");
|
||||
vec.push_back(v);
|
||||
|
||||
|
|
@ -206,7 +204,7 @@ BOOST_AUTO_TEST_CASE(univalue_array)
|
|||
BOOST_AUTO_TEST_CASE(univalue_object)
|
||||
{
|
||||
UniValue obj(UniValue::VOBJ);
|
||||
string strKey, strVal;
|
||||
std::string strKey, strVal;
|
||||
UniValue v;
|
||||
|
||||
strKey = "age";
|
||||
|
|
@ -266,7 +264,7 @@ BOOST_AUTO_TEST_CASE(univalue_object)
|
|||
|
||||
BOOST_CHECK(!obj.exists("nyuknyuknyuk"));
|
||||
|
||||
map<string, UniValue::VType> objTypes;
|
||||
std::map<std::string, UniValue::VType> objTypes;
|
||||
objTypes["age"] = UniValue::VNUM;
|
||||
objTypes["first"] = UniValue::VSTR;
|
||||
objTypes["last"] = UniValue::VSTR;
|
||||
|
|
@ -294,7 +292,7 @@ BOOST_AUTO_TEST_CASE(univalue_readwrite)
|
|||
UniValue v;
|
||||
BOOST_CHECK(v.read(json1));
|
||||
|
||||
string strJson1(json1);
|
||||
std::string strJson1(json1);
|
||||
BOOST_CHECK(v.read(strJson1));
|
||||
|
||||
BOOST_CHECK(v.isArray());
|
||||
|
|
@ -333,4 +331,3 @@ BOOST_AUTO_TEST_CASE(univalue_readwrite)
|
|||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
|
|
|
|||
|
|
@ -17,9 +17,7 @@
|
|||
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
extern map<string, string> mapArgs;
|
||||
extern std::map<std::string, std::string> mapArgs;
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(util_tests, BasicTestingSetup)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue