--- a/qtmobility/tests/auto/qmediarecorder/tst_qmediarecorder.cpp Fri Jun 11 14:26:25 2010 +0300
+++ b/qtmobility/tests/auto/qmediarecorder/tst_qmediarecorder.cpp Wed Jun 23 19:08:38 2010 +0300
@@ -46,12 +46,13 @@
#include <qmediaservice.h>
#include <qmediarecordercontrol.h>
#include <qmediarecorder.h>
+#include <qmetadatawritercontrol.h>
#include <qaudioendpointselector.h>
#include <qaudioencodercontrol.h>
#include <qmediacontainercontrol.h>
#include <qvideoencodercontrol.h>
-#include <QtMultimedia/qaudioformat.h>
+#include <qaudioformat.h>
QT_USE_NAMESPACE
class MockMediaContainerControl : public QMediaContainerControl
@@ -297,7 +298,8 @@
MockProvider(QObject *parent):
QMediaRecorderControl(parent),
m_state(QMediaRecorder::StoppedState),
- m_position(0) {}
+ m_position(0),
+ m_muted(false) {}
QUrl outputLocation() const
{
@@ -320,6 +322,11 @@
return m_position;
}
+ bool isMuted() const
+ {
+ return m_muted;
+ }
+
void applySettings() {}
using QMediaRecorderControl::error;
@@ -346,10 +353,62 @@
emit stateChanged(m_state);
}
+ void setMuted(bool muted)
+ {
+ if (m_muted != muted)
+ emit mutedChanged(m_muted = muted);
+ }
+
public:
QUrl m_sink;
QMediaRecorder::State m_state;
qint64 m_position;
+ bool m_muted;
+};
+
+
+class QtTestMetaDataProvider : public QMetaDataWriterControl
+{
+ Q_OBJECT
+public:
+ QtTestMetaDataProvider(QObject *parent = 0)
+ : QMetaDataWriterControl(parent)
+ , m_available(false)
+ , m_writable(false)
+ {
+ }
+
+ bool isMetaDataAvailable() const { return m_available; }
+ void setMetaDataAvailable(bool available) {
+ if (m_available != available)
+ emit metaDataAvailableChanged(m_available = available);
+ }
+ QList<QtMultimedia::MetaData> availableMetaData() const { return m_data.keys(); }
+
+ bool isWritable() const { return m_writable; }
+ void setWritable(bool writable) { emit writableChanged(m_writable = writable); }
+
+ QVariant metaData(QtMultimedia::MetaData key) const { return m_data.value(key); }
+ void setMetaData(QtMultimedia::MetaData key, const QVariant &value) {
+ m_data.insert(key, value); }
+
+ QVariant extendedMetaData(const QString &key) const { return m_extendedData.value(key); }
+ void setExtendedMetaData(const QString &key, const QVariant &value) {
+ m_extendedData.insert(key, value); }
+
+ QStringList availableExtendedMetaData() const { return m_extendedData.keys(); }
+
+ using QMetaDataWriterControl::metaDataChanged;
+
+ void populateMetaData()
+ {
+ m_available = true;
+ }
+
+ bool m_available;
+ bool m_writable;
+ QMap<QtMultimedia::MetaData, QVariant> m_data;
+ QMap<QString, QVariant> m_extendedData;
};
class MockService : public QMediaService
@@ -365,9 +424,10 @@
mockAudioEncodeControl = new MockAudioEncodeProvider(parent);
mockFormatControl = new MockMediaContainerControl(parent);
mockVideoEncodeControl = new MockVideoEncodeProvider(parent);
+ mockMetaDataControl = new QtTestMetaDataProvider(parent);
}
- QMediaControl* control(const char *name) const
+ QMediaControl* requestControl(const char *name)
{
if(hasControls && qstrcmp(name,QAudioEncoderControl_iid) == 0)
return mockAudioEncodeControl;
@@ -379,15 +439,20 @@
return mockFormatControl;
if(hasControls && qstrcmp(name,QVideoEncoderControl_iid) == 0)
return mockVideoEncodeControl;
+ if (hasControls && qstrcmp(name, QMetaDataWriterControl_iid) == 0)
+ return mockMetaDataControl;
return 0;
}
+ void releaseControl(QMediaControl*) {}
+
QMediaControl *mockControl;
QAudioEndpointSelector *mockAudioEndpointSelector;
QAudioEncoderControl *mockAudioEncodeControl;
QMediaContainerControl *mockFormatControl;
QVideoEncoderControl *mockVideoEncodeControl;
+ QtTestMetaDataProvider *mockMetaDataControl;
bool hasControls;
};
@@ -415,6 +480,7 @@
void testError();
void testSink();
void testRecord();
+ void testMute();
void testAudioDeviceControl();
void testAudioEncodeControl();
void testMediaFormatsControl();
@@ -423,6 +489,19 @@
void testAudioSettings();
void testVideoSettings();
+ void nullMetaDataControl();
+ void isMetaDataAvailable();
+ void isWritable();
+ void metaDataChanged();
+ void metaData_data();
+ void metaData();
+ void setMetaData_data();
+ void setMetaData();
+ void extendedMetaData_data() { metaData_data(); }
+ void extendedMetaData();
+ void setExtendedMetaData_data() { extendedMetaData_data(); }
+ void setExtendedMetaData();
+
private:
QAudioEncoderControl* encode;
QAudioEndpointSelector* audio;
@@ -442,11 +521,10 @@
service = new MockService(this, mock);
object = new MockObject(this, service);
capture = new QMediaRecorder(object);
- capture->setNotifyInterval(100);
- audio = qobject_cast<QAudioEndpointSelector*>(capture->service()->control(QAudioEndpointSelector_iid));
- encode = qobject_cast<QAudioEncoderControl*>(capture->service()->control(QAudioEncoderControl_iid));
- videoEncode = qobject_cast<QVideoEncoderControl*>(capture->service()->control(QVideoEncoderControl_iid));
+ 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()
@@ -484,6 +562,9 @@
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()
@@ -521,7 +602,7 @@
QAudioEncoderSettings audio;
audio.setCodec(id);
- audio.setQuality(QtMediaServices::LowQuality);
+ audio.setQuality(QtMultimedia::LowQuality);
QVideoEncoderSettings video;
video.setCodec(id);
@@ -600,6 +681,26 @@
}
+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)));
@@ -664,18 +765,18 @@
QCOMPARE(audioSettings.codec(), QString("audio/pcm"));
QCOMPARE(audioSettings.bitRate(), 128*1024);
QCOMPARE(audioSettings.sampleRate(), -1);
- QCOMPARE(audioSettings.quality(), QtMediaServices::NormalQuality);
+ QCOMPARE(audioSettings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(audioSettings.channelCount(), -1);
- QCOMPARE(audioSettings.encodingMode(), QtMediaServices::ConstantQualityEncoding);
+ QCOMPARE(audioSettings.encodingMode(), QtMultimedia::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(), QtMediaServices::NormalQuality);
- QCOMPARE(videoSettings.encodingMode(), QtMediaServices::ConstantQualityEncoding);
+ QCOMPARE(videoSettings.quality(), QtMultimedia::NormalQuality);
+ QCOMPARE(videoSettings.encodingMode(), QtMultimedia::ConstantQualityEncoding);
QString format = capture->containerMimeType();
QCOMPARE(format, QString());
@@ -683,15 +784,15 @@
audioSettings.setCodec("audio/mpeg");
audioSettings.setSampleRate(44100);
audioSettings.setBitRate(256*1024);
- audioSettings.setQuality(QtMediaServices::HighQuality);
- audioSettings.setEncodingMode(QtMediaServices::AverageBitRateEncoding);
+ audioSettings.setQuality(QtMultimedia::HighQuality);
+ audioSettings.setEncodingMode(QtMultimedia::AverageBitRateEncoding);
videoSettings.setCodec("video/3gpp");
videoSettings.setBitRate(800);
videoSettings.setFrameRate(24*1024);
videoSettings.setResolution(QSize(800,600));
- videoSettings.setQuality(QtMediaServices::HighQuality);
- audioSettings.setEncodingMode(QtMediaServices::TwoPassEncoding);
+ videoSettings.setQuality(QtMultimedia::HighQuality);
+ audioSettings.setEncodingMode(QtMultimedia::TwoPassEncoding);
format = QString("mov");
@@ -721,9 +822,9 @@
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
- QCOMPARE(settings.quality(), QtMediaServices::NormalQuality);
- settings.setQuality(QtMediaServices::HighQuality);
- QCOMPARE(settings.quality(), QtMediaServices::HighQuality);
+ QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
+ settings.setQuality(QtMultimedia::HighQuality);
+ QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings = QAudioEncoderSettings();
@@ -742,7 +843,7 @@
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.bitRate(), -1);
- QCOMPARE(settings.quality(), QtMediaServices::NormalQuality);
+ QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(settings.sampleRate(), -1);
{
@@ -754,7 +855,7 @@
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
- settings1.setQuality(QtMediaServices::HighQuality);
+ settings1.setQuality(QtMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -770,7 +871,7 @@
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
- settings1.setQuality(QtMediaServices::HighQuality);
+ settings1.setQuality(QtMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -802,19 +903,19 @@
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
- settings1.setEncodingMode(QtMediaServices::ConstantBitRateEncoding);
+ settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings2 = QAudioEncoderSettings();
- settings2.setEncodingMode(QtMediaServices::ConstantBitRateEncoding);
+ settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
QVERIFY(settings1 == settings2);
- settings2.setEncodingMode(QtMediaServices::TwoPassEncoding);
+ settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
- settings1.setQuality(QtMediaServices::NormalQuality);
+ settings1.setQuality(QtMultimedia::NormalQuality);
settings2 = QAudioEncoderSettings();
- settings2.setQuality(QtMediaServices::NormalQuality);
+ settings2.setQuality(QtMultimedia::NormalQuality);
QVERIFY(settings1 == settings2);
- settings2.setQuality(QtMediaServices::LowQuality);
+ settings2.setQuality(QtMultimedia::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QAudioEncoderSettings();
@@ -845,9 +946,9 @@
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
- QCOMPARE(settings.quality(), QtMediaServices::NormalQuality);
- settings.setQuality(QtMediaServices::HighQuality);
- QCOMPARE(settings.quality(), QtMediaServices::HighQuality);
+ QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
+ settings.setQuality(QtMultimedia::HighQuality);
+ QCOMPARE(settings.quality(), QtMultimedia::HighQuality);
QVERIFY(!settings.isNull());
settings = QVideoEncoderSettings();
@@ -870,7 +971,7 @@
QVERIFY(settings.isNull());
QCOMPARE(settings.codec(), QString());
QCOMPARE(settings.bitRate(), -1);
- QCOMPARE(settings.quality(), QtMediaServices::NormalQuality);
+ QCOMPARE(settings.quality(), QtMultimedia::NormalQuality);
QCOMPARE(settings.frameRate(), qreal());
QCOMPARE(settings.resolution(), QSize());
@@ -883,7 +984,7 @@
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
- settings1.setQuality(QtMediaServices::HighQuality);
+ settings1.setQuality(QtMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -899,7 +1000,7 @@
QCOMPARE(settings2, settings1);
QVERIFY(settings2.isNull());
- settings1.setQuality(QtMediaServices::HighQuality);
+ settings1.setQuality(QtMultimedia::HighQuality);
QVERIFY(settings2.isNull());
QVERIFY(!settings1.isNull());
@@ -931,19 +1032,19 @@
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
- settings1.setEncodingMode(QtMediaServices::ConstantBitRateEncoding);
+ settings1.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
settings2 = QVideoEncoderSettings();
- settings2.setEncodingMode(QtMediaServices::ConstantBitRateEncoding);
+ settings2.setEncodingMode(QtMultimedia::ConstantBitRateEncoding);
QVERIFY(settings1 == settings2);
- settings2.setEncodingMode(QtMediaServices::TwoPassEncoding);
+ settings2.setEncodingMode(QtMultimedia::TwoPassEncoding);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
- settings1.setQuality(QtMediaServices::NormalQuality);
+ settings1.setQuality(QtMultimedia::NormalQuality);
settings2 = QVideoEncoderSettings();
- settings2.setQuality(QtMediaServices::NormalQuality);
+ settings2.setQuality(QtMultimedia::NormalQuality);
QVERIFY(settings1 == settings2);
- settings2.setQuality(QtMediaServices::LowQuality);
+ settings2.setQuality(QtMultimedia::LowQuality);
QVERIFY(settings1 != settings2);
settings1 = QVideoEncoderSettings();
@@ -955,6 +1056,213 @@
QVERIFY(settings1 != settings2);
}
+
+void tst_QMediaRecorder::nullMetaDataControl()
+{
+ const QString titleKey(QLatin1String("Title"));
+ const QString title(QLatin1String("Host of Seraphim"));
+
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ service.hasControls = false;
+ MockObject object(0, &service);
+
+ QMediaRecorder recorder(&object);
+
+ QSignalSpy spy(&recorder, SIGNAL(metaDataChanged()));
+
+ QCOMPARE(recorder.isMetaDataAvailable(), false);
+ QCOMPARE(recorder.isMetaDataWritable(), false);
+
+ recorder.setMetaData(QtMultimedia::Title, title);
+ recorder.setExtendedMetaData(titleKey, title);
+
+ QCOMPARE(recorder.metaData(QtMultimedia::Title).toString(), QString());
+ QCOMPARE(recorder.extendedMetaData(titleKey).toString(), QString());
+ QCOMPARE(recorder.availableMetaData(), QList<QtMultimedia::MetaData>());
+ QCOMPARE(recorder.availableExtendedMetaData(), QStringList());
+ QCOMPARE(spy.count(), 0);
+}
+
+void tst_QMediaRecorder::isMetaDataAvailable()
+{
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ service.mockMetaDataControl->setMetaDataAvailable(false);
+ MockObject 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()
+{
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ service.mockMetaDataControl->setWritable(false);
+
+ MockObject 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()
+{
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ MockObject 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);
+
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ service.mockMetaDataControl->populateMetaData();
+
+ MockObject object(0, &service);
+
+ QMediaRecorder recorder(&object);
+ QVERIFY(object.availableMetaData().isEmpty());
+
+ service.mockMetaDataControl->m_data.insert(QtMultimedia::AlbumArtist, artist);
+ service.mockMetaDataControl->m_data.insert(QtMultimedia::Title, title);
+ service.mockMetaDataControl->m_data.insert(QtMultimedia::Genre, genre);
+
+ QCOMPARE(recorder.metaData(QtMultimedia::AlbumArtist).toString(), artist);
+ QCOMPARE(recorder.metaData(QtMultimedia::Title).toString(), title);
+
+ QList<QtMultimedia::MetaData> metaDataKeys = recorder.availableMetaData();
+ QCOMPARE(metaDataKeys.size(), 3);
+ QVERIFY(metaDataKeys.contains(QtMultimedia::AlbumArtist));
+ QVERIFY(metaDataKeys.contains(QtMultimedia::Title));
+ QVERIFY(metaDataKeys.contains(QtMultimedia::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);
+
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ service.mockMetaDataControl->populateMetaData();
+
+ MockObject object(0, &service);
+
+ QMediaRecorder recorder(&object);
+
+ recorder.setMetaData(QtMultimedia::Title, title);
+ QCOMPARE(recorder.metaData(QtMultimedia::Title).toString(), title);
+ QCOMPARE(service.mockMetaDataControl->m_data.value(QtMultimedia::Title).toString(), title);
+}
+
+void tst_QMediaRecorder::extendedMetaData()
+{
+ QFETCH(QString, artist);
+ QFETCH(QString, title);
+ QFETCH(QString, genre);
+
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ MockObject 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()
+{
+ MockProvider recorderControl(0);
+ MockService service(0, &recorderControl);
+ service.mockMetaDataControl->populateMetaData();
+
+ MockObject 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);
+}
+
+
QTEST_MAIN(tst_QMediaRecorder)
#include "tst_qmediarecorder.moc"