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

2
tests/auto/qmediaplayer/qmediaplayer.pro
View File

@@ -8,3 +8,5 @@ QT += network multimediakit-private
HEADERS += tst_qmediaplayer.h
SOURCES += main.cpp tst_qmediaplayer.cpp
include (../qmultimedia_common/mock.pri)
include (../qmultimedia_common/mockplayer.pri)

92
tests/auto/qmediaplayer/tst_qmediaplayer.cpp
View File

@@ -79,6 +79,8 @@
QT_USE_NAMESPACE
#include "mockvideosurface.h"
void tst_QMediaPlayer::initTestCase_data()
{
QTest::addColumn<bool>("valid");
@@ -126,8 +128,8 @@ void tst_QMediaPlayer::initTestCase()
qRegisterMetaType<QMediaPlayer::MediaStatus>("QMediaPlayer::MediaStatus");
qRegisterMetaType<QMediaContent>("QMediaContent");
mockService = new MockPlayerService;
mockProvider = new MockProvider(mockService);
mockService = new MockMediaPlayerService;
mockProvider = new MockMediaServiceProvider(mockService, true);
player = new QMediaPlayer(0, 0, mockProvider);
}
@@ -147,7 +149,7 @@ void tst_QMediaPlayer::cleanup()
void tst_QMediaPlayer::testNullService()
{
MockProvider provider(0);
MockMediaServiceProvider provider(0);
QMediaPlayer player(0, 0, &provider);
const QIODevice *nullDevice = 0;
@@ -842,6 +844,68 @@ void tst_QMediaPlayer::testPlaylist()
}
void tst_QMediaPlayer::testPlayerFlags()
{
MockMediaServiceProvider provider(0, true);
QMediaPlayer::Flag flags = QMediaPlayer::LowLatency;
QMediaPlayer player(0, flags, &provider);
QMediaServiceProviderHint::Feature feature;
if (flags & QMediaPlayer::LowLatency)
{
/* if the flag is low latency set the low latency play back for the service provider */
feature = QMediaServiceProviderHint::LowLatencyPlayback;
const QByteArray service(Q_MEDIASERVICE_MEDIAPLAYER);
const QMediaServiceProviderHint providerHint(feature);
/* request service for the service provider */
provider.requestService(service,providerHint);
/* Constructs a SupportedFeatures media service provider hint. */
QMediaServiceProviderHint servicepro(feature);
/* compare the flag value */
QVERIFY(servicepro.features() == QMediaServiceProviderHint::LowLatencyPlayback);
}
/* The player is expected to play QIODevice based streams.
If passed to QMediaPlayer constructor,
the service supporting streams playback will be chosen. */
flags = QMediaPlayer::StreamPlayback;
/* Construct a QMediaPlayer that uses the playback service from provider,
parented to parent and with flags.*/
QMediaPlayer player2(0,flags , &provider);
if (flags & QMediaPlayer::StreamPlayback)
{
/* if the flag is stream play back set the stream play back for the service provider */
feature = QMediaServiceProviderHint::StreamPlayback;
const QByteArray service(Q_MEDIASERVICE_MEDIAPLAYER);
const QMediaServiceProviderHint providerHint(feature);
/* request service for the service provider */
provider.requestService(service,providerHint);
/* Constructs a SupportedFeatures media service provider hint. */
QMediaServiceProviderHint servicepro(feature);
/* compare the flag value */
QVERIFY(servicepro.features() == QMediaServiceProviderHint::StreamPlayback);
}
}
void tst_QMediaPlayer::testDestructor()
{
/* create an object for player */
QMediaPlayer *player = new QMediaPlayer;
/* check whether the object is created */
QVERIFY(player);
/* delete the instance */
delete player;
}
void tst_QMediaPlayer::testNetworkAccess()
{
QNetworkConfigurationManager manager;
@@ -876,9 +940,8 @@ void tst_QMediaPlayer::testSetVideoOutput()
QGraphicsVideoItem item;
MockVideoSurface surface;
MockPlayerService service;
MockProvider provider(&service);
provider.deleteServiceOnRelease = false;
MockMediaPlayerService service;
MockMediaServiceProvider provider(&service);
QMediaPlayer player(0, 0, &provider);
player.setVideoOutput(&widget);
@@ -922,7 +985,7 @@ void tst_QMediaPlayer::testSetVideoOutputNoService()
QGraphicsVideoItem item;
MockVideoSurface surface;
MockProvider provider(0);
MockMediaServiceProvider provider(0, true);
QMediaPlayer player(0, 0, &provider);
player.setVideoOutput(&widget);
@@ -941,12 +1004,11 @@ void tst_QMediaPlayer::testSetVideoOutputNoControl()
QGraphicsVideoItem item;
MockVideoSurface surface;
MockPlayerService service;
MockMediaPlayerService service;
service.rendererRef = 1;
service.windowRef = 1;
MockProvider provider(&service);
provider.deleteServiceOnRelease = false;
MockMediaServiceProvider provider(&service);
QMediaPlayer player(0, 0, &provider);
player.setVideoOutput(&widget);
@@ -963,9 +1025,8 @@ void tst_QMediaPlayer::testSetVideoOutputDestruction()
{
MockVideoSurface surface;
MockPlayerService service;
MockProvider provider(&service);
provider.deleteServiceOnRelease = false;
MockMediaPlayerService service;
MockMediaServiceProvider provider(&service);
{
QMediaPlayer player(0, 0, &provider);
@@ -1016,4 +1077,9 @@ void tst_QMediaPlayer::debugEnums()
qDebug() << QMediaPlayer::NetworkError;
}
void tst_QMediaPlayer::testSupportedMimeTypes()
{
QStringList mimeList = QMediaPlayer::supportedMimeTypes(QMediaPlayer::LowLatency);
// This is empty on some platforms, and not on others, so can't test something here at the moment.
}

317
tests/auto/qmediaplayer/tst_qmediaplayer.h
View File

@@ -56,6 +56,9 @@
#include <qvideorenderercontrol.h>
#include <qvideowindowcontrol.h>
#include "mockmediaserviceprovider.h"
#include "mockmediaplayerservice.h"
QT_USE_NAMESPACE
class AutoConnection
@@ -79,313 +82,6 @@ private:
const char *method;
};
class MockPlayerControl : public QMediaPlayerControl
{
friend class MockPlayerService;
public:
MockPlayerControl():QMediaPlayerControl(0) {}
QMediaPlayer::State state() const { return _state; }
QMediaPlayer::MediaStatus mediaStatus() const { return _mediaStatus; }
qint64 duration() const { return _duration; }
qint64 position() const { return _position; }
void setPosition(qint64 position) { if (position != _position) emit positionChanged(_position = position); }
int volume() const { return _volume; }
void setVolume(int volume) { emit volumeChanged(_volume = volume); }
bool isMuted() const { return _muted; }
void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }
int bufferStatus() const { return _bufferStatus; }
bool isAudioAvailable() const { return _audioAvailable; }
bool isVideoAvailable() const { return _videoAvailable; }
bool isSeekable() const { return _isSeekable; }
QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(_seekRange.first, _seekRange.second); }
void setSeekRange(qint64 minimum, qint64 maximum) { _seekRange = qMakePair(minimum, maximum); }
qreal playbackRate() const { return _playbackRate; }
void setPlaybackRate(qreal rate) { if (rate != _playbackRate) emit playbackRateChanged(_playbackRate = rate); }
QMediaContent media() const { return _media; }
void setMedia(const QMediaContent &content, QIODevice *stream)
{
_stream = stream;
_media = content;
if (_state != QMediaPlayer::StoppedState) {
_mediaStatus = _media.isNull() ? QMediaPlayer::NoMedia : QMediaPlayer::LoadingMedia;
emit stateChanged(_state = QMediaPlayer::StoppedState);
emit mediaStatusChanged(_mediaStatus);
}
emit mediaChanged(_media = content);
}
QIODevice *mediaStream() const { return _stream; }
void play() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PlayingState) emit stateChanged(_state = QMediaPlayer::PlayingState); }
void pause() { if (_isValid && !_media.isNull() && _state != QMediaPlayer::PausedState) emit stateChanged(_state = QMediaPlayer::PausedState); }
void stop() { if (_state != QMediaPlayer::StoppedState) emit stateChanged(_state = QMediaPlayer::StoppedState); }
QMediaPlayer::State _state;
QMediaPlayer::MediaStatus _mediaStatus;
QMediaPlayer::Error _error;
qint64 _duration;
qint64 _position;
int _volume;
bool _muted;
int _bufferStatus;
bool _audioAvailable;
bool _videoAvailable;
bool _isSeekable;
QPair<qint64, qint64> _seekRange;
qreal _playbackRate;
QMediaContent _media;
QIODevice *_stream;
bool _isValid;
QString _errorString;
};
class MockVideoSurface : public QAbstractVideoSurface
{
public:
QList<QVideoFrame::PixelFormat> supportedPixelFormats(
const QAbstractVideoBuffer::HandleType) const
{
return QList<QVideoFrame::PixelFormat>();
}
bool present(const QVideoFrame &) { return false; }
};
class MockVideoRendererControl : public QVideoRendererControl
{
public:
MockVideoRendererControl() : m_surface(0) {}
QAbstractVideoSurface *surface() const { return m_surface; }
void setSurface(QAbstractVideoSurface *surface) { m_surface = surface; }
QAbstractVideoSurface *m_surface;
};
class MockVideoWindowControl : public QVideoWindowControl
{
public:
WId winId() const { return 0; }
void setWinId(WId) {}
QRect displayRect() const { return QRect(); }
void setDisplayRect(const QRect &) {}
bool isFullScreen() const { return false; }
void setFullScreen(bool) {}
void repaint() {}
QSize nativeSize() const { return QSize(); }
Qt::AspectRatioMode aspectRatioMode() const { return Qt::KeepAspectRatio; }
void setAspectRatioMode(Qt::AspectRatioMode) {}
int brightness() const { return 0; }
void setBrightness(int) {}
int contrast() const { return 0; }
void setContrast(int) {}
int hue() const { return 0; }
void setHue(int) {}
int saturation() const { return 0; }
void setSaturation(int) {}
};
class MockStreamsControl : public QMediaStreamsControl
{
public:
MockStreamsControl(QObject *parent = 0) : QMediaStreamsControl(parent) {}
int streamCount() { return _streams.count(); }
void setStreamCount(int count) { _streams.resize(count); }
StreamType streamType(int index) { return _streams.at(index).type; }
void setStreamType(int index, StreamType type) { _streams[index].type = type; }
QVariant metaData(int index, QtMultimediaKit::MetaData key) {
return _streams.at(index).metaData.value(key); }
void setMetaData(int index, QtMultimediaKit::MetaData key, const QVariant &value) {
_streams[index].metaData.insert(key, value); }
bool isActive(int index) { return _streams.at(index).active; }
void setActive(int index, bool state) { _streams[index].active = state; }
private:
struct Stream
{
Stream() : type(UnknownStream), active(false) {}
StreamType type;
QMap<QtMultimediaKit::MetaData, QVariant> metaData;
bool active;
};
QVector<Stream> _streams;
};
class MockNetworkAccessControl : public QMediaNetworkAccessControl
{
friend class MockPlayerService;
public:
MockNetworkAccessControl() {}
~MockNetworkAccessControl() {}
void setConfigurations(const QList<QNetworkConfiguration> &configurations)
{
_configurations = configurations;
_current = QNetworkConfiguration();
}
QNetworkConfiguration currentConfiguration() const
{
return _current;
}
private:
void setCurrentConfiguration(QNetworkConfiguration configuration)
{
if (_configurations.contains(configuration))
emit configurationChanged(_current = configuration);
else
emit configurationChanged(_current = QNetworkConfiguration());
}
QList<QNetworkConfiguration> _configurations;
QNetworkConfiguration _current;
};
Q_DECLARE_METATYPE(QNetworkConfiguration)
class MockPlayerService : public QMediaService
{
Q_OBJECT
public:
MockPlayerService():QMediaService(0)
{
mockControl = new MockPlayerControl;
mockStreamsControl = new MockStreamsControl;
mockNetworkControl = new MockNetworkAccessControl;
rendererControl = new MockVideoRendererControl;
windowControl = new MockVideoWindowControl;
rendererRef = 0;
windowRef = 0;
}
~MockPlayerService()
{
delete mockControl;
delete mockStreamsControl;
delete mockNetworkControl;
delete rendererControl;
delete windowControl;
}
QMediaControl* requestControl(const char *iid)
{
if (qstrcmp(iid, QMediaPlayerControl_iid) == 0) {
return mockControl;
} else if (qstrcmp(iid, QVideoRendererControl_iid) == 0) {
if (rendererRef == 0) {
rendererRef += 1;
return rendererControl;
}
} else if (qstrcmp(iid, QVideoWindowControl_iid) == 0) {
if (windowRef == 0) {
windowRef += 1;
return windowControl;
}
}
if (qstrcmp(iid, QMediaNetworkAccessControl_iid) == 0)
return mockNetworkControl;
return 0;
}
void releaseControl(QMediaControl *control)
{
if (control == rendererControl)
rendererRef -= 1;
else if (control == windowControl)
windowRef -= 1;
}
void setState(QMediaPlayer::State state) { emit mockControl->stateChanged(mockControl->_state = state); }
void setState(QMediaPlayer::State state, QMediaPlayer::MediaStatus status) {
mockControl->_state = state;
mockControl->_mediaStatus = status;
emit mockControl->mediaStatusChanged(status);
emit mockControl->stateChanged(state);
}
void setMediaStatus(QMediaPlayer::MediaStatus status) { emit mockControl->mediaStatusChanged(mockControl->_mediaStatus = status); }
void setIsValid(bool isValid) { mockControl->_isValid = isValid; }
void setMedia(QMediaContent media) { mockControl->_media = media; }
void setDuration(qint64 duration) { mockControl->_duration = duration; }
void setPosition(qint64 position) { mockControl->_position = position; }
void setSeekable(bool seekable) { mockControl->_isSeekable = seekable; }
void setVolume(int volume) { mockControl->_volume = volume; }
void setMuted(bool muted) { mockControl->_muted = muted; }
void setVideoAvailable(bool videoAvailable) { mockControl->_videoAvailable = videoAvailable; }
void setBufferStatus(int bufferStatus) { mockControl->_bufferStatus = bufferStatus; }
void setPlaybackRate(qreal playbackRate) { mockControl->_playbackRate = playbackRate; }
void setError(QMediaPlayer::Error error) { mockControl->_error = error; emit mockControl->error(mockControl->_error, mockControl->_errorString); }
void setErrorString(QString errorString) { mockControl->_errorString = errorString; emit mockControl->error(mockControl->_error, mockControl->_errorString); }
void selectCurrentConfiguration(QNetworkConfiguration config) { mockNetworkControl->setCurrentConfiguration(config); }
void reset()
{
mockControl->_state = QMediaPlayer::StoppedState;
mockControl->_mediaStatus = QMediaPlayer::UnknownMediaStatus;
mockControl->_error = QMediaPlayer::NoError;
mockControl->_duration = 0;
mockControl->_position = 0;
mockControl->_volume = 0;
mockControl->_muted = false;
mockControl->_bufferStatus = 0;
mockControl->_videoAvailable = false;
mockControl->_isSeekable = false;
mockControl->_playbackRate = 0.0;
mockControl->_media = QMediaContent();
mockControl->_stream = 0;
mockControl->_isValid = false;
mockControl->_errorString = QString();
mockNetworkControl->_current = QNetworkConfiguration();
mockNetworkControl->_configurations = QList<QNetworkConfiguration>();
}
MockPlayerControl *mockControl;
MockStreamsControl *mockStreamsControl;
MockNetworkAccessControl *mockNetworkControl;
MockVideoRendererControl *rendererControl;
MockVideoWindowControl *windowControl;
int rendererRef;
int windowRef;
};
class MockProvider : public QMediaServiceProvider
{
public:
MockProvider(MockPlayerService *service):mockService(service), deleteServiceOnRelease(true) {}
QMediaService *requestService(const QByteArray &, const QMediaServiceProviderHint &)
{
return mockService;
}
void releaseService(QMediaService *service) { if (deleteServiceOnRelease) delete service; }
MockPlayerService *mockService;
bool deleteServiceOnRelease;
};
class tst_QMediaPlayer: public QObject
{
Q_OBJECT
@@ -425,10 +121,13 @@ private slots:
void testSetVideoOutputDestruction();
void testPositionPropertyWatch();
void debugEnums();
void testPlayerFlags();
void testDestructor();
void testSupportedMimeTypes();
private:
MockProvider *mockProvider;
MockPlayerService *mockService;
MockMediaServiceProvider *mockProvider;
MockMediaPlayerService *mockService;
QMediaPlayer *player;
};