Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include "qmockintegration.h"
#include "qmockmediacapturesession.h"
#include "qmockcamera.h"
#include <QtMultimediaTestLib/private/mediabackendutils_p.h>
#include <QtTest/qsignalspy.h>
#include <QtTest/qtest.h>
#include <QtMultimedia/qcamera.h>
#include <QtMultimedia/qcameradevice.h>
#include <QtMultimedia/qimagecapture.h>
#include <QtMultimedia/qmediacapturesession.h>
#include <QtMultimedia/qmediadevices.h>
#include <QtMultimedia/qvideosink.h>
#include <QtMultimedia/private/qplatformcamera_p.h>
#include <QtMultimedia/private/qplatformimagecapture_p.h>
#include <QtCore/qdebug.h>
#include <QtCore/qobject.h>
Q_ENABLE_MOCK_MULTIMEDIA_PLUGIN
class tst_QCamera: public QObject
{
Q_OBJECT
public slots:
void initTestCase();
void init();
void cleanup();
private slots:
void testSimpleCamera();
void testSimpleCameraWhiteBalance();
void testSimpleCameraExposure();
void testSimpleCameraFocus();
void testSimpleCameraCapture();
void testCameraWhiteBalance();
void testCameraExposure();
void testCameraFocus();
void testCameraCapture();
void testCameraCaptureMetadata();
void testCameraEncodingProperyChange();
void testConstructor();
void testQCameraIsAvailable();
void testErrorSignal();
void testError();
void testErrorString();
void testSetCameraFormat();
// Test cases to for focus handling
void testFocusMode();
void testZoomChanged();
void testMaxZoomChangedSignal();
// Test cases for QPlatformCamera class.
void testCameraControl();
void testSetVideoOutput();
void testSetVideoOutputDestruction();
void testEnumDebug();
// Signals test cases for exposure related properties
void testSignalExposureCompensationChanged();
void testSignalIsoSensitivityChanged();
void testSignalShutterSpeedChanged();
void testSignalFlashReady();
};
void tst_QCamera::initTestCase()
{
#ifdef Q_OS_MACOS
if (isCI())
QSKIP("Flakiness on macOS CI, to be investigated, QTBUG-111812");
#endif
}
void tst_QCamera::init()
{
}
void tst_QCamera::cleanup()
{
}
void tst_QCamera::testSimpleCamera()
{
QMockCamera::Simple simple;
QCamera camera;
QCOMPARE(camera.isActive(), false);
camera.start();
QCOMPARE(camera.isActive(), true);
camera.stop();
QCOMPARE(camera.isActive(), false);
}
void tst_QCamera::testSimpleCameraWhiteBalance()
{
QMockCamera::Simple simple;
QCamera camera;
//only WhiteBalanceAuto is supported
QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceAuto));
QVERIFY(!camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceManual));
QVERIFY(!camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceCloudy));
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
camera.setWhiteBalanceMode(QCamera::WhiteBalanceCloudy);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
QCOMPARE(camera.colorTemperature(), 0);
camera.setColorTemperature(5000);
QCOMPARE(camera.colorTemperature(), 0);
}
void tst_QCamera::testSimpleCameraExposure()
{
QMockCamera::Simple simple;
QCamera camera;
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);
QVERIFY(!camera.isFlashModeSupported(QCamera::FlashOn));
QCOMPARE(camera.flashMode(), QCamera::FlashOff);
QCOMPARE(camera.isFlashReady(), false);
camera.setFlashMode(QCamera::FlashOn);
QCOMPARE(camera.flashMode(), QCamera::FlashOff);
QCOMPARE(camera.exposureCompensation(), 0.0);
camera.setExposureCompensation(2.0);
QCOMPARE(camera.exposureCompensation(), 0.0);
QCOMPARE(camera.isoSensitivity(), -1);
QCOMPARE(camera.minimumIsoSensitivity(), -1);
QCOMPARE(camera.maximumIsoSensitivity(), -1);
camera.setManualIsoSensitivity(100);
QCOMPARE(camera.isoSensitivity(), -1);
camera.setAutoIsoSensitivity();
QCOMPARE(camera.isoSensitivity(), -1);
QVERIFY(camera.exposureTime() < 0);
QCOMPARE(camera.minimumExposureTime(), -1.);
QCOMPARE(camera.maximumExposureTime(), -1.);
camera.setAutoExposureTime();
QVERIFY(camera.exposureTime() < 0);
camera.setManualExposureTime(1/128.0);
QVERIFY(camera.exposureTime() < 0);
}
void tst_QCamera::testSimpleCameraFocus()
{
QMockCamera::Simple simple;
QCamera camera;
QVERIFY(camera.isFocusModeSupported(QCamera::FocusModeAuto));
QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeInfinity));
QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
camera.setFocusMode(QCamera::FocusModeInfinity);
QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
QCOMPARE(camera.maximumZoomFactor(), 1.0);
QCOMPARE(camera.minimumZoomFactor(), 1.0);
QCOMPARE(camera.zoomFactor(), 1.0);
camera.zoomTo(100.0, 100.0);
QCOMPARE(camera.zoomFactor(), 1.0);
QCOMPARE(camera.customFocusPoint(), QPointF(-1., -1.));
camera.setCustomFocusPoint(QPointF(1.0, 1.0));
QCOMPARE(camera.customFocusPoint(), QPointF(-1., -1.));
}
void tst_QCamera::testSimpleCameraCapture()
{
QMockCamera::Simple simple;
QMediaCaptureSession session;
QCamera camera;
QImageCapture imageCapture;
session.setCamera(&camera);
session.setImageCapture(&imageCapture);
QVERIFY(!imageCapture.isReadyForCapture());
QVERIFY(imageCapture.isAvailable());
QCOMPARE(imageCapture.error(), QImageCapture::NoError);
QVERIFY(imageCapture.errorString().isEmpty());
QSignalSpy errorSignal(&imageCapture, &QImageCapture::errorOccurred);
imageCapture.captureToFile(QStringLiteral("/dev/null"));
QCOMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QImageCapture::NotReadyError);
QVERIFY(!imageCapture.errorString().isEmpty());
camera.start();
imageCapture.captureToFile(QStringLiteral("/dev/null"));
QCOMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QImageCapture::NoError);
QVERIFY(imageCapture.errorString().isEmpty());
}
void tst_QCamera::testCameraCapture()
{
QMediaCaptureSession session;
QCamera camera;
QImageCapture imageCapture;
session.setCamera(&camera);
session.setImageCapture(&imageCapture);
QVERIFY(!imageCapture.isReadyForCapture());
QSignalSpy capturedSignal(&imageCapture, &QImageCapture::imageCaptured);
QSignalSpy errorSignal(&imageCapture, &QImageCapture::errorOccurred);
imageCapture.captureToFile(QStringLiteral("/dev/null"));
QCOMPARE(capturedSignal.size(), 0);
QCOMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QImageCapture::NotReadyError);
errorSignal.clear();
camera.start();
QVERIFY(imageCapture.isReadyForCapture());
QCOMPARE(errorSignal.size(), 0);
imageCapture.captureToFile(QStringLiteral("/dev/null"));
QTRY_COMPARE(capturedSignal.size(), 1);
QCOMPARE(errorSignal.size(), 0);
QCOMPARE(imageCapture.error(), QImageCapture::NoError);
}
void tst_QCamera::testCameraCaptureMetadata()
{
QMediaCaptureSession session;
QCamera camera;
QImageCapture imageCapture;
session.setCamera(&camera);
session.setImageCapture(&imageCapture);
QSignalSpy metadataSignal(&imageCapture, &QImageCapture::imageMetadataAvailable);
QSignalSpy savedSignal(&imageCapture, &QImageCapture::imageSaved);
camera.start();
int id = imageCapture.captureToFile(QStringLiteral("/dev/null"));
QTRY_COMPARE(savedSignal.size(), 1);
QCOMPARE(metadataSignal.size(), 1);
QVariantList metadata = metadataSignal[0];
QCOMPARE(metadata[0].toInt(), id);
QMediaMetaData data = metadata[1].value<QMediaMetaData>();
QCOMPARE(data.keys().size(), 2);
QCOMPARE(data[QMediaMetaData::Author].toString(), "Author");
QCOMPARE(data[QMediaMetaData::Date].toDateTime().date().year(), 2021);
}
void tst_QCamera::testCameraWhiteBalance()
{
QCamera camera;
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
camera.setWhiteBalanceMode(QCamera::WhiteBalanceFlash);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceAuto));
QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceManual));
QVERIFY(camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceSunlight));
QVERIFY(!camera.isWhiteBalanceModeSupported(QCamera::WhiteBalanceCloudy));
camera.setWhiteBalanceMode(QCamera::WhiteBalanceSunlight);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceSunlight);
camera.setWhiteBalanceMode(QCamera::WhiteBalanceManual);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceManual);
camera.setColorTemperature(4000);
QCOMPARE(camera.colorTemperature(), 4000);
camera.setColorTemperature(8000);
QCOMPARE(camera.colorTemperature(), 8000);
camera.setWhiteBalanceMode(QCamera::WhiteBalanceAuto);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
camera.setColorTemperature(4000);
QCOMPARE(camera.colorTemperature(), 4000);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceManual);
camera.setColorTemperature(0);
QCOMPARE(camera.colorTemperature(), 0);
QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);
}
void tst_QCamera::testCameraExposure()
{
QCamera camera;
QVERIFY(camera.isExposureModeSupported(QCamera::ExposureAuto));
QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);
QVERIFY(camera.isExposureModeSupported(QCamera::ExposureManual));
camera.setExposureMode(QCamera::ExposureManual);
QCOMPARE(camera.exposureMode(), QCamera::ExposureManual);
QVERIFY(camera.isExposureModeSupported(QCamera::ExposureNight));
camera.setExposureMode(QCamera::ExposureNight);
QCOMPARE(camera.exposureMode(), QCamera::ExposureNight);
QVERIFY(camera.isExposureModeSupported(QCamera::ExposureSports ));
camera.setExposureMode(QCamera::ExposureSports);
QCOMPARE(camera.exposureMode(), QCamera::ExposureSports);
QVERIFY(camera.isExposureModeSupported(QCamera::ExposureSnow ));
camera.setExposureMode(QCamera::ExposureSnow);
QCOMPARE(camera.exposureMode(), QCamera::ExposureSnow);
QVERIFY(camera.isExposureModeSupported(QCamera::ExposureBeach ));
camera.setExposureMode(QCamera::ExposureBeach);
QCOMPARE(camera.exposureMode(), QCamera::ExposureBeach);
QVERIFY(camera.isExposureModeSupported(QCamera::ExposurePortrait ));
camera.setExposureMode(QCamera::ExposurePortrait);
QCOMPARE(camera.exposureMode(), QCamera::ExposurePortrait);
camera.setFlashMode(QCamera::FlashAuto);
QCOMPARE(camera.flashMode(), QCamera::FlashAuto);
QCOMPARE(camera.isFlashReady(), true);
camera.setFlashMode(QCamera::FlashOn);
QCOMPARE(camera.flashMode(), QCamera::FlashOn);
QCOMPARE(camera.exposureCompensation(), 0.0);
camera.setExposureCompensation(2.0);
QCOMPARE(camera.exposureCompensation(), 2.0);
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);
camera.setManualIsoSensitivity(-10);
QCOMPARE(camera.isoSensitivity(), minIso);
camera.setAutoIsoSensitivity();
QCOMPARE(camera.isoSensitivity(), 100);
qreal minExposureTime = camera.minimumExposureTime();
qreal maxExposureTime = camera.maximumExposureTime();
QVERIFY(minExposureTime > 0);
QVERIFY(maxExposureTime > 0);
QVERIFY(camera.exposureTime() >= minExposureTime);
QVERIFY(camera.exposureTime() <= maxExposureTime);
camera.setAutoExposureTime();
QVERIFY(camera.exposureTime() >= minExposureTime);
QVERIFY(camera.exposureTime() <= maxExposureTime);
camera.setManualExposureTime(0);
QCOMPARE(camera.exposureTime(), minExposureTime);
camera.setManualExposureTime(10000);
QCOMPARE(camera.exposureTime(), maxExposureTime);
camera.setAutoExposureTime();
}
void tst_QCamera::testCameraFocus()
{
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::FocusModeManual);
QCOMPARE(camera.focusMode(), QCamera::FocusModeManual);
camera.setFocusMode(QCamera::FocusModeInfinity);
QCOMPARE(camera.focusMode(), QCamera::FocusModeManual);
camera.setFocusMode(QCamera::FocusModeAuto);
QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
QVERIFY(camera.maximumZoomFactor() == 4.0);
QVERIFY(camera.minimumZoomFactor() == 1.0);
QCOMPARE(camera.zoomFactor(), 1.0);
camera.zoomTo(0.5, 1.0);
QCOMPARE(camera.zoomFactor(), 1.0);
camera.zoomTo(2.0, 0.5);
QCOMPARE(camera.zoomFactor(), 2.0);
camera.zoomTo(2.5, 1);
QCOMPARE(camera.zoomFactor(), 2.5);
camera.zoomTo(2000000.0, 0);
QCOMPARE(camera.zoomFactor(), camera.maximumZoomFactor());
QCOMPARE(camera.customFocusPoint(), QPointF(-1, -1));
camera.setCustomFocusPoint(QPointF(1.0, 1.0));
QCOMPARE(camera.customFocusPoint(), QPointF(1.0, 1.0));
}
void tst_QCamera::testCameraEncodingProperyChange()
{
QMediaCaptureSession session;
QCamera camera;
QImageCapture imageCapture;
session.setCamera(&camera);
session.setImageCapture(&imageCapture);
QSignalSpy activeChangedSignal(&camera, &QCamera::activeChanged);
camera.start();
QCOMPARE(camera.isActive(), true);
QCOMPARE(activeChangedSignal.size(), 1);
}
void tst_QCamera::testSetVideoOutput()
{
QMediaCaptureSession session;
QVideoSink surface;
QCamera camera;
session.setCamera(&camera);
QVERIFY(!session.videoOutput());
session.setVideoOutput(&surface);
QVERIFY(session.videoOutput() == &surface);
QVERIFY(session.videoSink() == &surface);
session.setVideoOutput(static_cast<QVideoSink *>(nullptr));
QVERIFY(session.videoOutput() == nullptr);
QVERIFY(session.videoSink() == nullptr);
session.setVideoOutput(&surface);
QVERIFY(session.videoOutput() == &surface);
QVERIFY(session.videoSink() == &surface);
session.setVideoSink(&surface);
QVERIFY(session.videoOutput() == nullptr);
QVERIFY(session.videoSink() == &surface);
session.setVideoOutput(&surface);
QVERIFY(session.videoOutput() == &surface);
QVERIFY(session.videoSink() == &surface);
session.setVideoSink(nullptr);
QVERIFY(session.videoOutput() == nullptr);
QVERIFY(session.videoSink() == nullptr);
}
void tst_QCamera::testSetVideoOutputDestruction()
{
{
QVideoSink surface;
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QVERIFY(session.videoOutput() == nullptr);
session.setVideoOutput(&surface);
}
}
{
QMediaCaptureSession session;
{
QVideoSink surface;
QCamera camera;
session.setCamera(&camera);
QVERIFY(session.videoOutput() == nullptr);
session.setVideoOutput(&surface);
}
}
{
QCamera camera;
{
QMediaCaptureSession session;
QVideoSink surface;
session.setCamera(&camera);
QVERIFY(session.videoOutput() == nullptr);
session.setVideoOutput(&surface);
}
}
{
QMediaCaptureSession session;
{
QVideoSink surface;
QCamera camera;
session.setCamera(&camera);
QVERIFY(session.videoOutput() == nullptr);
session.setVideoOutput(&surface);
}
}
}
void tst_QCamera::testEnumDebug()
{
QTest::ignoreMessage(QtDebugMsg, "QCamera::CameraError");
qDebug() << QCamera::CameraError;
// QTest::ignoreMessage(QtDebugMsg, "QCameraDevice::FrontFace");
// qDebug() << QCameraDevice::FrontFace;
}
void tst_QCamera::testCameraControl()
{
QCamera camera;
QMockCamera *m_cameraControl = new QMockCamera(&camera);
QVERIFY(m_cameraControl != nullptr);
}
void tst_QCamera::testConstructor()
{
auto cameras = QMediaDevices::videoInputs();
QCameraDevice defaultCamera = QMediaDevices::defaultVideoInput();
QCameraDevice frontCamera, backCamera;
for (const auto &c : cameras) {
if (frontCamera.isNull() && c.position() == QCameraDevice::FrontFace)
frontCamera = c;
if (backCamera.isNull() && c.position() == QCameraDevice::BackFace)
backCamera = c;
}
QVERIFY(!defaultCamera.isNull());
QVERIFY(!frontCamera.isNull());
QVERIFY(!backCamera.isNull());
{
QCamera camera;
QCOMPARE(camera.isAvailable(), true);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(camera.cameraDevice(), defaultCamera);
}
{
QCamera camera(QCameraDevice::FrontFace);
QCOMPARE(camera.isAvailable(), true);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(camera.cameraDevice(), frontCamera);
}
{
QCamera camera(QMediaDevices::defaultVideoInput());
QCOMPARE(camera.isAvailable(), true);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(camera.cameraDevice(), defaultCamera);
}
{
QCameraDevice cameraDevice = QMediaDevices::videoInputs().at(0);
QCamera camera(cameraDevice);
QCOMPARE(camera.isAvailable(), true);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(camera.cameraDevice(), cameraDevice);
}
{
QCamera camera(QCameraDevice::BackFace);
QCOMPARE(camera.isAvailable(), true);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(camera.cameraDevice(), backCamera);
}
{
// Should load the default camera when UnspecifiedPosition is requested
QCamera camera(QCameraDevice::UnspecifiedPosition);
QCOMPARE(camera.isAvailable(), true);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(camera.cameraDevice(), defaultCamera);
}
}
/* Test case for isAvailable */
void tst_QCamera::testQCameraIsAvailable()
{
QCamera camera;
QVERIFY(camera.isAvailable());
}
/* Test case for verifying if error signal generated correctly */
void tst_QCamera::testErrorSignal()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
auto *service = QMockIntegration::instance()->lastCaptureService();
QTEST_ASSERT(service);
QTEST_ASSERT(service->mockCameraControl);
QSignalSpy spyError(&camera, &QCamera::errorOccurred);
/* Set the QPlatformCamera error and verify if the signal is emitted correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError, QStringLiteral("Camera Error"));
QVERIFY(spyError.size() == 1);
QCamera::Error err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
QVERIFY(err == QCamera::CameraError);
spyError.clear();
/* Set the QPlatformCamera error and verify if the signal is emitted correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError,
QStringLiteral("InvalidRequestError Error"));
QVERIFY(spyError.size() == 1);
err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
QVERIFY(err == QCamera::CameraError);
spyError.clear();
/* Set the QPlatformCamera error and verify if the signal is emitted correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError,
QStringLiteral("NotSupportedFeatureError Error"));
QVERIFY(spyError.size() == 1);
err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
QVERIFY(err == QCamera::CameraError);
}
/* Test case for verifying the QCamera error */
void tst_QCamera::testError()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
auto *service = QMockIntegration::instance()->lastCaptureService();
/* Set the QPlatformCamera error and verify if it is set correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError, QStringLiteral("Camera Error"));
QVERIFY(camera.error() == QCamera::CameraError);
/* Set the QPlatformCamera error and verify if it is set correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError,
QStringLiteral("InvalidRequestError Error"));
QVERIFY(camera.error() == QCamera::CameraError);
/* Set the QPlatformCamera error and verify if it is set correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError,
QStringLiteral("CameraError Error"));
QVERIFY(camera.error() == QCamera::CameraError);
}
/* Test the error strings for QCamera class */
void tst_QCamera::testErrorString()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
auto *service = QMockIntegration::instance()->lastCaptureService();
/* Set the QPlatformCamera error and verify if it is set correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError, QStringLiteral("Camera Error"));
QVERIFY(camera.errorString() == QStringLiteral("Camera Error"));
/* Set the QPlatformCamera error and verify if it is set correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError,
QStringLiteral("InvalidRequestError Error"));
QVERIFY(camera.errorString() == QStringLiteral("InvalidRequestError Error"));
/* Set the QPlatformCamera error and verify if it is set correctly in QCamera */
service->mockCameraControl->updateError(QCamera::CameraError,
QStringLiteral("CameraError Error"));
QVERIFY(camera.errorString() == QStringLiteral("CameraError Error"));
}
void tst_QCamera::testSetCameraFormat()
{
QCamera camera;
QCameraDevice device = camera.cameraDevice();
auto videoFormats = device.videoFormats();
QVERIFY(videoFormats.size());
QCameraFormat cameraFormat = videoFormats.first();
QSignalSpy spy(&camera, &QCamera::cameraFormatChanged);
QVERIFY(spy.size() == 0);
camera.setCameraFormat(cameraFormat);
QCOMPARE(spy.size(), 1);
QCOMPARE(camera.cameraFormat(), cameraFormat);
QCOMPARE(camera.cameraFormat().pixelFormat(), QVideoFrameFormat::Format_ARGB8888);
QCOMPARE(camera.cameraFormat().resolution(), QSize(640, 480));
QCOMPARE(camera.cameraFormat().minFrameRate(), 0);
QCOMPARE(camera.cameraFormat().maxFrameRate(), 30);
QCOMPARE(spy.size(), 1);
spy.clear();
camera.setCameraFormat({});
QCOMPARE(spy.size(), 1);
QCOMPARE(camera.cameraFormat(), QCameraFormat());
spy.clear();
camera.setCameraDevice(QMediaDevices::videoInputs().at(1));
QCOMPARE(spy.size(), 1);
QCOMPARE(camera.cameraFormat(), QCameraFormat());
camera.setCameraFormat(camera.cameraDevice().videoFormats().first());
QCOMPARE(camera.cameraFormat().pixelFormat(), QVideoFrameFormat::Format_XRGB8888);
QCOMPARE(camera.cameraFormat().resolution(), QSize(1280, 720));
QCOMPARE(camera.cameraFormat().minFrameRate(), 0);
QCOMPARE(camera.cameraFormat().maxFrameRate(), 30);
QCOMPARE(spy.size(), 2);
}
//Added this code to cover QCamera::FocusModeHyperfocal and QCamera::FocusModeAutoNear
//As the FocusModeHyperfocal and FocusModeAutoNear are not supported we can not set the focus mode to these Focus Modes
void tst_QCamera::testFocusMode()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QVERIFY(!camera.isFocusModeSupported(QCamera::FocusModeInfinity));
QVERIFY(camera.isFocusModeSupported(QCamera::FocusModeAutoNear));
QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
camera.setFocusMode(QCamera::FocusModeInfinity);
QVERIFY(camera.focusMode() != QCamera::FocusModeInfinity);
QCOMPARE(camera.focusMode(), QCamera::FocusModeAuto);
camera.setFocusMode(QCamera::FocusModeAutoNear);
QVERIFY(camera.focusMode() == QCamera::FocusModeAutoNear);
}
void tst_QCamera::testZoomChanged()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QSignalSpy spy(&camera, &QCamera::zoomFactorChanged);
QVERIFY(spy.size() == 0);
camera.setZoomFactor(2.0);
QVERIFY(spy.size() == 1);
camera.zoomTo(3.0, 1);
QVERIFY(spy.size() == 2);
camera.zoomTo(1.0, 0);
QVERIFY(spy.size() == 3);
}
void tst_QCamera::testMaxZoomChangedSignal()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QMockCamera *mock = QMockIntegration::instance()->lastCamera();
// ### change max zoom factor on backend, e.g. by changing camera
QSignalSpy spy(&camera, &QCamera::maximumZoomFactorChanged);
mock->maximumZoomFactorChanged(55);
QVERIFY(spy.size() == 1);
QCOMPARE(camera.maximumZoomFactor(), 55);
}
void tst_QCamera::testSignalExposureCompensationChanged()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QSignalSpy spyExposureCompensationChanged(&camera, &QCamera::exposureCompensationChanged);
QVERIFY(spyExposureCompensationChanged.size() == 0);
QVERIFY(camera.exposureCompensation() != 800);
camera.setExposureCompensation(2.0);
QTest::qWait(100);
QVERIFY(camera.exposureCompensation() == 2.0);
QCOMPARE(spyExposureCompensationChanged.size(),1);
// Setting the same should not result in a signal
camera.setExposureCompensation(2.0);
QTest::qWait(100);
QVERIFY(camera.exposureCompensation() == 2.0);
QCOMPARE(spyExposureCompensationChanged.size(),1);
}
void tst_QCamera::testSignalIsoSensitivityChanged()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QSignalSpy spyisoSensitivityChanged(&camera, &QCamera::isoSensitivityChanged);
QVERIFY(spyisoSensitivityChanged.size() ==0);
camera.setManualIsoSensitivity(800); //set the manualiso sentivity to 800
QTest::qWait(100);
QVERIFY(spyisoSensitivityChanged.size() ==1);
}
void tst_QCamera::testSignalShutterSpeedChanged()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QSignalSpy spySignalExposureTimeChanged(&camera, &QCamera::exposureTimeChanged);
QVERIFY(spySignalExposureTimeChanged.size() == 0);
camera.setManualExposureTime(2.0);//set the ManualShutterSpeed to 2.0
QTest::qWait(100);
QVERIFY(spySignalExposureTimeChanged.size() ==1);
}
void tst_QCamera::testSignalFlashReady()
{
QMediaCaptureSession session;
QCamera camera;
session.setCamera(&camera);
QSignalSpy spyflashReady(&camera, &QCamera::flashReady);
QVERIFY(spyflashReady.size() == 0);
QVERIFY(camera.flashMode() == QCamera::FlashAuto);
camera.setFlashMode(QCamera::FlashOff);//set theFlashMode to QCamera::FlashOff
QVERIFY(camera.flashMode() == QCamera::FlashOff);
QCOMPARE(spyflashReady.size(), 1);
}
QTEST_MAIN(tst_QCamera)
#include "tst_qcamera.moc"