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

API unit tests from Maemo API test team.

Browse Source 
A large number of tweaks and changes to original tests, and refactor
a lot of the mock backends to reduce duplication.

Changed viewfinder test case to use mock service and provider so
that it matches the image capture test case.

Reviewed-by: Jonas Rabbe
(cherry picked from commit e40bef5508a4165cec4a46b97115aed461027fa5)

Also licence header fix:
(cherry picked from commit e9ee9e8c48b45b97d62ee4a82e400fa9d8ea8107)

Change-Id: Ic59891d75563bb2e008a336eea859e8c44d8d831
Reviewed-on: http://codereview.qt.nokia.com/2078
Reviewed-by: Jonas Rabbe <jonas.rabbe@nokia.com>
This commit is contained in:
Michael Goddard
2011-07-25 15:02:51 +10:00
committed by Qt by Nokia
parent 1e4dda9710
commit a6128410da
94 changed files with 8814 additions and 2396 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tests/auto/qaudiocapturesource/qaudiocapturesource.pro
View File

@@ -2,8 +2,8 @@ load(qttest_p4)
QT += multimediakit-private
# TARGET = tst_qaudiocapturesource
# CONFIG += testcase
SOURCES += tst_qaudiocapturesource.cpp
include (../qmultimedia_common/mockrecorder.pri)
include (../qmultimedia_common/mock.pri)

282
tests/auto/qaudiocapturesource/tst_qaudiocapturesource.cpp
View File

@@ -48,218 +48,16 @@
#include <qaudioencodercontrol.h>
#include <qmediarecordercontrol.h>
#include <qaudioendpointselector.h>
#include <qaudiodeviceinfo.h>
#include <qaudioinput.h>
#include <qmediaobject.h>
//TESTED_COMPONENT=src/multimedia
#include "mockmediaserviceprovider.h"
#include "mockmediarecorderservice.h"
QT_USE_NAMESPACE
class MockAudioEncoderControl : public QAudioEncoderControl
{
Q_OBJECT
public:
MockAudioEncoderControl(QObject *parent = 0):
QAudioEncoderControl(parent)
{
m_codecs << "audio/pcm" << "audio/mpeg";
m_descriptions << "Pulse Code Modulation" << "mp3 format";
m_audioSettings.setCodec("audio/pcm");
m_audioSettings.setSampleRate(8000);
m_freqs << 8000 << 11025 << 22050 << 44100;
}
~MockAudioEncoderControl() {}
QStringList supportedAudioCodecs() const { return m_codecs; }
QString codecDescription(const QString &codecName) const { return m_descriptions.at(m_codecs.indexOf(codecName)); }
QStringList supportedEncodingOptions(const QString &) const { return QStringList() << "bitrate"; }
QVariant encodingOption(const QString &, const QString &) const { return m_optionValue; }
void setEncodingOption(const QString &, const QString &, const QVariant &value) { m_optionValue = value; }
QList<int> supportedSampleRates(const QAudioEncoderSettings & = QAudioEncoderSettings(),
bool *continuous = 0) const
{
if (continuous)
*continuous = false;
return m_freqs;
}
QList<int> supportedChannelCounts(const QAudioEncoderSettings & = QAudioEncoderSettings()) const { QList<int> list; list << 1 << 2; return list; }
QAudioEncoderSettings audioSettings() const { return m_audioSettings; }
void setAudioSettings(const QAudioEncoderSettings &settings) { m_audioSettings = settings;}
QStringList m_codecs;
QStringList m_descriptions;
QAudioEncoderSettings m_audioSettings;
QList<int> m_freqs;
QVariant m_optionValue;
};
class MockMediaRecorderControl : public QMediaRecorderControl
{
Q_OBJECT
public:
MockMediaRecorderControl(QObject *parent = 0):
QMediaRecorderControl(parent),
m_state(QMediaRecorder::StoppedState),
m_position(0),
m_muted(false) {}
~MockMediaRecorderControl() {}
QUrl outputLocation() const { return m_sink; }
bool setOutputLocation(const QUrl &sink) { m_sink = sink; return true; }
QMediaRecorder::State state() const { return m_state; }
qint64 duration() const { return m_position; }
void applySettings() {}
bool isMuted() const { return m_muted; }
public slots:
void record()
{
m_state = QMediaRecorder::RecordingState;
m_position=1;
emit stateChanged(m_state);
emit durationChanged(m_position);
}
void pause()
{
m_state = QMediaRecorder::PausedState;
emit stateChanged(m_state);
}
void stop()
{
m_position=0;
m_state = QMediaRecorder::StoppedState;
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 MockAudioEndpointSelector : public QAudioEndpointSelector
{
Q_OBJECT
public:
MockAudioEndpointSelector(QObject *parent):
QAudioEndpointSelector(parent)
{
m_names << "device1" << "device2" << "device3";
m_descriptions << "dev1 comment" << "dev2 comment" << "dev3 comment";
m_audioInput = "device1";
emit availableEndpointsChanged();
}
~MockAudioEndpointSelector() {};
QList<QString> availableEndpoints() const
{
return m_names;
}
QString endpointDescription(const QString& name) const
{
QString desc;
for(int i = 0; i < m_names.count(); i++) {
if (m_names.at(i).compare(name) == 0) {
desc = m_descriptions.at(i);
break;
}
}
return desc;
}
QString defaultEndpoint() const
{
return m_names.at(0);
}
QString activeEndpoint() const
{
return m_audioInput;
}
public Q_SLOTS:
void setActiveEndpoint(const QString& name)
{
m_audioInput = name;
emit activeEndpointChanged(name);
}
private:
QString m_audioInput;
QList<QString> m_names;
QList<QString> m_descriptions;
};
class MockAudioSourceService : public QMediaService
{
Q_OBJECT
public:
MockAudioSourceService(): QMediaService(0), hasAudioDeviceControl(true)
{
mockAudioEncoderControl = new MockAudioEncoderControl(this);
mockMediaRecorderControl = new MockMediaRecorderControl(this);
mockAudioEndpointSelector = new MockAudioEndpointSelector(this);
}
~MockAudioSourceService()
{
delete mockAudioEncoderControl;
delete mockMediaRecorderControl;
delete mockAudioEndpointSelector;
}
QMediaControl* requestControl(const char *iid)
{
if (qstrcmp(iid, QAudioEncoderControl_iid) == 0)
return mockAudioEncoderControl;
if (qstrcmp(iid, QMediaRecorderControl_iid) == 0)
return mockMediaRecorderControl;
if (hasAudioDeviceControl && qstrcmp(iid, QAudioEndpointSelector_iid) == 0)
return mockAudioEndpointSelector;
return 0;
}
void releaseControl(QMediaControl*) {}
MockAudioEncoderControl *mockAudioEncoderControl;
MockMediaRecorderControl *mockMediaRecorderControl;
MockAudioEndpointSelector *mockAudioEndpointSelector;
bool hasAudioDeviceControl;
};
class MockProvider : public QMediaServiceProvider
{
public:
MockProvider(MockAudioSourceService *service):mockService(service) {}
QMediaService *requestService(const QByteArray&, const QMediaServiceProviderHint &)
{
return mockService;
}
void releaseService(QMediaService *) {}
MockAudioSourceService *mockService;
};
class tst_QAudioCaptureSource: public QObject
{
@@ -275,23 +73,26 @@ private slots:
void testAudioSource();
void testOptions();
void testDevices();
void testAvailability();
void testAvailableAudioInputChangedSignal();
private:
QAudioCaptureSource *audiosource;
MockAudioSourceService *mockAudioSourceService;
MockProvider *mockProvider;
MockMediaRecorderService *mockMediaRecorderService;
MockMediaServiceProvider *mockProvider;
};
void tst_QAudioCaptureSource::initTestCase()
{
mockAudioSourceService = new MockAudioSourceService;
mockProvider = new MockProvider(mockAudioSourceService);
mockMediaRecorderService = new MockMediaRecorderService;
mockProvider = new MockMediaServiceProvider(mockMediaRecorderService);
}
void tst_QAudioCaptureSource::cleanupTestCase()
{
delete audiosource;
delete mockProvider;
audiosource = 0;
}
/*
void tst_QAudioCaptureSource::testNullService()
@@ -307,7 +108,7 @@ void tst_QAudioCaptureSource::testNullService()
/*
void tst_QAudioCaptureSource::testNullControl()
{
MockAudioSourceService service;
MockRecorderService service;
service.hasAudioDeviceControl = false;
MockProvider provider(&service);
QAudioCaptureSource source(0, &provider);
@@ -328,31 +129,74 @@ void tst_QAudioCaptureSource::testAudioSource()
{
audiosource = new QAudioCaptureSource(0, mockProvider);
QCOMPARE(audiosource->service(),(QMediaService *) mockAudioSourceService);
QCOMPARE(audiosource->service(),(QMediaService *) mockMediaRecorderService);
}
void tst_QAudioCaptureSource::testOptions()
{
const QString codec(QLatin1String("mp3"));
const QString codec(QLatin1String("audio/mpeg"));
QStringList options = mockAudioSourceService->mockAudioEncoderControl->supportedEncodingOptions(codec);
QVERIFY(options.count() == 1);
mockAudioSourceService->mockAudioEncoderControl->setEncodingOption(codec, options.first(),8000);
QVERIFY(mockAudioSourceService->mockAudioEncoderControl->encodingOption(codec, options.first()).toInt() == 8000);
QStringList options = mockMediaRecorderService->mockAudioEncoderControl->supportedEncodingOptions(codec);
QCOMPARE(options.count(), 4);
mockMediaRecorderService->mockAudioEncoderControl->setEncodingOption(codec, options.first(),8000);
QVERIFY(mockMediaRecorderService->mockAudioEncoderControl->encodingOption(codec, options.first()).toInt() == 8000);
}
void tst_QAudioCaptureSource::testDevices()
{
audiosource = new QAudioCaptureSource(0,mockProvider);
QList<QString> devices = audiosource->audioInputs();
QVERIFY(devices.size() > 0);
QVERIFY(devices.at(0).compare("device1") == 0);
QVERIFY(audiosource->audioDescription("device1").compare("dev1 comment") == 0);
QVERIFY(audiosource->defaultAudioInput() == "device1");
QVERIFY(audiosource->isAvailable() == true);
QSignalSpy checkSignal(audiosource, SIGNAL(activeAudioInputChanged(QString)));
audiosource->setAudioInput("device2");
QVERIFY(audiosource->activeAudioInput().compare("device2") == 0);
QVERIFY(checkSignal.count() == 1);
QVERIFY(audiosource->isAvailable() == true);
}
void tst_QAudioCaptureSource::testAvailability()
{
MockMediaRecorderService service;
service.hasControls = false;
MockMediaServiceProvider provider(&service);
QAudioCaptureSource source(0, &provider);
QVERIFY(source.isAvailable() == false);
QVERIFY(source.availabilityError() == QtMultimediaKit::ServiceMissingError);
service.hasControls = true;
MockMediaServiceProvider provider2(&service);
QAudioCaptureSource source2(0, &provider2);
QVERIFY(source2.isAvailable() == true);
QVERIFY(source2.availabilityError() == QtMultimediaKit::NoError);
}
void tst_QAudioCaptureSource::testAvailableAudioInputChangedSignal()
{
// The availabilityChangedSignal is implemented in QAudioCaptureSource. SO using it to test the signal.
audiosource = new QAudioCaptureSource(0, mockProvider);
/* Spy the signal availableEndpointChanged and audioInputchanged */
QSignalSpy changed(mockMediaRecorderService->mockAudioEndpointSelector, SIGNAL(availableEndpointsChanged()));
QSignalSpy audioInputchange(audiosource, SIGNAL(availableAudioInputsChanged()));
/* Add the end points and verify if the available end point changed signal is emitted. */
QMetaObject::invokeMethod(mockMediaRecorderService->mockAudioEndpointSelector, "addEndpoints");
QVERIFY(changed.count() == 1);
QVERIFY(audioInputchange.count() == 1);
/* Now try removes */
changed.clear();
audioInputchange.clear();
QMetaObject::invokeMethod(mockMediaRecorderService->mockAudioEndpointSelector, "removeEndpoints");
QVERIFY(changed.count() == 1);
QVERIFY(audioInputchange.count() == 1);
}
QTEST_MAIN(tst_QAudioCaptureSource)