--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/radioapp/radiouiengine/tsrc/src/t_radiostation.cpp Fri Mar 19 09:29:04 2010 +0200
@@ -0,0 +1,1014 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: radiostation test implementation
+*
+*/
+
+#define UNIT_TESTS_FOR_10_1
+#ifdef UNIT_TESTS_FOR_10_1
+#include <e32base.h>
+#include <eikenv.h>
+#endif
+#include "t_radiostation.h"
+#include "radiopresetstorage.h"
+#include "radiostation.h"
+#include "radiostationmodel.h"
+#include "radioplaylogmodel.h"
+#include "radioenginewrapper.h"
+#include "radiouiengine.h"
+#include "radiologger.h" //connectAndTest
+
+// Constants
+const uint KTestFrequency1 = 89000000;
+const uint KTestFrequency2 = 89500000;
+const uint KTestFrequency3 = 90000000;
+const uint KTestFrequency4 = 90500000;
+const uint KTestFrequency5 = 91000000;
+const uint KTestFrequency6 = 91500000;
+const uint KTestGenre1 = 1;
+const uint KTestGenre2 = 2;
+const QString KTestStationName1 = "Radio Noice";
+const QString KTestStationName2 = "RN RENAMED";
+const QString KTestUrl1 = "http://qt.nokia.com";
+const QString KTestUrl2 = "http://www.radionoice.com";
+const QString KTestFrequencyString1 = "89000000";
+const QString KTestFrequencyString2 = "89500000";
+const QString KTestFrequencyString3 = "90000000";
+const QString KTestFrequencyString6 = "91500000";
+const QString KTestArtist1 = "Eläkeläiset";
+const QString KTestArtist2 = "Jope";
+const QString KTestArtist3 = "Motorhead";
+const QString KTestTitle1 = "Humppa^2";
+const QString KTestTitle2 = "´åäö´ ^&%¤^";
+const QString KTestTitle3 = "Dancing queen";
+const QString KTestRadioTextRadioText = "NOW! Metallica - Enter sandman in MusicStore for free";
+const QString KTestRadioTextPlusArtist = "Metallica";
+const QString KTestRadioTextPlusTitle = "Enter sandman";
+const QString KTestRadioTextPlusUrl = "www.metallica.com";
+const QString KTestRadioTextPlusUnsupportedTag = "*#*#*#";
+const QString KTestDynamicPSText = "MAKKARAA";
+
+/*!
+ *
+ */
+int main(int /* argc*/, char *argv[])
+{
+ TestRadioUiEngine tv;
+
+ char *pass[3];
+ pass[0] = argv[0];
+ pass[1] = "-o";
+ pass[2] = "c:\\data\\testradiouiengine.txt";
+
+ int res = QTest::qExec(&tv, 3, pass);
+
+ return res;
+}
+
+
+TestRadioUiEngine::TestRadioUiEngine()
+{
+}
+
+
+void TestRadioUiEngine::tunedToFrequency( uint /* frequency */, int /* commandSender */)
+{
+}
+
+
+void TestRadioUiEngine::seekingStarted( Seeking::Direction /* direction */)
+{
+}
+
+void TestRadioUiEngine::radioStatusChanged( bool /* radioIsOn */)
+{
+}
+
+void TestRadioUiEngine::rdsAvailabilityChanged( bool /* available */)
+{
+}
+
+void TestRadioUiEngine::volumeChanged( int /* volume */)
+{
+}
+
+void TestRadioUiEngine::muteChanged( bool /* muted */)
+{
+}
+
+void TestRadioUiEngine::audioRouteChanged( bool /* loudspeaker */)
+{
+}
+
+void TestRadioUiEngine::scanAndSaveFinished()
+{
+}
+
+
+void TestRadioUiEngine::headsetStatusChanged( bool /* connected */)
+{
+}
+
+void TestRadioUiEngine::skipPrevious()
+{
+}
+
+void TestRadioUiEngine::skipNext()
+{
+}
+
+/*!
+ * Destructor
+ */
+TestRadioUiEngine::~TestRadioUiEngine()
+{
+ delete mRadioStationModel;
+ delete mUiEngine;
+}
+
+/*!
+ * called before each testfunction is executed
+ */
+void TestRadioUiEngine::init()
+{
+}
+
+/*!
+ * called after every testfunction
+ */
+void TestRadioUiEngine::cleanup()
+{
+}
+
+/*!
+ * called before the first testfunction is executed
+ */
+void TestRadioUiEngine::initTestCase()
+{
+#ifdef UNIT_TESTS_FOR_10_1
+// Workaround for the below panic, occured after porting to 10.1
+// Main Panic E32USER-CBase 44
+// Create and install the active scheduler
+ CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
+ CleanupStack::PushL(scheduler);
+ CActiveScheduler::Install(scheduler);
+// CCoeEnv::Static() call in CRadioEngineTls returns NULL
+ CCoeEnv* env = new CCoeEnv;
+#endif
+ mUiEngine = new RadioUiEngine;
+ mRadioStationModel = new RadioStationModel( *mUiEngine );
+ mPlayLogModel = new RadioPlayLogModel( *mUiEngine );
+
+ mEngineWrapper.reset( new RadioEngineWrapper( mRadioStationModel->stationHandlerIf(), *this ) );
+ mPresetStorage.reset( new RadioPresetStorage() );
+ mRadioStationModel->initialize( mPresetStorage.data(), mEngineWrapper.data() );
+
+ //TODO:: Check why ASSERT fails when mModel->rowCount() == 0
+ if(mRadioStationModel->rowCount()>0)
+ {
+ mRadioStationModel->removeAll(); //ASSERT: \"last >= first\" in file qabstractitemmodel.cpp, line 2110
+ }
+
+ connectAndTest( mRadioStationModel, SIGNAL(dataChanged(const QModelIndex, const QModelIndex)),
+ this, SLOT(dataChanged(const QModelIndex, const QModelIndex)) );
+
+ connectAndTest( mRadioStationModel, SIGNAL(stationAdded(RadioStation)),
+ this, SLOT(stationAdded(RadioStation)) );
+
+ connectAndTest( mRadioStationModel, SIGNAL(stationDataChanged(RadioStation)),
+ this, SLOT(stationDataChanged(RadioStation)) );
+
+ connectAndTest( mRadioStationModel, SIGNAL(favoriteChanged(RadioStation)),
+ this, SLOT(favoriteChanged(RadioStation)) );
+
+ connectAndTest( mPlayLogModel, SIGNAL(itemAdded()),
+ this, SLOT(itemAdded()) );
+}
+
+/*!
+ * called after the last testfunction was executed
+ */
+void TestRadioUiEngine::cleanupTestCase()
+{
+ delete mRadioStationModel;
+ delete mUiEngine;
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::dataChanged(const QModelIndex /* topLeft */, const QModelIndex /* bottomRight */)
+{
+ mEnteredSlots |= DataChanged;
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::stationDataChanged( RadioStation /* addedStation */ )
+{
+ mEnteredSlots |= StationDataChanged;
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::favoriteChanged( RadioStation /* addedStation */)
+{
+ mEnteredSlots |= FavoriteChanged;
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::itemAdded()
+{
+ mEnteredSlots |= ItemAdded;
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::stationAdded( RadioStation addedStation )
+{
+ mEnteredSlots |= StationAdded;
+
+ QVERIFY2(( mStationToBeAdded == addedStation.name() ), "API:RadioStationModel stationAdded 1");
+ QVERIFY2(( mExpectedStationCount == mRadioStationModel->rowCount() ), "API:RadioStationModel stationAdded 2");
+}
+
+
+/*!
+ * Testing of implicit sharing a.k.a. copy-on-write
+ */
+void TestRadioUiEngine::testImplicitSharing()
+{
+ RadioStation t_RadioStation_1;
+
+ int originalPresetIndex = t_RadioStation_1.presetIndex();
+ // before any values assigned into any data field
+ QVERIFY2(( originalPresetIndex == RadioStation::SharedNull ), "API:Radiostation init failed 1");
+ t_RadioStation_1.setName("Noice");
+ originalPresetIndex = t_RadioStation_1.presetIndex();
+ // once some value assigned into some other data field
+ QVERIFY2(( originalPresetIndex == RadioStation::Invalid ), "API:Radiostation init failed 2");
+
+ t_RadioStation_1.setFrequency( KTestFrequency1 );
+ //const int newIndex = mModel->findUnusedPresetIndex();
+ t_RadioStation_1.setPresetIndex( 2 );
+ t_RadioStation_1.setGenre(1);
+ t_RadioStation_1.setUrl("http://qt.nokia.com");
+
+ RadioStation* t_RadioStation_2 = new RadioStation(t_RadioStation_1);
+ // test that changing the content of copied data doesn't cause
+ // detach in the copying data structure
+ uint originalFrequency = t_RadioStation_1.frequency();
+ t_RadioStation_1.setFrequency( originalFrequency + 1 );
+ // should be detached
+ bool detached = t_RadioStation_2->isDetached();
+ QVERIFY2(detached, "API:Radiostation Implicit sharing/ freq 1");
+
+ // test that changing the content of data sets detach true
+ originalFrequency = t_RadioStation_2->frequency();
+ t_RadioStation_2->setFrequency( originalFrequency + 1 );
+ // should be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(detached, "API:Radiostation Implicit sharing/ freq 2");
+ delete t_RadioStation_2;
+ t_RadioStation_2 = NULL;
+
+ //-------------------------------------------------------------------------
+ // test that changing the content of copied data doesn't cause
+ // detach in the copying data structure
+ t_RadioStation_2 = new RadioStation(t_RadioStation_1);
+ // should not be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(!detached, "API:Radiostation Implicit sharing/ preset index 1");
+ originalPresetIndex = t_RadioStation_1.presetIndex();
+ t_RadioStation_1.setPresetIndex( originalPresetIndex + 1 );
+ // should be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(detached, "API:Radiostation Implicit sharing/ preset index 2");
+
+ // test that changing the content of data sets detach true
+ originalPresetIndex = t_RadioStation_2->presetIndex();
+ //newIndex = mModel->findUnusedPresetIndex();
+ t_RadioStation_2->setPresetIndex( originalPresetIndex + 1 );
+ // should be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(detached, "API:Radiostation Implicit sharing/ preset index 3");
+ delete t_RadioStation_2;
+ t_RadioStation_2 = NULL;
+
+ // test that changing the content of copied data doesn't cause
+ // detach in the copying data structure
+ t_RadioStation_2 = new RadioStation(t_RadioStation_1);
+ // should not be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(!detached, "API:Radiostation Implicit sharing/ name 1");
+ //QString originalName = t_RadioStation_1.name();
+ t_RadioStation_1.setName("RadioOne");
+ // should be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(detached, "API:Radiostation Implicit sharing/ name 2");
+ // test that changing the content of data sets detach true
+ t_RadioStation_2->setName("RadioTwo");
+ // should be detached
+ detached = t_RadioStation_2->isDetached();
+ QVERIFY2(detached, "API:Radiostation Implicit sharing/ name 3");
+}
+
+/*!
+ * Testing of change flags set by RadioStation class
+ */
+void TestRadioUiEngine::testChangeFlags()
+{
+ RadioStation t_RadioStation;
+
+ QVERIFY2(!t_RadioStation.isValid(), "API:Radiostation Init failure");
+ t_RadioStation.setUserDefinedName("");
+ t_RadioStation.setUserDefinedName("Radio Noice");
+ t_RadioStation.setFrequency( KTestFrequency1 );
+ //const int newIndex = mModel->findUnusedPresetIndex();
+ t_RadioStation.setPresetIndex( 2 );
+ t_RadioStation.setGenre( KTestGenre1 );
+ t_RadioStation.setUrl( KTestUrl1 );
+
+ t_RadioStation.resetChangeFlags();
+ bool persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(!persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 1");
+ t_RadioStation.setUserDefinedName("Radio Noice+");
+ bool nameChanged = t_RadioStation.hasDataChanged( RadioStation::NameChanged );
+ QVERIFY2(nameChanged, "API:Radiostation Change flags/ NameChanged");
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 2");
+ t_RadioStation.resetChangeFlags();
+
+ uint originalGenre = t_RadioStation.genre();
+ t_RadioStation.setGenre( originalGenre + 1 );
+ bool genreChanged = t_RadioStation.hasDataChanged( RadioStation::GenreChanged );
+ QVERIFY2(genreChanged, "API:Radiostation Change flags/ GenreChanged");
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 3");
+ t_RadioStation.resetChangeFlags();
+
+ QString originalUrl = t_RadioStation.url();
+ t_RadioStation.setUrl(originalUrl);
+ // previous url set so no url or persistent data change flags should be set
+ bool urlChanged = t_RadioStation.hasDataChanged( RadioStation::UrlChanged );
+ QVERIFY2(!urlChanged, "API:Radiostation Change flags/ UrlChanged");
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(!persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 4");
+ t_RadioStation.resetChangeFlags();
+
+ QString originalRadioText = t_RadioStation.radioText();
+ t_RadioStation.setRadioText( originalRadioText + "buy sausage" );
+ bool radioTextChanged = t_RadioStation.hasDataChanged( RadioStation::RadioTextChanged );
+ QVERIFY2(radioTextChanged, "API:Radiostation Change flags/ RadioTextChanged");
+ // radio text not stored into cenrep
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(!persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 5");
+ t_RadioStation.resetChangeFlags();
+ t_RadioStation.setRadioText( t_RadioStation.radioText() );
+ // because current radio text is reset change flags must not be affected
+ radioTextChanged = t_RadioStation.hasDataChanged( RadioStation::RadioTextChanged );
+ QVERIFY2(!radioTextChanged, "API:Radiostation Change flags/ RadioTextChanged");
+ t_RadioStation.resetChangeFlags();
+
+ QVERIFY2((t_RadioStation.psType()==RadioStation::Unknown), "API:Radiostation PS type check");
+ t_RadioStation.setPsType( RadioStation::Dynamic );
+ bool psTypeChanged = t_RadioStation.hasDataChanged( RadioStation::PsTypeChanged );
+ QVERIFY2(psTypeChanged, "API:Radiostation Change flags/ PsTypeChanged");
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ // PS type not stored as persistent data
+ QVERIFY2(!persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 6");
+ t_RadioStation.resetChangeFlags();
+
+ t_RadioStation.setFavorite(t_RadioStation.isFavorite());
+ bool favouriteChanged = t_RadioStation.hasDataChanged( RadioStation::FavoriteChanged );
+ QVERIFY2(!favouriteChanged, "API:Radiostation Change flags/ FavoriteChanged");
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(!persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 7");
+ t_RadioStation.resetChangeFlags();
+
+ // initially there should not be PI code defined
+ QVERIFY2(!t_RadioStation.hasPiCode(), "API:Radiostation Pi code check");
+ // non-clear channel
+ t_RadioStation.setPiCode(0xC004, RadioRegion::Default); //88.1 CBEE-FM - Chatham, ON
+ bool piCodeChanged = t_RadioStation.hasDataChanged( RadioStation::PiCodeChanged );
+ QVERIFY2(piCodeChanged, "API:Radiostation Change flags/ PiCodeChanged");
+ persistentDataChanged = t_RadioStation.hasDataChanged( RadioStation::PersistentDataChanged );
+ QVERIFY2(persistentDataChanged, "API:Radiostation Change flags/ PersistentDataChanged 8");
+}
+
+/*!
+ * Testing of call sign integer to char conversion
+ */
+void TestRadioUiEngine::TestCallSignChar()
+{
+ for(uint i = 0; i < KLastCallSignCharCode; i++)
+ {
+ RadioStation t_RadioStation;
+ bool passed = t_RadioStation.callSignChar(i) == static_cast<char>( 'A' + i );
+ QVERIFY2(passed, "API:Radiostation TestCallSignChar 1");
+ }
+ RadioStation t_RadioStation;
+ bool passed = t_RadioStation.callSignChar(KLastCallSignCharCode + 1) == static_cast<char>( '?' );
+ QVERIFY2(passed, "API:Radiostation TestCallSignChar 2");
+}
+
+/*!
+ * Testing of PI code to call sign conversion
+ */
+void TestRadioUiEngine::testPICodeToCallSign()
+{
+ RadioStation t_RadioStation;
+
+ // boundary values, two typical values and three chars call sign case
+ QString callSign = t_RadioStation.piCodeToCallSign( KKxxxCallSignPiFirst - 1 );
+ QVERIFY2((callSign==""), "API:Radiostation Call sign <");
+ callSign = t_RadioStation.piCodeToCallSign( KKxxxCallSignPiFirst );
+ QVERIFY2((callSign=="KAAA"), "API:Radiostation Call sign KAAA");
+ callSign = t_RadioStation.piCodeToCallSign( 0x243F );
+ QVERIFY2((callSign=="KHRJ"), "API:Radiostation Call sign KHRJ");
+ callSign = t_RadioStation.piCodeToCallSign( KWxxxCallSignPiFirst - 1 );
+ QVERIFY2((callSign=="KZZZ"), "API:Radiostation Call sign KZZZ");
+ callSign = t_RadioStation.piCodeToCallSign( KWxxxCallSignPiFirst );
+ QVERIFY2((callSign=="WAAA"), "API:Radiostation Call sign WAAA");
+ callSign = t_RadioStation.piCodeToCallSign( 0x74B9 );
+ QVERIFY2((callSign=="WMDT"), "API:Radiostation Call sign WMDT");
+ callSign = t_RadioStation.piCodeToCallSign( KWxxxCallSignPiLast );
+ QVERIFY2((callSign=="WZZZ"), "API:Radiostation Call sign WZZZ");
+ callSign = t_RadioStation.piCodeToCallSign( KWxxxCallSignPiLast + 1 );
+ QVERIFY2((callSign=="KEX"), "API:Radiostation Call sign KEX");
+ callSign = t_RadioStation.piCodeToCallSign( 0x99B5 );
+ QVERIFY2((callSign=="WJZ"), "API:Radiostation Call sign WJZ");
+ callSign = t_RadioStation.piCodeToCallSign( 0x99C0 );
+ QVERIFY2((callSign==""), "API:Radiostation Call sign ????");
+}
+
+/*!
+ * Testing of RadioStationModel initial state
+ */
+void TestRadioUiEngine::testRadioStationModelInit()
+{
+ //TODO:: Check why ASSERT fails when mModel->rowCount() == 0
+ if( mRadioStationModel->rowCount()>0 )
+ {
+ mRadioStationModel->removeAll();
+ QVERIFY2((mRadioStationModel->rowCount()==0), "API:RadioStationModel removeAll()");
+ }
+
+ RadioStation foundStation;
+ // no stations in the model in this phase
+ QVERIFY2(!(mRadioStationModel->findFrequency( KTestFrequency1, foundStation )),
+ "API:RadioStationModel findFrequency 1");
+}
+
+/*!
+ * Testing of RadioStationModel addStation method and resulting RadioStationModel signals
+ */
+void TestRadioUiEngine::testAddStation1()
+{
+ RadioStation station;
+ station.setFrequency( KTestFrequency1 );
+ station.setFrequency( KTestFrequency1 );
+ station.setGenre( KTestGenre1 );
+ station.setGenre( KTestGenre1 );
+ station.setUrl( KTestUrl1 );
+ station.setType( RadioStation::LocalStation );
+ station.setType( RadioStation::LocalStation );
+ station.setName("");
+ station.setName( KTestStationName1 );
+ station.setDynamicPsText( KTestDynamicPSText );
+ station.setPiCode( 0xC004, RadioRegion::America ); //88.1 CBEE-FM - Chatham, ON
+ QVERIFY2(!(station.dynamicPsText().compare(KTestDynamicPSText)), "API:RadioStationModel addStation 1");
+ station.setDynamicPsText( KTestDynamicPSText );
+ // check that adding station increases model row count
+ mExpectedStationCount = mRadioStationModel->rowCount() + 1;
+ mStationToBeAdded = station.name();
+ mRadioStationModel->addStation( station );
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel addStation 2");
+ bool correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) &&
+ mEnteredSlots.testFlag( StationAdded ) && mEnteredSlots.testFlag( DataChanged );
+
+ bool frequencyUpdated = station.frequencyMhz().toDouble()*1000000 == KTestFrequency1;
+ QVERIFY2(frequencyUpdated, "API:RadioStationModel addStation 1");
+ // check that correct signals received
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel addStation 3");
+ mEnteredSlots = NoSlotsEntered;
+
+ // check that added station can be found by frequency
+ QModelIndex index = mRadioStationModel->modelIndexFromFrequency( KTestFrequency1 );
+ QVariant stationData = mRadioStationModel->data( index, Qt::DisplayRole );
+ QString stationName = stationData.toString().right( KTestStationName1.length() );
+ QVERIFY2(!(stationName.compare(KTestStationName1)), "API:RadioStationModel modelIndexFromFrequency");
+}
+
+/*!
+ * Testing of RadioStationModel saveStation method and resulting RadioStationModel signals
+ */
+void TestRadioUiEngine::testSaveStation1()
+{
+ RadioStation newStation1;
+ // check that find by frequency works
+ // this is needed for preset index to be updated into newStation1
+ QVERIFY2((mRadioStationModel->findFrequency( KTestFrequency1, newStation1 )),
+ "API:RadioStationModel findFrequency 2");
+ newStation1.setType( RadioStation::Favorite );
+ mRadioStationModel->saveStation( newStation1 );
+ bool correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) &&
+ mEnteredSlots.testFlag( FavoriteChanged ) && mEnteredSlots.testFlag( DataChanged );;
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel saveStation 1");
+
+ newStation1.setGenre(newStation1.genre()+1);
+ mRadioStationModel->saveStation( newStation1 );
+ correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) && mEnteredSlots.testFlag( DataChanged );
+ // check that correct signals received
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel saveStation 2");
+}
+
+/*!
+ * Testing of RadioStationModel addStation method and rowCount methods
+ */
+void TestRadioUiEngine::testAddStation2()
+{
+ RadioStation newStation2;
+ newStation2.setFrequency( KTestFrequency2 );
+ QVERIFY2(!newStation2.hasRds(), "API:RadioStationModel addStation 1");
+ newStation2.setGenre( KTestGenre2 );
+ // setting genre should set this true
+ QVERIFY2(newStation2.hasRds(), "API:RadioStationModel addStation 2");
+ newStation2.setUrl( KTestUrl2 );
+ newStation2.setType( RadioStation::LocalStation | RadioStation::Favorite );
+ newStation2.setName("Radio ice");
+ // check that adding station increases model row count
+ mExpectedStationCount = mRadioStationModel->rowCount()+1;
+ mStationToBeAdded = newStation2.name();
+ mRadioStationModel->addStation( newStation2 );
+
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel addStation 3");
+ mEnteredSlots = NoSlotsEntered;
+}
+
+/*!
+ * Testing of RadioStationModel saveStation method special cases
+ */
+void TestRadioUiEngine::testSaveStation2()
+{
+ RadioStation newStation1;
+ // this is needed for preset index to be updated into newStation1
+ QVERIFY2((mRadioStationModel->findFrequency( KTestFrequency1, newStation1 )),
+ "API:RadioStationModel findFrequency 2");
+
+ newStation1.setFrequency( KTestFrequency2 );
+ mExpectedStationCount = mRadioStationModel->rowCount();
+ // updating existing station data must not increase station count
+ mRadioStationModel->saveStation( newStation1 );
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel saveStation 1");
+ // because frequency tried to be updated no signals should be received either
+ bool correctSignalsReceived = mEnteredSlots.testFlag( NoSlotsEntered );
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel saveStation 2");
+ mEnteredSlots = NoSlotsEntered;
+
+ // original frequency resumed
+ newStation1.setFrequency( KTestFrequency1 );
+ newStation1.setGenre(newStation1.genre()+1);
+ mExpectedStationCount = mRadioStationModel->rowCount();
+ // now that frequency resumed signal should be received also
+ mRadioStationModel->saveStation( newStation1 );
+ correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) && mEnteredSlots.testFlag( DataChanged );
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel saveStation 3");
+ // updating existing station data must not increase station count
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel saveStation 2");
+
+ mExpectedStationCount = mRadioStationModel->rowCount();
+ mStationToBeAdded = newStation1.name();
+ // adding station must fail because the frequency is the same as previously used frequency
+ mRadioStationModel->addStation( newStation1 );
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel addStation 3");
+}
+
+/*!
+ * Testing of RadioStationModel addStation method special cases
+ */
+void TestRadioUiEngine::testAddStation3()
+{
+ RadioStation newStation3;
+ newStation3.setFrequency( KTestFrequency2 );
+ newStation3.setGenre(3);
+ newStation3.setUrl("http://www.radio4noice.com");
+ newStation3.setType( RadioStation::LocalStation | RadioStation::Favorite );
+ newStation3.setName("Radio e");
+ // adding station must fail because frequency is the same as previously used frequency
+ mExpectedStationCount = mRadioStationModel->rowCount();
+ mStationToBeAdded = newStation3.name();
+ mRadioStationModel->addStation( newStation3 );
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel addStation 4");
+ // adding station must success because the station frequency is different now
+ newStation3.setFrequency( KTestFrequency2 + 1 );
+ mExpectedStationCount = mRadioStationModel->rowCount() + 1;
+ mRadioStationModel->addStation( newStation3 );
+ QVERIFY2((mRadioStationModel->rowCount()==mExpectedStationCount), "API:RadioStationModel addStation 5");
+ // test that station can be found by frequency range
+ QList<RadioStation> stations;
+ stations = mRadioStationModel->stationsInRange( KTestFrequency1, KTestFrequency3 );
+ QVERIFY2((stations.count()==3), "API:RadioStationModel stationsInRange");
+}
+
+/*!
+ * Testing of RadioStationModel saveStation method special cases
+ */
+void TestRadioUiEngine::testSaveStation3()
+{
+ RadioStation newStation3;
+ RadioStation foundStation;
+ QVERIFY2(mRadioStationModel->findFrequency( KTestFrequency2 + 1, newStation3 ),
+ "API:RadioStationModel findFrequency 4");
+
+ newStation3.setFrequency( KTestFrequency3 );
+ // because frequency or preset index don't have change flag the frequency must not be updated
+ mRadioStationModel->saveStation( newStation3 );
+
+ QVERIFY2(!(mRadioStationModel->findFrequency( KTestFrequency3, foundStation )),
+ "API:RadioStationModel findFrequency 3");
+
+ int stationGenre;
+ stationGenre = newStation3.genre();
+ newStation3.setGenre( newStation3.genre() + 1 );
+ // allthough genre changed so the frequency update must not become effective
+ mRadioStationModel->saveStation( newStation3 );
+
+ QVERIFY2(!(mRadioStationModel->findFrequency( KTestFrequency3, foundStation )),
+ "API:RadioStationModel findFrequency 4");
+
+
+ mEnteredSlots = NoSlotsEntered;
+ foreach( const RadioStation& station, mRadioStationModel->list() )
+ {
+ if ( station.frequency() == KTestFrequency2 )
+ {
+ mRadioStationModel->setFavoriteByFrequency( KTestFrequency2, !station.isFavorite() );
+ }
+ }
+ bool correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) &&
+ mEnteredSlots.testFlag( FavoriteChanged ) && mEnteredSlots.testFlag( DataChanged );
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel findFrequency 5");
+}
+
+
+
+/*!
+ * Test that stations are stored into RadioStationModel in ascending frequency order
+ */
+void TestRadioUiEngine::testSortByFrequency()
+{
+ int role = RadioStationModel::RadioStationRole;
+ int previousFrequency(0); // int not initialized zero as default
+
+ for (int i = 0; i< mRadioStationModel->rowCount(); i++ )
+ {
+ QModelIndex index = mRadioStationModel->index( i, 0 );
+ QVariant stationData = mRadioStationModel->data( index, role );
+ RadioStation station = stationData.value<RadioStation>();
+ // stations must be obtainded at ascending frequency order
+ QVERIFY2((station.frequency()>previousFrequency), "API:RadioStationModel testSortByFrequency");
+ previousFrequency = station.frequency();
+ }
+}
+
+/*!
+ * Test that preset indexes match
+ */
+void TestRadioUiEngine::testFindPresetIndex()
+{
+ RadioStation station;
+ for (int i = 0; i< mRadioStationModel->rowCount(); i++ )
+ {
+ QVERIFY2((mRadioStationModel->findPresetIndex(i) != RadioStation::NotFound),
+ "API:RadioStationModel testFindPresetIndex 1");
+ QVERIFY2((mRadioStationModel->findPresetIndex( i, station ) != RadioStation::NotFound),
+ "API:RadioStationModel testFindPresetIndex 2");
+ QVERIFY2((station.presetIndex() == i), "API:RadioStationModel testFindPresetIndex 3");
+ }
+}
+
+/*!
+ * Test that preset can be removed from model by frequency
+ */
+void TestRadioUiEngine::testRemoveByFrequency()
+{
+ RadioStation station;
+ int initialStationCount( mRadioStationModel->rowCount() );
+ int presetIndex(0);
+
+ // find valid preset index
+ for(int i = 0; i<mRadioStationModel->rowCount(); i++)
+ {
+ presetIndex = mRadioStationModel->findPresetIndex( i, station );
+ if(presetIndex!=RadioStation::NotFound)
+ break;
+ }
+ QVERIFY2((presetIndex != RadioStation::NotFound), "API:RadioStationModel testRemoveByFrequency 1");
+
+ mRadioStationModel->removeByFrequency( station.frequency() );
+ QVERIFY2((mRadioStationModel->rowCount()==(initialStationCount-1)), "API:RadioStationModel testRemoveByFrequency 2");
+}
+
+/*!
+ * Test that station can be removed from model by preset index
+ */
+void TestRadioUiEngine::testRemoveByPresetIndex()
+{
+ RadioStation station;
+ station.setFrequency( KTestFrequency4 );
+ mStationToBeAdded = "";
+ mExpectedStationCount = mRadioStationModel->rowCount() + 1;
+ mRadioStationModel->addStation( station );
+ // for updating station preset index
+ QVERIFY2((mRadioStationModel->findFrequency( KTestFrequency4, station )),
+ "API:RadioStationModel testRemoveByPresetIndex 1");
+
+ int initialStationCount( mRadioStationModel->rowCount() );
+ mRadioStationModel->removeByPresetIndex( station.presetIndex() );
+ QVERIFY2((mRadioStationModel->rowCount()==(initialStationCount-1)), "API:RadioStationModel testRemoveByPresetIndex 2");
+}
+
+/*!
+ * Test RadioStationModel method removeStation
+ */
+void TestRadioUiEngine::testRemoveStation()
+{
+ RadioStation station;
+ station.setFrequency( KTestFrequency5 );
+ mStationToBeAdded = "";
+ mExpectedStationCount = mRadioStationModel->rowCount() + 1;
+ mRadioStationModel->addStation( station );
+ int initialStationCount( mRadioStationModel->rowCount() );
+ // for updating station preset index
+ QVERIFY2(mRadioStationModel->findFrequency( KTestFrequency5, station ),
+ "API:RadioStationModel testRemoveStation");
+
+ mRadioStationModel->removeStation( station );
+ QVERIFY2((mRadioStationModel->rowCount()==(initialStationCount-1)), "API:RadioStationModel testRemoveStation");
+}
+
+
+/*!
+ * Test setting and unsetting station type favourite
+ */
+void TestRadioUiEngine::testSetFavorite()
+{
+ RadioStation station;
+ station.setFrequency( KTestFrequency6 );
+ station.setType( RadioStation::Favorite );
+ QVERIFY2(station.isFavorite(), "API:RadioStationModel testSetFavorite 1");
+ mRadioStationModel->addStation( station );
+ mEnteredSlots = NoSlotsEntered;
+
+ mRadioStationModel->setFavoriteByFrequency( KTestFrequency6, false );
+ bool correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) &&
+ mEnteredSlots.testFlag( FavoriteChanged ) && mEnteredSlots.testFlag( DataChanged );
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel testSetFavorite 2");
+
+ mRadioStationModel->findFrequency( KTestFrequency6, station );
+ QVERIFY2(!station.isFavorite(), "API:RadioStationModel testSetFavorite 3");
+ mEnteredSlots = NoSlotsEntered;
+
+ mRadioStationModel->setFavoriteByPreset( station.presetIndex(), true );
+ correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) &&
+ mEnteredSlots.testFlag( FavoriteChanged ) && mEnteredSlots.testFlag( DataChanged );
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel testSetFavorite 4");
+
+ // test toggling the favorite
+ QModelIndex index = mRadioStationModel->modelIndexFromFrequency( KTestFrequency6 );
+ mRadioStationModel->setData( index, KTestFrequencyString6 ,RadioStationModel::ToggleFavoriteRole);
+ RadioStation station1 = mRadioStationModel->stationAt( index.row() );
+ QVERIFY2(!station1.isFavorite(), "API:RadioStationModel testToggleFavourite");
+
+}
+
+/*!
+ * Test renaming station
+ */
+void TestRadioUiEngine::testRenameStation()
+{
+ RadioStation station;
+ int presetIndex(0);
+ // find valid preset index
+ for( int i = 0; i<mRadioStationModel->rowCount(); i++ )
+ {
+ if( mRadioStationModel->findPresetIndex( i, station ) != RadioStation::NotFound )
+ {
+ presetIndex = i;
+ break;
+ }
+ }
+ QString initialStationName( station.name() );
+ mEnteredSlots = NoSlotsEntered;
+ mRadioStationModel->renameStation( presetIndex, initialStationName + "Renamed" );
+ bool correctSignalsReceived = mEnteredSlots.testFlag( StationDataChanged ) &&
+ mEnteredSlots.testFlag( DataChanged );
+ QVERIFY2(correctSignalsReceived, "API:RadioStationModel testRenameStation 1");
+ QVERIFY2(initialStationName!=mRadioStationModel->stationAt(presetIndex).name(), "API:RadioStationModel testRenameStation 2");
+
+ station.setUserDefinedName( KTestStationName2 );
+ QVERIFY2(station.isRenamed(), "API:RadioStationModel testRenameStation 1");
+
+}
+
+/*!
+ * Test setting radio text
+ */
+void TestRadioUiEngine::testSetRadioTextPlus()
+{
+ RadioStation station;
+ mRadioStationModel->findFrequency( KTestFrequency6, station );
+ station.setRadioText( "" );
+ station.setRadioText( KTestRadioTextRadioText );
+ station.setRadioText( KTestRadioTextRadioText );
+ station.setRadioTextPlus( RtPlus::Artist, KTestRadioTextPlusArtist );
+ station.setRadioTextPlus( RtPlus::Title, KTestRadioTextPlusTitle );
+ station.setRadioTextPlus( RtPlus::Homepage, KTestRadioTextPlusUrl );
+ station.setRadioTextPlus( RtPlus::Homepage + 1, KTestRadioTextPlusUnsupportedTag );
+ mRadioStationModel->saveStation( station );
+ bool effective = station.radioText().contains( KTestRadioTextPlusArtist, Qt::CaseSensitive );
+ QVERIFY2(effective, "API:RadioStationModel testSetRadioTextPlus 1");
+ effective = station.radioText().contains( KTestRadioTextPlusTitle, Qt::CaseSensitive );
+ QVERIFY2(effective, "API:RadioStationModel testSetRadioTextPlus 2");
+ effective = !station.url().compare( KTestRadioTextPlusUrl );
+ QVERIFY2(effective, "API:RadioStationModel testSetRadioTextPlus 3");
+}
+
+/*!
+ * Test RadioStationModel API
+ */
+void TestRadioUiEngine::testRadioStationModel()
+{
+ testRadioStationModelInit();
+ testAddStation1();
+ testSaveStation1();
+ testAddStation2();
+ testSaveStation2();
+ testAddStation3();
+ testSaveStation3();
+ testSortByFrequency();
+ testFindPresetIndex();
+ testRemoveByFrequency();
+ testRemoveByPresetIndex();
+ testRemoveStation();
+ testSetFavorite();
+ testRenameStation();
+ testSetRadioTextPlus();
+}
+/*!
+ * Test RadioPlayLogModel API
+ */
+void TestRadioUiEngine::testPlayLogModel()
+ {
+ testPlayLogModelInit();
+ testPlayLogModelAddItem();
+ testPlayLogModelFindItem();
+ testPlayLogModelUpdateItem();
+ testPlayLogModelSetData();
+ testAddRadioTextPlus();
+ testClearRadioTextPlus();
+ }
+
+/*!
+ * Testing of RadioPlayLogModel initial state
+ */
+void TestRadioUiEngine::testPlayLogModelInit()
+{
+ //TODO:: Check why ASSERT fails when mPlayLogModel->rowCount() == 0
+ if( mPlayLogModel->rowCount()>0 )
+ {
+ mPlayLogModel->removeAll();
+ QVERIFY2((mRadioStationModel->rowCount()==0), "API:RadioPlayLogModel removeAll() 1");
+ }
+ QVERIFY2((mPlayLogModel->rowCount()==0), "API:RadioPlayLogModel removeAll() 2");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testPlayLogModelAddItem()
+{
+ int expectedPlayLogItemCount( mPlayLogModel->rowCount() + 1 );
+ mEnteredSlots = NoSlotsEntered;
+ mPlayLogModel->addItem( KTestArtist1, KTestTitle1 );
+ bool correctSignalsReceived = mEnteredSlots.testFlag( ItemAdded );
+ // check that correct signals received
+ QVERIFY2(correctSignalsReceived, "API:RadioPlayLogModel addItem() 1");
+ // check that item count increases
+ QVERIFY2((mPlayLogModel->rowCount()==expectedPlayLogItemCount), "API:RadioPlayLogModel addItem() 2");
+
+ // check that artist/title stored into the model conforms to the one read from the model
+ QModelIndex index = mPlayLogModel->index( 0, 0 );
+ QStringList stringList = mPlayLogModel->data( index, Qt::DisplayRole ).value<QStringList>();
+ QString artistTitle = stringList.at(0);
+ QVERIFY2(!(artistTitle.compare(KTestArtist1+" - "+KTestTitle1)), "API:RadioPlayLogModel addItem() 3");
+
+
+ expectedPlayLogItemCount = mPlayLogModel->rowCount();
+ // trying to add an item that allready exists must not increase the item count
+ mPlayLogModel->addItem( KTestArtist1, KTestTitle1 );
+ QVERIFY2((mPlayLogModel->rowCount()==expectedPlayLogItemCount), "API:RadioPlayLogModel addItem() 4");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testPlayLogModelFindItem()
+{
+ RadioPlayLogItem item;
+ mPlayLogModel->findItem( KTestArtist1, KTestTitle1, item );
+ QVERIFY2((item.artist()==KTestArtist1), "API:RadioPlayLogModel findItem() 1");
+ QVERIFY2((item.title()==KTestTitle1), "API:RadioPlayLogModel findItem() 2");
+ // try to find an item that doesn't exist
+ int ret = mPlayLogModel->findItem( KTestArtist1+"+", KTestTitle1, item );
+ QVERIFY2(ret==-1, "API:RadioPlayLogModel findItem() 3");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testPlayLogModelUpdateItem()
+{
+ RadioPlayLogItem item;
+ mPlayLogModel->findItem( KTestArtist1, KTestTitle1, item );
+ item.setTitle( KTestTitle2 );
+ // update an existing item
+ mPlayLogModel->updateItem( 0, item, true );
+
+ RadioPlayLogItem foundItem;
+ // original item must not be found any more
+ int ret = mPlayLogModel->findItem(KTestArtist1, KTestTitle1, foundItem);
+ QVERIFY2(ret==-1, "API:RadioPlayLogModel updateItem() 1");
+ // but the updated one instead
+ mPlayLogModel->findItem(KTestArtist1, KTestTitle2, foundItem);
+ QVERIFY2((foundItem.title()==KTestTitle2), "API:RadioPlayLogModel updateItem() 2");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testPlayLogModelSetData()
+{
+ RadioPlayLogItem foundItem;
+ mPlayLogModel->findItem(KTestArtist1, KTestTitle2, foundItem);
+ QVERIFY2(!foundItem.isFavorite(), "API:RadioPlayLogModel SetData() 1");
+
+ QModelIndex index = mPlayLogModel->index( 0, 0 );
+ QString artistTitle = KTestArtist1 + KTestTitle2;
+ mPlayLogModel->setData( index, artistTitle, RadioPlayLogModel::SetFavoriteRole );
+ mPlayLogModel->findItem(KTestArtist1, KTestTitle2, foundItem);
+ // item should be now favorite
+ QVERIFY2(foundItem.isFavorite(), "API:RadioPlayLogModel SetData() 2");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testAddRadioTextPlus()
+{
+ mPlayLogModel->addRadioTextPlus( RtPlus::Artist, KTestArtist1 );
+ mPlayLogModel->addRadioTextPlus( RtPlus::Title, KTestTitle1 );
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testClearRadioTextPlus()
+{
+ mPlayLogModel->clearRadioTextPlus();
+}
+
+/*!
+ * Test RadioPlayLogModelItem API
+ */
+void TestRadioUiEngine::testPlayLogModelItem()
+{
+ RadioPlayLogItem* item = new RadioPlayLogItem( KTestArtist3, KTestTitle3 );
+ item->setArtist( KTestArtist3 );
+ QVERIFY2(!(item->artist().compare(KTestArtist3)), "API:testPlayLogModelItem setArtist()");
+ item->setTitle( KTestTitle3 );
+ QVERIFY2(!(item->title().compare(KTestTitle3)), "API:testPlayLogModelItem setTitle()");
+ QVERIFY2(!item->isFavorite(), "API:testPlayLogModelItem isFavorite() 1");
+ item->setFavorite();
+ QVERIFY2(item->isFavorite(), "API:testPlayLogModelItem isFavorite() 2");
+ item->setFavorite();
+ delete item;
+ item = NULL;
+}