slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
dc2fec1bd8974d695d9c22d4b958a73bbe9ff1a2
qtmultimedia/tests/auto/unit/qcamera/tst_qcamera.cpp
Andrew den Exter dc2fec1bd8 Allow supported camera locks to change after initialization. 
A camera backend may not be able to report which locks it supports
until after it is loaded, so query support on demand instead of caching
the value available at construction time.

Change-Id: I56fb1adee980ebc2fa893da3c983a6dce26329c0
Reviewed-by: Yoann Lopes <yoann.lopes@theqtcompany.com>
2014-11-28 04:19:35 +01:00

1950 lines
75 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** 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 Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/
//TESTED_COMPONENT=src/multimedia
#include <QtTest/QtTest>
#include <QDebug>
#include <qabstractvideosurface.h>
#include <qcameracontrol.h>
#include <qcameralockscontrol.h>
#include <qcameraexposurecontrol.h>
#include <qcameraflashcontrol.h>
#include <qcamerafocuscontrol.h>
#include <qcameraimagecapturecontrol.h>
#include <qimageencodercontrol.h>
#include <qcameraimageprocessingcontrol.h>
#include <qcameracapturebufferformatcontrol.h>
#include <qcameracapturedestinationcontrol.h>
#include <qmediaservice.h>
#include <qcamera.h>
#include <qcamerainfo.h>
#include <qcameraimagecapture.h>
#include <qvideorenderercontrol.h>
#include "mockcameraservice.h"
#include "mockmediaserviceprovider.h"
#include "mockvideosurface.h"
#include "mockvideorenderercontrol.h"
#include "mockvideowindowcontrol.h"
QT_USE_NAMESPACE
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 testSimpleCameraLock();
void testSimpleCaptureDestination();
void testSimpleCaptureFormat();
void testCameraWhiteBalance();
void testCameraExposure();
void testCameraFocus();
void testCameraCapture();
void testCameraCaptureMetadata();
void testImageSettings();
void testCameraLock();
void testCameraLockCancel();
void testCameraEncodingProperyChange();
void testCaptureDestination();
void testCaptureFormat();
void testConstructor();
void testCaptureMode();
void testIsCaptureModeSupported();
void testRequestedLocks();
void testSupportedLocks();
void testQCameraIsAvailable();
void testQCameraIsNotAvailable();
void testSearchAndLockWithLockTypes();
void testSetCaptureMode();
void testUnlockWithType();
void testCaptureModeChangedSignal();
void testLockStatusChangedWithTypesSignal();
void testErrorSignal();
void testError();
void testErrorString();
void testStatus();
void testLockType();
void testLockChangeReason();
// Test cases to for QCameraFocus
void testCameraFocusIsAvailable();
void testFocusModes();
void testOpticalAndDigitalZoomChanged();
void testMaxOpticalZoomChangedSignal();
void testMaxDigitalZoomChangedSignal();
void testfocusZonesChangedSignal();
// Test cases for QCameraControl class.
void testCameraControl();
void testCaptureModeChanged_signal();
void testEnumsOfQCameraControl();
// Test case for QCameraImageProcessing class
void testContrast();
void testDenoisingLevel();
void testIsAvailable();
void testSaturation();
void testSharpeningLevel();
void testEnumOfQCameraImageProcessing();
void testSetVideoOutput();
void testSetVideoOutputNoService();
void testSetVideoOutputNoControl();
void testSetVideoOutputDestruction();
void testEnumDebug();
// constructor for QCameraImageProceesing
void testImageProcessingControl();
// Signals test cases for QCameraExposure
void testSignalApertureChanged();
void testSignalExposureCompensationChanged();
void testSignalIsoSensitivityChanged();
void testSignalShutterSpeedChanged();
void testSignalFlashReady();
// test constructor
void testExposureControlConstructor();
private:
MockSimpleCameraService *mockSimpleCameraService;
MockCameraService *mockCameraService;
MockMediaServiceProvider *provider;
};
void tst_QCamera::initTestCase()
{
}
void tst_QCamera::init()
{
provider = new MockMediaServiceProvider;
mockSimpleCameraService = new MockSimpleCameraService;
mockCameraService = new MockCameraService;
provider->service = mockCameraService;
QMediaServiceProvider::setDefaultServiceProvider(provider);
}
void tst_QCamera::cleanup()
{
delete provider;
delete mockCameraService;
delete mockSimpleCameraService;
}
void tst_QCamera::testSimpleCamera()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCOMPARE(camera.service(), (QMediaService*)mockSimpleCameraService);
QCOMPARE(camera.state(), QCamera::UnloadedState);
camera.start();
QCOMPARE(camera.state(), QCamera::ActiveState);
camera.stop();
QCOMPARE(camera.state(), QCamera::LoadedState);
camera.unload();
QCOMPARE(camera.state(), QCamera::UnloadedState);
camera.load();
QCOMPARE(camera.state(), QCamera::LoadedState);
}
void tst_QCamera::testSimpleCameraWhiteBalance()
{
provider->service = mockSimpleCameraService;
QCamera camera;
//only WhiteBalanceAuto is supported
QVERIFY(!camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceAuto));
QVERIFY(!camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceCloudy));
QCOMPARE(camera.imageProcessing()->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto);
camera.imageProcessing()->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceCloudy);
QCOMPARE(camera.imageProcessing()->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceAuto);
QCOMPARE(camera.imageProcessing()->manualWhiteBalance()+1.0, 1.0);
camera.imageProcessing()->setManualWhiteBalance(5000);
QCOMPARE(camera.imageProcessing()->manualWhiteBalance()+1.0, 1.0);
}
void tst_QCamera::testSimpleCameraExposure()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure();
QVERIFY(cameraExposure != 0);
QVERIFY(!cameraExposure->isExposureModeSupported(QCameraExposure::ExposureAuto));
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureAuto);
cameraExposure->setExposureMode(QCameraExposure::ExposureManual);//should be ignored
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureAuto);
QVERIFY(!cameraExposure->isFlashModeSupported(QCameraExposure::FlashOff));
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashOff);
QCOMPARE(cameraExposure->isFlashReady(), false);
cameraExposure->setFlashMode(QCameraExposure::FlashOn);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashOff);
QVERIFY(!cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringAverage));
QVERIFY(!cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringSpot));
QVERIFY(!cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringMatrix));
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringMatrix);
cameraExposure->setMeteringMode(QCameraExposure::MeteringSpot);
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringMatrix);
QCOMPARE(cameraExposure->spotMeteringPoint(), QPointF());
cameraExposure->setSpotMeteringPoint(QPointF(0.5f, 0.5f));
QCOMPARE(cameraExposure->spotMeteringPoint(), QPointF());
QCOMPARE(cameraExposure->exposureCompensation(), 0.0);
cameraExposure->setExposureCompensation(2.0);
QCOMPARE(cameraExposure->exposureCompensation(), 0.0);
QCOMPARE(cameraExposure->isoSensitivity(), -1);
QVERIFY(cameraExposure->supportedIsoSensitivities().isEmpty());
cameraExposure->setManualIsoSensitivity(100);
QCOMPARE(cameraExposure->isoSensitivity(), -1);
cameraExposure->setAutoIsoSensitivity();
QCOMPARE(cameraExposure->isoSensitivity(), -1);
QVERIFY(cameraExposure->aperture() < 0);
QVERIFY(cameraExposure->supportedApertures().isEmpty());
cameraExposure->setAutoAperture();
QVERIFY(cameraExposure->aperture() < 0);
cameraExposure->setManualAperture(5.6);
QVERIFY(cameraExposure->aperture() < 0);
QVERIFY(cameraExposure->shutterSpeed() < 0);
QVERIFY(cameraExposure->supportedShutterSpeeds().isEmpty());
cameraExposure->setAutoShutterSpeed();
QVERIFY(cameraExposure->shutterSpeed() < 0);
cameraExposure->setManualShutterSpeed(1/128.0);
QVERIFY(cameraExposure->shutterSpeed() < 0);
}
void tst_QCamera::testSimpleCameraFocus()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QVERIFY(!cameraFocus->isFocusModeSupported(QCameraFocus::AutoFocus));
QVERIFY(!cameraFocus->isFocusModeSupported(QCameraFocus::ContinuousFocus));
QVERIFY(!cameraFocus->isFocusModeSupported(QCameraFocus::InfinityFocus));
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
QTest::ignoreMessage(QtWarningMsg, "Focus mode selection is not supported");
cameraFocus->setFocusMode(QCameraFocus::ContinuousFocus);
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
QCOMPARE(cameraFocus->maximumOpticalZoom(), 1.0);
QCOMPARE(cameraFocus->maximumDigitalZoom(), 1.0);
QCOMPARE(cameraFocus->opticalZoom(), 1.0);
QCOMPARE(cameraFocus->digitalZoom(), 1.0);
QTest::ignoreMessage(QtWarningMsg, "The camera doesn't support zooming.");
cameraFocus->zoomTo(100.0, 100.0);
QCOMPARE(cameraFocus->opticalZoom(), 1.0);
QCOMPARE(cameraFocus->digitalZoom(), 1.0);
QVERIFY(!cameraFocus->isFocusPointModeSupported(QCameraFocus::FocusPointAuto));
QCOMPARE(cameraFocus->focusPointMode(), QCameraFocus::FocusPointAuto);
QTest::ignoreMessage(QtWarningMsg, "Focus points mode selection is not supported");
cameraFocus->setFocusPointMode( QCameraFocus::FocusPointCenter );
QCOMPARE(cameraFocus->focusPointMode(), QCameraFocus::FocusPointAuto);
QCOMPARE(cameraFocus->customFocusPoint(), QPointF(0.5, 0.5));
QTest::ignoreMessage(QtWarningMsg, "Focus points selection is not supported");
cameraFocus->setCustomFocusPoint(QPointF(1.0, 1.0));
QCOMPARE(cameraFocus->customFocusPoint(), QPointF(0.5, 0.5));
}
void tst_QCamera::testSimpleCameraCapture()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QVERIFY(!imageCapture.isReadyForCapture());
QVERIFY(!imageCapture.isAvailable());
QCOMPARE(imageCapture.error(), QCameraImageCapture::NoError);
QVERIFY(imageCapture.errorString().isEmpty());
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int,QCameraImageCapture::Error,QString)));
imageCapture.capture(QString::fromLatin1("/dev/null"));
QCOMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QCameraImageCapture::NotSupportedFeatureError);
QVERIFY(!imageCapture.errorString().isEmpty());
}
void tst_QCamera::testSimpleCameraLock()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockExposure), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockFocus), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockWhiteBalance), QCamera::Unlocked);
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
camera.searchAndLock();
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockExposure), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockFocus), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockWhiteBalance), QCamera::Unlocked);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 0);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
camera.unlock();
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockExposure), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockFocus), QCamera::Unlocked);
QCOMPARE(camera.lockStatus(QCamera::LockWhiteBalance), QCamera::Unlocked);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 0);
}
void tst_QCamera::testSimpleCaptureDestination()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToFile));
QVERIFY(!imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer));
QVERIFY(!imageCapture.isCaptureDestinationSupported(
QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile));
QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToFile);
imageCapture.setCaptureDestination(QCameraImageCapture::CaptureToBuffer);
QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToFile);
}
void tst_QCamera::testSimpleCaptureFormat()
{
provider->service = mockSimpleCameraService;
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_Invalid);
QVERIFY(imageCapture.supportedBufferFormats().isEmpty());
imageCapture.setBufferFormat(QVideoFrame::Format_AdobeDng);
QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_Invalid);
}
void tst_QCamera::testCaptureDestination()
{
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToFile));
QVERIFY(imageCapture.isCaptureDestinationSupported(QCameraImageCapture::CaptureToBuffer));
QVERIFY(!imageCapture.isCaptureDestinationSupported(
QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile));
QSignalSpy destinationChangedSignal(&imageCapture, SIGNAL(captureDestinationChanged(QCameraImageCapture::CaptureDestinations)));
QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToFile);
imageCapture.setCaptureDestination(QCameraImageCapture::CaptureToBuffer);
QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToBuffer);
QCOMPARE(destinationChangedSignal.size(), 1);
QCOMPARE(destinationChangedSignal.first().first().value<QCameraImageCapture::CaptureDestinations>(),
QCameraImageCapture::CaptureToBuffer);
//not supported combination
imageCapture.setCaptureDestination(QCameraImageCapture::CaptureToBuffer | QCameraImageCapture::CaptureToFile);
QCOMPARE(imageCapture.captureDestination(), QCameraImageCapture::CaptureToBuffer);
QCOMPARE(destinationChangedSignal.size(), 1);
}
void tst_QCamera::testCaptureFormat()
{
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QSignalSpy formatChangedSignal(&imageCapture, SIGNAL(bufferFormatChanged(QVideoFrame::PixelFormat)));
QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_Jpeg);
QCOMPARE(imageCapture.supportedBufferFormats().size(), 3);
imageCapture.setBufferFormat(QVideoFrame::Format_AdobeDng);
QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_AdobeDng);
QCOMPARE(formatChangedSignal.size(), 1);
QCOMPARE(formatChangedSignal.first().first().value<QVideoFrame::PixelFormat>(),
QVideoFrame::Format_AdobeDng);
imageCapture.setBufferFormat(QVideoFrame::Format_Y16);
QCOMPARE(imageCapture.bufferFormat(), QVideoFrame::Format_AdobeDng);
QCOMPARE(formatChangedSignal.size(), 1);
}
void tst_QCamera::testCameraCapture()
{
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QVERIFY(!imageCapture.isReadyForCapture());
QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(int,QImage)));
QSignalSpy errorSignal(&imageCapture, SIGNAL(error(int,QCameraImageCapture::Error,QString)));
imageCapture.capture(QString::fromLatin1("/dev/null"));
QCOMPARE(capturedSignal.size(), 0);
QCOMPARE(errorSignal.size(), 1);
QCOMPARE(imageCapture.error(), QCameraImageCapture::NotReadyError);
errorSignal.clear();
camera.start();
QVERIFY(imageCapture.isReadyForCapture());
QCOMPARE(errorSignal.size(), 0);
imageCapture.capture(QString::fromLatin1("/dev/null"));
QTRY_COMPARE(capturedSignal.size(), 1);
QCOMPARE(errorSignal.size(), 0);
QCOMPARE(imageCapture.error(), QCameraImageCapture::NoError);
}
void tst_QCamera::testCameraCaptureMetadata()
{
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QSignalSpy metadataSignal(&imageCapture, SIGNAL(imageMetadataAvailable(int,QString,QVariant)));
QSignalSpy savedSignal(&imageCapture, SIGNAL(imageSaved(int,QString)));
camera.start();
int id = imageCapture.capture(QString::fromLatin1("/dev/null"));
QTRY_COMPARE(savedSignal.size(), 1);
QCOMPARE(metadataSignal.size(), 3);
QVariantList metadata = metadataSignal[0];
QCOMPARE(metadata[0].toInt(), id);
QCOMPARE(metadata[1].toString(), QMediaMetaData::FocalLengthIn35mmFilm);
QCOMPARE(metadata[2].value<QVariant>().toInt(), 50);
metadata = metadataSignal[1];
QCOMPARE(metadata[0].toInt(), id);
QCOMPARE(metadata[1].toString(), QMediaMetaData::DateTimeOriginal);
QDateTime captureTime = metadata[2].value<QVariant>().value<QDateTime>();
const qint64 dt = captureTime.secsTo(QDateTime::currentDateTime());
QVERIFY2(qAbs(dt) < 5, QByteArray::number(dt).constData()); // it should not take more than 5 seconds for signal to arrive here
metadata = metadataSignal[2];
QCOMPARE(metadata[0].toInt(), id);
QCOMPARE(metadata[1].toString(), QLatin1String("Answer to the Ultimate Question of Life, the Universe, and Everything"));
QCOMPARE(metadata[2].value<QVariant>().toInt(), 42);
}
void tst_QCamera::testCameraWhiteBalance()
{
QSet<QCameraImageProcessing::WhiteBalanceMode> whiteBalanceModes;
whiteBalanceModes << QCameraImageProcessing::WhiteBalanceAuto;
whiteBalanceModes << QCameraImageProcessing::WhiteBalanceFlash;
whiteBalanceModes << QCameraImageProcessing::WhiteBalanceTungsten;
MockCameraService service;
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);
QVERIFY(camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceAuto));
QVERIFY(camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceFlash));
QVERIFY(camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceTungsten));
QVERIFY(!camera.imageProcessing()->isWhiteBalanceModeSupported(QCameraImageProcessing::WhiteBalanceCloudy));
cameraImageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceTungsten);
QCOMPARE(cameraImageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceTungsten);
cameraImageProcessing->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceManual);
QCOMPARE(cameraImageProcessing->whiteBalanceMode(), QCameraImageProcessing::WhiteBalanceManual);
QCOMPARE(cameraImageProcessing->manualWhiteBalance(), 34.0);
cameraImageProcessing->setManualWhiteBalance(432.0);
QCOMPARE(cameraImageProcessing->manualWhiteBalance(), 432.0);
}
void tst_QCamera::testCameraExposure()
{
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure();
QVERIFY(cameraExposure != 0);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureAuto));
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureAuto);
// Test Cases For QCameraExposure
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureManual));
cameraExposure->setExposureMode(QCameraExposure::ExposureManual);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureManual);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureNight));
cameraExposure->setExposureMode(QCameraExposure::ExposureNight);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureNight);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureBacklight));
cameraExposure->setExposureMode(QCameraExposure::ExposureBacklight);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureBacklight);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureSpotlight ));
cameraExposure->setExposureMode(QCameraExposure::ExposureSpotlight);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureSpotlight);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureSports ));
cameraExposure->setExposureMode(QCameraExposure::ExposureSports);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureSports);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureSnow ));
cameraExposure->setExposureMode(QCameraExposure::ExposureSnow);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureSnow);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureBeach ));
cameraExposure->setExposureMode(QCameraExposure::ExposureBeach);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureBeach);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureLargeAperture ));
cameraExposure->setExposureMode(QCameraExposure::ExposureLargeAperture);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureLargeAperture);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureSmallAperture ));
cameraExposure->setExposureMode(QCameraExposure::ExposureSmallAperture);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureSmallAperture);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposurePortrait ));
cameraExposure->setExposureMode(QCameraExposure::ExposurePortrait);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposurePortrait);
QVERIFY(cameraExposure->isExposureModeSupported(QCameraExposure::ExposureModeVendor ));
cameraExposure->setExposureMode(QCameraExposure::ExposureModeVendor);
QCOMPARE(cameraExposure->exposureMode(), QCameraExposure::ExposureModeVendor);
cameraExposure->setFlashMode(QCameraExposure::FlashAuto);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashAuto);
QCOMPARE(cameraExposure->isFlashReady(), true);
cameraExposure->setFlashMode(QCameraExposure::FlashRedEyeReduction);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashRedEyeReduction);
cameraExposure->setFlashMode(QCameraExposure::FlashOn);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashOn);
cameraExposure->setFlashMode(QCameraExposure::FlashFill);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashFill);
cameraExposure->setFlashMode(QCameraExposure::FlashTorch);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashTorch);
cameraExposure->setFlashMode(QCameraExposure::FlashSlowSyncFrontCurtain);
QCOMPARE(cameraExposure->flashMode(), QCameraExposure::FlashSlowSyncFrontCurtain);
QVERIFY(!cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringAverage));
QVERIFY(cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringSpot));
QVERIFY(cameraExposure->isMeteringModeSupported(QCameraExposure::MeteringMatrix));
cameraExposure->setMeteringMode(QCameraExposure::MeteringMatrix);
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringMatrix);
//MeteringAverage is not supported, metering mode should not be changed
cameraExposure->setMeteringMode(QCameraExposure::MeteringAverage);
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringMatrix);
cameraExposure->setMeteringMode(QCameraExposure::MeteringSpot);
QCOMPARE(cameraExposure->meteringMode(), QCameraExposure::MeteringSpot);
cameraExposure->setSpotMeteringPoint(QPointF(0.5f, 0.25f));
QCOMPARE(cameraExposure->spotMeteringPoint(), QPointF(0.5f, 0.25f));
cameraExposure->setSpotMeteringPoint(QPointF(0.25f, 56.3f));
QCOMPARE(cameraExposure->spotMeteringPoint(), QPointF(0.5f, 0.25f));
cameraExposure->setSpotMeteringPoint(QPointF(0, 0));
QCOMPARE(cameraExposure->spotMeteringPoint(), QPointF(0, 0));
cameraExposure->setSpotMeteringPoint(QPointF(1, 1));
QCOMPARE(cameraExposure->spotMeteringPoint(), QPointF(1, 1));
QCOMPARE(cameraExposure->exposureCompensation(), 0.0);
cameraExposure->setExposureCompensation(2.0);
QCOMPARE(cameraExposure->exposureCompensation(), 2.0);
int minIso = cameraExposure->supportedIsoSensitivities().first();
int maxIso = cameraExposure->supportedIsoSensitivities().last();
QVERIFY(cameraExposure->isoSensitivity() > 0);
QCOMPARE(cameraExposure->requestedIsoSensitivity(), -1);
QVERIFY(minIso > 0);
QVERIFY(maxIso > 0);
cameraExposure->setManualIsoSensitivity(minIso);
QCOMPARE(cameraExposure->isoSensitivity(), minIso);
cameraExposure->setManualIsoSensitivity(maxIso*10);
QCOMPARE(cameraExposure->isoSensitivity(), maxIso);
QCOMPARE(cameraExposure->requestedIsoSensitivity(), maxIso*10);
cameraExposure->setManualIsoSensitivity(-10);
QCOMPARE(cameraExposure->isoSensitivity(), minIso);
QCOMPARE(cameraExposure->requestedIsoSensitivity(), -10);
cameraExposure->setAutoIsoSensitivity();
QCOMPARE(cameraExposure->isoSensitivity(), 100);
QCOMPARE(cameraExposure->requestedIsoSensitivity(), -1);
QCOMPARE(cameraExposure->requestedAperture(), -1.0);
qreal minAperture = cameraExposure->supportedApertures().first();
qreal maxAperture = cameraExposure->supportedApertures().last();
QVERIFY(minAperture > 0);
QVERIFY(maxAperture > 0);
QVERIFY(cameraExposure->aperture() >= minAperture);
QVERIFY(cameraExposure->aperture() <= maxAperture);
cameraExposure->setAutoAperture();
QVERIFY(cameraExposure->aperture() >= minAperture);
QVERIFY(cameraExposure->aperture() <= maxAperture);
QCOMPARE(cameraExposure->requestedAperture(), -1.0);
cameraExposure->setManualAperture(0);
QCOMPARE(cameraExposure->aperture(), minAperture);
QCOMPARE(cameraExposure->requestedAperture()+1.0, 1.0);
cameraExposure->setManualAperture(10000);
QCOMPARE(cameraExposure->aperture(), maxAperture);
QCOMPARE(cameraExposure->requestedAperture(), 10000.0);
cameraExposure->setAutoAperture();
QCOMPARE(cameraExposure->requestedAperture(), -1.0);
QCOMPARE(cameraExposure->requestedShutterSpeed(), -1.0);
qreal minShutterSpeed = cameraExposure->supportedShutterSpeeds().first();
qreal maxShutterSpeed = cameraExposure->supportedShutterSpeeds().last();
QVERIFY(minShutterSpeed > 0);
QVERIFY(maxShutterSpeed > 0);
QVERIFY(cameraExposure->shutterSpeed() >= minShutterSpeed);
QVERIFY(cameraExposure->shutterSpeed() <= maxShutterSpeed);
cameraExposure->setAutoShutterSpeed();
QVERIFY(cameraExposure->shutterSpeed() >= minShutterSpeed);
QVERIFY(cameraExposure->shutterSpeed() <= maxShutterSpeed);
QCOMPARE(cameraExposure->requestedShutterSpeed(), -1.0);
cameraExposure->setManualShutterSpeed(0);
QCOMPARE(cameraExposure->shutterSpeed(), minShutterSpeed);
QCOMPARE(cameraExposure->requestedShutterSpeed()+1.0, 1.0);
cameraExposure->setManualShutterSpeed(10000);
QCOMPARE(cameraExposure->shutterSpeed(), maxShutterSpeed);
QCOMPARE(cameraExposure->requestedShutterSpeed(), 10000.0);
cameraExposure->setAutoShutterSpeed();
QCOMPARE(cameraExposure->requestedShutterSpeed(), -1.0);
}
void tst_QCamera::testCameraFocus()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QVERIFY(cameraFocus->isFocusModeSupported(QCameraFocus::AutoFocus));
QVERIFY(cameraFocus->isFocusModeSupported(QCameraFocus::ContinuousFocus));
QVERIFY(!cameraFocus->isFocusModeSupported(QCameraFocus::InfinityFocus));
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
cameraFocus->setFocusMode(QCameraFocus::ManualFocus);
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
cameraFocus->setFocusMode(QCameraFocus::ContinuousFocus);
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::ContinuousFocus);
QVERIFY(cameraFocus->maximumOpticalZoom() >= 1.0);
QVERIFY(cameraFocus->maximumDigitalZoom() >= 1.0);
QCOMPARE(cameraFocus->opticalZoom(), 1.0);
QCOMPARE(cameraFocus->digitalZoom(), 1.0);
cameraFocus->zoomTo(0.5, 1.0);
QCOMPARE(cameraFocus->opticalZoom(), 1.0);
QCOMPARE(cameraFocus->digitalZoom(), 1.0);
cameraFocus->zoomTo(2.0, 0.5);
QCOMPARE(cameraFocus->opticalZoom(), 2.0);
QCOMPARE(cameraFocus->digitalZoom(), 1.0);
cameraFocus->zoomTo(2.0, 2.5);
QCOMPARE(cameraFocus->opticalZoom(), 2.0);
QCOMPARE(cameraFocus->digitalZoom(), 2.5);
cameraFocus->zoomTo(2000000.0, 1000000.0);
QVERIFY(qFuzzyCompare(cameraFocus->opticalZoom(), cameraFocus->maximumOpticalZoom()));
QVERIFY(qFuzzyCompare(cameraFocus->digitalZoom(), cameraFocus->maximumDigitalZoom()));
QVERIFY(cameraFocus->isFocusPointModeSupported(QCameraFocus::FocusPointAuto));
QVERIFY(cameraFocus->isFocusPointModeSupported(QCameraFocus::FocusPointCenter));
QVERIFY(cameraFocus->isFocusPointModeSupported(QCameraFocus::FocusPointCustom));
QCOMPARE(cameraFocus->focusPointMode(), QCameraFocus::FocusPointAuto);
cameraFocus->setFocusPointMode( QCameraFocus::FocusPointCenter );
QCOMPARE(cameraFocus->focusPointMode(), QCameraFocus::FocusPointCenter);
cameraFocus->setFocusPointMode( QCameraFocus::FocusPointFaceDetection );
QCOMPARE(cameraFocus->focusPointMode(), QCameraFocus::FocusPointCenter);
QCOMPARE(cameraFocus->customFocusPoint(), QPointF(0.5, 0.5));
cameraFocus->setCustomFocusPoint(QPointF(1.0, 1.0));
QCOMPARE(cameraFocus->customFocusPoint(), QPointF(1.0, 1.0));
}
void tst_QCamera::testImageSettings()
{
QImageEncoderSettings settings;
QVERIFY(settings.isNull());
QVERIFY(settings == QImageEncoderSettings());
QCOMPARE(settings.codec(), QString());
settings.setCodec(QLatin1String("codecName"));
QCOMPARE(settings.codec(), QLatin1String("codecName"));
QVERIFY(!settings.isNull());
QVERIFY(settings != QImageEncoderSettings());
settings = QImageEncoderSettings();
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
settings.setQuality(QMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings = QImageEncoderSettings();
QCOMPARE(settings.resolution(), QSize());
settings.setResolution(QSize(320,240));
QCOMPARE(settings.resolution(), QSize(320,240));
settings.setResolution(800,600);
QCOMPARE(settings.resolution(), QSize(800,600));
QVERIFY(!settings.isNull());
settings = QImageEncoderSettings();
settings.setEncodingOption(QLatin1Literal("encoderOption"), QVariant(1));
QCOMPARE(settings.encodingOption(QLatin1Literal("encoderOption")), QVariant(1));
QVariantMap options;
options.insert(QLatin1Literal("encoderOption"), QVariant(1));
QCOMPARE(settings.encodingOptions(), options);
options.insert(QLatin1Literal("encoderOption2"), QVariant(2));
options.remove(QLatin1Literal("encoderOption"));
settings.setEncodingOptions(options);
QCOMPARE(settings.encodingOption(QLatin1Literal("encoderOption")), QVariant());
QCOMPARE(settings.encodingOption(QLatin1Literal("encoderOption2")), QVariant(2));
QVERIFY(!settings.isNull());
QVERIFY(settings != QImageEncoderSettings());
settings = QImageEncoderSettings();
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
QCOMPARE(settings.resolution(), QSize());
QVERIFY(settings.encodingOptions().isEmpty());
{
QImageEncoderSettings settings1;
QImageEncoderSettings settings2;
QCOMPARE(settings2, settings1);
settings2 = settings1;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
QVERIFY(settings1 != settings2);
}
{
QImageEncoderSettings settings1;
QImageEncoderSettings settings2(settings1);
QCOMPARE(settings2, settings1);
settings2 = settings1;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
QVERIFY(settings1 != settings2);
}
QImageEncoderSettings settings1;
QImageEncoderSettings settings2;
settings1 = QImageEncoderSettings();
settings1.setResolution(800,600);
settings2 = QImageEncoderSettings();
settings2.setResolution(QSize(800,600));
QVERIFY(settings1 == settings2);
settings2.setResolution(QSize(400,300));
QVERIFY(settings1 != settings2);
settings1 = QImageEncoderSettings();
settings1.setCodec("codec1");
settings2 = QImageEncoderSettings();
settings2.setCodec("codec1");
QVERIFY(settings1 == settings2);
settings2.setCodec("codec2");
QVERIFY(settings1 != settings2);
settings1 = QImageEncoderSettings();
settings1.setQuality(QMultimedia::NormalQuality);
settings2 = QImageEncoderSettings();
settings2.setQuality(QMultimedia::NormalQuality);
QVERIFY(settings1 == settings2);
settings2.setQuality(QMultimedia::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QImageEncoderSettings();
settings1.setEncodingOption(QLatin1Literal("encoderOption"), QVariant(1));
settings2 = QImageEncoderSettings();
settings2.setEncodingOption(QLatin1Literal("encoderOption"), QVariant(1));
QVERIFY(settings1 == settings2);
settings2.setEncodingOption(QLatin1Literal("encoderOption"), QVariant(2));
QVERIFY(settings1 != settings2);
}
void tst_QCamera::testCameraLock()
{
QCamera camera;
camera.focus()->setFocusMode(QCameraFocus::AutoFocus);
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
camera.searchAndLock();
QCOMPARE(camera.lockStatus(), QCamera::Searching);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
QTRY_COMPARE(camera.lockStatus(), QCamera::Locked);
QCOMPARE(lockedSignal.count(), 1);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
camera.searchAndLock();
QCOMPARE(camera.lockStatus(), QCamera::Searching);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
camera.unlock();
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
}
void tst_QCamera::testCameraLockCancel()
{
MockCameraService service;
provider->service = &service;
QCamera camera(0, provider);
camera.focus()->setFocusMode(QCameraFocus::AutoFocus);
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
camera.searchAndLock();
QCOMPARE(camera.lockStatus(), QCamera::Searching);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
camera.unlock();
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
}
void tst_QCamera::testCameraEncodingProperyChange()
{
QCamera camera;
QCameraImageCapture imageCapture(&camera);
QSignalSpy stateChangedSignal(&camera, SIGNAL(stateChanged(QCamera::State)));
QSignalSpy statusChangedSignal(&camera, SIGNAL(statusChanged(QCamera::Status)));
camera.start();
QCOMPARE(camera.state(), QCamera::ActiveState);
QCOMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(stateChangedSignal.count(), 1);
QCOMPARE(statusChangedSignal.count(), 1);
stateChangedSignal.clear();
statusChangedSignal.clear();
camera.setCaptureMode(QCamera::CaptureVideo);
QCOMPARE(camera.state(), QCamera::ActiveState);
QCOMPARE(camera.status(), QCamera::LoadedStatus);
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 1);
stateChangedSignal.clear();
statusChangedSignal.clear();
QCOMPARE(camera.state(), QCamera::ActiveState);
QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 1);
stateChangedSignal.clear();
statusChangedSignal.clear();
//backens should not be stopped since the capture mode is Video
imageCapture.setEncodingSettings(QImageEncoderSettings());
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 0);
camera.setCaptureMode(QCamera::CaptureStillImage);
QCOMPARE(camera.state(), QCamera::ActiveState);
QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
stateChangedSignal.clear();
statusChangedSignal.clear();
//the settings change should trigger camera stop/start
imageCapture.setEncodingSettings(QImageEncoderSettings());
QCOMPARE(camera.state(), QCamera::ActiveState);
QCOMPARE(camera.status(), QCamera::LoadedStatus);
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 1);
stateChangedSignal.clear();
statusChangedSignal.clear();
QCOMPARE(camera.state(), QCamera::ActiveState);
QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 1);
stateChangedSignal.clear();
statusChangedSignal.clear();
//the settings change should trigger camera stop/start only once
camera.setCaptureMode(QCamera::CaptureVideo);
camera.setCaptureMode(QCamera::CaptureStillImage);
imageCapture.setEncodingSettings(QImageEncoderSettings());
imageCapture.setEncodingSettings(QImageEncoderSettings());
QCOMPARE(camera.state(), QCamera::ActiveState);
QCOMPARE(camera.status(), QCamera::LoadedStatus);
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 1);
stateChangedSignal.clear();
statusChangedSignal.clear();
QCOMPARE(camera.state(), QCamera::ActiveState);
QTRY_COMPARE(camera.status(), QCamera::ActiveStatus);
QCOMPARE(stateChangedSignal.count(), 0);
QCOMPARE(statusChangedSignal.count(), 1);
}
void tst_QCamera::testSetVideoOutput()
{
MockVideoSurface surface;
QCamera camera;
camera.setViewfinder(reinterpret_cast<QVideoWidget *>(0));
camera.setViewfinder(reinterpret_cast<QGraphicsVideoItem *>(0));
QCOMPARE(mockCameraService->rendererRef, 0);
camera.setViewfinder(&surface);
QVERIFY(mockCameraService->rendererControl->surface() == &surface);
QCOMPARE(mockCameraService->rendererRef, 1);
camera.setViewfinder(reinterpret_cast<QAbstractVideoSurface *>(0));
QVERIFY(mockCameraService->rendererControl->surface() == 0);
//rendererControl is released
QCOMPARE(mockCameraService->rendererRef, 0);
camera.setViewfinder(&surface);
QVERIFY(mockCameraService->rendererControl->surface() == &surface);
QCOMPARE(mockCameraService->rendererRef, 1);
camera.setViewfinder(reinterpret_cast<QVideoWidget *>(0));
QVERIFY(mockCameraService->rendererControl->surface() == 0);
//rendererControl is released
QCOMPARE(mockCameraService->rendererRef, 0);
camera.setViewfinder(&surface);
QVERIFY(mockCameraService->rendererControl->surface() == &surface);
QCOMPARE(mockCameraService->rendererRef, 1);
}
void tst_QCamera::testSetVideoOutputNoService()
{
MockVideoSurface surface;
provider->service = 0;
QCamera camera;
camera.setViewfinder(&surface);
// Nothing we can verify here other than it doesn't assert.
}
void tst_QCamera::testSetVideoOutputNoControl()
{
MockVideoSurface surface;
MockCameraService service;
service.rendererRef = 1;
provider->service = &service;
QCamera camera;
camera.setViewfinder(&surface);
QVERIFY(service.rendererControl->surface() == 0);
}
void tst_QCamera::testSetVideoOutputDestruction()
{
MockVideoSurface surface;
MockCameraService service;
provider->service = &service;
{
QCamera camera;
camera.setViewfinder(&surface);
QVERIFY(service.rendererControl->surface() == &surface);
QCOMPARE(service.rendererRef, 1);
}
QVERIFY(service.rendererControl->surface() == 0);
QCOMPARE(service.rendererRef, 0);
}
void tst_QCamera::testEnumDebug()
{
QTest::ignoreMessage(QtDebugMsg, "QCamera::ActiveState");
qDebug() << QCamera::ActiveState;
QTest::ignoreMessage(QtDebugMsg, "QCamera::ActiveStatus");
qDebug() << QCamera::ActiveStatus;
QTest::ignoreMessage(QtDebugMsg, "QCamera::CaptureVideo");
qDebug() << QCamera::CaptureVideo;
QTest::ignoreMessage(QtDebugMsg, "QCamera::CameraError");
qDebug() << QCamera::CameraError;
QTest::ignoreMessage(QtDebugMsg, "QCamera::Unlocked");
qDebug() << QCamera::Unlocked;
QTest::ignoreMessage(QtDebugMsg, "QCamera::LockAcquired");
qDebug() << QCamera::LockAcquired;
QTest::ignoreMessage(QtDebugMsg, "QCamera::NoLock");
qDebug() << QCamera::NoLock;
QTest::ignoreMessage(QtDebugMsg, "QCamera::LockExposure");
qDebug() << QCamera::LockExposure;
QTest::ignoreMessage(QtDebugMsg, "QCamera::FrontFace ");
qDebug() << QCamera::FrontFace;
}
void tst_QCamera::testCameraControl()
{
MockCameraControl *m_cameraControl=new MockCameraControl(this);
QVERIFY(m_cameraControl != NULL);
}
void tst_QCamera::testConstructor()
{
// Service doesn't implement QVideoDeviceSelectorControl
provider->service = mockSimpleCameraService;
{
QCamera camera;
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
}
{
// Requesting a camera at a specific position from a service which doesn't implement
// the QVideoDeviceSelectorControl should result in loading the default camera
QCamera camera(QCamera::FrontFace);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
}
// Service implements QVideoDeviceSelectorControl
provider->service = mockCameraService;
{
QCamera camera;
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1); // default is 1
}
{
QCamera camera(QCameraInfo::defaultCamera());
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
QCOMPARE(QCameraInfo(camera), QCameraInfo::defaultCamera());
}
{
QCameraInfo cameraInfo = QCameraInfo::availableCameras().at(0);
QCamera camera(cameraInfo);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 0);
QCOMPARE(QCameraInfo(camera), cameraInfo);
}
{
// Requesting a camera at a position which is not available should result in
// loading the default camera
QCamera camera(QCamera::FrontFace);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
}
{
QCamera camera(QCamera::BackFace);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 0);
}
{
// Should load the default camera when UnspecifiedPosition is requested
QCamera camera(QCamera::UnspecifiedPosition);
QCOMPARE(camera.availability(), QMultimedia::Available);
QCOMPARE(camera.error(), QCamera::NoError);
QCOMPARE(mockCameraService->mockVideoDeviceSelectorControl->selectedDevice(), 1);
}
}
/* captureModeChanged Signal test case. */
void tst_QCamera::testCaptureModeChanged_signal()
{
MockCameraControl *m_cameraControl= new MockCameraControl(this);
QSignalSpy spy(m_cameraControl, SIGNAL(captureModeChanged(QCamera::CaptureModes)));
QVERIFY(spy.size() == 0);
m_cameraControl->setCaptureMode(QCamera::CaptureVideo);
QVERIFY(spy.size() == 1);
m_cameraControl->setCaptureMode(QCamera::CaptureStillImage);
QVERIFY(spy.size() == 2);
}
/* Test case for captureMode */
void tst_QCamera::testCaptureMode()
{
QCamera camera;
QVERIFY(camera.captureMode() == QCamera::CaptureStillImage);
camera.setCaptureMode(QCamera::CaptureVideo);
QVERIFY(camera.captureMode() == QCamera::CaptureVideo);
}
/* Test case for isCaptureModeSupported */
void tst_QCamera::testIsCaptureModeSupported()
{
QCamera camera;
QVERIFY(camera.isCaptureModeSupported(QCamera::CaptureStillImage) == true);
QVERIFY(camera.isCaptureModeSupported(QCamera::CaptureVideo) == true);
}
/* Test case for requestedLocks. LockType is stored in OR combination so all
types of combinations are verified here.*/
void tst_QCamera::testRequestedLocks()
{
QCamera camera;
QCOMPARE(camera.requestedLocks(),QCamera::NoLock);
camera.searchAndLock(QCamera::LockExposure);
QCOMPARE(camera.requestedLocks(),QCamera::LockExposure);
camera.unlock();
camera.searchAndLock(QCamera::LockFocus);
QCOMPARE(camera.requestedLocks(),QCamera::LockFocus );
camera.unlock();
camera.searchAndLock(QCamera::LockWhiteBalance);
QCOMPARE(camera.requestedLocks(),QCamera::NoLock);
camera.unlock();
camera.searchAndLock(QCamera::LockExposure |QCamera::LockFocus );
QCOMPARE(camera.requestedLocks(),QCamera::LockExposure |QCamera::LockFocus );
camera.searchAndLock(QCamera::LockWhiteBalance);
QCOMPARE(camera.requestedLocks(),QCamera::LockExposure |QCamera::LockFocus);
camera.unlock(QCamera::LockExposure);
QCOMPARE(camera.requestedLocks(),QCamera::LockFocus);
camera.unlock(QCamera::LockFocus);
camera.searchAndLock(QCamera::LockExposure |QCamera::LockWhiteBalance );
QCOMPARE(camera.requestedLocks(),QCamera::LockExposure);
}
/* Test case for supportedLocks() */
void tst_QCamera::testSupportedLocks()
{
QCamera camera;
QCOMPARE(camera.supportedLocks(),QCamera::LockExposure | QCamera::LockFocus);
}
/* Test case for isAvailable */
void tst_QCamera::testQCameraIsAvailable()
{
QCamera camera;
QVERIFY(camera.isAvailable());
QVERIFY(camera.availability() == QMultimedia::Available);
}
void tst_QCamera::testQCameraIsNotAvailable()
{
provider->service = 0;
QCamera camera("random");
QCOMPARE(camera.error(), QCamera::ServiceMissingError);
QVERIFY(!camera.isAvailable());
QCOMPARE(camera.availability(), QMultimedia::ServiceMissing);
}
/* Test case for searchAndLock ( QCamera::LockTypes locks ) */
void tst_QCamera::testSearchAndLockWithLockTypes()
{
QCamera camera;
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
/* Spy the signals */
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* search and lock the camera with QCamera::LockExposure and verify if the signal is emitted correctly */
camera.searchAndLock(QCamera::LockExposure);
QCOMPARE(camera.lockStatus(), QCamera::Locked);
QCOMPARE(lockedSignal.count(), 1);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
}
/* Test case for setCaptureMode() */
void tst_QCamera::testSetCaptureMode()
{
QCamera camera;
/* Set the capture mode and verify if it set correctly */
camera.setCaptureMode(QCamera::CaptureVideo);
QVERIFY(camera.captureMode() == QCamera::CaptureVideo);
camera.setCaptureMode(QCamera::CaptureStillImage);
QVERIFY(camera.captureMode() == QCamera::CaptureStillImage);
}
/* Test case for unlock (QCamera::LockTypes) */
void tst_QCamera::testUnlockWithType()
{
QCamera camera;
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
/* Spy the signal */
QSignalSpy lockedSignal(&camera, SIGNAL(locked()));
QSignalSpy lockFailedSignal(&camera, SIGNAL(lockFailed()));
QSignalSpy lockStatusChangedSignal(&camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)));
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* lock the camera with QCamera::LockExposure and Verify if the signal is emitted correctly */
camera.searchAndLock(QCamera::LockExposure);
QCOMPARE(camera.lockStatus(), QCamera::Locked);
QCOMPARE(lockedSignal.count(), 1);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
/* Clear the signal */
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
lockStatusChangedSignalWithType.clear();
/* Unlock the camera and verify if the signal is emitted correctly */
camera.unlock(QCamera::LockExposure);
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
QCamera::LockType lockType = qvariant_cast<QCamera::LockType >(lockStatusChangedSignalWithType.at(0).at(0));
QCamera::LockStatus lockStatus = qvariant_cast<QCamera::LockStatus >(lockStatusChangedSignalWithType.at(0).at(1));
QVERIFY(lockType == QCamera::LockExposure);
QVERIFY(lockStatus == QCamera::Unlocked);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
lockStatusChangedSignalWithType.clear();
/* Lock the camera with QCamera::LockFocus */
camera.searchAndLock(QCamera::LockFocus);
lockedSignal.clear();
lockFailedSignal.clear();
lockStatusChangedSignal.clear();
lockStatusChangedSignalWithType.clear();
/* Unlock the camera and Verify if the signal is emitted correctly */
camera.unlock(QCamera::LockFocus);
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(lockedSignal.count(), 0);
QCOMPARE(lockFailedSignal.count(), 0);
QCOMPARE(lockStatusChangedSignal.count(), 1);
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
lockType = qvariant_cast<QCamera::LockType >(lockStatusChangedSignalWithType.at(0).at(0));
lockStatus = qvariant_cast<QCamera::LockStatus >(lockStatusChangedSignalWithType.at(0).at(1));
QVERIFY(lockType == QCamera::LockFocus);
QVERIFY(lockStatus == QCamera::Unlocked);
}
/* Test case for signal captureModeChanged(QCamera::CaptureModes) */
void tst_QCamera::testCaptureModeChangedSignal()
{
QCamera camera;
QVERIFY(camera.captureMode() == QCamera::CaptureStillImage);
qRegisterMetaType<QCamera::CaptureModes>("QCamera::CaptureModes");
/* Spy the signal */
QSignalSpy lockCaptureModeChangedSignal(&camera, SIGNAL(captureModeChanged(QCamera::CaptureModes)));
/* set the capture mode and Verify if the signal is emitted */
camera.setCaptureMode(QCamera::CaptureVideo);
QVERIFY(camera.captureMode() == QCamera::CaptureVideo);
QCOMPARE(lockCaptureModeChangedSignal.count(), 1);
QCamera::CaptureModes lockCaptureMode = qvariant_cast<QCamera::CaptureModes >(lockCaptureModeChangedSignal.at(0).at(0));
QVERIFY(lockCaptureMode == QCamera::CaptureVideo);
}
/* Test case for signal lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason) */
void tst_QCamera::testLockStatusChangedWithTypesSignal()
{
QCamera camera;
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
/* Spy the signal lockStatusChanged(QCamera::LockType,QCamera::LockStatus, QCamera::LockChangeReason) */
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* Lock the camera with type QCamera::LockExposure */
camera.searchAndLock(QCamera::LockExposure);
/* Verify if the signal is emitted and lock status is set correclty */
QCOMPARE(camera.lockStatus(), QCamera::Locked);
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
QCamera::LockType lockType = qvariant_cast<QCamera::LockType >(lockStatusChangedSignalWithType.at(0).at(0));
QCamera::LockStatus lockStatus = qvariant_cast<QCamera::LockStatus >(lockStatusChangedSignalWithType.at(0).at(1));
QVERIFY(lockType == QCamera::LockExposure);
QVERIFY(lockStatus == QCamera::Locked);
lockStatusChangedSignalWithType.clear();
/* Unlock the camera */
camera.unlock();
/* Verify if the signal is emitted and lock status is set correclty */
QCOMPARE(camera.lockStatus(), QCamera::Unlocked);
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
lockType = qvariant_cast<QCamera::LockType >(lockStatusChangedSignalWithType.at(0).at(0));
lockStatus = qvariant_cast<QCamera::LockStatus >(lockStatusChangedSignalWithType.at(0).at(1));
QVERIFY(lockType == QCamera::LockExposure);
QVERIFY(lockStatus == QCamera::Unlocked);
}
/* Test case for verifying if error signal generated correctly */
void tst_QCamera::testErrorSignal()
{
MockCameraService service;
provider->service = &service;
QCamera camera;
QSignalSpy spyError(&camera, SIGNAL(error(QCamera::Error)));
/* Set the QCameraControl error and verify if the signal is emitted correctly in QCamera */
service.mockControl->setError(QCamera::CameraError,QString("Camera Error"));
QVERIFY(spyError.count() == 1);
QCamera::Error err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
QVERIFY(err == QCamera::CameraError);
spyError.clear();
/* Set the QCameraControl error and verify if the signal is emitted correctly in QCamera */
service.mockControl->setError(QCamera::InvalidRequestError,QString("InvalidRequestError Error"));
QVERIFY(spyError.count() == 1);
err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
QVERIFY(err == QCamera::InvalidRequestError);
spyError.clear();
/* Set the QCameraControl error and verify if the signal is emitted correctly in QCamera */
service.mockControl->setError(QCamera::NotSupportedFeatureError,QString("NotSupportedFeatureError Error"));
QVERIFY(spyError.count() == 1);
err = qvariant_cast<QCamera::Error >(spyError.at(0).at(0));
QVERIFY(err == QCamera::NotSupportedFeatureError);
}
/* Test case for verifying the QCamera error */
void tst_QCamera::testError()
{
MockCameraService service;
provider->service = &service;
QCamera camera;
/* Set the QCameraControl error and verify if it is set correctly in QCamera */
service.mockControl->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::InvalidRequestError,QString("InvalidRequestError Error"));
QVERIFY(camera.error() == QCamera::InvalidRequestError);
/* Set the QCameraControl error and verify if it is set correctly in QCamera */
service.mockControl->setError(QCamera::NotSupportedFeatureError,QString("NotSupportedFeatureError Error"));
QVERIFY(camera.error() == QCamera::NotSupportedFeatureError);
}
/* Test the error strings for QCamera class */
void tst_QCamera::testErrorString()
{
MockCameraService service;
provider->service = &service;
QCamera camera;
/* Set the QCameraControl error and verify if it is set correctly in QCamera */
service.mockControl->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::InvalidRequestError,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::NotSupportedFeatureError,QString("NotSupportedFeatureError Error"));
QVERIFY(camera.errorString() == QString("NotSupportedFeatureError Error"));
}
/* Test case for verifying Status of QCamera. */
void tst_QCamera::testStatus()
{
MockCameraService service;
provider->service = &service;
QCamera camera;
/* Set the QCameraControl status and verify if it is set correctly in QCamera */
service.mockControl->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);
QVERIFY(camera.status() == QCamera::StandbyStatus);
/* Set the QCameraControl status and verify if it is set correctly in QCamera */
service.mockControl->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);
QVERIFY(camera.status() == QCamera::UnavailableStatus);
}
/* Test case for verifying default locktype QCamera::NoLock */
void tst_QCamera::testLockType()
{
QCamera camera;
QCOMPARE(camera.requestedLocks(),QCamera::NoLock);
}
/* Test case for QCamera::LockChangeReason with QCamera::LockAcquired */
void tst_QCamera::testLockChangeReason()
{
MockCameraService service;
provider->service = &service;
QCamera camera;
QSignalSpy lockStatusChangedSignalWithType(&camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)));
/* Set the lockChangeReason */
service.mockLocksControl->setLockChangeReason(QCamera::LockAcquired);
/* Verify if lockChangeReson is eqaul toQCamera::LockAcquired */
QCOMPARE(lockStatusChangedSignalWithType.count(), 1);
QCamera::LockChangeReason LockChangeReason = qvariant_cast<QCamera::LockChangeReason >(lockStatusChangedSignalWithType.at(0).at(2));
QVERIFY(LockChangeReason == QCamera::LockAcquired);
}
/* All the enums test case for QCameraControl class*/
void tst_QCamera::testEnumsOfQCameraControl()
{
MockCameraControl *m_cameraControl = new MockCameraControl(this);
bool result;
// In still mode, can't change much
QVERIFY(m_cameraControl->captureMode() == QCamera::CaptureStillImage);
result = m_cameraControl->canChangeProperty(MockCameraControl::CaptureMode, QCamera::ActiveStatus);
QVERIFY(!result);
result = m_cameraControl->canChangeProperty(MockCameraControl::ImageEncodingSettings, QCamera::ActiveStatus);
QVERIFY(!result);
result = m_cameraControl->canChangeProperty(MockCameraControl::VideoEncodingSettings, QCamera::ActiveStatus);
QVERIFY(result);
result = m_cameraControl->canChangeProperty(MockCameraControl::Viewfinder, QCamera::ActiveStatus);
QVERIFY(!result);
// In video mode can change image encoding settings
m_cameraControl->setCaptureMode(QCamera::CaptureVideo);
result = m_cameraControl->canChangeProperty(MockCameraControl::ImageEncodingSettings, QCamera::ActiveStatus);
QVERIFY(result);
result = m_cameraControl->canChangeProperty(MockCameraControl::VideoEncodingSettings, QCamera::ActiveStatus);
QVERIFY(result);
result = m_cameraControl->canChangeProperty(MockCameraControl::Viewfinder, QCamera::ActiveStatus);
QVERIFY(!result);
// Flip the allow everything bit
m_cameraControl->m_propertyChangesSupported = true;
result = m_cameraControl->canChangeProperty(MockCameraControl::CaptureMode, QCamera::ActiveStatus);
QVERIFY(result);
result = m_cameraControl->canChangeProperty(MockCameraControl::ImageEncodingSettings, QCamera::ActiveStatus);
QVERIFY(result);
result = m_cameraControl->canChangeProperty(MockCameraControl::VideoEncodingSettings, QCamera::ActiveStatus);
QVERIFY(result);
result = m_cameraControl->canChangeProperty(MockCameraControl::Viewfinder, QCamera::ActiveStatus);
QVERIFY(result);
}
// Test case for QCameraImageProcessing class
void tst_QCamera::testContrast()
{
QCamera camera;
QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
QVERIFY(cameraImageProcessing->contrast() ==0);
cameraImageProcessing->setContrast(0.123);
QCOMPARE(cameraImageProcessing->contrast(), 0.123);
cameraImageProcessing->setContrast(4.56);
QCOMPARE(cameraImageProcessing->contrast(), 4.56);
}
void tst_QCamera::testDenoisingLevel()
{
QCamera camera;
QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
QCOMPARE(cameraImageProcessing->denoisingLevel()+1 , 1.0);
cameraImageProcessing->setDenoisingLevel(-0.3);
QCOMPARE(cameraImageProcessing->denoisingLevel() , -0.3);
cameraImageProcessing->setDenoisingLevel(0.3);
QCOMPARE(cameraImageProcessing->denoisingLevel() , 0.3);
}
void tst_QCamera::testIsAvailable()
{
QCamera camera;
QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
QVERIFY(cameraImageProcessing->isAvailable() == true);
}
void tst_QCamera::testSaturation()
{
QCamera camera;
QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
QCOMPARE(cameraImageProcessing->saturation()+1.0, 1.0);
cameraImageProcessing->setSaturation(0.5);
QCOMPARE(cameraImageProcessing->saturation(), 0.5);
cameraImageProcessing->setSaturation(-0.5);
QCOMPARE(cameraImageProcessing->saturation(), -0.5);
}
void tst_QCamera::testSharpeningLevel()
{
QCamera camera;
QCameraImageProcessing *cameraImageProcessing = camera.imageProcessing();
QCOMPARE(cameraImageProcessing->sharpeningLevel()+1 , 1.0);
cameraImageProcessing->setSharpeningLevel(-0.3);
QCOMPARE(cameraImageProcessing->sharpeningLevel() , -0.3);
cameraImageProcessing->setSharpeningLevel(0.3);
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()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QVERIFY(cameraFocus->isAvailable());
}
//Added this code to cover QCameraFocus::HyperfocalFocus and QCameraFocus::MacroFocus
//As the HyperfocalFocus and MacroFocus are not supported we can not set the focus mode to these Focus Modes
void tst_QCamera::testFocusModes()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QVERIFY(!cameraFocus->isFocusModeSupported(QCameraFocus::HyperfocalFocus));
QVERIFY(!cameraFocus->isFocusModeSupported(QCameraFocus::MacroFocus));
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
cameraFocus->setFocusMode(QCameraFocus::HyperfocalFocus);
QVERIFY(cameraFocus->focusMode()!= QCameraFocus::HyperfocalFocus);
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
cameraFocus->setFocusMode(QCameraFocus::MacroFocus);
QVERIFY(cameraFocus->focusMode()!= QCameraFocus::MacroFocus);
QCOMPARE(cameraFocus->focusMode(), QCameraFocus::AutoFocus);
}
void tst_QCamera::testOpticalAndDigitalZoomChanged()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QSignalSpy spy1(cameraFocus,SIGNAL(digitalZoomChanged(qreal)));
QSignalSpy spy2(cameraFocus,SIGNAL(opticalZoomChanged(qreal)));
QVERIFY(spy1.count() == 0);
QVERIFY(spy2.count() == 0);
cameraFocus->zoomTo(2.0,3.0);
QVERIFY(spy1.count() == 1);
QVERIFY(spy2.count() == 1);
}
void tst_QCamera::testMaxDigitalZoomChangedSignal()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QSignalSpy spy(cameraFocus,SIGNAL(maximumDigitalZoomChanged(qreal)));
QVERIFY(spy.count() == 0);
cameraFocus->zoomTo(5.0,6.0);
QVERIFY(spy.count() == 1);
}
void tst_QCamera::testMaxOpticalZoomChangedSignal()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QSignalSpy spy(cameraFocus,SIGNAL(maximumOpticalZoomChanged(qreal)));
QVERIFY(spy.count() == 0);
cameraFocus->zoomTo(5.0,6.0);
QVERIFY(spy.count() == 1);
}
void tst_QCamera::testfocusZonesChangedSignal()
{
QCamera camera;
QCameraFocus *cameraFocus = camera.focus();
QVERIFY(cameraFocus != 0);
QSignalSpy spy(cameraFocus,SIGNAL(focusZonesChanged()));
cameraFocus->setCustomFocusPoint(QPointF(0.1, 0.1));
QVERIFY(spy.count() == 1);
}
// test constructor for abstract class of ImageProcessingControl
void tst_QCamera :: testImageProcessingControl()
{
QObject parent;
MockImageProcessingControl processCtrl(&parent);
}
void tst_QCamera::testSignalApertureChanged()
{
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure(); //create camera expose instance
QVERIFY(cameraExposure != 0);
QSignalSpy spyApertureChanged(cameraExposure , SIGNAL(apertureChanged(qreal)));
QSignalSpy spyApertureRangeChanged(cameraExposure , SIGNAL(apertureRangeChanged()));
QVERIFY(spyApertureChanged.count() ==0);
cameraExposure->setManualAperture(10.0);//set the ManualAperture to 10.0
QTest::qWait(100);
QVERIFY(spyApertureChanged.count() ==1);
QVERIFY(spyApertureRangeChanged.count() ==1);
}
void tst_QCamera::testSignalExposureCompensationChanged()
{
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure(); //create camera expose instance
QVERIFY(cameraExposure != 0);
QSignalSpy spyExposureCompensationChanged(cameraExposure , SIGNAL(exposureCompensationChanged(qreal)));
QVERIFY(spyExposureCompensationChanged.count() ==0);
QVERIFY(cameraExposure->exposureCompensation() != 800);
cameraExposure->setExposureCompensation(2.0);
QTest::qWait(100);
QVERIFY(cameraExposure->exposureCompensation() == 2.0);
QCOMPARE(spyExposureCompensationChanged.count(),1);
// Setting the same should not result in a signal
cameraExposure->setExposureCompensation(2.0);
QTest::qWait(100);
QVERIFY(cameraExposure->exposureCompensation() == 2.0);
QCOMPARE(spyExposureCompensationChanged.count(),1);
}
void tst_QCamera::testSignalIsoSensitivityChanged()
{
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure(); //create camera expose instance
QVERIFY(cameraExposure != 0);
QSignalSpy spyisoSensitivityChanged(cameraExposure , SIGNAL(isoSensitivityChanged(int)));
QVERIFY(spyisoSensitivityChanged.count() ==0);
cameraExposure->setManualIsoSensitivity(800); //set the manualiso sentivity to 800
QTest::qWait(100);
QVERIFY(spyisoSensitivityChanged.count() ==1);
}
void tst_QCamera::testSignalShutterSpeedChanged()
{
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure(); //create camera expose instance
QVERIFY(cameraExposure != 0);
QSignalSpy spySignalShutterSpeedChanged(cameraExposure , SIGNAL(shutterSpeedChanged(qreal)));
QSignalSpy spySignalShutterSpeedRangeChanged(cameraExposure , SIGNAL(shutterSpeedRangeChanged()));
QVERIFY(spySignalShutterSpeedChanged.count() ==0);
cameraExposure->setManualShutterSpeed(2.0);//set the ManualShutterSpeed to 2.0
QTest::qWait(100);
QVERIFY(spySignalShutterSpeedChanged.count() ==1);
QVERIFY(spySignalShutterSpeedRangeChanged.count() ==1);
}
void tst_QCamera::testSignalFlashReady()
{
QCamera camera;
QCameraExposure *cameraExposure = camera.exposure(); //create camera expose instance
QVERIFY(cameraExposure != 0);
QSignalSpy spyflashReady(cameraExposure,SIGNAL(flashReady(bool)));
QVERIFY(spyflashReady.count() ==0);
QVERIFY(cameraExposure->flashMode() ==QCameraExposure::FlashAuto);
cameraExposure->setFlashMode(QCameraExposure::FlashOff);//set theFlashMode to QCameraExposure::FlashOff
QVERIFY(cameraExposure->flashMode() ==QCameraExposure::FlashOff);
QVERIFY(spyflashReady.count() ==1);
}
// test constructor
void tst_QCamera::testExposureControlConstructor()
{
// To check changes in abstract classes's pure virtual functions
MockCameraExposureControl obj;
}
QTEST_MAIN(tst_QCamera)
#include "tst_qcamera.moc"
Reference in New Issue View Git Blame Copy Permalink