diff --git a/test/functional/getblocktemplate_proposals.py b/test/functional/getblocktemplate_proposals.py
deleted file mode 100755
index 6dc758bf1..000000000
--- a/test/functional/getblocktemplate_proposals.py
+++ /dev/null
@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2014-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 test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import *
-
-from binascii import a2b_hex, b2a_hex
-from hashlib import sha256
-from struct import pack
-
-
-def b2x(b):
-    return b2a_hex(b).decode('ascii')
-
-# NOTE: This does not work for signed numbers (set the high bit) or zero
-# (use b'\0')
-
-
-def encodeUNum(n):
-    s = bytearray(b'\1')
-    while n > 127:
-        s[0] += 1
-        s.append(n % 256)
-        n //= 256
-    s.append(n)
-    return bytes(s)
-
-
-def varlenEncode(n):
-    if n < 0xfd:
-        return pack('<B', n)
-    if n <= 0xffff:
-        return b'\xfd' + pack('<H', n)
-    if n <= 0xffffffff:
-        return b'\xfe' + pack('<L', n)
-    return b'\xff' + pack('<Q', n)
-
-
-def dblsha(b):
-    return sha256(sha256(b).digest()).digest()
-
-
-def genmrklroot(leaflist):
-    cur = leaflist
-    while len(cur) > 1:
-        n = []
-        if len(cur) & 1:
-            cur.append(cur[-1])
-        for i in range(0, len(cur), 2):
-            n.append(dblsha(cur[i] + cur[i + 1]))
-        cur = n
-    return cur[0]
-
-
-def template_to_bytearray(tmpl, txlist):
-    blkver = pack('<L', tmpl['version'])
-    mrklroot = genmrklroot(list(dblsha(a) for a in txlist))
-    timestamp = pack('<L', tmpl['curtime'])
-    nonce = b'\0\0\0\0'
-    blk = blkver + a2b_hex(tmpl['previousblockhash'])[
-        ::-1] + mrklroot + timestamp + a2b_hex(tmpl['bits'])[::-1] + nonce
-    blk += varlenEncode(len(txlist))
-    for tx in txlist:
-        blk += tx
-    return bytearray(blk)
-
-
-def template_to_hex(tmpl, txlist):
-    return b2x(template_to_bytearray(tmpl, txlist))
-
-
-def assert_template(node, tmpl, txlist, expect):
-    rsp = node.getblocktemplate(
-        {'data': template_to_hex(tmpl, txlist), 'mode': 'proposal'})
-    if rsp != expect:
-        raise AssertionError('unexpected: %s' % (rsp,))
-
-
-class GetBlockTemplateProposalTest(BitcoinTestFramework):
-
-    '''
-    Test block proposals with getblocktemplate.
-    '''
-
-    def __init__(self):
-        super().__init__()
-        self.num_nodes = 2
-        self.setup_clean_chain = False
-
-    def run_test(self):
-        node = self.nodes[0]
-        node.generate(1)  # Mine a block to leave initial block download
-        tmpl = node.getblocktemplate()
-        if 'coinbasetxn' not in tmpl:
-            rawcoinbase = encodeUNum(tmpl['height'])
-            rawcoinbase += b'\x01-'
-            hexcoinbase = b2x(rawcoinbase)
-            hexoutval = b2x(pack('<Q', tmpl['coinbasevalue']))
-            tmpl['coinbasetxn'] = {'data': '01000000' + '01' + '0000000000000000000000000000000000000000000000000000000000000000ffffffff' + (
-                '%02x' % (len(rawcoinbase),)) + hexcoinbase + 'fffffffe' + '01' + hexoutval + '00' + '00000000'}
-        txlist = list(bytearray(a2b_hex(a['data']))
-                      for a in (tmpl['coinbasetxn'],) + tuple(tmpl['transactions']))
-
-        # Test 0: Capability advertised
-        assert('proposal' in tmpl['capabilities'])
-
-        # NOTE: This test currently FAILS (regtest mode doesn't enforce block height in coinbase)
-        # Test 1: Bad height in coinbase
-        # txlist[0][4+1+36+1+1] += 1
-        # assert_template(node, tmpl, txlist, 'FIXME')
-        # txlist[0][4+1+36+1+1] -= 1
-
-        # Test 2: Bad input hash for gen tx
-        txlist[0][4 + 1] += 1
-        assert_template(node, tmpl, txlist, 'bad-cb-missing')
-        txlist[0][4 + 1] -= 1
-
-        # Test 3: Truncated final tx
-        lastbyte = txlist[-1].pop()
-        assert_raises_jsonrpc(-22, "Block decode failed",
-                              assert_template, node, tmpl, txlist, 'n/a')
-        txlist[-1].append(lastbyte)
-
-        # Test 4: Add an invalid tx to the end (duplicate of gen tx)
-        txlist.append(txlist[0])
-        assert_template(node, tmpl, txlist, 'bad-txns-duplicate')
-        txlist.pop()
-
-        # Test 5: Add an invalid tx to the end (non-duplicate)
-        txlist.append(bytearray(txlist[0]))
-        txlist[-1][4 + 1] = 0xff
-        assert_template(node, tmpl, txlist, 'bad-txns-inputs-missingorspent')
-        txlist.pop()
-
-        # Test 6: Future tx lock time
-        txlist[0][-4:] = b'\xff\xff\xff\xff'
-        assert_template(node, tmpl, txlist, 'bad-txns-nonfinal')
-        txlist[0][-4:] = b'\0\0\0\0'
-
-        # Test 7: Bad tx count
-        txlist.append(b'')
-        assert_raises_jsonrpc(-22, 'Block decode failed',
-                              assert_template, node, tmpl, txlist, 'n/a')
-        txlist.pop()
-
-        # Test 8: Bad bits
-        realbits = tmpl['bits']
-        tmpl['bits'] = '1c0000ff'  # impossible in the real world
-        assert_template(node, tmpl, txlist, 'bad-diffbits')
-        tmpl['bits'] = realbits
-
-        # Test 9: Bad merkle root
-        rawtmpl = template_to_bytearray(tmpl, txlist)
-        rawtmpl[4 + 32] = (rawtmpl[4 + 32] + 1) % 0x100
-        rsp = node.getblocktemplate({'data': b2x(rawtmpl), 'mode': 'proposal'})
-        if rsp != 'bad-txnmrklroot':
-            raise AssertionError('unexpected: %s' % (rsp,))
-
-        # Test 10: Bad timestamps
-        realtime = tmpl['curtime']
-        tmpl['curtime'] = 0x7fffffff
-        assert_template(node, tmpl, txlist, 'time-too-new')
-        tmpl['curtime'] = 0
-        assert_template(node, tmpl, txlist, 'time-too-old')
-        tmpl['curtime'] = realtime
-
-        # Test 11: Valid block
-        assert_template(node, tmpl, txlist, None)
-
-        # Test 12: Orphan block
-        tmpl['previousblockhash'] = 'ff00' * 16
-        assert_template(node, tmpl, txlist, 'inconclusive-not-best-prevblk')
-
-
-if __name__ == '__main__':
-    GetBlockTemplateProposalTest().main()
diff --git a/test/functional/mining.py b/test/functional/mining.py
new file mode 100755
index 000000000..feaeedd09
--- /dev/null
+++ b/test/functional/mining.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+# Copyright (c) 2014-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 mining RPCs
+
+- getblocktemplate proposal mode
+- submitblock"""
+
+from binascii import b2a_hex
+import copy
+
+from test_framework.blocktools import create_coinbase
+from test_framework.test_framework import BitcoinTestFramework
+from test_framework.mininode import CBlock
+from test_framework.util import *
+
+
+def b2x(b):
+    return b2a_hex(b).decode('ascii')
+
+
+def assert_template(node, block, expect, rehash=True):
+    if rehash:
+        block.hashMerkleRoot = block.calc_merkle_root()
+    rsp = node.getblocktemplate(
+        {'data': b2x(block.serialize()), 'mode': 'proposal'})
+    assert_equal(rsp, expect)
+
+
+class MiningTest(BitcoinTestFramework):
+    '''
+    Test block proposals with getblocktemplate.
+    '''
+
+    def __init__(self):
+        super().__init__()
+        self.num_nodes = 2
+        self.setup_clean_chain = False
+
+    def run_test(self):
+        node = self.nodes[0]
+        # Mine a block to leave initial block download
+        node.generate(1)
+        tmpl = node.getblocktemplate()
+        self.log.info("getblocktemplate: Test capability advertised")
+        assert 'proposal' in tmpl['capabilities']
+        assert 'coinbasetxn' not in tmpl
+
+        coinbase_tx = create_coinbase(height=int(tmpl["height"]) + 1)
+        # sequence numbers must not be max for nLockTime to have effect
+        coinbase_tx.vin[0].nSequence = 2 ** 32 - 2
+        coinbase_tx.rehash()
+
+        block = CBlock()
+        block.nVersion = tmpl["version"]
+        block.hashPrevBlock = int(tmpl["previousblockhash"], 16)
+        block.nTime = tmpl["curtime"]
+        block.nBits = int(tmpl["bits"], 16)
+        block.nNonce = 0
+        block.vtx = [coinbase_tx]
+
+        self.log.info("getblocktemplate: Test valid block")
+        assert_template(node, block, None)
+
+        self.log.info("submitblock: Test block decode failure")
+        assert_raises_jsonrpc(-22, "Block decode failed",
+                              node.submitblock, b2x(block.serialize()[:-15]))
+
+        self.log.info(
+            "getblocktemplate: Test bad input hash for coinbase transaction")
+        bad_block = copy.deepcopy(block)
+        bad_block.vtx[0].vin[0].prevout.hash += 1
+        bad_block.vtx[0].rehash()
+        assert_template(node, bad_block, 'bad-cb-missing')
+
+        self.log.info("submitblock: Test invalid coinbase transaction")
+        assert_raises_jsonrpc(-22, "Block does not start with a coinbase",
+                              node.submitblock, b2x(bad_block.serialize()))
+
+        self.log.info("getblocktemplate: Test truncated final transaction")
+        assert_raises_jsonrpc(-22, "Block decode failed", node.getblocktemplate,
+                              {'data': b2x(block.serialize()[:-1]), 'mode': 'proposal'})
+
+        self.log.info("getblocktemplate: Test duplicate transaction")
+        bad_block = copy.deepcopy(block)
+        bad_block.vtx.append(bad_block.vtx[0])
+        assert_template(node, bad_block, 'bad-txns-duplicate')
+
+        self.log.info("getblocktemplate: Test invalid transaction")
+        bad_block = copy.deepcopy(block)
+        bad_tx = copy.deepcopy(bad_block.vtx[0])
+        bad_tx.vin[0].prevout.hash = 255
+        bad_tx.rehash()
+        bad_block.vtx.append(bad_tx)
+        assert_template(node, bad_block, 'bad-txns-inputs-missingorspent')
+
+        self.log.info("getblocktemplate: Test nonfinal transaction")
+        bad_block = copy.deepcopy(block)
+        bad_block.vtx[0].nLockTime = 2 ** 32 - 1
+        bad_block.vtx[0].rehash()
+        assert_template(node, bad_block, 'bad-txns-nonfinal')
+
+        self.log.info("getblocktemplate: Test bad tx count")
+        # The tx count is immediately after the block header
+        TX_COUNT_OFFSET = 80
+        bad_block_sn = bytearray(block.serialize())
+        assert_equal(bad_block_sn[TX_COUNT_OFFSET], 1)
+        bad_block_sn[TX_COUNT_OFFSET] += 1
+        assert_raises_jsonrpc(-22, "Block decode failed", node.getblocktemplate,
+                              {'data': b2x(bad_block_sn), 'mode': 'proposal'})
+
+        self.log.info("getblocktemplate: Test bad bits")
+        bad_block = copy.deepcopy(block)
+        bad_block.nBits = 469762303  # impossible in the real world
+        assert_template(node, bad_block, 'bad-diffbits')
+
+        self.log.info("getblocktemplate: Test bad merkle root")
+        bad_block = copy.deepcopy(block)
+        bad_block.hashMerkleRoot += 1
+        assert_template(node, bad_block, 'bad-txnmrklroot', False)
+
+        self.log.info("getblocktemplate: Test bad timestamps")
+        bad_block = copy.deepcopy(block)
+        bad_block.nTime = 2 ** 31 - 1
+        assert_template(node, bad_block, 'time-too-new')
+        bad_block.nTime = 0
+        assert_template(node, bad_block, 'time-too-old')
+
+        self.log.info("getblocktemplate: Test not best block")
+        bad_block = copy.deepcopy(block)
+        bad_block.hashPrevBlock = 123
+        assert_template(node, bad_block, 'inconclusive-not-best-prevblk')
+
+
+if __name__ == '__main__':
+    MiningTest().main()
diff --git a/test/functional/test_runner.py b/test/functional/test_runner.py
index c9b9763bb..942548e6d 100755
--- a/test/functional/test_runner.py
+++ b/test/functional/test_runner.py
@@ -1,558 +1,558 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2016 The Bitcoin Core developers
 # Copyright (c) 2017 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Run regression test suite.
 
 This module calls down into individual test cases via subprocess. It will
 forward all unrecognized arguments onto the individual test scripts.
 
 Functional tests are disabled on Windows by default. Use --force to run them anyway.
 
 For a description of arguments recognized by test scripts, see
 `test/functional/test_framework/test_framework.py:BitcoinTestFramework.main`.
 
 """
 
 import argparse
 import configparser
 import datetime
 import os
 import time
 import shutil
 import signal
 import sys
 import subprocess
 import tempfile
 import re
 import logging
 
 # Formatting. Default colors to empty strings.
 BOLD, BLUE, RED, GREY = ("", ""), ("", ""), ("", ""), ("", "")
 try:
     # Make sure python thinks it can write unicode to its stdout
     "\u2713".encode("utf_8").decode(sys.stdout.encoding)
     TICK = "✓ "
     CROSS = "✖ "
     CIRCLE = "○ "
 except UnicodeDecodeError:
     TICK = "P "
     CROSS = "x "
     CIRCLE = "o "
 
 if os.name == 'posix':
     # primitive formatting on supported
     # terminal via ANSI escape sequences:
     BOLD = ('\033[0m', '\033[1m')
     BLUE = ('\033[0m', '\033[0;34m')
     RED = ('\033[0m', '\033[0;31m')
     GREY = ('\033[0m', '\033[1;30m')
 
 TEST_EXIT_PASSED = 0
 TEST_EXIT_SKIPPED = 77
 
 BASE_SCRIPTS = [
     # Longest test should go first, to favor running tests in parallel
     'wallet-hd.py',
     'walletbackup.py',
     # vv Tests less than 5m vv
     'p2p-fullblocktest.py',
     'fundrawtransaction.py',
     'p2p-compactblocks.py',
     # vv Tests less than 2m vv
     'wallet.py',
     'wallet-accounts.py',
     'wallet-dump.py',
     'listtransactions.py',
     # vv Tests less than 60s vv
     'sendheaders.py',
     'zapwallettxes.py',
     'importmulti.py',
     'mempool_limit.py',
     'merkle_blocks.py',
     'receivedby.py',
     'abandonconflict.py',
     'bip68-112-113-p2p.py',
     'rawtransactions.py',
     'reindex.py',
     # vv Tests less than 30s vv
     'keypool-topup.py',
     'zmq_test.py',
     'bitcoin_cli.py',
     'mempool_resurrect_test.py',
     'txn_doublespend.py --mineblock',
     'txn_clone.py',
     'getchaintips.py',
     'rest.py',
     'mempool_spendcoinbase.py',
     'mempool_reorg.py',
     'mempool_persist.py',
     'multiwallet.py',
     'httpbasics.py',
     'multi_rpc.py',
     'proxy_test.py',
     'signrawtransactions.py',
     'disconnect_ban.py',
     'decodescript.py',
     'blockchain.py',
     'disablewallet.py',
     'net.py',
     'keypool.py',
     'p2p-mempool.py',
     'prioritise_transaction.py',
     'high_priority_transaction.py',
     'invalidblockrequest.py',
     'invalidtxrequest.py',
     'p2p-versionbits-warning.py',
     'preciousblock.py',
     'importprunedfunds.py',
     'signmessages.py',
     'nulldummy.py',
     'import-rescan.py',
+    'mining.py',
     'rpcnamedargs.py',
     'listsinceblock.py',
     'p2p-leaktests.py',
     'abc-cmdline.py',
     'abc-p2p-fullblocktest.py',
     'abc-rpc.py',
     'mempool-accept-txn.py',
     'wallet-encryption.py',
     'uptime.py',
     'resendwallettransactions.py',
 ]
 
 EXTENDED_SCRIPTS = [
     # Longest test should go first, to favor running tests in parallel
     'pruning.py',
     # vv Tests less than 20m vv
     'smartfees.py',
     # vv Tests less than 5m vv
     'maxuploadtarget.py',
     'mempool_packages.py',
     'dbcrash.py',
     # vv Tests less than 2m vv
     'bip68-sequence.py',
     'getblocktemplate_longpoll.py',
     'p2p-timeouts.py',
     # vv Tests less than 60s vv
     'bip9-softforks.py',
     'p2p-feefilter.py',
     'rpcbind_test.py',
     # vv Tests less than 30s vv
     'assumevalid.py',
     'bip65-cltv.py',
     'bip65-cltv-p2p.py',
     'bipdersig-p2p.py',
     'bipdersig.py',
-    'getblocktemplate_proposals.py',
     'txn_doublespend.py',
     'txn_clone.py --mineblock',
     'forknotify.py',
     'invalidateblock.py',
     'p2p-acceptblock.py',
 ]
 
 # Place EXTENDED_SCRIPTS first since it has the 3 longest running tests
 ALL_SCRIPTS = EXTENDED_SCRIPTS + BASE_SCRIPTS
 
 
 NON_SCRIPTS = [
     # These are python files that live in the functional tests directory, but are not test scripts.
     "combine_logs.py",
     "create_cache.py",
     "test_runner.py",
 ]
 
 
 def main():
     # Parse arguments and pass through unrecognised args
     parser = argparse.ArgumentParser(add_help=False,
                                      usage='%(prog)s [test_runner.py options] [script options] [scripts]',
                                      description=__doc__,
                                      epilog='''
     Help text and arguments for individual test script:''',
                                      formatter_class=argparse.RawTextHelpFormatter)
     parser.add_argument('--coverage', action='store_true',
                         help='generate a basic coverage report for the RPC interface')
     parser.add_argument(
         '--exclude', '-x', help='specify a comma-seperated-list of scripts to exclude. Do not include the .py extension in the name.')
     parser.add_argument('--extended', action='store_true',
                         help='run the extended test suite in addition to the basic tests')
     parser.add_argument('--force', '-f', action='store_true',
                         help='run tests even on platforms where they are disabled by default (e.g. windows).')
     parser.add_argument('--help', '-h', '-?',
                         action='store_true', help='print help text and exit')
     parser.add_argument('--jobs', '-j', type=int, default=4,
                         help='how many test scripts to run in parallel. Default=4.')
     parser.add_argument('--keepcache', '-k', action='store_true',
                         help='the default behavior is to flush the cache directory on startup. --keepcache retains the cache from the previous testrun.')
     parser.add_argument('--quiet', '-q', action='store_true',
                         help='only print results summary and failure logs')
     parser.add_argument('--tmpdirprefix', '-t',
                         default=tempfile.gettempdir(), help="Root directory for datadirs")
     args, unknown_args = parser.parse_known_args()
 
     # Create a set to store arguments and create the passon string
     tests = set(arg for arg in unknown_args if arg[:2] != "--")
     passon_args = [arg for arg in unknown_args if arg[:2] == "--"]
 
     # Read config generated by configure.
     config = configparser.ConfigParser()
     configfile = os.path.abspath(os.path.dirname(__file__)) + "/../config.ini"
     config.read_file(open(configfile))
 
     passon_args.append("--configfile=%s" % configfile)
 
     # Set up logging
     logging_level = logging.INFO if args.quiet else logging.DEBUG
     logging.basicConfig(format='%(message)s', level=logging_level)
 
     # Create base test directory
     tmpdir = "%s/bitcoin_test_runner_%s" % (
         args.tmpdirprefix, datetime.datetime.now().strftime("%Y%m%d_%H%M%S"))
     os.makedirs(tmpdir)
 
     logging.debug("Temporary test directory at %s" % tmpdir)
 
     enable_wallet = config["components"].getboolean("ENABLE_WALLET")
     enable_utils = config["components"].getboolean("ENABLE_UTILS")
     enable_bitcoind = config["components"].getboolean("ENABLE_BITCOIND")
 
     if config["environment"]["EXEEXT"] == ".exe" and not args.force:
         # https://github.com/bitcoin/bitcoin/commit/d52802551752140cf41f0d9a225a43e84404d3e9
         # https://github.com/bitcoin/bitcoin/pull/5677#issuecomment-136646964
         print(
             "Tests currently disabled on Windows by default. Use --force option to enable")
         sys.exit(0)
 
     if not (enable_wallet and enable_utils and enable_bitcoind):
         print(
             "No functional tests to run. Wallet, utils, and bitcoind must all be enabled")
         print(
             "Rerun `configure` with -enable-wallet, -with-utils and -with-daemon and rerun make")
         sys.exit(0)
 
     # Build list of tests
     if tests:
         # Individual tests have been specified. Run specified tests that exist
         # in the ALL_SCRIPTS list. Accept the name with or without .py
         # extension.
         test_list = [t for t in ALL_SCRIPTS if
                      (t in tests or re.sub(".py$", "", t) in tests)]
     else:
         # No individual tests have been specified.
         # Run all base tests, and optionally run extended tests.
         test_list = BASE_SCRIPTS
         if args.extended:
             test_list += EXTENDED_SCRIPTS
             # TODO: BASE_SCRIPTS and EXTENDED_SCRIPTS are sorted by runtime
             # (for parallel running efficiency). This combined list will is no
             # longer sorted.
 
     # Remove the test cases that the user has explicitly asked to exclude.
     if args.exclude:
         for exclude_test in args.exclude.split(','):
             if exclude_test + ".py" in test_list:
                 test_list.remove(exclude_test + ".py")
 
     if not test_list:
         print("No valid test scripts specified. Check that your test is in one "
               "of the test lists in test_runner.py, or run test_runner.py with no arguments to run all tests")
         sys.exit(0)
 
     if args.help:
         # Print help for test_runner.py, then print help of the first script
         # and exit.
         parser.print_help()
         subprocess.check_call(
             (config["environment"]["SRCDIR"] + '/test/functional/' + test_list[0]).split() + ['-h'])
         sys.exit(0)
 
     check_script_list(config["environment"]["SRCDIR"])
 
     if not args.keepcache:
         shutil.rmtree("%s/test/cache" %
                       config["environment"]["BUILDDIR"], ignore_errors=True)
 
     run_tests(test_list, config["environment"]["SRCDIR"], config["environment"]["BUILDDIR"],
               config["environment"]["EXEEXT"], tmpdir, args.jobs, args.coverage, passon_args)
 
 
 def run_tests(test_list, src_dir, build_dir, exeext, tmpdir, jobs=1, enable_coverage=False, args=[]):
     # Warn if bitcoind is already running (unix only)
     try:
         pidofOutput = subprocess.check_output(["pidof", "bitcoind"])
         if pidofOutput is not None and pidofOutput != b'':
             print("%sWARNING!%s There is already a bitcoind process running on this system. Tests may fail unexpectedly due to resource contention!" % (
                 BOLD[1], BOLD[0]))
     except (OSError, subprocess.SubprocessError):
         pass
 
     # Warn if there is a cache directory
     cache_dir = "%s/test/cache" % build_dir
     if os.path.isdir(cache_dir):
         print("%sWARNING!%s There is a cache directory here: %s. If tests fail unexpectedly, try deleting the cache directory." % (
             BOLD[1], BOLD[0], cache_dir))
 
     # Set env vars
     if "BITCOIND" not in os.environ:
         os.environ["BITCOIND"] = build_dir + '/src/bitcoind' + exeext
         os.environ["BITCOINCLI"] = build_dir + '/src/bitcoin-cli' + exeext
 
     tests_dir = src_dir + '/test/functional/'
 
     flags = ["--srcdir={}/src".format(build_dir)] + args
     flags.append("--cachedir=%s" % cache_dir)
 
     if enable_coverage:
         coverage = RPCCoverage()
         flags.append(coverage.flag)
         logging.debug("Initializing coverage directory at %s" % coverage.dir)
     else:
         coverage = None
 
     if len(test_list) > 1 and jobs > 1:
         # Populate cache
         subprocess.check_output(
             [tests_dir + 'create_cache.py'] + flags + ["--tmpdir=%s/cache" % tmpdir])
 
     # Run Tests
     job_queue = TestHandler(jobs, tests_dir, tmpdir, test_list, flags)
     time0 = time.time()
     test_results = []
 
     max_len_name = len(max(test_list, key=len))
 
     for _ in range(len(test_list)):
         test_result, stdout, stderr = job_queue.get_next()
         test_results.append(test_result)
 
         if test_result.status == "Passed":
             logging.debug("\n%s%s%s passed, Duration: %s s" % (
                 BOLD[1], test_result.name, BOLD[0], test_result.time))
         elif test_result.status == "Skipped":
             logging.debug("\n%s%s%s skipped" %
                           (BOLD[1], test_result.name, BOLD[0]))
         else:
             print("\n%s%s%s failed, Duration: %s s\n" %
                   (BOLD[1], test_result.name, BOLD[0], test_result.time))
             print(BOLD[1] + 'stdout:\n' + BOLD[0] + stdout + '\n')
             print(BOLD[1] + 'stderr:\n' + BOLD[0] + stderr + '\n')
 
     print_results(test_results, max_len_name, (int(time.time() - time0)))
 
     if coverage:
         coverage.report_rpc_coverage()
 
         logging.debug("Cleaning up coverage data")
         coverage.cleanup()
 
     # Clear up the temp directory if all subdirectories are gone
     if not os.listdir(tmpdir):
         os.rmdir(tmpdir)
 
     all_passed = all(
         map(lambda test_result: test_result.status == "Passed", test_results))
 
     sys.exit(not all_passed)
 
 
 def print_results(test_results, max_len_name, runtime):
     results = "\n" + BOLD[1] + "%s | %s | %s\n\n" % (
         "TEST".ljust(max_len_name), "STATUS   ", "DURATION") + BOLD[0]
 
     test_results.sort(key=lambda result: result.name.lower())
     all_passed = True
     time_sum = 0
 
     for test_result in test_results:
         all_passed = all_passed and test_result.status != "Failed"
         time_sum += test_result.time
         test_result.padding = max_len_name
         results += str(test_result)
 
     status = TICK + "Passed" if all_passed else CROSS + "Failed"
     results += BOLD[1] + "\n%s | %s | %s s (accumulated) \n" % (
         "ALL".ljust(max_len_name), status.ljust(9), time_sum) + BOLD[0]
     results += "Runtime: %s s\n" % (runtime)
     print(results)
 
 
 class TestHandler:
 
     """
     Trigger the testscrips passed in via the list.
     """
 
     def __init__(self, num_tests_parallel, tests_dir, tmpdir, test_list=None, flags=None):
         assert(num_tests_parallel >= 1)
         self.num_jobs = num_tests_parallel
         self.tests_dir = tests_dir
         self.tmpdir = tmpdir
         self.test_list = test_list
         self.flags = flags
         self.num_running = 0
         # In case there is a graveyard of zombie bitcoinds, we can apply a
         # pseudorandom offset to hopefully jump over them.
         # (625 is PORT_RANGE/MAX_NODES)
         self.portseed_offset = int(time.time() * 1000) % 625
         self.jobs = []
 
     def get_next(self):
         while self.num_running < self.num_jobs and self.test_list:
             # Add tests
             self.num_running += 1
             t = self.test_list.pop(0)
             portseed = len(self.test_list) + self.portseed_offset
             portseed_arg = ["--portseed={}".format(portseed)]
             log_stdout = tempfile.SpooledTemporaryFile(max_size=2**16)
             log_stderr = tempfile.SpooledTemporaryFile(max_size=2**16)
             test_argv = t.split()
             tmpdir = ["--tmpdir=%s/%s_%s" %
                       (self.tmpdir, re.sub(".py$", "", test_argv[0]), portseed)]
             self.jobs.append((t,
                               time.time(),
                               subprocess.Popen([self.tests_dir + test_argv[0]] + test_argv[1:] + self.flags + portseed_arg + tmpdir,
                                                universal_newlines=True,
                                                stdout=log_stdout,
                                                stderr=log_stderr),
                               log_stdout,
                               log_stderr))
         if not self.jobs:
             raise IndexError('pop from empty list')
         while True:
             # Return first proc that finishes
             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)]
                     log_out.close(), log_err.close()
                     if proc.returncode == TEST_EXIT_PASSED and stderr == "":
                         status = "Passed"
                     elif proc.returncode == TEST_EXIT_SKIPPED:
                         status = "Skipped"
                     else:
                         status = "Failed"
                     self.num_running -= 1
                     self.jobs.remove(j)
 
                     return TestResult(name, status, int(time.time() - time0)), stdout, stderr
             print('.', end='', flush=True)
 
 
 class TestResult():
     def __init__(self, name, status, time):
         self.name = name
         self.status = status
         self.time = time
         self.padding = 0
 
     def __repr__(self):
         if self.status == "Passed":
             color = BLUE
             glyph = TICK
         elif self.status == "Failed":
             color = RED
             glyph = CROSS
         elif self.status == "Skipped":
             color = GREY
             glyph = CIRCLE
 
         return color[1] + "%s | %s%s | %s s\n" % (self.name.ljust(self.padding), glyph, self.status.ljust(7), self.time) + color[0]
 
 
 def check_script_list(src_dir):
     """Check scripts directory.
 
     Check that there are no scripts in the functional tests directory which are
     not being run by pull-tester.py."""
     script_dir = src_dir + '/test/functional/'
     python_files = set([t for t in os.listdir(script_dir) if t[-3:] == ".py"])
     missed_tests = list(
         python_files - set(map(lambda x: x.split()[0], ALL_SCRIPTS + NON_SCRIPTS)))
     if len(missed_tests) != 0:
         print("%sWARNING!%s The following scripts are not being run: %s. Check the test lists in test_runner.py." % (
             BOLD[1], BOLD[0], str(missed_tests)))
         if os.getenv('TRAVIS') == 'true':
             # On travis this warning is an error to prevent merging incomplete commits into master
             sys.exit(1)
 
 
 class RPCCoverage():
     """
     Coverage reporting utilities for test_runner.
 
     Coverage calculation works by having each test script subprocess write
     coverage files into a particular directory. These files contain the RPC
     commands invoked during testing, as well as a complete listing of RPC
     commands per `bitcoin-cli help` (`rpc_interface.txt`).
 
     After all tests complete, the commands run are combined and diff'd against
     the complete list to calculate uncovered RPC commands.
 
     See also: test/functional/test_framework/coverage.py
 
     """
 
     def __init__(self):
         self.dir = tempfile.mkdtemp(prefix="coverage")
         self.flag = '--coveragedir={}'.format(self.dir)
 
     def report_rpc_coverage(self):
         """
         Print out RPC commands that were unexercised by tests.
 
         """
         uncovered = self._get_uncovered_rpc_commands()
 
         if uncovered:
             print("Uncovered RPC commands:")
             print("".join(("  - {}\n".format(i)) for i in sorted(uncovered)))
         else:
             print("All RPC commands covered.")
 
     def cleanup(self):
         return shutil.rmtree(self.dir)
 
     def _get_uncovered_rpc_commands(self):
         """
         Return a set of currently untested RPC commands.
 
         """
         # This is shared from `test/functional/test-framework/coverage.py`
         reference_filename = 'rpc_interface.txt'
         coverage_file_prefix = 'coverage.'
 
         coverage_ref_filename = os.path.join(self.dir, reference_filename)
         coverage_filenames = set()
         all_cmds = set()
         covered_cmds = set()
 
         if not os.path.isfile(coverage_ref_filename):
             raise RuntimeError("No coverage reference found")
 
         with open(coverage_ref_filename, 'r') as f:
             all_cmds.update([i.strip() for i in f.readlines()])
 
         for root, dirs, files in os.walk(self.dir):
             for filename in files:
                 if filename.startswith(coverage_file_prefix):
                     coverage_filenames.add(os.path.join(root, filename))
 
         for filename in coverage_filenames:
             with open(filename, 'r') as f:
                 covered_cmds.update([i.strip() for i in f.readlines()])
 
         return all_cmds - covered_cmds
 
 
 if __name__ == '__main__':
     main()