slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
ba62df130c91ba472cadb77bd596e19fd6ca5ccb
qtmultimedia/tests/auto/qmediarecorder/tst_qmediarecorder.cpp
Dmytro Poplavskiy ba62df130c Fixed crash when QMediaObject is deleted before QMediaRecorder. 
Change-Id: I8a1674b6f3d2b2c9ab888facff21f94af41b81de
Reviewed-on: http://codereview.qt.nokia.com/3544
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Michael Goddard <michael.goddard@nokia.com>
2011-08-26 06:18:10 +02:00

1287 lines
47 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this
** file. Please review the following information to ensure the GNU Lesser
** General Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU General
** Public License version 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of this
** file. Please review the following information to ensure the GNU General
** Public License version 3.0 requirements will be met:
** http://www.gnu.org/copyleft/gpl.html.
**
** Other Usage
** Alternatively, this file may be used in accordance with the terms and
** conditions contained in a signed written agreement between you and Nokia.
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
//TESTED_COMPONENT=src/multimedia
#include "tst_qmediarecorder.h"
QT_USE_NAMESPACE
void tst_QMediaRecorder::initTestCase()
{
qRegisterMetaType<QMediaRecorder::State>("QMediaRecorder::State");
qRegisterMetaType<QMediaRecorder::Error>("QMediaRecorder::Error");
mock = new MockMediaRecorderControl(this);
service = new MockMediaRecorderService(this, mock);
object = new MockMediaObject(this, service);
capture = new QMediaRecorder(object);
audio = qobject_cast<QAudioEndpointSelector*>(service->requestControl(QAudioEndpointSelector_iid));
encode = qobject_cast<QAudioEncoderControl*>(service->requestControl(QAudioEncoderControl_iid));
videoEncode = qobject_cast<QVideoEncoderControl*>(service->requestControl(QVideoEncoderControl_iid));
}
void tst_QMediaRecorder::cleanupTestCase()
{
delete capture;
delete object;
delete service;
delete mock;
}
void tst_QMediaRecorder::testNullService()
{
const QString id(QLatin1String("application/x-format"));
MockMediaObject object(0, 0);
QMediaRecorder recorder(&object);
QCOMPARE(recorder.outputLocation(), QUrl());
QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);
QCOMPARE(recorder.error(), QMediaRecorder::NoError);
QCOMPARE(recorder.duration(), qint64(0));
QCOMPARE(recorder.supportedContainers(), QStringList());
QCOMPARE(recorder.containerDescription(id), QString());
QCOMPARE(recorder.supportedAudioCodecs(), QStringList());
QCOMPARE(recorder.audioCodecDescription(id), QString());
QCOMPARE(recorder.supportedAudioSampleRates(), QList<int>());
QCOMPARE(recorder.supportedVideoCodecs(), QStringList());
QCOMPARE(recorder.videoCodecDescription(id), QString());
bool continuous = true;
QCOMPARE(recorder.supportedResolutions(QVideoEncoderSettings(), &continuous), QList<QSize>());
QCOMPARE(continuous, false);
continuous = true;
QCOMPARE(recorder.supportedFrameRates(QVideoEncoderSettings(), &continuous), QList<qreal>());
QCOMPARE(continuous, false);
QCOMPARE(recorder.audioSettings(), QAudioEncoderSettings());
QCOMPARE(recorder.videoSettings(), QVideoEncoderSettings());
QCOMPARE(recorder.containerMimeType(), QString());
QVERIFY(!recorder.isMuted());
recorder.setMuted(true);
QVERIFY(!recorder.isMuted());
}
void tst_QMediaRecorder::testNullControls()
{
const QString id(QLatin1String("application/x-format"));
MockMediaRecorderService service(0, 0);
service.hasControls = false;
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QCOMPARE(recorder.outputLocation(), QUrl());
QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);
QCOMPARE(recorder.error(), QMediaRecorder::NoError);
QCOMPARE(recorder.duration(), qint64(0));
QCOMPARE(recorder.supportedContainers(), QStringList());
QCOMPARE(recorder.containerDescription(id), QString());
QCOMPARE(recorder.supportedAudioCodecs(), QStringList());
QCOMPARE(recorder.audioCodecDescription(id), QString());
QCOMPARE(recorder.supportedAudioSampleRates(), QList<int>());
QCOMPARE(recorder.supportedVideoCodecs(), QStringList());
QCOMPARE(recorder.videoCodecDescription(id), QString());
bool continuous = true;
QCOMPARE(recorder.supportedResolutions(QVideoEncoderSettings(), &continuous), QList<QSize>());
QCOMPARE(continuous, false);
continuous = true;
QCOMPARE(recorder.supportedFrameRates(QVideoEncoderSettings(), &continuous), QList<qreal>());
QCOMPARE(continuous, false);
QCOMPARE(recorder.audioSettings(), QAudioEncoderSettings());
QCOMPARE(recorder.videoSettings(), QVideoEncoderSettings());
QCOMPARE(recorder.containerMimeType(), QString());
recorder.setOutputLocation(QUrl("file://test/save/file.mp4"));
QCOMPARE(recorder.outputLocation(), QUrl());
QAudioEncoderSettings audio;
audio.setCodec(id);
audio.setQuality(QtMultimediaKit::LowQuality);
QVideoEncoderSettings video;
video.setCodec(id);
video.setResolution(640, 480);
recorder.setEncodingSettings(audio, video, id);
QCOMPARE(recorder.audioSettings(), QAudioEncoderSettings());
QCOMPARE(recorder.videoSettings(), QVideoEncoderSettings());
QCOMPARE(recorder.containerMimeType(), QString());
QSignalSpy spy(&recorder, SIGNAL(stateChanged(QMediaRecorder::State)));
recorder.record();
QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);
QCOMPARE(recorder.error(), QMediaRecorder::NoError);
QCOMPARE(spy.count(), 0);
recorder.pause();
QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);
QCOMPARE(recorder.error(), QMediaRecorder::NoError);
QCOMPARE(spy.count(), 0);
recorder.stop();
QCOMPARE(recorder.state(), QMediaRecorder::StoppedState);
QCOMPARE(recorder.error(), QMediaRecorder::NoError);
QCOMPARE(spy.count(), 0);
}
void tst_QMediaRecorder::testDeleteMediaObject()
{
MockMediaRecorderControl *mock = new MockMediaRecorderControl(this);
MockMediaRecorderService *service = new MockMediaRecorderService(this, mock);
MockMediaObject *object = new MockMediaObject(this, service);
QMediaRecorder *capture = new QMediaRecorder(object);
QVERIFY(capture->mediaObject() == object);
QVERIFY(capture->isAvailable());
delete object;
delete service;
delete mock;
QVERIFY(capture->mediaObject() == 0);
QVERIFY(!capture->isAvailable());
delete capture;
}
void tst_QMediaRecorder::testError()
{
const QString errorString(QLatin1String("format error"));
QSignalSpy spy(capture, SIGNAL(error(QMediaRecorder::Error)));
QCOMPARE(capture->error(), QMediaRecorder::NoError);
QCOMPARE(capture->errorString(), QString());
mock->error(QMediaRecorder::FormatError, errorString);
QCOMPARE(capture->error(), QMediaRecorder::FormatError);
QCOMPARE(capture->errorString(), errorString);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.last()[0].value<QMediaRecorder::Error>(), QMediaRecorder::FormatError);
}
void tst_QMediaRecorder::testSink()
{
capture->setOutputLocation(QUrl("test.tmp"));
QUrl s = capture->outputLocation();
QCOMPARE(s.toString(), QString("test.tmp"));
}
void tst_QMediaRecorder::testRecord()
{
QSignalSpy stateSignal(capture,SIGNAL(stateChanged(QMediaRecorder::State)));
QSignalSpy progressSignal(capture, SIGNAL(durationChanged(qint64)));
capture->record();
QCOMPARE(capture->state(), QMediaRecorder::RecordingState);
QCOMPARE(capture->error(), QMediaRecorder::NoError);
QCOMPARE(capture->errorString(), QString());
QTestEventLoop::instance().enterLoop(1);
QCOMPARE(stateSignal.count(), 1);
QCOMPARE(stateSignal.last()[0].value<QMediaRecorder::State>(), QMediaRecorder::RecordingState);
QVERIFY(progressSignal.count() > 0);
capture->pause();
QCOMPARE(capture->state(), QMediaRecorder::PausedState);
QTestEventLoop::instance().enterLoop(1);
QCOMPARE(stateSignal.count(), 2);
capture->stop();
QCOMPARE(capture->state(), QMediaRecorder::StoppedState);
QTestEventLoop::instance().enterLoop(1);
QCOMPARE(stateSignal.count(), 3);
mock->stop();
QCOMPARE(stateSignal.count(), 3);
}
void tst_QMediaRecorder::testMute()
{
QSignalSpy mutedChanged(capture, SIGNAL(mutedChanged(bool)));
QVERIFY(!capture->isMuted());
capture->setMuted(true);
QCOMPARE(mutedChanged.size(), 1);
QCOMPARE(mutedChanged[0][0].toBool(), true);
QVERIFY(capture->isMuted());
capture->setMuted(false);
QCOMPARE(mutedChanged.size(), 2);
QCOMPARE(mutedChanged[1][0].toBool(), false);
QVERIFY(!capture->isMuted());
capture->setMuted(false);
QCOMPARE(mutedChanged.size(), 2);
}
void tst_QMediaRecorder::testAudioDeviceControl()
{
QSignalSpy readSignal(audio,SIGNAL(activeEndpointChanged(QString)));
QVERIFY(audio->availableEndpoints().size() == 3);
QVERIFY(audio->defaultEndpoint().compare("device1") == 0);
audio->setActiveEndpoint("device2");
QTestEventLoop::instance().enterLoop(1);
QVERIFY(audio->activeEndpoint().compare("device2") == 0);
QVERIFY(readSignal.count() == 1);
QVERIFY(audio->endpointDescription("device2").compare("dev2 comment") == 0);
}
void tst_QMediaRecorder::testAudioEncodeControl()
{
QStringList codecs = capture->supportedAudioCodecs();
QVERIFY(codecs.count() == 2);
QVERIFY(capture->audioCodecDescription("audio/pcm") == "Pulse Code Modulation");
QStringList options = encode->supportedEncodingOptions("audio/mpeg");
QCOMPARE(options.count(), 4);
QVERIFY(encode->encodingOption("audio/mpeg","bitrate").isNull());
encode->setEncodingOption("audio/mpeg", "bitrate", QString("vbr"));
QCOMPARE(encode->encodingOption("audio/mpeg","bitrate").toString(), QString("vbr"));
QList<int> rates;
rates << 8000 << 11025 << 22050 << 44100;
QCOMPARE(capture->supportedAudioSampleRates(), rates);
}
void tst_QMediaRecorder::testMediaFormatsControl()
{
QCOMPARE(capture->supportedContainers(), QStringList() << "wav" << "mp3" << "mov");
QCOMPARE(capture->containerDescription("wav"), QString("WAV format"));
QCOMPARE(capture->containerDescription("mp3"), QString("MP3 format"));
QCOMPARE(capture->containerDescription("ogg"), QString());
}
void tst_QMediaRecorder::testVideoEncodeControl()
{
bool continuous = false;
QList<QSize> sizes = capture->supportedResolutions(QVideoEncoderSettings(), &continuous);
QCOMPARE(sizes.count(), 2);
QCOMPARE(continuous, true);
QList<qreal> rates = capture->supportedFrameRates(QVideoEncoderSettings(), &continuous);
QCOMPARE(rates.count(), 3);
QCOMPARE(continuous, false);
QStringList vCodecs = capture->supportedVideoCodecs();
QVERIFY(vCodecs.count() == 2);
QCOMPARE(capture->videoCodecDescription("video/3gpp"), QString("video/3gpp"));
QStringList options = videoEncode->supportedEncodingOptions("video/3gpp");
QCOMPARE(options.count(), 2);
QVERIFY(encode->encodingOption("video/3gpp","me").isNull());
encode->setEncodingOption("video/3gpp", "me", QString("dia"));
QCOMPARE(encode->encodingOption("video/3gpp","me").toString(), QString("dia"));
}
void tst_QMediaRecorder::testEncodingSettings()
{
QAudioEncoderSettings audioSettings = capture->audioSettings();
QCOMPARE(audioSettings.codec(), QString("audio/pcm"));
QCOMPARE(audioSettings.bitRate(), 128*1024);
QCOMPARE(audioSettings.sampleRate(), 8000);
QCOMPARE(audioSettings.quality(), QtMultimediaKit::NormalQuality);
QCOMPARE(audioSettings.channelCount(), -1);
QCOMPARE(audioSettings.encodingMode(), QtMultimediaKit::ConstantQualityEncoding);
QVideoEncoderSettings videoSettings = capture->videoSettings();
QCOMPARE(videoSettings.codec(), QString());
QCOMPARE(videoSettings.bitRate(), -1);
QCOMPARE(videoSettings.resolution(), QSize());
QCOMPARE(videoSettings.frameRate(), 0.0);
QCOMPARE(videoSettings.quality(), QtMultimediaKit::NormalQuality);
QCOMPARE(videoSettings.encodingMode(), QtMultimediaKit::ConstantQualityEncoding);
QString format = capture->containerMimeType();
QCOMPARE(format, QString());
audioSettings.setCodec("audio/mpeg");
audioSettings.setSampleRate(44100);
audioSettings.setBitRate(256*1024);
audioSettings.setQuality(QtMultimediaKit::HighQuality);
audioSettings.setEncodingMode(QtMultimediaKit::AverageBitRateEncoding);
videoSettings.setCodec("video/3gpp");
videoSettings.setBitRate(800);
videoSettings.setFrameRate(24*1024);
videoSettings.setResolution(QSize(800,600));
videoSettings.setQuality(QtMultimediaKit::HighQuality);
audioSettings.setEncodingMode(QtMultimediaKit::TwoPassEncoding);
format = QString("mov");
capture->setEncodingSettings(audioSettings,videoSettings,format);
QCOMPARE(capture->audioSettings(), audioSettings);
QCOMPARE(capture->videoSettings(), videoSettings);
QCOMPARE(capture->containerMimeType(), format);
}
void tst_QMediaRecorder::testAudioSettings()
{
QAudioEncoderSettings settings;
QVERIFY(settings.isNull());
QVERIFY(settings == QAudioEncoderSettings());
QCOMPARE(settings.codec(), QString());
settings.setCodec(QLatin1String("codecName"));
QCOMPARE(settings.codec(), QLatin1String("codecName"));
QVERIFY(!settings.isNull());
QVERIFY(settings != QAudioEncoderSettings());
settings = QAudioEncoderSettings();
QCOMPARE(settings.bitRate(), -1);
settings.setBitRate(128000);
QCOMPARE(settings.bitRate(), 128000);
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
QCOMPARE(settings.quality(), QtMultimediaKit::NormalQuality);
settings.setQuality(QtMultimediaKit::HighQuality);
QCOMPARE(settings.quality(), QtMultimediaKit::HighQuality);
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
QCOMPARE(settings.sampleRate(), -1);
settings.setSampleRate(44100);
QCOMPARE(settings.sampleRate(), 44100);
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
QCOMPARE(settings.channelCount(), -1);
settings.setChannelCount(2);
QCOMPARE(settings.channelCount(), 2);
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.bitRate(), -1);
QCOMPARE(settings.quality(), QtMultimediaKit::NormalQuality);
QCOMPARE(settings.sampleRate(), -1);
{
QAudioEncoderSettings settings1;
QAudioEncoderSettings settings2;
QCOMPARE(settings2, settings1);
settings2 = settings1;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimediaKit::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
QVERIFY(settings1 != settings2);
}
{
QAudioEncoderSettings settings1;
QAudioEncoderSettings settings2(settings1);
QCOMPARE(settings2, settings1);
settings2 = settings1;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimediaKit::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
QVERIFY(settings1 != settings2);
}
QAudioEncoderSettings settings1;
settings1.setBitRate(1);
QAudioEncoderSettings settings2;
settings2.setBitRate(1);
QVERIFY(settings1 == settings2);
settings2.setBitRate(2);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setChannelCount(1);
settings2 = QAudioEncoderSettings();
settings2.setChannelCount(1);
QVERIFY(settings1 == settings2);
settings2.setChannelCount(2);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setCodec("codec1");
settings2 = QAudioEncoderSettings();
settings2.setCodec("codec1");
QVERIFY(settings1 == settings2);
settings2.setCodec("codec2");
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
settings2 = QAudioEncoderSettings();
settings2.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
QVERIFY(settings1 == settings2);
settings2.setEncodingMode(QtMultimediaKit::TwoPassEncoding);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setQuality(QtMultimediaKit::NormalQuality);
settings2 = QAudioEncoderSettings();
settings2.setQuality(QtMultimediaKit::NormalQuality);
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimediaKit::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setSampleRate(1);
settings2 = QAudioEncoderSettings();
settings2.setSampleRate(1);
QVERIFY(settings1 == settings2);
settings2.setSampleRate(2);
QVERIFY(settings1 != settings2);
}
void tst_QMediaRecorder::testVideoSettings()
{
QVideoEncoderSettings settings;
QVERIFY(settings.isNull());
QVERIFY(settings == QVideoEncoderSettings());
QCOMPARE(settings.codec(), QString());
settings.setCodec(QLatin1String("codecName"));
QCOMPARE(settings.codec(), QLatin1String("codecName"));
QVERIFY(!settings.isNull());
QVERIFY(settings != QVideoEncoderSettings());
settings = QVideoEncoderSettings();
QCOMPARE(settings.bitRate(), -1);
settings.setBitRate(128000);
QCOMPARE(settings.bitRate(), 128000);
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
QCOMPARE(settings.quality(), QtMultimediaKit::NormalQuality);
settings.setQuality(QtMultimediaKit::HighQuality);
QCOMPARE(settings.quality(), QtMultimediaKit::HighQuality);
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
QCOMPARE(settings.frameRate(), qreal());
settings.setFrameRate(30000.0/10001);
QVERIFY(qFuzzyCompare(settings.frameRate(), qreal(30000.0/10001)));
settings.setFrameRate(24.0);
QVERIFY(qFuzzyCompare(settings.frameRate(), qreal(24.0)));
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
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 = QVideoEncoderSettings();
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.bitRate(), -1);
QCOMPARE(settings.quality(), QtMultimediaKit::NormalQuality);
QCOMPARE(settings.frameRate(), qreal());
QCOMPARE(settings.resolution(), QSize());
{
QVideoEncoderSettings settings1;
QVideoEncoderSettings settings2;
QCOMPARE(settings2, settings1);
settings2 = settings1;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimediaKit::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
QVERIFY(settings1 != settings2);
}
{
QVideoEncoderSettings settings1;
QVideoEncoderSettings settings2(settings1);
QCOMPARE(settings2, settings1);
settings2 = settings1;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimediaKit::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
QVERIFY(settings1 != settings2);
}
QVideoEncoderSettings settings1;
settings1.setBitRate(1);
QVideoEncoderSettings settings2;
settings2.setBitRate(1);
QVERIFY(settings1 == settings2);
settings2.setBitRate(2);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setResolution(800,600);
settings2 = QVideoEncoderSettings();
settings2.setResolution(QSize(800,600));
QVERIFY(settings1 == settings2);
settings2.setResolution(QSize(400,300));
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setCodec("codec1");
settings2 = QVideoEncoderSettings();
settings2.setCodec("codec1");
QVERIFY(settings1 == settings2);
settings2.setCodec("codec2");
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
settings2.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
QVERIFY(settings1 == settings2);
settings2.setEncodingMode(QtMultimediaKit::TwoPassEncoding);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setQuality(QtMultimediaKit::NormalQuality);
settings2 = QVideoEncoderSettings();
settings2.setQuality(QtMultimediaKit::NormalQuality);
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimediaKit::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setFrameRate(1);
settings2 = QVideoEncoderSettings();
settings2.setFrameRate(1);
QVERIFY(settings1 == settings2);
settings2.setFrameRate(2);
QVERIFY(settings1 != settings2);
}
void tst_QMediaRecorder::nullMetaDataControl()
{
const QString titleKey(QLatin1String("Title"));
const QString title(QLatin1String("Host of Seraphim"));
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
service.hasControls = false;
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QSignalSpy spy(&recorder, SIGNAL(metaDataChanged()));
QCOMPARE(recorder.isMetaDataAvailable(), false);
QCOMPARE(recorder.isMetaDataWritable(), false);
recorder.setMetaData(QtMultimediaKit::Title, title);
recorder.setExtendedMetaData(titleKey, title);
QCOMPARE(recorder.metaData(QtMultimediaKit::Title).toString(), QString());
QCOMPARE(recorder.extendedMetaData(titleKey).toString(), QString());
QCOMPARE(recorder.availableMetaData(), QList<QtMultimediaKit::MetaData>());
QCOMPARE(recorder.availableExtendedMetaData(), QStringList());
QCOMPARE(spy.count(), 0);
}
void tst_QMediaRecorder::isMetaDataAvailable()
{
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
service.mockMetaDataControl->setMetaDataAvailable(false);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QCOMPARE(recorder.isMetaDataAvailable(), false);
QSignalSpy spy(&recorder, SIGNAL(metaDataAvailableChanged(bool)));
service.mockMetaDataControl->setMetaDataAvailable(true);
QCOMPARE(recorder.isMetaDataAvailable(), true);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), true);
service.mockMetaDataControl->setMetaDataAvailable(false);
QCOMPARE(recorder.isMetaDataAvailable(), false);
QCOMPARE(spy.count(), 2);
QCOMPARE(spy.at(1).at(0).toBool(), false);
}
void tst_QMediaRecorder::isWritable()
{
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
service.mockMetaDataControl->setWritable(false);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QSignalSpy spy(&recorder, SIGNAL(metaDataWritableChanged(bool)));
QCOMPARE(recorder.isMetaDataWritable(), false);
service.mockMetaDataControl->setWritable(true);
QCOMPARE(recorder.isMetaDataWritable(), true);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.at(0).at(0).toBool(), true);
service.mockMetaDataControl->setWritable(false);
QCOMPARE(recorder.isMetaDataWritable(), false);
QCOMPARE(spy.count(), 2);
QCOMPARE(spy.at(1).at(0).toBool(), false);
}
void tst_QMediaRecorder::metaDataChanged()
{
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QSignalSpy spy(&recorder, SIGNAL(metaDataChanged()));
service.mockMetaDataControl->metaDataChanged();
QCOMPARE(spy.count(), 1);
service.mockMetaDataControl->metaDataChanged();
QCOMPARE(spy.count(), 2);
}
void tst_QMediaRecorder::metaData_data()
{
QTest::addColumn<QString>("artist");
QTest::addColumn<QString>("title");
QTest::addColumn<QString>("genre");
QTest::newRow("")
<< QString::fromLatin1("Dead Can Dance")
<< QString::fromLatin1("Host of Seraphim")
<< QString::fromLatin1("Awesome");
}
void tst_QMediaRecorder::metaData()
{
QFETCH(QString, artist);
QFETCH(QString, title);
QFETCH(QString, genre);
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
service.mockMetaDataControl->populateMetaData();
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QVERIFY(object.availableMetaData().isEmpty());
service.mockMetaDataControl->m_data.insert(QtMultimediaKit::AlbumArtist, artist);
service.mockMetaDataControl->m_data.insert(QtMultimediaKit::Title, title);
service.mockMetaDataControl->m_data.insert(QtMultimediaKit::Genre, genre);
QCOMPARE(recorder.metaData(QtMultimediaKit::AlbumArtist).toString(), artist);
QCOMPARE(recorder.metaData(QtMultimediaKit::Title).toString(), title);
QList<QtMultimediaKit::MetaData> metaDataKeys = recorder.availableMetaData();
QCOMPARE(metaDataKeys.size(), 3);
QVERIFY(metaDataKeys.contains(QtMultimediaKit::AlbumArtist));
QVERIFY(metaDataKeys.contains(QtMultimediaKit::Title));
QVERIFY(metaDataKeys.contains(QtMultimediaKit::Genre));
}
void tst_QMediaRecorder::setMetaData_data()
{
QTest::addColumn<QString>("title");
QTest::newRow("")
<< QString::fromLatin1("In the Kingdom of the Blind the One eyed are Kings");
}
void tst_QMediaRecorder::setMetaData()
{
QFETCH(QString, title);
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
service.mockMetaDataControl->populateMetaData();
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
recorder.setMetaData(QtMultimediaKit::Title, title);
QCOMPARE(recorder.metaData(QtMultimediaKit::Title).toString(), title);
QCOMPARE(service.mockMetaDataControl->m_data.value(QtMultimediaKit::Title).toString(), title);
}
void tst_QMediaRecorder::extendedMetaData()
{
QFETCH(QString, artist);
QFETCH(QString, title);
QFETCH(QString, genre);
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QVERIFY(recorder.availableExtendedMetaData().isEmpty());
service.mockMetaDataControl->m_extendedData.insert(QLatin1String("Artist"), artist);
service.mockMetaDataControl->m_extendedData.insert(QLatin1String("Title"), title);
service.mockMetaDataControl->m_extendedData.insert(QLatin1String("Genre"), genre);
QCOMPARE(recorder.extendedMetaData(QLatin1String("Artist")).toString(), artist);
QCOMPARE(recorder.extendedMetaData(QLatin1String("Title")).toString(), title);
QStringList extendedKeys = recorder.availableExtendedMetaData();
QCOMPARE(extendedKeys.size(), 3);
QVERIFY(extendedKeys.contains(QLatin1String("Artist")));
QVERIFY(extendedKeys.contains(QLatin1String("Title")));
QVERIFY(extendedKeys.contains(QLatin1String("Genre")));
}
void tst_QMediaRecorder::setExtendedMetaData()
{
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service(0, &recorderControl);
service.mockMetaDataControl->populateMetaData();
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QString title(QLatin1String("In the Kingdom of the Blind the One eyed are Kings"));
recorder.setExtendedMetaData(QLatin1String("Title"), title);
QCOMPARE(recorder.extendedMetaData(QLatin1String("Title")).toString(), title);
QCOMPARE(service.mockMetaDataControl->m_extendedData.value(QLatin1String("Title")).toString(), title);
}
void tst_QMediaRecorder::testAudioSettingsCopyConstructor()
{
/* create an object for AudioEncodersettings */
QAudioEncoderSettings audiosettings;
QVERIFY(audiosettings.isNull());
/* setting the desired properties for the AudioEncoder */
audiosettings.setBitRate(128*1000);
audiosettings.setChannelCount(4);
audiosettings.setCodec("audio/pcm");
audiosettings.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
audiosettings.setQuality(QtMultimediaKit::LowQuality);
audiosettings.setSampleRate(44100);
/* Copy constructor */
QAudioEncoderSettings other(audiosettings);
QVERIFY(!(other.isNull()));
/* Verifying whether data is copied properly or not */
QVERIFY(other.bitRate() == audiosettings.bitRate());
QVERIFY(other.sampleRate() == audiosettings.sampleRate());
QVERIFY(other.channelCount() == audiosettings.channelCount());
QCOMPARE(other.codec(), audiosettings.codec());
QVERIFY(other.encodingMode() == audiosettings.encodingMode());
QVERIFY(other.quality() == audiosettings.quality());
}
void tst_QMediaRecorder::testAudioSettingsOperatorNotEqual()
{
/* create an object for AudioEncodersettings */
QAudioEncoderSettings audiosettings1;
QVERIFY(audiosettings1.isNull());
QAudioEncoderSettings audiosettings2;
QVERIFY(audiosettings2.isNull());
/* setting the desired properties to for the AudioEncoder */
audiosettings1.setBitRate(128*1000);
audiosettings1.setChannelCount(4);
audiosettings1.setCodec("audio/pcm");
audiosettings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
audiosettings1.setQuality(QtMultimediaKit::LowQuality);
audiosettings1.setSampleRate(44100);
/* setting the desired properties for the AudioEncoder */
audiosettings2.setBitRate(128*1000);
audiosettings2.setChannelCount(4);
audiosettings2.setCodec("audio/pcm");
audiosettings2.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
audiosettings2.setQuality(QtMultimediaKit::LowQuality);
audiosettings2.setSampleRate(44100);
/* verify the both are equal or not */
QVERIFY(!(audiosettings1 != audiosettings2));
/* Modify the settings value for one object */
audiosettings2.setBitRate(64*1000);
audiosettings2.setEncodingMode(QtMultimediaKit::ConstantQualityEncoding);
/* verify the not equal opertor */
QVERIFY(audiosettings1 != audiosettings2);
QVERIFY(audiosettings2.bitRate() != audiosettings1.bitRate());
QVERIFY(audiosettings2.encodingMode() != audiosettings1.encodingMode());
}
void tst_QMediaRecorder::testAudioSettingsOperatorEqual()
{
/* create an object for AudioEncodersettings */
QAudioEncoderSettings audiosettings1;
QVERIFY(audiosettings1.isNull());
/* setting the desired properties to for the AudioEncoder */
audiosettings1.setBitRate(128*1000);
audiosettings1.setChannelCount(4);
audiosettings1.setCodec("audio/pcm");
audiosettings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
audiosettings1.setQuality(QtMultimediaKit::LowQuality);
audiosettings1.setSampleRate(44100);
QAudioEncoderSettings audiosettings2;
QVERIFY(audiosettings2.isNull());
/* setting the desired properties for the AudioEncoder */
audiosettings2.setBitRate(128*1000);
audiosettings2.setChannelCount(4);
audiosettings2.setCodec("audio/pcm");
audiosettings2.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
audiosettings2.setQuality(QtMultimediaKit::LowQuality);
audiosettings2.setSampleRate(44100);
/* verify both the values are same or not */
QVERIFY(audiosettings1 == audiosettings2);
audiosettings2.setChannelCount(2);
QVERIFY(audiosettings1 != audiosettings2);
}
void tst_QMediaRecorder::testAudioSettingsOperatorAssign()
{
/* create an object for AudioEncodersettings */
QAudioEncoderSettings audiosettings1;
QVERIFY(audiosettings1.isNull());
/* setting the desired properties for the AudioEncoder */
audiosettings1.setBitRate(128*1000);
audiosettings1.setChannelCount(4);
audiosettings1.setCodec("audio/pcm");
audiosettings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
audiosettings1.setQuality(QtMultimediaKit::LowQuality);
audiosettings1.setSampleRate(44100);
QAudioEncoderSettings audiosettings2;
audiosettings2 = audiosettings1;
/* Verifying whether data is copied properly or not */
QVERIFY(audiosettings2.bitRate() == audiosettings1.bitRate());
QVERIFY(audiosettings2.sampleRate() == audiosettings1.sampleRate());
QVERIFY(audiosettings2.channelCount() == audiosettings1.channelCount());
QCOMPARE(audiosettings2.codec(), audiosettings1.codec());
QVERIFY(audiosettings2.encodingMode() == audiosettings1.encodingMode());
QVERIFY(audiosettings2.quality() == audiosettings1.quality());
}
void tst_QMediaRecorder::testAudioSettingsDestructor()
{
/* Creating null object for the audioencodersettings */
QAudioEncoderSettings * audiosettings = new QAudioEncoderSettings;
/* Verifying the object is null or not */
QVERIFY(audiosettings->isNull());
/* delete the allocated memory */
delete audiosettings;
}
/* availabilityError() API test. */
void tst_QMediaRecorder::testAvailabilityError()
{
MockMediaRecorderService service(0, 0);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QCOMPARE(recorder.availabilityError(), QtMultimediaKit::ServiceMissingError);
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service1(0, &recorderControl);
service1.mockMetaDataControl->populateMetaData();
MockMediaObject object1(0, &service1);
QMediaRecorder recorder1(&object1);
QCOMPARE(recorder1.availabilityError(), QtMultimediaKit::NoError);
}
/* isAvailable() API test. */
void tst_QMediaRecorder::testIsAvailable()
{
MockMediaRecorderService service(0, 0);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QCOMPARE(recorder.isAvailable(), false);
MockMediaRecorderControl recorderControl(0);
MockMediaRecorderService service1(0, &recorderControl);
service1.mockMetaDataControl->populateMetaData();
MockMediaObject object1(0, &service1);
QMediaRecorder recorder1(&object1);
QCOMPARE(recorder1.isAvailable(), true);
}
/* mediaObject() API test. */
void tst_QMediaRecorder::testMediaObject()
{
MockMediaRecorderService service(0, 0);
service.hasControls = false;
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QMediaObject *medobj = recorder.mediaObject();
QVERIFY(medobj == NULL);
QMediaObject *medobj1 = capture->mediaObject();
QVERIFY(medobj1 != NULL);
}
/* enum QMediaRecorder::ResourceError property test. */
void tst_QMediaRecorder::testEnum()
{
const QString errorString(QLatin1String("resource error"));
QSignalSpy spy(capture, SIGNAL(error(QMediaRecorder::Error)));
QCOMPARE(capture->error(), QMediaRecorder::NoError);
QCOMPARE(capture->errorString(), QString());
mock->error(QMediaRecorder::ResourceError, errorString);
QCOMPARE(capture->error(), QMediaRecorder::ResourceError);
QCOMPARE(capture->errorString(), errorString);
QCOMPARE(spy.count(), 1);
QCOMPARE(spy.last()[0].value<QMediaRecorder::Error>(), QMediaRecorder::ResourceError);
}
/* Test the QVideoEncoderSettings quality API*/
void tst_QMediaRecorder::testVideoSettingsQuality()
{
/* Create the instance*/
QVideoEncoderSettings settings;
QVERIFY(settings.isNull());
QVERIFY(settings == QVideoEncoderSettings());
/* Verify the default value is intialised correctly*/
QCOMPARE(settings.quality(), QtMultimediaKit::NormalQuality);
/* Set all types of Quality parameter and Verify if it is set correctly*/
settings.setQuality(QtMultimediaKit::HighQuality);
QCOMPARE(settings.quality(), QtMultimediaKit::HighQuality);
QVERIFY(!settings.isNull());
settings.setQuality(QtMultimediaKit::VeryLowQuality);
QCOMPARE(settings.quality(), QtMultimediaKit::VeryLowQuality);
settings.setQuality(QtMultimediaKit::LowQuality);
QCOMPARE(settings.quality(), QtMultimediaKit::LowQuality);
settings.setQuality(QtMultimediaKit::VeryHighQuality);
QCOMPARE(settings.quality(), QtMultimediaKit::VeryHighQuality);
}
/* Test QVideoEncoderSettings encodingMode */
void tst_QMediaRecorder::testVideoSettingsEncodingMode()
{
/* Create the instance*/
QVideoEncoderSettings settings;
QVERIFY(settings.isNull());
QVERIFY(settings == QVideoEncoderSettings());
/* Verify the default values are initialised correctly*/
QCOMPARE(settings.encodingMode(), QtMultimediaKit::ConstantQualityEncoding);
QVERIFY(settings.isNull());
/* Set each type of encoding mode and Verify if it is set correctly*/
settings.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
QCOMPARE(settings.encodingMode(),QtMultimediaKit::ConstantBitRateEncoding);
QVERIFY(!settings.isNull());
settings.setEncodingMode(QtMultimediaKit::AverageBitRateEncoding);
QCOMPARE(settings.encodingMode(), QtMultimediaKit::AverageBitRateEncoding);
settings.setEncodingMode(QtMultimediaKit::TwoPassEncoding);
QCOMPARE(settings.encodingMode(), QtMultimediaKit::TwoPassEncoding);
}
/* Test QVideoEncoderSettings copy constructor */
void tst_QMediaRecorder::testVideoSettingsCopyConstructor()
{
/* Create the instance and initialise it*/
QVideoEncoderSettings settings1;
settings1.setCodec(QLatin1String("codecName"));
settings1.setBitRate(128000);
settings1.setQuality(QtMultimediaKit::HighQuality);
settings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
settings1.setFrameRate(30000.0/10001);
settings1.setResolution(QSize(320,240));
/* Create another instance with instance1 as argument*/
QVideoEncoderSettings settings2(settings1);
/* Verify if all the parameters are copied correctly*/
QCOMPARE(settings2 != settings1, false);
QCOMPARE(settings2.codec(), QLatin1String("codecName"));
QCOMPARE(settings2.bitRate(), 128000);
QCOMPARE(settings2.encodingMode(), QtMultimediaKit::ConstantBitRateEncoding);
QVERIFY(qFuzzyCompare(settings2.frameRate(), qreal(30000.0/10001)));
QCOMPARE(settings2.resolution(), QSize(320,240));
QCOMPARE(settings2.quality(), QtMultimediaKit::HighQuality);
/* Verify both the instances are equal*/
QCOMPARE(settings2, settings1);
QVERIFY(!settings2.isNull());
}
/* Test QVideoEncoderSettings Overloaded Operator assignment*/
void tst_QMediaRecorder::testVideoSettingsOperatorAssignment()
{
/* Create two instances.*/
QVideoEncoderSettings settings1;
QVideoEncoderSettings settings2;
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
/* Initialize all the parameters */
settings1.setCodec(QLatin1String("codecName"));
settings1.setBitRate(128000);
settings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
settings1.setFrameRate(30000.0/10001);
settings1.setResolution(QSize(320,240));
settings1.setQuality(QtMultimediaKit::HighQuality);
/* Assign one object to other*/
settings2 = settings1;
/* Verify all the parameters are copied correctly*/
QCOMPARE(settings2, settings1);
QCOMPARE(settings2.codec(), QLatin1String("codecName"));
QCOMPARE(settings2.bitRate(), 128000);
QCOMPARE(settings2.encodingMode(), QtMultimediaKit::ConstantBitRateEncoding);
QVERIFY(qFuzzyCompare(settings2.frameRate(), qreal(30000.0/10001)));
QCOMPARE(settings2.resolution(), QSize(320,240));
QCOMPARE(settings2.quality(), QtMultimediaKit::HighQuality);
QCOMPARE(settings2, settings1);
QVERIFY(!settings2.isNull());
}
/* Test QVideoEncoderSettings Overloaded OperatorNotEqual*/
void tst_QMediaRecorder::testVideoSettingsOperatorNotEqual()
{
/* Create the instance and set the bit rate and Verify objects with OperatorNotEqual*/
QVideoEncoderSettings settings1;
settings1.setBitRate(1);
QVideoEncoderSettings settings2;
settings2.setBitRate(1);
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setBitRate(2);
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
/* Verify Resolution with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setResolution(800,600);
settings2 = QVideoEncoderSettings();
settings2.setResolution(QSize(800,600));
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setResolution(QSize(400,300));
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
/* Verify Codec with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setCodec("codec1");
settings2 = QVideoEncoderSettings();
settings2.setCodec("codec1");
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setCodec("codec2");
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
/* Verify EncodingMode with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
settings2.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setEncodingMode(QtMultimediaKit::TwoPassEncoding);
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
/* Verify Quality with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setQuality(QtMultimediaKit::NormalQuality);
settings2 = QVideoEncoderSettings();
settings2.setQuality(QtMultimediaKit::NormalQuality);
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setQuality(QtMultimediaKit::LowQuality);
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
/* Verify FrameRate with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setFrameRate(1);
settings2 = QVideoEncoderSettings();
settings2.setFrameRate(1);
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setFrameRate(2);
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
}
/* Test QVideoEncoderSettings Overloaded comparison operator*/
void tst_QMediaRecorder::testVideoSettingsOperatorComparison()
{
/* Create the instance and set the bit rate and Verify objects with comparison operator*/
QVideoEncoderSettings settings1;
settings1.setBitRate(1);
QVideoEncoderSettings settings2;
settings2.setBitRate(1);
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setBitRate(2);
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
/* Verify resolution with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setResolution(800,600);
settings2 = QVideoEncoderSettings();
settings2.setResolution(QSize(800,600));
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setResolution(QSize(400,300));
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
/* Verify Codec with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setCodec("codec1");
settings2 = QVideoEncoderSettings();
settings2.setCodec("codec1");
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setCodec("codec2");
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
/* Verify EncodingMode with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
settings2.setEncodingMode(QtMultimediaKit::ConstantBitRateEncoding);
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setEncodingMode(QtMultimediaKit::TwoPassEncoding);
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
/* Verify Quality with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setQuality(QtMultimediaKit::NormalQuality);
settings2 = QVideoEncoderSettings();
settings2.setQuality(QtMultimediaKit::NormalQuality);
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimediaKit::LowQuality);
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
/* Verify FrameRate with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setFrameRate(1);
settings2 = QVideoEncoderSettings();
settings2.setFrameRate(1);
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setFrameRate(2);
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
}
/* Test the destuctor of the QVideoEncoderSettings*/
void tst_QMediaRecorder::testVideoSettingsDestructor()
{
/* Create the instance on heap and verify if object deleted correctly*/
QVideoEncoderSettings *settings1 = new QVideoEncoderSettings();
QVERIFY(settings1 != NULL);
QVERIFY(settings1->isNull());
delete settings1;
/* Create the instance on heap and initialise it and verify if object deleted correctly.*/
QVideoEncoderSettings *settings2 = new QVideoEncoderSettings();
QVERIFY(settings2 != NULL);
settings2->setCodec(QString("codec"));
QVERIFY(!settings2->isNull());
delete settings2;
}
Reference in New Issue View Git Blame Copy Permalink