Get rid of all uses of QMediaServiceProvider

In addition, clean up the multitude of mock services
and unify them. We'll probably still fail tons of
auto tests, but this does start making more sense
nevertheless.

Change-Id: I4bf7f19db98e02566b4285e4ab8c850ee0e4a0c7
Reviewed-by: Doris Verria <doris.verria@qt.io>
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

20 files changed, 317 insertions, 1102 deletions

diff --git a/tests/auto/unit/mockbackend/CMakeLists.txt b/tests/auto/unit/mockbackend/CMakeLists.txt
index 96fa6718d..c098e8e56 100644
--- a/tests/auto/unit/mockbackend/CMakeLists.txt
+++ b/tests/auto/unit/mockbackend/CMakeLists.txt
@@ -22,7 +22,6 @@ target_sources(QtMultimediaMockBackend INTERFACE
     mockcamerafocuscontrol.h
     mockcameraimagecapturecontrol.h
     mockcameraimageprocessingcontrol.h
-    mockcameraservice.h
     mockimageencodercontrol.h
     mockmediacontainercontrol.h
     mockmediaplayercontrol.h
diff --git a/tests/auto/unit/mockbackend/capture.pri b/tests/auto/unit/mockbackend/capture.pri
index 29704d7ff..549ac7978 100644
--- a/tests/auto/unit/mockbackend/capture.pri
+++ b/tests/auto/unit/mockbackend/capture.pri
@@ -5,7 +5,6 @@ HEADERS *= \
     $$PWD/mockcamerafocuscontrol.h \
     $$PWD/mockcameraimagecapturecontrol.h \
     $$PWD/mockcameraimageprocessingcontrol.h \
-    $$PWD/mockcameraservice.h \
     $$PWD/mockimageencodercontrol.h \
     $$PWD/mockmediacontainercontrol.h \
     $$PWD/mockmediarecordercontrol.h \
diff --git a/tests/auto/unit/mockbackend/mockcameraservice.h b/tests/auto/unit/mockbackend/mockcameraservice.h
deleted file mode 100644
index 8d3f2a238..000000000
--- a/tests/auto/unit/mockbackend/mockcameraservice.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the test suite of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef MOCKCAMERASERVICE_H
-#define MOCKCAMERASERVICE_H
-
-#include "qmediaservice.h"
-#include "mockcamerafocuscontrol.h"
-#include "mockcameraimageprocessingcontrol.h"
-#include "mockcameraimagecapturecontrol.h"
-#include "mockcameraexposurecontrol.h"
-#include "mockimageencodercontrol.h"
-#include "mockcameracontrol.h"
-#include "mockvideosurface.h"
-#include "mockvideorenderercontrol.h"
-#include "mockvideowindowcontrol.h"
-#include "mockvideodeviceselectorcontrol.h"
-
-class MockSimpleCameraService : public QMediaService
-{
-    Q_OBJECT
-
-public:
-    MockSimpleCameraService(): QMediaService(0)
-    {
-        mockControl = new MockCameraControl(this);
-    }
-
-    ~MockSimpleCameraService()
-    {
-    }
-
-    QObject *requestControl(const char *iid)
-    {
-        if (qstrcmp(iid, QCameraControl_iid) == 0)
-            return mockControl;
-        return 0;
-    }
-
-    void releaseControl(QObject *) {}
-
-    MockCameraControl *mockControl;
-};
-
-
-class MockCameraService : public QMediaService
-{
-    Q_OBJECT
-
-public:
-    MockCameraService(): QMediaService(0)
-    {
-        mockControl = new MockCameraControl(this);
-        mockExposureControl = new MockCameraExposureControl(this);
-        mockFocusControl = new MockCameraFocusControl(this);
-        mockCaptureControl = new MockCaptureControl(mockControl, this);
-        mockImageProcessingControl = new MockImageProcessingControl(this);
-        mockImageEncoderControl = new MockImageEncoderControl(this);
-        rendererControl = new MockVideoRendererControl(this);
-        windowControl = new MockVideoWindowControl(this);
-        mockVideoDeviceSelectorControl = new MockVideoDeviceSelectorControl(this);
-        rendererRef = 0;
-        windowRef = 0;
-    }
-
-    ~MockCameraService()
-    {
-    }
-
-    QObject *requestControl(const char *iid)
-    {
-        if (qstrcmp(iid, QCameraControl_iid) == 0)
-            return mockControl;
-
-        if (qstrcmp(iid, QCameraExposureControl_iid) == 0)
-            return mockExposureControl;
-
-        if (qstrcmp(iid, QCameraFocusControl_iid) == 0)
-            return mockFocusControl;
-
-        if (qstrcmp(iid, QCameraImageCaptureControl_iid) == 0)
-            return mockCaptureControl;
-
-        if (qstrcmp(iid, QCameraImageProcessingControl_iid) == 0)
-            return mockImageProcessingControl;
-
-        if (qstrcmp(iid, QImageEncoderControl_iid) == 0)
-            return mockImageEncoderControl;
-
-        if (qstrcmp(iid, QVideoDeviceSelectorControl_iid) == 0)
-            return mockVideoDeviceSelectorControl;
-
-        if (qstrcmp(iid, QVideoRendererControl_iid) == 0) {
-            if (rendererRef == 0) {
-                rendererRef += 1;
-                return rendererControl;
-            }
-        }
-        if (qstrcmp(iid, QVideoWindowControl_iid) == 0) {
-            if (windowRef == 0) {
-                windowRef += 1;
-                return windowControl;
-            }
-        }
-
-        return 0;
-    }
-
-    void releaseControl(QObject *control)
-    {
-        if (control == rendererControl)
-            rendererRef -= 1;
-        if (control == windowControl)
-            windowRef -= 1;
-    }
-
-    MockCameraControl *mockControl;
-    MockCaptureControl *mockCaptureControl;
-    MockCameraExposureControl *mockExposureControl;
-    MockCameraFocusControl *mockFocusControl;
-    MockImageProcessingControl *mockImageProcessingControl;
-    MockImageEncoderControl *mockImageEncoderControl;
-    MockVideoRendererControl *rendererControl;
-    MockVideoWindowControl *windowControl;
-    MockVideoDeviceSelectorControl *mockVideoDeviceSelectorControl;
-    int rendererRef;
-    int windowRef;
-};
-
-#endif // MOCKCAMERASERVICE_H
diff --git a/tests/auto/unit/mockbackend/mockmediaplayercontrol.h b/tests/auto/unit/mockbackend/mockmediaplayercontrol.h
index 1e7edb92d..924358095 100644
--- a/tests/auto/unit/mockbackend/mockmediaplayercontrol.h
+++ b/tests/auto/unit/mockbackend/mockmediaplayercontrol.h
@@ -56,9 +56,23 @@ public:
     {}
 
     QMediaPlayer::State state() const { return _state; }
+    void updateState(QMediaPlayer::State state) { emit stateChanged(_state = state); }
     QMediaPlayer::MediaStatus mediaStatus() const { return _mediaStatus; }
+    void updateMediaStatus(QMediaPlayer::MediaStatus status)
+    {
+        emit mediaStatusChanged(_mediaStatus = status);
+    }
+    void updateMediaStatus(QMediaPlayer::MediaStatus status, QMediaPlayer::State state)
+    {
+        _mediaStatus = status;
+        _state = state;
+
+        emit mediaStatusChanged(_mediaStatus);
+        emit stateChanged(_state);
+    }
 
     qint64 duration() const { return _duration; }
+    void setDuration(qint64 duration) { emit durationChanged(_duration = duration); }
 
     qint64 position() const { return _position; }
 
@@ -71,11 +85,14 @@ public:
     void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }
 
     int bufferStatus() const { return _bufferStatus; }
+    void setBufferStatus(int status) { emit bufferStatusChanged(_bufferStatus = status); }
 
     bool isAudioAvailable() const { return _audioAvailable; }
     bool isVideoAvailable() const { return _videoAvailable; }
 
     bool isSeekable() const { return _isSeekable; }
+    void setSeekable(bool seekable) { emit seekableChanged(_isSeekable = seekable); }
+
     QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(_seekRange.first, _seekRange.second); }
     void setSeekRange(qint64 minimum, qint64 maximum) { _seekRange = qMakePair(minimum, maximum); }
 
@@ -127,6 +144,11 @@ public:
                              << QStringLiteral("customRole2");
     }
 
+    void emitError(QMediaPlayer::Error err, const QString &errorString)
+    {
+        emit error(err, errorString);
+    }
+
     bool hasAudioRole = true;
     bool hasCustomAudioRole = true;
     QAudio::Role m_audioRole = QAudio::UnknownRole;
diff --git a/tests/auto/unit/mockbackend/mockmediaplayerservice.h b/tests/auto/unit/mockbackend/mockmediaplayerservice.h
index 483d21e8e..9f4332e32 100644
--- a/tests/auto/unit/mockbackend/mockmediaplayerservice.h
+++ b/tests/auto/unit/mockbackend/mockmediaplayerservice.h
@@ -36,6 +36,7 @@
 #include "mockvideorenderercontrol.h"
 #include "mockvideoprobecontrol.h"
 #include "mockvideowindowcontrol.h"
+#include "mockmetadatareadercontrol.h"
 
 class MockMediaPlayerService : public QMediaPlatformPlayerInterface
 {
@@ -50,6 +51,7 @@ public:
         rendererRef = 0;
         mockVideoProbeControl = new MockVideoProbeControl;
         windowControl = new MockVideoWindowControl;
+        metaDataControl = new MockMetaDataReaderControl;
         windowRef = 0;
     }
 
@@ -80,6 +82,8 @@ public:
                 return windowControl;
             }
         }
+        if (qstrcmp(iid, QMetaDataReaderControl_iid) == 0)
+            return metaDataControl;
 
         return 0;
     }
@@ -92,7 +96,7 @@ public:
             windowRef -= 1;
     }
 
-    QMediaPlayerControl *player() { return mockControl; }
+    MockMediaPlayerControl *player() { return mockControl; }
     QMetaDataReaderControl *dataReader() { return nullptr; } // ###
 
     QMediaStreamsControl *streams() { return nullptr; } // ###
@@ -151,6 +155,7 @@ public:
     MockVideoRendererControl *rendererControl;
     MockVideoProbeControl *mockVideoProbeControl;
     MockVideoWindowControl *windowControl;
+    MockMetaDataReaderControl *metaDataControl;
     int windowRef;
     int rendererRef;
 };
diff --git a/tests/auto/unit/mockbackend/mockmediarecorderservice.h b/tests/auto/unit/mockbackend/mockmediarecorderservice.h
index 38530f908..50e68efca 100644
--- a/tests/auto/unit/mockbackend/mockmediarecorderservice.h
+++ b/tests/auto/unit/mockbackend/mockmediarecorderservice.h
@@ -37,6 +37,15 @@
 #include "mockmediacontainercontrol.h"
 #include "mockmetadatawritercontrol.h"
 #include "mockaudioprobecontrol.h"
+#include "mockcamerafocuscontrol.h"
+#include "mockcameraimageprocessingcontrol.h"
+#include "mockcameraimagecapturecontrol.h"
+#include "mockcameraexposurecontrol.h"
+#include "mockimageencodercontrol.h"
+#include "mockcameracontrol.h"
+#include "mockvideorenderercontrol.h"
+#include "mockvideowindowcontrol.h"
+#include "mockvideodeviceselectorcontrol.h"
 #include <private/qmediaplatformcaptureinterface_p.h>
 
 class MockMediaRecorderService : public QMediaPlatformCaptureInterface
@@ -52,30 +61,94 @@ public:
         mockVideoEncoderControl = new MockVideoEncoderControl(this);
         mockMetaDataControl = new MockMetaDataWriterControl(this);
         mockAudioProbeControl = new MockAudioProbeControl(this);
+        mockCameraControl = new MockCameraControl(this);
+        mockExposureControl = new MockCameraExposureControl(this);
+        mockFocusControl = new MockCameraFocusControl(this);
+        mockCaptureControl = new MockCaptureControl(mockCameraControl, this);
+        mockImageProcessingControl = new MockImageProcessingControl(this);
+        mockImageEncoderControl = new MockImageEncoderControl(this);
+        rendererControl = new MockVideoRendererControl(this);
+        windowControl = new MockVideoWindowControl(this);
+        mockVideoDeviceSelectorControl = new MockVideoDeviceSelectorControl(this);
+        rendererRef = 0;
+        windowRef = 0;
     }
 
     QObject *requestControl(const char *name)
     {
-        if (hasControls && qstrcmp(name,QAudioEncoderSettingsControl_iid) == 0)
+        if (!hasControls)
+            return nullptr;
+
+        if (qstrcmp(name,QAudioEncoderSettingsControl_iid) == 0)
             return mockAudioEncoderControl;
-        if (hasControls && qstrcmp(name,QMediaRecorderControl_iid) == 0)
+        if (qstrcmp(name,QMediaRecorderControl_iid) == 0)
             return mockControl;
-        if (hasControls && qstrcmp(name,QMediaContainerControl_iid) == 0)
+        if (qstrcmp(name,QMediaContainerControl_iid) == 0)
             return mockFormatControl;
-        if (hasControls && qstrcmp(name,QVideoEncoderSettingsControl_iid) == 0)
+        if (qstrcmp(name,QVideoEncoderSettingsControl_iid) == 0)
             return mockVideoEncoderControl;
-        if (hasControls && qstrcmp(name, QMetaDataWriterControl_iid) == 0)
+        if (qstrcmp(name, QMetaDataWriterControl_iid) == 0)
             return mockMetaDataControl;
-        if (hasControls && qstrcmp(name, QMediaAudioProbeControl_iid) == 0)
+        if (qstrcmp(name, QMediaAudioProbeControl_iid) == 0)
             return mockAudioProbeControl;
 
-        return 0;
+        if (qstrcmp(name, QCameraControl_iid) == 0)
+            return mockCameraControl;
+
+        if (simpleCamera)
+            return nullptr;
+
+        if (qstrcmp(name, QCameraExposureControl_iid) == 0)
+            return mockExposureControl;
+        if (qstrcmp(name, QCameraFocusControl_iid) == 0)
+            return mockFocusControl;
+        if (qstrcmp(name, QCameraImageCaptureControl_iid) == 0)
+            return mockCaptureControl;
+        if (qstrcmp(name, QCameraImageProcessingControl_iid) == 0)
+            return mockImageProcessingControl;
+        if (qstrcmp(name, QImageEncoderControl_iid) == 0)
+            return mockImageEncoderControl;
+        if (qstrcmp(name, QVideoDeviceSelectorControl_iid) == 0)
+            return mockVideoDeviceSelectorControl;
+
+        if (qstrcmp(name, QVideoRendererControl_iid) == 0) {
+            if (rendererRef == 0) {
+                rendererRef += 1;
+                return rendererControl;
+            }
+        }
+        if (qstrcmp(name, QVideoWindowControl_iid) == 0) {
+            if (windowRef == 0) {
+                windowRef += 1;
+                return windowControl;
+            }
+        }
+
+        return nullptr;
     }
 
-    void releaseControl(QObject *)
+    void releaseControl(QObject *control)
     {
+        if (control == rendererControl)
+            rendererRef -= 1;
+        if (control == windowControl)
+            windowRef -= 1;
     }
 
+    static bool simpleCamera;
+
+    MockCameraControl *mockCameraControl;
+    MockCaptureControl *mockCaptureControl;
+    MockCameraExposureControl *mockExposureControl;
+    MockCameraFocusControl *mockFocusControl;
+    MockImageProcessingControl *mockImageProcessingControl;
+    MockImageEncoderControl *mockImageEncoderControl;
+    MockVideoRendererControl *rendererControl;
+    MockVideoWindowControl *windowControl;
+    MockVideoDeviceSelectorControl *mockVideoDeviceSelectorControl;
+    int rendererRef;
+    int windowRef;
+
     MockMediaRecorderControl *mockControl;
     QAudioEncoderSettingsControl *mockAudioEncoderControl;
     QMediaContainerControl *mockFormatControl;
diff --git a/tests/auto/unit/mockbackend/qmockintegration.cpp b/tests/auto/unit/mockbackend/qmockintegration.cpp
index 16f9956f1..92c612f60 100644
--- a/tests/auto/unit/mockbackend/qmockintegration.cpp
+++ b/tests/auto/unit/mockbackend/qmockintegration.cpp
@@ -91,4 +91,6 @@ QMediaPlatformCaptureInterface *QMockIntegration::createCaptureInterface(QMediaP
     return m_lastCaptureService;
 }
 
+bool MockMediaRecorderService::simpleCamera = false;
+
 QT_END_NAMESPACE
diff --git a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
index d942ec3db..ed288ca16 100644
--- a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
+++ b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
@@ -45,12 +45,12 @@
 #include <qvideorenderercontrol.h>
 #include <qmediadevicemanager.h>
 
-#include "mockcameraservice.h"
-
 #include "mockmediaserviceprovider.h"
 #include "mockvideosurface.h"
 #include "mockvideorenderercontrol.h"
 #include "mockvideowindowcontrol.h"
+#include "qmockintegration_p.h"
+#include "mockmediarecorderservice.h"
 
 QT_USE_NAMESPACE
 
@@ -133,7 +133,6 @@ private slots:
     void testIsAvailable();
     void testSaturation();
     void testSharpeningLevel();
-    void testEnumOfQCameraImageProcessing();
 
     void testSetVideoOutput();
     void testSetVideoOutputNoService();
@@ -156,9 +155,7 @@ private slots:
     void testExposureControlConstructor();
 
 private:
-    MockSimpleCameraService  *mockSimpleCameraService;
-    MockCameraService *mockCameraService;
-    MockMediaServiceProvider *provider;
+    QMockIntegration *integration;
 };
 
 Q_DECLARE_METATYPE(QCamera::FrameRateRange)
@@ -166,30 +163,23 @@ Q_DECLARE_METATYPE(QCamera::FrameRateRange)
 void tst_QCamera::initTestCase()
 {
     qRegisterMetaType<QCamera::FrameRateRange>("FrameRateRange");
+    MockMediaRecorderService::simpleCamera = false;
 }
 
 void tst_QCamera::init()
 {
-    provider = new MockMediaServiceProvider;
-    mockSimpleCameraService = new MockSimpleCameraService;
-    mockCameraService = new MockCameraService;
-
-    provider->service = mockCameraService;
-    QMediaServiceProvider::setDefaultServiceProvider(provider);
+    integration = new QMockIntegration;
 }
 
 void tst_QCamera::cleanup()
 {
-    delete provider;
-    delete mockCameraService;
-    delete mockSimpleCameraService;
+    delete integration;
 }
 
 void tst_QCamera::testSimpleCamera()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
     QCamera camera;
-    QCOMPARE(camera.service(), (QMediaService*)mockSimpleCameraService);
 
     QCOMPARE(camera.state(), QCamera::UnloadedState);
     camera.start();
@@ -204,7 +194,7 @@ void tst_QCamera::testSimpleCamera()
 
 void tst_QCamera::testSimpleCameraWhiteBalance()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
     QCamera camera;
 
     //only WhiteBalanceAuto is supported
@@ -220,7 +210,8 @@ void tst_QCamera::testSimpleCameraWhiteBalance()
 
 void tst_QCamera::testSimpleCameraExposure()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
+
     QCamera camera;
     QCameraExposure *cameraExposure = camera.exposure();
     QVERIFY(cameraExposure != nullptr);
@@ -264,7 +255,8 @@ void tst_QCamera::testSimpleCameraExposure()
 
 void tst_QCamera::testSimpleCameraFocus()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
+
     QCamera camera;
 
     QCameraFocus *cameraFocus = camera.focus();
@@ -305,7 +297,8 @@ void tst_QCamera::testSimpleCameraFocus()
 
 void tst_QCamera::testSimpleCameraCapture()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
+
     QCamera camera;
     QCameraImageCapture imageCapture(&camera);
 
@@ -324,7 +317,8 @@ void tst_QCamera::testSimpleCameraCapture()
 
 void tst_QCamera::testSimpleCameraLock()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
+
     QCamera camera;
     QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
     QCOMPARE(camera.lockStatus(QCamera::LockExposure), QCamera::Unlocked);
@@ -361,7 +355,8 @@ void tst_QCamera::testSimpleCameraLock()
 
 void tst_QCamera::testSimpleCaptureDestination()
 {
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
+
     QCamera camera;
     QCameraImageCapture imageCapture(&camera);
 
@@ -458,16 +453,14 @@ void tst_QCamera::testCameraWhiteBalance()
     whiteBalanceModes << QCameraImageProcessing::WhiteBalanceFlash;
     whiteBalanceModes << QCameraImageProcessing::WhiteBalanceTungsten;
 
-    MockCameraService service;
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFlash);
-    service.mockImageProcessingControl->setSupportedWhiteBalanceModes(whiteBalanceModes);
-    service.mockImageProcessingControl->setParameter(
+    QCamera camera;
+    auto *service = integration->lastCaptureService();
+    service->mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFlash);
+    service->mockImageProcessingControl->setSupportedWhiteBalanceModes(whiteBalanceModes);
+    service->mockImageProcessingControl->setParameter(
                 QCameraImageProcessingControl::ColorTemperature,
                 QVariant(34));
 
-    provider->service = &service;
-
-    QCamera camera;
     QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
 
     QCOMPARE(cameraImageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceFlash);
@@ -1099,9 +1092,10 @@ void tst_QCamera::testSupportedViewfinderSettings()
     QFETCH(QList<int>, expectedSupportedSettings);
 
     QList<QCameraViewfinderSettings> actualSupportedSettings = QCamera().supportedViewfinderSettings(settings);
+    auto *service = integration->lastCaptureService();
     QCOMPARE(actualSupportedSettings.size(), expectedSupportedSettings.size());
     for (int i = 0; i < expectedSupportedSettings.size(); ++i) {
-        QCameraViewfinderSettings expectedSettings = mockCameraService->mockControl->supportedSettings.at(expectedSupportedSettings.at(i));
+        QCameraViewfinderSettings expectedSettings = service->mockCameraControl->supportedSettings.at(expectedSupportedSettings.at(i));
         QCOMPARE(actualSupportedSettings.at(i), expectedSettings);
     }
 }
@@ -1411,8 +1405,6 @@ void tst_QCamera::testCameraLock()
 
 void tst_QCamera::testCameraLockCancel()
 {
-    MockCameraService service;
-    provider->service = &service;
     QCamera camera;
 
     camera.focus()->setFocusMode(QCameraFocus::AutoFocus);
@@ -1530,6 +1522,7 @@ void tst_QCamera::testSetVideoOutput()
 {
     MockVideoSurface surface;
     QCamera camera;
+    auto *mockCameraService = integration->lastCaptureService();
 
     camera.setViewfinder(static_cast<QMediaSink *>(nullptr));
 
@@ -1564,7 +1557,7 @@ void tst_QCamera::testSetVideoOutputNoService()
 {
     MockVideoSurface surface;
 
-    provider->service = nullptr;
+    integration->setFlags(QMockIntegration::NoCaptureInterface);
     QCamera camera;
 
     camera.setViewfinder(&surface);
@@ -1575,30 +1568,25 @@ void tst_QCamera::testSetVideoOutputNoControl()
 {
     MockVideoSurface surface;
 
-    MockCameraService service;
-    service.rendererRef = 1;
-    provider->service = &service;
-
     QCamera camera;
+    auto *service = integration->lastCaptureService();
+    service->rendererRef = 1;
 
     camera.setViewfinder(&surface);
-    QVERIFY(service.rendererControl->surface() == nullptr);
+    QVERIFY(service->rendererControl->surface() == nullptr);
 }
 
 void tst_QCamera::testSetVideoOutputDestruction()
 {
     MockVideoSurface surface;
-    MockCameraService service;
-    provider->service = &service;
 
     {
         QCamera camera;
+        auto *service = integration->lastCaptureService();
         camera.setViewfinder(&surface);
-        QVERIFY(service.rendererControl->surface() == &surface);
-        QCOMPARE(service.rendererRef, 1);
+        QVERIFY(service->rendererControl->surface() == &surface);
+        QCOMPARE(service->rendererRef, 1);
     }
-    QVERIFY(service.rendererControl->surface() == nullptr);
-    QCOMPARE(service.rendererRef, 0);
 }
 
 void tst_QCamera::testEnumDebug()
@@ -1632,7 +1620,8 @@ void tst_QCamera::testCameraControl()
 void tst_QCamera::testConstructor()
 {
     // Service doesn't implement QVideoDeviceSelectorControl
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
+
 
     {
         QCamera camera;
@@ -1648,30 +1637,30 @@ void tst_QCamera::testConstructor()
         QCOMPARE(camera.error(), QCamera::NoError);
     }
 
-    // Service implements QVideoDeviceSelectorControl
-    provider->service = mockCameraService;
-
     {
         QCamera camera;
+        auto *service = integration->lastCaptureService();
         QCOMPARE(camera.availability(), QMultimedia::Available);
         QCOMPARE(camera.error(), QCamera::NoError);
-        QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1); // default is 1
+        QCOMPARE(service->mockVideoDeviceSelectorControl->selectedDevice(), 1); // default is 1
     }
 
     {
         QCamera camera(QMediaDeviceManager::defaultVideoInput());
+        auto *service = integration->lastCaptureService();
         QCOMPARE(camera.availability(), QMultimedia::Available);
         QCOMPARE(camera.error(), QCamera::NoError);
-        QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
+        QCOMPARE(service->mockVideoDeviceSelectorControl->selectedDevice(), 1);
         QCOMPARE(QCameraInfo(camera), QMediaDeviceManager::defaultVideoInput());
     }
 
     {
         QCameraInfo cameraInfo = QMediaDeviceManager::videoInputs().at(0);
         QCamera camera(cameraInfo);
+        auto *service = integration->lastCaptureService();
         QCOMPARE(camera.availability(), QMultimedia::Available);
         QCOMPARE(camera.error(), QCamera::NoError);
-        QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 0);
+        QCOMPARE(service->mockVideoDeviceSelectorControl->selectedDevice(), 0);
         QCOMPARE(QCameraInfo(camera), cameraInfo);
     }
 
@@ -1679,24 +1668,27 @@ void tst_QCamera::testConstructor()
         // Requesting a camera at a position which is not available should result in
         // loading the default camera
         QCamera camera(QCamera::FrontFace);
+        auto *service = integration->lastCaptureService();
         QCOMPARE(camera.availability(), QMultimedia::Available);
         QCOMPARE(camera.error(), QCamera::NoError);
-        QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
+        QCOMPARE(service->mockVideoDeviceSelectorControl->selectedDevice(), 1);
     }
 
     {
         QCamera camera(QCamera::BackFace);
+        auto *service = integration->lastCaptureService();
         QCOMPARE(camera.availability(), QMultimedia::Available);
         QCOMPARE(camera.error(), QCamera::NoError);
-        QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 0);
+        QCOMPARE(service->mockVideoDeviceSelectorControl->selectedDevice(), 0);
     }
 
     {
         // Should load the default camera when UnspecifiedPosition is requested
         QCamera camera(QCamera::UnspecifiedPosition);
+        auto *service = integration->lastCaptureService();
         QCOMPARE(camera.availability(), QMultimedia::Available);
         QCOMPARE(camera.error(), QCamera::NoError);
-        QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
+        QCOMPARE(service->mockVideoDeviceSelectorControl->selectedDevice(), 1);
     }
 }
 
@@ -1781,12 +1773,13 @@ void tst_QCamera::testQCameraIsAvailable()
 
 void tst_QCamera::testQCameraIsNotAvailable()
 {
-    provider->service = nullptr;
+    integration->setFlags(QMockIntegration::NoCaptureInterface);
     QCamera camera("random");
 
     QCOMPARE(camera.error(), QCamera::CameraError);
     QVERIFY(!camera.isAvailable());
     QCOMPARE(camera.availability(), QMultimedia::ServiceMissing);
+    integration->setFlags({});
 }
 
 /* Test case for searchAndLock ( QCamera::LockTypes locks ) */
@@ -1945,15 +1938,13 @@ void tst_QCamera::testLockStatusChangedWithTypesSignal()
 /* Test case for verifying if error signal generated correctly */
 void tst_QCamera::testErrorSignal()
 {
-    MockCameraService service;
-    provider->service = &service;
-
     QCamera camera;
+    auto *service = integration->lastCaptureService();
 
     QSignalSpy spyError(&camera, SIGNAL(errorOccurred(QCamera::Error)));
 
     /* Set the QCameraControl error and verify if the signal is emitted correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("Camera Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("Camera Error"));
 
     QVERIFY(spyError.count() == 1);
     QCamera::Error err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
@@ -1962,7 +1953,7 @@ void tst_QCamera::testErrorSignal()
     spyError.clear();
 
     /* Set the QCameraControl error and verify if the signal is emitted correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("InvalidRequestError Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("InvalidRequestError Error"));
     QVERIFY(spyError.count() == 1);
     err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
     QVERIFY(err == QCamera::CameraError);
@@ -1970,7 +1961,7 @@ void tst_QCamera::testErrorSignal()
     spyError.clear();
 
     /* Set the QCameraControl error and verify if the signal is emitted correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("NotSupportedFeatureError Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("NotSupportedFeatureError Error"));
     QVERIFY(spyError.count() == 1);
     err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
     QVERIFY(err == QCamera::CameraError);
@@ -1980,21 +1971,19 @@ void tst_QCamera::testErrorSignal()
 /* Test case for verifying the QCamera error */
 void tst_QCamera::testError()
 {
-    MockCameraService service;
-    provider->service = &service;
-
     QCamera camera;
+    auto *service = integration->lastCaptureService();
 
     /* Set the QCameraControl error and verify if it is set correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("Camera Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("Camera Error"));
     QVERIFY(camera.error() == QCamera::CameraError);
 
     /* Set the QCameraControl error and verify if it is set correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("InvalidRequestError Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("InvalidRequestError Error"));
     QVERIFY(camera.error() == QCamera::CameraError);
 
     /* Set the QCameraControl error and verify if it is set correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("CameraError Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("CameraError Error"));
     QVERIFY(camera.error() == QCamera::CameraError);
 
 }
@@ -2002,46 +1991,42 @@ void tst_QCamera::testError()
 /* Test the error strings for QCamera class */
 void tst_QCamera::testErrorString()
 {
-    MockCameraService service;
-    provider->service = &service;
-
     QCamera camera;
+    auto *service = integration->lastCaptureService();
 
     /* Set the QCameraControl error and verify if it is set correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("Camera Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("Camera Error"));
     QVERIFY(camera.errorString() == QString("Camera Error"));
 
     /* Set the QCameraControl error and verify if it is set correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("InvalidRequestError Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("InvalidRequestError Error"));
     QVERIFY(camera.errorString() == QString("InvalidRequestError Error"));
 
     /* Set the QCameraControl error and verify if it is set correctly in QCamera */
-    service.mockControl->setError(QCamera::CameraError,QString("CameraError Error"));
+    service->mockCameraControl->setError(QCamera::CameraError,QString("CameraError Error"));
     QVERIFY(camera.errorString() == QString("CameraError Error"));
 }
 
 /* Test case for verifying Status of QCamera. */
 void tst_QCamera::testStatus()
 {
-    MockCameraService service;
-    provider->service = &service;
-
     QCamera camera;
+    auto *service = integration->lastCaptureService();
 
     /* Set the QCameraControl status and verify if it is set correctly in QCamera */
-    service.mockControl->setStatus(QCamera::StartingStatus);
+    service->mockCameraControl->setStatus(QCamera::StartingStatus);
     QVERIFY(camera.status() == QCamera::StartingStatus);
 
     /* Set the QCameraControl status and verify if it is set correctly in QCamera */
-    service.mockControl->setStatus(QCamera::StandbyStatus);
+    service->mockCameraControl->setStatus(QCamera::StandbyStatus);
     QVERIFY(camera.status() == QCamera::StandbyStatus);
 
     /* Set the QCameraControl status and verify if it is set correctly in QCamera */
-    service.mockControl->setStatus(QCamera::LoadingStatus);
+    service->mockCameraControl->setStatus(QCamera::LoadingStatus);
     QVERIFY(camera.status() == QCamera::LoadingStatus);
 
     /* Set the QCameraControl status and verify if it is set correctly in QCamera */
-    service.mockControl->setStatus(QCamera::UnavailableStatus);
+    service->mockCameraControl->setStatus(QCamera::UnavailableStatus);
     QVERIFY(camera.status() == QCamera::UnavailableStatus);
 }
 
@@ -2056,15 +2041,13 @@ void tst_QCamera::testLockType()
 /* Test case for QCamera::LockChangeReason with QCamera::LockAcquired */
 void tst_QCamera::testLockChangeReason()
 {
-    MockCameraService service;
-    provider->service = &service;
-
     QCamera camera;
+    auto *service = integration->lastCaptureService();
 
     QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
 
     /* Set the lockChangeReason */
-    service.mockControl->setLockChangeReason(QCamera::LockAcquired);
+    service->mockCameraControl->setLockChangeReason(QCamera::LockAcquired);
 
     /* Verify if lockChangeReson is eqaul toQCamera::LockAcquired */
     QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
@@ -2174,64 +2157,6 @@ void tst_QCamera::testSharpeningLevel()
     QCOMPARE(cameraImageProcessing->sharpeningLevel() , 0.3);
 }
 
-void tst_QCamera::testEnumOfQCameraImageProcessing()
-{
-    QSet<QCameraImageProcessing::WhiteBalanceMode> whiteBalanceModes;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceManual;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceAuto;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceSunlight;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceCloudy;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceShade;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceTungsten;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceFluorescent;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceFlash;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceSunset;
-    whiteBalanceModes << QCameraImageProcessing::WhiteBalanceVendor;
-
-    MockCameraService service;
-    service.mockImageProcessingControl->setSupportedWhiteBalanceModes(whiteBalanceModes);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceManual);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceManual));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceManual);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceAuto);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceAuto));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceAuto);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceSunlight);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceSunlight));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceSunlight);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceCloudy);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceCloudy));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceCloudy);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceShade);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceShade));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceShade);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceTungsten);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceTungsten));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceTungsten);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFluorescent);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceFluorescent));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceFluorescent);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceFlash);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceFlash));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceFlash);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceSunset);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceSunset));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceSunset);
-
-    service.mockImageProcessingControl->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceVendor);
-    QVERIFY(service.mockImageProcessingControl->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceVendor));
-    QVERIFY(service.mockImageProcessingControl->whiteBalanceMode() == QCameraImageProcessing::WhiteBalanceVendor);
-}
-
 //Added test cases for QCameraFocus
 void tst_QCamera::testCameraFocusIsAvailable()
 {
diff --git a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
index f2a5e5fa4..1a196ae71 100644
--- a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
+++ b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
@@ -49,8 +49,9 @@ Reviewer Name       Date                Coverage ( Full / Test Case IDs ).
 #include <qcamera.h>
 #include <qcameraimagecapture.h>
 
-#include "mockcameraservice.h"
 #include "mockmediaserviceprovider.h"
+#include "mockmediarecorderservice.h"
+#include "qmockintegration_p.h"
 
 QT_USE_NAMESPACE
 
@@ -109,31 +110,25 @@ private slots:
     void cameraImageCaptureControl();
 
 private:
-    MockCameraService  *mockcameraservice;
-    MockMediaServiceProvider *provider;
+    QMockIntegration *mockIntegration;
 };
 
 void tst_QCameraImageCapture::initTestCase()
 {
-    provider = new MockMediaServiceProvider;
-    QMediaServiceProvider::setDefaultServiceProvider(provider);
+    mockIntegration = new QMockIntegration;
 }
 
 void tst_QCameraImageCapture::init()
 {
-    mockcameraservice = new MockCameraService;
-    provider->service = mockcameraservice;
 }
 
 void tst_QCameraImageCapture::cleanup()
 {
-    delete mockcameraservice;
-    mockcameraservice = nullptr;
 }
 
 void tst_QCameraImageCapture::cleanupTestCase()
 {
-    delete provider;
+    delete mockIntegration;
 }
 
 //MaemoAPI-1823:test QCameraImageCapture Constructor
@@ -147,13 +142,11 @@ void tst_QCameraImageCapture::constructor()
 //MaemoAPI-1824:test mediaSource
 void tst_QCameraImageCapture::mediaSource()
 {
-    NullService  mymockcameraservice ;
-    provider->service = &mymockcameraservice;
     QCamera camera;
+    mockIntegration->lastCaptureService()->hasControls = false;
     QCameraImageCapture imageCapture(&camera);
     QVERIFY(imageCapture.camera() == nullptr);
 
-    provider->service = mockcameraservice;
     QCamera camera1;
     QCameraImageCapture imageCapture1(&camera1);
     QMediaSource *medobj1 = imageCapture1.camera();
@@ -162,8 +155,6 @@ void tst_QCameraImageCapture::mediaSource()
 
 void tst_QCameraImageCapture::deleteMediaSource()
 {
-    provider->service = new MockCameraService;
-
     QCamera *camera = new QCamera;
     QCameraImageCapture *capture = new QCameraImageCapture(camera);
 
@@ -171,7 +162,6 @@ void tst_QCameraImageCapture::deleteMediaSource()
     QVERIFY(capture->isAvailable());
 
     delete camera;
-    delete provider->service;
 
     //capture should detach from camera
     QVERIFY(capture->camera() == nullptr);
@@ -288,8 +278,7 @@ void tst_QCameraImageCapture::imageCodecDescription()
 //MaemoAPI-1830:test errors
 void tst_QCameraImageCapture::errors()
 {
-    MockSimpleCameraService mockSimpleCameraService ;
-    provider->service = &mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
 
     QCamera camera1;
     QCameraImageCapture imageCapture1(&camera1);
@@ -299,8 +288,6 @@ void tst_QCameraImageCapture::errors()
     QVERIFY2(!imageCapture1.errorString().isEmpty(), "Device does not support images capture");
     QVERIFY(imageCapture1.availability() == QMultimedia::ServiceMissing);
 
-    provider->service = mockcameraservice;
-
     QCamera camera;
     QCameraImageCapture imageCapture(&camera);
     QVERIFY(imageCapture.isAvailable() == true);
@@ -312,6 +299,8 @@ void tst_QCameraImageCapture::errors()
     QVERIFY(imageCapture.error() == QCameraImageCapture::NotReadyError);
     QVERIFY2(!imageCapture.errorString().isEmpty(), "Could not capture in stopped state");
     QVERIFY(imageCapture.availability() == QMultimedia::Available);
+
+    MockMediaRecorderService::simpleCamera = false;
 }
 
 //MaemoAPI-1831:test error
diff --git a/tests/auto/unit/multimedia/qcamerainfo/tst_qcamerainfo.cpp b/tests/auto/unit/multimedia/qcamerainfo/tst_qcamerainfo.cpp
index 3e5ebd6bc..b36d48c9a 100644
--- a/tests/auto/unit/multimedia/qcamerainfo/tst_qcamerainfo.cpp
+++ b/tests/auto/unit/multimedia/qcamerainfo/tst_qcamerainfo.cpp
@@ -33,8 +33,9 @@
 #include <qcamerainfo.h>
 #include <qmediadevicemanager.h>
 
-#include "mockcameraservice.h"
 #include "mockmediaserviceprovider.h"
+#include "qmockintegration_p.h"
+#include "mockmediarecorderservice.h"
 
 QT_USE_NAMESPACE
 
@@ -54,40 +55,33 @@ private slots:
     void equality_operators();
 
 private:
-    MockSimpleCameraService  *mockSimpleCameraService;
-    MockCameraService *mockCameraService;
-    MockMediaServiceProvider *provider;
+    QMockIntegration *integration;
 };
 
 void tst_QCameraInfo::initTestCase()
 {
+    MockMediaRecorderService::simpleCamera = false;
 }
 
 void tst_QCameraInfo::init()
 {
-    provider = new MockMediaServiceProvider;
-    mockSimpleCameraService = new MockSimpleCameraService;
-    mockCameraService = new MockCameraService;
-
-    provider->service = mockCameraService;
-    QMediaServiceProvider::setDefaultServiceProvider(provider);
+    integration = new QMockIntegration;
 }
 
 void tst_QCameraInfo::cleanup()
 {
-    delete provider;
-    delete mockCameraService;
-    delete mockSimpleCameraService;
+    delete integration;
 }
 
 void tst_QCameraInfo::constructor()
 {
     // Service doesn't implement QVideoDeviceSelectorControl
     // QCameraInfo should not be valid in this case
-    provider->service = mockSimpleCameraService;
+    MockMediaRecorderService::simpleCamera = true;
 
     {
         QCamera camera;
+
         QCameraInfo info(camera);
         QVERIFY(info.isNull());
         QVERIFY(info.id().isEmpty());
@@ -97,7 +91,7 @@ void tst_QCameraInfo::constructor()
     }
 
     // Service implements QVideoDeviceSelectorControl
-    provider->service = mockCameraService;
+    MockMediaRecorderService::simpleCamera = false;
 
     {
         // default camera
@@ -128,8 +122,6 @@ void tst_QCameraInfo::constructor()
 
 void tst_QCameraInfo::defaultCamera()
 {
-    provider->service = mockCameraService;
-
     QCameraInfo info = QMediaDeviceManager::defaultVideoInput();
 
     QVERIFY(!info.isNull());
@@ -144,8 +136,6 @@ void tst_QCameraInfo::defaultCamera()
 
 void tst_QCameraInfo::availableCameras()
 {
-    provider->service = mockCameraService;
-
     QList<QCameraInfo> cameras = QMediaDeviceManager::videoInputs();
     QCOMPARE(cameras.count(), 2);
 
@@ -178,8 +168,6 @@ void tst_QCameraInfo::availableCameras()
 
 void tst_QCameraInfo::equality_operators()
 {
-    provider->service = mockCameraService;
-
     QCameraInfo defaultCamera = QMediaDeviceManager::defaultVideoInput();
     QList<QCameraInfo> cameras = QMediaDeviceManager::videoInputs();
 
diff --git a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp
index 5b5b47ac3..a5353a285 100644
--- a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp
+++ b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp
@@ -46,12 +46,12 @@
 #include <qvideowidget.h>
 #include <qvideowindowcontrol.h>
 
-#include "mockcameraservice.h"
-
 #include "mockmediaserviceprovider.h"
 #include "mockvideosurface.h"
 #include "mockvideorenderercontrol.h"
 #include "mockvideowindowcontrol.h"
+#include "mockmediarecorderservice.h"
+#include "qmockintegration_p.h"
 
 QT_USE_NAMESPACE
 
@@ -73,32 +73,26 @@ private slots:
     void testSetVideoOutputNoControl();
 
 private:
-    MockCameraService  *mockCameraService;
-    MockMediaServiceProvider *provider;
+    QMockIntegration *mockIntegration;
 };
 
 void tst_QCameraWidgets::initTestCase()
 {
-    provider = new MockMediaServiceProvider;
-    QMediaServiceProvider::setDefaultServiceProvider(provider);
 }
 
 void tst_QCameraWidgets::init()
 {
-    mockCameraService = new MockCameraService;
-    provider->service = mockCameraService;
+    mockIntegration = new QMockIntegration;
 }
 
 void tst_QCameraWidgets::cleanup()
 {
-    delete mockCameraService;
-    provider->service = nullptr;
+    delete mockIntegration;
 }
 
 
 void tst_QCameraWidgets::cleanupTestCase()
 {
-    delete provider;
 }
 
 void tst_QCameraWidgets::testCameraEncodingProperyChange()
@@ -196,7 +190,8 @@ void tst_QCameraWidgets::testCameraEncodingProperyChange()
 
     QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
 
-    mockCameraService->mockControl->m_propertyChangesSupported = true;
+    auto *mockCameraService = mockIntegration->lastCaptureService();
+    mockCameraService->mockCameraControl->m_propertyChangesSupported = true;
     //the changes to encoding settings,
     //capture mode and encoding parameters should not trigger service restart
     stateChangedSignal.clear();
@@ -218,6 +213,7 @@ void tst_QCameraWidgets::testSetVideoOutput()
     QGraphicsVideoItem item;
     MockVideoSurface surface;
     QCamera camera;
+    auto *mockCameraService = mockIntegration->lastCaptureService();
 
     camera.setViewfinder(&widget);
     qDebug() << widget.mediaSource();
@@ -261,8 +257,9 @@ void tst_QCameraWidgets::testSetVideoOutputNoService()
     QGraphicsVideoItem item;
     MockVideoSurface surface;
 
-    provider->service = nullptr;
+    mockIntegration->setFlags(QMockIntegration::NoCaptureInterface);
     QCamera camera;
+    mockIntegration->setFlags({});
 
     camera.setViewfinder(&widget);
     QVERIFY(widget.mediaSource() == nullptr);
@@ -272,18 +269,21 @@ void tst_QCameraWidgets::testSetVideoOutputNoService()
 
     camera.setViewfinder(&surface);
     // Nothing we can verify here other than it doesn't assert.
+
 }
 
+
 void tst_QCameraWidgets::testSetVideoOutputNoControl()
 {
     QVideoWidget widget;
     QGraphicsVideoItem item;
     MockVideoSurface surface;
 
-    mockCameraService->rendererRef = 1;
-    mockCameraService->windowRef = 1;
 
     QCamera camera;
+    auto *mockCameraService = mockIntegration->lastCaptureService();
+    mockCameraService->rendererRef = 1;
+    mockCameraService->windowRef = 1;
 
     camera.setViewfinder(&widget);
     QVERIFY(widget.mediaSource() == nullptr);
diff --git a/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp b/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp
index bb58c1184..159449552 100644
--- a/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp
+++ b/tests/auto/unit/multimediawidgets/qmediaplayerwidgets/tst_qmediaplayerwidgets.cpp
@@ -40,6 +40,7 @@
 #include "mockmediaserviceprovider.h"
 #include "mockmediaplayerservice.h"
 #include "mockvideosurface.h"
+#include "qmockintegration_p.h"
 
 QT_USE_NAMESPACE
 
@@ -59,25 +60,22 @@ private slots:
     void testSetVideoOutputNoControl();
 
 private:
-    MockMediaServiceProvider *provider;
+    QMockIntegration *mockIntegration;
     MockMediaPlayerService  *mockService;
 };
 
 void tst_QMediaPlayerWidgets::initTestCase()
 {
-    provider = new MockMediaServiceProvider;
-    QMediaServiceProvider::setDefaultServiceProvider(provider);
+    mockIntegration = new QMockIntegration;
 }
 
 void tst_QMediaPlayerWidgets::cleanupTestCase()
 {
-    delete provider;
+    delete mockIntegration;
 }
 
 void tst_QMediaPlayerWidgets::init()
 {
-    mockService = new MockMediaPlayerService;
-    provider->service = mockService;
 }
 
 void tst_QMediaPlayerWidgets::cleanup()
@@ -133,8 +131,9 @@ void tst_QMediaPlayerWidgets::testSetVideoOutputNoService()
     QGraphicsVideoItem item;
     MockVideoSurface surface;
 
-    provider->service = nullptr;
+    mockIntegration->setFlags(QMockIntegration::NoPlayerInterface);
     QMediaPlayer player;
+    mockIntegration->setFlags({});
 
     player.setVideoOutput(&widget);
     QVERIFY(widget.mediaSource() == nullptr);
@@ -152,13 +151,10 @@ void tst_QMediaPlayerWidgets::testSetVideoOutputNoControl()
     QGraphicsVideoItem item;
     MockVideoSurface surface;
 
-    MockMediaPlayerService service;
-    service.rendererRef = 1;
-    service.windowRef = 1;
-
-    provider->service = &service;
-
     QMediaPlayer player;
+    auto *service = mockIntegration->lastPlayerService();
+    service->rendererRef = 1;
+    service->windowRef = 1;
 
     player.setVideoOutput(&widget);
     QVERIFY(widget.mediaSource() == nullptr);
@@ -167,7 +163,7 @@ void tst_QMediaPlayerWidgets::testSetVideoOutputNoControl()
     QVERIFY(item.mediaSource() == nullptr);
 
     player.setVideoOutput(&surface);
-    QVERIFY(service.rendererControl->surface() == nullptr);
+    QVERIFY(service->rendererControl->surface() == nullptr);
 }
 
 QTEST_MAIN(tst_QMediaPlayerWidgets)
diff --git a/tests/auto/unit/qml/CMakeLists.txt b/tests/auto/unit/qml/CMakeLists.txt
index fb8365592..6cc5951dc 100644
--- a/tests/auto/unit/qml/CMakeLists.txt
+++ b/tests/auto/unit/qml/CMakeLists.txt
@@ -2,7 +2,6 @@
 
 add_subdirectory(qdeclarativemultimediaglobal)
 add_subdirectory(qdeclarativeaudio)
-add_subdirectory(qdeclarativecamera)
 if(disabled)
     add_subdirectory(qdeclarativevideo)
 endif()
diff --git a/tests/auto/unit/qml/qdeclarativeaudio/tst_qdeclarativeaudio.cpp b/tests/auto/unit/qml/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
index 30b3eae71..6b3bf757f 100644
--- a/tests/auto/unit/qml/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
+++ b/tests/auto/unit/qml/qdeclarativeaudio/tst_qdeclarativeaudio.cpp
@@ -35,6 +35,8 @@
 
 #include "mockmediaserviceprovider.h"
 #include "mockmediaplayerservice.h"
+#include "mockmetadatareadercontrol.h"
+#include "qmockintegration_p.h"
 
 #include <QtMultimedia/qmediametadata.h>
 #include <qmediaplayercontrol.h>
@@ -55,8 +57,6 @@ public slots:
     void initTestCase();
 
 private slots:
-    void nullPlayerControl();
-    void nullMetaDataControl();
     void nullService();
 
     void source();
@@ -84,267 +84,23 @@ private:
     QMetaEnum enumerator(const QMetaObject *object, const char *name);
     void keyToValue(const QMetaEnum &enumeration, const char *key, int *result);
     int keyToValue(const QMetaEnum &enumeration, const char *key);
+
+    QMockIntegration *mockIntegration;
 };
 
 Q_DECLARE_METATYPE(QDeclarativeAudio::Error);
 Q_DECLARE_METATYPE(QDeclarativeAudio::AudioRole);
 
-class QtTestMediaPlayerControl : public QMediaPlayerControl
-{
-    Q_OBJECT
-public:
-    QtTestMediaPlayerControl(QObject *parent = nullptr)
-        : QMediaPlayerControl(parent)
-    {
-    }
-
-    [[nodiscard]] QMediaPlayer::State state() const override { return m_state; }
-    void updateState(QMediaPlayer::State state) { emit stateChanged(m_state = state); }
-
-    [[nodiscard]] QMediaPlayer::MediaStatus mediaStatus() const override { return m_mediaStatus; }
-    void updateMediaStatus(QMediaPlayer::MediaStatus status) {
-        emit mediaStatusChanged(m_mediaStatus = status); }
-    void updateMediaStatus(QMediaPlayer::MediaStatus status, QMediaPlayer::State state)
-    {
-        m_mediaStatus = status;
-        m_state = state;
-
-        emit mediaStatusChanged(m_mediaStatus);
-        emit stateChanged(m_state);
-    }
-
-    [[nodiscard]] qint64 duration() const override { return m_duration; }
-    void setDuration(qint64 duration) { emit durationChanged(m_duration = duration); }
-
-    [[nodiscard]] qint64 position() const override { return m_position; }
-    void setPosition(qint64 position) override { emit positionChanged(m_position = position); }
-
-    [[nodiscard]] int volume() const override { return m_volume; }
-    void setVolume(int volume) override { emit volumeChanged(m_volume = volume); }
-
-    [[nodiscard]] bool isMuted() const override { return m_muted; }
-    void setMuted(bool muted) override { emit mutedChanged(m_muted = muted); }
-
-    [[nodiscard]] int bufferStatus() const override { return m_bufferStatus; }
-    void setBufferStatus(int status) { emit bufferStatusChanged(m_bufferStatus = status); }
-
-    [[nodiscard]] bool isAudioAvailable() const override { return m_audioAvailable; }
-    void setAudioAvailable(bool available) {
-        emit audioAvailableChanged(m_audioAvailable = available); }
-    [[nodiscard]] bool isVideoAvailable() const override { return m_videoAvailable; }
-    void setVideoAvailable(bool available) {
-        emit videoAvailableChanged(m_videoAvailable = available); }
-
-    [[nodiscard]] bool isSeekable() const override { return m_seekable; }
-    void setSeekable(bool seekable) { emit seekableChanged(m_seekable = seekable); }
-
-    [[nodiscard]] QMediaTimeRange availablePlaybackRanges() const override { return QMediaTimeRange(); }
-
-    [[nodiscard]] qreal playbackRate() const override { return m_playbackRate; }
-    void setPlaybackRate(qreal rate) override { emit playbackRateChanged(m_playbackRate = rate); }
-
-    [[nodiscard]] QUrl media() const override { return m_media; }
-    [[nodiscard]] const QIODevice *mediaStream() const override { return nullptr; }
-    void setMedia(const QUrl &media, QIODevice *) override
-    {
-        m_media = media;
-
-        m_mediaStatus = m_media.isEmpty()
-                ? QMediaPlayer::NoMedia
-                : QMediaPlayer::LoadingMedia;
-
-        emit mediaStatusChanged(m_mediaStatus);
-    }
-
-    void play() override
-    {
-        m_state = QMediaPlayer::PlayingState;
-        if (m_mediaStatus == QMediaPlayer::EndOfMedia)
-            updateMediaStatus(QMediaPlayer::LoadedMedia);
-        emit stateChanged(m_state);
-    }
-    void pause() override { emit stateChanged(m_state = QMediaPlayer::PausedState); }
-    void stop() override { emit stateChanged(m_state = QMediaPlayer::StoppedState); }
-
-    void emitError(QMediaPlayer::Error err, const QString &errorString) {
-        emit error(err, errorString); }
-
-private:
-    QMediaPlayer::State m_state = QMediaPlayer::StoppedState;
-    QMediaPlayer::MediaStatus m_mediaStatus = QMediaPlayer::NoMedia;
-    qint64 m_duration = 0;
-    qint64 m_position = 0;
-    qreal m_playbackRate = 1.0;
-    int m_volume = 100;
-    int m_bufferStatus = 0;
-    bool m_muted = false;
-    bool m_audioAvailable = false;
-    bool m_videoAvailable = false;
-    bool m_seekable = false;
-    QUrl m_media;
-};
-
-class QtTestMetaDataControl : public QMetaDataReaderControl
-{
-    Q_OBJECT
-public:
-    QtTestMetaDataControl(QObject *parent = nullptr)
-        : QMetaDataReaderControl(parent)
-    {
-    }
-
-    [[nodiscard]] bool isMetaDataAvailable() const override { return true; }
-
-    [[nodiscard]] QVariant metaData(const QString &key) const override { return m_metaData.value(key); }
-    void setMetaData(const QString &key, const QVariant &value) {
-        m_metaData.insert(key, value); emit metaDataChanged(); }
-
-    [[nodiscard]] QStringList availableMetaData() const override { return m_metaData.keys(); }
-
-private:
-    QMap<QString, QVariant> m_metaData;
-};
-
-class QtTestMediaService : public QMediaService
-{
-    Q_OBJECT
-public:
-    QtTestMediaService(
-            QtTestMediaPlayerControl *playerControl,
-            QtTestMetaDataControl *metaDataControl,
-            QObject *parent)
-        : QMediaService(parent)
-        , playerControl(playerControl)
-        , metaDataControl(metaDataControl)
-    {
-    }
-
-    QObject *requestControl(const char *name) override
-    {
-        if (qstrcmp(name, QMediaPlayerControl_iid) == 0)
-            return playerControl;
-        if (qstrcmp(name, QMetaDataReaderControl_iid) == 0)
-            return metaDataControl;
-
-        return nullptr;
-    }
-
-    void releaseControl(QObject *) override {}
-
-    QtTestMediaPlayerControl *playerControl;
-    QtTestMetaDataControl *metaDataControl;
-};
-
-class QtTestMediaServiceProvider : public QMediaServiceProvider
-{
-    Q_OBJECT
-public:
-    QtTestMediaServiceProvider()
-        : service(new QtTestMediaService(
-                new QtTestMediaPlayerControl(this), new QtTestMetaDataControl(this), this))
-    {
-        setDefaultServiceProvider(this);
-    }
-
-    QtTestMediaServiceProvider(QtTestMediaService *service)
-        : service(service)
-    {
-        setDefaultServiceProvider(this);
-    }
-
-    QtTestMediaServiceProvider(
-            QtTestMediaPlayerControl *playerControl, QtTestMetaDataControl *metaDataControl)
-        : service(new QtTestMediaService(playerControl, metaDataControl, this))
-    {
-        setDefaultServiceProvider(this);
-    }
-
-    ~QtTestMediaServiceProvider() override
-    {
-        setDefaultServiceProvider(nullptr);
-    }
-
-    QMediaService *requestService(const QByteArray &type) override
-    {
-        requestedService = type;
-
-        return service;
-    }
-
-    void releaseService(QMediaService *) override {}
-
-    inline QtTestMediaPlayerControl *playerControl() { return service->playerControl; }
-    inline QtTestMetaDataControl *metaDataControl() { return service->metaDataControl; }
-
-    QtTestMediaService *service;
-    QByteArray requestedService;
-};
-
 void tst_QDeclarativeAudio::initTestCase()
 {
     qRegisterMetaType<QDeclarativeAudio::Error>();
     qRegisterMetaType<QDeclarativeAudio::AudioRole>();
-}
-
-void tst_QDeclarativeAudio::nullPlayerControl()
-{
-    QtTestMetaDataControl metaDataControl;
-    QtTestMediaServiceProvider provider(nullptr, &metaDataControl);
-
-    QDeclarativeAudio audio;
-    audio.classBegin();
-
-    QCOMPARE(audio.source(), QUrl());
-    audio.setSource(QUrl("http://example.com"));
-    QCOMPARE(audio.source(), QUrl("http://example.com"));
-
-    QCOMPARE(audio.playbackState(), audio.StoppedState);
-    audio.play();
-    QCOMPARE(audio.playbackState(), audio.StoppedState);
-    audio.pause();
-    QCOMPARE(audio.playbackState(), audio.StoppedState);
-
-    QCOMPARE(audio.duration(), 0);
-
-    QCOMPARE(audio.position(), 0);
-    audio.seek(10000);
-    QCOMPARE(audio.position(), 10000);
-
-    QCOMPARE(audio.volume(), qreal(1.0));
-    audio.setVolume(0.5);
-    QCOMPARE(audio.volume(), qreal(0.5));
-
-    QCOMPARE(audio.isMuted(), false);
-    audio.setMuted(true);
-    QCOMPARE(audio.isMuted(), true);
-
-    QCOMPARE(audio.bufferProgress(), qreal(0));
-
-    QCOMPARE(audio.isSeekable(), false);
-
-    QCOMPARE(audio.playbackRate(), qreal(1.0));
-
-    QCOMPARE(audio.status(), QDeclarativeAudio::NoMedia);
-
-    QCOMPARE(audio.error(), QDeclarativeAudio::ServiceMissing);
-}
-
-void tst_QDeclarativeAudio::nullMetaDataControl()
-{
-    QtTestMediaPlayerControl playerControl;
-    QtTestMediaServiceProvider provider(&playerControl, nullptr);
-
-    QDeclarativeAudio audio;
-    audio.classBegin();
-    audio.componentComplete();
-
-    QVERIFY(audio.metaData());
+    mockIntegration = new QMockIntegration;
 }
 
 void tst_QDeclarativeAudio::nullService()
 {
-    QtTestMediaServiceProvider provider(nullptr);
-
+    mockIntegration->setFlags(QMockIntegration::NoPlayerInterface);
     QDeclarativeAudio audio;
     audio.classBegin();
 
@@ -383,6 +139,7 @@ void tst_QDeclarativeAudio::nullService()
     QCOMPARE(audio.error(), QDeclarativeAudio::ServiceMissing);
 
     QVERIFY(audio.metaData());
+    mockIntegration->setFlags({});
 }
 
 void tst_QDeclarativeAudio::source()
@@ -391,8 +148,8 @@ void tst_QDeclarativeAudio::source()
     const QUrl url2("file:///local/path");
     const QUrl url3;
 
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -400,23 +157,22 @@ void tst_QDeclarativeAudio::source()
 
     audio.setSource(url1);
     QCOMPARE(audio.source(), url1);
-    QCOMPARE(provider.playerControl()->media(), url1);
+    QCOMPARE(service->player()->media(), url1);
     QCOMPARE(spy.count(), 1);
 
     audio.setSource(url2);
     QCOMPARE(audio.source(), url2);
-    QCOMPARE(provider.playerControl()->media(), url2);
+    QCOMPARE(service->player()->media(), url2);
     QCOMPARE(spy.count(), 2);
 
     audio.setSource(url3);
     QCOMPARE(audio.source(), url3);
-    QCOMPARE(provider.playerControl()->media(), url3);
+    QCOMPARE(service->player()->media(), url3);
     QCOMPARE(spy.count(), 3);
 }
 
 void tst_QDeclarativeAudio::autoLoad()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
     audio.classBegin();
     audio.componentComplete();
@@ -444,8 +200,8 @@ void tst_QDeclarativeAudio::autoLoad()
 
 void tst_QDeclarativeAudio::playing()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
 
     QSignalSpy stateChangedSpy(&audio, SIGNAL(playbackStateChanged()));
@@ -464,7 +220,7 @@ void tst_QDeclarativeAudio::playing()
     // play() when stopped.
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(playingSpy.count(),        ++playing);
     QCOMPARE(stoppedSpy.count(),          stopped);
@@ -472,7 +228,7 @@ void tst_QDeclarativeAudio::playing()
     // stop() when playing.
     audio.stop();
     QCOMPARE(audio.playbackState(), audio.StoppedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::StoppedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(playingSpy.count(),          playing);
     QCOMPARE(stoppedSpy.count(),        ++stopped);
@@ -480,14 +236,14 @@ void tst_QDeclarativeAudio::playing()
     // stop() when stopped.
     audio.stop();
     QCOMPARE(audio.playbackState(), audio.StoppedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::StoppedState);
     QCOMPARE(stateChangedSpy.count(),   stateChanged);
     QCOMPARE(playingSpy.count(),          playing);
     QCOMPARE(stoppedSpy.count(),          stopped);
 
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(playingSpy.count(),        ++playing);
     QCOMPARE(stoppedSpy.count(),          stopped);
@@ -495,7 +251,7 @@ void tst_QDeclarativeAudio::playing()
     // play() when playing.
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(),   stateChanged);
     QCOMPARE(playingSpy.count(),          playing);
     QCOMPARE(stoppedSpy.count(),          stopped);
@@ -503,8 +259,8 @@ void tst_QDeclarativeAudio::playing()
 
 void tst_QDeclarativeAudio::paused()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
 
     QSignalSpy stateChangedSpy(&audio, SIGNAL(playbackStateChanged()));
@@ -520,50 +276,50 @@ void tst_QDeclarativeAudio::paused()
     // play() when stopped.
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(pausedSpy.count(), pausedCount);
 
     // pause() when playing.
     audio.pause();
     QCOMPARE(audio.playbackState(), audio.PausedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PausedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PausedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(pausedSpy.count(), ++pausedCount);
 
     // pause() when paused.
     audio.pause();
     QCOMPARE(audio.playbackState(), audio.PausedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PausedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PausedState);
     QCOMPARE(stateChangedSpy.count(),   stateChanged);
     QCOMPARE(pausedSpy.count(), pausedCount);
 
     // stop() when paused.
     audio.stop();
     QCOMPARE(audio.playbackState(), audio.StoppedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::StoppedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(pausedSpy.count(), pausedCount);
 
     // pause() when stopped.
     audio.pause();
     QCOMPARE(audio.playbackState(), audio.PausedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PausedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PausedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(pausedSpy.count(), ++pausedCount);
 
     // play() when paused.
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(pausedSpy.count(), pausedCount);
 }
 
 void tst_QDeclarativeAudio::duration()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -571,28 +327,28 @@ void tst_QDeclarativeAudio::duration()
 
     QCOMPARE(audio.duration(), 0);
 
-    provider.playerControl()->setDuration(4040);
+    service->player()->setDuration(4040);
     QCOMPARE(audio.duration(), 4040);
     QCOMPARE(spy.count(), 1);
 
-    provider.playerControl()->setDuration(-129);
+    service->player()->setDuration(-129);
     QCOMPARE(audio.duration(), -129);
     QCOMPARE(spy.count(), 2);
 
-    provider.playerControl()->setDuration(0);
+    service->player()->setDuration(0);
     QCOMPARE(audio.duration(), 0);
     QCOMPARE(spy.count(), 3);
 
     // Unnecessary duration changed signals aren't filtered.
-    provider.playerControl()->setDuration(0);
+    service->player()->setDuration(0);
     QCOMPARE(audio.duration(), 0);
     QCOMPARE(spy.count(), 4);
 }
 
 void tst_QDeclarativeAudio::position()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -605,39 +361,39 @@ void tst_QDeclarativeAudio::position()
 
     audio.seek(450);
     QCOMPARE(audio.position(), 450);
-    QCOMPARE(provider.playerControl()->position(), qint64(450));
+    QCOMPARE(service->player()->position(), qint64(450));
     QCOMPARE(spy.count(), 1);
 
     audio.seek(-5403);
     QCOMPARE(audio.position(), 0);
-    QCOMPARE(provider.playerControl()->position(), qint64(0));
+    QCOMPARE(service->player()->position(), qint64(0));
     QCOMPARE(spy.count(), 2);
 
     audio.seek(-5403);
     QCOMPARE(audio.position(), 0);
-    QCOMPARE(provider.playerControl()->position(), qint64(0));
+    QCOMPARE(service->player()->position(), qint64(0));
     QCOMPARE(spy.count(), 2);
 
     // Check the signal change signal is emitted if the change originates from the media service.
-    provider.playerControl()->setPosition(450);
+    service->player()->setPosition(450);
     QCOMPARE(audio.position(), 450);
     QCOMPARE(spy.count(), 3);
 
     connect(&audio, SIGNAL(positionChanged()), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
-    provider.playerControl()->updateState(QMediaPlayer::PlayingState);
+    service->player()->updateState(QMediaPlayer::PlayingState);
     QTestEventLoop::instance().enterLoop(2);
     QVERIFY(spy.count() > 3 && spy.count() < 6); // 4 or 5
 
-    provider.playerControl()->updateState(QMediaPlayer::PausedState);
+    service->player()->updateState(QMediaPlayer::PausedState);
     QTestEventLoop::instance().enterLoop(1);
     QVERIFY(spy.count() < 6);
 }
 
 void tst_QDeclarativeAudio::volume()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -647,23 +403,23 @@ void tst_QDeclarativeAudio::volume()
 
     audio.setVolume(0.7);
     QCOMPARE(audio.volume(), qreal(0.7));
-    QCOMPARE(provider.playerControl()->volume(), 70);
+    QCOMPARE(service->player()->volume(), 70);
     QCOMPARE(spy.count(), 1);
 
     audio.setVolume(0.7);
     QCOMPARE(audio.volume(), qreal(0.7));
-    QCOMPARE(provider.playerControl()->volume(), 70);
+    QCOMPARE(service->player()->volume(), 70);
     QCOMPARE(spy.count(), 1);
 
-    provider.playerControl()->setVolume(30);
+    service->player()->setVolume(30);
     QCOMPARE(audio.volume(), qreal(0.3));
     QCOMPARE(spy.count(), 2);
 }
 
 void tst_QDeclarativeAudio::muted()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -673,23 +429,23 @@ void tst_QDeclarativeAudio::muted()
 
     audio.setMuted(true);
     QCOMPARE(audio.isMuted(), true);
-    QCOMPARE(provider.playerControl()->isMuted(), true);
+    QCOMPARE(service->player()->isMuted(), true);
     QCOMPARE(spy.count(), 1);
 
-    provider.playerControl()->setMuted(false);
+    service->player()->setMuted(false);
     QCOMPARE(audio.isMuted(), false);
     QCOMPARE(spy.count(), 2);
 
     audio.setMuted(false);
     QCOMPARE(audio.isMuted(), false);
-    QCOMPARE(provider.playerControl()->isMuted(), false);
+    QCOMPARE(service->player()->isMuted(), false);
     QCOMPARE(spy.count(), 2);
 }
 
 void tst_QDeclarativeAudio::bufferProgress()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -697,34 +453,34 @@ void tst_QDeclarativeAudio::bufferProgress()
 
     QCOMPARE(audio.bufferProgress(), qreal(0.0));
 
-    provider.playerControl()->setBufferStatus(20);
+    service->player()->setBufferStatus(20);
     QCOMPARE(audio.bufferProgress(), qreal(0.2));
     QCOMPARE(spy.count(), 1);
 
-    provider.playerControl()->setBufferStatus(20);
+    service->player()->setBufferStatus(20);
     QCOMPARE(audio.bufferProgress(), qreal(0.2));
     QCOMPARE(spy.count(), 2);
 
-    provider.playerControl()->setBufferStatus(40);
+    service->player()->setBufferStatus(40);
     QCOMPARE(audio.bufferProgress(), qreal(0.4));
     QCOMPARE(spy.count(), 3);
 
     connect(&audio, SIGNAL(positionChanged()), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
-    provider.playerControl()->updateMediaStatus(
+    service->player()->updateMediaStatus(
             QMediaPlayer::BufferingMedia, QMediaPlayer::PlayingState);
     QTestEventLoop::instance().enterLoop(2);
     QVERIFY(spy.count() > 3 && spy.count() < 6); // 4 or 5
 
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::BufferedMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::BufferedMedia);
     QTestEventLoop::instance().enterLoop(1);
     QVERIFY(spy.count() < 6);
 }
 
 void tst_QDeclarativeAudio::seekable()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -732,23 +488,23 @@ void tst_QDeclarativeAudio::seekable()
 
     QCOMPARE(audio.isSeekable(), false);
 
-    provider.playerControl()->setSeekable(true);
+    service->player()->setSeekable(true);
     QCOMPARE(audio.isSeekable(), true);
     QCOMPARE(spy.count(), 1);
 
-    provider.playerControl()->setSeekable(true);
+    service->player()->setSeekable(true);
     QCOMPARE(audio.isSeekable(), true);
     QCOMPARE(spy.count(), 2);
 
-    provider.playerControl()->setSeekable(false);
+    service->player()->setSeekable(false);
     QCOMPARE(audio.isSeekable(), false);
     QCOMPARE(spy.count(), 3);
 }
 
 void tst_QDeclarativeAudio::playbackRate()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -758,23 +514,23 @@ void tst_QDeclarativeAudio::playbackRate()
 
     audio.setPlaybackRate(0.5);
     QCOMPARE(audio.playbackRate(), qreal(0.5));
-    QCOMPARE(provider.playerControl()->playbackRate(), qreal(0.5));
+    QCOMPARE(service->player()->playbackRate(), qreal(0.5));
     QCOMPARE(spy.count(), 1);
 
-    provider.playerControl()->setPlaybackRate(2.0);
-    QCOMPARE(provider.playerControl()->playbackRate(), qreal(2.0));
+    service->player()->setPlaybackRate(2.0);
+    QCOMPARE(service->player()->playbackRate(), qreal(2.0));
     QCOMPARE(spy.count(), 2);
 
     audio.setPlaybackRate(2.0);
     QCOMPARE(audio.playbackRate(), qreal(2.0));
-    QCOMPARE(provider.playerControl()->playbackRate(), qreal(2.0));
+    QCOMPARE(service->player()->playbackRate(), qreal(2.0));
     QCOMPARE(spy.count(), 2);
 }
 
 void tst_QDeclarativeAudio::status()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -783,48 +539,48 @@ void tst_QDeclarativeAudio::status()
     QCOMPARE(audio.status(), QDeclarativeAudio::NoMedia);
 
     // Set media, start loading.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::LoadingMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::LoadingMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Loading);
     QCOMPARE(statusChangedSpy.count(), 1);
 
     // Finish loading.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::LoadedMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::LoadedMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Loaded);
     QCOMPARE(statusChangedSpy.count(), 2);
 
     // Play, start buffering.
-    provider.playerControl()->updateMediaStatus(
+    service->player()->updateMediaStatus(
             QMediaPlayer::StalledMedia, QMediaPlayer::PlayingState);
     QCOMPARE(audio.status(), QDeclarativeAudio::Stalled);
     QCOMPARE(statusChangedSpy.count(), 3);
 
     // Enough data buffered to proceed.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::BufferingMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::BufferingMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Buffering);
     QCOMPARE(statusChangedSpy.count(), 4);
 
     // Errant second buffering status changed.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::BufferingMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::BufferingMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Buffering);
     QCOMPARE(statusChangedSpy.count(), 4);
 
     // Buffer full.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::BufferedMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::BufferedMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Buffered);
     QCOMPARE(statusChangedSpy.count(), 5);
 
     // Buffer getting low.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::BufferingMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::BufferingMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Buffering);
     QCOMPARE(statusChangedSpy.count(), 6);
 
     // Buffer full.
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::BufferedMedia);
+    service->player()->updateMediaStatus(QMediaPlayer::BufferedMedia);
     QCOMPARE(audio.status(), QDeclarativeAudio::Buffered);
     QCOMPARE(statusChangedSpy.count(), 7);
 
     // Finished.
-    provider.playerControl()->updateMediaStatus(
+    service->player()->updateMediaStatus(
             QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
     QCOMPARE(audio.status(), QDeclarativeAudio::EndOfMedia);
     QCOMPARE(statusChangedSpy.count(), 8);
@@ -858,8 +614,8 @@ void tst_QDeclarativeAudio::metaData()
     QFETCH(QString, propertyKey);
     QFETCH(QVariant, value);
 
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -873,10 +629,10 @@ void tst_QDeclarativeAudio::metaData()
 
     property.write(audio.metaData(), value);
     QCOMPARE(property.read(audio.metaData()), QVariant());
-    QCOMPARE(provider.metaDataControl()->metaData(propertyKey), QVariant());
+    QCOMPARE(service->metaDataControl->metaData(propertyKey), QVariant());
     QCOMPARE(spy.count(), 0);
 
-    provider.metaDataControl()->setMetaData(propertyKey, value);
+    service->metaDataControl->setMetaData(propertyKey, value);
     QCOMPARE(property.read(audio.metaData()), value);
     QCOMPARE(spy.count(), 1);
 }
@@ -885,8 +641,8 @@ void tst_QDeclarativeAudio::error()
 {
     const QString errorString = QLatin1String("Failed to open device.");
 
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
     audio.classBegin();
     audio.componentComplete();
 
@@ -896,7 +652,7 @@ void tst_QDeclarativeAudio::error()
     QCOMPARE(audio.error(), QDeclarativeAudio::NoError);
     QCOMPARE(audio.errorString(), QString());
 
-    provider.playerControl()->emitError(QMediaPlayer::ResourceError, errorString);
+    service->player()->emitError(QMediaPlayer::ResourceError, errorString);
 
     QCOMPARE(audio.error(), QDeclarativeAudio::ResourceError);
     QCOMPARE(audio.errorString(), errorString);
@@ -920,8 +676,8 @@ void tst_QDeclarativeAudio::error()
 
 void tst_QDeclarativeAudio::loops()
 {
-    QtTestMediaServiceProvider provider;
     QDeclarativeAudio audio;
+    auto *service = mockIntegration->lastPlayerService();
 
     QSignalSpy loopsChangedSpy(&audio, SIGNAL(loopCountChanged()));
     QSignalSpy stateChangedSpy(&audio, SIGNAL(playbackStateChanged()));
@@ -944,42 +700,42 @@ void tst_QDeclarativeAudio::loops()
     //play till end
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(stoppedSpy.count(), stoppedCount);
 
     // play() when playing.
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(),   stateChanged);
     QCOMPARE(stoppedSpy.count(), stoppedCount);
 
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
+    service->player()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(),   stateChanged);
     QCOMPARE(stoppedSpy.count(), stoppedCount);
 
     //play to end
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
+    service->player()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
     QCOMPARE(stoppedSpy.count(), stoppedCount);
     //play to end
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
+    service->player()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
     QCOMPARE(audio.playbackState(), audio.StoppedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::StoppedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(stoppedSpy.count(), ++stoppedCount);
 
     // stop when playing
     audio.play();
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(stoppedSpy.count(), stoppedCount);
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
+    service->player()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
     audio.stop();
     QCOMPARE(audio.playbackState(), audio.StoppedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::StoppedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(stoppedSpy.count(), ++stoppedCount);
 
@@ -990,16 +746,16 @@ void tst_QDeclarativeAudio::loops()
     audio.play();
     QCOMPARE(audio.playbackState(), audio.PlayingState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
-    provider.playerControl()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
+    service->player()->updateMediaStatus(QMediaPlayer::EndOfMedia, QMediaPlayer::StoppedState);
     QCOMPARE(audio.playbackState(), audio.PlayingState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::PlayingState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::PlayingState);
     QCOMPARE(stateChangedSpy.count(), stateChanged);
 
     // stop() when playing in infinite loop.
     audio.stop();
     QCOMPARE(audio.playbackState(), audio.StoppedState);
-    QCOMPARE(provider.playerControl()->state(), QMediaPlayer::StoppedState);
+    QCOMPARE(service->player()->state(), QMediaPlayer::StoppedState);
     QCOMPARE(stateChangedSpy.count(), ++stateChanged);
     QCOMPARE(stoppedSpy.count(), ++stoppedCount);
 
@@ -1008,17 +764,14 @@ void tst_QDeclarativeAudio::loops()
 
 void tst_QDeclarativeAudio::audioRole()
 {
-    MockMediaPlayerService mockService;
-    MockMediaServiceProvider mockProvider(&mockService);
-    QMediaServiceProvider::setDefaultServiceProvider(&mockProvider);
-
     QQmlEngine engine;
     QQmlComponent component(&engine);
     component.setData("import QtQuick 2.0 \n import QtMultimedia 5.6 \n Audio { }", QUrl());
 
     {
-        mockService.mockControl->hasAudioRole = false;
         QDeclarativeAudio *audio = static_cast<QDeclarativeAudio*>(component.create());
+        auto *service = mockIntegration->lastPlayerService();
+        service->player()->hasAudioRole = false;
 
         QCOMPARE(audio->audioRole(), QDeclarativeAudio::UnknownRole);
         QVERIFY(audio->supportedAudioRoles().isArray());
@@ -1031,9 +784,9 @@ void tst_QDeclarativeAudio::audioRole()
     }
 
     {
-        mockService.reset();
-        mockService.mockControl->hasAudioRole = true;
         QDeclarativeAudio *audio = static_cast<QDeclarativeAudio*>(component.create());
+        auto *service = mockIntegration->lastPlayerService();
+        service->player()->hasAudioRole = false;
         QSignalSpy spy(audio, SIGNAL(audioRoleChanged()));
 
         QCOMPARE(audio->audioRole(), QDeclarativeAudio::UnknownRole);
@@ -1195,9 +948,6 @@ struct Surface : QAbstractVideoSurface
 
 void tst_QDeclarativeAudio::videoOutput()
 {
-    QtTestMediaPlayerControl playerControl;
-    QtTestMediaServiceProvider provider(&playerControl, nullptr);
-
     QDeclarativeAudio audio;
     QSignalSpy spy(&audio, &QDeclarativeAudio::videoOutputChanged);
 
diff --git a/tests/auto/unit/qml/qdeclarativecamera/CMakeLists.txt b/tests/auto/unit/qml/qdeclarativecamera/CMakeLists.txt
deleted file mode 100644
index 32fff8b7a..000000000
--- a/tests/auto/unit/qml/qdeclarativecamera/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-# Generated from qdeclarativecamera.pro.
-
-#####################################################################
-## tst_qdeclarativecamera Test:
-#####################################################################
-
-qt_add_test(tst_qdeclarativecamera
-    GUI
-    QMLTEST
-    SOURCES
-        tst_qdeclarativecamera.cpp
-    INCLUDE_DIRECTORIES
-        ../../mockbackend
-    PUBLIC_LIBRARIES
-        # Remove: L${CMAKE_CURRENT_SOURCE_DIR}
-        Qt::Gui
-        Qt::MultimediaPrivate
-        QtMultimediaMockBackend
-)
-
-#### Keys ignored in scope 1:.:.:qdeclarativecamera.pro:<TRUE>:
-# OTHER_FILES = "tst_qdeclarativecamera.qml"
diff --git a/tests/auto/unit/qml/qdeclarativecamera/qdeclarativecamera.pro b/tests/auto/unit/qml/qdeclarativecamera/qdeclarativecamera.pro
deleted file mode 100644
index 3393303f3..000000000
--- a/tests/auto/unit/qml/qdeclarativecamera/qdeclarativecamera.pro
+++ /dev/null
@@ -1,12 +0,0 @@
-TARGET = tst_qdeclarativecamera
-CONFIG += warn_on qmltestcase
-
-QT += multimedia-private
-
-include (../../mockbackend/mockbackend.pri)
-
-SOURCES += \
-        tst_qdeclarativecamera.cpp
-
-OTHER_FILES += \
-    tst_qdeclarativecamera.qml
diff --git a/tests/auto/unit/qml/qdeclarativecamera/tst_qdeclarativecamera.cpp b/tests/auto/unit/qml/qdeclarativecamera/tst_qdeclarativecamera.cpp
deleted file mode 100644
index 2406e5be8..000000000
--- a/tests/auto/unit/qml/qdeclarativecamera/tst_qdeclarativecamera.cpp
+++ /dev/null
@@ -1,42 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <QtQuickTest/quicktest.h>
-
-#include "mockcameraservice.h"
-#include "mockmediaserviceprovider.h"
-
-int main(int argc, char **argv)
-{
-    MockMediaServiceProvider provider;
-    MockCameraService mockCameraService;
-    provider.service = &mockCameraService;
-    QMediaServiceProvider::setDefaultServiceProvider(&provider);
-
-    return quick_test_main(argc, argv, "QDeclarativeCamera", QUICK_TEST_SOURCE_DIR);
-}
diff --git a/tests/auto/unit/qml/qdeclarativecamera/tst_qdeclarativecamera.qml b/tests/auto/unit/qml/qdeclarativecamera/tst_qdeclarativecamera.qml
deleted file mode 100644
index 0841d4ec1..000000000
--- a/tests/auto/unit/qml/qdeclarativecamera/tst_qdeclarativecamera.qml
+++ /dev/null
@@ -1,296 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-import QtQuick 2.0
-import QtTest 1.0
-import QtMultimedia 5.4
-
-TestCase {
-
-    Component {
-        id: cameraComponent
-        Camera { }
-    }
-
-    Loader {
-        id: cameraLoader
-    }
-
-    SignalSpy {
-        id: deviceIdSpy
-        target: cameraLoader.item
-        signalName: "deviceIdChanged"
-    }
-
-    function test_deviceId() {
-        deviceIdSpy.clear();
-        cameraLoader.sourceComponent = cameraComponent;
-        var camera = cameraLoader.item;
-
-        // default camera
-        compare(camera.deviceId, "othercamera", "deviceId");
-        compare(camera.displayName, "othercamera desc", "displayName");
-        compare(camera.position, Camera.UnspecifiedPosition, "position");
-        compare(camera.orientation, 0, "orientation");
-
-        // setting an invalid camera ID should leave the item unchanged
-        camera.deviceId = "invalidcamera";
-        compare(camera.deviceId, "othercamera");
-        compare(deviceIdSpy.count, 0);
-        compare(camera.displayName, "othercamera desc", "displayName");
-        compare(camera.position, Camera.UnspecifiedPosition, "position");
-        compare(camera.orientation, 0, "orientation");
-
-        // change to another valid camera
-        camera.deviceId = "backcamera";
-        compare(camera.deviceId, "backcamera");
-        compare(deviceIdSpy.count, 1);
-        compare(camera.displayName, "backcamera desc", "displayName");
-        compare(camera.position, Camera.BackFace, "position");
-        compare(camera.orientation, 90, "orientation");
-
-        // setting an empty device ID should load the default camera
-        camera.deviceId = "";
-        compare(camera.deviceId, "othercamera", "deviceId");
-        compare(deviceIdSpy.count, 2);
-
-        cameraLoader.sourceComponent = undefined;
-    }
-
-    function test_position() {
-        deviceIdSpy.clear();
-        cameraLoader.sourceComponent = cameraComponent;
-        var camera = cameraLoader.item;
-
-        // default camera
-        compare(camera.position, Camera.UnspecifiedPosition, "position");
-        compare(camera.deviceId, "othercamera", "deviceId");
-
-        // setting an unavailable camera position should leave the item unchanged
-        camera.position = Camera.FrontFace;
-        compare(camera.position, Camera.UnspecifiedPosition, "position");
-        compare(camera.deviceId, "othercamera", "deviceId");
-        compare(deviceIdSpy.count, 0);
-
-        // change to an available position
-        camera.position = Camera.BackFace;
-        compare(camera.position, Camera.BackFace, "position");
-        compare(camera.deviceId, "backcamera", "deviceId");
-        compare(deviceIdSpy.count, 1);
-
-        // setting UnspecifiedPosition should load the default camera
-        camera.position = Camera.UnspecifiedPosition;
-        compare(camera.position, Camera.UnspecifiedPosition, "position");
-        compare(camera.deviceId, "othercamera", "deviceId");
-        compare(deviceIdSpy.count, 2);
-
-        cameraLoader.sourceComponent = undefined;
-    }
-
-    SignalSpy {
-        id: cameraStateSpy
-        target: cameraLoader.item
-        signalName: "cameraStateChanged"
-    }
-
-    function test_cameraState() {
-        deviceIdSpy.clear();
-        cameraStateSpy.clear();
-        cameraLoader.sourceComponent = cameraComponent;
-        var camera = cameraLoader.item;
-
-        // camera should be in ActiveState by default
-        compare(camera.cameraState, Camera.ActiveState, "cameraState");
-        compare(camera.deviceId, "othercamera", "deviceId");
-
-        // Changing the camera device should unload the previous camera and apply the current state
-        // to the new camera
-        camera.deviceId = "backcamera";
-        compare(camera.deviceId, "backcamera", "deviceId");
-        compare(camera.cameraState, Camera.ActiveState, "cameraState");
-        compare(cameraStateSpy.count, 2);
-        compare(cameraStateSpy.signalArguments[0][0], Camera.UnloadedState);
-        compare(cameraStateSpy.signalArguments[1][0], Camera.ActiveState);
-
-        cameraLoader.sourceComponent = undefined;
-    }
-
-    function test_supportedViewfinderResolutions_data() {
-        // see mockcameracontrol.h for expected values
-
-        return [
-            {
-                tag: "all",
-                minimumFrameRate: 0, maximumFrameRate: 0,
-                expectedResolutions: [
-                    { width: 320, height: 240 },
-                    { width: 640, height: 480 },
-                    { width: 1280, height: 720 },
-                    { width: 1920, height: 1080 }
-                ]
-            },
-            {
-                tag: "invalid minimumFrameRate",
-                minimumFrameRate: 2, maximumFrameRate: 0,
-                expectedResolutions: [ ]
-            },
-            {
-                tag: "minimumFrameRate=5",
-                minimumFrameRate: 5, maximumFrameRate: 0,
-                expectedResolutions: [
-                    { width: 1920, height: 1080 }
-                ]
-            },
-            {
-                tag: "minimumFrameRate=10",
-                minimumFrameRate: 10, maximumFrameRate: 0,
-                expectedResolutions: [
-                    { width: 1280, height: 720 }
-                ]
-            },
-            {
-                tag: "minimumFrameRate=30",
-                minimumFrameRate: 30, maximumFrameRate: 0,
-                expectedResolutions: [
-                    { width: 320, height: 240 },
-                    { width: 640, height: 480 },
-                    { width: 1280, height: 720 }
-                ]
-            },
-            {
-                tag: "invalid maximumFrameRate",
-                minimumFrameRate: 0, maximumFrameRate: 2,
-                expectedResolutions: [ ]
-            },
-            {
-                tag: "maximumFrameRate=10",
-                minimumFrameRate: 0, maximumFrameRate: 10,
-                expectedResolutions: [
-                    { width: 1280, height: 720 },
-                    { width: 1920, height: 1080 }
-                ]
-            },
-            {
-                tag: "minimumFrameRate=10, maximumFrameRate=10",
-                minimumFrameRate: 10, maximumFrameRate: 10,
-                expectedResolutions: [
-                    { width: 1280, height: 720 }
-                ]
-            },
-            {
-                tag: "minimumFrameRate=30, maximumFrameRate=30",
-                minimumFrameRate: 30, maximumFrameRate: 30,
-                expectedResolutions: [
-                    { width: 320, height: 240 },
-                    { width: 640, height: 480 },
-                    { width: 1280, height: 720 }
-                ]
-            }
-        ]
-    }
-
-    function test_supportedViewfinderResolutions(data) {
-        cameraLoader.sourceComponent = cameraComponent;
-        var camera = cameraLoader.item;
-
-        var actualResolutions = camera.supportedViewfinderResolutions(data.minimumFrameRate, data.maximumFrameRate);
-        compare(actualResolutions.length, data.expectedResolutions.length);
-        for (var i = 0; i < actualResolutions.length; ++i) {
-            compare(actualResolutions[i].width, data.expectedResolutions[i].width);
-            compare(actualResolutions[i].height, data.expectedResolutions[i].height);
-        }
-
-        cameraLoader.sourceComponent = undefined;
-    }
-
-    function test_supportedViewfinderFrameRateRanges_data() {
-        // see mockcameracontrol.h for expected values
-        return [
-            {
-                tag: "all",
-                expectedFrameRateRanges: [
-                    { minimumFrameRate: 5, maximumFrameRate: 10 },
-                    { minimumFrameRate: 10, maximumFrameRate: 10 },
-                    { minimumFrameRate: 30, maximumFrameRate: 30 }
-                ]
-            },
-            {
-                tag: "invalid",
-                resolution: { width: 452472, height: 444534 },
-                expectedFrameRateRanges: [ ]
-            },
-            {
-                tag: "320, 240",
-                resolution: { width: 320, height: 240 },
-                expectedFrameRateRanges: [
-                    { minimumFrameRate: 30, maximumFrameRate: 30 }
-                ]
-            },
-            {
-                tag: "1280, 720",
-                resolution: { width: 1280, height: 720 },
-                expectedFrameRateRanges: [
-                    { minimumFrameRate: 10, maximumFrameRate: 10 },
-                    { minimumFrameRate: 30, maximumFrameRate: 30 }
-                ]
-            },
-            {
-                tag: "1920, 1080",
-                resolution: { width: 1920, height: 1080 },
-                expectedFrameRateRanges: [
-                    { minimumFrameRate: 5, maximumFrameRate: 10 }
-                ]
-            }
-        ]
-    }
-
-    function test_supportedViewfinderFrameRateRanges(data) {
-        cameraLoader.sourceComponent = cameraComponent;
-        var camera = cameraLoader.item;
-
-        // Pass the resolution as an object
-        var actualFrameRateRanges = camera.supportedViewfinderFrameRateRanges(data.resolution);
-        compare(actualFrameRateRanges.length, data.expectedFrameRateRanges.length);
-        for (var i = 0; i < actualFrameRateRanges.length; ++i) {
-            compare(actualFrameRateRanges[i].minimumFrameRate, data.expectedFrameRateRanges[i].minimumFrameRate);
-            compare(actualFrameRateRanges[i].maximumFrameRate, data.expectedFrameRateRanges[i].maximumFrameRate);
-        }
-
-        // Pass the resolution as a size
-        if (typeof data.resolution !== 'undefined') {
-            actualFrameRateRanges = camera.supportedViewfinderFrameRateRanges(Qt.size(data.resolution.width, data.resolution.height));
-            compare(actualFrameRateRanges.length, data.expectedFrameRateRanges.length);
-            for (i = 0; i < actualFrameRateRanges.length; ++i) {
-                compare(actualFrameRateRanges[i].minimumFrameRate, data.expectedFrameRateRanges[i].minimumFrameRate);
-                compare(actualFrameRateRanges[i].maximumFrameRate, data.expectedFrameRateRanges[i].maximumFrameRate);
-            }
-        }
-
-        cameraLoader.sourceComponent = undefined;
-    }
-}
diff --git a/tests/auto/unit/qml/qdeclarativemultimediaglobal/tst_qdeclarativemultimediaglobal.cpp b/tests/auto/unit/qml/qdeclarativemultimediaglobal/tst_qdeclarativemultimediaglobal.cpp
index d78eb0076..4d8602358 100644
--- a/tests/auto/unit/qml/qdeclarativemultimediaglobal/tst_qdeclarativemultimediaglobal.cpp
+++ b/tests/auto/unit/qml/qdeclarativemultimediaglobal/tst_qdeclarativemultimediaglobal.cpp
@@ -28,15 +28,11 @@
 
 #include <QtQuickTest/quicktest.h>
 
-#include "mockcameraservice.h"
-#include "mockmediaserviceprovider.h"
+#include "qmockintegration_p.h"
 
 int main(int argc, char **argv)
 {
-    MockMediaServiceProvider provider;
-    MockCameraService mockCameraService;
-    provider.service = &mockCameraService;
-    QMediaServiceProvider::setDefaultServiceProvider(&provider);
+    QMockIntegration integration;
 
     return quick_test_main(argc, argv, "QDeclarativeMultimediaGlobal", QUICK_TEST_SOURCE_DIR);
 }
diff --git a/tests/auto/unit/qml/qml.pro b/tests/auto/unit/qml/qml.pro
index e8cdcb67e..786d3220d 100644
--- a/tests/auto/unit/qml/qml.pro
+++ b/tests/auto/unit/qml/qml.pro
@@ -3,7 +3,6 @@ TEMPLATE = subdirs
 SUBDIRS += \
     qdeclarativemultimediaglobal \
     qdeclarativeaudio \
-    qdeclarativecamera
 
 disabled {
     SUBDIRS += \