diff --git a/src/qt/test/addressbooktests.cpp b/src/qt/test/addressbooktests.cpp
index 7b04a1490..ae92bd5fe 100644
--- a/src/qt/test/addressbooktests.cpp
+++ b/src/qt/test/addressbooktests.cpp
@@ -1,165 +1,165 @@
 #include <qt/test/addressbooktests.h>
 #include <test/util/setup_common.h>
 
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <qt/editaddressdialog.h>
 #include <qt/optionsmodel.h>
 #include <qt/platformstyle.h>
 #include <qt/qvalidatedlineedit.h>
 #include <qt/test/util.h>
 #include <qt/walletmodel.h>
 
 #include <cashaddrenc.h>
 #include <key.h>
 #include <key_io.h>
 #include <wallet/wallet.h>
 
 #include <QApplication>
 #include <QMessageBox>
 #include <QTimer>
 
 #include <memory>
 
 namespace {
 
 /**
  * Fill the edit address dialog box with data, submit it, and ensure that
  * the resulting message meets expectations.
  */
 void EditAddressAndSubmit(EditAddressDialog *dialog, const QString &label,
                           const QString &address, QString expected_msg) {
     QString warning_text;
 
     dialog->findChild<QLineEdit *>("labelEdit")->setText(label);
     dialog->findChild<QValidatedLineEdit *>("addressEdit")->setText(address);
 
     ConfirmMessage(&warning_text, 5);
     dialog->accept();
     QCOMPARE(warning_text, expected_msg);
 }
 
 /**
  * Test adding various send addresses to the address book.
  *
  * There are three cases tested:
  *
  *   - new_address: a new address which should add as a send address
  * successfully.
  *   - existing_s_address: an existing sending address which won't add
  * successfully.
  *   - existing_r_address: an existing receiving address which won't add
  * successfully.
  *
  * In each case, verify the resulting state of the address book and optionally
  * the warning message presented to the user.
  */
 void TestAddAddressesToSendBook(interfaces::Node &node) {
     TestChain100Setup test;
 
     std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
         Params(), node.context()->chain.get(), WalletLocation(),
         WalletDatabase::CreateMock());
 
     bool firstRun;
     wallet->LoadWallet(firstRun);
 
     auto build_address = [&wallet]() {
         CKey key;
         key.MakeNewKey(true);
         CTxDestination dest(GetDestinationForKey(
             key.GetPubKey(), wallet->m_default_address_type));
 
         return std::make_pair(
             dest, QString::fromStdString(EncodeCashAddr(dest, Params())));
     };
 
     CTxDestination r_key_dest, s_key_dest;
 
     // Add a preexisting "receive" entry in the address book.
     QString preexisting_r_address;
     QString r_label("already here (r)");
 
     // Add a preexisting "send" entry in the address book.
     QString preexisting_s_address;
     QString s_label("already here (s)");
 
     // Define a new address (which should add to the address book successfully).
     QString new_address;
 
     std::tie(r_key_dest, preexisting_r_address) = build_address();
     std::tie(s_key_dest, preexisting_s_address) = build_address();
     std::tie(std::ignore, new_address) = build_address();
 
     {
         LOCK(wallet->cs_wallet);
         wallet->SetAddressBook(r_key_dest, r_label.toStdString(), "receive");
         wallet->SetAddressBook(s_key_dest, s_label.toStdString(), "send");
     }
 
     auto check_addbook_size = [&wallet](int expected_size) {
         LOCK(wallet->cs_wallet);
         QCOMPARE(static_cast<int>(wallet->mapAddressBook.size()),
                  expected_size);
     };
 
     // We should start with the two addresses we added earlier and nothing else.
     check_addbook_size(2);
 
     // Initialize relevant QT models.
     std::unique_ptr<const PlatformStyle> platformStyle(
         PlatformStyle::instantiate("other"));
     OptionsModel optionsModel(node);
     AddWallet(wallet);
     WalletModel walletModel(interfaces::MakeWallet(wallet), node,
                             platformStyle.get(), &optionsModel);
     RemoveWallet(wallet);
     EditAddressDialog editAddressDialog(EditAddressDialog::NewSendingAddress);
     editAddressDialog.setModel(walletModel.getAddressTableModel());
 
     EditAddressAndSubmit(
         &editAddressDialog, QString("uhoh"), preexisting_r_address,
         QString(
             "Address \"%1\" already exists as a receiving address with label "
             "\"%2\" and so cannot be added as a sending address.")
             .arg(preexisting_r_address)
             .arg(r_label));
 
     check_addbook_size(2);
 
     EditAddressAndSubmit(
         &editAddressDialog, QString("uhoh, different"), preexisting_s_address,
         QString(
             "The entered address \"%1\" is already in the address book with "
             "label \"%2\".")
             .arg(preexisting_s_address)
             .arg(s_label));
 
     check_addbook_size(2);
 
     // Submit a new address which should add successfully - we expect the
     // warning message to be blank.
     EditAddressAndSubmit(&editAddressDialog, QString("new"), new_address,
                          QString(""));
 
     check_addbook_size(3);
 }
 
 } // namespace
 
 void AddressBookTests::addressBookTests() {
 #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 AddressBookTests 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.");
+        QWARN("Skipping AddressBookTests on mac build with 'minimal' platform "
+              "set due to Qt bugs. To run AppTests, invoke with "
+              "'QT_QPA_PLATFORM=cocoa test_bitcoin-qt' on mac, or else use a "
+              "linux or windows build.");
         return;
     }
 #endif
     TestAddAddressesToSendBook(m_node);
 }
diff --git a/src/qt/test/apptests.cpp b/src/qt/test/apptests.cpp
index 5c784ab18..3a2afcd6a 100644
--- a/src/qt/test/apptests.cpp
+++ b/src/qt/test/apptests.cpp
@@ -1,132 +1,131 @@
 // 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
 
 #include <test/util/setup_common.h>
 
 #include <univalue.h>
 
 #include <QAction>
 #include <QEventLoop>
 #include <QLineEdit>
 #include <QScopedPointer>
 #include <QTest>
 #include <QTextEdit>
 #include <QtGlobal>
 #include <QtTest/QtTestGui>
 #include <QtTest/QtTestWidgets>
 
 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.");
+              "to Qt bugs. To run AppTests, invoke with 'QT_QPA_PLATFORM=cocoa "
+              "test_bitcoin-qt' 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(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/test_main.cpp b/src/qt/test/test_main.cpp
index bb7f9d2ad..d39442436 100644
--- a/src/qt/test/test_main.cpp
+++ b/src/qt/test/test_main.cpp
@@ -1,114 +1,114 @@
 // 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 <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/util/setup_common.h>
 
 #include <QApplication>
 #include <QObject>
 #include <QTest>
 
 #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
 
 // This is all you need to run all the tests
 int main(int argc, char *argv[]) {
     // 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}; }
 
     std::unique_ptr<interfaces::Node> 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);
+    setenv("QT_QPA_PLATFORM", "minimal", /* overwrite */ 0);
 
     // Don't remove this, it's needed to access
     // QApplication:: and QCoreApplication:: in the tests
     BitcoinApplication app(*node);
     app.setApplicationName("BitcoinABC-Qt-test");
 
     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(*node);
     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(*node);
     if (QTest::qExec(&test7) != 0) {
         fInvalid = true;
     }
     AddressBookTests test8(*node);
     if (QTest::qExec(&test8) != 0) {
         fInvalid = true;
     }
 #endif
 
     return fInvalid;
 }
diff --git a/src/qt/test/wallettests.cpp b/src/qt/test/wallettests.cpp
index 5080af045..6df15f382 100644
--- a/src/qt/test/wallettests.cpp
+++ b/src/qt/test/wallettests.cpp
@@ -1,266 +1,267 @@
 #include <qt/test/util.h>
 #include <qt/test/wallettests.h>
 
 #include <cashaddrenc.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <interfaces/chain.h>
 #include <interfaces/node.h>
 #include <key_io.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/util/setup_common.h>
 
 #include <QAbstractButton>
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QListView>
 #include <QPushButton>
 #include <QTextEdit>
 #include <QTimer>
 #include <QVBoxLayout>
 
 #include <memory>
 
 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.
 TxId 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(EncodeCashAddr(address, Params())));
     entry->findChild<BitcoinAmountField *>("payAmount")->setValue(amount);
     TxId txid;
     boost::signals2::scoped_connection c =
         wallet.NotifyTransactionChanged.connect(
             [&txid](CWallet *, const TxId &hash, ChangeType status) {
                 if (status == CT_NEW) {
                     txid = hash;
                 }
             });
     ConfirmSend();
     bool invoked =
         QMetaObject::invokeMethod(&sendCoinsDialog, "on_sendButton_clicked");
     assert(invoked);
     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
+//     QT_QPA_PLATFORM=xcb     src/qt/test/test_bitcoin-qt  # Linux
+//     QT_QPA_PLATFORM=windows src/qt/test/test_bitcoin-qt  # Windows
+//     QT_QPA_PLATFORM=cocoa   src/qt/test/test_bitcoin-qt  # macOS
 void TestGUI(interfaces::Node &node) {
     // 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()));
     }
     node.context()->connman = std::move(test.m_node.connman);
     std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(
         Params(), node.context()->chain.get(), WalletLocation(),
         WalletDatabase::CreateMock());
 
     bool firstRun;
     wallet->LoadWallet(firstRun);
     {
         auto spk_man = wallet->GetLegacyScriptPubKeyMan();
         auto locked_chain = wallet->chain().lock();
         LOCK(wallet->cs_wallet);
         AssertLockHeld(spk_man->cs_wallet);
         wallet->SetAddressBook(
             GetDestinationForKey(test.coinbaseKey.GetPubKey(),
                                  wallet->m_default_address_type),
             "", "receive");
         spk_man->AddKeyPubKey(test.coinbaseKey, test.coinbaseKey.GetPubKey());
         wallet->SetLastBlockProcessed(105,
                                       ::ChainActive().Tip()->GetBlockHash());
     }
     {
         auto locked_chain = wallet->chain().lock();
         LockAssertion lock(::cs_main);
 
         WalletRescanReserver reserver(*wallet);
         reserver.reserve();
         CWallet::ScanResult result = wallet->ScanForWalletTransactions(
             locked_chain->getBlockHash(0), BlockHash(), reserver,
             true /* fUpdate */);
         QCOMPARE(result.status, CWallet::ScanResult::SUCCESS);
         QCOMPARE(result.last_scanned_block,
                  ::ChainActive().Tip()->GetBlockHash());
         QVERIFY(result.last_failed_block.IsNull());
     }
     wallet->SetBroadcastTransactions(true);
 
     // Create widgets for sending coins and listing transactions.
     std::unique_ptr<const PlatformStyle> platformStyle(
         PlatformStyle::instantiate("other"));
     OptionsModel optionsModel(node);
     AddWallet(wallet);
     WalletModel walletModel(interfaces::MakeWallet(wallet), node,
                             platformStyle.get(), &optionsModel);
     RemoveWallet(wallet);
 
     // Send two transactions, and verify they are added to transaction list.
     SendCoinsDialog sendCoinsDialog(platformStyle.get(), &walletModel);
     TransactionTableModel *transactionTableModel =
         walletModel.getTransactionTableModel();
     QCOMPARE(transactionTableModel->rowCount({}), 105);
     TxId txid1 = SendCoins(*wallet.get(), sendCoinsDialog,
                            CTxDestination(PKHash()), 5 * COIN);
     TxId txid2 = SendCoins(*wallet.get(), sendCoinsDialog,
                            CTxDestination(PKHash()), 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
     ReceiveCoinsDialog receiveCoinsDialog(platformStyle.get());
     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: bchreg:")) !=
                     -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);
 }
 
 } // namespace
 
 void WalletTests::walletTests() {
 #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.");
+        QWARN(
+            "Skipping WalletTests on mac build with 'minimal' platform set due "
+            "to Qt bugs. To run AppTests, invoke with 'QT_QPA_PLATFORM=cocoa "
+            "test_bitcoin-qt' on mac, or else use a linux or windows build.");
         return;
     }
 #endif
     TestGUI(m_node);
 }