1414 lines
46 KiB
C++
1414 lines
46 KiB
C++
/****************************************************************************
|
|
**
|
|
** 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 Mobility Components.
|
|
**
|
|
** $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$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "tst_QMediaPlayer_xa.h"
|
|
|
|
QT_USE_NAMESPACE
|
|
|
|
#define QTEST_MAIN_XA(TestObject) \
|
|
int main(int argc, char *argv[]) { \
|
|
char *new_argv[3]; \
|
|
QApplication app(argc, argv); \
|
|
\
|
|
QString str = "C:\\data\\" + QFileInfo(QCoreApplication::applicationFilePath()).baseName() + ".log"; \
|
|
QByteArray bytes = str.toAscii(); \
|
|
\
|
|
char arg1[] = "-o"; \
|
|
\
|
|
new_argv[0] = argv[0]; \
|
|
new_argv[1] = arg1; \
|
|
new_argv[2] = bytes.data(); \
|
|
\
|
|
TestObject tc; \
|
|
return QTest::qExec(&tc, 3, new_argv); \
|
|
}
|
|
|
|
#define WAIT_FOR_CONDITION(a,e) \
|
|
for (int _i = 0; _i < 500; _i += 1) { \
|
|
if ((a) == (e)) break; \
|
|
QTest::qWait(10);}
|
|
|
|
#define WAIT_FOR_EITHER_CONDITION(a,e,f) \
|
|
for (int _i = 0; _i < 500; _i += 1) { \
|
|
if (((a) == (e)) || ((a) == (f))) break; \
|
|
QTest::qWait(10);}
|
|
|
|
#define WAIT_FOR_CONDITION1(a) \
|
|
for (int _i = 0; _i < 500; _i += 1) { \
|
|
if (a) break; \
|
|
QTest::qWait(10);}
|
|
|
|
|
|
#define WAIT_LONG_FOR_CONDITION(a,e) \
|
|
for (int _i = 0; _i < 1800; _i += 1) { \
|
|
if ((a) == (e)) break; \
|
|
QTest::qWait(10);}
|
|
|
|
#define WAIT_LONG_FOR_CONDITION1(a) \
|
|
for (int _i = 0; _i < 1800; _i += 1) { \
|
|
if (a) break; \
|
|
QTest::qWait(100);}
|
|
|
|
tst_QMediaPlayer_xa::tst_QMediaPlayer_xa(): m_player(NULL), m_widget(NULL), m_windowWidget(NULL)
|
|
{
|
|
audioOnlyContent = new QMediaContent(QUrl("file:///C:/data/testfiles/test.mp3"));
|
|
videoOnlyContent = new QMediaContent(QUrl("file:///C:/data/testfiles/test_video.3gp"));
|
|
audioVideoContent = new QMediaContent(QUrl("file:///C:/data/testfiles/test.3gp"));
|
|
audioVideoAltContent = new QMediaContent(QUrl("file:///C:/data/testfiles/test_alt.3gp"));
|
|
//streamingContent = new QMediaContent(QUrl("rtsp://10.48.2.51/Copyright_Free_Test_Content/Clips/Video/3GP/176x144/h263/h263_176x144_15fps_384kbps_AAC-LC_128kbps_mono_44.1kHz.3gp"));
|
|
streamingContent3gp = new QMediaContent(QUrl("http://www.mobileplayground.co.uk/video/Crazy Frog.3gp"));
|
|
audioStreamingContent = new QMediaContent(QUrl("http://myopusradio.com:8000/easy"));
|
|
mediaContent = audioVideoContent;
|
|
}
|
|
|
|
tst_QMediaPlayer_xa::~tst_QMediaPlayer_xa()
|
|
{
|
|
delete audioOnlyContent;
|
|
delete videoOnlyContent;
|
|
delete audioVideoContent;
|
|
delete audioVideoAltContent;
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::initTestCase_data()
|
|
{
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::initTestCase()
|
|
{
|
|
m_player = new QMediaPlayer();
|
|
|
|
// Symbian back end needs coecontrol for creation.
|
|
m_widget = new QVideoWidget();
|
|
m_widget->setGeometry ( 0, 100, 350, 250 );
|
|
m_player->setVideoOutput(m_widget);
|
|
m_widget->showNormal();
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::cleanupTestCase()
|
|
{
|
|
delete m_player;
|
|
delete m_widget;
|
|
delete m_windowWidget;
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::resetPlayer()
|
|
{
|
|
delete m_player;
|
|
m_player = new QMediaPlayer();
|
|
m_player->setVideoOutput(m_widget);
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::resetPlayer_WindowControl()
|
|
{
|
|
delete m_player;
|
|
m_player = new QMediaPlayer();
|
|
|
|
if(!m_windowWidget) {
|
|
m_windowWidget = new QWidget();
|
|
m_windowWidget->showMaximized();
|
|
}
|
|
|
|
QVideoWindowControl* windowControl = (QVideoWindowControl*)(m_player->service()->requestControl(QVideoWindowControl_iid));
|
|
if (windowControl)
|
|
windowControl->setWinId(m_windowWidget->winId());
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::init()
|
|
{
|
|
qRegisterMetaType<QMediaPlayer::State>("QMediaPlayer::State");
|
|
qRegisterMetaType<QMediaPlayer::Error>("QMediaPlayer::Error");
|
|
qRegisterMetaType<QMediaPlayer::MediaStatus>("QMediaPlayer::MediaStatus");
|
|
qRegisterMetaType<QMediaContent>("QMediaContent");
|
|
updateLog("QT MediaPlayer Auto Test Cases", true);
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::cleanup()
|
|
{
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testMedia()
|
|
{
|
|
updateLog("*****testMedia");
|
|
|
|
setAudioVideoContent();
|
|
|
|
QTest::qWait(500);
|
|
QCOMPARE(m_player->media(), *mediaContent);
|
|
|
|
updateLog("*****testMedia: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testDuration()
|
|
{
|
|
updateLog("*****testDuration");
|
|
|
|
resetPlayer();
|
|
|
|
QSignalSpy spy(m_player, SIGNAL(durationChanged(qint64)));
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION1(spy.count()>0);
|
|
|
|
QVERIFY(m_player->duration() == duration);
|
|
|
|
updateLog("*****testDuration: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testPosition()
|
|
{
|
|
updateLog("*****testPosition");
|
|
resetPlayer();
|
|
|
|
qint64 position = 60000;
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
QCOMPARE(m_player->isSeekable(), true);
|
|
|
|
// preset position
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->setPosition(position);
|
|
WAIT_FOR_CONDITION(spy.count(), 1);
|
|
QCOMPARE(m_player->position(), position);
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(spy.at(0).at(0).toLongLong(), position);
|
|
}
|
|
|
|
// same pos second time
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->setPosition(position);
|
|
QCOMPARE(m_player->position(), position);
|
|
QCOMPARE(spy.count(), 0);
|
|
}
|
|
|
|
//zero pos
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->setPosition(0);
|
|
QCOMPARE(m_player->position(), qint64(0));
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(spy.at(0).at(0).toLongLong(), qint64(0));
|
|
}
|
|
|
|
//end pos
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->setPosition(duration);
|
|
QCOMPARE(m_player->position(), duration);
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(spy.at(0).at(0).toLongLong(), duration);
|
|
}
|
|
|
|
//negative pos
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->setPosition(qint64(-1));
|
|
QCOMPARE(m_player->position(), qint64(0));
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(spy.at(0).at(0).toLongLong(), qint64(0));
|
|
}
|
|
|
|
//over duration
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->setPosition(duration+1);
|
|
QCOMPARE(m_player->position(), duration);
|
|
QCOMPARE(spy.count(), 1);
|
|
QCOMPARE(spy.at(0).at(0).toLongLong(), duration);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testPositionWhilePlaying()
|
|
{
|
|
updateLog("*****testPositionWhilePlaying");
|
|
resetPlayer();
|
|
|
|
qint64 position = 60000;
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
// preset position
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
m_player->setPosition(position);
|
|
WAIT_FOR_CONDITION1(spy.count()>0);
|
|
QVERIFY(m_player->mediaStatus() == QMediaPlayer::BufferingMedia || m_player->mediaStatus() == QMediaPlayer::BufferedMedia);
|
|
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QVERIFY(m_player->position()>=position);
|
|
QVERIFY(spy.count()!=0);
|
|
}
|
|
|
|
//reset position
|
|
m_player->stop();
|
|
m_player->setPosition(position);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
//zero pos
|
|
{ QSignalSpy spy(m_player, SIGNAL(positionChanged(qint64)));
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
m_player->setPosition(0);
|
|
WAIT_FOR_CONDITION1(spy.count()>0);
|
|
QVERIFY(m_player->mediaStatus() == QMediaPlayer::BufferingMedia ||
|
|
m_player->mediaStatus() == QMediaPlayer::BufferedMedia);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QVERIFY(m_player->position() >= qint64(0));
|
|
QVERIFY(spy.count()!=0);
|
|
}
|
|
|
|
//reset position
|
|
m_player->stop();
|
|
m_player->setPosition(position);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testPositionWhilePlaying: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testVolume()
|
|
{
|
|
updateLog("*****testVolume");
|
|
|
|
int volume = 20;
|
|
|
|
// preset volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(volume);
|
|
QCOMPARE(m_player->volume(), volume);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// same volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
int currentVolume = m_player->volume();
|
|
m_player->setVolume(currentVolume);
|
|
QCOMPARE(m_player->volume(), currentVolume);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 0);
|
|
}
|
|
|
|
// zero volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(0);
|
|
QCOMPARE(m_player->volume(), 0);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// max volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(100);
|
|
QCOMPARE(m_player->volume(), 100);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// negative volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(int(-1));
|
|
QCOMPARE(m_player->volume(), 0);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// over max volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(1000);
|
|
QCOMPARE(m_player->volume(), 100);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
updateLog("*****testVolume: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testVolumeWhilePlaying()
|
|
{
|
|
updateLog("*****testVideoAndAudioAvailability");
|
|
resetPlayer();
|
|
|
|
int volume = 20;
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
|
|
m_player->play();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
// preset volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(volume);
|
|
QCOMPARE(m_player->volume(), volume);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// same volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
int currentVolume = m_player->volume();
|
|
m_player->setVolume(currentVolume);
|
|
QCOMPARE(m_player->volume(), currentVolume);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 0);
|
|
}
|
|
|
|
// zero volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(0);
|
|
QCOMPARE(m_player->volume(), 0);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// max volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(100);
|
|
QCOMPARE(m_player->volume(), 100);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// negative volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(int(-1));
|
|
QCOMPARE(m_player->volume(), 0);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
// over max volume
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setVolume(1000);
|
|
QCOMPARE(m_player->volume(), 100);
|
|
QCOMPARE(m_player->isMuted(), false);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testVideoAndAudioAvailability: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testMuted()
|
|
{
|
|
updateLog("*****testMuted");
|
|
|
|
int volume = 20;
|
|
|
|
//reset mute & volume
|
|
m_player->setMuted(false);
|
|
m_player->setVolume(0);
|
|
QVERIFY(m_player->isMuted() == false);
|
|
QCOMPARE(m_player->volume(), 0);
|
|
|
|
// set muted
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));
|
|
m_player->setMuted(true);
|
|
QCOMPARE(spy.count(), 1);
|
|
QVERIFY(m_player->isMuted() == true);
|
|
}
|
|
|
|
// set muted again
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));
|
|
m_player->setMuted(true);
|
|
QCOMPARE(spy.count(), 0);
|
|
QVERIFY(m_player->isMuted() == true);
|
|
}
|
|
|
|
// unmute
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));
|
|
m_player->setMuted(false);
|
|
QCOMPARE(spy.count(), 1);
|
|
QVERIFY(m_player->isMuted() == false);
|
|
}
|
|
|
|
// set volume while muted
|
|
{
|
|
QSignalSpy muteSpy(m_player, SIGNAL(mutedChanged(bool)));
|
|
QSignalSpy volumeSpy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setMuted(true);
|
|
m_player->setVolume(volume);
|
|
QCOMPARE(m_player->volume(), volume);
|
|
QCOMPARE(muteSpy.count(), 1);
|
|
QCOMPARE(volumeSpy.count(), 1);
|
|
QVERIFY(m_player->isMuted() == true);
|
|
}
|
|
|
|
updateLog("*****testMuted: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testMutedWhilePlaying()
|
|
{
|
|
updateLog("*****testMutedWhilePlaying");
|
|
resetPlayer();
|
|
|
|
int volume = 20;
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
|
|
//reset mute & volume
|
|
m_player->setMuted(false);
|
|
m_player->setVolume(65);
|
|
QVERIFY(m_player->isMuted() == false);
|
|
QCOMPARE(m_player->volume(), 65);
|
|
|
|
m_player->play();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
// set muted
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));
|
|
m_player->setMuted(true);
|
|
QCOMPARE(spy.count(), 1);
|
|
QVERIFY(m_player->isMuted() == true);
|
|
}
|
|
|
|
// set muted again
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));
|
|
m_player->setMuted(true);
|
|
QCOMPARE(spy.count(), 0);
|
|
QVERIFY(m_player->isMuted() == true);
|
|
}
|
|
|
|
// unmute
|
|
{
|
|
QSignalSpy spy(m_player, SIGNAL(mutedChanged(bool)));
|
|
m_player->setMuted(false);
|
|
QCOMPARE(spy.count(), 1);
|
|
QVERIFY(m_player->isMuted() == false);
|
|
}
|
|
|
|
// set volume while muted
|
|
{
|
|
QSignalSpy muteSpy(m_player, SIGNAL(mutedChanged(bool)));
|
|
QSignalSpy volumeSpy(m_player, SIGNAL(volumeChanged(int)));
|
|
m_player->setMuted(true);
|
|
m_player->setVolume(volume);
|
|
QCOMPARE(m_player->volume(), volume);
|
|
QCOMPARE(muteSpy.count(), 1);
|
|
QCOMPARE(volumeSpy.count(), 1);
|
|
QVERIFY(m_player->isMuted() == true);
|
|
}
|
|
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
|
|
updateLog("*****testMutedWhilePlaying: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testVideoAndAudioAvailability()
|
|
{
|
|
updateLog("*****testVideoAndAudioAvailability");
|
|
resetPlayer();
|
|
|
|
QList<QVariant> arguments;
|
|
|
|
|
|
setVideoOnlyContent();
|
|
|
|
|
|
QSignalSpy audioAvailableSpy(m_player, SIGNAL(audioAvailableChanged(bool)));
|
|
QSignalSpy videoAvailableSpy(m_player, SIGNAL(videoAvailableChanged(bool)));
|
|
|
|
setAudioOnlyContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
updateLog("SetMedia: audioOnlyContent");
|
|
WAIT_FOR_CONDITION(m_player->isAudioAvailable(), true);
|
|
updateLog("\t isAudioAvailable() == true");
|
|
QVERIFY(m_player->isVideoAvailable() == false);
|
|
updateLog("\t isVideoAvailable() == false");
|
|
QCOMPARE(audioAvailableSpy.count(), 1);
|
|
arguments = audioAvailableSpy.takeFirst();
|
|
QVERIFY(arguments.at(0).toBool() == true);
|
|
updateLog("\t audioAvailableChanged(true)");
|
|
QCOMPARE(videoAvailableSpy.count(), 1);
|
|
arguments = videoAvailableSpy.takeFirst();
|
|
QVERIFY(arguments.at(0).toBool() == false);
|
|
updateLog("\t videoAvailableChanged(false)");
|
|
|
|
setVideoOnlyContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
updateLog("SetMedia: videoOnlyContent");
|
|
WAIT_FOR_CONDITION(m_player->isVideoAvailable(), true);
|
|
updateLog("\t isVideoAvailable() == true");
|
|
QVERIFY(m_player->isAudioAvailable() == false);
|
|
updateLog("\t isAudioAvailable() == false");
|
|
QCOMPARE(audioAvailableSpy.count(), 1);
|
|
arguments = audioAvailableSpy.takeFirst();
|
|
QVERIFY(arguments.at(0).toBool() == false);
|
|
updateLog("\t audioAvailableChanged(false)");
|
|
QCOMPARE(videoAvailableSpy.count(), 1);
|
|
arguments = videoAvailableSpy.takeFirst();
|
|
QVERIFY(arguments.at(0).toBool() == true);
|
|
updateLog("\t videoAvailableChanged(true)");
|
|
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
updateLog("SetMedia: audioVideoContent");
|
|
WAIT_FOR_CONDITION(m_player->isAudioAvailable(), true);
|
|
updateLog("\t isAudioAvailable() == true");
|
|
QCOMPARE(audioAvailableSpy.count(), 1);
|
|
arguments = audioAvailableSpy.takeFirst();
|
|
QVERIFY(arguments.at(0).toBool() == true);
|
|
updateLog("\t audioAvailableChanged(true)");
|
|
QCOMPARE(videoAvailableSpy.count(), 0);
|
|
|
|
updateLog("*****testVideoAndAudioAvailability: PASSED");
|
|
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testStreamInformation()
|
|
{
|
|
updateLog("*****testStreamInformation");
|
|
resetPlayer();
|
|
QMediaStreamsControl* m_streamControl = (QMediaStreamsControl*)(m_player->service()->requestControl(QMediaStreamsControl_iid));
|
|
setVideoOnlyContent();
|
|
|
|
if(m_streamControl)
|
|
{
|
|
{
|
|
QSignalSpy streamInfoSpy(m_streamControl, SIGNAL(streamsChanged()));
|
|
setAudioOnlyContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_streamControl->streamCount() == 1);
|
|
QCOMPARE(streamInfoSpy.count(), 1);
|
|
}
|
|
|
|
{
|
|
QSignalSpy streamInfoSpy(m_streamControl, SIGNAL(streamsChanged()));
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_streamControl->streamCount() == 2);
|
|
QCOMPARE(streamInfoSpy.count(), 1);
|
|
}
|
|
|
|
{
|
|
QSignalSpy streamInfoSpy(m_streamControl, SIGNAL(streamsChanged()));
|
|
setAudioVideoContent(); //set alternate content
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_streamControl->streamCount() == 2);
|
|
QCOMPARE(streamInfoSpy.count(), 1);
|
|
}
|
|
|
|
{
|
|
QSignalSpy streamInfoSpy(m_streamControl, SIGNAL(streamsChanged()));
|
|
setVideoOnlyContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_streamControl->streamCount() == 1);
|
|
QCOMPARE(streamInfoSpy.count(), 1);
|
|
}
|
|
|
|
updateLog("*****testStreamInformation: PASSED");
|
|
}
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testPlay()
|
|
{
|
|
updateLog("*****testPlay");
|
|
resetPlayer();
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_player->media() == *mediaContent);
|
|
QSignalSpy spy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->play();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
|
|
//Play->Play
|
|
{
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->play();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QCOMPARE(stateSpy.count(), 0);
|
|
}
|
|
|
|
//Play->Pause
|
|
{
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->pause();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
QCOMPARE(stateSpy.count(), 1);
|
|
}
|
|
|
|
//Play->Stop
|
|
{
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE(stateSpy.count(), 1);
|
|
}
|
|
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testPlay: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testPause()
|
|
{
|
|
updateLog("*****testPause");
|
|
resetPlayer();
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_player->media() == *mediaContent);
|
|
QSignalSpy spy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->pause();
|
|
// at present there is no support for stop->pause state transition. TODO: uncomment when support added
|
|
//QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
//QCOMPARE(spy.count(), 1);
|
|
|
|
//Pause->Play
|
|
{
|
|
//QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->play();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QCOMPARE(stateSpy.count(), 1);
|
|
}
|
|
|
|
//Pause->Pause
|
|
{
|
|
m_player->pause();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->pause();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
QCOMPARE(stateSpy.count(), 0);
|
|
}
|
|
|
|
//Pause->Stop
|
|
{
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE(stateSpy.count(), 1);
|
|
}
|
|
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testPause: PASSED");
|
|
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testStop()
|
|
{
|
|
updateLog("*****testStop");
|
|
resetPlayer();
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_player->media() == *mediaContent);
|
|
|
|
QSignalSpy spy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->stop();
|
|
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE(spy.count(), 0);
|
|
|
|
//Stop->Play
|
|
{
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->play();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
QCOMPARE(stateSpy.count(), 1);
|
|
}
|
|
// at present there is no support for stop->pause state transition. TODO: uncomment when support added
|
|
//Stop->Pause
|
|
/* {
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->pause();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PausedState);
|
|
QCOMPARE(stateSpy.count(), 1);
|
|
}
|
|
*/
|
|
//Stop->Stop
|
|
{
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QSignalSpy stateSpy(m_player, SIGNAL(stateChanged(QMediaPlayer::State)));
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE(stateSpy.count(), 0);
|
|
}
|
|
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testStop: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testMediaStatus()
|
|
{
|
|
updateLog("*****testMediaStatus");
|
|
resetPlayer();
|
|
|
|
QSignalSpy statusSpy(m_player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(statusSpy.count()>0);
|
|
|
|
{
|
|
QSignalSpy statusSpy(m_player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QVERIFY(statusSpy.count()>0);
|
|
}
|
|
|
|
{
|
|
QSignalSpy statusSpy(m_player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
|
|
m_player->setPosition(duration - 10);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);
|
|
QVERIFY(statusSpy.count()>0);
|
|
}
|
|
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testMediaStatus: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testBufferStatus()
|
|
{
|
|
updateLog("*****testBufferStatus");
|
|
resetPlayer();
|
|
m_player->setNotifyInterval(50); //Since default interval is 1 sec,could not receive any bufferStatusChanged SIGNAL,hence checking for 50milliseconds
|
|
QSignalSpy spy(m_player, SIGNAL(bufferStatusChanged(int)));
|
|
// setStreamingContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
WAIT_FOR_CONDITION(m_player->bufferStatus(), 100);
|
|
QVERIFY(spy.count()>0);
|
|
updateLog("*****testBufferStatus: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testPlaybackRate()
|
|
{
|
|
updateLog("*****testPlaybackRate");
|
|
|
|
resetPlayer();
|
|
|
|
qreal playbackRate = 1.5;
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
|
|
m_player->setPlaybackRate(playbackRate);
|
|
QVERIFY(m_player->playbackRate() == playbackRate);
|
|
|
|
QSignalSpy spy(m_player, SIGNAL(playbackRateChanged(qreal)));
|
|
m_player->setPlaybackRate(playbackRate + 0.5f);
|
|
QCOMPARE(m_player->playbackRate(), playbackRate + 0.5f);
|
|
QCOMPARE(spy.count(), 1);
|
|
|
|
updateLog("*****testPlaybackRate: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testPlaybackRateWhilePlaying()
|
|
{
|
|
updateLog("*****testPlaybackRateWhilePlaying");
|
|
resetPlayer();
|
|
|
|
qreal playbackRate = 1.5;
|
|
|
|
setAudioVideoContent();
|
|
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
m_player->setPlaybackRate(playbackRate);
|
|
QVERIFY(m_player->playbackRate() == playbackRate);
|
|
|
|
QSignalSpy spy(m_player, SIGNAL(playbackRateChanged(qreal)));
|
|
m_player->setPlaybackRate(playbackRate + 0.5f);
|
|
QCOMPARE(m_player->playbackRate(), playbackRate + 0.5f);
|
|
QCOMPARE(spy.count(), 1);
|
|
|
|
updateLog("*****testPlaybackRateWhilePlaying: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testSeekable()
|
|
{
|
|
updateLog("*****testBufferStatus");
|
|
resetPlayer();
|
|
QSignalSpy spy(m_player, SIGNAL(seekableChanged(bool)));
|
|
setAudioVideoContent();
|
|
qint64 position = 1000;
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_player->isSeekable()==true);
|
|
m_player->setPosition(position);
|
|
QCOMPARE(spy.count(), 0);
|
|
QVERIFY(m_player->isSeekable()==true);
|
|
|
|
updateLog("*****testBufferStatus: PASSED");
|
|
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testAspectRatioMode()
|
|
{
|
|
updateLog("*****testBufferStatus");
|
|
resetPlayer();
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVideoWidgetControl* m_videoWidgetControl = (QVideoWidgetControl*)(m_player->service()->requestControl(QVideoWidgetControl_iid));
|
|
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
QCOMPARE(m_videoWidgetControl->aspectRatioMode(), Qt::KeepAspectRatio); //default
|
|
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
|
|
{
|
|
m_videoWidgetControl->setAspectRatioMode(Qt::IgnoreAspectRatio);
|
|
QCOMPARE(m_videoWidgetControl->aspectRatioMode(), Qt::IgnoreAspectRatio);
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
}
|
|
|
|
{
|
|
m_videoWidgetControl->setAspectRatioMode(Qt::KeepAspectRatioByExpanding);
|
|
QCOMPARE(m_videoWidgetControl->aspectRatioMode(), Qt::KeepAspectRatioByExpanding);
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
}
|
|
{
|
|
m_videoWidgetControl->setAspectRatioMode(Qt::KeepAspectRatio);
|
|
QCOMPARE(m_videoWidgetControl->aspectRatioMode(), Qt::KeepAspectRatio);
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
}
|
|
|
|
updateLog("*****testBufferStatus: PASSED");
|
|
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testFullScreen()
|
|
{
|
|
updateLog("*****testFullScreen");
|
|
resetPlayer();
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVideoWidgetControl* m_videoWidgetControl = (QVideoWidgetControl*)(m_player->service()->requestControl(QVideoWidgetControl_iid));
|
|
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
//m_widget->resize(50, 50);
|
|
m_widget->showNormal();
|
|
QTest::qWait(10000); //wait for 5 seconds
|
|
|
|
|
|
if(m_videoWidgetControl)
|
|
{
|
|
QSignalSpy spy(m_videoWidgetControl, SIGNAL(fullScreenChanged(bool)));
|
|
m_videoWidgetControl->setFullScreen(true);
|
|
QTest::qWait(10000); //wait for 5 seconds
|
|
QCOMPARE(m_videoWidgetControl->isFullScreen(), true);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
|
|
if(m_videoWidgetControl)
|
|
{
|
|
QSignalSpy spy(m_videoWidgetControl, SIGNAL(fullScreenChanged(bool)));
|
|
m_videoWidgetControl->setFullScreen(false);
|
|
QCOMPARE(m_videoWidgetControl->isFullScreen(), false);
|
|
QTest::qWait(10000); //wait for 5 seconds
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
updateLog("*****testFullScreen: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testWindowControl_NativeSize()
|
|
{
|
|
updateLog("*****testWindowControl_NativeSize");
|
|
resetPlayer_WindowControl();
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVERIFY(m_player->media() == *mediaContent);
|
|
m_player->play();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
QVideoWindowControl* windowControl = (QVideoWindowControl*)(m_player->service()->requestControl(QVideoWindowControl_iid));
|
|
if (windowControl)
|
|
{
|
|
QSize size = windowControl->nativeSize();
|
|
}
|
|
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
updateLog("*****testWindowControl_NativeSize: PASSED");
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testWindowControl_AspectRatioMode()
|
|
{
|
|
updateLog("*****testWindowControl_AspectRatioMode");
|
|
resetPlayer_WindowControl();
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVideoWindowControl* windowControl = (QVideoWindowControl*)(m_player->service()->requestControl(QVideoWindowControl_iid));
|
|
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
QCOMPARE(windowControl->aspectRatioMode(), Qt::KeepAspectRatio); //default
|
|
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
|
|
{
|
|
windowControl->setAspectRatioMode(Qt::IgnoreAspectRatio);
|
|
QCOMPARE(windowControl->aspectRatioMode(), Qt::IgnoreAspectRatio);
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
}
|
|
|
|
{
|
|
windowControl->setAspectRatioMode(Qt::KeepAspectRatioByExpanding);
|
|
QCOMPARE(windowControl->aspectRatioMode(), Qt::KeepAspectRatioByExpanding);
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
}
|
|
{
|
|
windowControl->setAspectRatioMode(Qt::KeepAspectRatio);
|
|
QCOMPARE(windowControl->aspectRatioMode(), Qt::KeepAspectRatio);
|
|
QTest::qWait(5000); //wait for 5 seconds
|
|
}
|
|
|
|
updateLog("*****testWindowControl_AspectRatioMode: PASSED");
|
|
|
|
}
|
|
|
|
void tst_QMediaPlayer_xa::testWindowControl_FullScreen()
|
|
{
|
|
updateLog("*****testWindowControl_FullScreen");
|
|
resetPlayer_WindowControl();
|
|
setAudioVideoContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QVideoWindowControl* windowControl = (QVideoWindowControl*)(m_player->service()->requestControl(QVideoWindowControl_iid));
|
|
|
|
m_player->play();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
|
|
//m_windowWidget->resize(250, 350);
|
|
m_windowWidget->showNormal();
|
|
QTest::qWait(10000); //wait for 5 seconds
|
|
|
|
if(windowControl)
|
|
{
|
|
QSignalSpy spy(windowControl, SIGNAL(fullScreenChanged(bool)));
|
|
windowControl->setFullScreen(true);
|
|
QTest::qWait(10000); //wait for 5 seconds
|
|
QCOMPARE(windowControl->isFullScreen(), true);
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
|
|
if(windowControl)
|
|
{
|
|
QSignalSpy spy(windowControl, SIGNAL(fullScreenChanged(bool)));
|
|
windowControl->setFullScreen(false);
|
|
QCOMPARE(windowControl->isFullScreen(), false);
|
|
QTest::qWait(10000); //wait for 5 seconds
|
|
QCOMPARE(spy.count(), 1);
|
|
}
|
|
|
|
updateLog("*****testWindowControl_FullScreen: PASSED");
|
|
}
|
|
|
|
|
|
//adding access-point testcase
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testSetconfigurationsAP()
|
|
{
|
|
updateLog("*****testSetconfigurationsAP");
|
|
resetPlayer();
|
|
|
|
//Passing only valid Accesspoint in QList
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
for (int i=0; i<=accesspointlist.size()-1;i++)
|
|
qDebug()<<"accesspointlist"<< accesspointlist.at(i).name();
|
|
configs<<accesspointlist.at(8);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
setStreamingContent3gp();
|
|
m_player->play();
|
|
QTest::qWait(100000);
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(8).name());
|
|
updateLog("*****testSetconfigurationsAP: PASSED");
|
|
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testSetAccesspoint()
|
|
{
|
|
updateLog("*****testSetAccesspoint");
|
|
resetPlayer();
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(0);
|
|
configs<<accesspointlist.at(3);
|
|
configs<<accesspointlist.at(10);
|
|
configs<<accesspointlist.at(8);
|
|
//Passing only valid Accesspoint in QList
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
|
|
setStreamingContent3gp();
|
|
QTest::qWait(200000);
|
|
m_player->play();
|
|
QTest::qWait(10000);
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(8).name());
|
|
|
|
updateLog("*****testSetAccesspoint: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testGetAccesspoint()
|
|
{
|
|
updateLog("*****testGetAccesspoint");
|
|
resetPlayer();
|
|
//getting information about the current configured accesspoint without setting any configurations
|
|
QNetworkConfiguration getaccespoint;
|
|
getaccespoint = m_player->currentNetworkConfiguration();
|
|
QCOMPARE(getaccespoint.name(),QString(""));
|
|
updateLog("*****testGetAccesspoint: ");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testDiffmediacontentAP()
|
|
{
|
|
updateLog("*****streaming Different mediacontent files via AP");
|
|
resetPlayer();
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(8);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
//first mediacontent file
|
|
setAudioStreamingContent();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
QTest::qWait(30000);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
//second mediacontent file
|
|
setStreamingContent3gp();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
QTest::qWait(20000);
|
|
QCOMPARE(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(8).name());
|
|
QNetworkConfiguration getaccespoint;
|
|
getaccespoint = m_player->currentNetworkConfiguration();
|
|
QCOMPARE(getaccespoint.name(), QString("MMMW"));
|
|
|
|
updateLog("*****testDiffmediacontentAP: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testInvalidaddressAP()
|
|
{
|
|
updateLog("*****testInvalidaddressAP");
|
|
resetPlayer();
|
|
//setting all invalid accesspoint
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(0);
|
|
configs<<accesspointlist.at(2);
|
|
configs<<accesspointlist.at(3);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
QNetworkConfiguration getaccespoint;
|
|
getaccespoint = m_player->currentNetworkConfiguration();
|
|
QCOMPARE(getaccespoint.name(), QString(""));
|
|
|
|
updateLog("*****testInvalidaddressAP: PASSED");
|
|
}
|
|
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testMultipleAccesspoints()
|
|
{
|
|
updateLog("*****testMultipleAccesspoints");
|
|
resetPlayer();
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(8);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
setStreamingContent3gp();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QTest::qWait(20000);
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(8).name());
|
|
//Second configuration list
|
|
QList<QNetworkConfiguration> secconfigs;
|
|
secaccesspoint = manager.allConfigurations();
|
|
secconfigs<<secaccesspoint.at(5);
|
|
QSignalSpy spy1(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(secconfigs);
|
|
setStreamingContent3gp();
|
|
// setAudioStreamingContent();
|
|
QTest::qWait(30000);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QTest::qWait(10000);
|
|
updateLog("*****testSetAccesspoint: PASSED");
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(5).name());
|
|
QNetworkConfiguration getaccespoint;
|
|
getaccespoint = m_player->currentNetworkConfiguration();
|
|
QCOMPARE(getaccespoint.name(), QString("Mobile Office"));
|
|
|
|
updateLog("*****testMultipleAccesspoints: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testReconnectAPWhilestreaming()
|
|
{
|
|
updateLog("*****testReconnectAPWhilestreaming");
|
|
resetPlayer();
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(15);
|
|
configs<<accesspointlist.at(12);
|
|
configs<<accesspointlist.at(0);
|
|
configs<<accesspointlist.at(8);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
setAudioStreamingContent();
|
|
m_player->play();
|
|
QTest::qWait(200000);
|
|
configs<<accesspointlist.at(5);
|
|
m_player->setNetworkConfigurations(configs);
|
|
m_player->play();
|
|
QTest::qWait(20000);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::EndOfMedia);
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(8).name());
|
|
QNetworkConfiguration getaccespoint;
|
|
getaccespoint = m_player->currentNetworkConfiguration();
|
|
QCOMPARE(getaccespoint.name(), QString("MMMW"));
|
|
updateLog("*****testReconnectAPWhilestreaming: PASSED");
|
|
}
|
|
|
|
|
|
void tst_QMediaPlayer_xa::teststreampausestream()
|
|
{
|
|
updateLog("*****teststreampausestream");
|
|
resetPlayer();
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(8);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
setStreamingContent3gp();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QTest::qWait(10000);
|
|
m_player->pause();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PausedState);
|
|
|
|
//Setting up the accesspoint when the player is in paused state
|
|
QList<QNetworkConfiguration> secconfigs;
|
|
secaccesspoint = manager.allConfigurations();
|
|
secconfigs<<secaccesspoint.at(5);
|
|
m_player->setNetworkConfigurations(secconfigs);
|
|
m_player->play();
|
|
QTest::qWait(20000);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
QCOMPARE((m_player->currentNetworkConfiguration()).name(), accesspointlist.at(8).name());
|
|
m_player->stop();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::StoppedState);
|
|
setStreamingContent3gp();
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
QCOMPARE(m_player->mediaStatus(), QMediaPlayer::LoadedMedia);
|
|
m_player->play();
|
|
QTest::qWait(20000);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
m_player->stop();
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(5).name());
|
|
|
|
updateLog("*****teststreampausestream: PASSED");
|
|
}
|
|
|
|
|
|
|
|
void tst_QMediaPlayer_xa::testStressAccessPoint()
|
|
{
|
|
updateLog("*****testStressAccessPoint");
|
|
resetPlayer();
|
|
for (int i=0; i<=50; i++) {
|
|
QList<QNetworkConfiguration> configs;
|
|
accesspointlist = manager.allConfigurations();
|
|
configs<<accesspointlist.at(8);
|
|
QSignalSpy spy(m_player, SIGNAL(networkConfigurationChanged(const QNetworkConfiguration&)));
|
|
m_player->setNetworkConfigurations(configs);
|
|
setStreamingContent3gp();
|
|
m_player->play();
|
|
QTest::qWait(20000);
|
|
WAIT_LONG_FOR_CONDITION(m_player->state(), QMediaPlayer::PlayingState);
|
|
WAIT_FOR_CONDITION(m_player->mediaStatus(), QMediaPlayer::BufferedMedia);
|
|
m_player->stop();
|
|
QCOMPARE(m_player->state(), QMediaPlayer::StoppedState);
|
|
QCOMPARE((m_player->currentNetworkConfiguration().name()), accesspointlist.at(8).name());
|
|
resetPlayer();
|
|
}
|
|
|
|
updateLog("*****testStressAccessPoint: PASSED");
|
|
}
|
|
|
|
|
|
|
|
void tst_QMediaPlayer_xa::updateLog(QString log, bool delFile)
|
|
{
|
|
QString logFileName = "C:\\data\\" + QFileInfo(QCoreApplication::applicationFilePath()).baseName() + "_detailed.log";
|
|
if(delFile)
|
|
{
|
|
QFile::remove(logFileName);
|
|
}
|
|
|
|
QFile f(logFileName);
|
|
|
|
if( !f.open( QIODevice::WriteOnly | QIODevice::Append ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
QTextStream ts( &f );
|
|
|
|
ts<<log<<"\n";
|
|
|
|
f.close();
|
|
}
|