/*

* 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" //Radio::connect

// 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	

    }    

    Radio::connect( mRadioStationModel,  SIGNAL(dataChanged(const QModelIndex, const QModelIndex)),

        this,    SLOT(dataChanged(const QModelIndex, const QModelIndex)) );

    Radio::connect( mRadioStationModel,           SIGNAL(stationAdded(RadioStation)),

        this,    SLOT(stationAdded(RadioStation)) );

    Radio::connect( mRadioStationModel,           SIGNAL(stationDataChanged(RadioStation)),

        this,    SLOT(stationDataChanged(RadioStation)) );

    Radio::connect( mRadioStationModel,           SIGNAL(favoriteChanged(RadioStation)),

        this,    SLOT(favoriteChanged(RadioStation)) );

    Radio::connect( 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 );