Move QPlatformCameraExposure API into QPlatformCamera

Clean up the internal API while we're at it and get rid of the
multiplexing API. Instead have virtual methods for each
property.

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

7 files changed, 98 insertions, 285 deletions

diff --git a/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp b/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp
index b13bfe3a4..3d1b970b5 100644
--- a/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp
+++ b/tests/auto/integration/qcamerabackend/tst_qcamerabackend.cpp
@@ -33,7 +33,6 @@
 #include <QDebug>
 
 #include <private/qplatformcamera_p.h>
-#include <private/qplatformcameraexposure_p.h>
 #include <private/qplatformcameraimagecapture_p.h>
 #include <private/qplatformcameraimageprocessing_p.h>
 #include <qcamera.h>
diff --git a/tests/auto/unit/mockbackend/CMakeLists.txt b/tests/auto/unit/mockbackend/CMakeLists.txt
index 8def1a078..0c471e7f1 100644
--- a/tests/auto/unit/mockbackend/CMakeLists.txt
+++ b/tests/auto/unit/mockbackend/CMakeLists.txt
@@ -15,7 +15,6 @@ target_link_libraries(QtMultimediaMockBackend INTERFACE
 target_sources(QtMultimediaMockBackend INTERFACE
     qmockaudiodecoder.h
     qmockcamera.h
-    qmockcameraexposure.h
     qmockcameraimageprocessing.h
     qmockimagecapture.h qmockimagecapture.cpp
     qmockmediaplayer.h
diff --git a/tests/auto/unit/mockbackend/qmockcamera.h b/tests/auto/unit/mockbackend/qmockcamera.h
index 9a8a6549f..5ccf79e2f 100644
--- a/tests/auto/unit/mockbackend/qmockcamera.h
+++ b/tests/auto/unit/mockbackend/qmockcamera.h
@@ -32,7 +32,6 @@
 #include "private/qplatformcamera_p.h"
 #include "qcamerainfo.h"
 #include "qmockcameraimageprocessing.h"
-#include "qmockcameraexposure.h"
 #include <qtimer.h>
 
 class QMockCamera : public QPlatformCamera
@@ -54,8 +53,14 @@ public:
           m_propertyChangesSupported(false)
     {
         if (!simpleCamera) {
-            mockExposure = new QMockCameraExposure(this);
             mockImageProcessing = new QMockCameraImageProcessing(this);
+            minIsoChanged(100);
+            maxIsoChanged(800);
+            minShutterSpeedChanged(.001);
+            maxShutterSpeedChanged(1);
+            exposureCompensationRangeChanged(-2, 2);
+            maximumZoomFactorChanged(4.);
+            setFlashMode(QCamera::FlashAuto);
         }
     }
 
@@ -90,17 +95,75 @@ public:
         m_camera = camera;
     }
 
-    void setFocusMode(QCamera::FocusMode mode) override { focusModeChanged(mode); }
-    bool isFocusModeSupported(QCamera::FocusMode /*mode*/) const override { return true; }
+    void setFocusMode(QCamera::FocusMode mode) override
+    {
+        if (isFocusModeSupported(mode))
+            focusModeChanged(mode);
+    }
+    bool isFocusModeSupported(QCamera::FocusMode mode) const override
+    { return simpleCamera ? mode == QCamera::FocusModeAuto : mode != QCamera::FocusModeInfinity; }
 
-    bool isCustomFocusPointSupported() const override { return true; }
-    void setCustomFocusPoint(const QPointF &point) override { customFocusPointChanged(point); }
+    bool isCustomFocusPointSupported() const override { return !simpleCamera; }
+    void setCustomFocusPoint(const QPointF &point) override
+    {
+        if (!simpleCamera)
+            customFocusPointChanged(point);
+    }
 
-    void setFocusDistance(float d) override { focusDistanceChanged(d); }
+    void setFocusDistance(float d) override
+    {
+        if (!simpleCamera)
+            focusDistanceChanged(d);
+    }
 
     void zoomTo(float newZoomFactor, float /*rate*/) override { zoomFactorChanged(newZoomFactor); }
 
-    QPlatformCameraExposure *exposureControl() override { return mockExposure; }
+    void setFlashMode(QCamera::FlashMode mode) override
+    {
+        if (!simpleCamera)
+            flashModeChanged(mode);
+        flashReadyChanged(mode != QCamera::FlashOff);
+    }
+    bool isFlashModeSupported(QCamera::FlashMode mode) const override { return simpleCamera ? mode == QCamera::FlashOff : true; }
+    bool isFlashReady() const override { return flashMode() != QCamera::FlashOff; }
+
+    void setExposureMode(QCamera::ExposureMode mode) override
+    {
+        if (!simpleCamera && isExposureModeSupported(mode))
+            exposureModeChanged(mode);
+    }
+    bool isExposureModeSupported(QCamera::ExposureMode mode) const override
+    {
+        return simpleCamera ? mode == QCamera::ExposureAuto : mode <= QCamera::ExposureBeach;
+    }
+    void setExposureCompensation(float c) override
+    {
+        if (!simpleCamera)
+            exposureCompensationChanged(qBound(-2., c, 2.));
+    }
+    int isoSensitivity() const override
+    {
+        if (simpleCamera)
+            return -1;
+        return manualIsoSensitivity() > 0 ? manualIsoSensitivity() : 100;
+    }
+    void setManualIsoSensitivity(int iso) override
+    {
+        if (!simpleCamera)
+            isoSensitivityChanged(qBound(100, iso, 800));
+    }
+    void setManualShutterSpeed(float secs) override
+    {
+        if (!simpleCamera)
+            shutterSpeedChanged(qBound(0.001, secs, 1.));
+    }
+    float shutterSpeed() const override
+    {
+        if (simpleCamera)
+            return -1.;
+        return manualShutterSpeed() > 0 ? manualShutterSpeed() : .05;
+    }
+
     QPlatformCameraImageProcessing *imageProcessingControl() override { return mockImageProcessing; }
 
     bool m_active = false;
@@ -108,7 +171,6 @@ public:
     QCameraInfo m_camera;
     bool m_propertyChangesSupported;
 
-    QMockCameraExposure *mockExposure = nullptr;
     QMockCameraImageProcessing *mockImageProcessing = nullptr;
 };
 
diff --git a/tests/auto/unit/mockbackend/qmockcameraexposure.h b/tests/auto/unit/mockbackend/qmockcameraexposure.h
deleted file mode 100644
index 61d5104b1..000000000
--- a/tests/auto/unit/mockbackend/qmockcameraexposure.h
+++ /dev/null
@@ -1,238 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2021 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 MOCKCAMERAEXPOSURECONTROL_H
-#define MOCKCAMERAEXPOSURECONTROL_H
-
-#include "private/qplatformcameraexposure_p.h"
-
-class QMockCameraExposure : public QPlatformCameraExposure
-{
-    Q_OBJECT
-public:
-    QMockCameraExposure(QObject *parent = 0):
-        QPlatformCameraExposure(parent),
-        m_shutterSpeed(0.01),
-        m_isoSensitivity(100),
-        m_exposureCompensation(0),
-        m_exposureMode(QCamera::ExposureAuto),
-        m_flashMode(QCamera::FlashAuto)
-    {
-        m_isoRanges << 100 << 200 << 400 << 800;
-        m_shutterRanges << 0.001 << 0.01 << 0.1 << 1.0;
-        m_exposureRanges << -2.0 << 2.0;
-
-        const QCamera::ExposureMode exposureModes[] = {
-            QCamera::ExposureAuto,
-            QCamera::ExposureManual,
-            QCamera::ExposureNight,
-            QCamera::ExposureSports,
-            QCamera::ExposureSnow,
-            QCamera::ExposurePortrait,
-            QCamera::ExposureBeach
-        };
-
-        for (QCamera::ExposureMode mode : exposureModes)
-            m_exposureModes << QVariant::fromValue<QCamera::ExposureMode>(mode);
-    }
-
-    ~QMockCameraExposure() {}
-
-    bool isParameterSupported(ExposureParameter parameter) const
-    {
-        switch (parameter) {
-        case QPlatformCameraExposure::ExposureMode:
-        case QPlatformCameraExposure::ExposureCompensation:
-        case QPlatformCameraExposure::ISO:
-        case QPlatformCameraExposure::ShutterSpeed:
-            return true;
-        default:
-            return false;
-        }
-    }
-
-    QVariant requestedValue(ExposureParameter param) const
-    {
-        return m_requestedParameters.value(param);
-    }
-
-    QVariant actualValue(ExposureParameter param) const
-    {
-        switch (param) {
-        case QPlatformCameraExposure::ExposureMode:
-            return QVariant::fromValue<QCamera::ExposureMode>(m_exposureMode);
-        case QPlatformCameraExposure::ExposureCompensation:
-            return QVariant(m_exposureCompensation);
-        case QPlatformCameraExposure::ISO:
-            return QVariant(m_isoSensitivity);
-        case QPlatformCameraExposure::ShutterSpeed:
-            return QVariant(m_shutterSpeed);
-        default:
-            return QVariant();
-        }
-    }
-
-    QVariantList supportedParameterRange(ExposureParameter parameter, bool *continuous) const
-    {
-        *continuous = false;
-
-        QVariantList res;
-        switch (parameter) {
-        case QPlatformCameraExposure::ExposureCompensation:
-            *continuous = true;
-            return m_exposureRanges;
-        case QPlatformCameraExposure::ISO:
-            return m_isoRanges;
-        case QPlatformCameraExposure::ShutterSpeed:
-            *continuous = true;
-            return m_shutterRanges;
-        case QPlatformCameraExposure::ExposureMode:
-            return m_exposureModes;
-        default:
-            break;
-        }
-
-        return res;
-    }
-
-    // Added valueChanged  and parameterRangeChanged signal
-    bool setValue(ExposureParameter param, const QVariant& value)
-    {
-        if (!isParameterSupported(param))
-            return false;
-
-        if (m_requestedParameters.value(param) != value) {
-            m_requestedParameters.insert(param, value);
-            emit requestedValueChanged(param);
-        }
-
-        switch (param) {
-        case QPlatformCameraExposure::ExposureMode:
-        {
-            QCamera::ExposureMode mode = value.value<QCamera::ExposureMode>();
-            if (mode != m_exposureMode && m_exposureModes.contains(value)) {
-                m_exposureMode = mode;
-                emit actualValueChanged(param);
-            }
-        }
-            break;
-        case QPlatformCameraExposure::ExposureCompensation:
-        {
-            m_res.clear();
-            m_res << -4.0 << 4.0;
-            qreal exposureCompensationlocal = qBound<qreal>(-2.0, value.toReal(), 2.0);
-            if (actualValue(param).toReal() !=  exposureCompensationlocal) {
-                m_exposureCompensation = exposureCompensationlocal;
-                emit actualValueChanged(param);
-            }
-
-            if (m_exposureRanges.last().toReal() != m_res.last().toReal()) {
-                m_exposureRanges.clear();
-                m_exposureRanges = m_res;
-                emit parameterRangeChanged(param);
-            }
-        }
-            break;
-        case QPlatformCameraExposure::ISO:
-        {
-            m_res.clear();
-            m_res << 20 << 50;
-            qreal exposureCompensationlocal = 100*qRound(qBound(100, value.toInt(), 800)/100.0);
-            if (actualValue(param).toReal() !=  exposureCompensationlocal) {
-                m_isoSensitivity = exposureCompensationlocal;
-                emit actualValueChanged(param);
-            }
-
-            if (m_isoRanges.last().toInt() != m_res.last().toInt()) {
-                m_isoRanges.clear();
-                m_isoRanges = m_res;
-                emit parameterRangeChanged(param);
-            }
-        }
-            break;
-       case QPlatformCameraExposure::ShutterSpeed:
-        {
-            m_res.clear();
-            m_res << 0.12 << 1.0 << 2.0;
-            qreal exposureCompensationlocal = qBound<qreal>(0.001, value.toReal(), 1.0);
-            if (actualValue(param).toReal() !=  exposureCompensationlocal) {
-                m_shutterSpeed = exposureCompensationlocal;
-                emit actualValueChanged(param);
-            }
-
-            if (m_shutterRanges.last().toReal() != m_res.last().toReal()) {
-                m_shutterRanges.clear();
-                m_shutterRanges = m_res;
-                emit parameterRangeChanged(param);
-            }
-        }
-            break;
-
-        default:
-            return false;
-        }
-
-        return true;
-    }
-
-    QCamera::FlashMode flashMode() const
-    {
-        return m_flashMode;
-    }
-
-    void setFlashMode(QCamera::FlashMode mode)
-    {
-        if (isFlashModeSupported(mode)) {
-            m_flashMode = mode;
-        }
-        emit flashReady(true);
-    }
-    //Setting the values for Flash mode
-
-    bool isFlashModeSupported(QCamera::FlashMode /*mode*/) const
-    {
-        return true;
-    }
-
-    bool isFlashReady() const
-    {
-        return true;
-    }
-
-private:
-    qreal m_shutterSpeed;
-    int m_isoSensitivity;
-    qreal m_exposureCompensation;
-    QCamera::ExposureMode m_exposureMode;
-    QCamera::FlashMode m_flashMode;
-    QVariantList m_isoRanges, m_shutterRanges, m_exposureRanges, m_res, m_exposureModes;
-
-    QMap<QPlatformCameraExposure::ExposureParameter, QVariant> m_requestedParameters;
-};
-
-#endif // MOCKCAMERAEXPOSURECONTROL_H
diff --git a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
index 6f5c584c5..290ed8d1f 100644
--- a/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
+++ b/tests/auto/unit/multimedia/qcamera/tst_qcamera.cpp
@@ -33,7 +33,6 @@
 
 #include <qvideosink.h>
 #include <private/qplatformcamera_p.h>
-#include <private/qplatformcameraexposure_p.h>
 #include <private/qplatformcameraimagecapture_p.h>
 #include <private/qplatformcameraimageprocessing_p.h>
 #include <qcamera.h>
@@ -154,7 +153,8 @@ void tst_QCamera::testSimpleCameraExposure()
     QMockCamera::Simple simple;
 
     QCamera camera;
-    QVERIFY(!camera.isExposureModeSupported(QCamera::ExposureAuto));
+    QVERIFY(camera.isExposureModeSupported(QCamera::ExposureAuto));
+    QVERIFY(!camera.isExposureModeSupported(QCamera::ExposureManual));
     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);
     camera.setExposureMode(QCamera::ExposureManual);//should be ignored
     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);
@@ -170,14 +170,16 @@ void tst_QCamera::testSimpleCameraExposure()
     QCOMPARE(camera.exposureCompensation(), 0.0);
 
     QCOMPARE(camera.isoSensitivity(), -1);
-    QVERIFY(camera.supportedIsoSensitivities().isEmpty());
+    QCOMPARE(camera.minimumIsoSensitivity(), -1);
+    QCOMPARE(camera.maximumIsoSensitivity(), -1);
     camera.setManualIsoSensitivity(100);
     QCOMPARE(camera.isoSensitivity(), -1);
     camera.setAutoIsoSensitivity();
     QCOMPARE(camera.isoSensitivity(), -1);
 
     QVERIFY(camera.shutterSpeed() < 0);
-    QVERIFY(camera.supportedShutterSpeeds().isEmpty());
+    QCOMPARE(camera.minimumShutterSpeed(), -1.);
+    QCOMPARE(camera.maximumShutterSpeed(), -1.);
     camera.setAutoShutterSpeed();
     QVERIFY(camera.shutterSpeed() < 0);
     camera.setManualShutterSpeed(1/128.0);
@@ -190,11 +192,11 @@ void tst_QCamera::testSimpleCameraFocus()
 
     QCamera camera;
 
-    QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeAuto));
+    QVERIFY(camera.isFocusModeSupported(QCamera::FocusModeAuto));
     QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeInfinity));
 
     QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
-    camera.setFocusMode(QCamera::FocusModeAuto);
+    camera.setFocusMode(QCamera::FocusModeInfinity);
     QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
 
     QCOMPARE(camera.maximumZoomFactor(), 1.0);
@@ -206,7 +208,7 @@ void tst_QCamera::testSimpleCameraFocus()
 
     QCOMPARE(camera.customFocusPoint(), QPointF(-1., -1.));
     camera.setCustomFocusPoint(QPointF(1.0, 1.0));
-    QCOMPARE(camera.customFocusPoint(), QPointF(-1, -1));
+    QCOMPARE(camera.customFocusPoint(), QPointF(-1., -1.));
 }
 
 void tst_QCamera::testSimpleCameraCapture()
@@ -370,28 +372,24 @@ void tst_QCamera::testCameraExposure()
     camera.setExposureCompensation(2.0);
     QCOMPARE(camera.exposureCompensation(), 2.0);
 
-    int minIso = camera.supportedIsoSensitivities().first();
-    int maxIso = camera.supportedIsoSensitivities().last();
-    QVERIFY(camera.isoSensitivity() > 0);
-    QCOMPARE(camera.requestedIsoSensitivity(), -1);
+    int minIso = camera.minimumIsoSensitivity();
+    int maxIso = camera.maximumIsoSensitivity();
+    QCOMPARE(camera.isoSensitivity(), 100);
     QVERIFY(minIso > 0);
     QVERIFY(maxIso > 0);
     camera.setManualIsoSensitivity(minIso);
     QCOMPARE(camera.isoSensitivity(), minIso);
     camera.setManualIsoSensitivity(maxIso*10);
     QCOMPARE(camera.isoSensitivity(), maxIso);
-    QCOMPARE(camera.requestedIsoSensitivity(), maxIso*10);
 
     camera.setManualIsoSensitivity(-10);
     QCOMPARE(camera.isoSensitivity(), minIso);
-    QCOMPARE(camera.requestedIsoSensitivity(), -10);
     camera.setAutoIsoSensitivity();
     QCOMPARE(camera.isoSensitivity(), 100);
-    QCOMPARE(camera.requestedIsoSensitivity(), -1);
 
-    QCOMPARE(camera.requestedShutterSpeed(), -1.0);
-    qreal minShutterSpeed = camera.supportedShutterSpeeds().first();
-    qreal maxShutterSpeed = camera.supportedShutterSpeeds().last();
+    qreal minShutterSpeed = camera.minimumShutterSpeed();
+    qreal maxShutterSpeed = camera.maximumShutterSpeed();
+    qDebug() << minShutterSpeed << maxShutterSpeed;
     QVERIFY(minShutterSpeed > 0);
     QVERIFY(maxShutterSpeed > 0);
     QVERIFY(camera.shutterSpeed() >= minShutterSpeed);
@@ -400,18 +398,14 @@ void tst_QCamera::testCameraExposure()
     camera.setAutoShutterSpeed();
     QVERIFY(camera.shutterSpeed() >= minShutterSpeed);
     QVERIFY(camera.shutterSpeed() <= maxShutterSpeed);
-    QCOMPARE(camera.requestedShutterSpeed(), -1.0);
 
     camera.setManualShutterSpeed(0);
     QCOMPARE(camera.shutterSpeed(), minShutterSpeed);
-    QCOMPARE(camera.requestedShutterSpeed()+1.0, 1.0);
 
     camera.setManualShutterSpeed(10000);
     QCOMPARE(camera.shutterSpeed(), maxShutterSpeed);
-    QCOMPARE(camera.requestedShutterSpeed(), 10000.0);
 
     camera.setAutoShutterSpeed();
-    QCOMPARE(camera.requestedShutterSpeed(), -1.0);
 }
 
 void tst_QCamera::testCameraFocus()
@@ -424,7 +418,9 @@ void tst_QCamera::testCameraFocus()
 
     QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
     camera.setFocusMode(QCamera::FocusModeManual);
-    QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
+    QCOMPARE(camera.focusMode(), QCamera::FocusModeManual);
+    camera.setFocusMode(QCamera::FocusModeInfinity);
+    QCOMPARE(camera.focusMode(), QCamera::FocusModeManual);
     camera.setFocusMode(QCamera::FocusModeAuto);
     QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
 
@@ -844,15 +840,14 @@ void tst_QCamera::testFocusMode()
     QCamera camera;
     session.setCamera(&camera);
 
-    QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeHyperfocal));
-    QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeAutoNear));
+    QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeInfinity));
+    QVERIFY(camera.isFocusModeSupported(QCamera::FocusModeAutoNear));
     QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
-    camera.setFocusMode(QCamera::FocusModeHyperfocal);
-    QVERIFY(camera.focusMode()!= QCamera::FocusModeHyperfocal);
+    camera.setFocusMode(QCamera::FocusModeInfinity);
+    QVERIFY(camera.focusMode() != QCamera::FocusModeInfinity);
     QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
     camera.setFocusMode(QCamera::FocusModeAutoNear);
-    QVERIFY(camera.focusMode()!= QCamera::FocusModeAutoNear);
-    QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
+    QVERIFY(camera.focusMode() == QCamera::FocusModeAutoNear);
 }
 
 void tst_QCamera::testZoomChanged()
@@ -934,7 +929,6 @@ void tst_QCamera::testSignalShutterSpeedChanged()
     session.setCamera(&camera);
 
     QSignalSpy spySignalShutterSpeedChanged(&camera, SIGNAL(shutterSpeedChanged(qreal)));
-    QSignalSpy spySignalShutterSpeedRangeChanged(&camera, SIGNAL(shutterSpeedRangeChanged()));
 
     QVERIFY(spySignalShutterSpeedChanged.count() ==0);
 
@@ -942,7 +936,6 @@ void tst_QCamera::testSignalShutterSpeedChanged()
     QTest::qWait(100);
 
     QVERIFY(spySignalShutterSpeedChanged.count() ==1);
-    QVERIFY(spySignalShutterSpeedRangeChanged.count() ==1);
 }
 
 void tst_QCamera::testSignalFlashReady()
@@ -953,15 +946,15 @@ void tst_QCamera::testSignalFlashReady()
 
     QSignalSpy spyflashReady(&camera,SIGNAL(flashReady(bool)));
 
-    QVERIFY(spyflashReady.count() ==0);
+    QVERIFY(spyflashReady.count() == 0);
 
-    QVERIFY(camera.flashMode() ==QCamera::FlashAuto);
+    QVERIFY(camera.flashMode() == QCamera::FlashAuto);
 
     camera.setFlashMode(QCamera::FlashOff);//set theFlashMode to QCamera::FlashOff
 
-    QVERIFY(camera.flashMode() ==QCamera::FlashOff);
+    QVERIFY(camera.flashMode() == QCamera::FlashOff);
 
-    QVERIFY(spyflashReady.count() ==1);
+    QCOMPARE(spyflashReady.count(), 1);
 }
 
 QTEST_MAIN(tst_QCamera)
diff --git a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
index 78c1d4c99..2b11636c0 100644
--- a/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
+++ b/tests/auto/unit/multimedia/qcameraimagecapture/tst_qcameraimagecapture.cpp
@@ -30,7 +30,6 @@
 #include <QDebug>
 
 #include <private/qplatformcamera_p.h>
-#include <private/qplatformcameraexposure_p.h>
 #include <private/qplatformcameraimagecapture_p.h>
 #include <private/qplatformcameraimageprocessing_p.h>
 #include <qcamera.h>
diff --git a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp
index 235294779..00cfc1646 100644
--- a/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp
+++ b/tests/auto/unit/multimediawidgets/qcamerawidgets/tst_qcamerawidgets.cpp
@@ -32,7 +32,6 @@
 #include <QDebug>
 
 #include <private/qplatformcamera_p.h>
-#include <private/qplatformcameraexposure_p.h>
 #include <private/qplatformcameraimagecapture_p.h>
 #include <private/qplatformcameraimageprocessing_p.h>
 #include <qmediacapturesession.h>