Tests: Unify debugger tests' connection mechanisms

All the tests do pretty much the same thing in their init() or
connect() methods: Create a process, create a debug connection, create
some clients and make sure they're all running. We can deduplicate the
code by moving all this into a common base class.

Furthermore, the QSKIP in the qqmlenginedebuginspectorintegration test
was obviously done because the BLACKLIST mechanism doesn't cover
failures from internally called methods. As we don't have that problem
anymore now, we can use BLACKLIST instead.

Change-Id: I6d45d3b4e9645558ecc783a81fd740b00235cdc1
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

11 files changed, 454 insertions, 620 deletions

diff --git a/tests/auto/qml/debugger/qqmldebugjs/qqmldebugjs/tst_qqmldebugjs.cpp b/tests/auto/qml/debugger/qqmldebugjs/qqmldebugjs/tst_qqmldebugjs.cpp
index b228cd0f20..59483d75da 100644
--- a/tests/auto/qml/debugger/qqmldebugjs/qqmldebugjs/tst_qqmldebugjs.cpp
+++ b/tests/auto/qml/debugger/qqmldebugjs/qqmldebugjs/tst_qqmldebugjs.cpp
@@ -136,7 +136,7 @@ const char *BREAKPOINTRELOCATION_QMLFILE = "breakpointRelocation.qml";
 do {\
     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__)) {\
         if (QTest::currentTestFailed()) \
-          qDebug().nospace() << "\nDEBUGGEE OUTPUT:\n" << process->output();\
+          qDebug().nospace() << "\nDEBUGGEE OUTPUT:\n" << m_process->output();\
         return;\
     }\
 } while (0)
@@ -144,26 +144,12 @@ do {\
 
 class QJSDebugClient;
 
-class tst_QQmlDebugJS : public QQmlDataTest
+class tst_QQmlDebugJS : public QQmlDebugTest
 {
     Q_OBJECT
 
-    enum InitResult {
-        InitSuccess,
-        ProcessFailed,
-        ConnectionFailed,
-        ClientFailed,
-        RestrictFailed
-    };
-
-    InitResult init(bool qmlscene, const QString &qmlFile = QString(TEST_QMLFILE),
-                    bool blockMode = true, bool restrictServices = false);
-
 private slots:
-    void initTestCase();
-    void cleanupTestCase();
-
-    void cleanup();
+    void initTestCase() override;
 
     void connect_data();
     void connect();
@@ -231,11 +217,12 @@ private slots:
     void getScripts();
 
 private:
-    void targetData();
+    ConnectResult init(bool qmlscene, const QString &qmlFile = QString(TEST_QMLFILE),
+                    bool blockMode = true, bool restrictServices = false);
+    QList<QQmlDebugClient *> createClients() override;
+    QPointer<QJSDebugClient> m_client;
 
-    QQmlDebugProcess *process;
-    QJSDebugClient *client;
-    QQmlDebugConnection *connection;
+    void targetData();
     QTime t;
 };
 
@@ -288,7 +275,6 @@ protected:
     void messageReceived(const QByteArray &data);
 
 signals:
-    void enabled();
     void connected();
     void interruptRequested();
     void result();
@@ -675,10 +661,8 @@ void QJSDebugClient::disconnect()
 
 void QJSDebugClient::stateChanged(State state)
 {
-    if (state == Enabled) {
+    if (state == Enabled)
         flushSendBuffer();
-        emit enabled();
-    }
 }
 
 void QJSDebugClient::messageReceived(const QByteArray &data)
@@ -771,107 +755,19 @@ QByteArray QJSDebugClient::packMessage(const QByteArray &type, const QByteArray
 
 void tst_QQmlDebugJS::initTestCase()
 {
-    QQmlDataTest::initTestCase();
+    QQmlDebugTest::initTestCase();
     t.start();
-    process = 0;
-    client = 0;
-    connection = 0;
-}
-
-void tst_QQmlDebugJS::cleanupTestCase()
-{
-    if (process) {
-        process->stop();
-        delete process;
-    }
-
-    if (client)
-        delete client;
-
-    if (connection)
-        delete connection;
-}
-
-template<typename F>
-struct Finalizer {
-    F m_lambda;
-    Finalizer(F &&lambda) : m_lambda(std::forward<F>(lambda)) {}
-    ~Finalizer() { m_lambda(); }
-};
-
-template<typename F>
-static Finalizer<F> defer(F &&lambda)
-{
-    return Finalizer<F>(std::forward<F>(lambda));
-}
-
-tst_QQmlDebugJS::InitResult tst_QQmlDebugJS::init(bool qmlscene, const QString &qmlFile,
-                                                  bool blockMode, bool restrictServices)
-{
-    connection = new QQmlDebugConnection();
-    if (qmlscene)
-        process = new QQmlDebugProcess(QLibraryInfo::location(QLibraryInfo::BinariesPath) +
-                                       "/qmlscene", this);
-    else
-        process = new QQmlDebugProcess(QCoreApplication::applicationDirPath() +
-                                       QLatin1String("/qqmldebugjsserver"), this);
-    client = new QJSDebugClient(connection);
-    QList<QQmlDebugClient *> others = QQmlDebugTest::createOtherClients(connection);
-    auto deleter = defer([&others]() { qDeleteAll(others); });
-    Q_UNUSED(deleter);
-
-    const char *args = 0;
-    if (blockMode)
-        args = restrictServices ? BLOCKRESTRICTEDMODE : BLOCKMODE;
-    else
-        args = restrictServices ? NORMALRESTRICTEDMODE : NORMALMODE;
-
-    process->start(QStringList() << QLatin1String(args) << testFile(qmlFile));
-
-    if (!process->waitForSessionStart())
-        return ProcessFailed;
-
-    const int port = process->debugPort();
-    connection->connectToHost("127.0.0.1", port);
-    if (!connection->waitForConnected())
-        return ConnectionFailed;
-
-    if (client->state() != QQmlDebugClient::Enabled
-            && !QQmlDebugTest::waitForSignal(client, SIGNAL(enabled()))) {
-        return ClientFailed;
-    }
-
-    const QQmlDebugClient::State expectedState = restrictServices ? QQmlDebugClient::Unavailable
-                                                                  : QQmlDebugClient::Enabled;
-    foreach (QQmlDebugClient *otherClient, others) {
-        if (otherClient->state() != expectedState)
-            return RestrictFailed;
-    }
-
-    return InitSuccess;
 }
 
-void tst_QQmlDebugJS::cleanup()
+QQmlDebugTest::ConnectResult tst_QQmlDebugJS::init(bool qmlscene, const QString &qmlFile,
+                                                   bool blockMode, bool restrictServices)
 {
-    if (QTest::currentTestFailed()) {
-        qDebug() << "Process State:" << process->state();
-        qDebug() << "Application Output:" << process->output();
-    }
-
-    if (process) {
-        process->stop();
-        delete process;
-    }
-
-    if (client)
-        delete client;
-
-    if (connection)
-        delete connection;
-
-    process = 0;
-    client = 0;
-    connection = 0;
+    const QString executable = qmlscene
+            ? QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmlscene"
+            : QCoreApplication::applicationDirPath() + QLatin1String("/qqmldebugjsserver");
+    return QQmlDebugTest::connect(
+                executable, restrictServices ? QStringLiteral("V8Debugger") : QString(),
+                testFile(qmlFile), blockMode);
 }
 
 void tst_QQmlDebugJS::connect_data()
@@ -894,9 +790,9 @@ void tst_QQmlDebugJS::connect()
     QFETCH(bool, blockMode);
     QFETCH(bool, restrictMode);
     QFETCH(bool, qmlscene);
-    QCOMPARE(init(qmlscene, QString(TEST_QMLFILE), blockMode, restrictMode), InitSuccess);
-    client->connect();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(connected())));
+    QCOMPARE(init(qmlscene, QString(TEST_QMLFILE), blockMode, restrictMode), ConnectSuccess);
+    m_client->connect();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(connected())));
 }
 
 void tst_QQmlDebugJS::interrupt()
@@ -906,11 +802,11 @@ void tst_QQmlDebugJS::interrupt()
     QFETCH(bool, qmlscene);
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
-    QCOMPARE(init(qmlscene), InitSuccess);
-    client->connect(redundantRefs, namesAsObjects);
+    QCOMPARE(init(qmlscene), ConnectSuccess);
+    m_client->connect(redundantRefs, namesAsObjects);
 
-    client->interrupt();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(interruptRequested())));
+    m_client->interrupt();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(interruptRequested())));
 }
 
 void tst_QQmlDebugJS::getVersion()
@@ -920,12 +816,12 @@ void tst_QQmlDebugJS::getVersion()
     QFETCH(bool, qmlscene);
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
-    QCOMPARE(init(qmlscene), InitSuccess);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(connected())));
+    QCOMPARE(init(qmlscene), ConnectSuccess);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(connected())));
 
-    client->version();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->version();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 }
 
 void tst_QQmlDebugJS::getVersionWhenAttaching()
@@ -935,11 +831,11 @@ void tst_QQmlDebugJS::getVersionWhenAttaching()
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
 
-    QCOMPARE(init(qmlscene, QLatin1String(TIMER_QMLFILE), false), InitSuccess);
-    client->connect(redundantRefs, namesAsObjects);
+    QCOMPARE(init(qmlscene, QLatin1String(TIMER_QMLFILE), false), ConnectSuccess);
+    m_client->connect(redundantRefs, namesAsObjects);
 
-    client->version();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->version();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 }
 
 void tst_QQmlDebugJS::disconnect()
@@ -949,11 +845,11 @@ void tst_QQmlDebugJS::disconnect()
     QFETCH(bool, qmlscene);
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
-    QCOMPARE(init(qmlscene), InitSuccess);
-    client->connect(redundantRefs, namesAsObjects);
+    QCOMPARE(init(qmlscene), ConnectSuccess);
+    m_client->connect(redundantRefs, namesAsObjects);
 
-    client->disconnect();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->disconnect();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 }
 
 void tst_QQmlDebugJS::setBreakpointInScriptOnCompleted()
@@ -964,14 +860,14 @@ void tst_QQmlDebugJS::setBreakpointInScriptOnCompleted()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 34;
-    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -987,14 +883,14 @@ void tst_QQmlDebugJS::setBreakpointInScriptOnComponentCreated()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 34;
-    QCOMPARE(init(qmlscene, CREATECOMPONENT_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, CREATECOMPONENT_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1008,16 +904,16 @@ void tst_QQmlDebugJS::setBreakpointInScriptOnTimerCallback()
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
     int sourceLine = 35;
-    QCOMPARE(init(qmlscene, TIMER_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, TIMER_QMLFILE), ConnectSuccess);
 
-    client->connect(redundantRefs, namesAsObjects);
+    m_client->connect(redundantRefs, namesAsObjects);
     //We can set the breakpoint after connect() here because the timer is repeating and if we miss
     //its first iteration we can still catch the second one.
-    client->setBreakpoint(QLatin1String(TIMER_QMLFILE), sourceLine, -1, true);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(TIMER_QMLFILE), sourceLine, -1, true);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1033,14 +929,14 @@ void tst_QQmlDebugJS::setBreakpointInScriptInDifferentFile()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 31;
-    QCOMPARE(init(qmlscene, LOADJSFILE_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, LOADJSFILE_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(TEST_JSFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(TEST_JSFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1057,15 +953,15 @@ void tst_QQmlDebugJS::setBreakpointInScriptOnComment()
 
     int sourceLine = 34;
     int actualLine = 36;
-    QCOMPARE(init(qmlscene, BREAKPOINTRELOCATION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, BREAKPOINTRELOCATION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(BREAKPOINTRELOCATION_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
+    m_client->setBreakpoint(QLatin1String(BREAKPOINTRELOCATION_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
     QEXPECT_FAIL("", "Relocation of breakpoints is disabled right now", Abort);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped()), 1));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped()), 1));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1082,15 +978,15 @@ void tst_QQmlDebugJS::setBreakpointInScriptOnEmptyLine()
 
     int sourceLine = 35;
     int actualLine = 36;
-    QCOMPARE(init(qmlscene, BREAKPOINTRELOCATION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, BREAKPOINTRELOCATION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(BREAKPOINTRELOCATION_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
+    m_client->setBreakpoint(QLatin1String(BREAKPOINTRELOCATION_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
     QEXPECT_FAIL("", "Relocation of breakpoints is disabled right now", Abort);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped()), 1));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped()), 1));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1106,14 +1002,14 @@ void tst_QQmlDebugJS::setBreakpointInScriptOnOptimizedBinding()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 39;
-    QCOMPARE(init(qmlscene, BREAKPOINTRELOCATION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, BREAKPOINTRELOCATION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(BREAKPOINTRELOCATION_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(BREAKPOINTRELOCATION_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1128,28 +1024,28 @@ void tst_QQmlDebugJS::setBreakpointInScriptWithCondition()
     QFETCH(bool, namesAsObjects);
     int out = 10;
     int sourceLine = 37;
-    QCOMPARE(init(qmlscene, CONDITION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, CONDITION_QMLFILE), ConnectSuccess);
 
-    client->connect(redundantRefs, namesAsObjects);
+    m_client->connect(redundantRefs, namesAsObjects);
     //The breakpoint is in a timer loop so we can set it after connect().
-    client->setBreakpoint(QLatin1String(CONDITION_QMLFILE), sourceLine, 1, true, QLatin1String("a > 10"));
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(CONDITION_QMLFILE), sourceLine, 1, true, QLatin1String("a > 10"));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
     //Get the frame index
-    QString jsonString = client->response;
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString = m_client->response;
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     {
         QVariantMap body = value.value("body").toMap();
         int frameIndex = body.value("index").toInt();
 
         //Verify the value of 'result'
-        client->evaluate(QLatin1String("a"),frameIndex);
-        QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+        m_client->evaluate(QLatin1String("a"),frameIndex);
+        QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
     }
 
-    jsonString = client->response;
-    QJSValue val = client->parser.call(QJSValueList() << QJSValue(jsonString));
+    jsonString = m_client->response;
+    QJSValue val = m_client->parser.call(QJSValueList() << QJSValue(jsonString));
     QVERIFY(val.isObject());
     QJSValue body = val.property(QStringLiteral("body"));
     QVERIFY(body.isObject());
@@ -1165,42 +1061,42 @@ void tst_QQmlDebugJS::setBreakpointInScriptThatQuits()
     QFETCH(bool, qmlscene);
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
-    QCOMPARE(init(qmlscene, QUIT_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, QUIT_QMLFILE), ConnectSuccess);
 
     int sourceLine = 36;
 
-    client->setBreakpoint(QLatin1String(QUIT_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(QUIT_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
     QCOMPARE(body.value("sourceLine").toInt(), sourceLine);
     QCOMPARE(QFileInfo(body.value("script").toMap().value("name").toString()).fileName(), QLatin1String(QUIT_QMLFILE));
 
-    client->continueDebugging(QJSDebugClient::Continue);
-    QVERIFY(process->waitForFinished());
-    QCOMPARE(process->exitStatus(), QProcess::NormalExit);
+    m_client->continueDebugging(QJSDebugClient::Continue);
+    QVERIFY(m_process->waitForFinished());
+    QCOMPARE(m_process->exitStatus(), QProcess::NormalExit);
 }
 
 void tst_QQmlDebugJS::setBreakpointWhenAttaching()
 {
     int sourceLine = 35;
-    QCOMPARE(init(true, QLatin1String(TIMER_QMLFILE), false), InitSuccess);
+    QCOMPARE(init(true, QLatin1String(TIMER_QMLFILE), false), ConnectSuccess);
 
-    client->connect();
+    m_client->connect();
 
     QSKIP("\nThe breakpoint may not hit because the engine may run in JIT mode or not have debug\n"
           "instructions, as we've connected in non-blocking mode above. That means we may have\n"
           "connected after the engine was already running, with all the QML already compiled.");
 
     //The breakpoint is in a timer loop so we can set it after connect().
-    client->setBreakpoint(QLatin1String(TIMER_QMLFILE), sourceLine);
+    m_client->setBreakpoint(QLatin1String(TIMER_QMLFILE), sourceLine);
 
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 }
 
 void tst_QQmlDebugJS::clearBreakpoint()
@@ -1212,41 +1108,41 @@ void tst_QQmlDebugJS::clearBreakpoint()
 
     int sourceLine1 = 37;
     int sourceLine2 = 38;
-    QCOMPARE(init(qmlscene, CHANGEBREAKPOINT_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, CHANGEBREAKPOINT_QMLFILE), ConnectSuccess);
 
-    client->connect(redundantRefs, namesAsObjects);
+    m_client->connect(redundantRefs, namesAsObjects);
     //The breakpoints are in a timer loop so we can set them after connect().
     //Furthermore the breakpoints should be hit in the right order because setting of breakpoints
     //can only occur in the QML event loop. (see QCOMPARE for sourceLine2 below)
-    client->setBreakpoint(QLatin1String(CHANGEBREAKPOINT_QMLFILE), sourceLine1, -1, true);
-    client->setBreakpoint(QLatin1String(CHANGEBREAKPOINT_QMLFILE), sourceLine2, -1, true);
+    m_client->setBreakpoint(QLatin1String(CHANGEBREAKPOINT_QMLFILE), sourceLine1, -1, true);
+    m_client->setBreakpoint(QLatin1String(CHANGEBREAKPOINT_QMLFILE), sourceLine2, -1, true);
 
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
     //Will hit 1st brakpoint, change this breakpoint enable = false
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
     QList<QVariant> breakpointsHit = body.value("breakpoints").toList();
 
     int breakpoint = breakpointsHit.at(0).toInt();
-    client->clearBreakpoint(breakpoint);
+    m_client->clearBreakpoint(breakpoint);
 
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 
     //Continue with debugging
-    client->continueDebugging(QJSDebugClient::Continue);
+    m_client->continueDebugging(QJSDebugClient::Continue);
     //Hit 2nd breakpoint
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
     //Continue with debugging
-    client->continueDebugging(QJSDebugClient::Continue);
+    m_client->continueDebugging(QJSDebugClient::Continue);
     //Should stop at 2nd breakpoint
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    jsonString = client->response;
-    value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    jsonString = m_client->response;
+    value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     body = value.value("body").toMap();
 
@@ -1260,10 +1156,10 @@ void tst_QQmlDebugJS::setExceptionBreak()
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
 
-    QCOMPARE(init(qmlscene, EXCEPTION_QMLFILE), InitSuccess);
-    client->setExceptionBreak(QJSDebugClient::All,true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    QCOMPARE(init(qmlscene, EXCEPTION_QMLFILE), ConnectSuccess);
+    m_client->setExceptionBreak(QJSDebugClient::All,true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 }
 
 void tst_QQmlDebugJS::stepNext()
@@ -1274,17 +1170,17 @@ void tst_QQmlDebugJS::stepNext()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 37;
-    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->continueDebugging(QJSDebugClient::Next);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->continueDebugging(QJSDebugClient::Next);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1301,17 +1197,17 @@ void tst_QQmlDebugJS::stepIn()
 
     int sourceLine = 41;
     int actualLine = 37;
-    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine, 1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine, 1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->continueDebugging(QJSDebugClient::In);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->continueDebugging(QJSDebugClient::In);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1328,17 +1224,17 @@ void tst_QQmlDebugJS::stepOut()
 
     int sourceLine = 37;
     int actualLine = 41;
-    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->continueDebugging(QJSDebugClient::Out);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->continueDebugging(QJSDebugClient::Out);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1355,18 +1251,18 @@ void tst_QQmlDebugJS::continueDebugging()
 
     int sourceLine1 = 41;
     int sourceLine2 = 38;
-    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, STEPACTION_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine1, -1, true);
-    client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine2, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine1, -1, true);
+    m_client->setBreakpoint(QLatin1String(STEPACTION_QMLFILE), sourceLine2, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->continueDebugging(QJSDebugClient::Continue);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->continueDebugging(QJSDebugClient::Continue);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
@@ -1382,14 +1278,14 @@ void tst_QQmlDebugJS::backtrace()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 34;
-    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->backtrace();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->backtrace();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 }
 
 void tst_QQmlDebugJS::getFrameDetails()
@@ -1400,14 +1296,14 @@ void tst_QQmlDebugJS::getFrameDetails()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 34;
-    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->frame();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->frame();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 }
 
 void tst_QQmlDebugJS::getScopeDetails()
@@ -1418,31 +1314,31 @@ void tst_QQmlDebugJS::getScopeDetails()
     QFETCH(bool, namesAsObjects);
 
     int sourceLine = 34;
-    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->scope();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->scope();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 }
 
 void tst_QQmlDebugJS::evaluateInGlobalScope()
 {
     //void evaluate(QString expr, int frame = -1);
-    QCOMPARE(init(true), InitSuccess);
+    QCOMPARE(init(true), ConnectSuccess);
 
-    client->connect();
+    m_client->connect();
 
     do {
         // The engine might not be initialized, yet. We just try until it shows up.
-        client->evaluate(QLatin1String("console.log('Hello World')"));
-    } while (!QQmlDebugTest::waitForSignal(client, SIGNAL(result()), 500));
+        m_client->evaluate(QLatin1String("console.log('Hello World')"));
+    } while (!QQmlDebugTest::waitForSignal(m_client, SIGNAL(result()), 500));
 
     //Verify the return value of 'console.log()', which is "undefined"
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
     QVariantMap body = value.value("body").toMap();
     QCOMPARE(body.value("type").toString(),QLatin1String("undefined"));
 }
@@ -1455,29 +1351,29 @@ void tst_QQmlDebugJS::evaluateInLocalScope()
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
     int sourceLine = 34;
-    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), InitSuccess);
+    QCOMPARE(init(qmlscene, ONCOMPLETED_QMLFILE), ConnectSuccess);
 
-    client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QLatin1String(ONCOMPLETED_QMLFILE), sourceLine, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->frame();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->frame();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 
     //Get the frame index
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
 
     int frameIndex = body.value("index").toInt();
 
-    client->evaluate(QLatin1String("root.a"), frameIndex);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->evaluate(QLatin1String("root.a"), frameIndex);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 
     //Verify the value of 'timer.interval'
-    jsonString = client->response;
-    value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    jsonString = m_client->response;
+    value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     body = value.value("body").toMap();
 
@@ -1486,25 +1382,25 @@ void tst_QQmlDebugJS::evaluateInLocalScope()
 
 void tst_QQmlDebugJS::evaluateInContext()
 {
-    connection = new QQmlDebugConnection();
-    process = new QQmlDebugProcess(QLibraryInfo::location(QLibraryInfo::BinariesPath)
+    m_connection = new QQmlDebugConnection();
+    m_process = new QQmlDebugProcess(QLibraryInfo::location(QLibraryInfo::BinariesPath)
                                    + "/qmlscene", this);
-    client = new QJSDebugClient(connection);
-    QScopedPointer<QQmlEngineDebugClient> engineClient(new QQmlEngineDebugClient(connection));
-    process->start(QStringList() << QLatin1String(BLOCKMODE) << testFile(ONCOMPLETED_QMLFILE));
+    m_client = new QJSDebugClient(m_connection);
+    QScopedPointer<QQmlEngineDebugClient> engineClient(new QQmlEngineDebugClient(m_connection));
+    m_process->start(QStringList() << QLatin1String(BLOCKMODE) << testFile(ONCOMPLETED_QMLFILE));
 
-    QVERIFY(process->waitForSessionStart());
+    QVERIFY(m_process->waitForSessionStart());
 
-    connection->connectToHost("127.0.0.1", process->debugPort());
-    QVERIFY(connection->waitForConnected());
+    m_connection->connectToHost("127.0.0.1", m_process->debugPort());
+    QVERIFY(m_connection->waitForConnected());
 
-    QTRY_COMPARE(client->state(), QQmlEngineDebugClient::Enabled);
+    QTRY_COMPARE(m_client->state(), QQmlEngineDebugClient::Enabled);
     QTRY_COMPARE(engineClient->state(), QQmlEngineDebugClient::Enabled);
-    client->connect();
+    m_client->connect();
 
     // "a" not accessible without extra context
-    client->evaluate(QLatin1String("a + 10"), -1, -1);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(failure())));
+    m_client->evaluate(QLatin1String("a + 10"), -1, -1);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(failure())));
 
     bool success = false;
     engineClient->queryAvailableEngines(&success);
@@ -1526,11 +1422,11 @@ void tst_QQmlDebugJS::evaluateInContext()
     auto object = engineClient->object();
 
     // "a" accessible in context of surrounding object
-    client->evaluate(QLatin1String("a + 10"), -1, object.debugId);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
+    m_client->evaluate(QLatin1String("a + 10"), -1, object.debugId);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
 
-    QString jsonString = client->response;
-    QVariantMap value = client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
+    QString jsonString = m_client->response;
+    QVariantMap value = m_client->parser.call(QJSValueList() << QJSValue(jsonString)).toVariant().toMap();
 
     QVariantMap body = value.value("body").toMap();
     QTRY_COMPARE(body.value("value").toInt(), 20);
@@ -1543,16 +1439,16 @@ void tst_QQmlDebugJS::getScripts()
     QFETCH(bool, qmlscene);
     QFETCH(bool, redundantRefs);
     QFETCH(bool, namesAsObjects);
-    QCOMPARE(init(qmlscene), InitSuccess);
+    QCOMPARE(init(qmlscene), ConnectSuccess);
 
-    client->setBreakpoint(QString(TEST_QMLFILE), 35, -1, true);
-    client->connect(redundantRefs, namesAsObjects);
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(stopped())));
+    m_client->setBreakpoint(QString(TEST_QMLFILE), 35, -1, true);
+    m_client->connect(redundantRefs, namesAsObjects);
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(stopped())));
 
-    client->scripts();
-    QVERIFY(QQmlDebugTest::waitForSignal(client, SIGNAL(result())));
-    QString jsonString(client->response);
-    QVariantMap value = client->parser.call(QJSValueList()
+    m_client->scripts();
+    QVERIFY(QQmlDebugTest::waitForSignal(m_client, SIGNAL(result())));
+    QString jsonString(m_client->response);
+    QVariantMap value = m_client->parser.call(QJSValueList()
                                             << QJSValue(jsonString)).toVariant().toMap();
 
     QList<QVariant> scripts = value.value("body").toList();
@@ -1561,6 +1457,12 @@ void tst_QQmlDebugJS::getScripts()
     QVERIFY(scripts.first().toMap()[QStringLiteral("name")].toString().endsWith(QStringLiteral("data/test.qml")));
 }
 
+QList<QQmlDebugClient *> tst_QQmlDebugJS::createClients()
+{
+    m_client = new QJSDebugClient(m_connection);
+    return QList<QQmlDebugClient *>({m_client});
+}
+
 void tst_QQmlDebugJS::targetData()
 {
     QTest::addColumn<bool>("qmlscene");
diff --git a/tests/auto/qml/debugger/qqmlenginecontrol/qqmlenginecontrol.pro b/tests/auto/qml/debugger/qqmlenginecontrol/qqmlenginecontrol.pro
index 34950a5569..73455bd903 100644
--- a/tests/auto/qml/debugger/qqmlenginecontrol/qqmlenginecontrol.pro
+++ b/tests/auto/qml/debugger/qqmlenginecontrol/qqmlenginecontrol.pro
@@ -8,7 +8,7 @@ include(../shared/debugutil.pri)
 
 TESTDATA = data/*
 
-QT += core qml testlib testlib-private gui-private core-private
+QT += core qml testlib gui-private core-private
 
 OTHER_FILES += \
     data/test.qml \
diff --git a/tests/auto/qml/debugger/qqmlenginecontrol/tst_qqmlenginecontrol.cpp b/tests/auto/qml/debugger/qqmlenginecontrol/tst_qqmlenginecontrol.cpp
index 2c515d7cf5..18ba133876 100644
--- a/tests/auto/qml/debugger/qqmlenginecontrol/tst_qqmlenginecontrol.cpp
+++ b/tests/auto/qml/debugger/qqmlenginecontrol/tst_qqmlenginecontrol.cpp
@@ -35,12 +35,8 @@
 #include <private/qqmlenginecontrolclient_p.h>
 
 #include <QtTest/qtest.h>
-#include <private/qtestresult_p.h>
 #include <QtCore/qlibraryinfo.h>
 
-#define STR_PORT_FROM "13773"
-#define STR_PORT_TO "13783"
-
 class QQmlEngineBlocker : public QObject
 {
     Q_OBJECT
@@ -65,77 +61,37 @@ void QQmlEngineBlocker::blockEngine(int engineId, const QString &name)
     static_cast<QQmlEngineControlClient *>(parent())->blockEngine(engineId);
 }
 
-class tst_QQmlEngineControl : public QQmlDataTest
+class tst_QQmlEngineControl : public QQmlDebugTest
 {
     Q_OBJECT
 
-public:
-    tst_QQmlEngineControl()
-        : m_process(0)
-        , m_connection(0)
-        , m_client(0)
-    {}
-
 private:
-    QQmlDebugProcess *m_process;
-    QQmlDebugConnection *m_connection;
-    QQmlEngineControlClient *m_client;
+    ConnectResult connect(const QString &testFile, bool restrictServices);
+    QList<QQmlDebugClient *> createClients() override;
 
-    void connect(const QString &testFile, bool restrictServices);
     void engine_data();
+    QPointer<QQmlEngineControlClient> m_client;
 
 private slots:
-    void cleanup();
-
     void startEngine_data();
     void startEngine();
     void stopEngine_data();
     void stopEngine();
 };
 
-void tst_QQmlEngineControl::connect(const QString &testFile, bool restrictServices)
+QQmlDebugTest::ConnectResult tst_QQmlEngineControl::connect(const QString &file,
+                                                            bool restrictServices)
 {
-    const QString executable = QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmlscene";
-    QStringList arguments;
-    arguments << QString::fromLatin1("-qmljsdebugger=port:%1,%2,block%3")
-                 .arg(STR_PORT_FROM).arg(STR_PORT_TO)
-                 .arg(restrictServices ? QStringLiteral(",services:EngineControl") : QString());
-
-    arguments << QQmlDataTest::instance()->testFile(testFile);
-
-    m_process = new QQmlDebugProcess(executable, this);
-    m_process->start(QStringList() << arguments);
-    QVERIFY2(m_process->waitForSessionStart(), "Could not launch application, or did not get 'Waiting for connection'.");
-
-    m_connection = new QQmlDebugConnection();
-    m_client = new QQmlEngineControlClient(m_connection);
-    new QQmlEngineBlocker(m_client);
-    QList<QQmlDebugClient *> others = QQmlDebugTest::createOtherClients(m_connection);
-
-    const int port = m_process->debugPort();
-    m_connection->connectToHost(QLatin1String("127.0.0.1"), port);
-
-    QTRY_COMPARE(m_client->state(), QQmlDebugClient::Enabled);
-    foreach (QQmlDebugClient *other, others)
-        QCOMPARE(other->state(), restrictServices ? QQmlDebugClient::Unavailable :
-                                                    QQmlDebugClient::Enabled);
-    qDeleteAll(others);
+    return QQmlDebugTest::connect(QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmlscene",
+                                  restrictServices ? QStringLiteral("EngineControl") : QString(),
+                                  testFile(file), true);
 }
 
-void tst_QQmlEngineControl::cleanup()
+QList<QQmlDebugClient *> tst_QQmlEngineControl::createClients()
 {
-    if (QTest::currentTestFailed()) {
-        qDebug() << "Process State:" << (m_process ? m_process->state() : QLatin1String("null"));
-        qDebug() << "Application Output:" << (m_process ? m_process->output() : QLatin1String("null"));
-        qDebug() << "Connection State:" << QQmlDebugTest::connectionStateString(m_connection);
-        qDebug() << "Client State:" << QQmlDebugTest::clientStateString(m_client);
-    }
-    delete m_process;
-    m_process = 0;
-    delete m_client;
-    m_client = 0;
-    delete m_connection;
-    m_connection = 0;
+    m_client = new QQmlEngineControlClient(m_connection);
+    new QQmlEngineBlocker(m_client);
+    return QList<QQmlDebugClient *>({m_client});
 }
 
 void tst_QQmlEngineControl::engine_data()
@@ -153,10 +109,7 @@ void tst_QQmlEngineControl::startEngine_data()
 void tst_QQmlEngineControl::startEngine()
 {
     QFETCH(bool, restrictMode);
-
-    connect("test.qml", restrictMode);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(connect("test.qml", restrictMode), ConnectSuccess);
 
     QTRY_VERIFY(!m_client->blockedEngines().empty());
     m_client->releaseEngine(m_client->blockedEngines().last());
@@ -174,9 +127,7 @@ void tst_QQmlEngineControl::stopEngine()
 {
     QFETCH(bool, restrictMode);
 
-    connect("exit.qml", restrictMode);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(connect("exit.qml", restrictMode), ConnectSuccess);
 
     QTRY_VERIFY(!m_client->blockedEngines().empty());
     m_client->releaseEngine(m_client->blockedEngines().last());
diff --git a/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/BLACKLIST b/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/BLACKLIST
new file mode 100644
index 0000000000..5fb1dc193b
--- /dev/null
+++ b/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/BLACKLIST
@@ -0,0 +1,2 @@
+# QTQAINFRA-1334
+windows gcc
diff --git a/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/qqmlenginedebuginspectorintegrationtest.pro b/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/qqmlenginedebuginspectorintegrationtest.pro
index de3b38ec7a..5f58e5ec7f 100644
--- a/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/qqmlenginedebuginspectorintegrationtest.pro
+++ b/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/qqmlenginedebuginspectorintegrationtest.pro
@@ -1,7 +1,7 @@
 CONFIG += testcase
 TARGET = tst_qqmlenginedebuginspectorintegration
 
-QT += qml testlib testlib-private gui-private core-private
+QT += qml testlib gui-private core-private
 osx:CONFIG -= app_bundle
 
 SOURCES += tst_qqmlenginedebuginspectorintegration.cpp
diff --git a/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/tst_qqmlenginedebuginspectorintegration.cpp b/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/tst_qqmlenginedebuginspectorintegration.cpp
index 738da048a3..249416a3b9 100644
--- a/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/tst_qqmlenginedebuginspectorintegration.cpp
+++ b/tests/auto/qml/debugger/qqmlenginedebuginspectorintegrationtest/tst_qqmlenginedebuginspectorintegration.cpp
@@ -34,7 +34,6 @@
 #include <private/qqmldebugconnection_p.h>
 
 #include <QtTest/qtest.h>
-#include <private/qtestresult_p.h>
 #include <QtTest/qsignalspy.h>
 #include <QtNetwork/qhostaddress.h>
 #include <QtCore/qtimer.h>
@@ -42,35 +41,21 @@
 #include <QtCore/qthread.h>
 #include <QtCore/qlibraryinfo.h>
 
-#define STR_PORT_FROM "3776"
-#define STR_PORT_TO "3786"
-
-class tst_QQmlEngineDebugInspectorIntegration : public QQmlDataTest
+class tst_QQmlEngineDebugInspectorIntegration : public QQmlDebugTest
 {
     Q_OBJECT
 
-public:
-    tst_QQmlEngineDebugInspectorIntegration()
-        : m_process(0)
-        , m_inspectorClient(0)
-        , m_engineDebugClient(0)
-        , m_recipient(0)
-    {
-    }
-
-
 private:
-    void init(bool restrictServices);
+    ConnectResult init(bool restrictServices);
+    QList<QQmlDebugClient *> createClients() override;
+
     QmlDebugObjectReference findRootObject();
 
-    QQmlDebugProcess *m_process;
-    QQmlInspectorClient *m_inspectorClient;
-    QQmlEngineDebugClient *m_engineDebugClient;
-    QQmlInspectorResultRecipient *m_recipient;
+    QPointer<QQmlInspectorClient> m_inspectorClient;
+    QPointer<QQmlEngineDebugClient> m_engineDebugClient;
+    QPointer<QQmlInspectorResultRecipient> m_recipient;
 
 private slots:
-    void cleanup();
-
     void connect_data();
     void connect();
     void objectLocationLookup();
@@ -100,57 +85,22 @@ QmlDebugObjectReference tst_QQmlEngineDebugInspectorIntegration::findRootObject(
     return m_engineDebugClient->object();
 }
 
-void tst_QQmlEngineDebugInspectorIntegration::init(bool restrictServices)
+QQmlDebugTest::ConnectResult tst_QQmlEngineDebugInspectorIntegration::init(bool restrictServices)
 {
-#if defined(Q_OS_WIN) && defined(Q_CC_MINGW)
-    QSKIP("Capturing output while running nested event loop is not reliable on Windows/GCC");
-#endif
-
-    const QString argument = QString::fromLatin1("-qmljsdebugger=port:%1,%2,block%3")
-            .arg(STR_PORT_FROM).arg(STR_PORT_TO)
-            .arg(restrictServices ? QStringLiteral(",services:QmlDebugger,QmlInspector") :
-                                    QString());
-
-    m_process = new QQmlDebugProcess(QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qml",
-                                     this);
-    m_process->start(QStringList() << argument << testFile("qtquick2.qml"));
-    QVERIFY2(m_process->waitForSessionStart(),
-             "Could not launch application, or did not get 'Waiting for connection'.");
-
-    QQmlDebugConnection *m_connection = new QQmlDebugConnection(this);
-    m_inspectorClient = new QQmlInspectorClient(m_connection);
-    m_engineDebugClient = new QQmlEngineDebugClient(m_connection);
-    m_recipient = new QQmlInspectorResultRecipient(this);
-    QObject::connect(m_inspectorClient, &QQmlInspectorClient::responseReceived,
-                     m_recipient, &QQmlInspectorResultRecipient::recordResponse);
-
-    QList<QQmlDebugClient *> others = QQmlDebugTest::createOtherClients(m_connection);
-
-    m_connection->connectToHost(QLatin1String("127.0.0.1"), m_process->debugPort());
-    QVERIFY(m_connection->waitForConnected());
-    foreach (QQmlDebugClient *other, others)
-        QCOMPARE(other->state(), restrictServices ? QQmlDebugClient::Unavailable :
-                                                    QQmlDebugClient::Enabled);
-    qDeleteAll(others);
-
-    QTRY_COMPARE(m_inspectorClient->state(), QQmlDebugClient::Enabled);
-    QTRY_COMPARE(m_engineDebugClient->state(), QQmlDebugClient::Enabled);
+    return QQmlDebugTest::connect(
+                QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qml",
+                restrictServices ? QStringLiteral("QmlDebugger,QmlInspector") : QString(),
+                testFile("qtquick2.qml"), true);
 }
 
-void tst_QQmlEngineDebugInspectorIntegration::cleanup()
+QList<QQmlDebugClient *> tst_QQmlEngineDebugInspectorIntegration::createClients()
 {
-    if (QTest::currentTestFailed()) {
-        qDebug() << "Process State:" << m_process->state();
-        qDebug() << "Application Output:" << m_process->output();
-    }
-    delete m_process;
-    m_process = 0;
-    delete m_engineDebugClient;
-    m_engineDebugClient = 0;
-    delete m_inspectorClient;
-    m_inspectorClient = 0;
-    delete m_recipient;
-    m_recipient = 0;
+    m_inspectorClient = new QQmlInspectorClient(m_connection);
+    m_engineDebugClient = new QQmlEngineDebugClient(m_connection);
+    m_recipient = new QQmlInspectorResultRecipient(m_inspectorClient);
+    QObject::connect(m_inspectorClient.data(), &QQmlInspectorClient::responseReceived,
+                     m_recipient.data(), &QQmlInspectorResultRecipient::recordResponse);
+    return QList<QQmlDebugClient *>({m_inspectorClient, m_engineDebugClient});
 }
 
 void tst_QQmlEngineDebugInspectorIntegration::connect_data()
@@ -163,14 +113,12 @@ void tst_QQmlEngineDebugInspectorIntegration::connect_data()
 void tst_QQmlEngineDebugInspectorIntegration::connect()
 {
     QFETCH(bool, restrictMode);
-    init(restrictMode);
+    QCOMPARE(init(restrictMode), ConnectSuccess);
 }
 
 void tst_QQmlEngineDebugInspectorIntegration::objectLocationLookup()
 {
-    init(true);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(init(true), ConnectSuccess);
 
     bool success = false;
     QmlDebugObjectReference rootObject = findRootObject();
@@ -196,9 +144,7 @@ void tst_QQmlEngineDebugInspectorIntegration::objectLocationLookup()
 
 void tst_QQmlEngineDebugInspectorIntegration::select()
 {
-    init(true);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(init(true), ConnectSuccess);
 
     QmlDebugObjectReference rootObject = findRootObject();
     QList<int> childIds;
@@ -216,9 +162,7 @@ void tst_QQmlEngineDebugInspectorIntegration::select()
 
 void tst_QQmlEngineDebugInspectorIntegration::createObject()
 {
-    init(true);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(init(true), ConnectSuccess);
 
     QString qml = QLatin1String("Rectangle {\n"
                                 "  id: xxxyxxx\n"
@@ -245,9 +189,7 @@ void tst_QQmlEngineDebugInspectorIntegration::createObject()
 
 void tst_QQmlEngineDebugInspectorIntegration::moveObject()
 {
-    init(true);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(init(true), ConnectSuccess);
 
     QCOMPARE(m_inspectorClient->state(), QQmlDebugClient::Enabled);
     QmlDebugObjectReference rootObject = findRootObject();
@@ -272,9 +214,7 @@ void tst_QQmlEngineDebugInspectorIntegration::moveObject()
 
 void tst_QQmlEngineDebugInspectorIntegration::destroyObject()
 {
-    init(true);
-    if (QTest::currentTestFailed() || QTestResult::skipCurrentTest())
-        return;
+    QCOMPARE(init(true), ConnectSuccess);
 
     QCOMPARE(m_inspectorClient->state(), QQmlDebugClient::Enabled);
     QmlDebugObjectReference rootObject = findRootObject();
diff --git a/tests/auto/qml/debugger/qqmlinspector/tst_qqmlinspector.cpp b/tests/auto/qml/debugger/qqmlinspector/tst_qqmlinspector.cpp
index 9461922eff..a4cf932ee1 100644
--- a/tests/auto/qml/debugger/qqmlinspector/tst_qqmlinspector.cpp
+++ b/tests/auto/qml/debugger/qqmlinspector/tst_qqmlinspector.cpp
@@ -40,64 +40,32 @@
 #include <QtCore/qlibraryinfo.h>
 #include <QtNetwork/qhostaddress.h>
 
-#define STR_PORT_FROM "3772"
-#define STR_PORT_TO "3782"
-
-
-class tst_QQmlInspector : public QQmlDataTest
+class tst_QQmlInspector : public QQmlDebugTest
 {
     Q_OBJECT
 
 private:
-    void startQmlProcess(const QString &qmlFile, bool restrictMode = true);
+    ConnectResult startQmlProcess(const QString &qmlFile, bool restrictMode = true);
     void checkAnimationSpeed(int targetMillisPerDegree);
+    QList<QQmlDebugClient *> createClients() override;
+    QQmlDebugProcess *createProcess(const QString &executable) override;
 
-private:
-    QScopedPointer<QQmlDebugProcess> m_process;
-    QScopedPointer<QQmlDebugConnection> m_connection;
-    QScopedPointer<QQmlInspectorClient> m_client;
-    QScopedPointer<QQmlInspectorResultRecipient> m_recipient;
+    QPointer<QQmlInspectorClient> m_client;
+    QPointer<QQmlInspectorResultRecipient> m_recipient;
 
 private slots:
-    void cleanup();
-
     void connect_data();
     void connect();
     void setAnimationSpeed();
     void showAppOnTop();
 };
 
-void tst_QQmlInspector::startQmlProcess(const QString &qmlFile, bool restrictServices)
+QQmlDebugTest::ConnectResult tst_QQmlInspector::startQmlProcess(const QString &qmlFile,
+                                                                bool restrictServices)
 {
-    const QString argument = QString::fromLatin1("-qmljsdebugger=port:%1,%2,block%3")
-            .arg(STR_PORT_FROM).arg(STR_PORT_TO)
-            .arg(restrictServices ? QStringLiteral(",services:QmlInspector") : QString());
-
-    m_process.reset(new QQmlDebugProcess(QLibraryInfo::location(QLibraryInfo::BinariesPath) +
-                                         "/qml"));
-    // Make sure the animation timing is exact
-    m_process->addEnvironment(QLatin1String("QSG_RENDER_LOOP=basic"));
-    m_process->start(QStringList() << argument << testFile(qmlFile));
-    QVERIFY2(m_process->waitForSessionStart(),
-             "Could not launch application, or did not get 'Waiting for connection'.");
-
-    m_client.reset();
-    m_connection.reset(new QQmlDebugConnection);
-    m_client.reset(new QQmlInspectorClient(m_connection.data()));
-
-    m_recipient.reset(new QQmlInspectorResultRecipient);
-    QObject::connect(m_client.data(), &QQmlInspectorClient::responseReceived,
-                     m_recipient.data(), &QQmlInspectorResultRecipient::recordResponse);
-
-    QList<QQmlDebugClient *> others = QQmlDebugTest::createOtherClients(m_connection.data());
-
-    m_connection->connectToHost(QLatin1String("127.0.0.1"), m_process->debugPort());
-    QTRY_COMPARE(m_client->state(), QQmlDebugClient::Enabled);
-
-    foreach (QQmlDebugClient *other, others)
-        QCOMPARE(other->state(), restrictServices ? QQmlDebugClient::Unavailable :
-                                                    QQmlDebugClient::Enabled);
-    qDeleteAll(others);
+    return QQmlDebugTest::connect(QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qml",
+                                  restrictServices ? QStringLiteral("QmlInspector") : QString(),
+                                  testFile(qmlFile), true);
 }
 
 void tst_QQmlInspector::checkAnimationSpeed(int targetMillisPerDegree)
@@ -114,8 +82,7 @@ void tst_QQmlInspector::checkAnimationSpeed(int targetMillisPerDegree)
         QString output = m_process->output();
         int position = output.length();
         do {
-            QVERIFY(QQmlDebugTest::waitForSignal(m_process.data(),
-                                                 SIGNAL(readyReadStandardOutput())));
+            QVERIFY(QQmlDebugTest::waitForSignal(m_process, SIGNAL(readyReadStandardOutput())));
             output = m_process->output();
         } while (!output.mid(position).contains(markerString));
 
@@ -144,12 +111,21 @@ void tst_QQmlInspector::checkAnimationSpeed(int targetMillisPerDegree)
           .arg(targetMillisPerDegree).toLocal8Bit().constData());
 }
 
-void tst_QQmlInspector::cleanup()
+QList<QQmlDebugClient *> tst_QQmlInspector::createClients()
 {
-    if (QTest::currentTestFailed()) {
-        qDebug() << "Process State:" << m_process->state();
-        qDebug() << "Application Output:" << m_process->output();
-    }
+    m_client = new QQmlInspectorClient(m_connection);
+    m_recipient = new QQmlInspectorResultRecipient(m_client);
+    QObject::connect(m_client.data(), &QQmlInspectorClient::responseReceived,
+                     m_recipient.data(), &QQmlInspectorResultRecipient::recordResponse);
+    return QList<QQmlDebugClient *>({m_client});
+}
+
+QQmlDebugProcess *tst_QQmlInspector::createProcess(const QString &executable)
+{
+    QQmlDebugProcess *process = QQmlDebugTest::createProcess(executable);
+    // Make sure the animation timing is exact
+    process->addEnvironment(QLatin1String("QSG_RENDER_LOOP=basic"));
+    return process;
 }
 
 void tst_QQmlInspector::connect_data()
@@ -166,7 +142,7 @@ void tst_QQmlInspector::connect()
 {
     QFETCH(QString, file);
     QFETCH(bool, restrictMode);
-    startQmlProcess(file, restrictMode);
+    QCOMPARE(startQmlProcess(file, restrictMode), ConnectSuccess);
     QVERIFY(m_client);
     QTRY_COMPARE(m_client->state(), QQmlDebugClient::Enabled);
 
@@ -181,7 +157,7 @@ void tst_QQmlInspector::connect()
 
 void tst_QQmlInspector::showAppOnTop()
 {
-    startQmlProcess("qtquick2.qml");
+    QCOMPARE(startQmlProcess("qtquick2.qml"), ConnectSuccess);
     QVERIFY(m_client);
     QTRY_COMPARE(m_client->state(), QQmlDebugClient::Enabled);
 
@@ -196,7 +172,7 @@ void tst_QQmlInspector::showAppOnTop()
 
 void tst_QQmlInspector::setAnimationSpeed()
 {
-    startQmlProcess("qtquick2.qml");
+    QCOMPARE(startQmlProcess("qtquick2.qml"), ConnectSuccess);
     QVERIFY(m_client);
     QTRY_COMPARE(m_client->state(), QQmlDebugClient::Enabled);
     checkAnimationSpeed(10);
diff --git a/tests/auto/qml/debugger/qqmlprofilerservice/qqmlprofilerservice.pro b/tests/auto/qml/debugger/qqmlprofilerservice/qqmlprofilerservice.pro
index 8b8bdfe54b..95d743e9ff 100644
--- a/tests/auto/qml/debugger/qqmlprofilerservice/qqmlprofilerservice.pro
+++ b/tests/auto/qml/debugger/qqmlprofilerservice/qqmlprofilerservice.pro
@@ -8,7 +8,7 @@ include(../shared/debugutil.pri)
 
 TESTDATA = data/*
 
-QT += core qml testlib testlib-private gui-private core-private
+QT += core qml testlib gui-private core-private
 
 OTHER_FILES += \
     data/pixmapCacheTest.qml \
diff --git a/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp b/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp
index a3873bd99e..45e4ad1207 100644
--- a/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp
+++ b/tests/auto/qml/debugger/qqmlprofilerservice/tst_qqmlprofilerservice.cpp
@@ -33,12 +33,8 @@
 #include <private/qqmldebugconnection_p.h>
 
 #include <QtTest/qtest.h>
-#include <private/qtestresult_p.h>
 #include <QtCore/qlibraryinfo.h>
 
-#define STR_PORT_FROM "13773"
-#define STR_PORT_TO "13783"
-
 struct QQmlProfilerData
 {
     QQmlProfilerData(qint64 time = -2, int messageType = -1, int detailType = -1,
@@ -258,24 +254,11 @@ void QQmlProfilerTestClient::complete()
     emit recordingFinished();
 }
 
-class tst_QQmlProfilerService : public QQmlDataTest
+class tst_QQmlProfilerService : public QQmlDebugTest
 {
     Q_OBJECT
 
-public:
-    tst_QQmlProfilerService()
-        : m_process(0)
-        , m_connection(0)
-        , m_client(0)
-    {
-    }
-
-
 private:
-    QQmlDebugProcess *m_process;
-    QQmlDebugConnection *m_connection;
-    QQmlProfilerTestClient *m_client;
-
     enum MessageListType {
         MessageListQML,
         MessageListJavaScript,
@@ -294,23 +277,17 @@ private:
         CheckAll = CheckMessageType | CheckDetailType | CheckLine | CheckColumn | CheckDataEndsWith
     };
 
-    enum ConnectResult
-    {
-        ConnectSuccess,
-        ProcessFailed,
-        ClientFailed,
-        EnableFailed,
-        RestrictFailed
-    };
-
     ConnectResult connect(bool block, const QString &testFile, bool restrictServices = true);
     void checkTraceReceived();
     void checkJsHeap();
     bool verify(MessageListType type, int expectedPosition, const QQmlProfilerData &expected,
                 quint32 checks);
 
+    QList<QQmlDebugClient *> createClients() override;
+    QPointer<QQmlProfilerTestClient> m_client;
+
 private slots:
-    void cleanup();
+    void cleanup() override;
 
     void connect_data();
     void connect();
@@ -325,65 +302,13 @@ private slots:
 
 #define VERIFY(type, position, expected, checks) QVERIFY(verify(type, position, expected, checks))
 
-template<typename F>
-struct Finalizer {
-    F m_lambda;
-    Finalizer(F &&lambda) : m_lambda(std::forward<F>(lambda)) {}
-    ~Finalizer() { m_lambda(); }
-};
-
-template<typename F>
-static Finalizer<F> defer(F &&lambda)
-{
-    return Finalizer<F>(std::forward<F>(lambda));
-}
-
-tst_QQmlProfilerService::ConnectResult tst_QQmlProfilerService::connect(
-        bool block, const QString &testFile, bool restrictServices)
+QQmlDebugTest::ConnectResult tst_QQmlProfilerService::connect(bool block, const QString &file,
+                                                              bool restrictServices)
 {
     // ### Still using qmlscene due to QTBUG-33377
-    const QString executable = QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmlscene";
-    QStringList arguments;
-    arguments << QString::fromLatin1("-qmljsdebugger=port:%1,%2%3%4")
-                 .arg(STR_PORT_FROM).arg(STR_PORT_TO)
-                 .arg(block ? QStringLiteral(",block") : QString())
-                 .arg(restrictServices ? QStringLiteral(",services:CanvasFrameRate") : QString())
-              << QQmlDataTest::instance()->testFile(testFile);
-
-    QScopedPointer<QQmlDebugProcess> process;
-    process.reset(new QQmlDebugProcess(executable, this));
-    process->start(QStringList() << arguments);
-    if (!process->waitForSessionStart()) {
-        qDebug("Could not launch application, or did not get 'Waiting for connection'.");
-        return ProcessFailed;
-    }
-
-    m_process = process.take();
-
-    m_connection = new QQmlDebugConnection();
-    m_client = new QQmlProfilerTestClient(m_connection);
-    if (!m_client)
-        return ClientFailed;
-
-    QList<QQmlDebugClient *> others = QQmlDebugTest::createOtherClients(m_connection);
-    auto deleter = defer([&others]() { qDeleteAll(others); });
-    Q_UNUSED(deleter);
-
-    const int port = m_process->debugPort();
-    m_connection->connectToHost(QLatin1String("127.0.0.1"), port);
-    for (int tries = 0; tries < 100 && m_client->state() != QQmlDebugClient::Enabled; ++tries)
-        QTest::qWait(50);
-    if (m_client->state() != QQmlDebugClient::Enabled)
-        return EnableFailed;
-
-    const QQmlDebugClient::State expectedState = restrictServices ? QQmlDebugClient::Unavailable
-                                                                  : QQmlDebugClient::Enabled;
-    for (QQmlDebugClient *other : others) {
-        if (other->state() != expectedState)
-            return RestrictFailed;
-    }
-
-    return ConnectSuccess;
+    return QQmlDebugTest::connect(QLibraryInfo::location(QLibraryInfo::BinariesPath) + "/qmlscene",
+                                  restrictServices ? QStringLiteral("CanvasFrameRate") : QString(),
+                                  testFile(file), block);
 }
 
 void tst_QQmlProfilerService::checkTraceReceived()
@@ -518,6 +443,12 @@ bool tst_QQmlProfilerService::verify(tst_QQmlProfilerService::MessageListType ty
     return false;
 }
 
+QList<QQmlDebugClient *> tst_QQmlProfilerService::createClients()
+{
+    m_client = new QQmlProfilerTestClient(m_connection);
+    return QList<QQmlDebugClient *>({m_client});
+}
+
 void tst_QQmlProfilerService::cleanup()
 {
     if (m_client && QTest::currentTestFailed()) {
@@ -555,17 +486,9 @@ void tst_QQmlProfilerService::cleanup()
             qDebug() << i++ << data.time << data.messageType << data.detailType;
         }
         qDebug() << " ";
-        qDebug() << "Process State:" << (m_process ? m_process->state() : QLatin1String("null"));
-        qDebug() << "Application Output:" << (m_process ? m_process->output() : QLatin1String("null"));
-        qDebug() << "Connection State:" << QQmlDebugTest::connectionStateString(m_connection);
-        qDebug() << "Client State:" << QQmlDebugTest::clientStateString(m_client);
     }
-    delete m_process;
-    m_process = 0;
-    delete m_client;
-    m_client = 0;
-    delete m_connection;
-    m_connection = 0;
+
+    QQmlDebugTest::cleanup();
 }
 
 void tst_QQmlProfilerService::connect_data()
diff --git a/tests/auto/qml/debugger/shared/debugutil.cpp b/tests/auto/qml/debugger/shared/debugutil.cpp
index 7b9e935678..d3bb25ee89 100644
--- a/tests/auto/qml/debugger/shared/debugutil.cpp
+++ b/tests/auto/qml/debugger/shared/debugutil.cpp
@@ -302,3 +302,115 @@ void QQmlDebugProcess::processError(QProcess::ProcessError error)
 
     m_eventLoop.exit();
 }
+
+template<typename F>
+struct Finalizer {
+    F m_lambda;
+    Finalizer(F &&lambda) : m_lambda(std::forward<F>(lambda)) {}
+    ~Finalizer() { m_lambda(); }
+};
+
+template<typename F>
+static Finalizer<F> defer(F &&lambda)
+{
+    return Finalizer<F>(std::forward<F>(lambda));
+}
+
+QQmlDebugTest::ConnectResult QQmlDebugTest::connect(
+        const QString &executable, const QString &services, const QString &extraArgs,
+        bool block)
+{
+    QStringList arguments;
+    arguments << QString::fromLatin1("-qmljsdebugger=port:13773,13783%3%4")
+                 .arg(block ? QStringLiteral(",block") : QString())
+                 .arg(services.isEmpty() ? services : (QStringLiteral(",services:") + services))
+              << extraArgs;
+
+    m_process = createProcess(executable);
+    if (!m_process)
+        return ProcessFailed;
+
+    m_process->start(QStringList() << arguments);
+    if (!m_process->waitForSessionStart())
+        return SessionFailed;
+
+    m_connection = createConnection();
+    if (!m_connection)
+        return ConnectionFailed;
+
+    m_clients = createClients();
+    if (m_clients.contains(nullptr))
+        return ClientsFailed;
+
+    auto allEnabled = [this]() {
+        for (QQmlDebugClient *client : m_clients) {
+            if (client->state() != QQmlDebugClient::Enabled)
+                return false;
+        }
+        return true;
+    };
+
+    QList<QQmlDebugClient *> others = createOtherClients(m_connection);
+    auto deleter = defer([&others]() { qDeleteAll(others); });
+    Q_UNUSED(deleter);
+
+    const int port = m_process->debugPort();
+    m_connection->connectToHost(QLatin1String("127.0.0.1"), port);
+    for (int tries = 0; tries < 100 && !allEnabled(); ++tries)
+        QTest::qWait(50);
+    if (!allEnabled())
+        return EnableFailed;
+
+    const QQmlDebugClient::State expectedState = services.isEmpty() ? QQmlDebugClient::Enabled
+                                                                    : QQmlDebugClient::Unavailable;
+    for (QQmlDebugClient *other : others) {
+        if (other->state() != expectedState)
+            return RestrictFailed;
+    }
+
+    return ConnectSuccess;
+}
+
+QList<QQmlDebugClient *> QQmlDebugTest::createClients()
+{
+    return QList<QQmlDebugClient *>();
+}
+
+QQmlDebugProcess *QQmlDebugTest::createProcess(const QString &executable)
+{
+    return new QQmlDebugProcess(executable, this);
+}
+
+QQmlDebugConnection *QQmlDebugTest::createConnection()
+{
+    return new QQmlDebugConnection(this);
+}
+
+void QQmlDebugTest::cleanup()
+{
+    if (QTest::currentTestFailed()) {
+        const QString null = QStringLiteral("null");
+
+        qDebug() << "Process State:" << (m_process ? m_process->state() : null);
+        qDebug() << "Application Output:" << (m_process ? m_process->output() : null);
+        qDebug() << "Connection State:" << QQmlDebugTest::connectionStateString(m_connection);
+        for (QQmlDebugClient *client : m_clients) {
+            if (client)
+                qDebug() << client->name() << "State:" << QQmlDebugTest::clientStateString(client);
+            else
+                qDebug() << "Failed Client:" << null;
+        }
+    }
+
+    qDeleteAll(m_clients);
+    m_clients.clear();
+
+    delete m_connection;
+    m_connection = nullptr;
+
+    if (m_process) {
+        m_process->stop();
+        delete m_process;
+        m_process = nullptr;
+    }
+}
diff --git a/tests/auto/qml/debugger/shared/debugutil_p.h b/tests/auto/qml/debugger/shared/debugutil_p.h
index 1ec0a6513d..f1b25d5f6d 100644
--- a/tests/auto/qml/debugger/shared/debugutil_p.h
+++ b/tests/auto/qml/debugger/shared/debugutil_p.h
@@ -41,6 +41,7 @@
 // We mean it.
 //
 
+#include <../../../shared/util.h>
 #include <private/qqmldebugclient_p.h>
 
 #include <QtCore/qeventloop.h>
@@ -51,13 +52,40 @@
 #include <QtTest/qtest.h>
 #include <QtQml/qqmlengine.h>
 
-class QQmlDebugTest
+class QQmlDebugProcess;
+class QQmlDebugTest : public QQmlDataTest
 {
+    Q_OBJECT
 public:
     static bool waitForSignal(QObject *receiver, const char *member, int timeout = 5000);
     static QList<QQmlDebugClient *> createOtherClients(QQmlDebugConnection *connection);
     static QString clientStateString(const QQmlDebugClient *client);
     static QString connectionStateString(const QQmlDebugConnection *connection);
+
+protected:
+    enum ConnectResult {
+        ConnectSuccess,
+        ProcessFailed,
+        SessionFailed,
+        ConnectionFailed,
+        ClientsFailed,
+        EnableFailed,
+        RestrictFailed
+    };
+
+    ConnectResult connect(const QString &executable, const QString &services,
+                          const QString &extraArgs, bool block);
+
+    virtual QQmlDebugProcess *createProcess(const QString &executable);
+    virtual QQmlDebugConnection *createConnection();
+    virtual QList<QQmlDebugClient *> createClients();
+
+    QQmlDebugProcess *m_process = nullptr;
+    QQmlDebugConnection *m_connection = nullptr;
+    QList<QQmlDebugClient *> m_clients;
+
+protected slots:
+    virtual void cleanup();
 };
 
 class QQmlDebugTestClient : public QQmlDebugClient