diff --git a/src/qt/test/bitcoinaddressvalidatortests.cpp b/src/qt/test/bitcoinaddressvalidatortests.cpp
index f749cbc29..a82ae174c 100644
--- a/src/qt/test/bitcoinaddressvalidatortests.cpp
+++ b/src/qt/test/bitcoinaddressvalidatortests.cpp
@@ -1,54 +1,56 @@
 // 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.
 
-#include "qt/test/bitcoinaddressvalidatortests.h"
-#include "chainparams.h"
-#include "qt/bitcoinaddressvalidator.h"
+#include <qt/bitcoinaddressvalidator.h>
+#include <qt/test/bitcoinaddressvalidatortests.h>
+
+#include <chainparams.h>
+
 #include <QValidator>
 
 void BitcoinAddressValidatorTests::inputTests() {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
     const std::string prefix = params->CashAddrPrefix();
     BitcoinAddressEntryValidator v(prefix, nullptr);
 
     int unused = 0;
     QString in;
 
     // Empty string is intermediate.
     in = "";
     QVERIFY(v.validate(in, unused) == QValidator::Intermediate);
 
     // invalid base58 because of I, invalid cashaddr, currently considered valid
     // anyway.
     in = "BIIC";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // invalid base58, invalid cashaddr, currently considered valid anyway.
     in = "BITCOINCASHH";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // invalid base58 because of I, but could be a cashaddr prefix
     in = "BITC";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // invalid base58, valid cashaddr
     in = "BITCOINCASH:QP";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // invalid base58, valid cashaddr, lower case
     in = "bitcoincash:qp";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // invalid base58, valid cashaddr, mixed case
     in = "bItCoInCaSh:Qp";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // valid base58, invalid cash
     in = "BBBBBBBBBBBBBB";
     QVERIFY(v.validate(in, unused) == QValidator::Acceptable);
 
     // Only alphanumeric chars are accepted.
     in = "%";
     QVERIFY(v.validate(in, unused) == QValidator::Invalid);
 }
diff --git a/src/qt/test/compattests.cpp b/src/qt/test/compattests.cpp
index fea1dce5b..3d50525e2 100644
--- a/src/qt/test/compattests.cpp
+++ b/src/qt/test/compattests.cpp
@@ -1,22 +1,21 @@
 // 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.
 
-#include "paymentrequestplus.h" // this includes protobuf's port.h which defines its own bswap macos
+#include <qt/test/compattests.h>
 
-#include "compattests.h"
-
-#include "compat/byteswap.h"
+#include <compat/byteswap.h>
+#include <qt/paymentrequestplus.h> // this includes protobuf's port.h which defines its own bswap macos
 
 void CompatTests::bswapTests() {
     // Sibling in bitcoin/src/test/bswap_tests.cpp
     uint16_t u1 = 0x1234;
     uint32_t u2 = 0x56789abc;
     uint64_t u3 = 0xdef0123456789abc;
     uint16_t e1 = 0x3412;
     uint32_t e2 = 0xbc9a7856;
     uint64_t e3 = 0xbc9a78563412f0de;
     QVERIFY(bswap_16(u1) == e1);
     QVERIFY(bswap_32(u2) == e2);
     QVERIFY(bswap_64(u3) == e3);
 }
diff --git a/src/qt/test/guiutiltests.cpp b/src/qt/test/guiutiltests.cpp
index 0b6491d5f..cd6aaf2cd 100644
--- a/src/qt/test/guiutiltests.cpp
+++ b/src/qt/test/guiutiltests.cpp
@@ -1,65 +1,66 @@
 // 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.
 
-#include "guiutiltests.h"
-#include "chainparams.h"
-#include "config.h"
-#include "dstencode.h"
-#include "guiutil.h"
+#include <qt/test/guiutiltests.h>
+
+#include <chainparams.h>
+#include <config.h>
+#include <dstencode.h>
+#include <qt/guiutil.h>
 
 namespace {
 
 class GUIUtilTestConfig : public DummyConfig {
 public:
     GUIUtilTestConfig()
         : DummyConfig(CBaseChainParams::MAIN), useCashAddr(false) {}
     void SetCashAddrEncoding(bool b) override { useCashAddr = b; }
     bool UseCashAddrEncoding() const override { return useCashAddr; }
 
 private:
     bool useCashAddr;
 };
 
 } // namespace
 
 void GUIUtilTests::dummyAddressTest() {
     GUIUtilTestConfig config;
     const CChainParams &params = config.GetChainParams();
 
     std::string dummyaddr;
 
     config.SetCashAddrEncoding(false);
     dummyaddr = GUIUtil::DummyAddress(config);
     QVERIFY(!IsValidDestinationString(dummyaddr, params));
     QVERIFY(!dummyaddr.empty());
 
     config.SetCashAddrEncoding(true);
     dummyaddr = GUIUtil::DummyAddress(config);
     QVERIFY(!IsValidDestinationString(dummyaddr, params));
     QVERIFY(!dummyaddr.empty());
 }
 
 void GUIUtilTests::toCurrentEncodingTest() {
     GUIUtilTestConfig config;
 
     // garbage in, garbage out
     QVERIFY(GUIUtil::convertToConfiguredAddressFormat(config, "garbage") ==
             "garbage");
 
     QString cashaddr_pubkey =
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a";
     QString base58_pubkey = "1BpEi6DfDAUFd7GtittLSdBeYJvcoaVggu";
 
     config.SetCashAddrEncoding(true);
     QVERIFY(GUIUtil::convertToConfiguredAddressFormat(
                 config, cashaddr_pubkey) == cashaddr_pubkey);
     QVERIFY(GUIUtil::convertToConfiguredAddressFormat(config, base58_pubkey) ==
             cashaddr_pubkey);
 
     config.SetCashAddrEncoding(false);
     QVERIFY(GUIUtil::convertToConfiguredAddressFormat(
                 config, cashaddr_pubkey) == base58_pubkey);
     QVERIFY(GUIUtil::convertToConfiguredAddressFormat(config, base58_pubkey) ==
             base58_pubkey);
 }
diff --git a/src/qt/test/paymentservertests.cpp b/src/qt/test/paymentservertests.cpp
index 35704139b..3ca880d1e 100644
--- a/src/qt/test/paymentservertests.cpp
+++ b/src/qt/test/paymentservertests.cpp
@@ -1,221 +1,221 @@
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "paymentservertests.h"
-
-#include "optionsmodel.h"
-#include "paymentrequestdata.h"
-
-#include "amount.h"
-#include "interfaces/node.h"
-#include "random.h"
-#include "script/script.h"
-#include "script/standard.h"
-#include "util.h"
-#include "utilstrencodings.h"
+#include <qt/test/paymentservertests.h>
+
+#include <amount.h>
+#include <interfaces/node.h>
+#include <qt/optionsmodel.h>
+#include <random.h>
+#include <script/script.h>
+#include <script/standard.h>
+#include <util.h>
+#include <utilstrencodings.h>
+
+#include <qt/test/paymentrequestdata.h>
 
 #include <openssl/x509.h>
 #include <openssl/x509_vfy.h>
 
 #include <QFileOpenEvent>
 #include <QTemporaryFile>
 
 X509 *parse_b64der_cert(const char *cert_data) {
     std::vector<uint8_t> data = DecodeBase64(cert_data);
     assert(data.size() > 0);
     const uint8_t *dptr = &data[0];
     X509 *cert = d2i_X509(nullptr, &dptr, data.size());
     assert(cert);
     return cert;
 }
 
 //
 // Test payment request handling
 //
 
 static SendCoinsRecipient handleRequest(PaymentServer *server,
                                         std::vector<uint8_t> &data) {
     RecipientCatcher sigCatcher;
     QObject::connect(server, SIGNAL(receivedPaymentRequest(SendCoinsRecipient)),
                      &sigCatcher, SLOT(getRecipient(SendCoinsRecipient)));
 
     // Write data to a temp file:
     QTemporaryFile f;
     f.open();
     f.write((const char *)&data[0], data.size());
     f.close();
 
     // Create a QObject, install event filter from PaymentServer and send a file
     // open event to the object
     QObject object;
     object.installEventFilter(server);
     QFileOpenEvent event(f.fileName());
     // If sending the event fails, this will cause sigCatcher to be empty, which
     // will lead to a test failure anyway.
     QCoreApplication::sendEvent(&object, &event);
 
     QObject::disconnect(server,
                         SIGNAL(receivedPaymentRequest(SendCoinsRecipient)),
                         &sigCatcher, SLOT(getRecipient(SendCoinsRecipient)));
 
     // Return results from sigCatcher
     return sigCatcher.recipient;
 }
 
 void PaymentServerTests::paymentServerTests() {
     SelectParams(CBaseChainParams::MAIN);
     auto node = interfaces::MakeNode();
     OptionsModel optionsModel(*node);
     PaymentServer *server = new PaymentServer(nullptr, false);
     X509_STORE *caStore = X509_STORE_new();
     X509_STORE_add_cert(caStore, parse_b64der_cert(caCert1_BASE64));
     PaymentServer::LoadRootCAs(caStore);
     server->setOptionsModel(&optionsModel);
     server->uiReady();
 
     std::vector<uint8_t> data;
     SendCoinsRecipient r;
     QString merchant;
 
     // Now feed PaymentRequests to server, and observe signals it produces
 
     // This payment request validates directly against the caCert1 certificate
     // authority:
     data = DecodeBase64(paymentrequest1_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString("testmerchant.org"));
 
     // Signed, but expired, merchant cert in the request:
     data = DecodeBase64(paymentrequest2_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // 10-long certificate chain, all intermediates valid:
     data = DecodeBase64(paymentrequest3_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString("testmerchant8.org"));
 
     // Long certificate chain, with an expired certificate in the middle:
     data = DecodeBase64(paymentrequest4_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // Validly signed, but by a CA not in our root CA list:
     data = DecodeBase64(paymentrequest5_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // Try again with no root CA's, verifiedMerchant should be empty:
     caStore = X509_STORE_new();
     PaymentServer::LoadRootCAs(caStore);
     data = DecodeBase64(paymentrequest1_cert1_BASE64);
     r = handleRequest(server, data);
     r.paymentRequest.getMerchant(caStore, merchant);
     QCOMPARE(merchant, QString(""));
 
     // Load second root certificate
     caStore = X509_STORE_new();
     X509_STORE_add_cert(caStore, parse_b64der_cert(caCert2_BASE64));
     PaymentServer::LoadRootCAs(caStore);
 
     QByteArray byteArray;
 
     // For the tests below we just need the payment request data from
     // paymentrequestdata.h parsed + stored in r.paymentRequest.
     //
     // These tests require us to bypass the following normal client execution
     // flow shown below to be able to explicitly just trigger a certain
     // condition!
     //
     // handleRequest()
     // -> PaymentServer::eventFilter()
     //   -> PaymentServer::handleURIOrFile()
     //     -> PaymentServer::readPaymentRequestFromFile()
     //       -> PaymentServer::processPaymentRequest()
 
     // Contains a testnet paytoaddress, so payment request network doesn't match
     // client network:
     data = DecodeBase64(paymentrequest1_cert2_BASE64);
     byteArray = QByteArray((const char *)&data[0], data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized, because network "main" is default,
     // even for uninizialized payment requests and that will fail our test here.
     QVERIFY(r.paymentRequest.IsInitialized());
     QCOMPARE(PaymentServer::verifyNetwork(*node, r.paymentRequest.getDetails()),
              false);
 
     // Expired payment request (expires is set to 1 = 1970-01-01 00:00:01):
     data = DecodeBase64(paymentrequest2_cert2_BASE64);
     byteArray = QByteArray((const char *)&data[0], data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // compares 1 < GetTime() == false (treated as expired payment request)
     QCOMPARE(PaymentServer::verifyExpired(r.paymentRequest.getDetails()), true);
 
     // Unexpired payment request (expires is set to 0x7FFFFFFFFFFFFFFF = max.
     // int64_t):
     // 9223372036854775807 (uint64), 9223372036854775807 (int64_t) and -1
     // (int32_t)
     // -1 is 1969-12-31 23:59:59 (for a 32 bit time values)
     data = DecodeBase64(paymentrequest3_cert2_BASE64);
     byteArray = QByteArray((const char *)&data[0], data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // compares 9223372036854775807 < GetTime() == false (treated as unexpired
     // payment request)
     QCOMPARE(PaymentServer::verifyExpired(r.paymentRequest.getDetails()),
              false);
 
     // Unexpired payment request (expires is set to 0x8000000000000000 > max.
     // int64_t, allowed uint64):
     // 9223372036854775808 (uint64), -9223372036854775808 (int64_t) and 0
     // (int32_t)
     // 0 is 1970-01-01 00:00:00 (for a 32 bit time values)
     data = DecodeBase64(paymentrequest4_cert2_BASE64);
     byteArray = QByteArray((const char *)&data[0], data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // compares -9223372036854775808 < GetTime() == true (treated as expired
     // payment request)
     QCOMPARE(PaymentServer::verifyExpired(r.paymentRequest.getDetails()), true);
 
     // Test BIP70 DoS protection:
     uint8_t randData[BIP70_MAX_PAYMENTREQUEST_SIZE + 1];
     GetRandBytes(randData, sizeof(randData));
     // Write data to a temp file:
     QTemporaryFile tempFile;
     tempFile.open();
     tempFile.write((const char *)randData, sizeof(randData));
     tempFile.close();
     // compares 50001 <= BIP70_MAX_PAYMENTREQUEST_SIZE == false
     QCOMPARE(PaymentServer::verifySize(tempFile.size()), false);
 
     // Payment request with amount overflow (amount is set to 21000001 BCH):
     data = DecodeBase64(paymentrequest5_cert2_BASE64);
     byteArray = QByteArray((const char *)&data[0], data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized
     QVERIFY(r.paymentRequest.IsInitialized());
     // Extract address and amount from the request
     QList<std::pair<CScript, Amount>> sendingTos = r.paymentRequest.getPayTo();
     for (const std::pair<CScript, Amount> &sendingTo : sendingTos) {
         CTxDestination dest;
         if (ExtractDestination(sendingTo.first, dest))
             QCOMPARE(PaymentServer::verifyAmount(sendingTo.second), false);
     }
 
     delete server;
 }
 
 void RecipientCatcher::getRecipient(const SendCoinsRecipient &r) {
     recipient = r;
 }
diff --git a/src/qt/test/paymentservertests.h b/src/qt/test/paymentservertests.h
index 889cf5dbe..f0ef0cb67 100644
--- a/src/qt/test/paymentservertests.h
+++ b/src/qt/test/paymentservertests.h
@@ -1,33 +1,33 @@
 // Copyright (c) 2009-2015 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_QT_TEST_PAYMENTSERVERTESTS_H
 #define BITCOIN_QT_TEST_PAYMENTSERVERTESTS_H
 
-#include "../paymentserver.h"
+#include <qt/paymentserver.h>
 
 #include <QObject>
 #include <QTest>
 
 class PaymentServerTests : public QObject {
     Q_OBJECT
 
 private Q_SLOTS:
     void paymentServerTests();
 };
 
 // Dummy class to receive paymentserver signals.
 // If SendCoinsRecipient was a proper QObject, then we could use QSignalSpy...
 // but it's not.
 class RecipientCatcher : public QObject {
     Q_OBJECT
 
 public Q_SLOTS:
     void getRecipient(const SendCoinsRecipient &r);
 
 public:
     SendCoinsRecipient recipient;
 };
 
 #endif // BITCOIN_QT_TEST_PAYMENTSERVERTESTS_H
diff --git a/src/qt/test/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp
index a2354a362..9d6970084 100644
--- a/src/qt/test/rpcnestedtests.cpp
+++ b/src/qt/test/rpcnestedtests.cpp
@@ -1,210 +1,212 @@
 // 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.
 
-#include <test/rpcnestedtests.h>
+#include <qt/test/rpcnestedtests.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <consensus/validation.h>
 #include <fs.h>
 #include <interfaces/node.h>
 #include <qt/rpcconsole.h>
 #include <rpc/register.h>
 #include <rpc/server.h>
-#include <test/test_bitcoin.h>
-#include <univalue.h>
 #include <util.h>
 #include <validation.h>
 
+#include <test/test_bitcoin.h>
+
 #include <QDir>
 #include <QtGlobal>
 
+#include <univalue.h>
+
 static UniValue rpcNestedTest_rpc(const Config &config,
                                   const JSONRPCRequest &request) {
     if (request.fHelp) {
         return "help message";
     }
     return request.params.write(0, 0);
 }
 
 static const ContextFreeRPCCommand vRPCCommands[] = {
     {"test", "rpcNestedTest", &rpcNestedTest_rpc, {}},
 };
 
 void RPCNestedTests::rpcNestedTests() {
     // do some test setup
     // could be moved to a more generic place when we add more tests on QT level
     tableRPC.appendCommand("rpcNestedTest", &vRPCCommands[0]);
     ClearDatadirCache();
     std::string path =
         QDir::tempPath().toStdString() + "/" +
         strprintf("test_bitcoin_qt_%lu_%i", (unsigned long)GetTime(),
                   (int)(GetRand(100000)));
     QDir dir(QString::fromStdString(path));
     dir.mkpath(".");
     gArgs.ForceSetArg("-datadir", path);
     // mempool.setSanityCheck(1.0);
 
     TestingSetup test;
 
     std::string result;
     std::string result2;
     std::string filtered;
     auto node = interfaces::MakeNode();
 
     // Simple result filtering with path.
     RPCConsole::RPCExecuteCommandLine(*node, result,
                                       "getblockchaininfo()[chain]", &filtered);
     QVERIFY(result == "main");
     QVERIFY(filtered == "getblockchaininfo()[chain]");
 
     // Simple 2 level nesting.
     RPCConsole::RPCExecuteCommandLine(*node, result,
                                       "getblock(getbestblockhash())");
     RPCConsole::RPCExecuteCommandLine(
         *node, result, "getblock(getblock(getbestblockhash())[hash], true)");
 
     // 4 level nesting with whitespace, filtering path and boolean parameter.
     RPCConsole::RPCExecuteCommandLine(
         *node, result,
         "getblock( getblock( getblock(getbestblockhash())[hash] "
         ")[hash], true)");
 
     RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo");
     QVERIFY(result.substr(0, 1) == "{");
 
     RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo()");
     QVERIFY(result.substr(0, 1) == "{");
 
     // Whitespace at the end will be tolerated.
     RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo ");
     QVERIFY(result.substr(0, 1) == "{");
 
     // Quote path identifier are allowed, but look after a child contaning the
     // quotes in the key.
     (RPCConsole::RPCExecuteCommandLine(*node, result,
                                        "getblockchaininfo()[\"chain\"]"));
     QVERIFY(result == "null");
 
     // parameter not in brackets are allowed.
     (RPCConsole::RPCExecuteCommandLine(*node, result,
                                        "createrawtransaction [] {} 0"));
     // Parameter in brackets are allowed.
     (RPCConsole::RPCExecuteCommandLine(*node, result2,
                                        "createrawtransaction([],{},0)"));
     QVERIFY(result == result2);
     // Whitespace between parameters is allowed.
     (RPCConsole::RPCExecuteCommandLine(
         *node, result2, "createrawtransaction( [],  {} , 0   )"));
     QVERIFY(result == result2);
 
     RPCConsole::RPCExecuteCommandLine(
         *node, result, "getblock(getbestblockhash())[tx][0]", &filtered);
     QVERIFY(result ==
             "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b");
     QVERIFY(filtered == "getblock(getbestblockhash())[tx][0]");
 
     RPCConsole::RPCParseCommandLine(nullptr, result, "importprivkey", false,
                                     &filtered);
     QVERIFY(filtered == "importprivkey(…)");
     RPCConsole::RPCParseCommandLine(
         nullptr, result, "signmessagewithprivkey abc", false, &filtered);
     QVERIFY(filtered == "signmessagewithprivkey(…)");
     RPCConsole::RPCParseCommandLine(
         nullptr, result, "signmessagewithprivkey abc,def", false, &filtered);
     QVERIFY(filtered == "signmessagewithprivkey(…)");
     RPCConsole::RPCParseCommandLine(
         nullptr, result, "signrawtransactionwithkey(abc)", false, &filtered);
     QVERIFY(filtered == "signrawtransactionwithkey(…)");
     RPCConsole::RPCParseCommandLine(nullptr, result, "walletpassphrase(help())",
                                     false, &filtered);
     QVERIFY(filtered == "walletpassphrase(…)");
     RPCConsole::RPCParseCommandLine(
         nullptr, result,
         "walletpassphrasechange(help(walletpassphrasechange(abc)))", false,
         &filtered);
     QVERIFY(filtered == "walletpassphrasechange(…)");
     RPCConsole::RPCParseCommandLine(
         nullptr, result, "help(encryptwallet(abc, def))", false, &filtered);
     QVERIFY(filtered == "help(encryptwallet(…))");
     RPCConsole::RPCParseCommandLine(nullptr, result, "help(importprivkey())",
                                     false, &filtered);
     QVERIFY(filtered == "help(importprivkey(…))");
     RPCConsole::RPCParseCommandLine(
         nullptr, result, "help(importprivkey(help()))", false, &filtered);
     QVERIFY(filtered == "help(importprivkey(…))");
     RPCConsole::RPCParseCommandLine(
         nullptr, result, "help(importprivkey(abc), walletpassphrase(def))",
         false, &filtered);
     QVERIFY(filtered == "help(importprivkey(…), walletpassphrase(…))");
 
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest");
     QVERIFY(result == "[]");
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest ''");
     QVERIFY(result == "[\"\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest \"\"");
     QVERIFY(result == "[\"\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest '' abc");
     QVERIFY(result == "[\"\",\"abc\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result,
                                       "rpcNestedTest abc '' abc");
     QVERIFY(result == "[\"abc\",\"\",\"abc\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest abc  abc");
     QVERIFY(result == "[\"abc\",\"abc\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result,
                                       "rpcNestedTest abc\t\tabc");
     QVERIFY(result == "[\"abc\",\"abc\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest(abc )");
     QVERIFY(result == "[\"abc\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result, "rpcNestedTest( abc )");
     QVERIFY(result == "[\"abc\"]");
     RPCConsole::RPCExecuteCommandLine(*node, result,
                                       "rpcNestedTest(   abc   ,   cba )");
     QVERIFY(result == "[\"abc\",\"cba\"]");
 
 #if QT_VERSION >= 0x050300
     // do the QVERIFY_EXCEPTION_THROWN checks only with Qt5.3 and higher
     // (QVERIFY_EXCEPTION_THROWN was introduced in Qt5.3)
 
     // invalid syntax
     QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
                                  *node, result, "getblockchaininfo() .\n"),
                              std::runtime_error);
 
     // invalid syntax
     QVERIFY_EXCEPTION_THROWN(
         RPCConsole::RPCExecuteCommandLine(
             *node, result, "getblockchaininfo() getblockchaininfo()"),
         std::runtime_error);
     // tolerate non closing brackets if we have no arguments.
     (RPCConsole::RPCExecuteCommandLine(*node, result, "getblockchaininfo("));
 
     // tolerate non command brackts
     (RPCConsole::RPCExecuteCommandLine(*node, result,
                                        "getblockchaininfo()()()"));
 
     // invalid argument
     QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
                                  *node, result, "getblockchaininfo(True)"),
                              UniValue);
     // method not found
     QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
                                  *node, result, "a(getblockchaininfo(True))"),
                              UniValue);
     // don't tollerate empty arguments when using ,
     QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
                                  *node, result, "rpcNestedTest abc,,abc"),
                              std::runtime_error);
     // don't tollerate empty arguments when using ,
     QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
                                  *node, result, "rpcNestedTest(abc,,abc)"),
                              std::runtime_error);
     // don't tollerate empty arguments when using ,
     QVERIFY_EXCEPTION_THROWN(RPCConsole::RPCExecuteCommandLine(
                                  *node, result, "rpcNestedTest(abc,,)"),
                              std::runtime_error);
 #endif
 
     fs::remove_all(fs::path(path));
 }
diff --git a/src/qt/test/rpcnestedtests.h b/src/qt/test/rpcnestedtests.h
index dedaba410..0c1535afd 100644
--- a/src/qt/test/rpcnestedtests.h
+++ b/src/qt/test/rpcnestedtests.h
@@ -1,21 +1,21 @@
 // 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.
 
 #ifndef BITCOIN_QT_TEST_RPC_NESTED_TESTS_H
 #define BITCOIN_QT_TEST_RPC_NESTED_TESTS_H
 
+#include <txdb.h>
+#include <txmempool.h>
+
 #include <QObject>
 #include <QTest>
 
-#include "txdb.h"
-#include "txmempool.h"
-
 class RPCNestedTests : public QObject {
     Q_OBJECT
 
 private Q_SLOTS:
     void rpcNestedTests();
 };
 
 #endif // BITCOIN_QT_TEST_RPC_NESTED_TESTS_H
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index 308ef1cb9..8b0d21f7b 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -1,104 +1,103 @@
 // Copyright (c) 2009-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.
 
 #if defined(HAVE_CONFIG_H)
-#include "config/bitcoin-config.h"
+#include <config/bitcoin-config.h>
 #endif
 
-#include "compat/setenv.h"
-
-#include "bitcoinaddressvalidatortests.h"
-#include "chainparams.h"
-#include "compattests.h"
-#include "guiutiltests.h"
-#include "key.h"
-#include "rpcnestedtests.h"
-#include "uritests.h"
-#include "util.h"
+#include <chainparams.h>
+#include <compat/setenv.h>
+#include <key.h>
+#include <util.h>
 
+#include <qt/test/bitcoinaddressvalidatortests.h>
+#include <qt/test/compattests.h>
+#include <qt/test/guiutiltests.h>
+#include <qt/test/rpcnestedtests.h>
+#include <qt/test/uritests.h>
 #ifdef ENABLE_WALLET
-#include "paymentservertests.h"
-#include "wallettests.h"
+#include <qt/test/paymentservertests.h>
+#include <qt/test/wallettests.h>
 #endif
 
 #include <QApplication>
 #include <QObject>
 #include <QTest>
 
 #include <openssl/ssl.h>
 
 #if defined(QT_STATICPLUGIN)
 #include <QtPlugin>
 #if defined(QT_QPA_PLATFORM_MINIMAL)
 Q_IMPORT_PLUGIN(QMinimalIntegrationPlugin);
 #endif
 #if defined(QT_QPA_PLATFORM_XCB)
 Q_IMPORT_PLUGIN(QXcbIntegrationPlugin);
 #elif defined(QT_QPA_PLATFORM_WINDOWS)
 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
 #elif defined(QT_QPA_PLATFORM_COCOA)
 Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin);
 #endif
 #endif
 
 extern void noui_connect();
 
 // This is all you need to run all the tests
 int main(int argc, char *argv[]) {
     SetupEnvironment();
     SetupNetworking();
     SelectParams(CBaseChainParams::MAIN);
     noui_connect();
 
     bool fInvalid = false;
 
     // Prefer the "minimal" platform for the test instead of the normal default
     // platform ("xcb", "windows", or "cocoa") so tests can't unintentially
     // interfere with any background GUIs and don't require extra resources.
     setenv("QT_QPA_PLATFORM", "minimal", 0);
 
     // Don't remove this, it's needed to access
     // QApplication:: and QCoreApplication:: in the tests
     QApplication app(argc, argv);
     app.setApplicationName("BitcoinABC-Qt-test");
 
     // This is necessary to initialize openssl on the test framework
     // (at least on Darwin).
     SSL_library_init();
 
     URITests test1;
     if (QTest::qExec(&test1) != 0) {
         fInvalid = true;
     }
 #ifdef ENABLE_WALLET
     PaymentServerTests test2;
     if (QTest::qExec(&test2) != 0) {
         fInvalid = true;
     }
 #endif
     RPCNestedTests test3;
     if (QTest::qExec(&test3) != 0) {
         fInvalid = true;
     }
     CompatTests test4;
     if (QTest::qExec(&test4) != 0) {
         fInvalid = true;
     }
     GUIUtilTests test5;
     if (QTest::qExec(&test5) != 0) {
         fInvalid = true;
     }
     BitcoinAddressValidatorTests test6;
     if (QTest::qExec(&test6) != 0) {
         fInvalid = true;
     }
 #ifdef ENABLE_WALLET
     WalletTests test7;
     if (QTest::qExec(&test7) != 0) {
         fInvalid = true;
     }
 #endif
 
     return fInvalid;
 }
diff --git a/src/qt/test/uritests.cpp b/src/qt/test/uritests.cpp
index ad10d8ca5..bd7a83813 100644
--- a/src/qt/test/uritests.cpp
+++ b/src/qt/test/uritests.cpp
@@ -1,232 +1,232 @@
 // Copyright (c) 2009-2014 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.
 
-#include "uritests.h"
+#include <qt/test/uritests.h>
 
-#include "chainparams.h"
-#include "config.h"
-#include "guiutil.h"
-#include "walletmodel.h"
+#include <chainparams.h>
+#include <config.h>
+#include <qt/guiutil.h>
+#include <qt/walletmodel.h>
 
 #include <QUrl>
 
 void URITests::uriTestsBase58() {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     SendCoinsRecipient rv;
     QString scheme = QString::fromStdString(params->CashAddrPrefix());
     QUrl uri;
     uri.setUrl(QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?req-dontexist="));
     QVERIFY(!GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?dontexist="));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.label == QString());
     QVERIFY(rv.amount == Amount::zero());
 
     uri.setUrl(QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?label="
                        "Wikipedia Example Address"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.label == QString("Wikipedia Example Address"));
     QVERIFY(rv.amount == Amount::zero());
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?amount=0.001"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.label == QString());
     QVERIFY(rv.amount == 100000 * SATOSHI);
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?amount=1.001"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.label == QString());
     QVERIFY(rv.amount == 100100000 * SATOSHI);
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?amount=100&"
                 "label=Wikipedia Example"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.amount == int64_t(10000000000) * SATOSHI);
     QVERIFY(rv.label == QString("Wikipedia Example"));
 
     uri.setUrl(QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?message="
                        "Wikipedia Example Address"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.label == QString());
 
     QVERIFY(GUIUtil::parseBitcoinURI(scheme,
                                      "bitcoincash://"
                                      "175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?"
                                      "message=Wikipedia Example Address",
                                      &rv));
     QVERIFY(rv.address == QString("175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W"));
     QVERIFY(rv.label == QString());
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?req-message="
                 "Wikipedia Example Address"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?amount=1,"
                 "000&label=Wikipedia Example"));
     QVERIFY(!GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 
     uri.setUrl(
         QString("bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?amount=1,"
                 "000.0&label=Wikipedia Example"));
     QVERIFY(!GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 }
 
 void URITests::uriTestsCashAddr() {
     const auto params = CreateChainParams(CBaseChainParams::MAIN);
 
     SendCoinsRecipient rv;
     QUrl uri;
     QString scheme = QString::fromStdString(params->CashAddrPrefix());
     uri.setUrl(QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?"
                        "req-dontexist="));
     QVERIFY(!GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?dontexist="));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.label == QString());
     QVERIFY(rv.amount == Amount::zero());
 
     uri.setUrl(
         QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?label="
                 "Wikipedia Example Address"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.label == QString("Wikipedia Example Address"));
     QVERIFY(rv.amount == Amount::zero());
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?amount=0.001"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.label == QString());
     QVERIFY(rv.amount == 100000 * SATOSHI);
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?amount=1.001"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.label == QString());
     QVERIFY(rv.amount == 100100000 * SATOSHI);
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?amount=100&"
         "label=Wikipedia Example"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.amount == int64_t(10000000000) * SATOSHI);
     QVERIFY(rv.label == QString("Wikipedia Example"));
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?message="
         "Wikipedia Example Address"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.label == QString());
 
     QVERIFY(
         GUIUtil::parseBitcoinURI(scheme,
                                  "bitcoincash://"
                                  "qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?"
                                  "message=Wikipedia Example Address",
                                  &rv));
     QVERIFY(rv.address ==
             QString("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a"));
     QVERIFY(rv.label == QString());
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?req-message="
         "Wikipedia Example Address"));
     QVERIFY(GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?amount=1,"
         "000&label=Wikipedia Example"));
     QVERIFY(!GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 
     uri.setUrl(QString(
         "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?amount=1,"
         "000.0&label=Wikipedia Example"));
     QVERIFY(!GUIUtil::parseBitcoinURI(scheme, uri, &rv));
 }
 
 namespace {
 class UriTestConfig : public DummyConfig {
 public:
     UriTestConfig(bool useCashAddrIn)
         : DummyConfig(CBaseChainParams::MAIN), useCashAddr(useCashAddrIn) {}
     bool UseCashAddrEncoding() const override { return useCashAddr; }
 
 private:
     bool useCashAddr;
 };
 
 } // namespace
 
 void URITests::uriTestFormatURI() {
     {
         UriTestConfig cfg(true);
         SendCoinsRecipient r;
         r.address = "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a";
         r.message = "test";
         QString uri = GUIUtil::formatBitcoinURI(cfg, r);
         QVERIFY(uri == "bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a?"
                        "message=test");
     }
 
     {
         UriTestConfig cfg(false);
         SendCoinsRecipient r;
         r.address = "175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W";
         r.message = "test";
         QString uri = GUIUtil::formatBitcoinURI(cfg, r);
         QVERIFY(uri ==
                 "bitcoincash:175tWpb8K1S7NmH4Zx6rewF9WQrcZv245W?message=test");
     }
 }
 
 void URITests::uriTestScheme() {
     {
         // cashaddr - scheme depends on selected chain params
         UriTestConfig config(true);
         config.SetChainParams(CBaseChainParams::MAIN);
         QVERIFY("bitcoincash" == GUIUtil::bitcoinURIScheme(config));
         config.SetChainParams(CBaseChainParams::TESTNET);
         QVERIFY("bchtest" == GUIUtil::bitcoinURIScheme(config));
         config.SetChainParams(CBaseChainParams::REGTEST);
         QVERIFY("bchreg" == GUIUtil::bitcoinURIScheme(config));
     }
     {
         // legacy - scheme is "bitcoincash" regardless of chain params
         UriTestConfig config(false);
         config.SetChainParams(CBaseChainParams::MAIN);
         QVERIFY("bitcoincash" == GUIUtil::bitcoinURIScheme(config));
         config.SetChainParams(CBaseChainParams::TESTNET);
         QVERIFY("bitcoincash" == GUIUtil::bitcoinURIScheme(config));
         config.SetChainParams(CBaseChainParams::REGTEST);
         QVERIFY("bitcoincash" == GUIUtil::bitcoinURIScheme(config));
     }
 }
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index a087db166..7a3cbae37 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -1,248 +1,249 @@
-#include "wallettests.h"
-
-#include "chainparams.h"
-#include "config.h"
-#include "dstencode.h"
-#include "interfaces/node.h"
-#include "qt/bitcoinamountfield.h"
-#include "qt/optionsmodel.h"
-#include "qt/overviewpage.h"
-#include "qt/platformstyle.h"
-#include "qt/qvalidatedlineedit.h"
-#include "qt/receivecoinsdialog.h"
-#include "qt/receiverequestdialog.h"
-#include "qt/recentrequeststablemodel.h"
-#include "qt/sendcoinsdialog.h"
-#include "qt/sendcoinsentry.h"
-#include "qt/transactiontablemodel.h"
-#include "qt/walletmodel.h"
-#include "test/test_bitcoin.h"
-#include "validation.h"
-#include "wallet/wallet.h"
+#include <qt/test/wallettests.h>
+
+#include <chainparams.h>
+#include <config.h>
+#include <dstencode.h>
+#include <interfaces/node.h>
+#include <qt/bitcoinamountfield.h>
+#include <qt/optionsmodel.h>
+#include <qt/overviewpage.h>
+#include <qt/platformstyle.h>
+#include <qt/qvalidatedlineedit.h>
+#include <qt/receivecoinsdialog.h>
+#include <qt/receiverequestdialog.h>
+#include <qt/recentrequeststablemodel.h>
+#include <qt/sendcoinsdialog.h>
+#include <qt/sendcoinsentry.h>
+#include <qt/transactiontablemodel.h>
+#include <qt/walletmodel.h>
+#include <validation.h>
+#include <wallet/wallet.h>
+
+#include <test/test_bitcoin.h>
 
 #include <QAbstractButton>
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QListView>
 #include <QPushButton>
 #include <QTextEdit>
 #include <QTimer>
 #include <QVBoxLayout>
 
 namespace {
 //! Press "Yes" or "Cancel" buttons in modal send confirmation dialog.
 void ConfirmSend(QString *text = nullptr, bool cancel = false) {
     QTimer::singleShot(0, Qt::PreciseTimer, [text, cancel]() {
         for (QWidget *widget : QApplication::topLevelWidgets()) {
             if (widget->inherits("SendConfirmationDialog")) {
                 SendConfirmationDialog *dialog =
                     qobject_cast<SendConfirmationDialog *>(widget);
                 if (text) {
                     *text = dialog->text();
                 }
                 QAbstractButton *button = dialog->button(
                     cancel ? QMessageBox::Cancel : QMessageBox::Yes);
                 button->setEnabled(true);
                 button->click();
             }
         }
     });
 }
 
 //! Send coins to address and return txid.
 uint256 SendCoins(CWallet &wallet, SendCoinsDialog &sendCoinsDialog,
                   const CTxDestination &address, Amount amount) {
     QVBoxLayout *entries = sendCoinsDialog.findChild<QVBoxLayout *>("entries");
     SendCoinsEntry *entry =
         qobject_cast<SendCoinsEntry *>(entries->itemAt(0)->widget());
     entry->findChild<QValidatedLineEdit *>("payTo")->setText(
         QString::fromStdString(EncodeDestination(address)));
     entry->findChild<BitcoinAmountField *>("payAmount")->setValue(amount);
     uint256 txid;
     boost::signals2::scoped_connection c =
         wallet.NotifyTransactionChanged.connect(
             [&txid](CWallet *, const uint256 &hash, ChangeType status) {
                 if (status == CT_NEW) {
                     txid = hash;
                 }
             });
     ConfirmSend();
     QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");
     return txid;
 }
 
 //! Find index of txid in transaction list.
 QModelIndex FindTx(const QAbstractItemModel &model, const uint256 &txid) {
     QString hash = QString::fromStdString(txid.ToString());
     int rows = model.rowCount({});
     for (int row = 0; row < rows; ++row) {
         QModelIndex index = model.index(row, 0, {});
         if (model.data(index, TransactionTableModel::TxHashRole) == hash) {
             return index;
         }
     }
     return {};
 }
 
 //! Simple qt wallet tests.
 //
 // Test widgets can be debugged interactively calling show() on them and
 // manually running the event loop, e.g.:
 //
 //     sendCoinsDialog.show();
 //     QEventLoop().exec();
 //
 // This also requires overriding the default minimal Qt platform:
 //
 //     src/qt/test/test_bitcoin-qt -platform xcb      # Linux
 //     src/qt/test/test_bitcoin-qt -platform windows  # Windows
 //     src/qt/test/test_bitcoin-qt -platform cocoa    # macOS
 void TestGUI() {
 #ifdef Q_OS_MAC
     if (QApplication::platformName() == "minimal") {
         // Disable for mac on "minimal" platform to avoid crashes inside the Qt
         // framework when it tries to look up unimplemented cocoa functions,
         // and fails to handle returned nulls
         // (https://bugreports.qt.io/browse/QTBUG-49686).
         QWARN("Skipping WalletTests on mac build with 'minimal' platform set "
               "due to Qt bugs. To run AppTests, invoke "
               "with 'test_bitcoin-qt -platform cocoa' on mac, or else use a "
               "linux or windows build.");
         return;
     }
 #endif
 
     // Set up wallet and chain with 105 blocks (5 mature blocks for spending).
     TestChain100Setup test;
     for (int i = 0; i < 5; ++i) {
         test.CreateAndProcessBlock(
             {}, GetScriptForRawPubKey(test.coinbaseKey.GetPubKey()));
     }
     bitdb.MakeMock();
     std::unique_ptr<CWalletDBWrapper> dbw(
         new CWalletDBWrapper(&bitdb, "wallet_test.dat"));
     CWallet wallet(Params(), std::move(dbw));
     bool firstRun;
     wallet.LoadWallet(firstRun);
     {
         LOCK(wallet.cs_wallet);
         wallet.SetAddressBook(test.coinbaseKey.GetPubKey().GetID(), "",
                               "receive");
         wallet.AddKeyPubKey(test.coinbaseKey, test.coinbaseKey.GetPubKey());
     }
     {
         LOCK(cs_main);
         wallet.ScanForWalletTransactions(chainActive.Genesis(), nullptr, true);
     }
     wallet.SetBroadcastTransactions(true);
 
     // Create widgets for sending coins and listing transactions.
     std::unique_ptr<const PlatformStyle> platformStyle(
         PlatformStyle::instantiate("other"));
     SendCoinsDialog sendCoinsDialog(platformStyle.get());
     auto node = interfaces::MakeNode();
     OptionsModel optionsModel(*node);
     vpwallets.insert(vpwallets.begin(), &wallet);
     WalletModel walletModel(std::move(node->getWallets()[0]), *node,
                             platformStyle.get(), &optionsModel);
     vpwallets.erase(vpwallets.begin());
     sendCoinsDialog.setModel(&walletModel);
 
     // Send two transactions, and verify they are added to transaction list.
     TransactionTableModel *transactionTableModel =
         walletModel.getTransactionTableModel();
     QCOMPARE(transactionTableModel->rowCount({}), 105);
     uint256 txid1 =
         SendCoins(wallet, sendCoinsDialog, CTxDestination(CKeyID()), 5 * COIN);
     uint256 txid2 =
         SendCoins(wallet, sendCoinsDialog, CTxDestination(CKeyID()), 10 * COIN);
     QCOMPARE(transactionTableModel->rowCount({}), 107);
     QVERIFY(FindTx(*transactionTableModel, txid1).isValid());
     QVERIFY(FindTx(*transactionTableModel, txid2).isValid());
 
     // Check current balance on OverviewPage
     OverviewPage overviewPage(platformStyle.get());
     overviewPage.setWalletModel(&walletModel);
     QLabel *balanceLabel = overviewPage.findChild<QLabel *>("labelBalance");
     QString balanceText = balanceLabel->text();
     int unit = walletModel.getOptionsModel()->getDisplayUnit();
     Amount balance = walletModel.wallet().getBalance();
     QString balanceComparison = BitcoinUnits::formatWithUnit(
         unit, balance, false, BitcoinUnits::separatorAlways);
     QCOMPARE(balanceText, balanceComparison);
 
     // Check Request Payment button
     const Config &config = GetConfig();
     ReceiveCoinsDialog receiveCoinsDialog(platformStyle.get(), &config);
     receiveCoinsDialog.setModel(&walletModel);
     RecentRequestsTableModel *requestTableModel =
         walletModel.getRecentRequestsTableModel();
 
     // Label input
     QLineEdit *labelInput =
         receiveCoinsDialog.findChild<QLineEdit *>("reqLabel");
     labelInput->setText("TEST_LABEL_1");
 
     // Amount input
     BitcoinAmountField *amountInput =
         receiveCoinsDialog.findChild<BitcoinAmountField *>("reqAmount");
     amountInput->setValue(1 * SATOSHI);
 
     // Message input
     QLineEdit *messageInput =
         receiveCoinsDialog.findChild<QLineEdit *>("reqMessage");
     messageInput->setText("TEST_MESSAGE_1");
     int initialRowCount = requestTableModel->rowCount({});
     QPushButton *requestPaymentButton =
         receiveCoinsDialog.findChild<QPushButton *>("receiveButton");
     requestPaymentButton->click();
     for (QWidget *widget : QApplication::topLevelWidgets()) {
         if (widget->inherits("ReceiveRequestDialog")) {
             ReceiveRequestDialog *receiveRequestDialog =
                 qobject_cast<ReceiveRequestDialog *>(widget);
             QTextEdit *rlist =
                 receiveRequestDialog->QObject::findChild<QTextEdit *>("outUri");
             QString paymentText = rlist->toPlainText();
             QStringList paymentTextList = paymentText.split('\n');
             QCOMPARE(paymentTextList.at(0), QString("Payment information"));
             QVERIFY(paymentTextList.at(1).indexOf(
                         QString("URI: bitcoincash:")) != -1);
             QVERIFY(paymentTextList.at(2).indexOf(QString("Address:")) != -1);
             QCOMPARE(paymentTextList.at(3),
                      QString("Amount: 0.00000001 ") +
                          QString::fromStdString(CURRENCY_UNIT));
             QCOMPARE(paymentTextList.at(4), QString("Label: TEST_LABEL_1"));
             QCOMPARE(paymentTextList.at(5), QString("Message: TEST_MESSAGE_1"));
         }
     }
 
     // Clear button
     QPushButton *clearButton =
         receiveCoinsDialog.findChild<QPushButton *>("clearButton");
     clearButton->click();
     QCOMPARE(labelInput->text(), QString(""));
     QCOMPARE(amountInput->value(), Amount::zero());
     QCOMPARE(messageInput->text(), QString(""));
 
     // Check addition to history
     int currentRowCount = requestTableModel->rowCount({});
     QCOMPARE(currentRowCount, initialRowCount + 1);
 
     // Check Remove button
     QTableView *table =
         receiveCoinsDialog.findChild<QTableView *>("recentRequestsView");
     table->selectRow(currentRowCount - 1);
     QPushButton *removeRequestButton =
         receiveCoinsDialog.findChild<QPushButton *>("removeRequestButton");
     removeRequestButton->click();
     QCOMPARE(requestTableModel->rowCount({}), currentRowCount - 1);
 
     bitdb.Flush(true);
     bitdb.Reset();
 }
 
 }
 
 void WalletTests::walletTests() {
     TestGUI();
 }