1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include <QtTest/QtTest>

    43 #include <QDebug>

    44 

    45 #include <experimental/qcameracontrol.h>

    46 #include <experimental/qcameraexposurecontrol.h>

    47 #include <experimental/qcamerafocuscontrol.h>

    48 #include <experimental/qimagecapturecontrol.h>

    49 #include <qimageencodercontrol.h>

    50 #include <experimental/qimageprocessingcontrol.h>

    51 #include <qmediaservice.h>

    52 #include <experimental/qcamera.h>

    53 #include <experimental/qstillimagecapture.h>

    54 

    55 

    56 #define QTRY_COMPARE(a,e)                       \

    57     for (int _i = 0; _i < 5000; _i += 100) {    \

    58         if ((a) == (e)) break;                  \

    59         QTest::qWait(100);                      \

    60     }                                           \

    61     QCOMPARE(a, e)

    62 

    63 #define QTRY_VERIFY(a)                       \

    64     for (int _i = 0; _i < 5000; _i += 100) {    \

    65         if (a) break;                  \

    66         QTest::qWait(100);                      \

    67     }                                           \

    68     QVERIFY(a)

    69 

    70 QTM_USE_NAMESPACE

    71 

    72 class tst_QCamera: public QObject

    73 {

    74     Q_OBJECT

    75 

    76 private:

    77     

    78     QString capturePath(QDir dir);

    79 public slots:

    80     void initTestCase();

    81     void cleanupTestCase();

    82 

    83 private slots:

    84     void testAvailableDevices();

    85     void testDeviceDescription();

    86     void testCtorWithDevice();

    87     void testSimpleCamera();

    88     void testSimpleCameraWhiteBalance();

    89     void testSimpleCameraExposure();

    90     void testSimpleCameraFocus();

    91     void testSimpleCameraCapture();

    92 

    93     void testCameraWhiteBalance();

    94     void testCameraExposure();

    95     void testCameraFocus();

    96     void testCameraCapture();

    97     void testImageSettings();

    98 

    99 };

   100 

   101 void tst_QCamera::initTestCase()

   102 {

   103     qRegisterMetaType<QCamera::State>("QCamera::State");

   104     qRegisterMetaType<QCamera::Error>("QCamera::Error");

   105 }

   106 

   107 void tst_QCamera::cleanupTestCase()

   108 {

   109 }

   110 QString tst_QCamera::capturePath(QDir dir)

   111 {

   112     int lastImage = 0;

   113     foreach( QString fileName, dir.entryList(QStringList() << "img_*.jpg") ) {

   114         int imgNumber = fileName.mid(4, fileName.size()-8).toInt();

   115         lastImage = qMax(lastImage, imgNumber);

   116     }

   117 

   118     return dir.absolutePath() + QDir::separator()  + QString("img_%1.jpg").arg(lastImage+1,

   119         4, //fieldWidth

   120         10,

   121         QLatin1Char('0'));

   122 }

   123 

   124 void tst_QCamera::testAvailableDevices()

   125 {

   126     int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();

   127 

   128     QVERIFY(QCamera::availableDevices().count() == deviceCount);

   129 }

   130 

   131 void tst_QCamera::testDeviceDescription()

   132 {

   133     int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();

   134 

   135     if (deviceCount == 0)

   136         QVERIFY(QCamera::deviceDescription(QByteArray("random")).isNull());

   137     else {

   138         foreach (const QByteArray &device, QCamera::availableDevices())

   139             QVERIFY(QCamera::deviceDescription(device).length() > 0);

   140     }

   141 }

   142 

   143 void tst_QCamera::testCtorWithDevice()

   144 {

   145     int deviceCount = QMediaServiceProvider::defaultServiceProvider()->devices(QByteArray(Q_MEDIASERVICE_CAMERA)).count();

   146     QCamera *camera = 0;

   147 

   148     if (deviceCount == 0) {

   149         camera = new QCamera("random");

   150         QVERIFY(camera->error() == QCamera::ServiceMissingError);

   151     }

   152     else {

   153         camera = new QCamera(QCamera::availableDevices().first());

   154         QVERIFY(camera->error() == QCamera::NoError);

   155     }

   156 

   157     delete camera;

   158 }

   159 

   160 void tst_QCamera::testSimpleCamera()

   161 {

   162     QCamera camera(0);

   163     

   164     QSignalSpy spyAdd(&camera, SIGNAL(stateChanged(QCamera::State)));

   165     QVERIFY(camera.service() != NULL);

   166 

   167     QCOMPARE(camera.state(), QCamera::StoppedState);

   168     camera.start();

   169     QTRY_COMPARE(spyAdd.count(), 1);

   170     

   171     QCOMPARE(camera.state(), QCamera::ActiveState);

   172     camera.stop();

   173     QTRY_COMPARE(spyAdd.count(), 2);

   174     QCOMPARE(camera.state(), QCamera::StoppedState);

   175 }

   176 

   177 void tst_QCamera::testSimpleCameraWhiteBalance()

   178 {

   179     QCamera camera(0);

   180 

   181     //only WhiteBalanceAuto is supported

   182     QCOMPARE(camera.supportedWhiteBalanceModes(), QCamera::WhiteBalanceAuto);

   183     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceAuto);

   184     camera.setWhiteBalanceMode(QCamera::WhiteBalanceCloudy);

   185     QCOMPARE(camera.supportedWhiteBalanceModes(), QCamera::WhiteBalanceAuto);

   186     QCOMPARE(camera.manualWhiteBalance(), -1);

   187     camera.setManualWhiteBalance(5000);

   188     QCOMPARE(camera.manualWhiteBalance(), -1);

   189 }

   190 

   191 void tst_QCamera::testSimpleCameraExposure()

   192 {

   193     QCamera camera(0);

   194 

   195     QCOMPARE(camera.supportedExposureModes(), QCamera::ExposureAuto);

   196     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);

   197     camera.setExposureMode(QCamera::ExposureManual);//should be ignored

   198     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);

   199 

   200     QCOMPARE(camera.supportedFlashModes(), QCamera::FlashOff);

   201     QCOMPARE(camera.flashMode(), QCamera::FlashOff);

   202     QCOMPARE(camera.isFlashReady(), false);

   203     camera.setFlashMode(QCamera::FlashOn);

   204     QCOMPARE(camera.flashMode(), QCamera::FlashOff);

   205 

   206     QCOMPARE(camera.supportedMeteringModes(), QCamera::MeteringMatrix);

   207     QCOMPARE(camera.meteringMode(), QCamera::MeteringMatrix);

   208     camera.setMeteringMode(QCamera::MeteringSpot);

   209     QCOMPARE(camera.meteringMode(), QCamera::MeteringMatrix);

   210 

   211     QCOMPARE(camera.exposureCompensation(), 0.0);

   212     camera.setExposureCompensation(2.0);

   213     QCOMPARE(camera.exposureCompensation(), 0.0);

   214 

   215     QCOMPARE(camera.isoSensitivity(), -1);    

   216     QVERIFY(camera.supportedIsoSensitivities().isEmpty());

   217     camera.setManualIsoSensitivity(100);

   218     QCOMPARE(camera.isoSensitivity(), -1);

   219     camera.setAutoIsoSensitivity();

   220     QCOMPARE(camera.isoSensitivity(), -1);

   221 

   222     QVERIFY(camera.aperture() < 0);

   223     QVERIFY(camera.supportedApertures().isEmpty());

   224     camera.setAutoAperture();

   225     QVERIFY(camera.aperture() < 0);

   226     camera.setManualAperture(5.6);

   227     QVERIFY(camera.aperture() < 0);

   228 

   229     QVERIFY(camera.shutterSpeed() < 0);

   230     QVERIFY(camera.supportedShutterSpeeds().isEmpty());

   231     camera.setAutoShutterSpeed();

   232     QVERIFY(camera.shutterSpeed() < 0);

   233     camera.setManualShutterSpeed(1/128.0);

   234     QVERIFY(camera.shutterSpeed() < 0);

   235 

   236     QCOMPARE(camera.isExposureLocked(), true);

   237 

   238 }

   239 

   240 void tst_QCamera::testSimpleCameraFocus()

   241 {

   242     QCamera camera(0);

   243 

   244     QCOMPARE(camera.supportedFocusModes(), QCamera::AutoFocus);

   245     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   246     camera.setFocusMode(QCamera::ContinuousFocus);

   247     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   248     QCOMPARE(camera.focusStatus(), QCamera::FocusInitial);

   249 

   250     QVERIFY(!camera.isMacroFocusingSupported());

   251     QVERIFY(!camera.macroFocusingEnabled());

   252     // macro focusing not supported

   253     //camera.setMacroFocusingEnabled(true);

   254     //QVERIFY(!camera.macroFocusingEnabled());

   255 

   256     QCOMPARE(camera.maximumOpticalZoom(), 1.0); // these should be check model ny model

   257     QCOMPARE(camera.maximumDigitalZoom(), 3.0); // these should be check model ny model

   258     QCOMPARE(camera.digitalZoom(), 1.0);

   259     camera.zoomTo(0,2.0);

   260     QCOMPARE(camera.digitalZoom(), 2.0);

   261     QCOMPARE(camera.opticalZoom(), 1.0);

   262 

   263 }

   264 

   265 void tst_QCamera::testSimpleCameraCapture()

   266 {

   267     // This tests that taking a picture works with default setup

   268     QCamera camera(0);

   269     QStillImageCapture imageCapture(&camera);

   270     // we need to start camera before we take images.

   271     QSignalSpy cameraState(&camera, SIGNAL(stateChanged(QCamera::State)));

   272     QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(QString,QImage)));

   273     QSignalSpy errorSignal(&imageCapture, SIGNAL(error(QStillImageCapture::Error)));

   274     QSignalSpy imageSavedSignal(&imageCapture, SIGNAL(imageSaved(const QString&)));

   275    

   276     QCOMPARE(camera.state(), QCamera::StoppedState);

   277     camera.start(); //we need to start camera before taking picture

   278     QTRY_COMPARE(cameraState.count(), 1); // wait for camera to initialize itself

   279     QCOMPARE(camera.state(), QCamera::ActiveState);

   280     QVERIFY(imageCapture.isAvailable());

   281     QVERIFY(imageCapture.isReadyForCapture());

   282     

   283     QCOMPARE(imageCapture.error(), QStillImageCapture::NoError);

   284     QVERIFY(imageCapture.errorString().isEmpty());

   285     

   286     imageCapture.capture(capturePath(QDir::rootPath()));

   287     QTRY_COMPARE(capturedSignal.count(), 1);

   288     QTRY_COMPARE(imageSavedSignal.count(), 1);

   289     

   290     QCOMPARE(errorSignal.size(), 0);

   291         

   292 //    camera.stop();

   293 }

   294 

   295 void tst_QCamera::testCameraCapture()

   296 {

   297     QCamera camera(0);

   298     QStillImageCapture imageCapture(&camera);

   299     // check we have some controls and devices

   300     //QVERIFY(!imageCapture.isAvailable());

   301     QVERIFY(!imageCapture.isReadyForCapture());

   302 

   303     QSignalSpy cameraState(&camera, SIGNAL(stateChanged(QCamera::State)));

   304     QSignalSpy capturedSignal(&imageCapture, SIGNAL(imageCaptured(QString,QImage)));

   305     QSignalSpy errorSignal(&imageCapture, SIGNAL(error(QStillImageCapture::Error)));

   306     QSignalSpy cameraErrorSignal(&camera, SIGNAL(error(QCamera::Error)));

   307     QSignalSpy imageSavedSignal(&imageCapture, SIGNAL(imageSaved(const QString&)));

   308     

   309     // case where we have not started the camera

   310     // we shoul receive NotReadyToCaptureError

   311     imageCapture.capture(QString::fromLatin1("/dev/null"));

   312     QCOMPARE(capturedSignal.size(), 0);

   313     

   314     qDebug()<<"Camera errorNumber=" <<camera.error();

   315     qDebug()<<"Camera errorText="  <<camera.errorString();

   316     

   317     QCOMPARE(cameraErrorSignal.size(), 1);

   318     QCOMPARE(camera.error(), QCamera::NotReadyToCaptureError);

   319     QCOMPARE(errorSignal.size(), 1);

   320     QCOMPARE(imageCapture.error(), QStillImageCapture::NotReadyError);

   321     QCOMPARE(camera.state(), QCamera::StoppedState);

   322 

   323     // Phase 2 test taking picture to a real path

   324     errorSignal.clear();

   325     cameraErrorSignal.clear();

   326     cameraState.clear();

   327     capturedSignal.clear();

   328     imageSavedSignal.clear();

   329     

   330     //we need to start camera before taking picture. this is the difference between previous test 

   331     camera.start();

   332     QTRY_COMPARE (errorSignal.count(), 0); // We should not have any error code.

   333     QTRY_COMPARE (cameraState.count(), 1); // wait for camera to initialize itself

   334     QCOMPARE(camera.state(), QCamera::ActiveState);

   335     QVERIFY(imageCapture.isReadyForCapture());

   336     imageCapture.capture(QString::fromLatin1("/dev/null"));

   337     // we should receive captured signal, but no imageSavedSignal()

   338     QCOMPARE(capturedSignal.size(), 1);

   339     QCOMPARE(errorSignal.size(), 0);

   340     QCOMPARE(cameraErrorSignal.size(), 0);

   341     // as this is no good place to save image we shouldn't have imageSaved signal

   342     QCOMPARE(imageSavedSignal.size(), 0);

   343     QCOMPARE(imageCapture.error(), QStillImageCapture::ResourceError);

   344     

   345     camera.stop();

   346 }

   347 

   348 void tst_QCamera::testCameraWhiteBalance()

   349 {

   350     QCamera::WhiteBalanceModes whiteBalanceModes

   351             = QCamera::WhiteBalanceAuto

   352             | QCamera::WhiteBalanceFlash

   353             | QCamera::WhiteBalanceIncandescent;

   354 

   355     QCamera camera(0);

   356 

   357     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceFlash);

   358     QCOMPARE(camera.supportedWhiteBalanceModes(), whiteBalanceModes);

   359 

   360     camera.setWhiteBalanceMode(QCamera::WhiteBalanceIncandescent);

   361     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceIncandescent);

   362 

   363     camera.setWhiteBalanceMode(QCamera::WhiteBalanceManual);

   364     QCOMPARE(camera.whiteBalanceMode(), QCamera::WhiteBalanceManual);

   365     QCOMPARE(camera.manualWhiteBalance(), 34);

   366 

   367     camera.setManualWhiteBalance(432);

   368     QCOMPARE(camera.manualWhiteBalance(), 432);

   369 }

   370 

   371 void tst_QCamera::testCameraExposure()

   372 {

   373     QCamera camera(0);

   374 

   375     QVERIFY(camera.supportedExposureModes() & QCamera::ExposureAuto);

   376     QCOMPARE(camera.exposureMode(), QCamera::ExposureAuto);

   377     camera.setExposureMode(QCamera::ExposureManual);

   378     QCOMPARE(camera.exposureMode(), QCamera::ExposureManual);

   379 

   380     QCOMPARE(camera.flashMode(), QCamera::FlashAuto);

   381     QCOMPARE(camera.isFlashReady(), true);

   382     camera.setFlashMode(QCamera::FlashOn);

   383     QCOMPARE(camera.flashMode(), QCamera::FlashOn);

   384 

   385     camera.setFlashMode(QCamera::FlashRedEyeReduction); // not expected to be supported

   386     QCOMPARE(camera.flashMode(), QCamera::FlashOn);

   387 

   388     QCOMPARE(camera.meteringMode(), QCamera::MeteringMatrix);

   389     camera.setMeteringMode(QCamera::MeteringAverage);

   390     QCOMPARE(camera.meteringMode(), QCamera::MeteringAverage);

   391     camera.setMeteringMode(QCamera::MeteringSpot);

   392     QCOMPARE(camera.meteringMode(), QCamera::MeteringAverage);

   393 

   394 

   395     QCOMPARE(camera.exposureCompensation(), 0.0);

   396     camera.setExposureCompensation(2.0);

   397     QCOMPARE(camera.exposureCompensation(), 2.0);

   398 

   399     int minIso = camera.supportedIsoSensitivities().first();

   400     int maxIso = camera.supportedIsoSensitivities().last();

   401     QVERIFY(camera.isoSensitivity() > 0);

   402     QVERIFY(minIso > 0);

   403     QVERIFY(maxIso > 0);

   404     camera.setManualIsoSensitivity(minIso);

   405     QCOMPARE(camera.isoSensitivity(), minIso);

   406     camera.setManualIsoSensitivity(maxIso*10);

   407     QCOMPARE(camera.isoSensitivity(), maxIso);

   408     camera.setManualIsoSensitivity(-10);

   409     QCOMPARE(camera.isoSensitivity(), minIso);

   410     camera.setAutoIsoSensitivity();

   411     QCOMPARE(camera.isoSensitivity(), 100);

   412 

   413     qreal minAperture = camera.supportedApertures().first();

   414     qreal maxAperture = camera.supportedApertures().last();

   415     QVERIFY(minAperture > 0);

   416     QVERIFY(maxAperture > 0);

   417     QVERIFY(camera.aperture() >= minAperture);

   418     QVERIFY(camera.aperture() <= maxAperture);

   419 

   420     camera.setAutoAperture();

   421     QVERIFY(camera.aperture() >= minAperture);

   422     QVERIFY(camera.aperture() <= maxAperture);

   423 

   424     camera.setManualAperture(0);

   425     QCOMPARE(camera.aperture(), minAperture);

   426 

   427     camera.setManualAperture(10000);

   428     QCOMPARE(camera.aperture(), maxAperture);

   429 

   430 

   431     qreal minShutterSpeed = camera.supportedShutterSpeeds().first();

   432     qreal maxShutterSpeed = camera.supportedShutterSpeeds().last();

   433     QVERIFY(minShutterSpeed > 0);

   434     QVERIFY(maxShutterSpeed > 0);

   435     QVERIFY(camera.shutterSpeed() >= minShutterSpeed);

   436     QVERIFY(camera.shutterSpeed() <= maxShutterSpeed);

   437 

   438     camera.setAutoShutterSpeed();

   439     QVERIFY(camera.shutterSpeed() >= minShutterSpeed);

   440     QVERIFY(camera.shutterSpeed() <= maxShutterSpeed);

   441 

   442     camera.setManualShutterSpeed(0);

   443     QCOMPARE(camera.shutterSpeed(), minShutterSpeed);

   444 

   445     camera.setManualShutterSpeed(10000);

   446     QCOMPARE(camera.shutterSpeed(), maxShutterSpeed);

   447 

   448     QCOMPARE(camera.isExposureLocked(), false);

   449 

   450     camera.lockExposure();

   451     QCOMPARE(camera.isExposureLocked(), true);

   452 

   453     camera.unlockExposure();

   454     QCOMPARE(camera.isExposureLocked(), false);

   455 }

   456 

   457 void tst_QCamera::testCameraFocus()

   458 {

   459     QCamera camera(0);

   460 

   461     QCOMPARE(camera.supportedFocusModes(), QCamera::AutoFocus /*| QCamera::ContinuousFocus*/);

   462     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   463     camera.setFocusMode(QCamera::ManualFocus);

   464     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   465     camera.setFocusMode(QCamera::ContinuousFocus);

   466     QCOMPARE(camera.focusMode(), QCamera::AutoFocus);

   467     QCOMPARE(camera.focusStatus(), QCamera::FocusInitial);

   468 

   469     QVERIFY(camera.isMacroFocusingSupported());

   470     QVERIFY(!camera.macroFocusingEnabled());

   471     // macro focusing not supported

   472     //camera.setMacroFocusingEnabled(true);

   473     //QVERIFY(camera.macroFocusingEnabled());

   474 

   475     QVERIFY(camera.maximumOpticalZoom() == 1.0);

   476     QVERIFY(camera.maximumDigitalZoom() >= 1.0);

   477     QCOMPARE(camera.digitalZoom(), 1.0);

   478     camera.zoomTo(1.0,0.5);

   479     QCOMPARE(camera.digitalZoom(), 0.5);

   480     camera.zoomTo(1.0,2.0);

   481     QCOMPARE(camera.digitalZoom(), 2.0);

   482     camera.zoomTo(1.0,2000000.0);

   483     QVERIFY(qFuzzyCompare(camera.digitalZoom(), camera.maximumOpticalZoom()*camera.maximumDigitalZoom()));

   484 

   485     /* TODO: focusing has changed 

   486     camera.lockFocus();

   487     QCOMPARE(camera.isFocusLocked(), true);

   488     camera.unlockFocus();

   489     QCOMPARE(camera.isFocusLocked(), false);

   490     */

   491 }

   492 

   493 void tst_QCamera::testImageSettings()

   494 {

   495     QImageEncoderSettings settings;

   496     QVERIFY(settings.isNull());

   497     QVERIFY(settings == QImageEncoderSettings());

   498 

   499     QCOMPARE(settings.codec(), QString());

   500     settings.setCodec(QLatin1String("codecName"));

   501     QCOMPARE(settings.codec(), QLatin1String("codecName"));

   502     QVERIFY(!settings.isNull());

   503     QVERIFY(settings != QImageEncoderSettings());

   504 

   505     settings = QImageEncoderSettings();

   506     QCOMPARE(settings.quality(), QtMedia::NormalQuality);

   507     settings.setQuality(QtMedia::HighQuality);

   508     QCOMPARE(settings.quality(), QtMedia::HighQuality);

   509     QVERIFY(!settings.isNull());

   510 

   511     settings = QImageEncoderSettings();

   512     QCOMPARE(settings.resolution(), QSize());

   513     settings.setResolution(QSize(320,240));

   514     QCOMPARE(settings.resolution(), QSize(320,240));

   515     settings.setResolution(800,600);

   516     QCOMPARE(settings.resolution(), QSize(800,600));

   517     QVERIFY(!settings.isNull());

   518 

   519     settings = QImageEncoderSettings();

   520     QVERIFY(settings.isNull());

   521     QCOMPARE(settings.codec(), QString());

   522     QCOMPARE(settings.quality(), QtMedia::NormalQuality);

   523     QCOMPARE(settings.resolution(), QSize());

   524 

   525     {

   526         QImageEncoderSettings settings1;

   527         QImageEncoderSettings settings2;

   528         QCOMPARE(settings2, settings1);

   529 

   530         settings2 = settings1;

   531         QCOMPARE(settings2, settings1);

   532         QVERIFY(settings2.isNull());

   533 

   534         settings1.setQuality(QtMedia::HighQuality);

   535 

   536         QVERIFY(settings2.isNull());

   537         QVERIFY(!settings1.isNull());

   538         QVERIFY(settings1 != settings2);

   539     }

   540 

   541     {

   542         QImageEncoderSettings settings1;

   543         QImageEncoderSettings settings2(settings1);

   544         QCOMPARE(settings2, settings1);

   545 

   546         settings2 = settings1;

   547         QCOMPARE(settings2, settings1);

   548         QVERIFY(settings2.isNull());

   549 

   550         settings1.setQuality(QtMedia::HighQuality);

   551 

   552         QVERIFY(settings2.isNull());

   553         QVERIFY(!settings1.isNull());

   554         QVERIFY(settings1 != settings2);

   555     }

   556 

   557     QImageEncoderSettings settings1;

   558     QImageEncoderSettings settings2;

   559 

   560     settings1 = QImageEncoderSettings();

   561     settings1.setResolution(800,600);

   562     settings2 = QImageEncoderSettings();

   563     settings2.setResolution(QSize(800,600));

   564     QVERIFY(settings1 == settings2);

   565     settings2.setResolution(QSize(400,300));

   566     QVERIFY(settings1 != settings2);

   567 

   568     settings1 = QImageEncoderSettings();

   569     settings1.setCodec("codec1");

   570     settings2 = QImageEncoderSettings();

   571     settings2.setCodec("codec1");

   572     QVERIFY(settings1 == settings2);

   573     settings2.setCodec("codec2");

   574     QVERIFY(settings1 != settings2);

   575 

   576     settings1 = QImageEncoderSettings();

   577     settings1.setQuality(QtMedia::NormalQuality);

   578     settings2 = QImageEncoderSettings();

   579     settings2.setQuality(QtMedia::NormalQuality);

   580     QVERIFY(settings1 == settings2);

   581     settings2.setQuality(QtMedia::LowQuality);

   582     QVERIFY(settings1 != settings2);

   583 }

   584 

   585 QTEST_MAIN(tst_QCamera)

   586 

   587 #include "tst_qcamera.moc"