diff --git a/src/qt/test/apptests.cpp b/src/qt/test/apptests.cpp
index b66535873e..dc41bc09e6 100644
--- a/src/qt/test/apptests.cpp
+++ b/src/qt/test/apptests.cpp
@@ -1,146 +1,150 @@
 // Copyright (c) 2018 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 <qt/test/apptests.h>
 
 #include <chainparams.h>
 #include <config.h>
 #include <httprpc.h>
 #include <key.h>
 #include <qt/bitcoin.h>
 #include <qt/bitcoingui.h>
 #include <qt/networkstyle.h>
 #include <qt/rpcconsole.h>
 #include <rpc/server.h>
 #include <shutdown.h>
 #include <validation.h>
 
 #if defined(HAVE_CONFIG_H)
 #include <config/bitcoin-config.h>
 #endif
 #ifdef ENABLE_WALLET
 #include <wallet/db.h>
 #endif
 
+#include <test/setup_common.h>
+
 #include <QAction>
 #include <QEventLoop>
 #include <QLineEdit>
 #include <QScopedPointer>
 #include <QTest>
 #include <QTextEdit>
 #include <QtGlobal>
 /*
  * FIXME: <QtTest/QtTestGui> requires QT_WIDGETS_LIB to be defined prior
  * inclusion to export the QtTest::keyClicks symbol.
  * On some older Qt versions the definition end up being set by the inclusion of
  * <QtTest/QtTestWidgets>.
  * This only occurs when building with autotools, as QMake and CMake define
  * QT_WIDGETS_LIB on the command line. As a workaround for autotools,
  * <QtTest/QtTestWidgets> should be included before <QtTest/QtTestGui>.
  * Also prevent the linter from sorting the includes.
  */
 // clang-format off
 #include <QtTest/QtTestWidgets>
 #include <QtTest/QtTestGui>
 // clang-format on
 
 #include <univalue.h>
 
 #include <new>
 #include <string>
 
 namespace {
 //! Call getblockchaininfo RPC and check first field of JSON output.
 void TestRpcCommand(RPCConsole *console) {
     QEventLoop loop;
     QTextEdit *messagesWidget =
         console->findChild<QTextEdit *>("messagesWidget");
     QObject::connect(messagesWidget, &QTextEdit::textChanged, &loop,
                      &QEventLoop::quit);
     QLineEdit *lineEdit = console->findChild<QLineEdit *>("lineEdit");
     QTest::keyClicks(lineEdit, "getblockchaininfo");
     QTest::keyClick(lineEdit, Qt::Key_Return);
     loop.exec();
     QString output = messagesWidget->toPlainText();
     UniValue value;
     value.read(
         output
             .right(output.size() -
                    output.lastIndexOf(QChar::ObjectReplacementCharacter) - 1)
             .toStdString());
     QCOMPARE(value["chain"].get_str(), std::string("regtest"));
 }
 } // namespace
 
 //! Entry point for BitcoinApplication tests.
 void AppTests::appTests() {
 #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 AppTests 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
 
     Config &config = const_cast<Config &>(GetConfig());
 
+    // Create a temp data directory to backup the gui settings to
+    BasicTestingSetup test{CBaseChainParams::REGTEST};
     // Already started by the common test setup, so stop it to avoid
     // interference
     ECC_Stop();
     LogInstance().DisconnectTestLogger();
 
     m_app.parameterSetup();
     m_app.createOptionsModel(true /* reset settings */);
     QScopedPointer<const NetworkStyle> style(NetworkStyle::instantiate(
         QString::fromStdString(Params().NetworkIDString())));
     m_app.setupPlatformStyle();
     m_app.createWindow(&config, style.data());
     connect(&m_app, &BitcoinApplication::windowShown, this,
             &AppTests::guiTests);
     expectCallback("guiTests");
     m_app.baseInitialize(config);
 
     RPCServer rpcServer;
     HTTPRPCRequestProcessor httpRPCRequestProcessor(config, rpcServer);
     m_app.requestInitialize(config, rpcServer, httpRPCRequestProcessor);
     m_app.exec();
     m_app.requestShutdown(config);
     m_app.exec();
 
     // Reset global state to avoid interfering with later tests.
     AbortShutdown();
     UnloadBlockIndex();
 }
 
 //! Entry point for BitcoinGUI tests.
 void AppTests::guiTests(BitcoinGUI *window) {
     HandleCallback callback{"guiTests", *this};
     connect(window, &BitcoinGUI::consoleShown, this, &AppTests::consoleTests);
     expectCallback("consoleTests");
     QAction *action = window->findChild<QAction *>("openRPCConsoleAction");
     action->activate(QAction::Trigger);
 }
 
 //! Entry point for RPCConsole tests.
 void AppTests::consoleTests(RPCConsole *console) {
     HandleCallback callback{"consoleTests", *this};
     TestRpcCommand(console);
 }
 
 //! Destructor to shut down after the last expected callback completes.
 AppTests::HandleCallback::~HandleCallback() {
     auto &callbacks = m_app_tests.m_callbacks;
     auto it = callbacks.find(m_callback);
     assert(it != callbacks.end());
     callbacks.erase(it);
     if (callbacks.empty()) {
         m_app_tests.m_app.quit();
     }
 }
diff --git a/src/qt/test/paymentservertests.cpp b/src/qt/test/paymentservertests.cpp
index f86b10a852..ed4cac8499 100644
--- a/src/qt/test/paymentservertests.cpp
+++ b/src/qt/test/paymentservertests.cpp
@@ -1,221 +1,222 @@
 // 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 <qt/test/paymentservertests.h>
 
 #include <amount.h>
 #include <interfaces/node.h>
 #include <qt/optionsmodel.h>
 #include <qt/test/paymentrequestdata.h>
 #include <random.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <util/strencodings.h>
-#include <util/system.h>
+
+#include <test/setup_common.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.data();
     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, &PaymentServer::receivedPaymentRequest,
                      &sigCatcher, &RecipientCatcher::getRecipient);
 
     // Write data to a temp file:
     QTemporaryFile f;
     f.open();
     f.write((const char *)data.data(), 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, &PaymentServer::receivedPaymentRequest,
                         &sigCatcher, &RecipientCatcher::getRecipient);
 
     // Return results from sigCatcher
     return sigCatcher.recipient;
 }
 
 void PaymentServerTests::paymentServerTests() {
-    SelectParams(CBaseChainParams::MAIN);
+    BasicTestingSetup testing_setup(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.data(), data.size());
     r.paymentRequest.parse(byteArray);
     // Ensure the request is initialized, because network "main" is default,
     // even for uninitialized 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.data(), 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.data(), 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.data(), 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:
     auto randdata =
         FastRandomContext().randbytes(BIP70_MAX_PAYMENTREQUEST_SIZE + 1);
 
     // Write data to a temp file:
     QTemporaryFile tempFile;
     tempFile.open();
     tempFile.write((const char *)randdata.data(), randdata.size());
     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.data(), 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/rpcnestedtests.cpp b/src/qt/test/rpcnestedtests.cpp
index a7da6fa35e..e85eab5f40 100644
--- a/src/qt/test/rpcnestedtests.cpp
+++ b/src/qt/test/rpcnestedtests.cpp
@@ -1,201 +1,197 @@
 // 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 <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 <util/system.h>
 #include <validation.h>
 
 #include <test/setup_common.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]);
     // mempool.setSanityCheck(1.0);
 
-    // Already started by the common test setup, so stop it to avoid
-    // interference
-    ECC_Stop();
-    LogInstance().DisconnectTestLogger();
     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 containing 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\"]");
 
     // 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);
 }
diff --git a/src/qt/test/test_main.cpp b/src/qt/test/test_main.cpp
index 712678c591..464cea4b9c 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -1,121 +1,125 @@
 // 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>
 #endif
 
 #include <chainparams.h>
 #include <compat/setenv.h>
 #include <interfaces/node.h>
 #include <key.h>
 
 #include <qt/bitcoin.h>
 #include <qt/test/apptests.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 <qt/test/addressbooktests.h>
 #ifdef ENABLE_BIP70
 #include <qt/test/paymentservertests.h>
 #endif // ENABLE_BIP70
 #include <qt/test/wallettests.h>
 #endif // ENABLE_WALLET
 
 #include <test/setup_common.h>
 
 #include <QApplication>
 #include <QObject>
 #include <QTest>
 
 #ifdef ENABLE_BIP70
 #include <openssl/ssl.h>
 #endif
 
 #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[]) {
-    BasicTestingSetup test{CBaseChainParams::REGTEST};
+    // Initialize persistent globals with the testing setup state for sanity.
+    // E.g. -datadir in gArgs is set to a temp directory dummy value (instead
+    // of defaulting to the default datadir), or globalChainParams is set to
+    // regtest params.
+    //
+    // All tests must use their own testing setup (if needed).
+    { BasicTestingSetup dummy{CBaseChainParams::REGTEST}; }
 
     auto node = interfaces::MakeNode();
 
     bool fInvalid = false;
 
     // Prefer the "minimal" platform for the test instead of the normal default
     // platform ("xcb", "windows", or "cocoa") so tests can't unintentionally
     // 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
     BitcoinApplication app(*node, argc, argv);
     app.setApplicationName("BitcoinABC-Qt-test");
 
 #ifdef ENABLE_BIP70
     // This is necessary to initialize openssl on the test framework
     // (at least on Darwin).
     SSL_library_init();
 #endif
 
     AppTests app_tests(app);
     if (QTest::qExec(&app_tests) != 0) {
         fInvalid = true;
     }
     URITests test1;
     if (QTest::qExec(&test1) != 0) {
         fInvalid = true;
     }
 #if defined(ENABLE_WALLET) && defined(ENABLE_BIP70)
     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;
     }
     AddressBookTests test8;
     if (QTest::qExec(&test8) != 0) {
         fInvalid = true;
     }
 #endif
 
     return fInvalid;
 }