diff -r a2b50a479edf -r 6df133bd92e1 radioapp/radiouiengine/tsrc/src/t_radiostation.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/radioapp/radiouiengine/tsrc/src/t_radiostation.cpp	Fri Jun 04 10:21:36 2010 +0100
@@ -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 "radiohistorymodel.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 );
+    mhistoryModel = new RadioHistoryModel( *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( mhistoryModel,           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 RadioHistoryModel API
+ */
+void TestRadioUiEngine::testhistoryModel()
+    {
+    testHistoryModelInit();
+    testHistoryModelAddItem();
+    testHistoryModelFindItem();
+    testHistoryModelUpdateItem();
+    testHistoryModelSetData();
+    testAddRadioTextPlus();
+    testClearRadioTextPlus();
+    }
+
+/*!
+ * Testing of RadioHistoryModel initial state
+ */
+void TestRadioUiEngine::testHistoryModelInit()
+{
+    //TODO:: Check why ASSERT fails when mhistoryModel->rowCount() == 0 
+    if( mhistoryModel->rowCount()>0 )
+    {       
+        mhistoryModel->removeAll();
+        QVERIFY2((mRadioStationModel->rowCount()==0), "API:RadioHistoryModel removeAll() 1");
+    }
+    QVERIFY2((mhistoryModel->rowCount()==0), "API:RadioHistoryModel removeAll() 2");           
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testHistoryModelAddItem()
+{
+    int expectedHistoryItemCount( mhistoryModel->rowCount() + 1 );
+    mEnteredSlots = NoSlotsEntered;
+    mhistoryModel->addItem( KTestArtist1, KTestTitle1 );    
+    bool correctSignalsReceived = mEnteredSlots.testFlag( ItemAdded );
+    // check that correct signals received
+    QVERIFY2(correctSignalsReceived, "API:RadioHistoryModel addItem() 1");
+    // check that item count increases
+    QVERIFY2((mhistoryModel->rowCount()==expectedHistoryItemCount), "API:RadioHistoryModel addItem() 2");
+    
+    // check that artist/title stored into the model conforms to the one read from the model
+    QModelIndex index = mhistoryModel->index( 0, 0 );
+    QStringList stringList = mhistoryModel->data( index, Qt::DisplayRole ).value<QStringList>();        
+    QString artistTitle = stringList.at(0);    
+    QVERIFY2(!(artistTitle.compare(KTestArtist1+" - "+KTestTitle1)), "API:RadioHistoryModel addItem() 3");
+    
+    
+    expectedHistoryItemCount = mhistoryModel->rowCount();
+    // trying to add an item that allready exists must not increase the item count
+    mhistoryModel->addItem( KTestArtist1, KTestTitle1 );
+    QVERIFY2((mhistoryModel->rowCount()==expectedHistoryItemCount), "API:RadioHistoryModel addItem() 4");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testHistoryModelFindItem()
+{
+    RadioHistoryItem item;
+    mhistoryModel->findItem( KTestArtist1, KTestTitle1, item );
+    QVERIFY2((item.artist()==KTestArtist1), "API:RadioHistoryModel findItem() 1");
+    QVERIFY2((item.title()==KTestTitle1), "API:RadioHistoryModel findItem() 2");
+    // try to find an item that doesn't exist
+    int ret = mhistoryModel->findItem( KTestArtist1+"+", KTestTitle1, item );
+    QVERIFY2(ret==-1, "API:RadioHistoryModel findItem() 3");
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testHistoryModelUpdateItem()
+{
+    RadioHistoryItem item;    
+    mhistoryModel->findItem( KTestArtist1, KTestTitle1, item );
+    item.setTitle( KTestTitle2 );    
+    // update an existing item
+    mhistoryModel->updateItem( 0, item, true );
+    
+    RadioHistoryItem foundItem;
+    // original item must not be found any more
+    int ret = mhistoryModel->findItem(KTestArtist1, KTestTitle1, foundItem);
+    QVERIFY2(ret==-1, "API:RadioHistoryModel updateItem() 1");
+    // but the updated one instead
+    mhistoryModel->findItem(KTestArtist1, KTestTitle2, foundItem);
+    QVERIFY2((foundItem.title()==KTestTitle2), "API:RadioHistoryModel updateItem() 2"); 
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testHistoryModelSetData()
+{
+   RadioHistoryItem foundItem;
+   mhistoryModel->findItem(KTestArtist1, KTestTitle2, foundItem);
+   QVERIFY2(!foundItem.isFavorite(), "API:RadioHistoryModel SetData() 1");
+   
+   QModelIndex index = mhistoryModel->index( 0, 0 );
+   QString artistTitle = KTestArtist1 + KTestTitle2;
+   mhistoryModel->setData( index, artistTitle, RadioHistoryModel::SetFavoriteRole );
+   mhistoryModel->findItem(KTestArtist1, KTestTitle2, foundItem);
+   // item should be now favorite
+   QVERIFY2(foundItem.isFavorite(), "API:RadioHistoryModel SetData() 2");    
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testAddRadioTextPlus()
+{   
+    mhistoryModel->addRadioTextPlus( RtPlus::Artist, KTestArtist1 );
+    mhistoryModel->addRadioTextPlus( RtPlus::Title, KTestTitle1 );
+}
+
+/*!
+ *
+ */
+void TestRadioUiEngine::testClearRadioTextPlus()
+{   
+    mhistoryModel->clearRadioTextPlus();
+}
+
+/*!
+ * Test RadioHistoryModelItem API
+ */
+void TestRadioUiEngine::testHistoryModelItem()
+{
+    RadioHistoryItem* item = new RadioHistoryItem( KTestArtist3, KTestTitle3 );
+    item->setArtist( KTestArtist3 );
+    QVERIFY2(!(item->artist().compare(KTestArtist3)), "API:testHistoryModelItem setArtist()");
+    item->setTitle( KTestTitle3 );
+    QVERIFY2(!(item->title().compare(KTestTitle3)), "API:testHistoryModelItem setTitle()");
+    QVERIFY2(!item->isFavorite(), "API:testHistoryModelItem isFavorite() 1");
+    item->setFavorite();
+    QVERIFY2(item->isFavorite(), "API:testHistoryModelItem isFavorite() 2");
+    item->setFavorite();
+    delete item;
+    item = NULL;
+}