21 files changed, 433 insertions, 250 deletions

diff --git a/test/functional/config.ini.in b/test/config.ini.in
index 29586c555d..35ee092be4 100644
--- a/test/functional/config.ini.in
+++ b/test/config.ini.in
@@ -3,7 +3,7 @@
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 # These environment variables are set by the build process and read by
-# test/functional/test_runner.py
+# test/functional/test_runner.py and test/util/bitcoin-util-test.py
 
 [environment]
 SRCDIR=@abs_top_srcdir@
diff --git a/test/functional/bip68-sequence.py b/test/functional/bip68-sequence.py
index db66b7719c..87a50692f6 100755
--- a/test/functional/bip68-sequence.py
+++ b/test/functional/bip68-sequence.py
@@ -241,7 +241,7 @@ class BIP68Test(BitcoinTestFramework):
 
         # Now mine some blocks, but make sure tx2 doesn't get mined.
         # Use prioritisetransaction to lower the effective feerate to 0
-        self.nodes[0].prioritisetransaction(tx2.hash, int(-self.relayfee*COIN))
+        self.nodes[0].prioritisetransaction(txid=tx2.hash, fee_delta=int(-self.relayfee*COIN))
         cur_time = int(time.time())
         for i in range(10):
             self.nodes[0].setmocktime(cur_time + 600)
@@ -254,7 +254,7 @@ class BIP68Test(BitcoinTestFramework):
         test_nonzero_locks(tx2, self.nodes[0], self.relayfee, use_height_lock=False)
 
         # Mine tx2, and then try again
-        self.nodes[0].prioritisetransaction(tx2.hash, int(self.relayfee*COIN))
+        self.nodes[0].prioritisetransaction(txid=tx2.hash, fee_delta=int(self.relayfee*COIN))
 
         # Advance the time on the node so that we can test timelocks
         self.nodes[0].setmocktime(cur_time+600)
diff --git a/test/functional/blockchain.py b/test/functional/blockchain.py
index 5ada3e629e..e205c6400c 100755
--- a/test/functional/blockchain.py
+++ b/test/functional/blockchain.py
@@ -18,13 +18,16 @@ Tests correspond to code in rpc/blockchain.cpp.
 """
 
 from decimal import Decimal
+import subprocess
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import (
     assert_equal,
+    assert_raises,
     assert_raises_jsonrpc,
     assert_is_hex_string,
     assert_is_hash_string,
+    bitcoind_processes,
 )
 
 
@@ -34,6 +37,7 @@ class BlockchainTest(BitcoinTestFramework):
         super().__init__()
         self.setup_clean_chain = False
         self.num_nodes = 1
+        self.extra_args = [['-stopatheight=207']]
 
     def run_test(self):
         self._test_getchaintxstats()
@@ -41,7 +45,8 @@ class BlockchainTest(BitcoinTestFramework):
         self._test_getblockheader()
         self._test_getdifficulty()
         self._test_getnetworkhashps()
-        self.nodes[0].verifychain(4, 0)
+        self._test_stopatheight()
+        assert self.nodes[0].verifychain(4, 0)
 
     def _test_getchaintxstats(self):
         chaintxstats = self.nodes[0].getchaintxstats(1)
@@ -59,6 +64,7 @@ class BlockchainTest(BitcoinTestFramework):
         assert_equal(res['transactions'], 200)
         assert_equal(res['height'], 200)
         assert_equal(res['txouts'], 200)
+        assert_equal(res['bogosize'], 17000),
         assert_equal(res['bestblock'], node.getblockhash(200))
         size = res['disk_size']
         assert size > 6400
@@ -75,6 +81,7 @@ class BlockchainTest(BitcoinTestFramework):
         assert_equal(res2['total_amount'], Decimal('0'))
         assert_equal(res2['height'], 0)
         assert_equal(res2['txouts'], 0)
+        assert_equal(res2['bogosize'], 0),
         assert_equal(res2['bestblock'], node.getblockhash(0))
         assert_equal(len(res2['hash_serialized_2']), 64)
 
@@ -86,6 +93,7 @@ class BlockchainTest(BitcoinTestFramework):
         assert_equal(res['transactions'], res3['transactions'])
         assert_equal(res['height'], res3['height'])
         assert_equal(res['txouts'], res3['txouts'])
+        assert_equal(res['bogosize'], res3['bogosize'])
         assert_equal(res['bestblock'], res3['bestblock'])
         assert_equal(res['hash_serialized_2'], res3['hash_serialized_2'])
 
@@ -126,5 +134,18 @@ class BlockchainTest(BitcoinTestFramework):
         # This should be 2 hashes every 10 minutes or 1/300
         assert abs(hashes_per_second * 300 - 1) < 0.0001
 
+    def _test_stopatheight(self):
+        assert_equal(self.nodes[0].getblockcount(), 200)
+        self.nodes[0].generate(6)
+        assert_equal(self.nodes[0].getblockcount(), 206)
+        self.log.debug('Node should not stop at this height')
+        assert_raises(subprocess.TimeoutExpired, lambda: bitcoind_processes[0].wait(timeout=3))
+        self.nodes[0].generate(1)
+        self.log.debug('Node should stop at this height...')
+        bitcoind_processes[0].wait(timeout=3)
+        self.nodes[0] = self.start_node(0, self.options.tmpdir)
+        assert_equal(self.nodes[0].getblockcount(), 207)
+
+
 if __name__ == '__main__':
     BlockchainTest().main()
diff --git a/test/functional/fundrawtransaction.py b/test/functional/fundrawtransaction.py
index c41afe2b93..0a3166b89b 100755
--- a/test/functional/fundrawtransaction.py
+++ b/test/functional/fundrawtransaction.py
@@ -452,7 +452,7 @@ class RawTransactionsTest(BitcoinTestFramework):
         self.stop_node(2)
         self.stop_node(3)
         self.nodes[1].encryptwallet("test")
-        self.nodes.pop(1)
+        bitcoind_processes[1].wait(timeout=BITCOIND_PROC_WAIT_TIMEOUT)
 
         self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir)
         # This test is not meant to test fee estimation and we'd like
diff --git a/test/functional/mempool_packages.py b/test/functional/mempool_packages.py
index 72f04095f4..e225493816 100755
--- a/test/functional/mempool_packages.py
+++ b/test/functional/mempool_packages.py
@@ -96,7 +96,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
 
         # Check that ancestor modified fees includes fee deltas from
         # prioritisetransaction
-        self.nodes[0].prioritisetransaction(chain[0], 1000)
+        self.nodes[0].prioritisetransaction(txid=chain[0], fee_delta=1000)
         mempool = self.nodes[0].getrawmempool(True)
         ancestor_fees = 0
         for x in chain:
@@ -104,11 +104,11 @@ class MempoolPackagesTest(BitcoinTestFramework):
             assert_equal(mempool[x]['ancestorfees'], ancestor_fees * COIN + 1000)
         
         # Undo the prioritisetransaction for later tests
-        self.nodes[0].prioritisetransaction(chain[0], -1000)
+        self.nodes[0].prioritisetransaction(txid=chain[0], fee_delta=-1000)
 
         # Check that descendant modified fees includes fee deltas from
         # prioritisetransaction
-        self.nodes[0].prioritisetransaction(chain[-1], 1000)
+        self.nodes[0].prioritisetransaction(txid=chain[-1], fee_delta=1000)
         mempool = self.nodes[0].getrawmempool(True)
 
         descendant_fees = 0
@@ -126,7 +126,7 @@ class MempoolPackagesTest(BitcoinTestFramework):
         assert_equal(len(self.nodes[0].getrawmempool()), 0)
         # Prioritise a transaction that has been mined, then add it back to the
         # mempool by using invalidateblock.
-        self.nodes[0].prioritisetransaction(chain[-1], 2000)
+        self.nodes[0].prioritisetransaction(txid=chain[-1], fee_delta=2000)
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
         # Keep node1's tip synced with node0
         self.nodes[1].invalidateblock(self.nodes[1].getbestblockhash())
diff --git a/test/functional/merkle_blocks.py b/test/functional/merkle_blocks.py
index 06af72ef10..bcc65c8408 100755
--- a/test/functional/merkle_blocks.py
+++ b/test/functional/merkle_blocks.py
@@ -39,7 +39,8 @@ class MerkleBlockTest(BitcoinTestFramework):
         txid1 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransaction(tx1)["hex"])
         tx2 = self.nodes[0].createrawtransaction([node0utxos.pop()], {self.nodes[1].getnewaddress(): 49.99})
         txid2 = self.nodes[0].sendrawtransaction(self.nodes[0].signrawtransaction(tx2)["hex"])
-        assert_raises(JSONRPCException, self.nodes[0].gettxoutproof, [txid1])
+        # This will raise an exception because the transaction is not yet in a block
+        assert_raises_jsonrpc(-5, "Transaction not yet in block", self.nodes[0].gettxoutproof, [txid1])
 
         self.nodes[0].generate(1)
         blockhash = self.nodes[0].getblockhash(chain_height + 1)
@@ -56,7 +57,7 @@ class MerkleBlockTest(BitcoinTestFramework):
 
         txin_spent = self.nodes[1].listunspent(1).pop()
         tx3 = self.nodes[1].createrawtransaction([txin_spent], {self.nodes[0].getnewaddress(): 49.98})
-        self.nodes[0].sendrawtransaction(self.nodes[1].signrawtransaction(tx3)["hex"])
+        txid3 = self.nodes[0].sendrawtransaction(self.nodes[1].signrawtransaction(tx3)["hex"])
         self.nodes[0].generate(1)
         self.sync_all()
 
@@ -64,17 +65,21 @@ class MerkleBlockTest(BitcoinTestFramework):
         txid_unspent = txid1 if txin_spent["txid"] != txid1 else txid2
 
         # We can't find the block from a fully-spent tx
-        assert_raises(JSONRPCException, self.nodes[2].gettxoutproof, [txid_spent])
-        # ...but we can if we specify the block
+        assert_raises_jsonrpc(-5, "Transaction not yet in block", self.nodes[2].gettxoutproof, [txid_spent])
+        # We can get the proof if we specify the block
         assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_spent], blockhash)), [txid_spent])
-        # ...or if the first tx is not fully-spent
+        # We can't get the proof if we specify a non-existent block
+        assert_raises_jsonrpc(-5, "Block not found", self.nodes[2].gettxoutproof, [txid_spent], "00000000000000000000000000000000")
+        # We can get the proof if the transaction is unspent
         assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid_unspent])), [txid_unspent])
-        try:
-            assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2])), txlist)
-        except JSONRPCException:
-            assert_equal(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid2, txid1])), txlist)
-        # ...or if we have a -txindex
+        # We can get the proof if we provide a list of transactions and one of them is unspent. The ordering of the list should not matter.
+        assert_equal(sorted(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid1, txid2]))), sorted(txlist))
+        assert_equal(sorted(self.nodes[2].verifytxoutproof(self.nodes[2].gettxoutproof([txid2, txid1]))), sorted(txlist))
+        # We can always get a proof if we have a -txindex
         assert_equal(self.nodes[2].verifytxoutproof(self.nodes[3].gettxoutproof([txid_spent])), [txid_spent])
+        # We can't get a proof if we specify transactions from different blocks
+        assert_raises_jsonrpc(-5, "Not all transactions found in specified or retrieved block", self.nodes[2].gettxoutproof, [txid1, txid3])
+
 
 if __name__ == '__main__':
     MerkleBlockTest().main()
diff --git a/test/functional/multi_rpc.py b/test/functional/multi_rpc.py
index 6ff91a960b..a30e15ace9 100755
--- a/test/functional/multi_rpc.py
+++ b/test/functional/multi_rpc.py
@@ -16,16 +16,21 @@ class HTTPBasicsTest (BitcoinTestFramework):
     def __init__(self):
         super().__init__()
         self.setup_clean_chain = False
-        self.num_nodes = 1
+        self.num_nodes = 2
 
     def setup_chain(self):
         super().setup_chain()
         #Append rpcauth to bitcoin.conf before initialization
         rpcauth = "rpcauth=rt:93648e835a54c573682c2eb19f882535$7681e9c5b74bdd85e78166031d2058e1069b3ed7ed967c93fc63abba06f31144"
         rpcauth2 = "rpcauth=rt2:f8607b1a88861fac29dfccf9b52ff9f$ff36a0c23c8c62b4846112e50fa888416e94c17bfd4c42f88fd8f55ec6a3137e"
+        rpcuser = "rpcuser=rpcuser💻"
+        rpcpassword = "rpcpassword=rpcpassword🔑"
         with open(os.path.join(self.options.tmpdir+"/node0", "bitcoin.conf"), 'a', encoding='utf8') as f:
             f.write(rpcauth+"\n")
             f.write(rpcauth2+"\n")
+        with open(os.path.join(self.options.tmpdir+"/node1", "bitcoin.conf"), 'a', encoding='utf8') as f:
+            f.write(rpcuser+"\n")
+            f.write(rpcpassword+"\n")
 
     def run_test(self):
 
@@ -50,7 +55,7 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         resp = conn.getresponse()
-        assert_equal(resp.status==401, False)
+        assert_equal(resp.status, 200)
         conn.close()
         
         #Use new authpair to confirm both work
@@ -60,7 +65,7 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         resp = conn.getresponse()
-        assert_equal(resp.status==401, False)
+        assert_equal(resp.status, 200)
         conn.close()
 
         #Wrong login name with rt's password
@@ -71,7 +76,7 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         resp = conn.getresponse()
-        assert_equal(resp.status==401, True)
+        assert_equal(resp.status, 401)
         conn.close()
 
         #Wrong password for rt
@@ -82,7 +87,7 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         resp = conn.getresponse()
-        assert_equal(resp.status==401, True)
+        assert_equal(resp.status, 401)
         conn.close()
 
         #Correct for rt2
@@ -93,7 +98,7 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         resp = conn.getresponse()
-        assert_equal(resp.status==401, False)
+        assert_equal(resp.status, 200)
         conn.close()
 
         #Wrong password for rt2
@@ -104,7 +109,46 @@ class HTTPBasicsTest (BitcoinTestFramework):
         conn.connect()
         conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
         resp = conn.getresponse()
-        assert_equal(resp.status==401, True)
+        assert_equal(resp.status, 401)
+        conn.close()
+
+        ###############################################################
+        # Check correctness of the rpcuser/rpcpassword config options #
+        ###############################################################
+        url = urllib.parse.urlparse(self.nodes[1].url)
+
+        # rpcuser and rpcpassword authpair
+        rpcuserauthpair = "rpcuser💻:rpcpassword🔑"
+
+        headers = {"Authorization": "Basic " + str_to_b64str(rpcuserauthpair)}
+
+        conn = http.client.HTTPConnection(url.hostname, url.port)
+        conn.connect()
+        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        resp = conn.getresponse()
+        assert_equal(resp.status, 200)
+        conn.close()
+
+        #Wrong login name with rpcuser's password
+        rpcuserauthpair = "rpcuserwrong:rpcpassword"
+        headers = {"Authorization": "Basic " + str_to_b64str(rpcuserauthpair)}
+
+        conn = http.client.HTTPConnection(url.hostname, url.port)
+        conn.connect()
+        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        resp = conn.getresponse()
+        assert_equal(resp.status, 401)
+        conn.close()
+
+        #Wrong password for rpcuser
+        rpcuserauthpair = "rpcuser:rpcpasswordwrong"
+        headers = {"Authorization": "Basic " + str_to_b64str(rpcuserauthpair)}
+
+        conn = http.client.HTTPConnection(url.hostname, url.port)
+        conn.connect()
+        conn.request('POST', '/', '{"method": "getbestblockhash"}', headers)
+        resp = conn.getresponse()
+        assert_equal(resp.status, 401)
         conn.close()
 
 
diff --git a/test/functional/p2p-compactblocks.py b/test/functional/p2p-compactblocks.py
index 9b302120ac..ff76e49fba 100755
--- a/test/functional/p2p-compactblocks.py
+++ b/test/functional/p2p-compactblocks.py
@@ -98,7 +98,7 @@ class CompactBlocksTest(BitcoinTestFramework):
         self.setup_clean_chain = True
         # Node0 = pre-segwit, node1 = segwit-aware
         self.num_nodes = 2
-        self.extra_args = [["-bip9params=segwit:0:0"], ["-txindex"]]
+        self.extra_args = [["-vbparams=segwit:0:0"], ["-txindex"]]
         self.utxos = []
 
     def build_block_on_tip(self, node, segwit=False):
diff --git a/test/functional/p2p-segwit.py b/test/functional/p2p-segwit.py
index ab97596ba3..63dfbb8ae6 100755
--- a/test/functional/p2p-segwit.py
+++ b/test/functional/p2p-segwit.py
@@ -114,7 +114,7 @@ class SegWitTest(BitcoinTestFramework):
         super().__init__()
         self.setup_clean_chain = True
         self.num_nodes = 3
-        self.extra_args = [["-whitelist=127.0.0.1"], ["-whitelist=127.0.0.1", "-acceptnonstdtxn=0"], ["-whitelist=127.0.0.1", "-bip9params=segwit:0:0"]]
+        self.extra_args = [["-whitelist=127.0.0.1"], ["-whitelist=127.0.0.1", "-acceptnonstdtxn=0"], ["-whitelist=127.0.0.1", "-vbparams=segwit:0:0"]]
 
     def setup_network(self):
         self.setup_nodes()
@@ -1486,7 +1486,7 @@ class SegWitTest(BitcoinTestFramework):
     # nodes would have stored, this requires special handling.
     # To enable this test, pass --oldbinary=<path-to-pre-segwit-bitcoind> to
     # the test.
-    def test_upgrade_after_activation(self, node, node_id):
+    def test_upgrade_after_activation(self, node_id):
         self.log.info("Testing software upgrade after softfork activation")
 
         assert(node_id != 0) # node0 is assumed to be a segwit-active bitcoind
@@ -1502,14 +1502,14 @@ class SegWitTest(BitcoinTestFramework):
         sync_blocks(self.nodes)
 
         # Make sure that this peer thinks segwit has activated.
-        assert(get_bip9_status(node, 'segwit')['status'] == "active")
+        assert(get_bip9_status(self.nodes[node_id], 'segwit')['status'] == "active")
 
         # Make sure this peers blocks match those of node0.
-        height = node.getblockcount()
+        height = self.nodes[node_id].getblockcount()
         while height >= 0:
-            block_hash = node.getblockhash(height)
+            block_hash = self.nodes[node_id].getblockhash(height)
             assert_equal(block_hash, self.nodes[0].getblockhash(height))
-            assert_equal(self.nodes[0].getblock(block_hash), node.getblock(block_hash))
+            assert_equal(self.nodes[0].getblock(block_hash), self.nodes[node_id].getblock(block_hash))
             height -= 1
 
 
@@ -1944,7 +1944,7 @@ class SegWitTest(BitcoinTestFramework):
         self.test_signature_version_1()
         self.test_non_standard_witness()
         sync_blocks(self.nodes)
-        self.test_upgrade_after_activation(self.nodes[2], 2)
+        self.test_upgrade_after_activation(node_id=2)
         self.test_witness_sigops()
 
 
diff --git a/test/functional/prioritise_transaction.py b/test/functional/prioritise_transaction.py
index 9c3b3fd5d9..4fc03d2547 100755
--- a/test/functional/prioritise_transaction.py
+++ b/test/functional/prioritise_transaction.py
@@ -46,7 +46,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
 
         # add a fee delta to something in the cheapest bucket and make sure it gets mined
         # also check that a different entry in the cheapest bucket is NOT mined
-        self.nodes[0].prioritisetransaction(txids[0][0], int(3*base_fee*COIN))
+        self.nodes[0].prioritisetransaction(txid=txids[0][0], fee_delta=int(3*base_fee*COIN))
 
         self.nodes[0].generate(1)
 
@@ -65,7 +65,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
 
         # Add a prioritisation before a tx is in the mempool (de-prioritising a
         # high-fee transaction so that it's now low fee).
-        self.nodes[0].prioritisetransaction(high_fee_tx, -int(2*base_fee*COIN))
+        self.nodes[0].prioritisetransaction(txid=high_fee_tx, fee_delta=-int(2*base_fee*COIN))
 
         # Add everything back to mempool
         self.nodes[0].invalidateblock(self.nodes[0].getbestblockhash())
@@ -109,7 +109,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
         # This is a less than 1000-byte transaction, so just set the fee
         # to be the minimum for a 1000 byte transaction and check that it is
         # accepted.
-        self.nodes[0].prioritisetransaction(tx_id, int(self.relayfee*COIN))
+        self.nodes[0].prioritisetransaction(txid=tx_id, fee_delta=int(self.relayfee*COIN))
 
         self.log.info("Assert that prioritised free transaction is accepted to mempool")
         assert_equal(self.nodes[0].sendrawtransaction(tx_hex), tx_id)
@@ -120,7 +120,7 @@ class PrioritiseTransactionTest(BitcoinTestFramework):
         mock_time = int(time.time())
         self.nodes[0].setmocktime(mock_time)
         template = self.nodes[0].getblocktemplate()
-        self.nodes[0].prioritisetransaction(tx_id, -int(self.relayfee*COIN))
+        self.nodes[0].prioritisetransaction(txid=tx_id, fee_delta=-int(self.relayfee*COIN))
         self.nodes[0].setmocktime(mock_time+10)
         new_template = self.nodes[0].getblocktemplate()
 
diff --git a/test/functional/pruning.py b/test/functional/pruning.py
index 4c3501ad77..37e9d29738 100755
--- a/test/functional/pruning.py
+++ b/test/functional/pruning.py
@@ -315,7 +315,7 @@ class PruneTest(BitcoinTestFramework):
         # check that the pruning node's wallet is still in good shape
         self.log.info("Stop and start pruning node to trigger wallet rescan")
         self.stop_node(2)
-        self.start_node(2, self.options.tmpdir, ["-prune=550"])
+        self.nodes[2] = self.start_node(2, self.options.tmpdir, ["-prune=550"])
         self.log.info("Success")
 
         # check that wallet loads loads successfully when restarting a pruned node after IBD.
@@ -325,7 +325,7 @@ class PruneTest(BitcoinTestFramework):
         nds = [self.nodes[0], self.nodes[5]]
         sync_blocks(nds, wait=5, timeout=300)
         self.stop_node(5) #stop and start to trigger rescan
-        self.start_node(5, self.options.tmpdir, ["-prune=550"])
+        self.nodes[5] = self.start_node(5, self.options.tmpdir, ["-prune=550"])
         self.log.info("Success")
 
     def run_test(self):
diff --git a/test/functional/replace-by-fee.py b/test/functional/replace-by-fee.py
index e940ce535c..d6bf3ea59f 100755
--- a/test/functional/replace-by-fee.py
+++ b/test/functional/replace-by-fee.py
@@ -99,6 +99,9 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         self.log.info("Running test opt-in...")
         self.test_opt_in()
 
+        self.log.info("Running test RPC...")
+        self.test_rpc()
+
         self.log.info("Running test prioritised transactions...")
         self.test_prioritised_transactions()
 
@@ -482,7 +485,7 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         assert_raises_jsonrpc(-26, "insufficient fee", self.nodes[0].sendrawtransaction, tx1b_hex, True)
 
         # Use prioritisetransaction to set tx1a's fee to 0.
-        self.nodes[0].prioritisetransaction(tx1a_txid, int(-0.1*COIN))
+        self.nodes[0].prioritisetransaction(txid=tx1a_txid, fee_delta=int(-0.1*COIN))
 
         # Now tx1b should be able to replace tx1a
         tx1b_txid = self.nodes[0].sendrawtransaction(tx1b_hex, True)
@@ -509,12 +512,32 @@ class ReplaceByFeeTest(BitcoinTestFramework):
         assert_raises_jsonrpc(-26, "insufficient fee", self.nodes[0].sendrawtransaction, tx2b_hex, True)
 
         # Now prioritise tx2b to have a higher modified fee
-        self.nodes[0].prioritisetransaction(tx2b.hash, int(0.1*COIN))
+        self.nodes[0].prioritisetransaction(txid=tx2b.hash, fee_delta=int(0.1*COIN))
 
         # tx2b should now be accepted
         tx2b_txid = self.nodes[0].sendrawtransaction(tx2b_hex, True)
 
         assert(tx2b_txid in self.nodes[0].getrawmempool())
 
+    def test_rpc(self):
+        us0 = self.nodes[0].listunspent()[0]
+        ins = [us0]
+        outs = {self.nodes[0].getnewaddress() : Decimal(1.0000000)}
+        rawtx0 = self.nodes[0].createrawtransaction(ins, outs, 0, True)
+        rawtx1 = self.nodes[0].createrawtransaction(ins, outs, 0, False)
+        json0  = self.nodes[0].decoderawtransaction(rawtx0)
+        json1  = self.nodes[0].decoderawtransaction(rawtx1)
+        assert_equal(json0["vin"][0]["sequence"], 4294967293)
+        assert_equal(json1["vin"][0]["sequence"], 4294967295)
+
+        rawtx2 = self.nodes[0].createrawtransaction([], outs)
+        frawtx2a = self.nodes[0].fundrawtransaction(rawtx2, {"optIntoRbf": True})
+        frawtx2b = self.nodes[0].fundrawtransaction(rawtx2, {"optIntoRbf": False})
+
+        json0  = self.nodes[0].decoderawtransaction(frawtx2a['hex'])
+        json1  = self.nodes[0].decoderawtransaction(frawtx2b['hex'])
+        assert_equal(json0["vin"][0]["sequence"], 4294967293)
+        assert_equal(json1["vin"][0]["sequence"], 4294967294)
+
 if __name__ == '__main__':
     ReplaceByFeeTest().main()
diff --git a/test/functional/rpcbind_test.py b/test/functional/rpcbind_test.py
index 5336cf2ec8..198599010e 100755
--- a/test/functional/rpcbind_test.py
+++ b/test/functional/rpcbind_test.py
@@ -49,7 +49,7 @@ class RPCBindTest(BitcoinTestFramework):
         base_args = ['-disablewallet', '-nolisten'] + ['-rpcallowip='+x for x in allow_ips]
         self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, [base_args])
         # connect to node through non-loopback interface
-        node = get_rpc_proxy(rpc_url(0, "%s:%d" % (rpchost, rpcport)), 0)
+        node = get_rpc_proxy(rpc_url(get_datadir_path(self.options.tmpdir, 0), 0, "%s:%d" % (rpchost, rpcport)), 0)
         node.getnetworkinfo()
         self.stop_nodes()
 
diff --git a/test/functional/test_framework/test_framework.py b/test/functional/test_framework/test_framework.py
index 67abf35687..c7fd44b81c 100755
--- a/test/functional/test_framework/test_framework.py
+++ b/test/functional/test_framework/test_framework.py
@@ -28,6 +28,7 @@ from .util import (
     get_mocktime,
     get_rpc_proxy,
     initialize_datadir,
+    get_datadir_path,
     log_filename,
     p2p_port,
     rpc_url,
@@ -300,13 +301,13 @@ class BitcoinTestFramework(object):
                     args.append("-connect=127.0.0.1:" + str(p2p_port(0)))
                 bitcoind_processes[i] = subprocess.Popen(args)
                 self.log.debug("initialize_chain: bitcoind started, waiting for RPC to come up")
-                wait_for_bitcoind_start(bitcoind_processes[i], rpc_url(i), i)
+                wait_for_bitcoind_start(bitcoind_processes[i], datadir, i)
                 self.log.debug("initialize_chain: RPC successfully started")
 
             self.nodes = []
             for i in range(MAX_NODES):
                 try:
-                    self.nodes.append(get_rpc_proxy(rpc_url(i), i))
+                    self.nodes.append(get_rpc_proxy(rpc_url(get_datadir_path(cachedir, i), i), i))
                 except:
                     self.log.exception("Error connecting to node %d" % i)
                     sys.exit(1)
diff --git a/test/functional/test_framework/util.py b/test/functional/test_framework/util.py
index 2b0f32c2b6..d2a609451d 100644
--- a/test/functional/test_framework/util.py
+++ b/test/functional/test_framework/util.py
@@ -181,21 +181,40 @@ def initialize_datadir(dirname, n):
     datadir = os.path.join(dirname, "node"+str(n))
     if not os.path.isdir(datadir):
         os.makedirs(datadir)
-    rpc_u, rpc_p = rpc_auth_pair(n)
     with open(os.path.join(datadir, "bitcoin.conf"), 'w', encoding='utf8') as f:
         f.write("regtest=1\n")
-        f.write("rpcuser=" + rpc_u + "\n")
-        f.write("rpcpassword=" + rpc_p + "\n")
         f.write("port="+str(p2p_port(n))+"\n")
         f.write("rpcport="+str(rpc_port(n))+"\n")
         f.write("listenonion=0\n")
     return datadir
 
-def rpc_auth_pair(n):
-    return 'rpcuser💻' + str(n), 'rpcpass🔑' + str(n)
-
-def rpc_url(i, rpchost=None):
-    rpc_u, rpc_p = rpc_auth_pair(i)
+def get_datadir_path(dirname, n):
+    return os.path.join(dirname, "node"+str(n))
+
+def get_auth_cookie(datadir, n):
+    user = None
+    password = None
+    if os.path.isfile(os.path.join(datadir, "bitcoin.conf")):
+        with open(os.path.join(datadir, "bitcoin.conf"), 'r') as f:
+            for line in f:
+                if line.startswith("rpcuser="):
+                    assert user is None # Ensure that there is only one rpcuser line
+                    user = line.split("=")[1].strip("\n")
+                if line.startswith("rpcpassword="):
+                    assert password is None # Ensure that there is only one rpcpassword line
+                    password = line.split("=")[1].strip("\n")
+    if os.path.isfile(os.path.join(datadir, "regtest", ".cookie")):
+        with open(os.path.join(datadir, "regtest", ".cookie"), 'r') as f:
+            userpass = f.read()
+            split_userpass = userpass.split(':')
+            user = split_userpass[0]
+            password = split_userpass[1]
+    if user is None or password is None:
+        raise ValueError("No RPC credentials")
+    return user, password
+
+def rpc_url(datadir, i, rpchost=None):
+    rpc_u, rpc_p = get_auth_cookie(datadir, i)
     host = '127.0.0.1'
     port = rpc_port(i)
     if rpchost:
@@ -206,7 +225,7 @@ def rpc_url(i, rpchost=None):
             host = rpchost
     return "http://%s:%s@%s:%d" % (rpc_u, rpc_p, host, int(port))
 
-def wait_for_bitcoind_start(process, url, i):
+def wait_for_bitcoind_start(process, datadir, i, rpchost=None):
     '''
     Wait for bitcoind to start. This means that RPC is accessible and fully initialized.
     Raise an exception if bitcoind exits during initialization.
@@ -215,7 +234,8 @@ def wait_for_bitcoind_start(process, url, i):
         if process.poll() is not None:
             raise Exception('bitcoind exited with status %i during initialization' % process.returncode)
         try:
-            rpc = get_rpc_proxy(url, i)
+            # Check if .cookie file to be created
+            rpc = get_rpc_proxy(rpc_url(datadir, i, rpchost), i)
             blocks = rpc.getblockcount()
             break # break out of loop on success
         except IOError as e:
@@ -224,6 +244,9 @@ def wait_for_bitcoind_start(process, url, i):
         except JSONRPCException as e: # Initialization phase
             if e.error['code'] != -28: # RPC in warmup?
                 raise # unknown JSON RPC exception
+        except ValueError as e: # cookie file not found and no rpcuser or rpcassword. bitcoind still starting
+            if "No RPC credentials" not in str(e):
+                raise
         time.sleep(0.25)
 
 
@@ -239,10 +262,9 @@ def _start_node(i, dirname, extra_args=None, rpchost=None, timewait=None, binary
     if extra_args is not None: args.extend(extra_args)
     bitcoind_processes[i] = subprocess.Popen(args, stderr=stderr)
     logger.debug("initialize_chain: bitcoind started, waiting for RPC to come up")
-    url = rpc_url(i, rpchost)
-    wait_for_bitcoind_start(bitcoind_processes[i], url, i)
+    wait_for_bitcoind_start(bitcoind_processes[i], datadir, i, rpchost)
     logger.debug("initialize_chain: RPC successfully started")
-    proxy = get_rpc_proxy(url, i, timeout=timewait)
+    proxy = get_rpc_proxy(rpc_url(datadir, i, rpchost), i, timeout=timewait)
 
     if COVERAGE_DIR:
         coverage.write_all_rpc_commands(COVERAGE_DIR, proxy)
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index b2aee7c739..0dca318af8 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -20,6 +20,7 @@ import datetime
 import os
 import time
 import shutil
+import signal
 import sys
 import subprocess
 import tempfile
@@ -78,7 +79,7 @@ BASE_SCRIPTS= [
     'rawtransactions.py',
     'reindex.py',
     # vv Tests less than 30s vv
-    "zmq_test.py",
+    'zmq_test.py',
     'mempool_resurrect_test.py',
     'txn_doublespend.py --mineblock',
     'txn_clone.py',
@@ -111,6 +112,7 @@ BASE_SCRIPTS= [
     'rpcnamedargs.py',
     'listsinceblock.py',
     'p2p-leaktests.py',
+    'wallet-encryption.py',
 ]
 
 EXTENDED_SCRIPTS = [
@@ -180,7 +182,7 @@ def main():
 
     # Read config generated by configure.
     config = configparser.ConfigParser()
-    configfile = os.path.abspath(os.path.dirname(__file__)) + "/config.ini"
+    configfile = os.path.abspath(os.path.dirname(__file__)) + "/../config.ini"
     config.read_file(open(configfile))
 
     passon_args.append("--configfile=%s" % configfile)
@@ -389,6 +391,10 @@ class TestHandler:
             time.sleep(.5)
             for j in self.jobs:
                 (name, time0, proc, log_out, log_err) = j
+                if os.getenv('TRAVIS') == 'true' and int(time.time() - time0) > 20 * 60:
+                    # In travis, timeout individual tests after 20 minutes (to stop tests hanging and not
+                    # providing useful output.
+                    proc.send_signal(signal.SIGINT)
                 if proc.poll() is not None:
                     log_out.seek(0), log_err.seek(0)
                     [stdout, stderr] = [l.read().decode('utf-8') for l in (log_out, log_err)]
diff --git a/test/functional/wallet-encryption.py b/test/functional/wallet-encryption.py
new file mode 100755
index 0000000000..33872e3c94
--- /dev/null
+++ b/test/functional/wallet-encryption.py
@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test Wallet encryption"""
+
+import time
+
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.util import (
+    assert_equal,
+    assert_raises_jsonrpc,
+    bitcoind_processes,
+    BITCOIND_PROC_WAIT_TIMEOUT,
+)
+
+class WalletEncryptionTest(BitcoinTestFramework):
+
+    def __init__(self):
+        super().__init__()
+        self.setup_clean_chain = True
+        self.num_nodes = 1
+
+    def run_test(self):
+        passphrase = "WalletPassphrase"
+        passphrase2 = "SecondWalletPassphrase"
+
+        # Make sure the wallet isn't encrypted first
+        address = self.nodes[0].getnewaddress()
+        privkey = self.nodes[0].dumpprivkey(address)
+        assert_equal(privkey[:1], "c")
+        assert_equal(len(privkey), 52)
+
+        # Encrypt the wallet
+        self.nodes[0].encryptwallet(passphrase)
+        bitcoind_processes[0].wait(timeout=BITCOIND_PROC_WAIT_TIMEOUT)
+        self.nodes[0] = self.start_node(0, self.options.tmpdir)
+
+        # Test that the wallet is encrypted
+        assert_raises_jsonrpc(-13, "Please enter the wallet passphrase with walletpassphrase first", self.nodes[0].dumpprivkey, address)
+
+        # Check that walletpassphrase works
+        self.nodes[0].walletpassphrase(passphrase, 2)
+        assert_equal(privkey, self.nodes[0].dumpprivkey(address))
+
+        # Check that the timeout is right
+        time.sleep(2)
+        assert_raises_jsonrpc(-13, "Please enter the wallet passphrase with walletpassphrase first", self.nodes[0].dumpprivkey, address)
+
+        # Test wrong passphrase
+        assert_raises_jsonrpc(-14, "wallet passphrase entered was incorrect", self.nodes[0].walletpassphrase, passphrase + "wrong", 10)
+
+        # Test walletlock
+        self.nodes[0].walletpassphrase(passphrase, 84600)
+        assert_equal(privkey, self.nodes[0].dumpprivkey(address))
+        self.nodes[0].walletlock()
+        assert_raises_jsonrpc(-13, "Please enter the wallet passphrase with walletpassphrase first", self.nodes[0].dumpprivkey, address)
+
+        # Test passphrase changes
+        self.nodes[0].walletpassphrasechange(passphrase, passphrase2)
+        assert_raises_jsonrpc(-14, "wallet passphrase entered was incorrect", self.nodes[0].walletpassphrase, passphrase, 10)
+        self.nodes[0].walletpassphrase(passphrase2, 10)
+        assert_equal(privkey, self.nodes[0].dumpprivkey(address))
+
+if __name__ == '__main__':
+    WalletEncryptionTest().main()
diff --git a/test/functional/zmq_test.py b/test/functional/zmq_test.py
index ce39cfefdc..26c946d215 100755
--- a/test/functional/zmq_test.py
+++ b/test/functional/zmq_test.py
@@ -8,15 +8,15 @@ import os
 import struct
 
 from test_framework.test_framework import BitcoinTestFramework, SkipTest
-from test_framework.util import *
+from test_framework.util import (assert_equal,
+                                 bytes_to_hex_str,
+                                 )
 
 class ZMQTest (BitcoinTestFramework):
 
     def __init__(self):
         super().__init__()
-        self.num_nodes = 4
-
-    port = 28332
+        self.num_nodes = 2
 
     def setup_nodes(self):
         # Try to import python3-zmq. Skip this test if the import fails.
@@ -28,7 +28,7 @@ class ZMQTest (BitcoinTestFramework):
         # Check that bitcoin has been built with ZMQ enabled
         config = configparser.ConfigParser()
         if not self.options.configfile:
-            self.options.configfile = os.path.dirname(__file__) + "/config.ini"
+            self.options.configfile = os.path.dirname(__file__) + "/../config.ini"
         config.read_file(open(self.options.configfile))
 
         if not config["components"].getboolean("ENABLE_ZMQ"):
@@ -36,59 +36,66 @@ class ZMQTest (BitcoinTestFramework):
 
         self.zmqContext = zmq.Context()
         self.zmqSubSocket = self.zmqContext.socket(zmq.SUB)
+        self.zmqSubSocket.set(zmq.RCVTIMEO, 60000)
         self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashblock")
         self.zmqSubSocket.setsockopt(zmq.SUBSCRIBE, b"hashtx")
-        self.zmqSubSocket.connect("tcp://127.0.0.1:%i" % self.port)
-        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args=[
-            ['-zmqpubhashtx=tcp://127.0.0.1:'+str(self.port), '-zmqpubhashblock=tcp://127.0.0.1:'+str(self.port)],
-            [],
-            [],
-            []
-            ])
+        ip_address = "tcp://127.0.0.1:28332"
+        self.zmqSubSocket.connect(ip_address)
+        extra_args = [['-zmqpubhashtx=%s' % ip_address, '-zmqpubhashblock=%s' % ip_address], []]
+        self.nodes = self.start_nodes(self.num_nodes, self.options.tmpdir, extra_args)
 
     def run_test(self):
-        self.sync_all()
+        try:
+            self._zmq_test()
+        finally:
+            # Destroy the zmq context
+            self.log.debug("Destroying zmq context")
+            self.zmqContext.destroy(linger=None)
 
+    def _zmq_test(self):
         genhashes = self.nodes[0].generate(1)
         self.sync_all()
 
-        self.log.info("listen...")
+        self.log.info("Wait for tx")
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         assert_equal(topic, b"hashtx")
         body = msg[1]
         msgSequence = struct.unpack('<I', msg[-1])[-1]
-        assert_equal(msgSequence, 0) #must be sequence 0 on hashtx
+        assert_equal(msgSequence, 0)  # must be sequence 0 on hashtx
 
+        self.log.info("Wait for block")
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         body = msg[1]
         msgSequence = struct.unpack('<I', msg[-1])[-1]
-        assert_equal(msgSequence, 0) #must be sequence 0 on hashblock
+        assert_equal(msgSequence, 0)  # must be sequence 0 on hashblock
         blkhash = bytes_to_hex_str(body)
 
-        assert_equal(genhashes[0], blkhash) #blockhash from generate must be equal to the hash received over zmq
+        assert_equal(genhashes[0], blkhash)  # blockhash from generate must be equal to the hash received over zmq
 
+        self.log.info("Generate 10 blocks (and 10 coinbase txes)")
         n = 10
         genhashes = self.nodes[1].generate(n)
         self.sync_all()
 
         zmqHashes = []
         blockcount = 0
-        for x in range(0,n*2):
+        for x in range(n * 2):
             msg = self.zmqSubSocket.recv_multipart()
             topic = msg[0]
             body = msg[1]
             if topic == b"hashblock":
                 zmqHashes.append(bytes_to_hex_str(body))
                 msgSequence = struct.unpack('<I', msg[-1])[-1]
-                assert_equal(msgSequence, blockcount+1)
+                assert_equal(msgSequence, blockcount + 1)
                 blockcount += 1
 
-        for x in range(0,n):
-            assert_equal(genhashes[x], zmqHashes[x]) #blockhash from generate must be equal to the hash received over zmq
+        for x in range(n):
+            assert_equal(genhashes[x], zmqHashes[x])  # blockhash from generate must be equal to the hash received over zmq
 
-        #test tx from a second node
+        self.log.info("Wait for tx from second node")
+        # test tx from a second node
         hashRPC = self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 1.0)
         self.sync_all()
 
@@ -96,14 +103,12 @@ class ZMQTest (BitcoinTestFramework):
         msg = self.zmqSubSocket.recv_multipart()
         topic = msg[0]
         body = msg[1]
-        hashZMQ = ""
-        if topic == b"hashtx":
-            hashZMQ = bytes_to_hex_str(body)
-            msgSequence = struct.unpack('<I', msg[-1])[-1]
-            assert_equal(msgSequence, blockcount+1)
-
-        assert_equal(hashRPC, hashZMQ) #blockhash from generate must be equal to the hash received over zmq
+        assert_equal(topic, b"hashtx")
+        hashZMQ = bytes_to_hex_str(body)
+        msgSequence = struct.unpack('<I', msg[-1])[-1]
+        assert_equal(msgSequence, blockcount + 1)
 
+        assert_equal(hashRPC, hashZMQ)  # txid from sendtoaddress must be equal to the hash received over zmq
 
 if __name__ == '__main__':
-    ZMQTest ().main ()
+    ZMQTest().main()
diff --git a/test/util/bctest.py b/test/util/bctest.py
deleted file mode 100644
index b17cf77ae3..0000000000
--- a/test/util/bctest.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# Copyright 2014 BitPay Inc.
-# Copyright 2016 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-from __future__ import division,print_function,unicode_literals
-import subprocess
-import os
-import json
-import sys
-import binascii
-import difflib
-import logging
-import pprint
-
-def parse_output(a, fmt):
-    """Parse the output according to specified format.
-
-    Raise an error if the output can't be parsed."""
-    if fmt == 'json': # json: compare parsed data
-        return json.loads(a)
-    elif fmt == 'hex': # hex: parse and compare binary data
-        return binascii.a2b_hex(a.strip())
-    else:
-        raise NotImplementedError("Don't know how to compare %s" % fmt)
-
-def bctest(testDir, testObj, buildenv):
-    """Runs a single test, comparing output and RC to expected output and RC.
-
-    Raises an error if input can't be read, executable fails, or output/RC
-    are not as expected. Error is caught by bctester() and reported.
-    """
-    # Get the exec names and arguments
-    execprog = buildenv.BUILDDIR + "/src/" + testObj['exec'] + buildenv.exeext
-    execargs = testObj['args']
-    execrun = [execprog] + execargs
-
-    # Read the input data (if there is any)
-    stdinCfg = None
-    inputData = None
-    if "input" in testObj:
-        filename = testDir + "/" + testObj['input']
-        inputData = open(filename).read()
-        stdinCfg = subprocess.PIPE
-
-    # Read the expected output data (if there is any)
-    outputFn = None
-    outputData = None
-    if "output_cmp" in testObj:
-        outputFn = testObj['output_cmp']
-        outputType = os.path.splitext(outputFn)[1][1:] # output type from file extension (determines how to compare)
-        try:
-            outputData = open(testDir + "/" + outputFn).read()
-        except:
-            logging.error("Output file " + outputFn + " can not be opened")
-            raise
-        if not outputData:
-            logging.error("Output data missing for " + outputFn)
-            raise Exception
-
-    # Run the test
-    proc = subprocess.Popen(execrun, stdin=stdinCfg, stdout=subprocess.PIPE, stderr=subprocess.PIPE,universal_newlines=True)
-    try:
-        outs = proc.communicate(input=inputData)
-    except OSError:
-        logging.error("OSError, Failed to execute " + execprog)
-        raise
-
-    if outputData:
-        data_mismatch, formatting_mismatch = False, False
-        # Parse command output and expected output
-        try:
-            a_parsed = parse_output(outs[0], outputType)
-        except Exception as e:
-            logging.error('Error parsing command output as %s: %s' % (outputType,e))
-            raise
-        try:
-            b_parsed = parse_output(outputData, outputType)
-        except Exception as e:
-            logging.error('Error parsing expected output %s as %s: %s' % (outputFn,outputType,e))
-            raise
-        # Compare data
-        if a_parsed != b_parsed:
-            logging.error("Output data mismatch for " + outputFn + " (format " + outputType + ")")
-            data_mismatch = True
-        # Compare formatting
-        if outs[0] != outputData:
-            error_message = "Output formatting mismatch for " + outputFn + ":\n"
-            error_message += "".join(difflib.context_diff(outputData.splitlines(True),
-                                                          outs[0].splitlines(True),
-                                                          fromfile=outputFn,
-                                                          tofile="returned"))
-            logging.error(error_message)
-            formatting_mismatch = True
-
-        assert not data_mismatch and not formatting_mismatch
-
-    # Compare the return code to the expected return code
-    wantRC = 0
-    if "return_code" in testObj:
-        wantRC = testObj['return_code']
-    if proc.returncode != wantRC:
-        logging.error("Return code mismatch for " + outputFn)
-        raise Exception
-
-    if "error_txt" in testObj:
-        want_error = testObj["error_txt"]
-        # Compare error text
-        # TODO: ideally, we'd compare the strings exactly and also assert
-        # That stderr is empty if no errors are expected. However, bitcoin-tx
-        # emits DISPLAY errors when running as a windows application on
-        # linux through wine. Just assert that the expected error text appears
-        # somewhere in stderr.
-        if want_error not in outs[1]:
-            logging.error("Error mismatch:\n" + "Expected: " + want_error + "\nReceived: " + outs[1].rstrip())
-            raise Exception
-
-def bctester(testDir, input_basename, buildenv):
-    """ Loads and parses the input file, runs all tests and reports results"""
-    input_filename = testDir + "/" + input_basename
-    raw_data = open(input_filename).read()
-    input_data = json.loads(raw_data)
-
-    failed_testcases = []
-
-    for testObj in input_data:
-        try:
-            bctest(testDir, testObj, buildenv)
-            logging.info("PASSED: " + testObj["description"])
-        except:
-            logging.info("FAILED: " + testObj["description"])
-            failed_testcases.append(testObj["description"])
-
-    if failed_testcases:
-        error_message = "FAILED_TESTCASES:\n"
-        error_message += pprint.pformat(failed_testcases, width=400)
-        logging.error(error_message)
-        sys.exit(1)
-    else:
-        sys.exit(0)
diff --git a/test/util/bitcoin-util-test.py b/test/util/bitcoin-util-test.py
index e09a25159d..d15d6a6011 100755
--- a/test/util/bitcoin-util-test.py
+++ b/test/util/bitcoin-util-test.py
@@ -1,26 +1,30 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # Copyright 2014 BitPay Inc.
-# Copyright 2016 The Bitcoin Core developers
+# Copyright 2016-2017 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
-from __future__ import division,print_function,unicode_literals
-import os
-import sys
-import argparse
-import logging
+"""Test framework for bitcoin utils.
 
-help_text="""Test framework for bitcoin utils.
-
-Runs automatically during `make check`. 
+Runs automatically during `make check`.
 
 Can also be run manually."""
 
-if __name__ == '__main__':
-    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-    import buildenv
-    import bctest
+import argparse
+import binascii
+import configparser
+import difflib
+import json
+import logging
+import os
+import pprint
+import subprocess
+import sys
 
-    parser = argparse.ArgumentParser(description=help_text)
+def main():
+    config = configparser.ConfigParser()
+    config.read_file(open(os.path.dirname(__file__) + "/../config.ini"))
+
+    parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument('-v', '--verbose', action='store_true')
     args = parser.parse_args()
     verbose = args.verbose
@@ -31,6 +35,135 @@ if __name__ == '__main__':
         level = logging.ERROR
     formatter = '%(asctime)s - %(levelname)s - %(message)s'
     # Add the format/level to the logger
-    logging.basicConfig(format = formatter, level=level)
+    logging.basicConfig(format=formatter, level=level)
+
+    bctester(config["environment"]["SRCDIR"] + "/test/util/data", "bitcoin-util-test.json", config["environment"])
+
+def bctester(testDir, input_basename, buildenv):
+    """ Loads and parses the input file, runs all tests and reports results"""
+    input_filename = testDir + "/" + input_basename
+    raw_data = open(input_filename).read()
+    input_data = json.loads(raw_data)
+
+    failed_testcases = []
+
+    for testObj in input_data:
+        try:
+            bctest(testDir, testObj, buildenv)
+            logging.info("PASSED: " + testObj["description"])
+        except:
+            logging.info("FAILED: " + testObj["description"])
+            failed_testcases.append(testObj["description"])
 
-    bctest.bctester(buildenv.SRCDIR + "/test/util/data", "bitcoin-util-test.json", buildenv)
+    if failed_testcases:
+        error_message = "FAILED_TESTCASES:\n"
+        error_message += pprint.pformat(failed_testcases, width=400)
+        logging.error(error_message)
+        sys.exit(1)
+    else:
+        sys.exit(0)
+
+def bctest(testDir, testObj, buildenv):
+    """Runs a single test, comparing output and RC to expected output and RC.
+
+    Raises an error if input can't be read, executable fails, or output/RC
+    are not as expected. Error is caught by bctester() and reported.
+    """
+    # Get the exec names and arguments
+    execprog = buildenv["BUILDDIR"] + "/src/" + testObj['exec'] + buildenv["EXEEXT"]
+    execargs = testObj['args']
+    execrun = [execprog] + execargs
+
+    # Read the input data (if there is any)
+    stdinCfg = None
+    inputData = None
+    if "input" in testObj:
+        filename = testDir + "/" + testObj['input']
+        inputData = open(filename).read()
+        stdinCfg = subprocess.PIPE
+
+    # Read the expected output data (if there is any)
+    outputFn = None
+    outputData = None
+    if "output_cmp" in testObj:
+        outputFn = testObj['output_cmp']
+        outputType = os.path.splitext(outputFn)[1][1:]  # output type from file extension (determines how to compare)
+        try:
+            outputData = open(testDir + "/" + outputFn).read()
+        except:
+            logging.error("Output file " + outputFn + " can not be opened")
+            raise
+        if not outputData:
+            logging.error("Output data missing for " + outputFn)
+            raise Exception
+
+    # Run the test
+    proc = subprocess.Popen(execrun, stdin=stdinCfg, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+    try:
+        outs = proc.communicate(input=inputData)
+    except OSError:
+        logging.error("OSError, Failed to execute " + execprog)
+        raise
+
+    if outputData:
+        data_mismatch, formatting_mismatch = False, False
+        # Parse command output and expected output
+        try:
+            a_parsed = parse_output(outs[0], outputType)
+        except Exception as e:
+            logging.error('Error parsing command output as %s: %s' % (outputType, e))
+            raise
+        try:
+            b_parsed = parse_output(outputData, outputType)
+        except Exception as e:
+            logging.error('Error parsing expected output %s as %s: %s' % (outputFn, outputType, e))
+            raise
+        # Compare data
+        if a_parsed != b_parsed:
+            logging.error("Output data mismatch for " + outputFn + " (format " + outputType + ")")
+            data_mismatch = True
+        # Compare formatting
+        if outs[0] != outputData:
+            error_message = "Output formatting mismatch for " + outputFn + ":\n"
+            error_message += "".join(difflib.context_diff(outputData.splitlines(True),
+                                                          outs[0].splitlines(True),
+                                                          fromfile=outputFn,
+                                                          tofile="returned"))
+            logging.error(error_message)
+            formatting_mismatch = True
+
+        assert not data_mismatch and not formatting_mismatch
+
+    # Compare the return code to the expected return code
+    wantRC = 0
+    if "return_code" in testObj:
+        wantRC = testObj['return_code']
+    if proc.returncode != wantRC:
+        logging.error("Return code mismatch for " + outputFn)
+        raise Exception
+
+    if "error_txt" in testObj:
+        want_error = testObj["error_txt"]
+        # Compare error text
+        # TODO: ideally, we'd compare the strings exactly and also assert
+        # That stderr is empty if no errors are expected. However, bitcoin-tx
+        # emits DISPLAY errors when running as a windows application on
+        # linux through wine. Just assert that the expected error text appears
+        # somewhere in stderr.
+        if want_error not in outs[1]:
+            logging.error("Error mismatch:\n" + "Expected: " + want_error + "\nReceived: " + outs[1].rstrip())
+            raise Exception
+
+def parse_output(a, fmt):
+    """Parse the output according to specified format.
+
+    Raise an error if the output can't be parsed."""
+    if fmt == 'json':  # json: compare parsed data
+        return json.loads(a)
+    elif fmt == 'hex':  # hex: parse and compare binary data
+        return binascii.a2b_hex(a.strip())
+    else:
+        raise NotImplementedError("Don't know how to compare %s" % fmt)
+
+if __name__ == '__main__':
+    main()
diff --git a/test/util/buildenv.py.in b/test/util/buildenv.py.in
deleted file mode 100644
index 33030b0348..0000000000
--- a/test/util/buildenv.py.in
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/usr/bin/env python
-exeext="@EXEEXT@"
-SRCDIR="@abs_top_srcdir@"
-BUILDDIR="@abs_top_builddir@"