mirror of
https://github.com/AskDavis/Casinotest.git
synced 2026-01-06 05:09:46 -08:00
Version 1.1.0.0 update
This commit is contained in:
transcoder
@@ -16,10 +16,10 @@
|
||||
#include <stdint.h>
|
||||
|
||||
// Tests this internal-to-main.cpp method:
|
||||
extern bool AddOrphanTx(const CDataStream& vMsg);
|
||||
extern bool AddOrphanTx(const CTransaction& tx);
|
||||
extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
|
||||
extern std::map<uint256, CDataStream*> mapOrphanTransactions;
|
||||
extern std::map<uint256, std::map<uint256, CDataStream*> > mapOrphanTransactionsByPrev;
|
||||
extern std::map<uint256, CTransaction> mapOrphanTransactions;
|
||||
extern std::map<uint256, std::set<uint256> > mapOrphanTransactionsByPrev;
|
||||
|
||||
CService ip(uint32_t i)
|
||||
{
|
||||
@@ -37,7 +37,7 @@ BOOST_AUTO_TEST_CASE(DoS_banning)
|
||||
CNode dummyNode1(INVALID_SOCKET, addr1, "", true);
|
||||
dummyNode1.Misbehaving(100); // Should get banned
|
||||
BOOST_CHECK(CNode::IsBanned(addr1));
|
||||
BOOST_CHECK(!CNode::IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different ip, not banned
|
||||
BOOST_CHECK(!CNode::IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different IP, not banned
|
||||
|
||||
CAddress addr2(ip(0xa0b0c002));
|
||||
CNode dummyNode2(INVALID_SOCKET, addr2, "", true);
|
||||
@@ -46,7 +46,7 @@ BOOST_AUTO_TEST_CASE(DoS_banning)
|
||||
BOOST_CHECK(CNode::IsBanned(addr1)); // ... but 1 still should be
|
||||
dummyNode2.Misbehaving(50);
|
||||
BOOST_CHECK(CNode::IsBanned(addr2));
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(DoS_banscore)
|
||||
{
|
||||
@@ -99,7 +99,7 @@ BOOST_AUTO_TEST_CASE(DoS_checknbits)
|
||||
{
|
||||
using namespace boost::assign; // for 'map_list_of()'
|
||||
|
||||
// Timestamps,nBits from the bitcoin blockchain.
|
||||
// Timestamps,nBits from the bitcoin block chain.
|
||||
// These are the block-chain checkpoint blocks
|
||||
typedef std::map<int64, unsigned int> BlockData;
|
||||
BlockData chainData =
|
||||
@@ -129,19 +129,15 @@ BOOST_AUTO_TEST_CASE(DoS_checknbits)
|
||||
|
||||
// ... but OK if enough time passed for difficulty to adjust downward:
|
||||
BOOST_CHECK(CheckNBits(firstcheck.second, lastcheck.first+60*60*24*365*4, lastcheck.second, lastcheck.first));
|
||||
|
||||
}
|
||||
|
||||
CTransaction RandomOrphan()
|
||||
{
|
||||
std::map<uint256, CDataStream*>::iterator it;
|
||||
std::map<uint256, CTransaction>::iterator it;
|
||||
it = mapOrphanTransactions.lower_bound(GetRandHash());
|
||||
if (it == mapOrphanTransactions.end())
|
||||
it = mapOrphanTransactions.begin();
|
||||
const CDataStream* pvMsg = it->second;
|
||||
CTransaction tx;
|
||||
CDataStream(*pvMsg) >> tx;
|
||||
return tx;
|
||||
return it->second;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
|
||||
@@ -163,9 +159,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
|
||||
tx.vout[0].nValue = 1*CENT;
|
||||
tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
|
||||
|
||||
CDataStream ds(SER_DISK, CLIENT_VERSION);
|
||||
ds << tx;
|
||||
AddOrphanTx(ds);
|
||||
AddOrphanTx(tx);
|
||||
}
|
||||
|
||||
// ... and 50 that depend on other orphans:
|
||||
@@ -182,9 +176,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
|
||||
tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
|
||||
SignSignature(keystore, txPrev, tx, 0);
|
||||
|
||||
CDataStream ds(SER_DISK, CLIENT_VERSION);
|
||||
ds << tx;
|
||||
AddOrphanTx(ds);
|
||||
AddOrphanTx(tx);
|
||||
}
|
||||
|
||||
// This really-big orphan should be ignored:
|
||||
@@ -208,9 +200,7 @@ BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
|
||||
for (unsigned int j = 1; j < tx.vin.size(); j++)
|
||||
tx.vin[j].scriptSig = tx.vin[0].scriptSig;
|
||||
|
||||
CDataStream ds(SER_DISK, CLIENT_VERSION);
|
||||
ds << tx;
|
||||
BOOST_CHECK(!AddOrphanTx(ds));
|
||||
BOOST_CHECK(!AddOrphanTx(tx));
|
||||
}
|
||||
|
||||
// Test LimitOrphanTxSize() function:
|
||||
@@ -231,6 +221,7 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
|
||||
key.MakeNewKey(true);
|
||||
CBasicKeyStore keystore;
|
||||
keystore.AddKey(key);
|
||||
unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
|
||||
|
||||
// 100 orphan transactions:
|
||||
static const int NPREV=100;
|
||||
@@ -246,9 +237,7 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
|
||||
tx.vout[0].nValue = 1*CENT;
|
||||
tx.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
|
||||
|
||||
CDataStream ds(SER_DISK, CLIENT_VERSION);
|
||||
ds << tx;
|
||||
AddOrphanTx(ds);
|
||||
AddOrphanTx(tx);
|
||||
}
|
||||
|
||||
// Create a transaction that depends on orphans:
|
||||
@@ -278,7 +267,7 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
|
||||
mst1 = boost::posix_time::microsec_clock::local_time();
|
||||
for (unsigned int i = 0; i < 5; i++)
|
||||
for (unsigned int j = 0; j < tx.vin.size(); j++)
|
||||
BOOST_CHECK(VerifySignature(orphans[j], tx, j, true, SIGHASH_ALL));
|
||||
BOOST_CHECK(VerifySignature(CCoins(orphans[j], MEMPOOL_HEIGHT), tx, j, flags, SIGHASH_ALL));
|
||||
mst2 = boost::posix_time::microsec_clock::local_time();
|
||||
msdiff = mst2 - mst1;
|
||||
long nManyValidate = msdiff.total_milliseconds();
|
||||
@@ -289,13 +278,13 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
|
||||
// Empty a signature, validation should fail:
|
||||
CScript save = tx.vin[0].scriptSig;
|
||||
tx.vin[0].scriptSig = CScript();
|
||||
BOOST_CHECK(!VerifySignature(orphans[0], tx, 0, true, SIGHASH_ALL));
|
||||
BOOST_CHECK(!VerifySignature(CCoins(orphans[0], MEMPOOL_HEIGHT), tx, 0, flags, SIGHASH_ALL));
|
||||
tx.vin[0].scriptSig = save;
|
||||
|
||||
// Swap signatures, validation should fail:
|
||||
std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig);
|
||||
BOOST_CHECK(!VerifySignature(orphans[0], tx, 0, true, SIGHASH_ALL));
|
||||
BOOST_CHECK(!VerifySignature(orphans[1], tx, 1, true, SIGHASH_ALL));
|
||||
BOOST_CHECK(!VerifySignature(CCoins(orphans[0], MEMPOOL_HEIGHT), tx, 0, flags, SIGHASH_ALL));
|
||||
BOOST_CHECK(!VerifySignature(CCoins(orphans[1], MEMPOOL_HEIGHT), tx, 1, flags, SIGHASH_ALL));
|
||||
std::swap(tx.vin[0].scriptSig, tx.vin[1].scriptSig);
|
||||
|
||||
// Exercise -maxsigcachesize code:
|
||||
@@ -305,7 +294,7 @@ BOOST_AUTO_TEST_CASE(DoS_checkSig)
|
||||
BOOST_CHECK(SignSignature(keystore, orphans[0], tx, 0));
|
||||
BOOST_CHECK(tx.vin[0].scriptSig != oldSig);
|
||||
for (unsigned int j = 0; j < tx.vin.size(); j++)
|
||||
BOOST_CHECK(VerifySignature(orphans[j], tx, j, true, SIGHASH_ALL));
|
||||
BOOST_CHECK(VerifySignature(CCoins(orphans[j], MEMPOOL_HEIGHT), tx, j, flags, SIGHASH_ALL));
|
||||
mapArgs.erase("-maxsigcachesize");
|
||||
|
||||
LimitOrphanTxSize(0);
|
||||
|
||||
123
src/test/accounting_tests.cpp
Normal file
123
src/test/accounting_tests.cpp
Normal file
@@ -0,0 +1,123 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include <boost/foreach.hpp>
|
||||
|
||||
#include "init.h"
|
||||
#include "wallet.h"
|
||||
#include "walletdb.h"
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(accounting_tests)
|
||||
|
||||
static void
|
||||
GetResults(CWalletDB& walletdb, std::map<int64, CAccountingEntry>& results)
|
||||
{
|
||||
std::list<CAccountingEntry> aes;
|
||||
|
||||
results.clear();
|
||||
BOOST_CHECK(walletdb.ReorderTransactions(pwalletMain) == DB_LOAD_OK);
|
||||
walletdb.ListAccountCreditDebit("", aes);
|
||||
BOOST_FOREACH(CAccountingEntry& ae, aes)
|
||||
{
|
||||
results[ae.nOrderPos] = ae;
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(acc_orderupgrade)
|
||||
{
|
||||
CWalletDB walletdb(pwalletMain->strWalletFile);
|
||||
std::vector<CWalletTx*> vpwtx;
|
||||
CWalletTx wtx;
|
||||
CAccountingEntry ae;
|
||||
std::map<int64, CAccountingEntry> results;
|
||||
|
||||
ae.strAccount = "";
|
||||
ae.nCreditDebit = 1;
|
||||
ae.nTime = 1333333333;
|
||||
ae.strOtherAccount = "b";
|
||||
ae.strComment = "";
|
||||
walletdb.WriteAccountingEntry(ae);
|
||||
|
||||
wtx.mapValue["comment"] = "z";
|
||||
pwalletMain->AddToWallet(wtx);
|
||||
vpwtx.push_back(&pwalletMain->mapWallet[wtx.GetHash()]);
|
||||
vpwtx[0]->nTimeReceived = (unsigned int)1333333335;
|
||||
vpwtx[0]->nOrderPos = -1;
|
||||
|
||||
ae.nTime = 1333333336;
|
||||
ae.strOtherAccount = "c";
|
||||
walletdb.WriteAccountingEntry(ae);
|
||||
|
||||
GetResults(walletdb, results);
|
||||
|
||||
BOOST_CHECK(pwalletMain->nOrderPosNext == 3);
|
||||
BOOST_CHECK(2 == results.size());
|
||||
BOOST_CHECK(results[0].nTime == 1333333333);
|
||||
BOOST_CHECK(results[0].strComment.empty());
|
||||
BOOST_CHECK(1 == vpwtx[0]->nOrderPos);
|
||||
BOOST_CHECK(results[2].nTime == 1333333336);
|
||||
BOOST_CHECK(results[2].strOtherAccount == "c");
|
||||
|
||||
|
||||
ae.nTime = 1333333330;
|
||||
ae.strOtherAccount = "d";
|
||||
ae.nOrderPos = pwalletMain->IncOrderPosNext();
|
||||
walletdb.WriteAccountingEntry(ae);
|
||||
|
||||
GetResults(walletdb, results);
|
||||
|
||||
BOOST_CHECK(results.size() == 3);
|
||||
BOOST_CHECK(pwalletMain->nOrderPosNext == 4);
|
||||
BOOST_CHECK(results[0].nTime == 1333333333);
|
||||
BOOST_CHECK(1 == vpwtx[0]->nOrderPos);
|
||||
BOOST_CHECK(results[2].nTime == 1333333336);
|
||||
BOOST_CHECK(results[3].nTime == 1333333330);
|
||||
BOOST_CHECK(results[3].strComment.empty());
|
||||
|
||||
|
||||
wtx.mapValue["comment"] = "y";
|
||||
--wtx.nLockTime; // Just to change the hash :)
|
||||
pwalletMain->AddToWallet(wtx);
|
||||
vpwtx.push_back(&pwalletMain->mapWallet[wtx.GetHash()]);
|
||||
vpwtx[1]->nTimeReceived = (unsigned int)1333333336;
|
||||
|
||||
wtx.mapValue["comment"] = "x";
|
||||
--wtx.nLockTime; // Just to change the hash :)
|
||||
pwalletMain->AddToWallet(wtx);
|
||||
vpwtx.push_back(&pwalletMain->mapWallet[wtx.GetHash()]);
|
||||
vpwtx[2]->nTimeReceived = (unsigned int)1333333329;
|
||||
vpwtx[2]->nOrderPos = -1;
|
||||
|
||||
GetResults(walletdb, results);
|
||||
|
||||
BOOST_CHECK(results.size() == 3);
|
||||
BOOST_CHECK(pwalletMain->nOrderPosNext == 6);
|
||||
BOOST_CHECK(0 == vpwtx[2]->nOrderPos);
|
||||
BOOST_CHECK(results[1].nTime == 1333333333);
|
||||
BOOST_CHECK(2 == vpwtx[0]->nOrderPos);
|
||||
BOOST_CHECK(results[3].nTime == 1333333336);
|
||||
BOOST_CHECK(results[4].nTime == 1333333330);
|
||||
BOOST_CHECK(results[4].strComment.empty());
|
||||
BOOST_CHECK(5 == vpwtx[1]->nOrderPos);
|
||||
|
||||
|
||||
ae.nTime = 1333333334;
|
||||
ae.strOtherAccount = "e";
|
||||
ae.nOrderPos = -1;
|
||||
walletdb.WriteAccountingEntry(ae);
|
||||
|
||||
GetResults(walletdb, results);
|
||||
|
||||
BOOST_CHECK(results.size() == 4);
|
||||
BOOST_CHECK(pwalletMain->nOrderPosNext == 7);
|
||||
BOOST_CHECK(0 == vpwtx[2]->nOrderPos);
|
||||
BOOST_CHECK(results[1].nTime == 1333333333);
|
||||
BOOST_CHECK(2 == vpwtx[0]->nOrderPos);
|
||||
BOOST_CHECK(results[3].nTime == 1333333336);
|
||||
BOOST_CHECK(results[3].strComment.empty());
|
||||
BOOST_CHECK(results[4].nTime == 1333333330);
|
||||
BOOST_CHECK(results[4].strComment.empty());
|
||||
BOOST_CHECK(results[5].nTime == 1333333334);
|
||||
BOOST_CHECK(6 == vpwtx[1]->nOrderPos);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
182
src/test/alert_tests.cpp
Normal file
182
src/test/alert_tests.cpp
Normal file
@@ -0,0 +1,182 @@
|
||||
//
|
||||
// Unit tests for alert system
|
||||
//
|
||||
|
||||
#include <boost/foreach.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <fstream>
|
||||
|
||||
#include "alert.h"
|
||||
#include "serialize.h"
|
||||
#include "util.h"
|
||||
|
||||
#if 0
|
||||
//
|
||||
// alertTests contains 7 alerts, generated with this code:
|
||||
// (SignAndSave code not shown, alert signing key is secret)
|
||||
//
|
||||
{
|
||||
CAlert alert;
|
||||
alert.nRelayUntil = 60;
|
||||
alert.nExpiration = 24 * 60 * 60;
|
||||
alert.nID = 1;
|
||||
alert.nCancel = 0; // cancels previous messages up to this ID number
|
||||
alert.nMinVer = 0; // These versions are protocol versions
|
||||
alert.nMaxVer = 70001;
|
||||
alert.nPriority = 1;
|
||||
alert.strComment = "Alert comment";
|
||||
alert.strStatusBar = "Alert 1";
|
||||
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
alert.setSubVer.insert(std::string("/Satoshi:0.1.0/"));
|
||||
alert.strStatusBar = "Alert 1 for Satoshi 0.1.0";
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
alert.setSubVer.insert(std::string("/Satoshi:0.2.0/"));
|
||||
alert.strStatusBar = "Alert 1 for Satoshi 0.1.0, 0.2.0";
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
alert.setSubVer.clear();
|
||||
++alert.nID;
|
||||
alert.nCancel = 1;
|
||||
alert.nPriority = 100;
|
||||
alert.strStatusBar = "Alert 2, cancels 1";
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
alert.nExpiration += 60;
|
||||
++alert.nID;
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
++alert.nID;
|
||||
alert.nMinVer = 11;
|
||||
alert.nMaxVer = 22;
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
++alert.nID;
|
||||
alert.strStatusBar = "Alert 2 for Satoshi 0.1.0";
|
||||
alert.setSubVer.insert(std::string("/Satoshi:0.1.0/"));
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
|
||||
++alert.nID;
|
||||
alert.nMinVer = 0;
|
||||
alert.nMaxVer = 999999;
|
||||
alert.strStatusBar = "Evil Alert'; /bin/ls; echo '";
|
||||
alert.setSubVer.clear();
|
||||
SignAndSave(alert, "test/alertTests");
|
||||
}
|
||||
#endif
|
||||
|
||||
struct ReadAlerts
|
||||
{
|
||||
ReadAlerts()
|
||||
{
|
||||
std::string filename("alertTests");
|
||||
namespace fs = boost::filesystem;
|
||||
fs::path testFile = fs::current_path() / "test" / "data" / filename;
|
||||
#ifdef TEST_DATA_DIR
|
||||
if (!fs::exists(testFile))
|
||||
{
|
||||
testFile = fs::path(BOOST_PP_STRINGIZE(TEST_DATA_DIR)) / filename;
|
||||
}
|
||||
#endif
|
||||
FILE* fp = fopen(testFile.string().c_str(), "rb");
|
||||
if (!fp) return;
|
||||
|
||||
|
||||
CAutoFile filein = CAutoFile(fp, SER_DISK, CLIENT_VERSION);
|
||||
if (!filein) return;
|
||||
|
||||
try {
|
||||
while (!feof(filein))
|
||||
{
|
||||
CAlert alert;
|
||||
filein >> alert;
|
||||
alerts.push_back(alert);
|
||||
}
|
||||
}
|
||||
catch (std::exception) { }
|
||||
}
|
||||
~ReadAlerts() { }
|
||||
|
||||
static std::vector<std::string> read_lines(boost::filesystem::path filepath)
|
||||
{
|
||||
std::vector<std::string> result;
|
||||
|
||||
std::ifstream f(filepath.string().c_str());
|
||||
std::string line;
|
||||
while (std::getline(f,line))
|
||||
result.push_back(line);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
std::vector<CAlert> alerts;
|
||||
};
|
||||
|
||||
BOOST_FIXTURE_TEST_SUITE(Alert_tests, ReadAlerts)
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(AlertApplies)
|
||||
{
|
||||
SetMockTime(11);
|
||||
|
||||
BOOST_FOREACH(const CAlert& alert, alerts)
|
||||
{
|
||||
BOOST_CHECK(alert.CheckSignature());
|
||||
}
|
||||
// Matches:
|
||||
BOOST_CHECK(alerts[0].AppliesTo(1, ""));
|
||||
BOOST_CHECK(alerts[0].AppliesTo(70001, ""));
|
||||
BOOST_CHECK(alerts[0].AppliesTo(1, "/Satoshi:11.11.11/"));
|
||||
|
||||
BOOST_CHECK(alerts[1].AppliesTo(1, "/Satoshi:0.1.0/"));
|
||||
BOOST_CHECK(alerts[1].AppliesTo(70001, "/Satoshi:0.1.0/"));
|
||||
|
||||
BOOST_CHECK(alerts[2].AppliesTo(1, "/Satoshi:0.1.0/"));
|
||||
BOOST_CHECK(alerts[2].AppliesTo(1, "/Satoshi:0.2.0/"));
|
||||
|
||||
// Don't match:
|
||||
BOOST_CHECK(!alerts[0].AppliesTo(-1, ""));
|
||||
BOOST_CHECK(!alerts[0].AppliesTo(70002, ""));
|
||||
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(1, ""));
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(1, "Satoshi:0.1.0"));
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(1, "/Satoshi:0.1.0"));
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(1, "Satoshi:0.1.0/"));
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(-1, "/Satoshi:0.1.0/"));
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(70002, "/Satoshi:0.1.0/"));
|
||||
BOOST_CHECK(!alerts[1].AppliesTo(1, "/Satoshi:0.2.0/"));
|
||||
|
||||
BOOST_CHECK(!alerts[2].AppliesTo(1, "/Satoshi:0.3.0/"));
|
||||
|
||||
SetMockTime(0);
|
||||
}
|
||||
|
||||
|
||||
// This uses sh 'echo' to test the -alertnotify function, writing to a
|
||||
// /tmp file. So skip it on Windows:
|
||||
#ifndef WIN32
|
||||
BOOST_AUTO_TEST_CASE(AlertNotify)
|
||||
{
|
||||
SetMockTime(11);
|
||||
|
||||
boost::filesystem::path temp = GetTempPath() / "alertnotify.txt";
|
||||
boost::filesystem::remove(temp);
|
||||
|
||||
mapArgs["-alertnotify"] = std::string("echo %s >> ") + temp.string();
|
||||
|
||||
BOOST_FOREACH(CAlert alert, alerts)
|
||||
alert.ProcessAlert(false);
|
||||
|
||||
std::vector<std::string> r = read_lines(temp);
|
||||
BOOST_CHECK_EQUAL(r.size(), 1u);
|
||||
BOOST_CHECK_EQUAL(r[0], "Evil Alert; /bin/ls; echo "); // single-quotes should be removed
|
||||
|
||||
boost::filesystem::remove(temp);
|
||||
|
||||
SetMockTime(0);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
115
src/test/allocator_tests.cpp
Normal file
115
src/test/allocator_tests.cpp
Normal file
@@ -0,0 +1,115 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include "init.h"
|
||||
#include "main.h"
|
||||
#include "util.h"
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(allocator_tests)
|
||||
|
||||
// Dummy memory page locker for platform independent tests
|
||||
static const void *last_lock_addr, *last_unlock_addr;
|
||||
static size_t last_lock_len, last_unlock_len;
|
||||
class TestLocker
|
||||
{
|
||||
public:
|
||||
bool Lock(const void *addr, size_t len)
|
||||
{
|
||||
last_lock_addr = addr;
|
||||
last_lock_len = len;
|
||||
return true;
|
||||
}
|
||||
bool Unlock(const void *addr, size_t len)
|
||||
{
|
||||
last_unlock_addr = addr;
|
||||
last_unlock_len = len;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_LockedPageManagerBase)
|
||||
{
|
||||
const size_t test_page_size = 4096;
|
||||
LockedPageManagerBase<TestLocker> lpm(test_page_size);
|
||||
size_t addr;
|
||||
last_lock_addr = last_unlock_addr = 0;
|
||||
last_lock_len = last_unlock_len = 0;
|
||||
|
||||
/* Try large number of small objects */
|
||||
addr = 0;
|
||||
for(int i=0; i<1000; ++i)
|
||||
{
|
||||
lpm.LockRange(reinterpret_cast<void*>(addr), 33);
|
||||
addr += 33;
|
||||
}
|
||||
/* Try small number of page-sized objects, straddling two pages */
|
||||
addr = test_page_size*100 + 53;
|
||||
for(int i=0; i<100; ++i)
|
||||
{
|
||||
lpm.LockRange(reinterpret_cast<void*>(addr), test_page_size);
|
||||
addr += test_page_size;
|
||||
}
|
||||
/* Try small number of page-sized objects aligned to exactly one page */
|
||||
addr = test_page_size*300;
|
||||
for(int i=0; i<100; ++i)
|
||||
{
|
||||
lpm.LockRange(reinterpret_cast<void*>(addr), test_page_size);
|
||||
addr += test_page_size;
|
||||
}
|
||||
/* one very large object, straddling pages */
|
||||
lpm.LockRange(reinterpret_cast<void*>(test_page_size*600+1), test_page_size*500);
|
||||
BOOST_CHECK(last_lock_addr == reinterpret_cast<void*>(test_page_size*(600+500)));
|
||||
/* one very large object, page aligned */
|
||||
lpm.LockRange(reinterpret_cast<void*>(test_page_size*1200), test_page_size*500-1);
|
||||
BOOST_CHECK(last_lock_addr == reinterpret_cast<void*>(test_page_size*(1200+500-1)));
|
||||
|
||||
BOOST_CHECK(lpm.GetLockedPageCount() == (
|
||||
(1000*33+test_page_size-1)/test_page_size + // small objects
|
||||
101 + 100 + // page-sized objects
|
||||
501 + 500)); // large objects
|
||||
BOOST_CHECK((last_lock_len & (test_page_size-1)) == 0); // always lock entire pages
|
||||
BOOST_CHECK(last_unlock_len == 0); // nothing unlocked yet
|
||||
|
||||
/* And unlock again */
|
||||
addr = 0;
|
||||
for(int i=0; i<1000; ++i)
|
||||
{
|
||||
lpm.UnlockRange(reinterpret_cast<void*>(addr), 33);
|
||||
addr += 33;
|
||||
}
|
||||
addr = test_page_size*100 + 53;
|
||||
for(int i=0; i<100; ++i)
|
||||
{
|
||||
lpm.UnlockRange(reinterpret_cast<void*>(addr), test_page_size);
|
||||
addr += test_page_size;
|
||||
}
|
||||
addr = test_page_size*300;
|
||||
for(int i=0; i<100; ++i)
|
||||
{
|
||||
lpm.UnlockRange(reinterpret_cast<void*>(addr), test_page_size);
|
||||
addr += test_page_size;
|
||||
}
|
||||
lpm.UnlockRange(reinterpret_cast<void*>(test_page_size*600+1), test_page_size*500);
|
||||
lpm.UnlockRange(reinterpret_cast<void*>(test_page_size*1200), test_page_size*500-1);
|
||||
|
||||
/* Check that everything is released */
|
||||
BOOST_CHECK(lpm.GetLockedPageCount() == 0);
|
||||
|
||||
/* A few and unlocks of size zero (should have no effect) */
|
||||
addr = 0;
|
||||
for(int i=0; i<1000; ++i)
|
||||
{
|
||||
lpm.LockRange(reinterpret_cast<void*>(addr), 0);
|
||||
addr += 1;
|
||||
}
|
||||
BOOST_CHECK(lpm.GetLockedPageCount() == 0);
|
||||
addr = 0;
|
||||
for(int i=0; i<1000; ++i)
|
||||
{
|
||||
lpm.UnlockRange(reinterpret_cast<void*>(addr), 0);
|
||||
addr += 1;
|
||||
}
|
||||
BOOST_CHECK(lpm.GetLockedPageCount() == 0);
|
||||
BOOST_CHECK((last_unlock_len & (test_page_size-1)) == 0); // always unlock entire pages
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
@@ -1,87 +1,261 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include "json/json_spirit_reader_template.h"
|
||||
#include "json/json_spirit_writer_template.h"
|
||||
#include "json/json_spirit_utils.h"
|
||||
|
||||
#include "base58.h"
|
||||
#include "util.h"
|
||||
|
||||
using namespace json_spirit;
|
||||
extern Array read_json(const std::string& filename);
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(base58_tests)
|
||||
|
||||
// TODO:
|
||||
// EncodeBase58Check
|
||||
// DecodeBase58Check
|
||||
// CBase58Data
|
||||
// bool SetString(const char* psz)
|
||||
// bool SetString(const std::string& str)
|
||||
// std::string ToString() const
|
||||
// int CompareTo(const CBase58Data& b58) const
|
||||
// bool operator==(const CBase58Data& b58) const
|
||||
// bool operator<=(const CBase58Data& b58) const
|
||||
// bool operator>=(const CBase58Data& b58) const
|
||||
// bool operator< (const CBase58Data& b58) const
|
||||
// bool operator> (const CBase58Data& b58) const
|
||||
|
||||
// CBitcoinAddress
|
||||
// bool SetHash160(const uint160& hash160)
|
||||
// bool SetPubKey(const std::vector<unsigned char>& vchPubKey)
|
||||
// bool IsValid() const
|
||||
// CBitcoinAddress()
|
||||
// CBitcoinAddress(uint160 hash160In)
|
||||
// CBitcoinAddress(const std::vector<unsigned char>& vchPubKey)
|
||||
// CBitcoinAddress(const std::string& strAddress)
|
||||
// CBitcoinAddress(const char* pszAddress)
|
||||
// uint160 GetHash160() const
|
||||
|
||||
#define U(x) (reinterpret_cast<const unsigned char*>(x))
|
||||
static struct {
|
||||
const unsigned char *data;
|
||||
int size;
|
||||
} vstrIn[] = {
|
||||
{U(""), 0},
|
||||
{U("\x61"), 1},
|
||||
{U("\x62\x62\x62"), 3},
|
||||
{U("\x63\x63\x63"), 3},
|
||||
{U("\x73\x69\x6d\x70\x6c\x79\x20\x61\x20\x6c\x6f\x6e\x67\x20\x73\x74\x72\x69\x6e\x67"), 20},
|
||||
{U("\x00\xeb\x15\x23\x1d\xfc\xeb\x60\x92\x58\x86\xb6\x7d\x06\x52\x99\x92\x59\x15\xae\xb1\x72\xc0\x66\x47"), 25},
|
||||
{U("\x51\x6b\x6f\xcd\x0f"), 5},
|
||||
{U("\xbf\x4f\x89\x00\x1e\x67\x02\x74\xdd"), 9},
|
||||
{U("\x57\x2e\x47\x94"), 4},
|
||||
{U("\xec\xac\x89\xca\xd9\x39\x23\xc0\x23\x21"), 10},
|
||||
{U("\x10\xc8\x51\x1e"), 4},
|
||||
{U("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), 10},
|
||||
};
|
||||
|
||||
const char *vstrOut[] = {
|
||||
"",
|
||||
"2g",
|
||||
"a3gV",
|
||||
"aPEr",
|
||||
"2cFupjhnEsSn59qHXstmK2ffpLv2",
|
||||
"1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L",
|
||||
"ABnLTmg",
|
||||
"3SEo3LWLoPntC",
|
||||
"3EFU7m",
|
||||
"EJDM8drfXA6uyA",
|
||||
"Rt5zm",
|
||||
"1111111111"
|
||||
};
|
||||
|
||||
// Goal: test low-level base58 encoding functionality
|
||||
BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
|
||||
{
|
||||
for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
|
||||
Array tests = read_json("base58_encode_decode.json");
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(EncodeBase58(vstrIn[i].data, vstrIn[i].data + vstrIn[i].size), vstrOut[i]);
|
||||
Array test = tv.get_array();
|
||||
std::string strTest = write_string(tv, false);
|
||||
if (test.size() < 2) // Allow for extra stuff (useful for comments)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
std::vector<unsigned char> sourcedata = ParseHex(test[0].get_str());
|
||||
std::string base58string = test[1].get_str();
|
||||
BOOST_CHECK_MESSAGE(
|
||||
EncodeBase58(&sourcedata[0], &sourcedata[sourcedata.size()]) == base58string,
|
||||
strTest);
|
||||
}
|
||||
}
|
||||
|
||||
// Goal: test low-level base58 decoding functionality
|
||||
BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
|
||||
{
|
||||
Array tests = read_json("base58_encode_decode.json");
|
||||
std::vector<unsigned char> result;
|
||||
for (unsigned int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
std::vector<unsigned char> expected(vstrIn[i].data, vstrIn[i].data + vstrIn[i].size);
|
||||
BOOST_CHECK(DecodeBase58(vstrOut[i], result));
|
||||
BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
|
||||
Array test = tv.get_array();
|
||||
std::string strTest = write_string(tv, false);
|
||||
if (test.size() < 2) // Allow for extra stuff (useful for comments)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
std::vector<unsigned char> expected = ParseHex(test[0].get_str());
|
||||
std::string base58string = test[1].get_str();
|
||||
BOOST_CHECK_MESSAGE(DecodeBase58(base58string, result), strTest);
|
||||
BOOST_CHECK_MESSAGE(result.size() == expected.size() && std::equal(result.begin(), result.end(), expected.begin()), strTest);
|
||||
}
|
||||
|
||||
BOOST_CHECK(!DecodeBase58("invalid", result));
|
||||
}
|
||||
|
||||
// Visitor to check address type
|
||||
class TestAddrTypeVisitor : public boost::static_visitor<bool>
|
||||
{
|
||||
private:
|
||||
std::string exp_addrType;
|
||||
public:
|
||||
TestAddrTypeVisitor(const std::string &exp_addrType) : exp_addrType(exp_addrType) { }
|
||||
bool operator()(const CKeyID &id) const
|
||||
{
|
||||
return (exp_addrType == "pubkey");
|
||||
}
|
||||
bool operator()(const CScriptID &id) const
|
||||
{
|
||||
return (exp_addrType == "script");
|
||||
}
|
||||
bool operator()(const CNoDestination &no) const
|
||||
{
|
||||
return (exp_addrType == "none");
|
||||
}
|
||||
};
|
||||
|
||||
// Visitor to check address payload
|
||||
class TestPayloadVisitor : public boost::static_visitor<bool>
|
||||
{
|
||||
private:
|
||||
std::vector<unsigned char> exp_payload;
|
||||
public:
|
||||
TestPayloadVisitor(std::vector<unsigned char> &exp_payload) : exp_payload(exp_payload) { }
|
||||
bool operator()(const CKeyID &id) const
|
||||
{
|
||||
uint160 exp_key(exp_payload);
|
||||
return exp_key == id;
|
||||
}
|
||||
bool operator()(const CScriptID &id) const
|
||||
{
|
||||
uint160 exp_key(exp_payload);
|
||||
return exp_key == id;
|
||||
}
|
||||
bool operator()(const CNoDestination &no) const
|
||||
{
|
||||
return exp_payload.size() == 0;
|
||||
}
|
||||
};
|
||||
|
||||
// Goal: check that parsed keys match test payload
|
||||
BOOST_AUTO_TEST_CASE(base58_keys_valid_parse)
|
||||
{
|
||||
Array tests = read_json("base58_keys_valid.json");
|
||||
std::vector<unsigned char> result;
|
||||
CBitcoinSecret secret;
|
||||
CBitcoinAddress addr;
|
||||
// Save global state
|
||||
bool fTestNet_stored = fTestNet;
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
Array test = tv.get_array();
|
||||
std::string strTest = write_string(tv, false);
|
||||
if (test.size() < 3) // Allow for extra stuff (useful for comments)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
std::string exp_base58string = test[0].get_str();
|
||||
std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
|
||||
const Object &metadata = test[2].get_obj();
|
||||
bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
|
||||
bool isTestnet = find_value(metadata, "isTestnet").get_bool();
|
||||
fTestNet = isTestnet; // Override testnet flag
|
||||
if(isPrivkey)
|
||||
{
|
||||
bool isCompressed = find_value(metadata, "isCompressed").get_bool();
|
||||
// Must be valid private key
|
||||
// Note: CBitcoinSecret::SetString tests isValid, whereas CBitcoinAddress does not!
|
||||
BOOST_CHECK_MESSAGE(secret.SetString(exp_base58string), "!SetString:"+ strTest);
|
||||
BOOST_CHECK_MESSAGE(secret.IsValid(), "!IsValid:" + strTest);
|
||||
CKey privkey = secret.GetKey();
|
||||
BOOST_CHECK_MESSAGE(privkey.IsCompressed() == isCompressed, "compressed mismatch:" + strTest);
|
||||
BOOST_CHECK_MESSAGE(privkey.size() == exp_payload.size() && std::equal(privkey.begin(), privkey.end(), exp_payload.begin()), "key mismatch:" + strTest);
|
||||
|
||||
// Private key must be invalid public key
|
||||
addr.SetString(exp_base58string);
|
||||
BOOST_CHECK_MESSAGE(!addr.IsValid(), "IsValid privkey as pubkey:" + strTest);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string exp_addrType = find_value(metadata, "addrType").get_str(); // "script" or "pubkey"
|
||||
// Must be valid public key
|
||||
BOOST_CHECK_MESSAGE(addr.SetString(exp_base58string), "SetString:" + strTest);
|
||||
BOOST_CHECK_MESSAGE(addr.IsValid(), "!IsValid:" + strTest);
|
||||
BOOST_CHECK_MESSAGE(addr.IsScript() == (exp_addrType == "script"), "isScript mismatch" + strTest);
|
||||
CTxDestination dest = addr.Get();
|
||||
BOOST_CHECK_MESSAGE(boost::apply_visitor(TestAddrTypeVisitor(exp_addrType), dest), "addrType mismatch" + strTest);
|
||||
|
||||
// Public key must be invalid private key
|
||||
secret.SetString(exp_base58string);
|
||||
BOOST_CHECK_MESSAGE(!secret.IsValid(), "IsValid pubkey as privkey:" + strTest);
|
||||
}
|
||||
}
|
||||
// Restore global state
|
||||
fTestNet = fTestNet_stored;
|
||||
}
|
||||
|
||||
// Goal: check that generated keys match test vectors
|
||||
BOOST_AUTO_TEST_CASE(base58_keys_valid_gen)
|
||||
{
|
||||
Array tests = read_json("base58_keys_valid.json");
|
||||
std::vector<unsigned char> result;
|
||||
// Save global state
|
||||
bool fTestNet_stored = fTestNet;
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
Array test = tv.get_array();
|
||||
std::string strTest = write_string(tv, false);
|
||||
if (test.size() < 3) // Allow for extra stuff (useful for comments)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
std::string exp_base58string = test[0].get_str();
|
||||
std::vector<unsigned char> exp_payload = ParseHex(test[1].get_str());
|
||||
const Object &metadata = test[2].get_obj();
|
||||
bool isPrivkey = find_value(metadata, "isPrivkey").get_bool();
|
||||
bool isTestnet = find_value(metadata, "isTestnet").get_bool();
|
||||
fTestNet = isTestnet; // Override testnet flag
|
||||
if(isPrivkey)
|
||||
{
|
||||
bool isCompressed = find_value(metadata, "isCompressed").get_bool();
|
||||
CKey key;
|
||||
key.Set(exp_payload.begin(), exp_payload.end(), isCompressed);
|
||||
assert(key.IsValid());
|
||||
CBitcoinSecret secret;
|
||||
secret.SetKey(key);
|
||||
BOOST_CHECK_MESSAGE(secret.ToString() == exp_base58string, "result mismatch: " + strTest);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::string exp_addrType = find_value(metadata, "addrType").get_str();
|
||||
CTxDestination dest;
|
||||
if(exp_addrType == "pubkey")
|
||||
{
|
||||
dest = CKeyID(uint160(exp_payload));
|
||||
}
|
||||
else if(exp_addrType == "script")
|
||||
{
|
||||
dest = CScriptID(uint160(exp_payload));
|
||||
}
|
||||
else if(exp_addrType == "none")
|
||||
{
|
||||
dest = CNoDestination();
|
||||
}
|
||||
else
|
||||
{
|
||||
BOOST_ERROR("Bad addrtype: " << strTest);
|
||||
continue;
|
||||
}
|
||||
CBitcoinAddress addrOut;
|
||||
BOOST_CHECK_MESSAGE(boost::apply_visitor(CBitcoinAddressVisitor(&addrOut), dest), "encode dest: " + strTest);
|
||||
BOOST_CHECK_MESSAGE(addrOut.ToString() == exp_base58string, "mismatch: " + strTest);
|
||||
}
|
||||
}
|
||||
|
||||
// Visiting a CNoDestination must fail
|
||||
CBitcoinAddress dummyAddr;
|
||||
CTxDestination nodest = CNoDestination();
|
||||
BOOST_CHECK(!boost::apply_visitor(CBitcoinAddressVisitor(&dummyAddr), nodest));
|
||||
|
||||
// Restore global state
|
||||
fTestNet = fTestNet_stored;
|
||||
}
|
||||
|
||||
// Goal: check that base58 parsing code is robust against a variety of corrupted data
|
||||
BOOST_AUTO_TEST_CASE(base58_keys_invalid)
|
||||
{
|
||||
Array tests = read_json("base58_keys_invalid.json"); // Negative testcases
|
||||
std::vector<unsigned char> result;
|
||||
CBitcoinSecret secret;
|
||||
CBitcoinAddress addr;
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
Array test = tv.get_array();
|
||||
std::string strTest = write_string(tv, false);
|
||||
if (test.size() < 1) // Allow for extra stuff (useful for comments)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
std::string exp_base58string = test[0].get_str();
|
||||
|
||||
// must be invalid as public and as private key
|
||||
addr.SetString(exp_base58string);
|
||||
BOOST_CHECK_MESSAGE(!addr.IsValid(), "IsValid pubkey:" + strTest);
|
||||
secret.SetString(exp_base58string);
|
||||
BOOST_CHECK_MESSAGE(!secret.IsValid(), "IsValid privkey:" + strTest);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
|
||||
@@ -12,8 +12,8 @@ BOOST_AUTO_TEST_SUITE(bignum_tests)
|
||||
// You should use it like this:
|
||||
// NOINLINE void function() {...}
|
||||
#if defined(__GNUC__)
|
||||
// This also works and will be defined for any compiler implementing gcc
|
||||
// extensions, such as clang and icc.
|
||||
// This also works and will be defined for any compiler implementing GCC
|
||||
// extensions, such as Clang and ICC.
|
||||
#define NOINLINE __attribute__((noinline))
|
||||
#elif defined(_MSC_VER)
|
||||
#define NOINLINE __declspec(noinline)
|
||||
@@ -48,7 +48,7 @@ BOOST_AUTO_TEST_SUITE(bignum_tests)
|
||||
// that -ftrapv will detect overflows.
|
||||
NOINLINE void mysetint64(CBigNum& num, int64 n)
|
||||
{
|
||||
num.setint64(n);
|
||||
num.setint64(n);
|
||||
}
|
||||
|
||||
// For each number, we do 2 tests: one with inline code, then we reset the
|
||||
@@ -122,4 +122,57 @@ BOOST_AUTO_TEST_CASE(bignum_setint64)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(bignum_SetCompact)
|
||||
{
|
||||
CBigNum num;
|
||||
num.SetCompact(0);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "0");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
|
||||
|
||||
num.SetCompact(0x00123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "0");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
|
||||
|
||||
num.SetCompact(0x01123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "12");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x01120000U);
|
||||
|
||||
// Make sure that we don't generate compacts with the 0x00800000 bit set
|
||||
num = 0x80;
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x02008000U);
|
||||
|
||||
num.SetCompact(0x01fedcba);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "-7e");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x01fe0000U);
|
||||
|
||||
num.SetCompact(0x02123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "1234");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x02123400U);
|
||||
|
||||
num.SetCompact(0x03123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "123456");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x03123456U);
|
||||
|
||||
num.SetCompact(0x04123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "12345600");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x04123456U);
|
||||
|
||||
num.SetCompact(0x04923456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "-12345600");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x04923456U);
|
||||
|
||||
num.SetCompact(0x05009234);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "92340000");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x05009234U);
|
||||
|
||||
num.SetCompact(0x20123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "1234560000000000000000000000000000000000000000000000000000000000");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0x20123456U);
|
||||
|
||||
num.SetCompact(0xff123456);
|
||||
BOOST_CHECK_EQUAL(num.GetHex(), "123456000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
|
||||
BOOST_CHECK_EQUAL(num.GetCompact(), 0xff123456U);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
446
src/test/bloom_tests.cpp
Normal file
446
src/test/bloom_tests.cpp
Normal file
File diff suppressed because one or more lines are too long
87
src/test/canonical_tests.cpp
Normal file
87
src/test/canonical_tests.cpp
Normal file
@@ -0,0 +1,87 @@
|
||||
//
|
||||
// Unit tests for canonical signatures
|
||||
|
||||
#include "json/json_spirit_writer_template.h"
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <openssl/ecdsa.h>
|
||||
|
||||
#include "key.h"
|
||||
#include "script.h"
|
||||
#include "util.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace json_spirit;
|
||||
|
||||
|
||||
// In script_tests.cpp
|
||||
extern Array read_json(const std::string& filename);
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(canonical_tests)
|
||||
|
||||
// OpenSSL-based test for canonical signature (without test for hashtype byte)
|
||||
bool static IsCanonicalSignature_OpenSSL_inner(const std::vector<unsigned char>& vchSig)
|
||||
{
|
||||
if (vchSig.size() == 0)
|
||||
return false;
|
||||
const unsigned char *input = &vchSig[0];
|
||||
ECDSA_SIG *psig = NULL;
|
||||
d2i_ECDSA_SIG(&psig, &input, vchSig.size());
|
||||
if (psig == NULL)
|
||||
return false;
|
||||
unsigned char buf[256];
|
||||
unsigned char *pbuf = buf;
|
||||
unsigned int nLen = i2d_ECDSA_SIG(psig, NULL);
|
||||
if (nLen != vchSig.size()) {
|
||||
ECDSA_SIG_free(psig);
|
||||
return false;
|
||||
}
|
||||
nLen = i2d_ECDSA_SIG(psig, &pbuf);
|
||||
ECDSA_SIG_free(psig);
|
||||
return (memcmp(&vchSig[0], &buf[0], nLen) == 0);
|
||||
}
|
||||
|
||||
// OpenSSL-based test for canonical signature
|
||||
bool static IsCanonicalSignature_OpenSSL(const std::vector<unsigned char> &vchSignature) {
|
||||
if (vchSignature.size() < 1)
|
||||
return false;
|
||||
if (vchSignature.size() > 127)
|
||||
return false;
|
||||
if (vchSignature[vchSignature.size() - 1] & 0x7C)
|
||||
return false;
|
||||
|
||||
std::vector<unsigned char> vchSig(vchSignature);
|
||||
vchSig.pop_back();
|
||||
if (!IsCanonicalSignature_OpenSSL_inner(vchSig))
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(script_canon)
|
||||
{
|
||||
Array tests = read_json("sig_canonical.json");
|
||||
|
||||
BOOST_FOREACH(Value &tv, tests) {
|
||||
string test = tv.get_str();
|
||||
if (IsHex(test)) {
|
||||
std::vector<unsigned char> sig = ParseHex(test);
|
||||
BOOST_CHECK_MESSAGE(IsCanonicalSignature(sig), test);
|
||||
BOOST_CHECK_MESSAGE(IsCanonicalSignature_OpenSSL(sig), test);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(script_noncanon)
|
||||
{
|
||||
Array tests = read_json("sig_noncanonical.json");
|
||||
|
||||
BOOST_FOREACH(Value &tv, tests) {
|
||||
string test = tv.get_str();
|
||||
if (IsHex(test)) {
|
||||
std::vector<unsigned char> sig = ParseHex(test);
|
||||
BOOST_CHECK_MESSAGE(!IsCanonicalSignature(sig), test);
|
||||
BOOST_CHECK_MESSAGE(!IsCanonicalSignature_OpenSSL(sig), test);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
66
src/test/checkblock_tests.cpp
Normal file
66
src/test/checkblock_tests.cpp
Normal file
@@ -0,0 +1,66 @@
|
||||
//
|
||||
// Unit tests for block.CheckBlock()
|
||||
//
|
||||
#include <algorithm>
|
||||
|
||||
#include <boost/assign/list_of.hpp> // for 'map_list_of()'
|
||||
#include <boost/date_time/posix_time/posix_time_types.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/foreach.hpp>
|
||||
|
||||
#include "main.h"
|
||||
#include "wallet.h"
|
||||
#include "net.h"
|
||||
#include "util.h"
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(CheckBlock_tests)
|
||||
|
||||
bool
|
||||
read_block(const std::string& filename, CBlock& block)
|
||||
{
|
||||
namespace fs = boost::filesystem;
|
||||
fs::path testFile = fs::current_path() / "test" / "data" / filename;
|
||||
#ifdef TEST_DATA_DIR
|
||||
if (!fs::exists(testFile))
|
||||
{
|
||||
testFile = fs::path(BOOST_PP_STRINGIZE(TEST_DATA_DIR)) / filename;
|
||||
}
|
||||
#endif
|
||||
FILE* fp = fopen(testFile.string().c_str(), "rb");
|
||||
if (!fp) return false;
|
||||
|
||||
fseek(fp, 8, SEEK_SET); // skip msgheader/size
|
||||
|
||||
CAutoFile filein = CAutoFile(fp, SER_DISK, CLIENT_VERSION);
|
||||
if (!filein) return false;
|
||||
|
||||
filein >> block;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(May15)
|
||||
{
|
||||
// Putting a 1MB binary file in the git repository is not a great
|
||||
// idea, so this test is only run if you manually download
|
||||
// test/data/Mar12Fork.dat from
|
||||
// http://sourceforge.net/projects/bitcoin/files/Bitcoin/blockchain/Mar12Fork.dat/download
|
||||
unsigned int tMay15 = 1368576000;
|
||||
SetMockTime(tMay15); // Test as if it was right at May 15
|
||||
|
||||
CBlock forkingBlock;
|
||||
if (read_block("Mar12Fork.dat", forkingBlock))
|
||||
{
|
||||
CValidationState state;
|
||||
forkingBlock.nTime = tMay15-1; // Invalidates PoW
|
||||
BOOST_CHECK(!forkingBlock.CheckBlock(state, false, false));
|
||||
|
||||
// After May 15'th, big blocks are OK:
|
||||
forkingBlock.nTime = tMay15; // Invalidates PoW
|
||||
BOOST_CHECK(forkingBlock.CheckBlock(state, false, false));
|
||||
}
|
||||
|
||||
SetMockTime(0);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
62
src/test/compress_tests.cpp
Normal file
62
src/test/compress_tests.cpp
Normal file
@@ -0,0 +1,62 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "main.h"
|
||||
|
||||
// amounts 0.00000001 .. 0.00100000
|
||||
#define NUM_MULTIPLES_UNIT 100000
|
||||
|
||||
// amounts 0.01 .. 100.00
|
||||
#define NUM_MULTIPLES_CENT 10000
|
||||
|
||||
// amounts 1 .. 10000
|
||||
#define NUM_MULTIPLES_1BTC 10000
|
||||
|
||||
// amounts 50 .. 21000000
|
||||
#define NUM_MULTIPLES_50BTC 420000
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(compress_tests)
|
||||
|
||||
bool static TestEncode(uint64 in) {
|
||||
return in == CTxOutCompressor::DecompressAmount(CTxOutCompressor::CompressAmount(in));
|
||||
}
|
||||
|
||||
bool static TestDecode(uint64 in) {
|
||||
return in == CTxOutCompressor::CompressAmount(CTxOutCompressor::DecompressAmount(in));
|
||||
}
|
||||
|
||||
bool static TestPair(uint64 dec, uint64 enc) {
|
||||
return CTxOutCompressor::CompressAmount(dec) == enc &&
|
||||
CTxOutCompressor::DecompressAmount(enc) == dec;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(compress_amounts)
|
||||
{
|
||||
BOOST_CHECK(TestPair( 0, 0x0));
|
||||
BOOST_CHECK(TestPair( 1, 0x1));
|
||||
BOOST_CHECK(TestPair( CENT, 0x7));
|
||||
BOOST_CHECK(TestPair( COIN, 0x9));
|
||||
BOOST_CHECK(TestPair( 50*COIN, 0x32));
|
||||
BOOST_CHECK(TestPair(21000000*COIN, 0x1406f40));
|
||||
|
||||
for (uint64 i = 1; i <= NUM_MULTIPLES_UNIT; i++)
|
||||
BOOST_CHECK(TestEncode(i));
|
||||
|
||||
for (uint64 i = 1; i <= NUM_MULTIPLES_CENT; i++)
|
||||
BOOST_CHECK(TestEncode(i * CENT));
|
||||
|
||||
for (uint64 i = 1; i <= NUM_MULTIPLES_1BTC; i++)
|
||||
BOOST_CHECK(TestEncode(i * COIN));
|
||||
|
||||
for (uint64 i = 1; i <= NUM_MULTIPLES_50BTC; i++)
|
||||
BOOST_CHECK(TestEncode(i * 50 * COIN));
|
||||
|
||||
for (uint64 i = 0; i < 100000; i++)
|
||||
BOOST_CHECK(TestDecode(i));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
BIN
src/test/data/alertTests
Normal file
BIN
src/test/data/alertTests
Normal file
Binary file not shown.
14
src/test/data/base58_encode_decode.json
Normal file
14
src/test/data/base58_encode_decode.json
Normal file
@@ -0,0 +1,14 @@
|
||||
[
|
||||
["", ""],
|
||||
["61", "2g"],
|
||||
["626262", "a3gV"],
|
||||
["636363", "aPEr"],
|
||||
["73696d706c792061206c6f6e6720737472696e67", "2cFupjhnEsSn59qHXstmK2ffpLv2"],
|
||||
["00eb15231dfceb60925886b67d065299925915aeb172c06647", "1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L"],
|
||||
["516b6fcd0f", "ABnLTmg"],
|
||||
["bf4f89001e670274dd", "3SEo3LWLoPntC"],
|
||||
["572e4794", "3EFU7m"],
|
||||
["ecac89cad93923c02321", "EJDM8drfXA6uyA"],
|
||||
["10c8511e", "Rt5zm"],
|
||||
["00000000000000000000", "1111111111"]
|
||||
]
|
||||
152
src/test/data/base58_keys_invalid.json
Normal file
152
src/test/data/base58_keys_invalid.json
Normal file
@@ -0,0 +1,152 @@
|
||||
[
|
||||
[
|
||||
""
|
||||
],
|
||||
[
|
||||
"x"
|
||||
],
|
||||
[
|
||||
"37qgekLpCCHrQuSjvX3fs496FWTGsHFHizjJAs6NPcR47aefnnCWECAhHV6E3g4YN7u7Yuwod5Y"
|
||||
],
|
||||
[
|
||||
"dzb7VV1Ui55BARxv7ATxAtCUeJsANKovDGWFVgpTbhq9gvPqP3yv"
|
||||
],
|
||||
[
|
||||
"MuNu7ZAEDFiHthiunm7dPjwKqrVNCM3mAz6rP9zFveQu14YA8CxExSJTHcVP9DErn6u84E6Ej7S"
|
||||
],
|
||||
[
|
||||
"rPpQpYknyNQ5AEHuY6H8ijJJrYc2nDKKk9jjmKEXsWzyAQcFGpDLU2Zvsmoi8JLR7hAwoy3RQWf"
|
||||
],
|
||||
[
|
||||
"4Uc3FmN6NQ6zLBK5QQBXRBUREaaHwCZYsGCueHauuDmJpZKn6jkEskMB2Zi2CNgtb5r6epWEFfUJq"
|
||||
],
|
||||
[
|
||||
"7aQgR5DFQ25vyXmqZAWmnVCjL3PkBcdVkBUpjrjMTcghHx3E8wb"
|
||||
],
|
||||
[
|
||||
"17QpPprjeg69fW1DV8DcYYCKvWjYhXvWkov6MJ1iTTvMFj6weAqW7wybZeH57WTNxXVCRH4veVs"
|
||||
],
|
||||
[
|
||||
"KxuACDviz8Xvpn1xAh9MfopySZNuyajYMZWz16Dv2mHHryznWUp3"
|
||||
],
|
||||
[
|
||||
"7nK3GSmqdXJQtdohvGfJ7KsSmn3TmGqExug49583bDAL91pVSGq5xS9SHoAYL3Wv3ijKTit65th"
|
||||
],
|
||||
[
|
||||
"cTivdBmq7bay3RFGEBBuNfMh2P1pDCgRYN2Wbxmgwr4ki3jNUL2va"
|
||||
],
|
||||
[
|
||||
"gjMV4vjNjyMrna4fsAr8bWxAbwtmMUBXJS3zL4NJt5qjozpbQLmAfK1uA3CquSqsZQMpoD1g2nk"
|
||||
],
|
||||
[
|
||||
"emXm1naBMoVzPjbk7xpeTVMFy4oDEe25UmoyGgKEB1gGWsK8kRGs"
|
||||
],
|
||||
[
|
||||
"7VThQnNRj1o3Zyvc7XHPRrjDf8j2oivPTeDXnRPYWeYGE4pXeRJDZgf28ppti5hsHWXS2GSobdqyo"
|
||||
],
|
||||
[
|
||||
"1G9u6oCVCPh2o8m3t55ACiYvG1y5BHewUkDSdiQarDcYXXhFHYdzMdYfUAhfxn5vNZBwpgUNpso"
|
||||
],
|
||||
[
|
||||
"31QQ7ZMLkScDiB4VyZjuptr7AEc9j1SjstF7pRoLhHTGkW4Q2y9XELobQmhhWxeRvqcukGd1XCq"
|
||||
],
|
||||
[
|
||||
"DHqKSnpxa8ZdQyH8keAhvLTrfkyBMQxqngcQA5N8LQ9KVt25kmGN"
|
||||
],
|
||||
[
|
||||
"2LUHcJPbwLCy9GLH1qXmfmAwvadWw4bp4PCpDfduLqV17s6iDcy1imUwhQJhAoNoN1XNmweiJP4i"
|
||||
],
|
||||
[
|
||||
"7USRzBXAnmck8fX9HmW7RAb4qt92VFX6soCnts9s74wxm4gguVhtG5of8fZGbNPJA83irHVY6bCos"
|
||||
],
|
||||
[
|
||||
"1DGezo7BfVebZxAbNT3XGujdeHyNNBF3vnficYoTSp4PfK2QaML9bHzAMxke3wdKdHYWmsMTJVu"
|
||||
],
|
||||
[
|
||||
"2D12DqDZKwCxxkzs1ZATJWvgJGhQ4cFi3WrizQ5zLAyhN5HxuAJ1yMYaJp8GuYsTLLxTAz6otCfb"
|
||||
],
|
||||
[
|
||||
"8AFJzuTujXjw1Z6M3fWhQ1ujDW7zsV4ePeVjVo7D1egERqSW9nZ"
|
||||
],
|
||||
[
|
||||
"163Q17qLbTCue8YY3AvjpUhotuaodLm2uqMhpYirsKjVqnxJRWTEoywMVY3NbBAHuhAJ2cF9GAZ"
|
||||
],
|
||||
[
|
||||
"2MnmgiRH4eGLyLc9eAqStzk7dFgBjFtUCtu"
|
||||
],
|
||||
[
|
||||
"461QQ2sYWxU7H2PV4oBwJGNch8XVTYYbZxU"
|
||||
],
|
||||
[
|
||||
"2UCtv53VttmQYkVU4VMtXB31REvQg4ABzs41AEKZ8UcB7DAfVzdkV9JDErwGwyj5AUHLkmgZeobs"
|
||||
],
|
||||
[
|
||||
"cSNjAsnhgtiFMi6MtfvgscMB2Cbhn2v1FUYfviJ1CdjfidvmeW6mn"
|
||||
],
|
||||
[
|
||||
"gmsow2Y6EWAFDFE1CE4Hd3Tpu2BvfmBfG1SXsuRARbnt1WjkZnFh1qGTiptWWbjsq2Q6qvpgJVj"
|
||||
],
|
||||
[
|
||||
"nksUKSkzS76v8EsSgozXGMoQFiCoCHzCVajFKAXqzK5on9ZJYVHMD5CKwgmX3S3c7M1U3xabUny"
|
||||
],
|
||||
[
|
||||
"L3favK1UzFGgdzYBF2oBT5tbayCo4vtVBLJhg2iYuMeePxWG8SQc"
|
||||
],
|
||||
[
|
||||
"7VxLxGGtYT6N99GdEfi6xz56xdQ8nP2dG1CavuXx7Rf2PrvNMTBNevjkfgs9JmkcGm6EXpj8ipyPZ"
|
||||
],
|
||||
[
|
||||
"2mbZwFXF6cxShaCo2czTRB62WTx9LxhTtpP"
|
||||
],
|
||||
[
|
||||
"dB7cwYdcPSgiyAwKWL3JwCVwSk6epU2txw"
|
||||
],
|
||||
[
|
||||
"HPhFUhUAh8ZQQisH8QQWafAxtQYju3SFTX"
|
||||
],
|
||||
[
|
||||
"4ctAH6AkHzq5ioiM1m9T3E2hiYEev5mTsB"
|
||||
],
|
||||
[
|
||||
"Hn1uFi4dNexWrqARpjMqgT6cX1UsNPuV3cHdGg9ExyXw8HTKadbktRDtdeVmY3M1BxJStiL4vjJ"
|
||||
],
|
||||
[
|
||||
"Sq3fDbvutABmnAHHExJDgPLQn44KnNC7UsXuT7KZecpaYDMU9Txs"
|
||||
],
|
||||
[
|
||||
"6TqWyrqdgUEYDQU1aChMuFMMEimHX44qHFzCUgGfqxGgZNMUVWJ"
|
||||
],
|
||||
[
|
||||
"giqJo7oWqFxNKWyrgcBxAVHXnjJ1t6cGoEffce5Y1y7u649Noj5wJ4mmiUAKEVVrYAGg2KPB3Y4"
|
||||
],
|
||||
[
|
||||
"cNzHY5e8vcmM3QVJUcjCyiKMYfeYvyueq5qCMV3kqcySoLyGLYUK"
|
||||
],
|
||||
[
|
||||
"37uTe568EYc9WLoHEd9jXEvUiWbq5LFLscNyqvAzLU5vBArUJA6eydkLmnMwJDjkL5kXc2VK7ig"
|
||||
],
|
||||
[
|
||||
"EsYbG4tWWWY45G31nox838qNdzksbPySWc"
|
||||
],
|
||||
[
|
||||
"nbuzhfwMoNzA3PaFnyLcRxE9bTJPDkjZ6Rf6Y6o2ckXZfzZzXBT"
|
||||
],
|
||||
[
|
||||
"cQN9PoxZeCWK1x56xnz6QYAsvR11XAce3Ehp3gMUdfSQ53Y2mPzx"
|
||||
],
|
||||
[
|
||||
"1Gm3N3rkef6iMbx4voBzaxtXcmmiMTqZPhcuAepRzYUJQW4qRpEnHvMojzof42hjFRf8PE2jPde"
|
||||
],
|
||||
[
|
||||
"2TAq2tuN6x6m233bpT7yqdYQPELdTDJn1eU"
|
||||
],
|
||||
[
|
||||
"ntEtnnGhqPii4joABvBtSEJG6BxjT2tUZqE8PcVYgk3RHpgxgHDCQxNbLJf7ardf1dDk2oCQ7Cf"
|
||||
],
|
||||
[
|
||||
"Ky1YjoZNgQ196HJV3HpdkecfhRBmRZdMJk89Hi5KGfpfPwS2bUbfd"
|
||||
],
|
||||
[
|
||||
"2A1q1YsMZowabbvta7kTy2Fd6qN4r5ZCeG3qLpvZBMzCixMUdkN2Y4dHB1wPsZAeVXUGD83MfRED"
|
||||
]
|
||||
]
|
||||
452
src/test/data/base58_keys_valid.json
Normal file
452
src/test/data/base58_keys_valid.json
Normal file
@@ -0,0 +1,452 @@
|
||||
[
|
||||
[
|
||||
"Lf8Th7S4LDxFUZegQgn5z5se7BahrJ9DeV",
|
||||
"da589613a4c031bafa9fa5490fdaea491e81e687",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"3CMNFxN1oHBc4R1EpboAL5yzHGgE611Xou",
|
||||
"74f209f6ea907e2ea48f74fae05782ae8a665257",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"mo9ncXisMeAoXwqcV5EWuyncbmCcQN4rVs",
|
||||
"53c0307d6851aa0ce7825ba883c6bd9ad242b486",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"2N2JD6wb56AfK4tfmM6PwdVmoYk2dCKf4Br",
|
||||
"6349a418fc4578d10a372b54b45c280cc8c4382f",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"6uoCwsNo3oV9rsYwHY7TeGtZpwLbWJyVcKCAQyz91Ah4XbZYxw3",
|
||||
"58fb1bfc04bd9293a916d0688cba48ac143921a400e2086f43e16a02e572f2de",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"T9wxCLuZLZ2uSs44HUzGW5ZC2hNtnZqsbZGKtWC1MhJjHbRNCVYP",
|
||||
"cdc32fb8fab8b80ecf7e7501d93173f4c10bc45bd42c030ceaa7d947090bb441",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"9213qJab2HNEpMpYNBa7wHGFKKbkDn24jpANDs2huN3yi4J11ko",
|
||||
"36cb93b9ab1bdabf7fb9f2c04f1b9cc879933530ae7842398eef5a63a56800c2",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"cTpB4YiyKiBcPxnefsDpbnDxFDffjqJob8wGCEDXxgQ7zQoMXJdH",
|
||||
"b9f4892c9e8282028fea1d2667c4dc5213564d41fc5783896a0d843fc15089f3",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"LP7Ls95NmnuWi5o9bKZrezLiyCPy1B5P1q",
|
||||
"2aa075715a16b3f8fe726ae9c5c4aa044bbca054",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"3QjYXhTkvuj8qPaXHTTWb5wjXhdsLAAWVy",
|
||||
"fcc5460dd6e2487c7d75b1963625da0e8f4c5975",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"n3ZddxzLvAY9o7184TB4c6FJasAybsw4HZ",
|
||||
"f1d470f9b02370fdec2e6b708b08ac431bf7a5f7",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"2NBFNJTktNa7GZusGbDbGKRZTxdK9VVez3n",
|
||||
"c579342c2c4c9220205e2cdc285617040c924a0a",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"6vs3xk3YxdBcHAA12Y63qwALButouE5SBzZUnBzCq5N8wvMjnZ9",
|
||||
"e5686121b71c57364887d32d7b90885af98ebd96972bd1c00a6bd2a8f1f35b45",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"T4rLdfaJrCLN3uemQQoi1nAhXSAFwepDX4Ahjw8EjVP27Avmjzo4",
|
||||
"35b0165377348a7ba55184f5a30834e7b5ba20dcb3ed4c7bb330e1dc631b050f",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"93DVKyFYwSN6wEo3E2fCrFPUp17FtrtNi2Lf7n4G3garFb16CRj",
|
||||
"d6bca256b5abc5602ec2e1c121a08b0da2556587430bcf7e1898af2224885203",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"cTDVKtMGVYWTHCb1AFjmVbEbWjvKpKqKgMaR3QJxToMSQAhmCeTN",
|
||||
"a81ca4e8f90181ec4b61b6a7eb998af17b2cb04de8a03b504b9e34c4c61db7d9",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"LdaHb6WXgyf38F96JweN9XNWKJS91iCLNF",
|
||||
"c94ab72be12aa1a05f1af875f7250333e5d27aa2",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"3AnNxabYGoTxYiTEZwFEnerUoeFXK2Zoks",
|
||||
"63bcc565f9e68ee0189dd5cc67f1b0e5f02f45cb",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"n3LnJXCqbPjghuVs8ph9CYsAe4Sh4j97wk",
|
||||
"ef66444b5b17f14e8fae6e7e19b045a78c54fd79",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"2NB72XtkjpnATMggui83aEtPawyyKvnbX2o",
|
||||
"c3e55fceceaa4391ed2a9677f4a4d34eacd021a0",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"6uQT9bdxJhE83M8RjCQfo7U9oaAo5ncAP5skuzemx5DeuA6hB9o",
|
||||
"2550053cc3dfc32104fd3d0b1bce0e6f6e65a0564d36018f1544d9aa4764ad39",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"T4cpoFeaPJhTCTdLfmbNmA2f2PyjJgpCWU2pcdzBwExj5F9panJ4",
|
||||
"2ebc4b6d730064cf6023b006f2b4aff89a53ac04740f21d84efa6ef33d8855cd",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"927CnUkUbasYtDwYwVn2j8GdTuACNnKkjZ1rpZd2yBB1CLcnXpo",
|
||||
"44c4f6a096eac5238291a94cc24c01e3b19b8d8cef72874a079e00a242237a52",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"cUcfCMRjiQf85YMzzQEk9d1s5A4K7xL5SmBCLrezqXFuTVefyhY7",
|
||||
"d1de707020a9059d6d3abaf85e17967c6555151143db13dbb06db78df0f15c69",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"LX5YLxmAJ3YKHaRc2eR2A2s1cnw6fPA4SE",
|
||||
"820a3743686bf0fd46005de06cfd382bbcbd70c5",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"33vt8ViH5jsr115AGkW6cEmEz9MpvJSwDk",
|
||||
"188f91a931947eddd7432d6e614387e32b244709",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"mhaMcBxNh5cqXm4aTQ6EcVbKtfL6LGyK2H",
|
||||
"1694f5bc1a7295b600f40018a618a6ea48eeb498",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"2MxgPqX1iThW3oZVk9KoFcE5M4JpiETssVN",
|
||||
"3b9b3fd7a50d4f08d1a5b0f62f644fa7115ae2f3",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"6usgadpSJcXjfNFqn2Cz1kgKEWYhtzANKvhBs5pAKpsoCCRRv6H",
|
||||
"63252cd47897bd0380152475453e275cf504226ee82253bbc980a926b2a71689",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"T8wbMCiccPDTa3hUFT23LUXeWU1AiNpVy8MgsQMFAbPjDjpWPVod",
|
||||
"afbd7a0468460c25eef3576503578ce5ff985a598e30960018ad559282b3ef3c",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"92xFEve1Z9N8Z641KQQS7ByCSb8kGjsDzw6fAmjHN1LZGKQXyMq",
|
||||
"b4204389cef18bbe2b353623cbf93e8678fbc92a475b664ae98ed594e6cf0856",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"cVM65tdYu1YK37tNoAyGoJTR13VBYFva1vg9FLuPAsJijGvG6NEA",
|
||||
"e7b230133f1b5489843260236b06edca25f66adb1be455fbd38d4010d48faeef",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"LZa2tVcdFafKLMVeEKijaJ45jvruvZSRFK",
|
||||
"9d5df1006a8a175f342dd0610337331fceb45830",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"3QCzvfL4ZRvmJFiWWBVwxfdaNBT8EtxB5y",
|
||||
"f6fe69bcb548a829cce4c57bf6fff8af3a5981f9",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"mizXiucXRCsEriQCHUkCqef9ph9qtPbZZ6",
|
||||
"261f83568a098a8638844bd7aeca039d5f2352c0",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"2NEWDzHWwY5ZZp8CQWbB7ouNMLqCia6YRda",
|
||||
"e930e1834a4d234702773951d627cce82fbb5d2e",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"6vUB9QijBguaXPMoLXK5ZwLJCZTjKKAeQxgWfZLfJvForhka5D8",
|
||||
"b176f3e34ff474dea2fb3cafb19be519e6e8f34fd39166f5d5ce657154eb05d6",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"T5MCn7wUVMmffkTpoRNdW1MhWaRoSgNESC5tzeTSHie92tMBxjEZ",
|
||||
"448970a2a25f412fd9fc48d9df5dee7a01ad039b824efc28663f31728b92cce2",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"91cTVUcgydqyZLgaANpf1fvL55FH53QMm4BsnCADVNYuWuqdVys",
|
||||
"037f4192c630f399d9271e26c575269b1d15be553ea1a7217f0cb8513cef41cb",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"cQspfSzsgLeiJGB2u8vrAiWpCU4MxUT6JseWo2SjXy4Qbzn2fwDw",
|
||||
"6251e205e8ad508bab5596bee086ef16cd4b239e0cc0c5d7c4e6035441e7d5de",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"LPJfbhKmpiDNczUF1xwL8mBpwjg22kCRiw",
|
||||
"2cc4ac26bb08dfad7a40aa48b88046cfd2c930fd",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"37Sp6Rv3y4kVd1nQ1JV5pfqXccHNyZm1x3",
|
||||
"3f210e7277c899c3a155cc1c90f4106cbddeec6e",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"myoqcgYiehufrsnnkqdqbp69dddVDMopJu",
|
||||
"c8a3c2a09a298592c3e180f02487cd91ba3400b5",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"2N7FuwuUuoTBrDFdrAZ9KxBmtqMLxce9i1C",
|
||||
"99b31df7c9068d1481b596578ddbb4d3bd90baeb",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"6vM32FdMdhMF7qS9TLDH2sTLC6wALamAk9ebRFESaUpq9yf2mbE",
|
||||
"a1409598b6d7490548b3d5f3255b2c6adf487d82306a920d41362b98350b18a1",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"TA8YZ69RUn4NjmCJ9gaoDmxesD9bb9xzkXKHDcymJApWVKTPbYTm",
|
||||
"d3362922cebe534a1cef42928fc7208c9cfa1c4413422b2af741110fe5b0c8de",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"93N87D6uxSBzwXvpokpzg8FFmfQPmvX4xHoWQe3pLdYpbiwT5YV",
|
||||
"ea577acfb5d1d14d3b7b195c321566f12f87d2b77ea3a53f68df7ebf8604a801",
|
||||
{
|
||||
"isCompressed": false,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"cMxXusSihaX58wpJ3tNuuUcZEQGt6DKJ1wEpxys88FFaQCYjku9h",
|
||||
"0b3b34f0958d8a268193a9814da92c3e8b58b4a4378a542863e34ac289cd830c",
|
||||
{
|
||||
"isCompressed": true,
|
||||
"isPrivkey": true,
|
||||
"isTestnet": true
|
||||
}
|
||||
],
|
||||
[
|
||||
"LWzPZSe3opyEdEmRAiULVLR3zBZS3oY9Wu",
|
||||
"8110cd88bfb26bfb08e0878ddb34af03fc03c8b7",
|
||||
{
|
||||
"addrType": "pubkey",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
],
|
||||
[
|
||||
"3ALJH9Y951VCGcVZYAdpA3KchoP9McEj1G",
|
||||
"5ece0cadddc415b1980f001785947120acdb36fc",
|
||||
{
|
||||
"addrType": "script",
|
||||
"isPrivkey": false,
|
||||
"isTestnet": false
|
||||
}
|
||||
]
|
||||
]
|
||||
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
7
src/test/data/sig_canonical.json
Normal file
7
src/test/data/sig_canonical.json
Normal file
@@ -0,0 +1,7 @@
|
||||
[
|
||||
"300602010002010001",
|
||||
"3008020200ff020200ff01",
|
||||
"304402203932c892e2e550f3af8ee4ce9c215a87f9bb831dcac87b2838e2c2eaa891df0c022030b61dd36543125d56b9f9f3a1f9353189e5af33cdda8d77a5209aec03978fa001",
|
||||
"30450220076045be6f9eca28ff1ec606b833d0b87e70b2a630f5e3a496b110967a40f90a0221008fffd599910eefe00bc803c688c2eca1d2ba7f6b180620eaa03488e6585db6ba01",
|
||||
"3046022100876045be6f9eca28ff1ec606b833d0b87e70b2a630f5e3a496b110967a40f90a0221008fffd599910eefe00bc803c688c2eca1d2ba7f6b180620eaa03488e6585db6ba01"
|
||||
]
|
||||
22
src/test/data/sig_noncanonical.json
Normal file
22
src/test/data/sig_noncanonical.json
Normal file
@@ -0,0 +1,22 @@
|
||||
[
|
||||
"non-hex strings are ignored",
|
||||
|
||||
"too short:", "30050201FF020001",
|
||||
"too long:", "30470221005990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba6105022200002d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"hashtype:", "304402205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed11",
|
||||
"type:", "314402205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"total length:", "304502205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"S len oob:", "301F01205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb101",
|
||||
"R+S:", "304502205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed0001",
|
||||
|
||||
"R type:", "304401205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"R len = 0:", "3024020002202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"R<0:", "304402208990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"R padded:", "30450221005990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610502202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
|
||||
|
||||
"S type:", "304402205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba610501202d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"S len = 0:", "302402205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba6105020001",
|
||||
"S<0:", "304402205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61050220fd5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01",
|
||||
"S padded:", "304502205990e0584b2b238e1dfaad8d6ed69ecc1a4a13ac85fc0b31d0df395eb1ba61050221002d5876262c288beb511d061691bf26777344b702b00f8fe28621fe4e566695ed01"
|
||||
]
|
||||
69
src/test/data/tx_invalid.json
Normal file
69
src/test/data/tx_invalid.json
Normal file
@@ -0,0 +1,69 @@
|
||||
[
|
||||
["The following are deserialized transactions which are invalid."],
|
||||
["They are in the form"],
|
||||
["[[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"],
|
||||
["serializedTransaction, enforceP2SH]"],
|
||||
["Objects that are only a single string (like this one) are ignored"],
|
||||
|
||||
["0e1b5688cf179cd9f7cbda1fac0090f6e684bbf8cd946660120197c3f3681809 but with extra junk appended to the end of the scriptPubKey"],
|
||||
[[["6ca7ec7b1847f6bdbd737176050e6a08d66ccd55bb94ad24f4018024107a5827", 0, "0x41 0x043b640e983c9690a14c039a2037ecc3467b27a0dcd58f19d76c7bc118d09fec45adc5370a1c5bf8067ca9f5557a4cf885fdb0fe0dcc9c3a7137226106fbc779a5 CHECKSIG VERIFY 1"]],
|
||||
"010000000127587a10248001f424ad94bb55cd6cd6086a0e05767173bdbdf647187beca76c000000004948304502201b822ad10d6adc1a341ae8835be3f70a25201bbff31f59cbb9c5353a5f0eca18022100ea7b2f7074e9aa9cf70aa8d0ffee13e6b45dddabf1ab961bda378bcdb778fa4701ffffffff0100f2052a010000001976a914fc50c5907d86fed474ba5ce8b12a66e0a4c139d888ac00000000", true],
|
||||
|
||||
["This is the nearly-standard transaction with CHECKSIGVERIFY 1 instead of CHECKSIG from tx_valid.json"],
|
||||
["but with the signature duplicated in the scriptPubKey with a non-standard pushdata prefix"],
|
||||
["See FindAndDelete, which will only remove if it uses the same pushdata prefix as is standard"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "DUP HASH160 0x14 0x5b6462475454710f3c22f5fdf0b40704c92f25c3 EQUALVERIFY CHECKSIGVERIFY 1 0x4c 0x47 0x3044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a01"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006a473044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a012103ba8c8b86dea131c22ab967e6dd99bdae8eff7a1f75a2c35f1f944109e3fe5e22ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Same as above, but with the sig in the scriptSig also pushed with the same non-standard OP_PUSHDATA"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "DUP HASH160 0x14 0x5b6462475454710f3c22f5fdf0b40704c92f25c3 EQUALVERIFY CHECKSIGVERIFY 1 0x4c 0x47 0x3044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a01"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006b4c473044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a012103ba8c8b86dea131c22ab967e6dd99bdae8eff7a1f75a2c35f1f944109e3fe5e22ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["An invalid P2SH Transaction"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x7a052c840ba73af26755de42cf01cc9e0a49fef0 EQUAL"]],
|
||||
"010000000100010000000000000000000000000000000000000000000000000000000000000000000009085768617420697320ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Tests for CTransaction::CheckTransaction()"],
|
||||
["No inputs"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x7a052c840ba73af26755de42cf01cc9e0a49fef0 EQUAL"]],
|
||||
"0100000000010000000000000000015100000000", true],
|
||||
|
||||
["No outputs"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x05ab9e14d983742513f0f451e105ffb4198d1dd4 EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006d483045022100f16703104aab4e4088317c862daec83440242411b039d14280e03dd33b487ab802201318a7be236672c5c56083eb7a5a195bc57a40af7923ff8545016cd3b571e2a601232103c40e5d339df3f30bf753e7e04450ae4ef76c9e45587d1d993bdc4cd06f0651c7acffffffff0000000000", true],
|
||||
|
||||
["Negative output"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0xae609aca8061d77c5e111f6bb62501a6bbe2bfdb EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006d4830450220063222cbb128731fc09de0d7323746539166544d6c1df84d867ccea84bcc8903022100bf568e8552844de664cd41648a031554327aa8844af34b4f27397c65b92c04de0123210243ec37dee0e2e053a9c976f43147e79bc7d9dc606ea51010af1ac80db6b069e1acffffffff01ffffffffffffffff015100000000", true],
|
||||
|
||||
["MAX_MONEY + 1 output"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x32afac281462b822adbec5094b8d4d337dd5bd6a EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006e493046022100e1eadba00d9296c743cb6ecc703fd9ddc9b3cd12906176a226ae4c18d6b00796022100a71aef7d2874deff681ba6080f1b278bac7bb99c61b08a85f4311970ffe7f63f012321030c0588dc44d92bdcbf8e72093466766fdc265ead8db64517b0c542275b70fffbacffffffff010140075af0750700015100000000", true],
|
||||
|
||||
["MAX_MONEY output + 1 output"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0xb558cbf4930954aa6a344363a15668d7477ae716 EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006d483045022027deccc14aa6668e78a8c9da3484fbcd4f9dcc9bb7d1b85146314b21b9ae4d86022100d0b43dece8cfb07348de0ca8bc5b86276fa88f7f2138381128b7c36ab2e42264012321029bb13463ddd5d2cc05da6e84e37536cb9525703cfd8f43afdb414988987a92f6acffffffff020040075af075070001510001000000000000015100000000", true],
|
||||
|
||||
["Duplicate inputs"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x236d0639db62b0773fd8ac34dc85ae19e9aba80a EQUAL"]],
|
||||
"01000000020001000000000000000000000000000000000000000000000000000000000000000000006c47304402204bb1197053d0d7799bf1b30cd503c44b58d6240cccbdc85b6fe76d087980208f02204beeed78200178ffc6c74237bb74b3f276bbb4098b5605d814304fe128bf1431012321039e8815e15952a7c3fada1905f8cf55419837133bd7756c0ef14fc8dfe50c0deaacffffffff0001000000000000000000000000000000000000000000000000000000000000000000006c47304402202306489afef52a6f62e90bf750bbcdf40c06f5c6b138286e6b6b86176bb9341802200dba98486ea68380f47ebb19a7df173b99e6bc9c681d6ccf3bde31465d1f16b3012321039e8815e15952a7c3fada1905f8cf55419837133bd7756c0ef14fc8dfe50c0deaacffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Coinbase of size 1"],
|
||||
["Note the input is just required to make the tester happy"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000000", -1, "1"]],
|
||||
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0151ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Coinbase of size 101"],
|
||||
["Note the input is just required to make the tester happy"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000000", -1, "1"]],
|
||||
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff655151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Null txin"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000000", -1, "HASH160 0x14 0x02dae7dbbda56097959cba59b1989dd3e47937bf EQUAL"]],
|
||||
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff6e49304602210086f39e028e46dafa8e1e3be63906465f4cf038fbe5ed6403dc3e74ae876e6431022100c4625c675cfc5c7e3a0e0d7eaec92ac24da20c73a88eb40d09253e51ac6def5201232103a183ddc41e84753aca47723c965d1b5c8b0e2b537963518355e6dd6cf8415e50acffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Same as the transactions in valid with one input SIGHASH_ALL and one SIGHASH_ANYONECANPAY, but we set the _ANYONECANPAY sequence number, invalidating the SIGHASH_ALL signature"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0x21 0x035e7f0d4d0841bcd56c39337ed086b1a633ee770c1ffdd94ac552a95ac2ce0efc CHECKSIG"],
|
||||
["0000000000000000000000000000000000000000000000000000000000000200", 0, "0x21 0x035e7f0d4d0841bcd56c39337ed086b1a633ee770c1ffdd94ac552a95ac2ce0efc CHECKSIG"]],
|
||||
"01000000020001000000000000000000000000000000000000000000000000000000000000000000004948304502203a0f5f0e1f2bdbcd04db3061d18f3af70e07f4f467cbc1b8116f267025f5360b022100c792b6e215afc5afc721a351ec413e714305cb749aae3d7fee76621313418df10101000000000200000000000000000000000000000000000000000000000000000000000000000000484730440220201dc2d030e380e8f9cfb41b442d930fa5a685bb2c8db5906671f865507d0670022018d9e7a8d4c8d86a73c2a724ee38ef983ec249827e0e464841735955c707ece98101000000010100000000000000015100000000", true]
|
||||
]
|
||||
81
src/test/data/tx_valid.json
Normal file
81
src/test/data/tx_valid.json
Normal file
@@ -0,0 +1,81 @@
|
||||
[
|
||||
["The following are deserialized transactions which are valid."],
|
||||
["They are in the form"],
|
||||
["[[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"],
|
||||
["serializedTransaction, enforceP2SH]"],
|
||||
["Objects that are only a single string (like this one) are ignored"],
|
||||
|
||||
["The following is 23b397edccd3740a74adb603c9756370fafcde9bcc4483eb271ecad09a94dd63"],
|
||||
["It is of particular interest because it contains an invalidly-encoded signature which OpenSSL accepts"],
|
||||
["See http://r6.ca/blog/20111119T211504Z.html"],
|
||||
["It is also the first OP_CHECKMULTISIG transaction in standard form"],
|
||||
[[["60a20bd93aa49ab4b28d514ec10b06e1829ce6818ec06cd3aabd013ebcdc4bb1", 0, "1 0x41 0x04cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4 0x41 0x0461cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d76519aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af 2 OP_CHECKMULTISIG"]],
|
||||
"0100000001b14bdcbc3e01bdaad36cc08e81e69c82e1060bc14e518db2b49aa43ad90ba26000000000490047304402203f16c6f40162ab686621ef3000b04e75418a0c0cb2d8aebeac894ae360ac1e780220ddc15ecdfc3507ac48e1681a33eb60996631bf6bf5bc0a0682c4db743ce7ca2b01ffffffff0140420f00000000001976a914660d4ef3a743e3e696ad990364e555c271ad504b88ac00000000", true],
|
||||
|
||||
["The following is a tweaked form of 23b397edccd3740a74adb603c9756370fafcde9bcc4483eb271ecad09a94dd63"],
|
||||
["It has an arbitrary extra byte stuffed into the signature at pos length - 2"],
|
||||
[[["60a20bd93aa49ab4b28d514ec10b06e1829ce6818ec06cd3aabd013ebcdc4bb1", 0, "1 0x41 0x04cc71eb30d653c0c3163990c47b976f3fb3f37cccdcbedb169a1dfef58bbfbfaff7d8a473e7e2e6d317b87bafe8bde97e3cf8f065dec022b51d11fcdd0d348ac4 0x41 0x0461cbdcc5409fb4b4d42b51d33381354d80e550078cb532a34bfa2fcfdeb7d76519aecc62770f5b0e4ef8551946d8a540911abe3e7854a26f39f58b25c15342af 2 OP_CHECKMULTISIG"]],
|
||||
"0100000001b14bdcbc3e01bdaad36cc08e81e69c82e1060bc14e518db2b49aa43ad90ba260000000004A0048304402203f16c6f40162ab686621ef3000b04e75418a0c0cb2d8aebeac894ae360ac1e780220ddc15ecdfc3507ac48e1681a33eb60996631bf6bf5bc0a0682c4db743ce7ca2bab01ffffffff0140420f00000000001976a914660d4ef3a743e3e696ad990364e555c271ad504b88ac00000000", true],
|
||||
|
||||
["The following is c99c49da4c38af669dea436d3e73780dfdb6c1ecf9958baa52960e8baee30e73"],
|
||||
["It is of interest because it contains a 0-sequence as well as a signature of SIGHASH type 0 (which is not a real type)"],
|
||||
[[["406b2b06bcd34d3c8733e6b79f7a394c8a431fbf4ff5ac705c93f4076bb77602", 0, "DUP HASH160 0x14 0xdc44b1164188067c3a32d4780f5996fa14a4f2d9 EQUALVERIFY CHECKSIG"]],
|
||||
"01000000010276b76b07f4935c70acf54fbf1f438a4c397a9fb7e633873c4dd3bc062b6b40000000008c493046022100d23459d03ed7e9511a47d13292d3430a04627de6235b6e51a40f9cd386f2abe3022100e7d25b080f0bb8d8d5f878bba7d54ad2fda650ea8d158a33ee3cbd11768191fd004104b0e2c879e4daf7b9ab68350228c159766676a14f5815084ba166432aab46198d4cca98fa3e9981d0a90b2effc514b76279476550ba3663fdcaff94c38420e9d5000000000100093d00000000001976a9149a7b0f3b80c6baaeedce0a0842553800f832ba1f88ac00000000", true],
|
||||
|
||||
["A nearly-standard transaction with CHECKSIGVERIFY 1 instead of CHECKSIG"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "DUP HASH160 0x14 0x5b6462475454710f3c22f5fdf0b40704c92f25c3 EQUALVERIFY CHECKSIGVERIFY 1"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006a473044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a012103ba8c8b86dea131c22ab967e6dd99bdae8eff7a1f75a2c35f1f944109e3fe5e22ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Same as above, but with the signature duplicated in the scriptPubKey with the proper pushdata prefix"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "DUP HASH160 0x14 0x5b6462475454710f3c22f5fdf0b40704c92f25c3 EQUALVERIFY CHECKSIGVERIFY 1 0x47 0x3044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a01"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006a473044022067288ea50aa799543a536ff9306f8e1cba05b9c6b10951175b924f96732555ed022026d7b5265f38d21541519e4a1e55044d5b9e17e15cdbaf29ae3792e99e883e7a012103ba8c8b86dea131c22ab967e6dd99bdae8eff7a1f75a2c35f1f944109e3fe5e22ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["The following is f7fdd091fa6d8f5e7a8c2458f5c38faffff2d3f1406b6e4fe2c99dcc0d2d1cbb"],
|
||||
["It caught a bug in the workaround for 23b397edccd3740a74adb603c9756370fafcde9bcc4483eb271ecad09a94dd63 in an overly simple implementation"],
|
||||
[[["b464e85df2a238416f8bdae11d120add610380ea07f4ef19c5f9dfd472f96c3d", 0, "DUP HASH160 0x14 0xbef80ecf3a44500fda1bc92176e442891662aed2 EQUALVERIFY CHECKSIG"],
|
||||
["b7978cc96e59a8b13e0865d3f95657561a7f725be952438637475920bac9eb21", 1, "DUP HASH160 0x14 0xbef80ecf3a44500fda1bc92176e442891662aed2 EQUALVERIFY CHECKSIG"]],
|
||||
"01000000023d6cf972d4dff9c519eff407ea800361dd0a121de1da8b6f4138a2f25de864b4000000008a4730440220ffda47bfc776bcd269da4832626ac332adfca6dd835e8ecd83cd1ebe7d709b0e022049cffa1cdc102a0b56e0e04913606c70af702a1149dc3b305ab9439288fee090014104266abb36d66eb4218a6dd31f09bb92cf3cfa803c7ea72c1fc80a50f919273e613f895b855fb7465ccbc8919ad1bd4a306c783f22cd3227327694c4fa4c1c439affffffff21ebc9ba20594737864352e95b727f1a565756f9d365083eb1a8596ec98c97b7010000008a4730440220503ff10e9f1e0de731407a4a245531c9ff17676eda461f8ceeb8c06049fa2c810220c008ac34694510298fa60b3f000df01caa244f165b727d4896eb84f81e46bcc4014104266abb36d66eb4218a6dd31f09bb92cf3cfa803c7ea72c1fc80a50f919273e613f895b855fb7465ccbc8919ad1bd4a306c783f22cd3227327694c4fa4c1c439affffffff01f0da5200000000001976a914857ccd42dded6df32949d4646dfa10a92458cfaa88ac00000000", true],
|
||||
|
||||
["The following tests for the presence of a bug in the handling of SIGHASH_SINGLE"],
|
||||
["It results in signing the constant 1, instead of something generated based on the transaction,"],
|
||||
["when the input doing the signing has an index greater than the maximum output index"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "DUP HASH160 0x14 0xe52b482f2faa8ecbf0db344f93c84ac908557f33 EQUALVERIFY CHECKSIG"], ["0000000000000000000000000000000000000000000000000000000000000200", 0, "1"]],
|
||||
"01000000020002000000000000000000000000000000000000000000000000000000000000000000000151ffffffff0001000000000000000000000000000000000000000000000000000000000000000000006b483045022100c9cdd08798a28af9d1baf44a6c77bcc7e279f47dc487c8c899911bc48feaffcc0220503c5c50ae3998a733263c5c0f7061b483e2b56c4c41b456e7d2f5a78a74c077032102d5c25adb51b61339d2b05315791e21bbe80ea470a49db0135720983c905aace0ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["An invalid P2SH Transaction"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x7a052c840ba73af26755de42cf01cc9e0a49fef0 EQUAL"]],
|
||||
"010000000100010000000000000000000000000000000000000000000000000000000000000000000009085768617420697320ffffffff010000000000000000015100000000", false],
|
||||
|
||||
["A valid P2SH Transaction using the standard transaction type put forth in BIP 16"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x8febbed40483661de6958d957412f82deed8e2f7 EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006e493046022100c66c9cdf4c43609586d15424c54707156e316d88b0a1534c9e6b0d4f311406310221009c0fe51dbc9c4ab7cc25d3fdbeccf6679fe6827f08edf2b4a9f16ee3eb0e438a0123210338e8034509af564c62644c07691942e0c056752008a173c89f60ab2a88ac2ebfacffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Tests for CTransaction::CheckTransaction()"],
|
||||
["MAX_MONEY output"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0x32afac281462b822adbec5094b8d4d337dd5bd6a EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006e493046022100e1eadba00d9296c743cb6ecc703fd9ddc9b3cd12906176a226ae4c18d6b00796022100a71aef7d2874deff681ba6080f1b278bac7bb99c61b08a85f4311970ffe7f63f012321030c0588dc44d92bdcbf8e72093466766fdc265ead8db64517b0c542275b70fffbacffffffff010040075af0750700015100000000", true],
|
||||
|
||||
["MAX_MONEY output + 0 output"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "HASH160 0x14 0xb558cbf4930954aa6a344363a15668d7477ae716 EQUAL"]],
|
||||
"01000000010001000000000000000000000000000000000000000000000000000000000000000000006d483045022027deccc14aa6668e78a8c9da3484fbcd4f9dcc9bb7d1b85146314b21b9ae4d86022100d0b43dece8cfb07348de0ca8bc5b86276fa88f7f2138381128b7c36ab2e42264012321029bb13463ddd5d2cc05da6e84e37536cb9525703cfd8f43afdb414988987a92f6acffffffff020040075af075070001510000000000000000015100000000", true],
|
||||
|
||||
["Coinbase of size 2"],
|
||||
["Note the input is just required to make the tester happy"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000000", -1, "1"]],
|
||||
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff025151ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Coinbase of size 100"],
|
||||
["Note the input is just required to make the tester happy"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000000", -1, "1"]],
|
||||
"01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff6451515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151515151ffffffff010000000000000000015100000000", true],
|
||||
|
||||
["Simple transaction with first input is signed with SIGHASH_ALL, second with SIGHASH_ANYONECANPAY"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0x21 0x035e7f0d4d0841bcd56c39337ed086b1a633ee770c1ffdd94ac552a95ac2ce0efc CHECKSIG"],
|
||||
["0000000000000000000000000000000000000000000000000000000000000200", 0, "0x21 0x035e7f0d4d0841bcd56c39337ed086b1a633ee770c1ffdd94ac552a95ac2ce0efc CHECKSIG"]],
|
||||
"010000000200010000000000000000000000000000000000000000000000000000000000000000000049483045022100d180fd2eb9140aeb4210c9204d3f358766eb53842b2a9473db687fa24b12a3cc022079781799cd4f038b85135bbe49ec2b57f306b2bb17101b17f71f000fcab2b6fb01ffffffff0002000000000000000000000000000000000000000000000000000000000000000000004847304402205f7530653eea9b38699e476320ab135b74771e1c48b81a5d041e2ca84b9be7a802200ac8d1f40fb026674fe5a5edd3dea715c27baa9baca51ed45ea750ac9dc0a55e81ffffffff010100000000000000015100000000", true],
|
||||
|
||||
["Same as above, but we change the sequence number of the first input to check that SIGHASH_ANYONECANPAY is being followed"],
|
||||
[[["0000000000000000000000000000000000000000000000000000000000000100", 0, "0x21 0x035e7f0d4d0841bcd56c39337ed086b1a633ee770c1ffdd94ac552a95ac2ce0efc CHECKSIG"],
|
||||
["0000000000000000000000000000000000000000000000000000000000000200", 0, "0x21 0x035e7f0d4d0841bcd56c39337ed086b1a633ee770c1ffdd94ac552a95ac2ce0efc CHECKSIG"]],
|
||||
"01000000020001000000000000000000000000000000000000000000000000000000000000000000004948304502203a0f5f0e1f2bdbcd04db3061d18f3af70e07f4f467cbc1b8116f267025f5360b022100c792b6e215afc5afc721a351ec413e714305cb749aae3d7fee76621313418df101010000000002000000000000000000000000000000000000000000000000000000000000000000004847304402205f7530653eea9b38699e476320ab135b74771e1c48b81a5d041e2ca84b9be7a802200ac8d1f40fb026674fe5a5edd3dea715c27baa9baca51ed45ea750ac9dc0a55e81ffffffff010100000000000000015100000000", true]
|
||||
]
|
||||
@@ -26,8 +26,8 @@ static const string strAddressBad("LRjyUS2uuieEPkhZNdQz8hE5YycxVEqSXA");
|
||||
#ifdef KEY_TESTS_DUMPINFO
|
||||
void dumpKeyInfo(uint256 privkey)
|
||||
{
|
||||
CSecret secret;
|
||||
secret.resize(32);
|
||||
CKey key;
|
||||
key.resize(32);
|
||||
memcpy(&secret[0], &privkey, 32);
|
||||
vector<unsigned char> sec;
|
||||
sec.resize(32);
|
||||
@@ -62,29 +62,24 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
||||
BOOST_CHECK( bsecret2C.SetString(strSecret2C));
|
||||
BOOST_CHECK(!baddress1.SetString(strAddressBad));
|
||||
|
||||
bool fCompressed;
|
||||
CSecret secret1 = bsecret1.GetSecret (fCompressed);
|
||||
BOOST_CHECK(fCompressed == false);
|
||||
CSecret secret2 = bsecret2.GetSecret (fCompressed);
|
||||
BOOST_CHECK(fCompressed == false);
|
||||
CSecret secret1C = bsecret1C.GetSecret(fCompressed);
|
||||
BOOST_CHECK(fCompressed == true);
|
||||
CSecret secret2C = bsecret2C.GetSecret(fCompressed);
|
||||
BOOST_CHECK(fCompressed == true);
|
||||
CKey key1 = bsecret1.GetKey();
|
||||
BOOST_CHECK(key1.IsCompressed() == false);
|
||||
CKey key2 = bsecret2.GetKey();
|
||||
BOOST_CHECK(key2.IsCompressed() == false);
|
||||
CKey key1C = bsecret1C.GetKey();
|
||||
BOOST_CHECK(key1C.IsCompressed() == true);
|
||||
CKey key2C = bsecret2C.GetKey();
|
||||
BOOST_CHECK(key1C.IsCompressed() == true);
|
||||
|
||||
BOOST_CHECK(secret1 == secret1C);
|
||||
BOOST_CHECK(secret2 == secret2C);
|
||||
CPubKey pubkey1 = key1. GetPubKey();
|
||||
CPubKey pubkey2 = key2. GetPubKey();
|
||||
CPubKey pubkey1C = key1C.GetPubKey();
|
||||
CPubKey pubkey2C = key2C.GetPubKey();
|
||||
|
||||
CKey key1, key2, key1C, key2C;
|
||||
key1.SetSecret(secret1, false);
|
||||
key2.SetSecret(secret2, false);
|
||||
key1C.SetSecret(secret1, true);
|
||||
key2C.SetSecret(secret2, true);
|
||||
|
||||
BOOST_CHECK(addr1.Get() == CTxDestination(key1.GetPubKey().GetID()));
|
||||
BOOST_CHECK(addr2.Get() == CTxDestination(key2.GetPubKey().GetID()));
|
||||
BOOST_CHECK(addr1C.Get() == CTxDestination(key1C.GetPubKey().GetID()));
|
||||
BOOST_CHECK(addr2C.Get() == CTxDestination(key2C.GetPubKey().GetID()));
|
||||
BOOST_CHECK(addr1.Get() == CTxDestination(pubkey1.GetID()));
|
||||
BOOST_CHECK(addr2.Get() == CTxDestination(pubkey2.GetID()));
|
||||
BOOST_CHECK(addr1C.Get() == CTxDestination(pubkey1C.GetID()));
|
||||
BOOST_CHECK(addr2C.Get() == CTxDestination(pubkey2C.GetID()));
|
||||
|
||||
for (int n=0; n<16; n++)
|
||||
{
|
||||
@@ -100,25 +95,25 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
||||
BOOST_CHECK(key1C.Sign(hashMsg, sign1C));
|
||||
BOOST_CHECK(key2C.Sign(hashMsg, sign2C));
|
||||
|
||||
BOOST_CHECK( key1.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK(!key1.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK( key1.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK(!key1.Verify(hashMsg, sign2C));
|
||||
BOOST_CHECK( pubkey1.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK( pubkey1.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK(!pubkey1.Verify(hashMsg, sign2C));
|
||||
|
||||
BOOST_CHECK(!key2.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK( key2.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK(!key2.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK( key2.Verify(hashMsg, sign2C));
|
||||
BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK( pubkey2.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK(!pubkey2.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK( pubkey2.Verify(hashMsg, sign2C));
|
||||
|
||||
BOOST_CHECK( key1C.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK(!key1C.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK( key1C.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK(!key1C.Verify(hashMsg, sign2C));
|
||||
BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK( pubkey1C.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK(!pubkey1C.Verify(hashMsg, sign2C));
|
||||
|
||||
BOOST_CHECK(!key2C.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK( key2C.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK(!key2C.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK( key2C.Verify(hashMsg, sign2C));
|
||||
BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1));
|
||||
BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2));
|
||||
BOOST_CHECK(!pubkey2C.Verify(hashMsg, sign1C));
|
||||
BOOST_CHECK( pubkey2C.Verify(hashMsg, sign2C));
|
||||
|
||||
// compact signatures (with key recovery)
|
||||
|
||||
@@ -129,18 +124,17 @@ BOOST_AUTO_TEST_CASE(key_test1)
|
||||
BOOST_CHECK(key1C.SignCompact(hashMsg, csign1C));
|
||||
BOOST_CHECK(key2C.SignCompact(hashMsg, csign2C));
|
||||
|
||||
CKey rkey1, rkey2, rkey1C, rkey2C;
|
||||
CPubKey rkey1, rkey2, rkey1C, rkey2C;
|
||||
|
||||
BOOST_CHECK(rkey1.SetCompactSignature (hashMsg, csign1));
|
||||
BOOST_CHECK(rkey2.SetCompactSignature (hashMsg, csign2));
|
||||
BOOST_CHECK(rkey1C.SetCompactSignature(hashMsg, csign1C));
|
||||
BOOST_CHECK(rkey2C.SetCompactSignature(hashMsg, csign2C));
|
||||
BOOST_CHECK(rkey1.RecoverCompact (hashMsg, csign1));
|
||||
BOOST_CHECK(rkey2.RecoverCompact (hashMsg, csign2));
|
||||
BOOST_CHECK(rkey1C.RecoverCompact(hashMsg, csign1C));
|
||||
BOOST_CHECK(rkey2C.RecoverCompact(hashMsg, csign2C));
|
||||
|
||||
|
||||
BOOST_CHECK(rkey1.GetPubKey() == key1.GetPubKey());
|
||||
BOOST_CHECK(rkey2.GetPubKey() == key2.GetPubKey());
|
||||
BOOST_CHECK(rkey1C.GetPubKey() == key1C.GetPubKey());
|
||||
BOOST_CHECK(rkey2C.GetPubKey() == key2C.GetPubKey());
|
||||
BOOST_CHECK(rkey1 == pubkey1);
|
||||
BOOST_CHECK(rkey2 == pubkey2);
|
||||
BOOST_CHECK(rkey1C == pubkey1C);
|
||||
BOOST_CHECK(rkey2C == pubkey2C);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,12 +1,206 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include "init.h"
|
||||
#include "main.h"
|
||||
#include "uint256.h"
|
||||
#include "util.h"
|
||||
#include "wallet.h"
|
||||
|
||||
extern void SHA256Transform(void* pstate, void* pinput, const void* pinit);
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(miner_tests)
|
||||
|
||||
static
|
||||
struct {
|
||||
unsigned char extranonce;
|
||||
unsigned int nonce;
|
||||
} blockinfo[] = {
|
||||
{4, 0xa4ad9f65}, {2, 0x15cf2b27}, {1, 0x037620ac}, {1, 0x700d9c54},
|
||||
{2, 0xce79f74f}, {2, 0x52d9c194}, {1, 0x77bc3efc}, {2, 0xbb62c5e8},
|
||||
{2, 0x83ff997a}, {1, 0x48b984ee}, {1, 0xef925da0}, {2, 0x680d2979},
|
||||
{2, 0x08953af7}, {1, 0x087dd553}, {2, 0x210e2818}, {2, 0xdfffcdef},
|
||||
{1, 0xeea1b209}, {2, 0xba4a8943}, {1, 0xa7333e77}, {1, 0x344f3e2a},
|
||||
{3, 0xd651f08e}, {2, 0xeca3957f}, {2, 0xca35aa49}, {1, 0x6bb2065d},
|
||||
{2, 0x0170ee44}, {1, 0x6e12f4aa}, {2, 0x43f4f4db}, {2, 0x279c1c44},
|
||||
{2, 0xb5a50f10}, {2, 0xb3902841}, {2, 0xd198647e}, {2, 0x6bc40d88},
|
||||
{1, 0x633a9a1c}, {2, 0x9a722ed8}, {2, 0x55580d10}, {1, 0xd65022a1},
|
||||
{2, 0xa12ffcc8}, {1, 0x75a6a9c7}, {2, 0xfb7c80b7}, {1, 0xe8403e6c},
|
||||
{1, 0xe34017a0}, {3, 0x659e177b}, {2, 0xba5c40bf}, {5, 0x022f11ef},
|
||||
{1, 0xa9ab516a}, {5, 0xd0999ed4}, {1, 0x37277cb3}, {1, 0x830f735f},
|
||||
{1, 0xc6e3d947}, {2, 0x824a0c1b}, {1, 0x99962416}, {1, 0x75336f63},
|
||||
{1, 0xaacf0fea}, {1, 0xd6531aec}, {5, 0x7afcf541}, {5, 0x9d6fac0d},
|
||||
{1, 0x4cf5c4df}, {1, 0xabe0f2a0}, {6, 0x4a3dac18}, {2, 0xf265febe},
|
||||
{2, 0x1bc9f23f}, {1, 0xad49ab71}, {1, 0x9f2d8923}, {1, 0x15acb65d},
|
||||
{2, 0xd1cecb52}, {2, 0xf856808b}, {1, 0x0fa96e29}, {1, 0xe063ecbc},
|
||||
{1, 0x78d926c6}, {5, 0x3e38ad35}, {5, 0x73901915}, {1, 0x63424be0},
|
||||
{1, 0x6d6b0a1d}, {2, 0x888ba681}, {2, 0xe96b0714}, {1, 0xb7fcaa55},
|
||||
{2, 0x19c106eb}, {1, 0x5aa13484}, {2, 0x5bf4c2f3}, {2, 0x94d401dd},
|
||||
{1, 0xa9bc23d9}, {1, 0x3a69c375}, {1, 0x56ed2006}, {5, 0x85ba6dbd},
|
||||
{1, 0xfd9b2000}, {1, 0x2b2be19a}, {1, 0xba724468}, {1, 0x717eb6e5},
|
||||
{1, 0x70de86d9}, {1, 0x74e23a42}, {1, 0x49e92832}, {2, 0x6926dbb9},
|
||||
{0, 0x64452497}, {1, 0x54306d6f}, {2, 0x97ebf052}, {2, 0x55198b70},
|
||||
{2, 0x03fe61f0}, {1, 0x98f9e67f}, {1, 0xc0842a09}, {1, 0xdfed39c5},
|
||||
{1, 0x3144223e}, {1, 0xb3d12f84}, {1, 0x7366ceb7}, {5, 0x6240691b},
|
||||
{2, 0xd3529b57}, {1, 0xf4cae3b1}, {1, 0x5b1df222}, {1, 0xa16a5c70},
|
||||
{2, 0xbbccedc6}, {2, 0xfe38d0ef},
|
||||
};
|
||||
|
||||
// NOTE: These tests rely on CreateNewBlock doing its own self-validation!
|
||||
BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
||||
{
|
||||
CReserveKey reservekey(pwalletMain);
|
||||
CBlockTemplate *pblocktemplate;
|
||||
CTransaction tx;
|
||||
CScript script;
|
||||
uint256 hash;
|
||||
|
||||
// Simple block creation, nothing special yet:
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
|
||||
// We can't make transactions until we have inputs
|
||||
// Therefore, load 100 blocks :)
|
||||
std::vector<CTransaction*>txFirst;
|
||||
for (unsigned int i = 0; i < sizeof(blockinfo)/sizeof(*blockinfo); ++i)
|
||||
{
|
||||
CBlock *pblock = &pblocktemplate->block; // pointer for convenience
|
||||
pblock->nVersion = 1;
|
||||
pblock->nTime = pindexBest->GetMedianTimePast()+1;
|
||||
pblock->vtx[0].vin[0].scriptSig = CScript();
|
||||
pblock->vtx[0].vin[0].scriptSig.push_back(blockinfo[i].extranonce);
|
||||
pblock->vtx[0].vin[0].scriptSig.push_back(pindexBest->nHeight);
|
||||
pblock->vtx[0].vout[0].scriptPubKey = CScript();
|
||||
if (txFirst.size() < 2)
|
||||
txFirst.push_back(new CTransaction(pblock->vtx[0]));
|
||||
pblock->hashMerkleRoot = pblock->BuildMerkleTree();
|
||||
pblock->nNonce = blockinfo[i].nonce;
|
||||
CValidationState state;
|
||||
BOOST_CHECK(ProcessBlock(state, NULL, pblock));
|
||||
BOOST_CHECK(state.IsValid());
|
||||
pblock->hashPrevBlock = pblock->GetHash();
|
||||
}
|
||||
delete pblocktemplate;
|
||||
|
||||
// Just to make sure we can still make simple blocks
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
|
||||
// block sigops > limit: 1000 CHECKMULTISIG + 1
|
||||
tx.vin.resize(1);
|
||||
// NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
|
||||
tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
|
||||
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
||||
tx.vin[0].prevout.n = 0;
|
||||
tx.vout.resize(1);
|
||||
tx.vout[0].nValue = 5000000000LL;
|
||||
for (unsigned int i = 0; i < 1001; ++i)
|
||||
{
|
||||
tx.vout[0].nValue -= 1000000;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
tx.vin[0].prevout.hash = hash;
|
||||
}
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// block size > limit
|
||||
tx.vin[0].scriptSig = CScript();
|
||||
// 18 * (520char + DROP) + OP_1 = 9433 bytes
|
||||
std::vector<unsigned char> vchData(520);
|
||||
for (unsigned int i = 0; i < 18; ++i)
|
||||
tx.vin[0].scriptSig << vchData << OP_DROP;
|
||||
tx.vin[0].scriptSig << OP_1;
|
||||
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
||||
tx.vout[0].nValue = 5000000000LL;
|
||||
for (unsigned int i = 0; i < 128; ++i)
|
||||
{
|
||||
tx.vout[0].nValue -= 10000000;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
tx.vin[0].prevout.hash = hash;
|
||||
}
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// orphan in mempool
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// child with higher priority than parent
|
||||
tx.vin[0].scriptSig = CScript() << OP_1;
|
||||
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
||||
tx.vout[0].nValue = 4900000000LL;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
tx.vin[0].prevout.hash = hash;
|
||||
tx.vin.resize(2);
|
||||
tx.vin[1].scriptSig = CScript() << OP_1;
|
||||
tx.vin[1].prevout.hash = txFirst[0]->GetHash();
|
||||
tx.vin[1].prevout.n = 0;
|
||||
tx.vout[0].nValue = 5900000000LL;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// coinbase in mempool
|
||||
tx.vin.resize(1);
|
||||
tx.vin[0].prevout.SetNull();
|
||||
tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
|
||||
tx.vout[0].nValue = 0;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// invalid (pre-p2sh) txn in mempool
|
||||
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
||||
tx.vin[0].prevout.n = 0;
|
||||
tx.vin[0].scriptSig = CScript() << OP_1;
|
||||
tx.vout[0].nValue = 4900000000LL;
|
||||
script = CScript() << OP_0;
|
||||
tx.vout[0].scriptPubKey.SetDestination(script.GetID());
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
tx.vin[0].prevout.hash = hash;
|
||||
tx.vin[0].scriptSig = CScript() << (std::vector<unsigned char>)script;
|
||||
tx.vout[0].nValue -= 1000000;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash,tx);
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// double spend txn pair in mempool
|
||||
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
||||
tx.vin[0].scriptSig = CScript() << OP_1;
|
||||
tx.vout[0].nValue = 4900000000LL;
|
||||
tx.vout[0].scriptPubKey = CScript() << OP_1;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
tx.vout[0].scriptPubKey = CScript() << OP_2;
|
||||
hash = tx.GetHash();
|
||||
mempool.addUnchecked(hash, tx);
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
mempool.clear();
|
||||
|
||||
// subsidy changing
|
||||
int nHeight = pindexBest->nHeight;
|
||||
pindexBest->nHeight = 209999;
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
pindexBest->nHeight = 210000;
|
||||
BOOST_CHECK(pblocktemplate = CreateNewBlockWithKey(reservekey));
|
||||
delete pblocktemplate;
|
||||
pindexBest->nHeight = nHeight;
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(sha256transform_equality)
|
||||
{
|
||||
unsigned int pSHA256InitState[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
|
||||
|
||||
@@ -20,8 +20,6 @@ using namespace boost::assign;
|
||||
typedef vector<unsigned char> valtype;
|
||||
|
||||
extern uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
|
||||
extern bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
|
||||
bool fValidatePayToScriptHash, int nHashType);
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(multisig_tests)
|
||||
|
||||
@@ -32,7 +30,7 @@ sign_multisig(CScript scriptPubKey, vector<CKey> keys, CTransaction transaction,
|
||||
|
||||
CScript result;
|
||||
result << OP_0; // CHECKMULTISIG bug workaround
|
||||
BOOST_FOREACH(CKey key, keys)
|
||||
BOOST_FOREACH(const CKey &key, keys)
|
||||
{
|
||||
vector<unsigned char> vchSig;
|
||||
BOOST_CHECK(key.Sign(hash, vchSig));
|
||||
@@ -44,6 +42,8 @@ sign_multisig(CScript scriptPubKey, vector<CKey> keys, CTransaction transaction,
|
||||
|
||||
BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
{
|
||||
unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
|
||||
|
||||
CKey key[4];
|
||||
for (int i = 0; i < 4; i++)
|
||||
key[i].MakeNewKey(true);
|
||||
@@ -80,19 +80,19 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
keys.clear();
|
||||
keys += key[0],key[1]; // magic operator+= from boost.assign
|
||||
s = sign_multisig(a_and_b, keys, txTo[0], 0);
|
||||
BOOST_CHECK(VerifyScript(s, a_and_b, txTo[0], 0, true, 0));
|
||||
BOOST_CHECK(VerifyScript(s, a_and_b, txTo[0], 0, flags, 0));
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
keys.clear();
|
||||
keys += key[i];
|
||||
s = sign_multisig(a_and_b, keys, txTo[0], 0);
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, txTo[0], 0, true, 0), strprintf("a&b 1: %d", i));
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, txTo[0], 0, flags, 0), strprintf("a&b 1: %d", i));
|
||||
|
||||
keys.clear();
|
||||
keys += key[1],key[i];
|
||||
s = sign_multisig(a_and_b, keys, txTo[0], 0);
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, txTo[0], 0, true, 0), strprintf("a&b 2: %d", i));
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_and_b, txTo[0], 0, flags, 0), strprintf("a&b 2: %d", i));
|
||||
}
|
||||
|
||||
// Test a OR b:
|
||||
@@ -102,16 +102,16 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
keys += key[i];
|
||||
s = sign_multisig(a_or_b, keys, txTo[1], 0);
|
||||
if (i == 0 || i == 1)
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(s, a_or_b, txTo[1], 0, true, 0), strprintf("a|b: %d", i));
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(s, a_or_b, txTo[1], 0, flags, 0), strprintf("a|b: %d", i));
|
||||
else
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_or_b, txTo[1], 0, true, 0), strprintf("a|b: %d", i));
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, a_or_b, txTo[1], 0, flags, 0), strprintf("a|b: %d", i));
|
||||
}
|
||||
s.clear();
|
||||
s << OP_0 << OP_0;
|
||||
BOOST_CHECK(!VerifyScript(s, a_or_b, txTo[1], 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(s, a_or_b, txTo[1], 0, flags, 0));
|
||||
s.clear();
|
||||
s << OP_0 << OP_1;
|
||||
BOOST_CHECK(!VerifyScript(s, a_or_b, txTo[1], 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(s, a_or_b, txTo[1], 0, flags, 0));
|
||||
|
||||
|
||||
for (int i = 0; i < 4; i++)
|
||||
@@ -121,9 +121,9 @@ BOOST_AUTO_TEST_CASE(multisig_verify)
|
||||
keys += key[i],key[j];
|
||||
s = sign_multisig(escrow, keys, txTo[2], 0);
|
||||
if (i < j && i < 3 && j < 3)
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(s, escrow, txTo[2], 0, true, 0), strprintf("escrow 1: %d %d", i, j));
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(s, escrow, txTo[2], 0, flags, 0), strprintf("escrow 1: %d %d", i, j));
|
||||
else
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, escrow, txTo[2], 0, true, 0), strprintf("escrow 2: %d %d", i, j));
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(s, escrow, txTo[2], 0, flags, 0), strprintf("escrow 2: %d %d", i, j));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -216,7 +216,7 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
||||
CScript s;
|
||||
s << OP_2 << key[0].GetPubKey() << key[1].GetPubKey() << OP_2 << OP_CHECKMULTISIG;
|
||||
BOOST_CHECK(Solver(s, whichType, solutions));
|
||||
BOOST_CHECK_EQUAL(solutions.size(), 4);
|
||||
BOOST_CHECK_EQUAL(solutions.size(), 4U);
|
||||
CTxDestination addr;
|
||||
BOOST_CHECK(!ExtractDestination(s, addr));
|
||||
BOOST_CHECK(IsMine(keystore, s));
|
||||
@@ -229,7 +229,7 @@ BOOST_AUTO_TEST_CASE(multisig_Solver1)
|
||||
CScript s;
|
||||
s << OP_1 << key[0].GetPubKey() << key[1].GetPubKey() << OP_2 << OP_CHECKMULTISIG;
|
||||
BOOST_CHECK(Solver(s, whichType, solutions));
|
||||
BOOST_CHECK_EQUAL(solutions.size(), 4);
|
||||
BOOST_CHECK_EQUAL(solutions.size(), 4U);
|
||||
vector<CTxDestination> addrs;
|
||||
int nRequired;
|
||||
BOOST_CHECK(ExtractDestinations(s, whichType, addrs, nRequired));
|
||||
|
||||
@@ -52,20 +52,20 @@ bool static TestSplitHost(string test, string host, int port)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(netbase_splithost)
|
||||
{
|
||||
BOOST_CHECK(TestSplitHost("www.casinocoin.org", "www.casinocoin.org", -1));
|
||||
BOOST_CHECK(TestSplitHost("[www.casinocoin.org]", "www.casinocoin.org", -1));
|
||||
BOOST_CHECK(TestSplitHost("www.casinocoin.org:80", "www.casinocoin.org", 80));
|
||||
BOOST_CHECK(TestSplitHost("[www.casinocoin.org]:80", "www.casinocoin.org", 80));
|
||||
BOOST_CHECK(TestSplitHost("www.bitcoin.org", "www.bitcoin.org", -1));
|
||||
BOOST_CHECK(TestSplitHost("[www.bitcoin.org]", "www.bitcoin.org", -1));
|
||||
BOOST_CHECK(TestSplitHost("www.bitcoin.org:80", "www.bitcoin.org", 80));
|
||||
BOOST_CHECK(TestSplitHost("[www.bitcoin.org]:80", "www.bitcoin.org", 80));
|
||||
BOOST_CHECK(TestSplitHost("127.0.0.1", "127.0.0.1", -1));
|
||||
BOOST_CHECK(TestSplitHost("127.0.0.1:8333", "127.0.0.1", 8333));
|
||||
BOOST_CHECK(TestSplitHost("127.0.0.1:47950", "127.0.0.1", 47950));
|
||||
BOOST_CHECK(TestSplitHost("[127.0.0.1]", "127.0.0.1", -1));
|
||||
BOOST_CHECK(TestSplitHost("[127.0.0.1]:8333", "127.0.0.1", 8333));
|
||||
BOOST_CHECK(TestSplitHost("[127.0.0.1]:47950", "127.0.0.1", 47950));
|
||||
BOOST_CHECK(TestSplitHost("::ffff:127.0.0.1", "::ffff:127.0.0.1", -1));
|
||||
BOOST_CHECK(TestSplitHost("[::ffff:127.0.0.1]:8333", "::ffff:127.0.0.1", 8333));
|
||||
BOOST_CHECK(TestSplitHost("[::]:8333", "::", 8333));
|
||||
BOOST_CHECK(TestSplitHost("::8333", "::8333", -1));
|
||||
BOOST_CHECK(TestSplitHost(":8333", "", 8333));
|
||||
BOOST_CHECK(TestSplitHost("[]:8333", "", 8333));
|
||||
BOOST_CHECK(TestSplitHost("[::ffff:127.0.0.1]:47950", "::ffff:127.0.0.1", 47950));
|
||||
BOOST_CHECK(TestSplitHost("[::]:47950", "::", 47950));
|
||||
BOOST_CHECK(TestSplitHost("::47950", "::47950", -1));
|
||||
BOOST_CHECK(TestSplitHost(":47950", "", 47950));
|
||||
BOOST_CHECK(TestSplitHost("[]:47950", "", 47950));
|
||||
BOOST_CHECK(TestSplitHost("", "", -1));
|
||||
}
|
||||
|
||||
@@ -80,10 +80,10 @@ bool static TestParse(string src, string canon)
|
||||
BOOST_AUTO_TEST_CASE(netbase_lookupnumeric)
|
||||
{
|
||||
BOOST_CHECK(TestParse("127.0.0.1", "127.0.0.1:65535"));
|
||||
BOOST_CHECK(TestParse("127.0.0.1:8333", "127.0.0.1:8333"));
|
||||
BOOST_CHECK(TestParse("127.0.0.1:47950", "127.0.0.1:47950"));
|
||||
BOOST_CHECK(TestParse("::ffff:127.0.0.1", "127.0.0.1:65535"));
|
||||
BOOST_CHECK(TestParse("::", "[::]:65535"));
|
||||
BOOST_CHECK(TestParse("[::]:8333", "[::]:8333"));
|
||||
BOOST_CHECK(TestParse("[::]:47950", "[::]:47950"));
|
||||
BOOST_CHECK(TestParse("[127.0.0.1]", "127.0.0.1:65535"));
|
||||
BOOST_CHECK(TestParse(":::", ""));
|
||||
}
|
||||
|
||||
98
src/test/pmt_tests.cpp
Normal file
98
src/test/pmt_tests.cpp
Normal file
@@ -0,0 +1,98 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include "uint256.h"
|
||||
#include "main.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
class CPartialMerkleTreeTester : public CPartialMerkleTree
|
||||
{
|
||||
public:
|
||||
// flip one bit in one of the hashes - this should break the authentication
|
||||
void Damage() {
|
||||
unsigned int n = rand() % vHash.size();
|
||||
int bit = rand() % 256;
|
||||
uint256 &hash = vHash[n];
|
||||
hash ^= ((uint256)1 << bit);
|
||||
}
|
||||
};
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(pmt_tests)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(pmt_test1)
|
||||
{
|
||||
static const unsigned int nTxCounts[] = {1, 4, 7, 17, 56, 100, 127, 256, 312, 513, 1000, 4095};
|
||||
|
||||
for (int n = 0; n < 12; n++) {
|
||||
unsigned int nTx = nTxCounts[n];
|
||||
|
||||
// build a block with some dummy transactions
|
||||
CBlock block;
|
||||
for (unsigned int j=0; j<nTx; j++) {
|
||||
CTransaction tx;
|
||||
tx.nLockTime = rand(); // actual transaction data doesn't matter; just make the nLockTime's unique
|
||||
block.vtx.push_back(tx);
|
||||
}
|
||||
|
||||
// calculate actual merkle root and height
|
||||
uint256 merkleRoot1 = block.BuildMerkleTree();
|
||||
std::vector<uint256> vTxid(nTx, 0);
|
||||
for (unsigned int j=0; j<nTx; j++)
|
||||
vTxid[j] = block.vtx[j].GetHash();
|
||||
int nHeight = 1, nTx_ = nTx;
|
||||
while (nTx_ > 1) {
|
||||
nTx_ = (nTx_+1)/2;
|
||||
nHeight++;
|
||||
}
|
||||
|
||||
// check with random subsets with inclusion chances 1, 1/2, 1/4, ..., 1/128
|
||||
for (int att = 1; att < 15; att++) {
|
||||
// build random subset of txid's
|
||||
std::vector<bool> vMatch(nTx, false);
|
||||
std::vector<uint256> vMatchTxid1;
|
||||
for (unsigned int j=0; j<nTx; j++) {
|
||||
bool fInclude = (rand() & ((1 << (att/2)) - 1)) == 0;
|
||||
vMatch[j] = fInclude;
|
||||
if (fInclude)
|
||||
vMatchTxid1.push_back(vTxid[j]);
|
||||
}
|
||||
|
||||
// build the partial merkle tree
|
||||
CPartialMerkleTree pmt1(vTxid, vMatch);
|
||||
|
||||
// serialize
|
||||
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
|
||||
ss << pmt1;
|
||||
|
||||
// verify CPartialMerkleTree's size guarantees
|
||||
unsigned int n = std::min<unsigned int>(nTx, 1 + vMatchTxid1.size()*nHeight);
|
||||
BOOST_CHECK(ss.size() <= 10 + (258*n+7)/8);
|
||||
|
||||
// deserialize into a tester copy
|
||||
CPartialMerkleTreeTester pmt2;
|
||||
ss >> pmt2;
|
||||
|
||||
// extract merkle root and matched txids from copy
|
||||
std::vector<uint256> vMatchTxid2;
|
||||
uint256 merkleRoot2 = pmt2.ExtractMatches(vMatchTxid2);
|
||||
|
||||
// check that it has the same merkle root as the original, and a valid one
|
||||
BOOST_CHECK(merkleRoot1 == merkleRoot2);
|
||||
BOOST_CHECK(merkleRoot2 != 0);
|
||||
|
||||
// check that it contains the matched transactions (in the same order!)
|
||||
BOOST_CHECK(vMatchTxid1 == vMatchTxid2);
|
||||
|
||||
// check that random bit flips break the authentication
|
||||
for (int j=0; j<4; j++) {
|
||||
CPartialMerkleTreeTester pmt3(pmt2);
|
||||
pmt3.Damage();
|
||||
std::vector<uint256> vMatchTxid3;
|
||||
uint256 merkleRoot3 = pmt3.ExtractMatches(vMatchTxid3);
|
||||
BOOST_CHECK(merkleRoot3 != merkleRoot1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
@@ -1,5 +1,6 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/algorithm/string.hpp>
|
||||
#include <boost/foreach.hpp>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include "base58.h"
|
||||
#include "util.h"
|
||||
@@ -17,19 +18,12 @@ createArgs(int nRequired, const char* address1=NULL, const char* address2=NULL)
|
||||
result.push_back(nRequired);
|
||||
Array addresses;
|
||||
if (address1) addresses.push_back(address1);
|
||||
if (address2) addresses.push_back(address1);
|
||||
if (address2) addresses.push_back(address2);
|
||||
result.push_back(addresses);
|
||||
return result;
|
||||
}
|
||||
|
||||
// This can be removed this when addmultisigaddress is enabled on main net:
|
||||
struct TestNetFixture
|
||||
{
|
||||
TestNetFixture() { fTestNet = true; }
|
||||
~TestNetFixture() { fTestNet = false; }
|
||||
};
|
||||
|
||||
BOOST_FIXTURE_TEST_CASE(rpc_addmultisig, TestNetFixture)
|
||||
BOOST_AUTO_TEST_CASE(rpc_addmultisig)
|
||||
{
|
||||
rpcfn_type addmultisig = tableRPC["addmultisigaddress"]->actor;
|
||||
|
||||
@@ -66,4 +60,112 @@ BOOST_FIXTURE_TEST_CASE(rpc_addmultisig, TestNetFixture)
|
||||
BOOST_CHECK_THROW(addmultisig(createArgs(2, short2.c_str()), false), runtime_error);
|
||||
}
|
||||
|
||||
static Value CallRPC(string args)
|
||||
{
|
||||
vector<string> vArgs;
|
||||
boost::split(vArgs, args, boost::is_any_of(" \t"));
|
||||
string strMethod = vArgs[0];
|
||||
vArgs.erase(vArgs.begin());
|
||||
Array params = RPCConvertValues(strMethod, vArgs);
|
||||
|
||||
rpcfn_type method = tableRPC[strMethod]->actor;
|
||||
try {
|
||||
Value result = (*method)(params, false);
|
||||
return result;
|
||||
}
|
||||
catch (Object& objError)
|
||||
{
|
||||
throw runtime_error(find_value(objError, "message").get_str());
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(rpc_wallet)
|
||||
{
|
||||
// Test RPC calls for various wallet statistics
|
||||
Value r;
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listunspent"));
|
||||
BOOST_CHECK_THROW(CallRPC("listunspent string"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("listunspent 0 string"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("listunspent 0 1 not_array"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("listunspent 0 1 [] extra"), runtime_error);
|
||||
BOOST_CHECK_NO_THROW(r=CallRPC("listunspent 0 1 []"));
|
||||
BOOST_CHECK(r.get_array().empty());
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaddress"));
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaddress 0"));
|
||||
BOOST_CHECK_THROW(CallRPC("listreceivedbyaddress not_int"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("listreceivedbyaddress 0 not_bool"), runtime_error);
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaddress 0 true"));
|
||||
BOOST_CHECK_THROW(CallRPC("listreceivedbyaddress 0 true extra"), runtime_error);
|
||||
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaccount"));
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaccount 0"));
|
||||
BOOST_CHECK_THROW(CallRPC("listreceivedbyaccount not_int"), runtime_error);
|
||||
BOOST_CHECK_THROW(CallRPC("listreceivedbyaccount 0 not_bool"), runtime_error);
|
||||
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaccount 0 true"));
|
||||
BOOST_CHECK_THROW(CallRPC("listreceivedbyaccount 0 true extra"), runtime_error);
|
||||
}
|
||||
|
||||
|
||||
BOOST_AUTO_TEST_CASE(rpc_rawparams)
|
||||
{
|
||||
// Test raw transaction API argument handling
|
||||
Value 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("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_NO_THROW(CallRPC("createrawtransaction [] {}"));
|
||||
BOOST_CHECK_THROW(CallRPC("createrawtransaction [] {} extra"), 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_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(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);
|
||||
|
||||
// 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_AUTO_TEST_CASE(rpc_rawsign)
|
||||
{
|
||||
Value r;
|
||||
// input is a 1-of-2 multisig (so is output):
|
||||
string prevout =
|
||||
"[{\"txid\":\"b4cc287e58f87cdae59417329f710f3ecd75a4ee1d2872b7248f50977c8493f3\","
|
||||
"\"vout\":1,\"scriptPubKey\":\"a914b10c9df5f7edf436c697f02f1efdba4cf399615187\","
|
||||
"\"redeemScript\":\"512103debedc17b3df2badbcdd86d5feb4562b86fe182e5998abd8bcd4f122c6155b1b21027e940bb73ab8732bfdf7f9216ecefca5b94d6df834e77e108f68e66f126044c052ae\"}]";
|
||||
r = CallRPC(string("createrawtransaction ")+prevout+" "+
|
||||
"{\"3HqAe9LtNBjnsfM4CyYaWTnvCaUYT7v4oZ\":11}");
|
||||
string notsigned = r.get_str();
|
||||
string privkey1 = "\"T6hoRM7L8u4f9vHd4eGMAmwV6AMCE11PvYi7YjrdegG223kw64r1\"";
|
||||
string privkey2 = "\"T5Xu6pe5iqQYqXGxhcY2QEFr7NNoVQ5R6A4abpswunCTF9w85g8V\"";
|
||||
r = CallRPC(string("signrawtransaction ")+notsigned+" "+prevout+" "+"[]");
|
||||
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == false);
|
||||
r = CallRPC(string("signrawtransaction ")+notsigned+" "+prevout+" "+"["+privkey1+","+privkey2+"]");
|
||||
BOOST_CHECK(find_value(r.get_obj(), "complete").get_bool() == true);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@@ -13,8 +13,6 @@ using namespace std;
|
||||
|
||||
// Test routines internal to script.cpp:
|
||||
extern uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
|
||||
extern bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
|
||||
bool fValidatePayToScriptHash, int nHashType);
|
||||
|
||||
// Helpers:
|
||||
static std::vector<unsigned char>
|
||||
@@ -40,7 +38,7 @@ Verify(const CScript& scriptSig, const CScript& scriptPubKey, bool fStrict)
|
||||
txTo.vin[0].scriptSig = scriptSig;
|
||||
txTo.vout[0].nValue = 1;
|
||||
|
||||
return VerifyScript(scriptSig, scriptPubKey, txTo, 0, fStrict, 0);
|
||||
return VerifyScript(scriptSig, scriptPubKey, txTo, 0, fStrict ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE, 0);
|
||||
}
|
||||
|
||||
|
||||
@@ -80,7 +78,9 @@ BOOST_AUTO_TEST_CASE(sign)
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
txFrom.vout[i].scriptPubKey = evalScripts[i];
|
||||
txFrom.vout[i].nValue = COIN;
|
||||
txFrom.vout[i+4].scriptPubKey = standardScripts[i];
|
||||
txFrom.vout[i+4].nValue = COIN;
|
||||
}
|
||||
BOOST_CHECK(txFrom.IsStandard());
|
||||
|
||||
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(sign)
|
||||
{
|
||||
CScript sigSave = txTo[i].vin[0].scriptSig;
|
||||
txTo[i].vin[0].scriptSig = txTo[j].vin[0].scriptSig;
|
||||
bool sigOK = VerifySignature(txFrom, txTo[i], 0, true, 0);
|
||||
bool sigOK = VerifySignature(CCoins(txFrom, 0), txTo[i], 0, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, 0);
|
||||
if (i == j)
|
||||
BOOST_CHECK_MESSAGE(sigOK, strprintf("VerifySignature %d %d", i, j));
|
||||
else
|
||||
@@ -130,7 +130,7 @@ BOOST_AUTO_TEST_CASE(norecurse)
|
||||
// Should not verify, because it will try to execute OP_INVALIDOPCODE
|
||||
BOOST_CHECK(!Verify(scriptSig, p2sh, true));
|
||||
|
||||
// Try to recurse, and verification should succeed because
|
||||
// Try to recur, and verification should succeed because
|
||||
// the inner HASH160 <> EQUAL should only check the hash:
|
||||
CScript p2sh2;
|
||||
p2sh2.SetDestination(p2sh.GetID());
|
||||
@@ -145,19 +145,19 @@ BOOST_AUTO_TEST_CASE(set)
|
||||
// Test the CScript::Set* methods
|
||||
CBasicKeyStore keystore;
|
||||
CKey key[4];
|
||||
std::vector<CKey> keys;
|
||||
std::vector<CPubKey> keys;
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
key[i].MakeNewKey(true);
|
||||
keystore.AddKey(key[i]);
|
||||
keys.push_back(key[i]);
|
||||
keys.push_back(key[i].GetPubKey());
|
||||
}
|
||||
|
||||
CScript inner[4];
|
||||
inner[0].SetDestination(key[0].GetPubKey().GetID());
|
||||
inner[1].SetMultisig(2, std::vector<CKey>(keys.begin(), keys.begin()+2));
|
||||
inner[2].SetMultisig(1, std::vector<CKey>(keys.begin(), keys.begin()+2));
|
||||
inner[3].SetMultisig(2, std::vector<CKey>(keys.begin(), keys.begin()+3));
|
||||
inner[1].SetMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
|
||||
inner[2].SetMultisig(1, std::vector<CPubKey>(keys.begin(), keys.begin()+2));
|
||||
inner[3].SetMultisig(2, std::vector<CPubKey>(keys.begin(), keys.begin()+3));
|
||||
|
||||
CScript outer[4];
|
||||
for (int i = 0; i < 4; i++)
|
||||
@@ -171,6 +171,7 @@ BOOST_AUTO_TEST_CASE(set)
|
||||
for (int i = 0; i < 4; i++)
|
||||
{
|
||||
txFrom.vout[i].scriptPubKey = outer[i];
|
||||
txFrom.vout[i].nValue = CENT;
|
||||
}
|
||||
BOOST_CHECK(txFrom.IsStandard());
|
||||
|
||||
@@ -181,7 +182,7 @@ BOOST_AUTO_TEST_CASE(set)
|
||||
txTo[i].vout.resize(1);
|
||||
txTo[i].vin[0].prevout.n = i;
|
||||
txTo[i].vin[0].prevout.hash = txFrom.GetHash();
|
||||
txTo[i].vout[0].nValue = 1;
|
||||
txTo[i].vout[0].nValue = 1*CENT;
|
||||
txTo[i].vout[0].scriptPubKey = inner[i];
|
||||
BOOST_CHECK_MESSAGE(IsMine(keystore, txFrom.vout[i].scriptPubKey), strprintf("IsMine %d", i));
|
||||
}
|
||||
@@ -225,7 +226,7 @@ BOOST_AUTO_TEST_CASE(is)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(switchover)
|
||||
{
|
||||
// Test switchover code
|
||||
// Test switch over code
|
||||
CScript notValid;
|
||||
notValid << OP_11 << OP_12 << OP_EQUALVERIFY;
|
||||
CScript scriptSig;
|
||||
@@ -243,15 +244,16 @@ BOOST_AUTO_TEST_CASE(switchover)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
{
|
||||
std::map<uint256, std::pair<CTxIndex, CTransaction> > mapInputs;
|
||||
CCoinsView coinsDummy;
|
||||
CCoinsViewCache coins(coinsDummy);
|
||||
CBasicKeyStore keystore;
|
||||
CKey key[3];
|
||||
vector<CKey> keys;
|
||||
vector<CPubKey> keys;
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
key[i].MakeNewKey(true);
|
||||
keystore.AddKey(key[i]);
|
||||
keys.push_back(key[i]);
|
||||
keys.push_back(key[i].GetPubKey());
|
||||
}
|
||||
|
||||
CTransaction txFrom;
|
||||
@@ -264,23 +266,29 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
CScript pay1of3; pay1of3.SetMultisig(1, keys);
|
||||
|
||||
txFrom.vout[0].scriptPubKey = payScriptHash1;
|
||||
txFrom.vout[0].nValue = 1000;
|
||||
txFrom.vout[1].scriptPubKey = pay1;
|
||||
txFrom.vout[1].nValue = 2000;
|
||||
txFrom.vout[2].scriptPubKey = pay1of3;
|
||||
txFrom.vout[2].nValue = 3000;
|
||||
|
||||
// Last three non-standard:
|
||||
CScript empty;
|
||||
keystore.AddCScript(empty);
|
||||
txFrom.vout[3].scriptPubKey = empty;
|
||||
txFrom.vout[3].nValue = 4000;
|
||||
// Can't use SetPayToScriptHash, it checks for the empty Script. So:
|
||||
txFrom.vout[4].scriptPubKey << OP_HASH160 << Hash160(empty) << OP_EQUAL;
|
||||
txFrom.vout[4].nValue = 5000;
|
||||
CScript oneOfEleven;
|
||||
oneOfEleven << OP_1;
|
||||
for (int i = 0; i < 11; i++)
|
||||
oneOfEleven << key[0].GetPubKey();
|
||||
oneOfEleven << OP_11 << OP_CHECKMULTISIG;
|
||||
txFrom.vout[5].scriptPubKey.SetDestination(oneOfEleven.GetID());
|
||||
txFrom.vout[5].nValue = 6000;
|
||||
|
||||
mapInputs[txFrom.GetHash()] = make_pair(CTxIndex(), txFrom);
|
||||
coins.SetCoins(txFrom.GetHash(), CCoins(txFrom, 0));
|
||||
|
||||
CTransaction txTo;
|
||||
txTo.vout.resize(1);
|
||||
@@ -297,21 +305,22 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
txTo.vin[2].prevout.hash = txFrom.GetHash();
|
||||
BOOST_CHECK(SignSignature(keystore, txFrom, txTo, 2));
|
||||
|
||||
BOOST_CHECK(txTo.AreInputsStandard(mapInputs));
|
||||
BOOST_CHECK_EQUAL(txTo.GetP2SHSigOpCount(mapInputs), 1);
|
||||
BOOST_CHECK(txTo.AreInputsStandard(coins));
|
||||
BOOST_CHECK_EQUAL(txTo.GetP2SHSigOpCount(coins), 1U);
|
||||
|
||||
// Make sure adding crap to the scriptSigs makes them non-standard:
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
CScript t = txTo.vin[i].scriptSig;
|
||||
txTo.vin[i].scriptSig = (CScript() << 11) + t;
|
||||
BOOST_CHECK(!txTo.AreInputsStandard(mapInputs));
|
||||
BOOST_CHECK(!txTo.AreInputsStandard(coins));
|
||||
txTo.vin[i].scriptSig = t;
|
||||
}
|
||||
|
||||
CTransaction txToNonStd;
|
||||
txToNonStd.vout.resize(1);
|
||||
txToNonStd.vout[0].scriptPubKey.SetDestination(key[1].GetPubKey().GetID());
|
||||
txToNonStd.vout[0].nValue = 1000;
|
||||
txToNonStd.vin.resize(2);
|
||||
txToNonStd.vin[0].prevout.n = 4;
|
||||
txToNonStd.vin[0].prevout.hash = txFrom.GetHash();
|
||||
@@ -320,11 +329,11 @@ BOOST_AUTO_TEST_CASE(AreInputsStandard)
|
||||
txToNonStd.vin[1].prevout.hash = txFrom.GetHash();
|
||||
txToNonStd.vin[1].scriptSig << OP_0 << Serialize(oneOfEleven);
|
||||
|
||||
BOOST_CHECK(!txToNonStd.AreInputsStandard(mapInputs));
|
||||
BOOST_CHECK_EQUAL(txToNonStd.GetP2SHSigOpCount(mapInputs), 11);
|
||||
BOOST_CHECK(!txToNonStd.AreInputsStandard(coins));
|
||||
BOOST_CHECK_EQUAL(txToNonStd.GetP2SHSigOpCount(coins), 11U);
|
||||
|
||||
txToNonStd.vin[0].scriptSig.clear();
|
||||
BOOST_CHECK(!txToNonStd.AreInputsStandard(mapInputs));
|
||||
BOOST_CHECK(!txToNonStd.AreInputsStandard(coins));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@@ -20,8 +20,8 @@ using namespace json_spirit;
|
||||
using namespace boost::algorithm;
|
||||
|
||||
extern uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
|
||||
extern bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
|
||||
bool fValidatePayToScriptHash, int nHashType);
|
||||
|
||||
static const unsigned int flags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
|
||||
|
||||
CScript
|
||||
ParseScript(string s)
|
||||
@@ -79,7 +79,7 @@ ParseScript(string s)
|
||||
{
|
||||
BOOST_ERROR("Parse error: " << s);
|
||||
return CScript();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
@@ -143,7 +143,7 @@ BOOST_AUTO_TEST_CASE(script_valid)
|
||||
CScript scriptPubKey = ParseScript(scriptPubKeyString);
|
||||
|
||||
CTransaction tx;
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, tx, 0, true, SIGHASH_NONE), strTest);
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, tx, 0, flags, SIGHASH_NONE), strTest);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -167,7 +167,7 @@ BOOST_AUTO_TEST_CASE(script_invalid)
|
||||
CScript scriptPubKey = ParseScript(scriptPubKeyString);
|
||||
|
||||
CTransaction tx;
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(scriptSig, scriptPubKey, tx, 0, true, SIGHASH_NONE), strTest);
|
||||
BOOST_CHECK_MESSAGE(!VerifyScript(scriptSig, scriptPubKey, tx, 0, flags, SIGHASH_NONE), strTest);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -181,18 +181,18 @@ BOOST_AUTO_TEST_CASE(script_PushData)
|
||||
static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
|
||||
|
||||
vector<vector<unsigned char> > directStack;
|
||||
BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), CTransaction(), 0, 0));
|
||||
BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), CTransaction(), 0, true, 0));
|
||||
|
||||
vector<vector<unsigned char> > pushdata1Stack;
|
||||
BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), CTransaction(), 0, 0));
|
||||
BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), CTransaction(), 0, true, 0));
|
||||
BOOST_CHECK(pushdata1Stack == directStack);
|
||||
|
||||
vector<vector<unsigned char> > pushdata2Stack;
|
||||
BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), CTransaction(), 0, 0));
|
||||
BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), CTransaction(), 0, true, 0));
|
||||
BOOST_CHECK(pushdata2Stack == directStack);
|
||||
|
||||
vector<vector<unsigned char> > pushdata4Stack;
|
||||
BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), CTransaction(), 0, 0));
|
||||
BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), CTransaction(), 0, true, 0));
|
||||
BOOST_CHECK(pushdata4Stack == directStack);
|
||||
}
|
||||
|
||||
@@ -206,12 +206,12 @@ sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transac
|
||||
// NOTE: CHECKMULTISIG has an unfortunate bug; it requires
|
||||
// one extra item on the stack, before the signatures.
|
||||
// Putting OP_0 on the stack is the workaround;
|
||||
// fixing the bug would mean splitting the blockchain (old
|
||||
// fixing the bug would mean splitting the block chain (old
|
||||
// clients would not accept new CHECKMULTISIG transactions,
|
||||
// and vice-versa)
|
||||
//
|
||||
result << OP_0;
|
||||
BOOST_FOREACH(CKey key, keys)
|
||||
BOOST_FOREACH(const CKey &key, keys)
|
||||
{
|
||||
vector<unsigned char> vchSig;
|
||||
BOOST_CHECK(key.Sign(hash, vchSig));
|
||||
@@ -221,7 +221,7 @@ sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transac
|
||||
return result;
|
||||
}
|
||||
CScript
|
||||
sign_multisig(CScript scriptPubKey, CKey key, CTransaction transaction)
|
||||
sign_multisig(CScript scriptPubKey, const CKey &key, CTransaction transaction)
|
||||
{
|
||||
std::vector<CKey> keys;
|
||||
keys.push_back(key);
|
||||
@@ -250,15 +250,15 @@ BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
|
||||
txTo12.vout[0].nValue = 1;
|
||||
|
||||
CScript goodsig1 = sign_multisig(scriptPubKey12, key1, txTo12);
|
||||
BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, txTo12, 0, true, 0));
|
||||
BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, txTo12, 0, flags, 0));
|
||||
txTo12.vout[0].nValue = 2;
|
||||
BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, txTo12, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, txTo12, 0, flags, 0));
|
||||
|
||||
CScript goodsig2 = sign_multisig(scriptPubKey12, key2, txTo12);
|
||||
BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, txTo12, 0, true, 0));
|
||||
BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, txTo12, 0, flags, 0));
|
||||
|
||||
CScript badsig1 = sign_multisig(scriptPubKey12, key3, txTo12);
|
||||
BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, txTo12, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, txTo12, 0, flags, 0));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
|
||||
@@ -286,46 +286,46 @@ BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
|
||||
std::vector<CKey> keys;
|
||||
keys.push_back(key1); keys.push_back(key2);
|
||||
CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key1); keys.push_back(key3);
|
||||
CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key2); keys.push_back(key3);
|
||||
CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key2); keys.push_back(key2); // Can't re-use sig
|
||||
CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
|
||||
CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
|
||||
CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
|
||||
CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear();
|
||||
keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
|
||||
CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
|
||||
keys.clear(); // Must have signatures
|
||||
CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
|
||||
BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, txTo23, 0, true, 0));
|
||||
BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, txTo23, 0, flags, 0));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
@@ -333,11 +333,13 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
// Test the CombineSignatures function
|
||||
CBasicKeyStore keystore;
|
||||
vector<CKey> keys;
|
||||
vector<CPubKey> pubkeys;
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
CKey key;
|
||||
key.MakeNewKey(i%2 == 1);
|
||||
keys.push_back(key);
|
||||
pubkeys.push_back(key.GetPubKey());
|
||||
keystore.AddKey(key);
|
||||
}
|
||||
|
||||
@@ -390,7 +392,7 @@ BOOST_AUTO_TEST_CASE(script_combineSigs)
|
||||
BOOST_CHECK(combined == scriptSig);
|
||||
|
||||
// Hardest case: Multisig 2-of-3
|
||||
scriptPubKey.SetMultisig(2, keys);
|
||||
scriptPubKey.SetMultisig(2, pubkeys);
|
||||
keystore.AddCScript(scriptPubKey);
|
||||
SignSignature(keystore, txFrom, txTo, 0);
|
||||
combined = CombineSignatures(scriptPubKey, txTo, 0, scriptSig, empty);
|
||||
|
||||
33
src/test/scrypt_tests.cpp
Normal file
33
src/test/scrypt_tests.cpp
Normal file
@@ -0,0 +1,33 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include "util.h"
|
||||
#include "scrypt.h"
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(scrypt_tests)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(scrypt_hashtest)
|
||||
{
|
||||
// Test Scrypt hash with known inputs against expected outputs
|
||||
#define HASHCOUNT 5
|
||||
const char* inputhex[HASHCOUNT] = { "020000004c1271c211717198227392b029a64a7971931d351b387bb80db027f270411e398a07046f7d4a08dd815412a8712f874a7ebf0507e3878bd24e20a3b73fd750a667d2f451eac7471b00de6659", "0200000011503ee6a855e900c00cfdd98f5f55fffeaee9b6bf55bea9b852d9de2ce35828e204eef76acfd36949ae56d1fbe81c1ac9c0209e6331ad56414f9072506a77f8c6faf551eac7471b00389d01", "02000000a72c8a177f523946f42f22c3e86b8023221b4105e8007e59e81f6beb013e29aaf635295cb9ac966213fb56e046dc71df5b3f7f67ceaeab24038e743f883aff1aaafaf551eac7471b0166249b", "010000007824bc3a8a1b4628485eee3024abd8626721f7f870f8ad4d2f33a27155167f6a4009d1285049603888fe85a84b6c803a53305a8d497965a5e896e1a00568359589faf551eac7471b0065434e", "0200000050bfd4e4a307a8cb6ef4aef69abc5c0f2d579648bd80d7733e1ccc3fbc90ed664a7f74006cb11bde87785f229ecd366c2d4e44432832580e0608c579e4cb76f383f7f551eac7471b00c36982" };
|
||||
const char* expected[HASHCOUNT] = { "00000000002bef4107f882f6115e0b01f348d21195dacd3582aa2dabd7985806" , "00000000003a0d11bdd5eb634e08b7feddcfbbf228ed35d250daf19f1c88fc94", "00000000000b40f895f288e13244728a6c2d9d59d8aff29c65f8dd5114a8ca81", "00000000003007005891cd4923031e99d8e8d72f6e8e7edc6a86181897e105fe", "000000000018f0b426a4afc7130ccb47fa02af730d345b4fe7c7724d3800ec8c" };
|
||||
#if defined(USE_SSE2)
|
||||
scrypt_detect_sse2();
|
||||
#endif
|
||||
uint256 scrypthash;
|
||||
std::vector<unsigned char> inputbytes;
|
||||
char scratchpad[SCRYPT_SCRATCHPAD_SIZE];
|
||||
for (int i = 0; i < HASHCOUNT; i++) {
|
||||
inputbytes = ParseHex(inputhex[i]);
|
||||
#if defined(USE_SSE2)
|
||||
// Test SSE2 scrypt
|
||||
scrypt_1024_1_1_256_sp_sse2((const char*)&inputbytes[0], BEGIN(scrypthash), scratchpad);
|
||||
BOOST_CHECK_EQUAL(scrypthash.ToString().c_str(), expected[i]);
|
||||
#endif
|
||||
// Test generic scrypt
|
||||
scrypt_1024_1_1_256_sp_generic((const char*)&inputbytes[0], BEGIN(scrypthash), scratchpad);
|
||||
BOOST_CHECK_EQUAL(scrypthash.ToString().c_str(), expected[i]);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
45
src/test/serialize_tests.cpp
Normal file
45
src/test/serialize_tests.cpp
Normal file
@@ -0,0 +1,45 @@
|
||||
#include <boost/test/unit_test.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "serialize.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(serialize_tests)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(varints)
|
||||
{
|
||||
// encode
|
||||
|
||||
CDataStream ss(SER_DISK, 0);
|
||||
CDataStream::size_type size = 0;
|
||||
for (int i = 0; i < 100000; i++) {
|
||||
ss << VARINT(i);
|
||||
size += ::GetSerializeSize(VARINT(i), 0, 0);
|
||||
BOOST_CHECK(size == ss.size());
|
||||
}
|
||||
|
||||
for (uint64 i = 0; i < 100000000000ULL; i += 999999937) {
|
||||
ss << VARINT(i);
|
||||
size += ::GetSerializeSize(VARINT(i), 0, 0);
|
||||
BOOST_CHECK(size == ss.size());
|
||||
}
|
||||
|
||||
// decode
|
||||
for (int i = 0; i < 100000; i++) {
|
||||
int j = -1;
|
||||
ss >> VARINT(j);
|
||||
BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
|
||||
}
|
||||
|
||||
for (uint64 i = 0; i < 100000000000ULL; i += 999999937) {
|
||||
uint64 j = -1;
|
||||
ss >> VARINT(j);
|
||||
BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
@@ -21,40 +21,40 @@ BOOST_AUTO_TEST_CASE(GetSigOpCount)
|
||||
{
|
||||
// Test CScript::GetSigOpCount()
|
||||
CScript s1;
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 0);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 0);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 0U);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 0U);
|
||||
|
||||
uint160 dummy;
|
||||
s1 << OP_1 << dummy << dummy << OP_2 << OP_CHECKMULTISIG;
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 2);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 2U);
|
||||
s1 << OP_IF << OP_CHECKSIG << OP_ENDIF;
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 3);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 21);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(true), 3U);
|
||||
BOOST_CHECK_EQUAL(s1.GetSigOpCount(false), 21U);
|
||||
|
||||
CScript p2sh;
|
||||
p2sh.SetDestination(s1.GetID());
|
||||
CScript scriptSig;
|
||||
scriptSig << OP_0 << Serialize(s1);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig), 3);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig), 3U);
|
||||
|
||||
std::vector<CKey> keys;
|
||||
std::vector<CPubKey> keys;
|
||||
for (int i = 0; i < 3; i++)
|
||||
{
|
||||
CKey k;
|
||||
k.MakeNewKey(true);
|
||||
keys.push_back(k);
|
||||
keys.push_back(k.GetPubKey());
|
||||
}
|
||||
CScript s2;
|
||||
s2.SetMultisig(1, keys);
|
||||
BOOST_CHECK_EQUAL(s2.GetSigOpCount(true), 3);
|
||||
BOOST_CHECK_EQUAL(s2.GetSigOpCount(false), 20);
|
||||
BOOST_CHECK_EQUAL(s2.GetSigOpCount(true), 3U);
|
||||
BOOST_CHECK_EQUAL(s2.GetSigOpCount(false), 20U);
|
||||
|
||||
p2sh.SetDestination(s2.GetID());
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(true), 0);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(false), 0);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(true), 0U);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(false), 0U);
|
||||
CScript scriptSig2;
|
||||
scriptSig2 << OP_1 << dummy << dummy << Serialize(s2);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig2), 3);
|
||||
BOOST_CHECK_EQUAL(p2sh.GetSigOpCount(scriptSig2), 3U);
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@@ -1,8 +1,12 @@
|
||||
#define BOOST_TEST_MODULE Bitcoin Test Suite
|
||||
#define BOOST_TEST_MODULE CasinoCoin Test Suite
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include <boost/filesystem.hpp>
|
||||
|
||||
#include "db.h"
|
||||
#include "txdb.h"
|
||||
#include "main.h"
|
||||
#include "wallet.h"
|
||||
#include "util.h"
|
||||
|
||||
CWallet* pwalletMain;
|
||||
CClientUIInterface uiInterface;
|
||||
@@ -11,16 +15,40 @@ extern bool fPrintToConsole;
|
||||
extern void noui_connect();
|
||||
|
||||
struct TestingSetup {
|
||||
CCoinsViewDB *pcoinsdbview;
|
||||
boost::filesystem::path pathTemp;
|
||||
boost::thread_group threadGroup;
|
||||
|
||||
TestingSetup() {
|
||||
fPrintToConsole = true; // don't want to write to debug.log file
|
||||
fPrintToDebugger = true; // don't want to write to debug.log file
|
||||
noui_connect();
|
||||
pwalletMain = new CWallet();
|
||||
bitdb.MakeMock();
|
||||
pathTemp = GetTempPath() / strprintf("test_casinocoin_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
|
||||
boost::filesystem::create_directories(pathTemp);
|
||||
mapArgs["-datadir"] = pathTemp.string();
|
||||
pblocktree = new CBlockTreeDB(1 << 20, true);
|
||||
pcoinsdbview = new CCoinsViewDB(1 << 23, true);
|
||||
pcoinsTip = new CCoinsViewCache(*pcoinsdbview);
|
||||
InitBlockIndex();
|
||||
bool fFirstRun;
|
||||
pwalletMain = new CWallet("wallet.dat");
|
||||
pwalletMain->LoadWallet(fFirstRun);
|
||||
RegisterWallet(pwalletMain);
|
||||
nScriptCheckThreads = 3;
|
||||
for (int i=0; i < nScriptCheckThreads-1; i++)
|
||||
threadGroup.create_thread(&ThreadScriptCheck);
|
||||
}
|
||||
~TestingSetup()
|
||||
{
|
||||
threadGroup.interrupt_all();
|
||||
threadGroup.join_all();
|
||||
delete pwalletMain;
|
||||
pwalletMain = NULL;
|
||||
delete pcoinsTip;
|
||||
delete pcoinsdbview;
|
||||
delete pblocktree;
|
||||
bitdb.Flush(true);
|
||||
boost::filesystem::remove_all(pathTemp);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@@ -1,12 +1,159 @@
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <boost/test/unit_test.hpp>
|
||||
#include "json/json_spirit_writer_template.h"
|
||||
|
||||
#include "main.h"
|
||||
#include "wallet.h"
|
||||
|
||||
using namespace std;
|
||||
using namespace json_spirit;
|
||||
|
||||
// In script_tests.cpp
|
||||
extern Array read_json(const std::string& filename);
|
||||
extern CScript ParseScript(string s);
|
||||
|
||||
BOOST_AUTO_TEST_SUITE(transaction_tests)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(tx_valid)
|
||||
{
|
||||
// Read tests from test/data/tx_valid.json
|
||||
// Format is an array of arrays
|
||||
// Inner arrays are either [ "comment" ]
|
||||
// or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
|
||||
// ... where all scripts are stringified scripts.
|
||||
Array tests = read_json("tx_valid.json");
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
Array test = tv.get_array();
|
||||
string strTest = write_string(tv, false);
|
||||
if (test[0].type() == array_type)
|
||||
{
|
||||
if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
|
||||
map<COutPoint, CScript> mapprevOutScriptPubKeys;
|
||||
Array inputs = test[0].get_array();
|
||||
bool fValid = true;
|
||||
BOOST_FOREACH(Value& input, inputs)
|
||||
{
|
||||
if (input.type() != array_type)
|
||||
{
|
||||
fValid = false;
|
||||
break;
|
||||
}
|
||||
Array vinput = input.get_array();
|
||||
if (vinput.size() != 3)
|
||||
{
|
||||
fValid = false;
|
||||
break;
|
||||
}
|
||||
|
||||
mapprevOutScriptPubKeys[COutPoint(uint256(vinput[0].get_str()), vinput[1].get_int())] = ParseScript(vinput[2].get_str());
|
||||
}
|
||||
if (!fValid)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
|
||||
string transaction = test[1].get_str();
|
||||
CDataStream stream(ParseHex(transaction), SER_NETWORK, PROTOCOL_VERSION);
|
||||
CTransaction tx;
|
||||
stream >> tx;
|
||||
|
||||
CValidationState state;
|
||||
BOOST_CHECK_MESSAGE(tx.CheckTransaction(state), strTest);
|
||||
BOOST_CHECK(state.IsValid());
|
||||
|
||||
for (unsigned int i = 0; i < tx.vin.size(); i++)
|
||||
{
|
||||
if (!mapprevOutScriptPubKeys.count(tx.vin[i].prevout))
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
break;
|
||||
}
|
||||
|
||||
BOOST_CHECK_MESSAGE(VerifyScript(tx.vin[i].scriptSig, mapprevOutScriptPubKeys[tx.vin[i].prevout], tx, i, test[2].get_bool() ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE, 0), strTest);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(tx_invalid)
|
||||
{
|
||||
// Read tests from test/data/tx_invalid.json
|
||||
// Format is an array of arrays
|
||||
// Inner arrays are either [ "comment" ]
|
||||
// or [[[prevout hash, prevout index, prevout scriptPubKey], [input 2], ...],"], serializedTransaction, enforceP2SH
|
||||
// ... where all scripts are stringified scripts.
|
||||
Array tests = read_json("tx_invalid.json");
|
||||
|
||||
BOOST_FOREACH(Value& tv, tests)
|
||||
{
|
||||
Array test = tv.get_array();
|
||||
string strTest = write_string(tv, false);
|
||||
if (test[0].type() == array_type)
|
||||
{
|
||||
if (test.size() != 3 || test[1].type() != str_type || test[2].type() != bool_type)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
|
||||
map<COutPoint, CScript> mapprevOutScriptPubKeys;
|
||||
Array inputs = test[0].get_array();
|
||||
bool fValid = true;
|
||||
BOOST_FOREACH(Value& input, inputs)
|
||||
{
|
||||
if (input.type() != array_type)
|
||||
{
|
||||
fValid = false;
|
||||
break;
|
||||
}
|
||||
Array vinput = input.get_array();
|
||||
if (vinput.size() != 3)
|
||||
{
|
||||
fValid = false;
|
||||
break;
|
||||
}
|
||||
|
||||
mapprevOutScriptPubKeys[COutPoint(uint256(vinput[0].get_str()), vinput[1].get_int())] = ParseScript(vinput[2].get_str());
|
||||
}
|
||||
if (!fValid)
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
continue;
|
||||
}
|
||||
|
||||
string transaction = test[1].get_str();
|
||||
CDataStream stream(ParseHex(transaction), SER_NETWORK, PROTOCOL_VERSION);
|
||||
CTransaction tx;
|
||||
stream >> tx;
|
||||
|
||||
CValidationState state;
|
||||
fValid = tx.CheckTransaction(state) && state.IsValid();
|
||||
|
||||
for (unsigned int i = 0; i < tx.vin.size() && fValid; i++)
|
||||
{
|
||||
if (!mapprevOutScriptPubKeys.count(tx.vin[i].prevout))
|
||||
{
|
||||
BOOST_ERROR("Bad test: " << strTest);
|
||||
break;
|
||||
}
|
||||
|
||||
fValid = VerifyScript(tx.vin[i].scriptSig, mapprevOutScriptPubKeys[tx.vin[i].prevout], tx, i, test[2].get_bool() ? SCRIPT_VERIFY_P2SH : SCRIPT_VERIFY_NONE, 0);
|
||||
}
|
||||
|
||||
BOOST_CHECK_MESSAGE(!fValid, strTest);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(basic_transaction_tests)
|
||||
{
|
||||
// Random real transaction (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
|
||||
@@ -15,11 +162,12 @@ BOOST_AUTO_TEST_CASE(basic_transaction_tests)
|
||||
CDataStream stream(vch, SER_DISK, CLIENT_VERSION);
|
||||
CTransaction tx;
|
||||
stream >> tx;
|
||||
BOOST_CHECK_MESSAGE(tx.CheckTransaction(), "Simple deserialized transaction should be valid.");
|
||||
CValidationState state;
|
||||
BOOST_CHECK_MESSAGE(tx.CheckTransaction(state) && state.IsValid(), "Simple deserialized transaction should be valid.");
|
||||
|
||||
// Check that duplicate txins fail
|
||||
tx.vin.push_back(tx.vin[0]);
|
||||
BOOST_CHECK_MESSAGE(!tx.CheckTransaction(), "Transaction with duplicate txins should be invalid.");
|
||||
BOOST_CHECK_MESSAGE(!tx.CheckTransaction(state) || !state.IsValid(), "Transaction with duplicate txins should be invalid.");
|
||||
}
|
||||
|
||||
//
|
||||
@@ -29,7 +177,7 @@ BOOST_AUTO_TEST_CASE(basic_transaction_tests)
|
||||
// paid to a TX_PUBKEYHASH.
|
||||
//
|
||||
static std::vector<CTransaction>
|
||||
SetupDummyInputs(CBasicKeyStore& keystoreRet, MapPrevTx& inputsRet)
|
||||
SetupDummyInputs(CBasicKeyStore& keystoreRet, CCoinsView & coinsRet)
|
||||
{
|
||||
std::vector<CTransaction> dummyTransactions;
|
||||
dummyTransactions.resize(2);
|
||||
@@ -48,14 +196,14 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, MapPrevTx& inputsRet)
|
||||
dummyTransactions[0].vout[0].scriptPubKey << key[0].GetPubKey() << OP_CHECKSIG;
|
||||
dummyTransactions[0].vout[1].nValue = 50*CENT;
|
||||
dummyTransactions[0].vout[1].scriptPubKey << key[1].GetPubKey() << OP_CHECKSIG;
|
||||
inputsRet[dummyTransactions[0].GetHash()] = make_pair(CTxIndex(), dummyTransactions[0]);
|
||||
coinsRet.SetCoins(dummyTransactions[0].GetHash(), CCoins(dummyTransactions[0], 0));
|
||||
|
||||
dummyTransactions[1].vout.resize(2);
|
||||
dummyTransactions[1].vout[0].nValue = 21*CENT;
|
||||
dummyTransactions[1].vout[0].scriptPubKey.SetDestination(key[2].GetPubKey().GetID());
|
||||
dummyTransactions[1].vout[1].nValue = 22*CENT;
|
||||
dummyTransactions[1].vout[1].scriptPubKey.SetDestination(key[3].GetPubKey().GetID());
|
||||
inputsRet[dummyTransactions[1].GetHash()] = make_pair(CTxIndex(), dummyTransactions[1]);
|
||||
coinsRet.SetCoins(dummyTransactions[1].GetHash(), CCoins(dummyTransactions[1], 0));
|
||||
|
||||
return dummyTransactions;
|
||||
}
|
||||
@@ -63,8 +211,9 @@ SetupDummyInputs(CBasicKeyStore& keystoreRet, MapPrevTx& inputsRet)
|
||||
BOOST_AUTO_TEST_CASE(test_Get)
|
||||
{
|
||||
CBasicKeyStore keystore;
|
||||
MapPrevTx dummyInputs;
|
||||
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, dummyInputs);
|
||||
CCoinsView coinsDummy;
|
||||
CCoinsViewCache coins(coinsDummy);
|
||||
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
|
||||
|
||||
CTransaction t1;
|
||||
t1.vin.resize(3);
|
||||
@@ -81,40 +230,47 @@ BOOST_AUTO_TEST_CASE(test_Get)
|
||||
t1.vout[0].nValue = 90*CENT;
|
||||
t1.vout[0].scriptPubKey << OP_1;
|
||||
|
||||
BOOST_CHECK(t1.AreInputsStandard(dummyInputs));
|
||||
BOOST_CHECK_EQUAL(t1.GetValueIn(dummyInputs), (50+21+22)*CENT);
|
||||
BOOST_CHECK(t1.AreInputsStandard(coins));
|
||||
BOOST_CHECK_EQUAL(t1.GetValueIn(coins), (50+21+22)*CENT);
|
||||
|
||||
// Adding extra junk to the scriptSig should make it non-standard:
|
||||
t1.vin[0].scriptSig << OP_11;
|
||||
BOOST_CHECK(!t1.AreInputsStandard(dummyInputs));
|
||||
BOOST_CHECK(!t1.AreInputsStandard(coins));
|
||||
|
||||
// ... as should not having enough:
|
||||
t1.vin[0].scriptSig = CScript();
|
||||
BOOST_CHECK(!t1.AreInputsStandard(dummyInputs));
|
||||
BOOST_CHECK(!t1.AreInputsStandard(coins));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(test_GetThrow)
|
||||
BOOST_AUTO_TEST_CASE(test_IsStandard)
|
||||
{
|
||||
CBasicKeyStore keystore;
|
||||
MapPrevTx dummyInputs;
|
||||
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, dummyInputs);
|
||||
CCoinsView coinsDummy;
|
||||
CCoinsViewCache coins(coinsDummy);
|
||||
std::vector<CTransaction> dummyTransactions = SetupDummyInputs(keystore, coins);
|
||||
|
||||
MapPrevTx missingInputs;
|
||||
CTransaction t;
|
||||
t.vin.resize(1);
|
||||
t.vin[0].prevout.hash = dummyTransactions[0].GetHash();
|
||||
t.vin[0].prevout.n = 1;
|
||||
t.vin[0].scriptSig << std::vector<unsigned char>(65, 0);
|
||||
t.vout.resize(1);
|
||||
t.vout[0].nValue = 90*CENT;
|
||||
CKey key;
|
||||
key.MakeNewKey(true);
|
||||
t.vout[0].scriptPubKey.SetDestination(key.GetPubKey().GetID());
|
||||
|
||||
CTransaction t1;
|
||||
t1.vin.resize(3);
|
||||
t1.vin[0].prevout.hash = dummyTransactions[0].GetHash();
|
||||
t1.vin[0].prevout.n = 0;
|
||||
t1.vin[1].prevout.hash = dummyTransactions[1].GetHash();;
|
||||
t1.vin[1].prevout.n = 0;
|
||||
t1.vin[2].prevout.hash = dummyTransactions[1].GetHash();;
|
||||
t1.vin[2].prevout.n = 1;
|
||||
t1.vout.resize(2);
|
||||
t1.vout[0].nValue = 90*CENT;
|
||||
t1.vout[0].scriptPubKey << OP_1;
|
||||
BOOST_CHECK(t.IsStandard());
|
||||
|
||||
BOOST_CHECK_THROW(t1.AreInputsStandard(missingInputs), runtime_error);
|
||||
BOOST_CHECK_THROW(t1.GetValueIn(missingInputs), runtime_error);
|
||||
t.vout[0].nValue = 5011; // dust
|
||||
// CasinoCoin does not enforce isDust(). Per dust fees are considered sufficient as deterrant.
|
||||
// BOOST_CHECK(!t.IsStandard());
|
||||
|
||||
t.vout[0].nValue = 6011; // not dust
|
||||
BOOST_CHECK(t.IsStandard());
|
||||
|
||||
t.vout[0].scriptPubKey = CScript() << OP_1;
|
||||
BOOST_CHECK(!t.IsStandard());
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@@ -103,11 +103,13 @@ BOOST_AUTO_TEST_CASE(util_HexStr)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
|
||||
{
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 0), "01/01/70 00:00:00");
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 0x7FFFFFFF), "01/19/38 03:14:07");
|
||||
/*These are platform-dependant and thus removed to avoid useless test failures
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0), "1970-01-01 00:00:00");
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 0x7FFFFFFF), "2038-01-19 03:14:07");
|
||||
// Formats used within Bitcoin
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 1317425777), "09/30/11 23:36:17");
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M", 1317425777), "09/30/11 23:36");
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M:%S", 1317425777), "2011-09-30 23:36:17");
|
||||
BOOST_CHECK_EQUAL(DateTimeStrFormat("%Y-%m-%d %H:%M", 1317425777), "2011-09-30 23:36");
|
||||
*/
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(util_ParseParameters)
|
||||
@@ -259,4 +261,45 @@ BOOST_AUTO_TEST_CASE(util_IsHex)
|
||||
BOOST_CHECK(!IsHex("0x0000"));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(util_seed_insecure_rand)
|
||||
{
|
||||
int i;
|
||||
int count=0;
|
||||
|
||||
seed_insecure_rand(true);
|
||||
|
||||
for (int mod=2;mod<11;mod++)
|
||||
{
|
||||
int mask = 1;
|
||||
// Really rough binomal confidence approximation.
|
||||
int err = 30*10000./mod*sqrt((1./mod*(1-1./mod))/10000.);
|
||||
//mask is 2^ceil(log2(mod))-1
|
||||
while(mask<mod-1)mask=(mask<<1)+1;
|
||||
|
||||
count = 0;
|
||||
//How often does it get a zero from the uniform range [0,mod)?
|
||||
for (i=0;i<10000;i++)
|
||||
{
|
||||
uint32_t rval;
|
||||
do{
|
||||
rval=insecure_rand()&mask;
|
||||
}while(rval>=(uint32_t)mod);
|
||||
count += rval==0;
|
||||
}
|
||||
BOOST_CHECK(count<=10000/mod+err);
|
||||
BOOST_CHECK(count>=10000/mod-err);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_CASE(util_TimingResistantEqual)
|
||||
{
|
||||
BOOST_CHECK(TimingResistantEqual(std::string(""), std::string("")));
|
||||
BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("")));
|
||||
BOOST_CHECK(!TimingResistantEqual(std::string(""), std::string("abc")));
|
||||
BOOST_CHECK(!TimingResistantEqual(std::string("a"), std::string("aa")));
|
||||
BOOST_CHECK(!TimingResistantEqual(std::string("aa"), std::string("a")));
|
||||
BOOST_CHECK(TimingResistantEqual(std::string("abc"), std::string("abc")));
|
||||
BOOST_CHECK(!TimingResistantEqual(std::string("abc"), std::string("aba")));
|
||||
}
|
||||
|
||||
BOOST_AUTO_TEST_SUITE_END()
|
||||
|
||||
@@ -21,13 +21,12 @@ static vector<COutput> vCoins;
|
||||
|
||||
static void add_coin(int64 nValue, int nAge = 6*24, bool fIsFromMe = false, int nInput=0)
|
||||
{
|
||||
static int i;
|
||||
CTransaction* tx = new CTransaction;
|
||||
tx->nLockTime = i++; // so all transactions get different hashes
|
||||
tx->vout.resize(nInput+1);
|
||||
tx->vout[nInput].nValue = nValue;
|
||||
CWalletTx* wtx = new CWalletTx(&wallet, *tx);
|
||||
delete tx;
|
||||
static int nextLockTime = 0;
|
||||
CTransaction tx;
|
||||
tx.nLockTime = nextLockTime++; // so all transactions get different hashes
|
||||
tx.vout.resize(nInput+1);
|
||||
tx.vout[nInput].nValue = nValue;
|
||||
CWalletTx* wtx = new CWalletTx(&wallet, tx);
|
||||
if (fIsFromMe)
|
||||
{
|
||||
// IsFromMe() returns (GetDebit() > 0), and GetDebit() is 0 if vin.empty(),
|
||||
@@ -55,8 +54,8 @@ static bool equal_sets(CoinSet a, CoinSet b)
|
||||
|
||||
BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
{
|
||||
static CoinSet setCoinsRet, setCoinsRet2;
|
||||
static int64 nValueRet;
|
||||
CoinSet setCoinsRet, setCoinsRet2;
|
||||
int64 nValueRet;
|
||||
|
||||
// test multiple times to allow for differences in the shuffle order
|
||||
for (int i = 0; i < RUN_TESTS; i++)
|
||||
@@ -104,22 +103,22 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
// try making 34 cents from 1,2,5,10,20 - we can't do it exactly
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(34 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_GT(nValueRet, 34 * CENT); // but should get more than 34 cents
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3); // the best should be 20+10+5. it's incredibly unlikely the 1 or 2 got included (but possible)
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U); // the best should be 20+10+5. it's incredibly unlikely the 1 or 2 got included (but possible)
|
||||
|
||||
// when we try making 7 cents, the smaller coins (1,2,5) are enough. We should see just 2+5
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf( 7 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 7 * CENT);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
|
||||
|
||||
// when we try making 8 cents, the smaller coins (1,2,5) are exactly enough.
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf( 8 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK(nValueRet == 8 * CENT);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
|
||||
|
||||
// when we try making 9 cents, no subset of smaller coins is enough, and we get the next bigger coin (10)
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf( 9 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 10 * CENT);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
|
||||
|
||||
// now clear out the wallet and start again to test choosing between subsets of smaller coins and the next biggest coin
|
||||
empty_wallet();
|
||||
@@ -137,26 +136,26 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
// now try making 16 cents. the best smaller coins can do is 6+7+8 = 21; not as good at the next biggest coin, 20
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(16 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 20 * CENT); // we should get 20 in one coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
|
||||
|
||||
add_coin( 5*CENT); // now we have 5+6+7+8+20+30 = 75 cents total
|
||||
|
||||
// now if we try making 16 cents again, the smaller coins can make 5+6+7 = 18 cents, better than the next biggest coin, 20
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(16 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 18 * CENT); // we should get 18 in 3 coins
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
|
||||
|
||||
add_coin( 18*CENT); // now we have 5+6+7+8+18+20+30
|
||||
|
||||
// and now if we try making 16 cents again, the smaller coins can make 5+6+7 = 18 cents, the same as the next biggest coin, 18
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(16 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 18 * CENT); // we should get 18 in 1 coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1); // because in the event of a tie, the biggest coin wins
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U); // because in the event of a tie, the biggest coin wins
|
||||
|
||||
// now try making 11 cents. we should get 5+6
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(11 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 11 * CENT);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
|
||||
|
||||
// check that the smallest bigger coin is used
|
||||
add_coin( 1*COIN);
|
||||
@@ -164,12 +163,12 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
add_coin( 3*COIN);
|
||||
add_coin( 4*COIN); // now we have 5+6+7+8+18+20+30+100+200+300+400 = 1094 cents
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(95 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 1 * COIN); // we should get 1 bitcoin in 1 coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1);
|
||||
BOOST_CHECK_EQUAL(nValueRet, 1 * COIN); // we should get 1 BTC in 1 coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
|
||||
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(195 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 2 * COIN); // we should get 2 bitcoins in 1 coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1);
|
||||
BOOST_CHECK_EQUAL(nValueRet, 2 * COIN); // we should get 2 BTC in 1 coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
|
||||
|
||||
// empty the wallet and start again, now with fractions of a cent, to test sub-cent change avoidance
|
||||
empty_wallet();
|
||||
@@ -207,7 +206,7 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(500000 * COIN, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 500000 * COIN); // we should get the exact amount
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 10); // in ten coins
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 10U); // in ten coins
|
||||
|
||||
// if there's not enough in the smaller coins to make at least 1 cent change (0.5+0.6+0.7 < 1.0+1.0),
|
||||
// we need to try finding an exact subset anyway
|
||||
@@ -220,7 +219,7 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
add_coin(1111 * CENT);
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(1 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 1111 * CENT); // we get the bigger coin
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 1U);
|
||||
|
||||
// but sometimes it's possible, and we use an exact subset (0.4 + 0.6 = 1.0)
|
||||
empty_wallet();
|
||||
@@ -230,7 +229,7 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
add_coin(1111 * CENT);
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(1 * CENT, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 1 * CENT); // we should get the exact amount
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2); // in two coins 0.4+0.6
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U); // in two coins 0.4+0.6
|
||||
|
||||
// test avoiding sub-cent change
|
||||
empty_wallet();
|
||||
@@ -241,12 +240,12 @@ BOOST_AUTO_TEST_CASE(coin_selection_tests)
|
||||
// trying to make 1.0001 from these three coins
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(1.0001 * COIN, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 1.0105 * COIN); // we should get all coins
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 3U);
|
||||
|
||||
// but if we try to make 0.999, we should take the bigger of the two small coins to avoid sub-cent change
|
||||
BOOST_CHECK( wallet.SelectCoinsMinConf(0.999 * COIN, 1, 1, vCoins, setCoinsRet, nValueRet));
|
||||
BOOST_CHECK_EQUAL(nValueRet, 1.01 * COIN); // we should get 1 + 0.01
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2);
|
||||
BOOST_CHECK_EQUAL(setCoinsRet.size(), 2U);
|
||||
|
||||
// test randomness
|
||||
{
|
||||
|
||||
Reference in New Issue
Block a user