slapin/qtmultimedia
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
680cc0c97431de03487206fee575fa89c24b8842
qtmultimedia/tests/auto/unit/qradiotuner/tst_qradiotuner.cpp
Antti Kokko bbfccc7135 Update copyright headers 
Qt copyrights are now in The Qt Company, so we could update the source
code headers accordingly. In the same go we should also fix the links to
point to qt.io.

Change-Id: I1c6faa4f59f8eca54f01ef20941fa60161dd7872
Reviewed-by: Yoann Lopes <yoann.lopes@theqtcompany.com>
2015-02-12 10:27:47 +00:00

394 lines
13 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** As a special exception, The Qt Company gives you certain additional
** rights. These rights are described in The Qt Company LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/
//TESTED_COMPONENT=src/multimedia
#include <QtTest/QtTest>
#include <QDebug>
#include <QTimer>
#include <QtCore/QMap>
#include <qmediaobject.h>
#include <qmediacontrol.h>
#include <qmediaservice.h>
#include <qradiotunercontrol.h>
#include <qradiotuner.h>
#include "mockmediaserviceprovider.h"
#include "mockmediaservice.h"
#include "mockradiotunercontrol.h"
#include "mockavailabilitycontrol.h"
QT_USE_NAMESPACE
class tst_QRadioTuner: public QObject
{
Q_OBJECT
public slots:
void initTestCase();
void cleanupTestCase();
void init();
private slots:
void testNullService();
void testNullControl();
void testBand();
void testFrequency();
void testMute();
void testSearch();
void testVolume();
void testSignal();
void testStereo();
void testSearchAllStations();
void errorSignal();
private:
MockRadioTunerControl *mock;
MockAvailabilityControl *mockAvailability;
MockMediaService *service;
MockMediaServiceProvider *provider;
QRadioTuner *radio;
};
void tst_QRadioTuner::initTestCase()
{
qRegisterMetaType<QRadioTuner::State>("QRadioTuner::State");
qRegisterMetaType<QRadioTuner::Band>("QRadioTuner::Band");
mock = new MockRadioTunerControl(this);
mockAvailability = new MockAvailabilityControl(QMultimedia::Available);
QMap<QString, QMediaControl *> map;
map.insert(QRadioTunerControl_iid, mock);
map.insert(QMediaAvailabilityControl_iid, mockAvailability);
service = new MockMediaService(this, map);
provider = new MockMediaServiceProvider(service);
QMediaServiceProvider::setDefaultServiceProvider(provider);
radio = new QRadioTuner;
QVERIFY(radio->service() != 0);
QVERIFY(radio->isAvailable());
QVERIFY(radio->availability() == QMultimedia::Available);
QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
QCOMPARE(radio->state(), QRadioTuner::StoppedState);
radio->start();
QVERIFY(radio->availability() == QMultimedia::Available);
QCOMPARE(radio->state(), QRadioTuner::ActiveState);
QCOMPARE(stateSpy.count(), 1);
QCOMPARE(stateSpy.first()[0].value<QRadioTuner::State>(), QRadioTuner::ActiveState);
}
void tst_QRadioTuner::cleanupTestCase()
{
QVERIFY(radio->error() == QRadioTuner::NoError);
QVERIFY(radio->errorString().isEmpty());
QSignalSpy stateSpy(radio, SIGNAL(stateChanged(QRadioTuner::State)));
radio->stop();
QVERIFY(radio->availability() == QMultimedia::Available);
QCOMPARE(radio->state(), QRadioTuner::StoppedState);
QCOMPARE(stateSpy.count(), 1);
QCOMPARE(stateSpy.first()[0].value<QRadioTuner::State>(), QRadioTuner::StoppedState);
delete radio;
delete service;
delete provider;
delete mockAvailability;
}
void tst_QRadioTuner::init()
{
QMediaServiceProvider::setDefaultServiceProvider(provider);
}
void tst_QRadioTuner::testNullService()
{
const QPair<int, int> nullRange(0, 0);
MockMediaServiceProvider provider(0);
QMediaServiceProvider::setDefaultServiceProvider(&provider);
QRadioTuner radio;
QVERIFY(!radio.isAvailable());
radio.start();
QCOMPARE(radio.error(), QRadioTuner::ResourceError);
QCOMPARE(radio.errorString(), QString());
QCOMPARE(radio.band(), QRadioTuner::FM);
QCOMPARE(radio.isBandSupported(QRadioTuner::AM), false);
QCOMPARE(radio.isBandSupported(QRadioTuner::FM), false);
QCOMPARE(radio.frequency(), 0);
QCOMPARE(radio.frequencyStep(QRadioTuner::AM), 0);
QCOMPARE(radio.frequencyStep(QRadioTuner::FM), 0);
QCOMPARE(radio.frequencyRange(QRadioTuner::AM), nullRange);
QCOMPARE(radio.frequencyRange(QRadioTuner::FM), nullRange);
QCOMPARE(radio.isStereo(), false);
QCOMPARE(radio.stereoMode(), QRadioTuner::Auto);
QCOMPARE(radio.signalStrength(), 0);
QCOMPARE(radio.volume(), 0);
QCOMPARE(radio.isMuted(), false);
QCOMPARE(radio.isSearching(), false);
radio.stop();
}
void tst_QRadioTuner::testNullControl()
{
const QPair<int, int> nullRange(0, 0);
MockMediaService service(0, 0);
MockMediaServiceProvider provider(&service);
QMediaServiceProvider::setDefaultServiceProvider(&provider);
QRadioTuner radio;
QVERIFY(!radio.isAvailable());
radio.start();
QCOMPARE(radio.error(), QRadioTuner::ResourceError);
QCOMPARE(radio.errorString(), QString());
QCOMPARE(radio.band(), QRadioTuner::FM);
QCOMPARE(radio.isBandSupported(QRadioTuner::AM), false);
QCOMPARE(radio.isBandSupported(QRadioTuner::FM), false);
QCOMPARE(radio.frequency(), 0);
QCOMPARE(radio.frequencyStep(QRadioTuner::AM), 0);
QCOMPARE(radio.frequencyStep(QRadioTuner::FM), 0);
QCOMPARE(radio.frequencyRange(QRadioTuner::AM), nullRange);
QCOMPARE(radio.frequencyRange(QRadioTuner::FM), nullRange);
{
QSignalSpy bandSpy(&radio, SIGNAL(bandChanged(QRadioTuner::Band)));
QSignalSpy frequencySpy(&radio, SIGNAL(frequencyChanged(int)));
radio.setFrequency(107500);
QCOMPARE(radio.band(), QRadioTuner::FM);
QCOMPARE(radio.frequency(), 0);
QCOMPARE(bandSpy.count(), 0);
QCOMPARE(frequencySpy.count(), 0);
radio.setBand(QRadioTuner::AM);
QCOMPARE(radio.band(), QRadioTuner::FM);
QCOMPARE(radio.frequency(), 0);
QCOMPARE(bandSpy.count(), 0);
QCOMPARE(frequencySpy.count(), 0);
}
QCOMPARE(radio.isStereo(), false);
QCOMPARE(radio.stereoMode(), QRadioTuner::Auto);
radio.setStereoMode(QRadioTuner::ForceStereo);
QCOMPARE(radio.stereoMode(), QRadioTuner::Auto);
QCOMPARE(radio.signalStrength(), 0);
QCOMPARE(radio.volume(), 0);
QCOMPARE(radio.isMuted(), false);
{
QSignalSpy volumeSpy(&radio, SIGNAL(volumeChanged(int)));
QSignalSpy muteSpy(&radio, SIGNAL(mutedChanged(bool)));
radio.setVolume(76);
QCOMPARE(radio.volume(), 0);
QCOMPARE(volumeSpy.count(), 0);
radio.setMuted(true);
QCOMPARE(radio.isMuted(), false);
QCOMPARE(muteSpy.count(), 0);
}
QCOMPARE(radio.isSearching(), false);
{
QSignalSpy spy(&radio, SIGNAL(searchingChanged(bool)));
radio.searchBackward();
QCOMPARE(radio.isSearching(), false);
QCOMPARE(spy.count(), 0);
radio.searchForward();
QCOMPARE(radio.isSearching(), false);
QCOMPARE(spy.count(), 0);
radio.searchAllStations();
QCOMPARE(radio.isSearching(), false);
QCOMPARE(spy.count(), 0);
radio.cancelSearch();
QCOMPARE(radio.isSearching(), false);
QCOMPARE(spy.count(), 0);
}
radio.stop();
}
void tst_QRadioTuner::testBand()
{
QVERIFY(radio->isBandSupported(QRadioTuner::FM));
QVERIFY(!radio->isBandSupported(QRadioTuner::SW));
if(radio->isBandSupported(QRadioTuner::AM)) {
QSignalSpy readSignal(radio, SIGNAL(bandChanged(QRadioTuner::Band)));
radio->setBand(QRadioTuner::AM);
QTestEventLoop::instance().enterLoop(1);
QVERIFY(radio->band() == QRadioTuner::AM);
QVERIFY(readSignal.count() == 1);
}
}
void tst_QRadioTuner::testFrequency()
{
QSignalSpy readSignal(radio, SIGNAL(frequencyChanged(int)));
radio->setFrequency(104500000);
QTestEventLoop::instance().enterLoop(1);
QVERIFY(radio->frequency() == 104500000);
QVERIFY(readSignal.count() == 1);
QVERIFY(radio->frequencyStep(QRadioTuner::FM) == 1);
QPair<int,int> test = radio->frequencyRange(QRadioTuner::FM);
QVERIFY(test.first == 1);
QVERIFY(test.second == 2);
}
void tst_QRadioTuner::testMute()
{
QSignalSpy readSignal(radio, SIGNAL(mutedChanged(bool)));
radio->setMuted(true);
QTestEventLoop::instance().enterLoop(1);
QVERIFY(radio->isMuted());
QVERIFY(readSignal.count() == 1);
}
void tst_QRadioTuner::testSearch()
{
QSignalSpy readSignal(radio, SIGNAL(searchingChanged(bool)));
QVERIFY(!radio->isSearching());
radio->searchForward();
QTestEventLoop::instance().enterLoop(1);
QVERIFY(radio->isSearching());
QVERIFY(readSignal.count() == 1);
radio->cancelSearch();
QTestEventLoop::instance().enterLoop(1);
QVERIFY(!radio->isSearching());
QVERIFY(readSignal.count() == 2);
radio->searchBackward();
QTestEventLoop::instance().enterLoop(1);
QVERIFY(radio->isSearching());
QVERIFY(readSignal.count() == 3);
radio->cancelSearch();
QVERIFY(!radio->isSearching());
}
void tst_QRadioTuner::testVolume()
{
QVERIFY(radio->volume() == 100);
QSignalSpy readSignal(radio, SIGNAL(volumeChanged(int)));
radio->setVolume(50);
QTestEventLoop::instance().enterLoop(1);
QVERIFY(radio->volume() == 50);
QVERIFY(readSignal.count() == 1);
}
void tst_QRadioTuner::testSignal()
{
QVERIFY(radio->signalStrength() == 0);
// There is no set of this only a get, do nothing else.
}
void tst_QRadioTuner::testStereo()
{
/* no set function to toggle stereo status;
cannot emit stereoStatusChanged() signal */
QVERIFY(radio->isStereo());
radio->setStereoMode(QRadioTuner::ForceMono);
QVERIFY(radio->stereoMode() == QRadioTuner::ForceMono);
}
void tst_QRadioTuner::testSearchAllStations()
{
QSignalSpy foundSpy(radio, SIGNAL(stationFound(int,QString)));
QSignalSpy completeSpy(radio, SIGNAL(searchingChanged(bool)));
radio->searchAllStations(QRadioTuner::SearchGetStationId);
QTestEventLoop::instance().enterLoop(1);
QCOMPARE(radio->frequency(), 103100000 );
QCOMPARE(foundSpy.count(), 3);
QVERIFY(qvariant_cast<int>(foundSpy.at(2).at(0)) == 103100000 );
QVERIFY(qvariant_cast<QString>(foundSpy.at(2).at(1)) == QString("MockProgramPI3") );
QCOMPARE(completeSpy.count(), 2);
}
// QRadioTuner's errorsignal
void tst_QRadioTuner::errorSignal()
{
qRegisterMetaType<QRadioTuner::Error>("QRadioTuner::Error");
QObject obj;
MockRadioTunerControl dctrl(&obj);
MockMediaService service(&obj, &dctrl);
MockMediaServiceProvider provider(&service);
QMediaServiceProvider::setDefaultServiceProvider(&provider);
QRadioTuner radio;
QSignalSpy spy(&radio, SIGNAL(error(QRadioTuner::Error)));
QVERIFY(radio.service() != 0);
QVERIFY(radio.isAvailable());
radio.start();
radio.setBand(QRadioTuner::FM);
QVERIFY(spy.count() == 1);
QVERIFY(qvariant_cast<QRadioTuner::Error>(spy.at(0).at(0)) == QRadioTuner::NoError);
QVERIFY(radio.error() == QRadioTuner::NoError);
QVERIFY(radio.error() != QRadioTuner::OpenError);
QVERIFY(radio.errorString().isEmpty());
spy.clear();
/* emits QRadioTuner::OutOfRangeError if band is set to FM2 or LW
and frequency set to >= 148500000 */
radio.setBand(QRadioTuner::LW);
radio.setBand(QRadioTuner::FM2);
radio.setFrequency(148500000);
QVERIFY(spy.count() == 3);
QVERIFY(qvariant_cast<QRadioTuner::Error>(spy.at(0).at(0)) == QRadioTuner::OutOfRangeError);
QVERIFY(qvariant_cast<QRadioTuner::Error>(spy.at(1).at(0)) == QRadioTuner::OutOfRangeError);
QVERIFY(qvariant_cast<QRadioTuner::Error>(spy.at(2).at(0)) == QRadioTuner::OutOfRangeError);
QVERIFY(radio.error() == QRadioTuner::OutOfRangeError);
QVERIFY2(!radio.errorString().isEmpty(), "band and range not supported");
spy.clear();
radio.stop();
}
QTEST_GUILESS_MAIN(tst_QRadioTuner)
#include "tst_qradiotuner.moc"
Reference in New Issue View Git Blame Copy Permalink