slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rename namespace QtMultimedia -> QMultimedia

Browse Source 
Main code, examples, tests and docs updated. Method:
1. Mass find+replace "QtMultimedia::" -> "QMultimedia::"
2. Hand-modified declaration in qtmedianamespace.h/cpp

For consistency (with minimal disruption), namespaces with a "Qt" prefix
will be renamed.

Part of the Header Consistency Project
(http://lists.qt-project.org/pipermail/development/2012-October/007570.html)

Change-Id: I1fbc43a1aa91d996aa61869fcd8d05186bf7cf6d
Reviewed-by: Lars Knoll <lars.knoll@digia.com>
Reviewed-by: Stephen Kelly <stephen.kelly@kdab.com>
This commit is contained in:
Sze Howe Koh
2012-11-01 00:33:21 +08:00
committed by The Qt Project
parent 13fd00199a
commit 832c3929f2
78 changed files with 381 additions and 384 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tests/auto/unit/qaudiodecoder/tst_qaudiodecoder.cpp
View File

@@ -348,7 +348,7 @@ void tst_QAudioDecoder::nullControl()
QVERIFY(d.error() == QAudioDecoder::ServiceMissingError);
QVERIFY(!d.errorString().isEmpty());
QVERIFY(d.hasSupport("MIME") == QtMultimedia::MaybeSupported);
QVERIFY(d.hasSupport("MIME") == QMultimedia::MaybeSupported);
QVERIFY(d.state() == QAudioDecoder::StoppedState);
@@ -389,7 +389,7 @@ void tst_QAudioDecoder::nullService()
QVERIFY(d.error() == QAudioDecoder::ServiceMissingError);
QVERIFY(!d.errorString().isEmpty());
QVERIFY(d.hasSupport("MIME") == QtMultimedia::MaybeSupported);
QVERIFY(d.hasSupport("MIME") == QMultimedia::MaybeSupported);
QVERIFY(d.state() == QAudioDecoder::StoppedState);

4
tests/auto/unit/qaudioprobe/tst_qaudioprobe.cpp
View File

@@ -104,7 +104,7 @@ void tst_QAudioProbe::testNullService()
recorder = new QAudioRecorder;
QVERIFY(!recorder->isAvailable());
QCOMPARE(recorder->availability(), QtMultimedia::ServiceMissing);
QCOMPARE(recorder->availability(), QMultimedia::ServiceMissing);
QAudioProbe probe;
QVERIFY(!probe.isActive());
@@ -122,7 +122,7 @@ void tst_QAudioProbe::testNullControl()
recorder = new QAudioRecorder;
QVERIFY(!recorder->isAvailable());
QCOMPARE(recorder->availability(), QtMultimedia::ServiceMissing);
QCOMPARE(recorder->availability(), QMultimedia::ServiceMissing);
QAudioProbe probe;
QVERIFY(!probe.isActive());

6
tests/auto/unit/qaudiorecorder/tst_qaudiorecorder.cpp
View File

@@ -106,7 +106,7 @@ void tst_QAudioRecorder::testNullService()
QAudioRecorder source;
QVERIFY(!source.isAvailable());
QCOMPARE(source.availability(), QtMultimedia::ServiceMissing);
QCOMPARE(source.availability(), QMultimedia::ServiceMissing);
QCOMPARE(source.audioInputs().size(), 0);
QCOMPARE(source.defaultAudioInput(), QString());
@@ -120,7 +120,7 @@ void tst_QAudioRecorder::testNullControl()
QAudioRecorder source;
QVERIFY(!source.isAvailable());
QCOMPARE(source.availability(), QtMultimedia::ServiceMissing);
QCOMPARE(source.availability(), QMultimedia::ServiceMissing);
QCOMPARE(source.audioInputs().size(), 0);
QCOMPARE(source.defaultAudioInput(), QString());
@@ -163,7 +163,7 @@ void tst_QAudioRecorder::testAvailability()
QAudioRecorder source;
QVERIFY(source.isAvailable());
QCOMPARE(source.availability(), QtMultimedia::Available);
QCOMPARE(source.availability(), QMultimedia::Available);
}
void tst_QAudioRecorder::testAvailableAudioInputChangedSignal()

22
tests/auto/unit/qcamera/tst_qcamera.cpp
View File

@@ -778,9 +778,9 @@ void tst_QCamera::testImageSettings()
QVERIFY(settings != QImageEncoderSettings());
settings = QImageEncoderSettings();
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
settings.setQuality(QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
settings.setQuality(QMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings = QImageEncoderSettings();
@@ -808,7 +808,7 @@ void tst_QCamera::testImageSettings()
settings = QImageEncoderSettings();
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
QCOMPARE(settings.resolution(), QSize());
QVERIFY(settings.encodingOptions().isEmpty());
@@ -821,7 +821,7 @@ void tst_QCamera::testImageSettings()
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -837,7 +837,7 @@ void tst_QCamera::testImageSettings()
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -864,11 +864,11 @@ void tst_QCamera::testImageSettings()
QVERIFY(settings1 != settings2);
settings1 = QImageEncoderSettings();
settings1.setQuality(QtMultimedia::NormalQuality);
settings1.setQuality(QMultimedia::NormalQuality);
settings2 = QImageEncoderSettings();
settings2.setQuality(QtMultimedia::NormalQuality);
settings2.setQuality(QMultimedia::NormalQuality);
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimedia::LowQuality);
settings2.setQuality(QMultimedia::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QImageEncoderSettings();
@@ -1233,7 +1233,7 @@ void tst_QCamera::testQCameraIsAvailable()
{
QCamera camera;
QVERIFY(camera.isAvailable());
QVERIFY(camera.availability() == QtMultimedia::Available);
QVERIFY(camera.availability() == QMultimedia::Available);
}
void tst_QCamera::testQCameraIsNotAvailable()
@@ -1243,7 +1243,7 @@ void tst_QCamera::testQCameraIsNotAvailable()
QCOMPARE(camera.error(), QCamera::ServiceMissingError);
QVERIFY(!camera.isAvailable());
QCOMPARE(camera.availability(), QtMultimedia::ServiceMissing);
QCOMPARE(camera.availability(), QMultimedia::ServiceMissing);
}
/* Test case for searchAndLock ( QCamera::LockTypes locks ) */

10
tests/auto/unit/qcameraimagecapture/tst_qcameraimagecapture.cpp
View File

@@ -260,11 +260,11 @@ void tst_QCameraImageCapture::encodingSettings()
QVERIFY(imageCapture.encodingSettings() == QImageEncoderSettings());
QImageEncoderSettings settings;
settings.setCodec("JPEG");
settings.setQuality(QtMultimedia::NormalQuality);
settings.setQuality(QMultimedia::NormalQuality);
imageCapture.setEncodingSettings(settings);
QVERIFY(!imageCapture.encodingSettings().isNull());
QVERIFY(imageCapture.encodingSettings().codec() == "JPEG");
QVERIFY(imageCapture.encodingSettings().quality() == QtMultimedia::NormalQuality);
QVERIFY(imageCapture.encodingSettings().quality() == QMultimedia::NormalQuality);
}
//MaemoAPI-1838:test supportedImageCodecs
@@ -312,7 +312,7 @@ void tst_QCameraImageCapture::errors()
imageCapture1.capture(QString::fromLatin1("/dev/null"));
QVERIFY(imageCapture1.error() == QCameraImageCapture::NotSupportedFeatureError);
QVERIFY2(!imageCapture1.errorString().isEmpty(), "Device does not support images capture");
QVERIFY(imageCapture1.availability() == QtMultimedia::ServiceMissing);
QVERIFY(imageCapture1.availability() == QMultimedia::ServiceMissing);
provider->service = mockcameraservice;
@@ -321,12 +321,12 @@ void tst_QCameraImageCapture::errors()
QVERIFY(imageCapture.isAvailable() == true);
QVERIFY(imageCapture.error() == QCameraImageCapture::NoError);
QVERIFY(imageCapture.errorString().isEmpty());
QVERIFY(imageCapture.availability() == QtMultimedia::Available);
QVERIFY(imageCapture.availability() == QMultimedia::Available);
imageCapture.capture();
QVERIFY(imageCapture.error() == QCameraImageCapture::NotReadyError);
QVERIFY2(!imageCapture.errorString().isEmpty(), "Could not capture in stopped state");
QVERIFY(imageCapture.availability() == QtMultimedia::Available);
QVERIFY(imageCapture.availability() == QMultimedia::Available);
}
//MaemoAPI-1831:test error

28
tests/auto/unit/qmediaobject/tst_qmediaobject.cpp
View File

@@ -441,52 +441,52 @@ void tst_QMediaObject::availability()
{
QtTestMediaObject nullObject(0);
QCOMPARE(nullObject.isAvailable(), false);
QCOMPARE(nullObject.availability(), QtMultimedia::ServiceMissing);
QCOMPARE(nullObject.availability(), QMultimedia::ServiceMissing);
}
{
QtTestMediaObjectService service;
QtTestMediaObject object(&service);
QCOMPARE(object.isAvailable(), true);
QCOMPARE(object.availability(), QtMultimedia::Available);
QCOMPARE(object.availability(), QMultimedia::Available);
}
{
MockAvailabilityControl available(QtMultimedia::Available);
MockAvailabilityControl available(QMultimedia::Available);
QtTestMediaObjectService service(0, &available);
QtTestMediaObject object(&service);
QSignalSpy availabilitySpy(&object, SIGNAL(availabilityChanged(bool)));
QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)));
QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
QCOMPARE(object.isAvailable(), true);
QCOMPARE(object.availability(), QtMultimedia::Available);
QCOMPARE(object.availability(), QMultimedia::Available);
available.setAvailability(QtMultimedia::Busy);
available.setAvailability(QMultimedia::Busy);
QCOMPARE(object.isAvailable(), false);
QCOMPARE(object.availability(), QtMultimedia::Busy);
QCOMPARE(object.availability(), QMultimedia::Busy);
QCOMPARE(availabilitySpy.count(), 1);
QCOMPARE(availabilityStatusSpy.count(), 1);
available.setAvailability(QtMultimedia::Available);
available.setAvailability(QMultimedia::Available);
QCOMPARE(object.isAvailable(), true);
QCOMPARE(object.availability(), QtMultimedia::Available);
QCOMPARE(object.availability(), QMultimedia::Available);
QCOMPARE(availabilitySpy.count(), 2);
QCOMPARE(availabilityStatusSpy.count(), 2);
}
{
MockAvailabilityControl available(QtMultimedia::Busy);
MockAvailabilityControl available(QMultimedia::Busy);
QtTestMediaObjectService service(0, &available);
QtTestMediaObject object(&service);
QSignalSpy availabilitySpy(&object, SIGNAL(availabilityChanged(bool)));
QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)));
QSignalSpy availabilityStatusSpy(&object, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
QCOMPARE(object.isAvailable(), false);
QCOMPARE(object.availability(), QtMultimedia::Busy);
QCOMPARE(object.availability(), QMultimedia::Busy);
available.setAvailability(QtMultimedia::Available);
available.setAvailability(QMultimedia::Available);
QCOMPARE(object.isAvailable(), true);
QCOMPARE(object.availability(), QtMultimedia::Available);
QCOMPARE(object.availability(), QMultimedia::Available);
QCOMPARE(availabilitySpy.count(), 1);
QCOMPARE(availabilityStatusSpy.count(), 1);
}

4
tests/auto/unit/qmediaplayer/tst_qmediaplayer.cpp
View File

@@ -222,7 +222,7 @@ void tst_QMediaPlayer::testNullService()
QCOMPARE(player.playbackRate(), qreal(0));
QCOMPARE(player.error(), QMediaPlayer::ServiceMissingError);
QCOMPARE(player.isAvailable(), false);
QCOMPARE(player.availability(), QtMultimedia::ServiceMissing);
QCOMPARE(player.availability(), QMultimedia::ServiceMissing);
{
QFETCH_GLOBAL(QMediaContent, mediaContent);
@@ -501,7 +501,7 @@ void tst_QMediaPlayer::testErrorString()
void tst_QMediaPlayer::testIsAvailable()
{
QCOMPARE(player->isAvailable(), true);
QCOMPARE(player->availability(), QtMultimedia::Available);
QCOMPARE(player->availability(), QMultimedia::Available);
}
void tst_QMediaPlayer::testService()

188
tests/auto/unit/qmediarecorder/tst_qmediarecorder.cpp
View File

@@ -215,7 +215,7 @@ void tst_QMediaRecorder::testNullControls()
QAudioEncoderSettings audio;
audio.setCodec(id);
audio.setQuality(QtMultimedia::LowQuality);
audio.setQuality(QMultimedia::LowQuality);
QVideoEncoderSettings video;
video.setCodec(id);
@@ -447,18 +447,18 @@ void tst_QMediaRecorder::testEncodingSettings()
QCOMPARE(audioSettings.codec(), QString("audio/pcm"));
QCOMPARE(audioSettings.bitRate(), 128*1024);
QCOMPARE(audioSettings.sampleRate(), 8000);
QCOMPARE(audioSettings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(audioSettings.quality(), QMultimedia::NormalQuality);
QCOMPARE(audioSettings.channelCount(), -1);
QCOMPARE(audioSettings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
QCOMPARE(audioSettings.encodingMode(), QMultimedia::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(), QtMultimedia::NormalQuality);
QCOMPARE(videoSettings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
QCOMPARE(videoSettings.quality(), QMultimedia::NormalQuality);
QCOMPARE(videoSettings.encodingMode(), QMultimedia::ConstantQualityEncoding);
QString format = capture->containerFormat();
QCOMPARE(format, QString());
@@ -466,15 +466,15 @@ void tst_QMediaRecorder::testEncodingSettings()
audioSettings.setCodec("audio/mpeg");
audioSettings.setSampleRate(44100);
audioSettings.setBitRate(256*1024);
audioSettings.setQuality(QtMultimedia::HighQuality);
audioSettings.setEncodingMode(QtMultimedia::AverageBitRateEncoding);
audioSettings.setQuality(QMultimedia::HighQuality);
audioSettings.setEncodingMode(QMultimedia::AverageBitRateEncoding);
videoSettings.setCodec("video/3gpp");
videoSettings.setBitRate(800);
videoSettings.setFrameRate(24*1024);
videoSettings.setResolution(QSize(800,600));
videoSettings.setQuality(QtMultimedia::HighQuality);
audioSettings.setEncodingMode(QtMultimedia::TwoPassEncoding);
videoSettings.setQuality(QMultimedia::HighQuality);
audioSettings.setEncodingMode(QMultimedia::TwoPassEncoding);
format = QString("mov");
@@ -506,9 +506,9 @@ void tst_QMediaRecorder::testAudioSettings()
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
settings.setQuality(QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
settings.setQuality(QMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
@@ -541,7 +541,7 @@ void tst_QMediaRecorder::testAudioSettings()
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.bitRate(), -1);
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
QCOMPARE(settings.sampleRate(), -1);
QVERIFY(settings.encodingOptions().isEmpty());
@@ -554,7 +554,7 @@ void tst_QMediaRecorder::testAudioSettings()
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -570,7 +570,7 @@ void tst_QMediaRecorder::testAudioSettings()
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -602,19 +602,19 @@ void tst_QMediaRecorder::testAudioSettings()
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
settings2 = QAudioEncoderSettings();
settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
QVERIFY(settings1 == settings2);
settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
settings1.setQuality(QtMultimedia::NormalQuality);
settings1.setQuality(QMultimedia::NormalQuality);
settings2 = QAudioEncoderSettings();
settings2.setQuality(QtMultimedia::NormalQuality);
settings2.setQuality(QMultimedia::NormalQuality);
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimedia::LowQuality);
settings2.setQuality(QMultimedia::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
@@ -653,9 +653,9 @@ void tst_QMediaRecorder::testVideoSettings()
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
settings.setQuality(QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
settings.setQuality(QMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
@@ -692,7 +692,7 @@ void tst_QMediaRecorder::testVideoSettings()
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.bitRate(), -1);
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
QCOMPARE(settings.frameRate(), qreal());
QCOMPARE(settings.resolution(), QSize());
QVERIFY(settings.encodingOptions().isEmpty());
@@ -706,7 +706,7 @@ void tst_QMediaRecorder::testVideoSettings()
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -722,7 +722,7 @@ void tst_QMediaRecorder::testVideoSettings()
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -754,19 +754,19 @@ void tst_QMediaRecorder::testVideoSettings()
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
QVERIFY(settings1 == settings2);
settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
settings1.setQuality(QtMultimedia::NormalQuality);
settings1.setQuality(QMultimedia::NormalQuality);
settings2 = QVideoEncoderSettings();
settings2.setQuality(QtMultimedia::NormalQuality);
settings2.setQuality(QMultimedia::NormalQuality);
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimedia::LowQuality);
settings2.setQuality(QMultimedia::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
@@ -803,7 +803,7 @@ void tst_QMediaRecorder::testSettingsApplied()
recorder.setVideoSettings(videoSettings);
QAudioEncoderSettings audioSettings;
audioSettings.setQuality(QtMultimedia::HighQuality);
audioSettings.setQuality(QMultimedia::HighQuality);
recorder.setAudioSettings(audioSettings);
recorder.setContainerFormat("mkv");
@@ -812,7 +812,7 @@ void tst_QMediaRecorder::testSettingsApplied()
QTRY_COMPARE(recorderControl.m_settingAppliedCount, 2);
//encoder settings are applied before recording if changed
audioSettings.setQuality(QtMultimedia::VeryHighQuality);
audioSettings.setQuality(QMultimedia::VeryHighQuality);
recorder.setAudioSettings(audioSettings);
QCOMPARE(recorderControl.m_settingAppliedCount, 2);
@@ -1010,8 +1010,8 @@ void tst_QMediaRecorder::testAudioSettingsCopyConstructor()
audiosettings.setBitRate(128*1000);
audiosettings.setChannelCount(4);
audiosettings.setCodec("audio/pcm");
audiosettings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
audiosettings.setQuality(QtMultimedia::LowQuality);
audiosettings.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
audiosettings.setQuality(QMultimedia::LowQuality);
audiosettings.setSampleRate(44100);
/* Copy constructor */
@@ -1040,16 +1040,16 @@ void tst_QMediaRecorder::testAudioSettingsOperatorNotEqual()
audiosettings1.setBitRate(128*1000);
audiosettings1.setChannelCount(4);
audiosettings1.setCodec("audio/pcm");
audiosettings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
audiosettings1.setQuality(QtMultimedia::LowQuality);
audiosettings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
audiosettings1.setQuality(QMultimedia::LowQuality);
audiosettings1.setSampleRate(44100);
/* setting the desired properties for the AudioEncoder */
audiosettings2.setBitRate(128*1000);
audiosettings2.setChannelCount(4);
audiosettings2.setCodec("audio/pcm");
audiosettings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
audiosettings2.setQuality(QtMultimedia::LowQuality);
audiosettings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
audiosettings2.setQuality(QMultimedia::LowQuality);
audiosettings2.setSampleRate(44100);
/* verify the both are equal or not */
@@ -1057,7 +1057,7 @@ void tst_QMediaRecorder::testAudioSettingsOperatorNotEqual()
/* Modify the settings value for one object */
audiosettings2.setBitRate(64*1000);
audiosettings2.setEncodingMode(QtMultimedia::ConstantQualityEncoding);
audiosettings2.setEncodingMode(QMultimedia::ConstantQualityEncoding);
/* verify the not equal opertor */
QVERIFY(audiosettings1 != audiosettings2);
@@ -1076,8 +1076,8 @@ void tst_QMediaRecorder::testAudioSettingsOperatorEqual()
audiosettings1.setBitRate(128*1000);
audiosettings1.setChannelCount(4);
audiosettings1.setCodec("audio/pcm");
audiosettings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
audiosettings1.setQuality(QtMultimedia::LowQuality);
audiosettings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
audiosettings1.setQuality(QMultimedia::LowQuality);
audiosettings1.setSampleRate(44100);
QAudioEncoderSettings audiosettings2;
@@ -1087,8 +1087,8 @@ void tst_QMediaRecorder::testAudioSettingsOperatorEqual()
audiosettings2.setBitRate(128*1000);
audiosettings2.setChannelCount(4);
audiosettings2.setCodec("audio/pcm");
audiosettings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
audiosettings2.setQuality(QtMultimedia::LowQuality);
audiosettings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
audiosettings2.setQuality(QMultimedia::LowQuality);
audiosettings2.setSampleRate(44100);
/* verify both the values are same or not */
@@ -1108,8 +1108,8 @@ void tst_QMediaRecorder::testAudioSettingsOperatorAssign()
audiosettings1.setBitRate(128*1000);
audiosettings1.setChannelCount(4);
audiosettings1.setCodec("audio/pcm");
audiosettings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
audiosettings1.setQuality(QtMultimedia::LowQuality);
audiosettings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
audiosettings1.setQuality(QMultimedia::LowQuality);
audiosettings1.setSampleRate(44100);
QAudioEncoderSettings audiosettings2;
@@ -1141,7 +1141,7 @@ void tst_QMediaRecorder::testAvailabilityStatus()
MockMediaRecorderService service(0, 0);
MockMediaObject object(0, &service);
QMediaRecorder recorder(&object);
QCOMPARE(recorder.availability(), QtMultimedia::ServiceMissing);
QCOMPARE(recorder.availability(), QMultimedia::ServiceMissing);
QCOMPARE(recorder.isAvailable(), false);
}
{
@@ -1150,7 +1150,7 @@ void tst_QMediaRecorder::testAvailabilityStatus()
service1.mockMetaDataControl->populateMetaData();
MockMediaObject object1(0, &service1);
QMediaRecorder recorder1(&object1);
QCOMPARE(recorder1.availability(), QtMultimedia::Available);
QCOMPARE(recorder1.availability(), QMultimedia::Available);
QCOMPARE(recorder1.isAvailable(), true);
}
{
@@ -1160,29 +1160,29 @@ void tst_QMediaRecorder::testAvailabilityStatus()
MockMediaObject object1(0, &service1);
QMediaRecorder recorder1(&object1);
QCOMPARE(recorder1.availability(), QtMultimedia::Available);
QCOMPARE(recorder1.availability(), QMultimedia::Available);
QCOMPARE(recorder1.isAvailable(), true);
}
{
MockMediaRecorderControl recorderControl(0);
MockAvailabilityControl availability(QtMultimedia::Available);
MockAvailabilityControl availability(QMultimedia::Available);
MockMediaRecorderService service1(0, &recorderControl, &availability);
service1.mockMetaDataControl->populateMetaData();
MockMediaObject object1(0, &service1);
QMediaRecorder recorder1(&object1);
QSignalSpy spy(&object1, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityStatus)));
QSignalSpy spy(&object1, SIGNAL(availabilityChanged(QMultimedia::AvailabilityStatus)));
QCOMPARE(recorder1.availability(), QtMultimedia::Available);
QCOMPARE(recorder1.availability(), QMultimedia::Available);
QCOMPARE(recorder1.isAvailable(), true);
availability.setAvailability(QtMultimedia::Busy);
QCOMPARE(recorder1.availability(), QtMultimedia::Busy);
availability.setAvailability(QMultimedia::Busy);
QCOMPARE(recorder1.availability(), QMultimedia::Busy);
QCOMPARE(recorder1.isAvailable(), false);
QCOMPARE(spy.count(), 1);
availability.setAvailability(QtMultimedia::Available);
QCOMPARE(recorder1.availability(), QtMultimedia::Available);
availability.setAvailability(QMultimedia::Available);
QCOMPARE(recorder1.availability(), QMultimedia::Available);
QCOMPARE(recorder1.isAvailable(), true);
QCOMPARE(spy.count(), 2);
}
@@ -1246,21 +1246,21 @@ void tst_QMediaRecorder::testVideoSettingsQuality()
QVERIFY(settings == QVideoEncoderSettings());
/* Verify the default value is intialised correctly*/
QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(settings.quality(), QMultimedia::NormalQuality);
/* Set all types of Quality parameter and Verify if it is set correctly*/
settings.setQuality(QtMultimedia::HighQuality);
QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
settings.setQuality(QMultimedia::HighQuality);
QCOMPARE(settings.quality(), QMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings.setQuality(QtMultimedia::VeryLowQuality);
QCOMPARE(settings.quality(), QtMultimedia::VeryLowQuality);
settings.setQuality(QMultimedia::VeryLowQuality);
QCOMPARE(settings.quality(), QMultimedia::VeryLowQuality);
settings.setQuality(QtMultimedia::LowQuality);
QCOMPARE(settings.quality(), QtMultimedia::LowQuality);
settings.setQuality(QMultimedia::LowQuality);
QCOMPARE(settings.quality(), QMultimedia::LowQuality);
settings.setQuality(QtMultimedia::VeryHighQuality);
QCOMPARE(settings.quality(), QtMultimedia::VeryHighQuality);
settings.setQuality(QMultimedia::VeryHighQuality);
QCOMPARE(settings.quality(), QMultimedia::VeryHighQuality);
}
/* Test QVideoEncoderSettings encodingMode */
@@ -1272,19 +1272,19 @@ void tst_QMediaRecorder::testVideoSettingsEncodingMode()
QVERIFY(settings == QVideoEncoderSettings());
/* Verify the default values are initialised correctly*/
QCOMPARE(settings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
QCOMPARE(settings.encodingMode(), QMultimedia::ConstantQualityEncoding);
QVERIFY(settings.isNull());
/* Set each type of encoding mode and Verify if it is set correctly*/
settings.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
QCOMPARE(settings.encodingMode(),QtMultimedia::ConstantBitRateEncoding);
settings.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
QCOMPARE(settings.encodingMode(),QMultimedia::ConstantBitRateEncoding);
QVERIFY(!settings.isNull());
settings.setEncodingMode(QtMultimedia::AverageBitRateEncoding);
QCOMPARE(settings.encodingMode(), QtMultimedia::AverageBitRateEncoding);
settings.setEncodingMode(QMultimedia::AverageBitRateEncoding);
QCOMPARE(settings.encodingMode(), QMultimedia::AverageBitRateEncoding);
settings.setEncodingMode(QtMultimedia::TwoPassEncoding);
QCOMPARE(settings.encodingMode(), QtMultimedia::TwoPassEncoding);
settings.setEncodingMode(QMultimedia::TwoPassEncoding);
QCOMPARE(settings.encodingMode(), QMultimedia::TwoPassEncoding);
}
/* Test QVideoEncoderSettings copy constructor */
@@ -1294,8 +1294,8 @@ void tst_QMediaRecorder::testVideoSettingsCopyConstructor()
QVideoEncoderSettings settings1;
settings1.setCodec(QLatin1String("codecName"));
settings1.setBitRate(128000);
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings1.setQuality(QMultimedia::HighQuality);
settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
settings1.setFrameRate(30000.0/10001);
settings1.setResolution(QSize(320,240));
@@ -1306,10 +1306,10 @@ void tst_QMediaRecorder::testVideoSettingsCopyConstructor()
QCOMPARE(settings2 != settings1, false);
QCOMPARE(settings2.codec(), QLatin1String("codecName"));
QCOMPARE(settings2.bitRate(), 128000);
QCOMPARE(settings2.encodingMode(), QtMultimedia::ConstantBitRateEncoding);
QCOMPARE(settings2.encodingMode(), QMultimedia::ConstantBitRateEncoding);
QVERIFY(qFuzzyCompare(settings2.frameRate(), qreal(30000.0/10001)));
QCOMPARE(settings2.resolution(), QSize(320,240));
QCOMPARE(settings2.quality(), QtMultimedia::HighQuality);
QCOMPARE(settings2.quality(), QMultimedia::HighQuality);
/* Verify both the instances are equal*/
QCOMPARE(settings2, settings1);
@@ -1328,10 +1328,10 @@ void tst_QMediaRecorder::testVideoSettingsOperatorAssignment()
/* Initialize all the parameters */
settings1.setCodec(QLatin1String("codecName"));
settings1.setBitRate(128000);
settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
settings1.setFrameRate(30000.0/10001);
settings1.setResolution(QSize(320,240));
settings1.setQuality(QtMultimedia::HighQuality);
settings1.setQuality(QMultimedia::HighQuality);
/* Assign one object to other*/
settings2 = settings1;
@@ -1339,10 +1339,10 @@ void tst_QMediaRecorder::testVideoSettingsOperatorAssignment()
QCOMPARE(settings2, settings1);
QCOMPARE(settings2.codec(), QLatin1String("codecName"));
QCOMPARE(settings2.bitRate(), 128000);
QCOMPARE(settings2.encodingMode(), QtMultimedia::ConstantBitRateEncoding);
QCOMPARE(settings2.encodingMode(), QMultimedia::ConstantBitRateEncoding);
QVERIFY(qFuzzyCompare(settings2.frameRate(), qreal(30000.0/10001)));
QCOMPARE(settings2.resolution(), QSize(320,240));
QCOMPARE(settings2.quality(), QtMultimedia::HighQuality);
QCOMPARE(settings2.quality(), QMultimedia::HighQuality);
QCOMPARE(settings2, settings1);
QVERIFY(!settings2.isNull());
}
@@ -1385,23 +1385,23 @@ void tst_QMediaRecorder::testVideoSettingsOperatorNotEqual()
/* Verify EncodingMode with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
/* Verify Quality with not equal operator*/
settings1 = QVideoEncoderSettings();
settings1.setQuality(QtMultimedia::NormalQuality);
settings1.setQuality(QMultimedia::NormalQuality);
settings2 = QVideoEncoderSettings();
settings2.setQuality(QtMultimedia::NormalQuality);
settings2.setQuality(QMultimedia::NormalQuality);
/* OperatorNotEqual returns false when both objects are equal*/
QCOMPARE(settings1 != settings2, false);
settings2.setQuality(QtMultimedia::LowQuality);
settings2.setQuality(QMultimedia::LowQuality);
/* OperatorNotEqual returns true when both objects are not equal*/
QVERIFY(settings1 != settings2);
@@ -1456,23 +1456,23 @@ void tst_QMediaRecorder::testVideoSettingsOperatorComparison()
/* Verify EncodingMode with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings1.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings2.setEncodingMode(QMultimedia::ConstantBitRateEncoding);
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
settings2.setEncodingMode(QMultimedia::TwoPassEncoding);
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);
/* Verify Quality with comparison operator*/
settings1 = QVideoEncoderSettings();
settings1.setQuality(QtMultimedia::NormalQuality);
settings1.setQuality(QMultimedia::NormalQuality);
settings2 = QVideoEncoderSettings();
settings2.setQuality(QtMultimedia::NormalQuality);
settings2.setQuality(QMultimedia::NormalQuality);
/* Comparison operator returns true when both objects are equal*/
QVERIFY(settings1 == settings2);
settings2.setQuality(QtMultimedia::LowQuality);
settings2.setQuality(QMultimedia::LowQuality);
/* Comparison operator returns false when both objects are not equal*/
QCOMPARE(settings1 == settings2, false);

8
tests/auto/unit/qmediaserviceprovider/mockserviceplugin1/mockserviceplugin1.cpp
View File

@@ -71,16 +71,16 @@ public:
delete service;
}
QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
{
if (codecs.contains(QLatin1String("mpeg4")))
return QtMultimedia::NotSupported;
return QMultimedia::NotSupported;
if (mimeType == "audio/ogg") {
return QtMultimedia::ProbablySupported;
return QMultimedia::ProbablySupported;
}
return QtMultimedia::MaybeSupported;
return QMultimedia::MaybeSupported;
}
QStringList supportedMimeTypes() const

6
tests/auto/unit/qmediaserviceprovider/mockserviceplugin2/mockserviceplugin2.cpp
View File

@@ -71,14 +71,14 @@ public:
delete service;
}
QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
{
Q_UNUSED(codecs);
if (mimeType == "audio/wav")
return QtMultimedia::PreferredService;
return QMultimedia::PreferredService;
return QtMultimedia::NotSupported;
return QMultimedia::NotSupported;
}
QStringList supportedMimeTypes() const

8
tests/auto/unit/qmediaserviceprovider/mockserviceplugin4/mockserviceplugin4.cpp
View File

@@ -70,15 +70,15 @@ public:
delete service;
}
QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
QMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
{
if (codecs.contains(QLatin1String("jpeg2000")))
return QtMultimedia::NotSupported;
return QMultimedia::NotSupported;
if (supportedMimeTypes().contains(mimeType))
return QtMultimedia::ProbablySupported;
return QMultimedia::ProbablySupported;
return QtMultimedia::MaybeSupported;
return QMultimedia::MaybeSupported;
}
QStringList supportedMimeTypes() const

28
tests/auto/unit/qmediaserviceprovider/tst_qmediaserviceprovider.cpp
View File

@@ -119,7 +119,7 @@ void tst_QMediaServiceProvider::testHasSupport()
{
MockMediaServiceProvider mockProvider;
QCOMPARE(mockProvider.hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "video/ogv", QStringList()),
QtMultimedia::MaybeSupported);
QMultimedia::MaybeSupported);
QMediaServiceProvider *provider = QMediaServiceProvider::defaultServiceProvider();
@@ -127,44 +127,44 @@ void tst_QMediaServiceProvider::testHasSupport()
QSKIP("No default provider");
QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "video/ogv", QStringList()),
QtMultimedia::MaybeSupported);
QMultimedia::MaybeSupported);
QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "audio/ogg", QStringList()),
QtMultimedia::ProbablySupported);
QMultimedia::ProbablySupported);
//while the service returns PreferredService, provider should return ProbablySupported
QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "audio/wav", QStringList()),
QtMultimedia::ProbablySupported);
QMultimedia::ProbablySupported);
//even while all the plugins with "hasSupport" returned NotSupported,
//MockServicePlugin3 has no "hasSupport" interface, so MaybeSupported
QCOMPARE(provider->hasSupport(QByteArray(Q_MEDIASERVICE_MEDIAPLAYER), "video/avi",
QStringList() << "mpeg4"),
QtMultimedia::MaybeSupported);
QMultimedia::MaybeSupported);
QCOMPARE(provider->hasSupport(QByteArray("non existing service"), "video/ogv", QStringList()),
QtMultimedia::NotSupported);
QMultimedia::NotSupported);
QCOMPARE(QMediaPlayer::hasSupport("video/ogv"), QtMultimedia::MaybeSupported);
QCOMPARE(QMediaPlayer::hasSupport("audio/ogg"), QtMultimedia::ProbablySupported);
QCOMPARE(QMediaPlayer::hasSupport("audio/wav"), QtMultimedia::ProbablySupported);
QCOMPARE(QMediaPlayer::hasSupport("video/ogv"), QMultimedia::MaybeSupported);
QCOMPARE(QMediaPlayer::hasSupport("audio/ogg"), QMultimedia::ProbablySupported);
QCOMPARE(QMediaPlayer::hasSupport("audio/wav"), QMultimedia::ProbablySupported);
//test low latency flag support
QCOMPARE(QMediaPlayer::hasSupport("audio/wav", QStringList(), QMediaPlayer::LowLatency),
QtMultimedia::ProbablySupported);
QMultimedia::ProbablySupported);
//plugin1 probably supports audio/ogg, it checked because it doesn't provide features iface
QCOMPARE(QMediaPlayer::hasSupport("audio/ogg", QStringList(), QMediaPlayer::LowLatency),
QtMultimedia::ProbablySupported);
QMultimedia::ProbablySupported);
//Plugin4 is not checked here, sine it's known not support low latency
QCOMPARE(QMediaPlayer::hasSupport("video/quicktime", QStringList(), QMediaPlayer::LowLatency),
QtMultimedia::MaybeSupported);
QMultimedia::MaybeSupported);
//test streaming flag support
QCOMPARE(QMediaPlayer::hasSupport("video/quicktime", QStringList(), QMediaPlayer::StreamPlayback),
QtMultimedia::ProbablySupported);
QMultimedia::ProbablySupported);
//Plugin2 is not checked here, sine it's known not support streaming
QCOMPARE(QMediaPlayer::hasSupport("audio/wav", QStringList(), QMediaPlayer::StreamPlayback),
QtMultimedia::MaybeSupported);
QMultimedia::MaybeSupported);
//ensure the correct media player plugin is chosen for mime type
QMediaPlayer simplePlayer(0, QMediaPlayer::LowLatency);

8
tests/auto/unit/qmultimedia_common/mockavailabilitycontrol.h
View File

@@ -50,18 +50,18 @@ class MockAvailabilityControl : public QMediaAvailabilityControl
Q_OBJECT
public:
MockAvailabilityControl(QtMultimedia::AvailabilityStatus available)
MockAvailabilityControl(QMultimedia::AvailabilityStatus available)
: m_availability(available)
{
}
QtMultimedia::AvailabilityStatus availability() const
QMultimedia::AvailabilityStatus availability() const
{
return m_availability;
}
void setAvailability(QtMultimedia::AvailabilityStatus availability)
void setAvailability(QMultimedia::AvailabilityStatus availability)
{
if (m_availability != availability) {
m_availability = availability;
@@ -69,7 +69,7 @@ public:
}
}
QtMultimedia::AvailabilityStatus m_availability;
QMultimedia::AvailabilityStatus m_availability;
};
#endif // MOCKAVAILABILITYCONTROL_H

4
tests/auto/unit/qmultimedia_common/mockimageencodercontrol.h
View File

@@ -65,12 +65,12 @@ public:
settings.resolution() == QSize(320,240))
resolutions << settings.resolution();
if (settings.quality() == QtMultimedia::HighQuality && settings.resolution() == QSize(640,480))
if (settings.quality() == QMultimedia::HighQuality && settings.resolution() == QSize(640,480))
resolutions << settings.resolution();
} else {
resolutions << QSize(160, 120);
resolutions << QSize(320, 240);
if (settings.quality() == QtMultimedia::HighQuality)
if (settings.quality() == QMultimedia::HighQuality)
resolutions << QSize(640, 480);
}

4
tests/auto/unit/qradiodata/tst_qradiodata.cpp
View File

@@ -89,7 +89,7 @@ void tst_QRadioData::initTestCase()
{
qRegisterMetaType<QRadioData::ProgramType>("QRadioData::ProgramType");
mockAvailability = new MockAvailabilityControl(QtMultimedia::Available);
mockAvailability = new MockAvailabilityControl(QMultimedia::Available);
mockTuner = new MockRadioTunerControl(this);
mockData = new MockRadioDataControl(this);
@@ -105,7 +105,7 @@ void tst_QRadioData::initTestCase()
radio = new QRadioTuner;
radioData = radio->radioData();
QVERIFY(radioData->availability() == QtMultimedia::Available);
QVERIFY(radioData->availability() == QMultimedia::Available);
}
void tst_QRadioData::cleanupTestCase()

8
tests/auto/unit/qradiotuner/tst_qradiotuner.cpp
View File

@@ -95,7 +95,7 @@ void tst_QRadioTuner::initTestCase()
qRegisterMetaType<QRadioTuner::Band>("QRadioTuner::Band");
mock = new MockRadioTunerControl(this);
mockAvailability = new MockAvailabilityControl(QtMultimedia::Available);
mockAvailability = new MockAvailabilityControl(QMultimedia::Available);
QMap<QString, QMediaControl *> map;
map.insert(QRadioTunerControl_iid, mock);
@@ -108,13 +108,13 @@ void tst_QRadioTuner::initTestCase()
radio = new QRadioTuner;
QVERIFY(radio->service() != 0);
QVERIFY(radio->isAvailable());
QVERIFY(radio->availability() == QtMultimedia::Available);
QVERIFY(radio->availability() == QMultimedia::Available);
QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
QCOMPARE(radio->state(), QRadioTuner::StoppedState);
radio->start();
QVERIFY(radio->availability() == QtMultimedia::Available);
QVERIFY(radio->availability() == QMultimedia::Available);
QCOMPARE(radio->state(), QRadioTuner::ActiveState);
QCOMPARE(stateSpy.count(), 1);
@@ -129,7 +129,7 @@ void tst_QRadioTuner::cleanupTestCase()
QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
radio->stop();
QVERIFY(radio->availability() == QtMultimedia::Available);
QVERIFY(radio->availability() == QMultimedia::Available);
QCOMPARE(radio->state(), QRadioTuner::StoppedState);
QCOMPARE(stateSpy.count(), 1);

2
tests/auto/unit/qvideoprobe/tst_qvideoprobe.cpp
View File

@@ -116,7 +116,7 @@ void tst_QVideoProbe::testNullService()
player = new QMediaPlayer;
QVERIFY(!player->isAvailable());
QCOMPARE(player->availability(), QtMultimedia::ServiceMissing);
QCOMPARE(player->availability(), QMultimedia::ServiceMissing);
QVideoProbe probe;
QVERIFY(!probe.isActive());