diff --git a/test/functional/abc-parkedchain.py b/test/functional/abc-parkedchain.py
index e19818506..c30808cd0 100755
--- a/test/functional/abc-parkedchain.py
+++ b/test/functional/abc-parkedchain.py
@@ -1,249 +1,253 @@
 #!/usr/bin/env python3
 # Copyright (c) 2018 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the parckblock and unparkblock RPC calls."""
 
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, connect_nodes_bi, wait_until
+from test_framework.util import (
+    assert_equal,
+    connect_nodes_bi,
+    wait_until
+)
 
 
 class ParkedChainTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.extra_args = [["-noparkdeepreorg",
                             "-noautomaticunparking"], ["-maxreorgdepth=-1"]]
 
     def skip_test_if_missing_module(self):
         self.skip_if_no_wallet()
 
     # There should only be one chaintip, which is expected_tip
     def only_valid_tip(self, expected_tip, other_tip_status=None):
         node = self.nodes[0]
         assert_equal(node.getbestblockhash(), expected_tip)
         for tip in node.getchaintips():
             if tip["hash"] == expected_tip:
                 assert_equal(tip["status"], "active")
             else:
                 assert_equal(tip["status"], other_tip_status)
 
     def run_test(self):
         def wait_for_tip(node, tip):
             def check_tip():
                 return node.getbestblockhash() == tip
             wait_until(check_tip)
 
         node = self.nodes[0]
         parking_node = self.nodes[1]
 
         self.log.info("Test chain parking...")
         node.generate(10)
         tip = node.getbestblockhash()
         node.generate(1)
         block_to_park = node.getbestblockhash()
         node.generate(10)
         parked_tip = node.getbestblockhash()
 
         # get parking_node caught up.
         # (probably not needed, but just in case parking can have race
         # condition like invalidateblock below)
         wait_for_tip(parking_node, parked_tip)
 
         # Let's park the chain.
         assert parked_tip != tip
         assert block_to_park != tip
         assert block_to_park != parked_tip
         node.parkblock(block_to_park)
         assert_equal(node.getbestblockhash(), tip)
 
         # When the chain is unparked, the node reorg into its original chain.
         node.unparkblock(parked_tip)
         assert_equal(node.getbestblockhash(), parked_tip)
 
         # Parking and then unparking a block should not change its validity,
         # and invaliding and reconsidering a block should not change its
         # parked state.  See the following test cases:
         self.log.info("Test invalidate, park, unpark, reconsider...")
         node.generate(1)
         tip = node.getbestblockhash()
         node.generate(1)
         bad_tip = node.getbestblockhash()
         # Generate an extra block to check that children are invalidated as
         # expected and do not produce dangling chaintips
         node.generate(1)
         good_tip = node.getbestblockhash()
 
         # avoid race condition from parking_node requesting block when invalid
         wait_for_tip(parking_node, good_tip)
 
         node.invalidateblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.unparkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         self.log.info("Test park, invalidate, reconsider, unpark")
         node.generate(1)
         tip = node.getbestblockhash()
         node.generate(1)
         bad_tip = node.getbestblockhash()
         node.generate(1)
         good_tip = node.getbestblockhash()
 
         # avoid race condition from parking_node requesting block when invalid
         wait_for_tip(parking_node, good_tip)
 
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.invalidateblock(bad_tip)
         # NOTE: Intuitively, other_tip_status would be "invalid", but because
         # only valid (unparked) chains are walked, child blocks' statuses are
         # not updated, so the "parked" state remains.
         self.only_valid_tip(tip, other_tip_status="parked")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.unparkblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         self.log.info("Test invalidate, park, reconsider, unpark...")
         node.generate(1)
         tip = node.getbestblockhash()
         node.generate(1)
         bad_tip = node.getbestblockhash()
         node.generate(1)
         good_tip = node.getbestblockhash()
 
         # avoid race condition from parking_node requesting block when invalid
         wait_for_tip(parking_node, good_tip)
 
         node.invalidateblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.unparkblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         self.log.info("Test park, invalidate, unpark, reconsider")
         node.generate(1)
         tip = node.getbestblockhash()
         node.generate(1)
         bad_tip = node.getbestblockhash()
         node.generate(1)
         good_tip = node.getbestblockhash()
 
         # avoid race condition from parking_node requesting block when invalid
         wait_for_tip(parking_node, good_tip)
 
         node.parkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="parked")
         node.invalidateblock(bad_tip)
         # NOTE: Intuitively, other_tip_status would be "invalid", but because
         # only valid (unparked) chains are walked, child blocks' statuses are
         # not updated, so the "parked" state remains.
         self.only_valid_tip(tip, other_tip_status="parked")
         node.unparkblock(bad_tip)
         self.only_valid_tip(tip, other_tip_status="invalid")
         node.reconsiderblock(bad_tip)
         self.only_valid_tip(good_tip)
 
         # To get ready for next testset, make sure both nodes are in sync.
         wait_for_tip(parking_node, good_tip)
         assert_equal(node.getbestblockhash(), parking_node.getbestblockhash())
 
         # Wait for node 1 to park the chain.
         def wait_for_parked_block(block):
             def check_block():
                 for tip in parking_node.getchaintips():
                     if tip["hash"] == block:
                         assert tip["status"] != "active"
                         return tip["status"] == "parked"
                 return False
             wait_until(check_block)
 
         def check_reorg_protection(depth, extra_blocks):
             self.log.info(
                 "Test deep reorg parking, {} block deep".format(depth))
 
             # Invalidate the tip on node 0, so it doesn't follow node 1.
             node.invalidateblock(node.getbestblockhash())
             # Mine block to create a fork of proper depth
             parking_node.generatetoaddress(
                 nblocks=depth - 1,
                 address=parking_node.getnewaddress(label='coinbase'))
             node.generatetoaddress(
                 nblocks=depth,
                 address=node.getnewaddress(label='coinbase'))
             # extra block should now find themselves parked
             for i in range(extra_blocks):
                 node.generate(1)
                 wait_for_parked_block(node.getbestblockhash())
 
             # If we mine one more block, the node reorgs.
             node.generate(1)
             wait_until(lambda: parking_node.getbestblockhash()
                        == node.getbestblockhash())
 
         check_reorg_protection(1, 0)
         check_reorg_protection(2, 0)
         check_reorg_protection(3, 1)
         check_reorg_protection(4, 4)
         check_reorg_protection(5, 5)
         check_reorg_protection(6, 6)
         check_reorg_protection(100, 100)
 
         # try deep reorg with a log check.
         with parking_node.assert_debug_log(["Park block"]):
             check_reorg_protection(3, 1)
 
         self.log.info(
             "Accepting many blocks at once (possibly out of order) should not park if there is no reorg.")
         # rewind one block to make a reorg that is shallow.
         node.invalidateblock(parking_node.getbestblockhash())
         # generate a ton of blocks at once.
         try:
             with parking_node.assert_debug_log(["Park block"]):
                 node.generatetoaddress(
                     nblocks=20,
                     address=node.getnewaddress(label='coinbase'))
                 wait_until(lambda: parking_node.getbestblockhash() ==
                            node.getbestblockhash())
         except AssertionError as exc:
             # good, we want an absence of "Park block" messages
             assert "does not partially match log" in exc.args[0]
         else:
             raise AssertionError("Parked block when there was no deep reorg")
 
         self.log.info("Test that unparking works when -parkdeepreorg=0")
         # Set up parking node height = fork + 4, node height = fork + 5
         node.invalidateblock(node.getbestblockhash())
         parking_node.generate(3)
         node.generatetoaddress(
             nblocks=5,
             address=node.getnewaddress(label='coinbase'))
         wait_for_parked_block(node.getbestblockhash())
         # Restart the parking node without parkdeepreorg.
         self.restart_node(1, ["-parkdeepreorg=0"])
         parking_node = self.nodes[1]
         connect_nodes_bi(node, parking_node)
         # The other chain should still be marked 'parked'.
         wait_for_parked_block(node.getbestblockhash())
         # Three more blocks is not enough to unpark. Even though its PoW is
         # larger, we are still following the delayed-unparking rules.
         node.generate(3)
         wait_for_parked_block(node.getbestblockhash())
         # Final block pushes over the edge, and should unpark.
         node.generate(1)
         wait_until(lambda: parking_node.getbestblockhash() ==
                    node.getbestblockhash(), timeout=5)
 
         # Do not append tests after this point without restarting node again.
         # Parking node is no longer parking.
 
 
 if __name__ == '__main__':
     ParkedChainTest().main()
diff --git a/test/functional/abc_p2p_compactblocks.py b/test/functional/abc_p2p_compactblocks.py
index f4311ed5a..e5798d139 100755
--- a/test/functional/abc_p2p_compactblocks.py
+++ b/test/functional/abc_p2p_compactblocks.py
@@ -1,363 +1,366 @@
 #!/usr/bin/env python3
 # Copyright (c) 2015-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.
 """
 This test checks simple acceptance of bigger blocks via p2p.
 It is derived from the much more complex p2p-fullblocktest.
 The intention is that small tests can be derived from this one, or
 this one can be extended, to cover the checks done for bigger blocks
 (e.g. sigops limits).
 """
 
 from collections import deque
 import random
 import time
 
 from test_framework.blocktools import (
     create_block,
     create_coinbase,
     create_tx_with_script,
     make_conform_to_ctor,
 )
 from test_framework.cdefs import ONE_MEGABYTE
 from test_framework.messages import (
     COutPoint,
     CTransaction,
     CTxIn,
     CTxOut,
     HeaderAndShortIDs,
     msg_cmpctblock,
     msg_sendcmpct,
     ser_compact_size,
 )
 from test_framework.mininode import (
     mininode_lock,
     P2PDataStore,
     P2PInterface,
 )
 from test_framework.script import CScript, OP_RETURN, OP_TRUE
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.txtools import pad_tx
-from test_framework.util import assert_equal, wait_until
+from test_framework.util import (
+    assert_equal,
+    wait_until
+)
 
 
 class PreviousSpendableOutput():
 
     def __init__(self, tx=CTransaction(), n=-1):
         self.tx = tx
         # the output we're spending
         self.n = n
 
 
 # TestP2PConn: A peer we use to send messages to bitcoind, and store responses.
 class TestP2PConn(P2PInterface):
 
     def __init__(self):
         self.last_sendcmpct = None
         self.last_cmpctblock = None
         self.last_getheaders = None
         self.last_headers = None
         super().__init__()
 
     def on_sendcmpct(self, message):
         self.last_sendcmpct = message
 
     def on_cmpctblock(self, message):
         self.last_cmpctblock = message
         self.last_cmpctblock.header_and_shortids.header.calc_sha256()
 
     def on_getheaders(self, message):
         self.last_getheaders = message
 
     def on_headers(self, message):
         self.last_headers = message
         for x in self.last_headers.headers:
             x.calc_sha256()
 
     def clear_block_data(self):
         with mininode_lock:
             self.last_sendcmpct = None
             self.last_cmpctblock = None
 
 
 class FullBlockTest(BitcoinTestFramework):
 
     def set_test_params(self):
         self.num_nodes = 1
         self.setup_clean_chain = True
         self.block_heights = {}
         self.tip = None
         self.blocks = {}
         self.excessive_block_size = 16 * ONE_MEGABYTE
         self.extra_args = [['-whitelist=127.0.0.1',
                             '-limitancestorcount=999999',
                             '-limitancestorsize=999999',
                             '-limitdescendantcount=999999',
                             '-limitdescendantsize=999999',
                             '-maxmempool=99999',
                             '-excessiveblocksize={}'.format(
                                 self.excessive_block_size),
                             '-acceptnonstdtxn=1']]
         # UBSAN will cause this test to timeout without this.
         self.rpc_timeout = 180
 
     def add_options(self, parser):
         super().add_options(parser)
         parser.add_argument(
             "--runbarelyexpensive", dest="runbarelyexpensive", default=True)
 
     def add_transactions_to_block(self, block, tx_list):
         [tx.rehash() for tx in tx_list]
         block.vtx.extend(tx_list)
 
     # this is a little handier to use than the version in blocktools.py
     def create_tx(self, spend_tx, n, value, script=CScript([OP_TRUE])):
         tx = create_tx_with_script(spend_tx, n, b"", value, script)
         return tx
 
     def next_block(self, number, spend=None, script=CScript(
             [OP_TRUE]), block_size=0, extra_txns=0):
         if self.tip is None:
             base_block_hash = self.genesis_hash
             block_time = int(time.time()) + 1
         else:
             base_block_hash = self.tip.sha256
             block_time = self.tip.nTime + 1
         # First create the coinbase
         height = self.block_heights[base_block_hash] + 1
         coinbase = create_coinbase(height)
         coinbase.rehash()
         if spend is None:
             # We need to have something to spend to fill the block.
             assert_equal(block_size, 0)
             block = create_block(base_block_hash, coinbase, block_time)
         else:
             # all but one satoshi to fees
             coinbase.vout[0].nValue += spend.tx.vout[spend.n].nValue - 1
             coinbase.rehash()
             block = create_block(base_block_hash, coinbase, block_time)
 
             # Make sure we have plenty enough to spend going forward.
             spendable_outputs = deque([spend])
 
             def get_base_transaction():
                 # Create the new transaction
                 tx = CTransaction()
                 # Spend from one of the spendable outputs
                 spend = spendable_outputs.popleft()
                 tx.vin.append(CTxIn(COutPoint(spend.tx.sha256, spend.n)))
                 # Add spendable outputs
                 for i in range(4):
                     tx.vout.append(CTxOut(0, CScript([OP_TRUE])))
                     spendable_outputs.append(PreviousSpendableOutput(tx, i))
                 pad_tx(tx)
                 return tx
 
             tx = get_base_transaction()
 
             # Make it the same format as transaction added for padding and save the size.
             # It's missing the padding output, so we add a constant to account
             # for it.
             tx.rehash()
 
             # If a specific script is required, add it.
             if script is not None:
                 tx.vout.append(CTxOut(1, script))
 
             # Put some random data into the first transaction of the chain to
             # randomize ids.
             tx.vout.append(
                 CTxOut(0, CScript([random.randint(0, 256), OP_RETURN])))
 
             # Add the transaction to the block
             self.add_transactions_to_block(block, [tx])
 
             # Add transaction until we reach the expected transaction count
             for _ in range(extra_txns):
                 self.add_transactions_to_block(block, [get_base_transaction()])
 
             # If we have a block size requirement, just fill
             # the block until we get there
             current_block_size = len(block.serialize())
             overage_bytes = 0
             while current_block_size < block_size:
                 # We will add a new transaction. That means the size of
                 # the field enumerating how many transaction go in the block
                 # may change.
                 current_block_size -= len(ser_compact_size(len(block.vtx)))
                 current_block_size += len(ser_compact_size(len(block.vtx) + 1))
 
                 # Add padding to fill the block.
                 left_to_fill = block_size - current_block_size
 
                 # Don't go over the 1 mb limit for a txn
                 if left_to_fill > 500000:
                     # Make sure we eat up non-divisible by 100 amounts quickly
                     # Also keep transaction less than 1 MB
                     left_to_fill = 500000 + left_to_fill % 100
 
                 # Create the new transaction
                 tx = get_base_transaction()
                 pad_tx(tx, left_to_fill - overage_bytes)
                 if len(tx.serialize()) + current_block_size > block_size:
                     # Our padding was too big try again
                     overage_bytes += 1
                     continue
 
                 # Add the tx to the list of transactions to be included
                 # in the block.
                 self.add_transactions_to_block(block, [tx])
                 current_block_size += len(tx.serialize())
 
             # Now that we added a bunch of transaction, we need to recompute
             # the merkle root.
             make_conform_to_ctor(block)
             block.hashMerkleRoot = block.calc_merkle_root()
 
         # Check that the block size is what's expected
         if block_size > 0:
             assert_equal(len(block.serialize()), block_size)
 
         # Do PoW, which is cheap on regnet
         block.solve()
         self.tip = block
         self.block_heights[block.sha256] = height
         assert number not in self.blocks
         self.blocks[number] = block
         return block
 
     def run_test(self):
         node = self.nodes[0]
         default_p2p = node.add_p2p_connection(P2PDataStore())
         test_p2p = node.add_p2p_connection(TestP2PConn())
 
         # Set the blocksize to 2MB as initial condition
         node.setexcessiveblock(self.excessive_block_size)
 
         self.genesis_hash = int(node.getbestblockhash(), 16)
         self.block_heights[self.genesis_hash] = 0
         spendable_outputs = []
 
         # save the current tip so it can be spent by a later block
         def save_spendable_output():
             spendable_outputs.append(self.tip)
 
         # get an output that we previously marked as spendable
         def get_spendable_output():
             return PreviousSpendableOutput(spendable_outputs.pop(0).vtx[0], 0)
 
         # move the tip back to a previous block
         def tip(number):
             self.tip = self.blocks[number]
 
         # shorthand for functions
         block = self.next_block
 
         # Create a new block
         block(0)
         save_spendable_output()
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Now we need that block to mature so we can spend the coinbase.
         maturity_blocks = []
         for i in range(99):
             block(5000 + i)
             maturity_blocks.append(self.tip)
             save_spendable_output()
 
         # Get to one block of the May 15, 2018 HF activation
         for i in range(6):
             block(5100 + i)
             maturity_blocks.append(self.tip)
 
         # Send it all to the node at once.
         default_p2p.send_blocks_and_test(maturity_blocks, node)
 
         # collect spendable outputs now to avoid cluttering the code later on
         out = []
         for i in range(100):
             out.append(get_spendable_output())
 
         # Check that compact block also work for big blocks
         # Wait for SENDCMPCT
         def received_sendcmpct():
             return (test_p2p.last_sendcmpct is not None)
         wait_until(received_sendcmpct, timeout=30)
 
         sendcmpct = msg_sendcmpct()
         sendcmpct.version = 1
         sendcmpct.announce = True
         test_p2p.send_and_ping(sendcmpct)
 
         # Exchange headers
         def received_getheaders():
             return (test_p2p.last_getheaders is not None)
         wait_until(received_getheaders, timeout=30)
 
         # Return the favor
         test_p2p.send_message(test_p2p.last_getheaders)
 
         # Wait for the header list
         def received_headers():
             return (test_p2p.last_headers is not None)
         wait_until(received_headers, timeout=30)
 
         # It's like we know about the same headers !
         test_p2p.send_message(test_p2p.last_headers)
 
         # Send a block
         b1 = block(1, spend=out[0], block_size=ONE_MEGABYTE + 1)
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Checks the node to forward it via compact block
         def received_block():
             return (test_p2p.last_cmpctblock is not None)
         wait_until(received_block, timeout=30)
 
         # Was it our block ?
         cmpctblk_header = test_p2p.last_cmpctblock.header_and_shortids.header
         cmpctblk_header.calc_sha256()
         assert cmpctblk_header.sha256 == b1.sha256
 
         # Send a large block with numerous transactions.
         test_p2p.clear_block_data()
         b2 = block(2, spend=out[1], extra_txns=70000,
                    block_size=self.excessive_block_size - 1000)
         default_p2p.send_blocks_and_test([self.tip], node)
 
         # Checks the node forwards it via compact block
         wait_until(received_block, timeout=30)
 
         # Was it our block ?
         cmpctblk_header = test_p2p.last_cmpctblock.header_and_shortids.header
         cmpctblk_header.calc_sha256()
         assert cmpctblk_header.sha256 == b2.sha256
 
         # In order to avoid having to resend a ton of transactions, we invalidate
         # b2, which will send all its transactions in the mempool. Note that this
         # assumes reorgs will insert low-fee transactions back into the
         # mempool.
         node.invalidateblock(node.getbestblockhash())
 
         # Let's send a compact block and see if the node accepts it.
         # Let's modify b2 and use it so that we can reuse the mempool.
         tx = b2.vtx[0]
         tx.vout.append(CTxOut(0, CScript([random.randint(0, 256), OP_RETURN])))
         tx.rehash()
         b2.vtx[0] = tx
         b2.hashMerkleRoot = b2.calc_merkle_root()
         b2.solve()
 
         # Now we create the compact block and send it
         comp_block = HeaderAndShortIDs()
         comp_block.initialize_from_block(b2)
         test_p2p.send_and_ping(msg_cmpctblock(comp_block.to_p2p()))
 
         # Check that compact block is received properly
         assert int(node.getbestblockhash(), 16) == b2.sha256
 
 
 if __name__ == '__main__':
     FullBlockTest().main()
diff --git a/test/functional/feature_notifications.py b/test/functional/feature_notifications.py
index 595c9fbe9..0a50de045 100755
--- a/test/functional/feature_notifications.py
+++ b/test/functional/feature_notifications.py
@@ -1,122 +1,126 @@
 #!/usr/bin/env python3
 # Copyright (c) 2014-2019 The Bitcoin Core developers
 # Copyright (c) 2018 The Bitcoin developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 """Test the -alertnotify, -blocknotify and -walletnotify options."""
 import os
 
 from test_framework.address import ADDRESS_BCHREG_UNSPENDABLE
 from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, connect_nodes_bi, wait_until
+from test_framework.util import (
+    assert_equal,
+    connect_nodes_bi,
+    wait_until
+)
 
 FORK_WARNING_MESSAGE = "Warning: Large-work fork detected, forking after block {}"
 
 
 class NotificationsTest(BitcoinTestFramework):
     def set_test_params(self):
         self.num_nodes = 2
         self.setup_clean_chain = True
 
     def setup_network(self):
         self.alertnotify_dir = os.path.join(self.options.tmpdir, "alertnotify")
         self.blocknotify_dir = os.path.join(self.options.tmpdir, "blocknotify")
         self.walletnotify_dir = os.path.join(
             self.options.tmpdir, "walletnotify")
         os.mkdir(self.alertnotify_dir)
         os.mkdir(self.blocknotify_dir)
         os.mkdir(self.walletnotify_dir)
 
         # -alertnotify and -blocknotify on node0, walletnotify on node1
         self.extra_args = [["-alertnotify=echo > {}".format(
             os.path.join(self.alertnotify_dir, '%s')),
             "-blocknotify=echo > {}".format(os.path.join(self.blocknotify_dir, '%s'))],
             ["-blockversion=211",
              "-rescan",
              "-walletnotify=echo > {}".format(os.path.join(self.walletnotify_dir, '%s'))]]
         super().setup_network()
 
     def run_test(self):
         self.log.info("test -blocknotify")
         block_count = 10
         blocks = self.nodes[1].generatetoaddress(
             block_count,
             self.nodes[1].getnewaddress() if self.is_wallet_compiled()
             else ADDRESS_BCHREG_UNSPENDABLE
         )
 
         # wait at most 10 seconds for expected number of files before reading
         # the content
         wait_until(
             lambda: len(
                 os.listdir(
                     self.blocknotify_dir)) == block_count,
             timeout=10)
 
         # directory content should equal the generated blocks hashes
         assert_equal(sorted(blocks), sorted(os.listdir(self.blocknotify_dir)))
 
         if self.is_wallet_compiled():
             self.log.info("test -walletnotify")
             # wait at most 10 seconds for expected number of files before reading
             # the content
             wait_until(
                 lambda: len(
                     os.listdir(
                         self.walletnotify_dir)) == block_count,
                 timeout=10)
 
             # directory content should equal the generated transaction hashes
             txids_rpc = list(
                 map(lambda t: t['txid'], self.nodes[1].listtransactions("*", block_count)))
             assert_equal(
                 sorted(txids_rpc), sorted(
                     os.listdir(
                         self.walletnotify_dir)))
             for tx_file in os.listdir(self.walletnotify_dir):
                 os.remove(os.path.join(self.walletnotify_dir, tx_file))
 
             self.log.info("test -walletnotify after rescan")
             # restart node to rescan to force wallet notifications
             self.restart_node(1)
             connect_nodes_bi(self.nodes[0], self.nodes[1])
 
             wait_until(
                 lambda: len(
                     os.listdir(
                         self.walletnotify_dir)) == block_count,
                 timeout=10)
 
             # directory content should equal the generated transaction hashes
             txids_rpc = list(
                 map(lambda t: t['txid'], self.nodes[1].listtransactions("*", block_count)))
             assert_equal(
                 sorted(txids_rpc), sorted(
                     os.listdir(
                         self.walletnotify_dir)))
 
         # Create an invalid chain and ensure the node warns.
         self.log.info("test -alertnotify for forked chain")
         fork_block = self.nodes[0].getbestblockhash()
         self.nodes[0].generatetoaddress(1, ADDRESS_BCHREG_UNSPENDABLE)
         invalid_block = self.nodes[0].getbestblockhash()
         self.nodes[0].generatetoaddress(7, ADDRESS_BCHREG_UNSPENDABLE)
 
         # Invalidate a large branch, which should trigger an alert.
         self.nodes[0].invalidateblock(invalid_block)
 
         # Give bitcoind 10 seconds to write the alert notification
         wait_until(lambda: len(os.listdir(self.alertnotify_dir)), timeout=10)
 
         # The notification command is unable to properly handle the spaces on
         # windows. Skip the content check in this case.
         if os.name != 'nt':
             assert FORK_WARNING_MESSAGE.format(
                 fork_block) in os.listdir(self.alertnotify_dir)
 
         for notify_file in os.listdir(self.alertnotify_dir):
             os.remove(os.path.join(self.alertnotify_dir, notify_file))
 
 
 if __name__ == '__main__':
     NotificationsTest().main()