/*

* 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

*

*/

#include <e32base.h>

#include <eikenv.h>

#include <e32property.h>

#include <radiomonitor.h>

#include "t_radioenginewrapper.h"

//#include "radiopresetstorage.h"

//#include "radiostation.h"

//#include "radiostationmodel.h"

//#include "radioplaylogmodel.h"

#include "radioenginewrapper.h"

#include "radiologger.h" //Radio::connect

#include <cradiosettings.h>

#include "mradioenginesettings.h"

#include <radiostubmanager.h>

#include "trace.h"

#include "RadioClientServer.h"

#include "radiointernalcrkeys.h"

#define STUB  mRadioStubManager

#define TUNER  mRadioStubManager->iTuner

#define PLAYER  mRadioStubManager->iPlayer

#define RDS  mRadioStubManager->iRds

#define ACCESSORYOBSERVER  mRadioStubManager->iAccessoryObserver

#define REMCONTARGET  mRadioStubManager->iRemConTarget

// Constants

const uint KTestFrequency1 = 89000000;

const QString KTestStationName1 = "Radio Noice";

// CONSTANTS

_LIT_SECURITY_POLICY_PASS(KRadioServerReadPolicy);

_LIT_SECURITY_POLICY_C1(KRadioServerWritePolicy, ECapabilityWriteUserData);

/*!

 *

 */

int main(int /* argc*/, char *argv[])

{

FUNC_LOG;

    TestRadioEngineWrapper 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;

}

TestRadioEngineWrapper::TestRadioEngineWrapper()

{

FUNC_LOG;

}

// from base class RadioStationHandlerIf

uint TestRadioEngineWrapper::currentFrequency() const

{

FUNC_LOG;

return 0;

}

int TestRadioEngineWrapper::currentPresetIndex() const

{

FUNC_LOG;

return 0;

}

void TestRadioEngineWrapper::setCurrentStation( uint /*frequency*/ )

{

FUNC_LOG;

}

bool TestRadioEngineWrapper::containsFrequency( uint /*frequency*/ )

{

FUNC_LOG;

return 1;

}

bool TestRadioEngineWrapper::containsPresetIndex( int /*presetIndex*/ )

{

FUNC_LOG;

return 1;

}

void TestRadioEngineWrapper::startDynamicPsCheck()

{

FUNC_LOG;

}

void TestRadioEngineWrapper::addScannedFrequency( uint /*frequency*/ )

{

FUNC_LOG;

}

void TestRadioEngineWrapper::removeLocalStations()

{

FUNC_LOG;

}

void TestRadioEngineWrapper::setCurrentPsName( uint /*frequency*/, const QString& /*name*/ )

{

FUNC_LOG;

}

void TestRadioEngineWrapper::setCurrentRadioText( uint /*frequency*/, const QString& /*radioText*/ )

{

FUNC_LOG;

}

void TestRadioEngineWrapper::setCurrentRadioTextPlus( uint /*frequency*/, int /*rtClass*/, const QString& /*rtItem*/ )

{

FUNC_LOG;

}

void TestRadioEngineWrapper::setCurrentPiCode( uint /*frequency*/, int /*piCode*/ )

{

FUNC_LOG;

}

void TestRadioEngineWrapper::setCurrentGenre( uint /*frequency*/, int /*genre*/ )

{

FUNC_LOG;

}

//  from base class RadioEngineWrapperObserver

void TestRadioEngineWrapper::tunedToFrequency( uint frequency, int /* commandSender */)

{

    FUNC_LOG;

    mEnteredSlots |= TunedToFrequency;

    TInt err = mRadioCR->Set( KRadioCRTunedFrequency , (TInt)frequency );

    QVERIFY2( KErrNone == err, "Setting key KRadioCRTunedFrequency failed!" );

}

void TestRadioEngineWrapper::seekingStarted( Seeking::Direction /* direction */)

{

FUNC_LOG;

mEnteredSlots |= SeekingStarted;

}

void TestRadioEngineWrapper::radioStatusChanged( bool /* radioIsOn */)

{

FUNC_LOG;

}

void TestRadioEngineWrapper::rdsAvailabilityChanged( bool /* available */)

{

FUNC_LOG;

}

void TestRadioEngineWrapper::volumeChanged( int volume )

{

FUNC_LOG;

mEnteredSlots |= VolumeChanged;

mLastRecordedVolume = volume;

}

void TestRadioEngineWrapper::muteChanged( bool /* muted */)

{

FUNC_LOG;

mEnteredSlots |= MuteChanged;

}

void TestRadioEngineWrapper::audioRouteChanged( bool /* loudspeaker */)

{

FUNC_LOG;

}

void TestRadioEngineWrapper::scanAndSaveFinished()

{

FUNC_LOG;

}

void TestRadioEngineWrapper::headsetStatusChanged( bool /* connected */)

{

FUNC_LOG;

mEnteredSlots |= HeadsetConnected;

}

void TestRadioEngineWrapper::skipPrevious()

{

FUNC_LOG;

}

void TestRadioEngineWrapper::skipNext()

{

FUNC_LOG;

}

/*!

 * Destructor

 */

TestRadioEngineWrapper::~TestRadioEngineWrapper()

{

FUNC_LOG;

mRadioStubManagerChunk.Close();

delete mEngineWrapper;

mEngineWrapper = NULL;

delete mScheduler;

mScheduler = NULL;

}

/*!

 * called before each testfunction is executed

 */

void TestRadioEngineWrapper::init()

{

FUNC_LOG;

}

/*!

 * called after every testfunction

 */

void TestRadioEngineWrapper::cleanup()

{

FUNC_LOG;

}

/*!

 * called before the first testfunction is executed

 */

 void TestRadioEngineWrapper::initTestCase()

{

    FUNC_LOG;

    // Workaround for the below panic, occured after porting to 10.1 

    // Main Panic E32USER-CBase 44

    // Create and install the active scheduler

    mScheduler = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(mScheduler);

    TInt err = mRadioStubManagerChunk.CreateGlobal(

            KRadioStubManagerLocalChunkName,

            sizeof(SRadioStubManager),

            sizeof(SRadioStubManager),

            EOwnerThread );

    QVERIFY2( KErrNone == err, "Creation of memory chunk KRadioStubManagerLocalChunkName failed." );

    QVERIFY2( sizeof(SRadioStubManager) <= mRadioStubManagerChunk.MaxSize(), "Improper size for memory chunk KRadioStubManagerLocalChunkName." );

    TUint8* basePtr = mRadioStubManagerChunk.Base();

    QVERIFY2( 0 != basePtr, "Getting base pointer of memory chunk KRadioStubManagerLocalChunkName failed." );

    mRadioStubManager = (SRadioStubManager*)basePtr;

    // Zero configuration/control data 

    mRadioStubManager->FillZ();

    TRAP( err, mSchedulerTimer = CSchedulerStopAndStartTimer::NewL( *this ) );

    QVERIFY2(  KErrNone == err, "CSchedulerStopAndStartTimer not constructed!" );     

    mSchedulerTimer->StartTimer( 1000000, CSchedulerStopAndStartTimer::ETimerIdCreateMUT );

}

void TestRadioEngineWrapper::testIsEngineConstructed()

{

    FUNC_LOG;

    QVERIFY2(  mEngineWrapper->isEngineConstructed(), "Radio Engine not constructed!" );;

}

void TestRadioEngineWrapper::testRadioSettingsReference()

{

    FUNC_LOG;

    QVERIFY2(  0 != &mEngineWrapper->settings(), "Settings reference illegal!" );    

}

void TestRadioEngineWrapper::testRegion()

{   

    FUNC_LOG;

    QVERIFY2( mEngineWrapper->region() >= RadioRegion::None, "Illegal Region Id!");

    QVERIFY2( mEngineWrapper->region() <= RadioRegion::Poland, "Illegal Region Id!");

    QVERIFY2(  mEngineWrapper->frequencyStepSize() != 0, "Region Step Size illegal!" );

    QVERIFY2(  mEngineWrapper->minFrequency()  <  mEngineWrapper->maxFrequency(), "Region Minimum Frequency illegal!" );

    QVERIFY2(  mEngineWrapper->maxFrequency()  > mEngineWrapper->minFrequency(), "Region Maximum Frequency illegal!" );

    QVERIFY2(  mEngineWrapper->isFrequencyValid( mEngineWrapper->minFrequency() + mEngineWrapper->frequencyStepSize() ), "Legal frequency not accepted!" );

    QVERIFY2(  mEngineWrapper->isFrequencyValid( mEngineWrapper->maxFrequency() - mEngineWrapper->frequencyStepSize() ), "Legal frequency not accepted!" );

    QVERIFY2(  mEngineWrapper->isFrequencyValid( mEngineWrapper->minFrequency() ), "Legal minimum frequency not accepted!" );

    QVERIFY2(  mEngineWrapper->isFrequencyValid( mEngineWrapper->maxFrequency() ), "Legal maximum frequency not accepted!" );

    QVERIFY2(  !mEngineWrapper->isFrequencyValid( mEngineWrapper->maxFrequency() + mEngineWrapper->frequencyStepSize() ), "Illegal frequency accepted!" );

    QVERIFY2(  !mEngineWrapper->isFrequencyValid( mEngineWrapper->minFrequency() - mEngineWrapper->frequencyStepSize() ), "Illegal frequency accepted!" );

    QVERIFY2(  !mEngineWrapper->isFrequencyValid( 0 + mEngineWrapper->frequencyStepSize() ), "Illegal frequency accepted!" );

    QVERIFY2(  !mEngineWrapper->isFrequencyValid( 0 - mEngineWrapper->frequencyStepSize() ), "Illegal frequency accepted!" );

}

void TestRadioEngineWrapper::testRadioOnOff()

{

    FUNC_LOG;

    QVERIFY2(  !mEngineWrapper->isRadioOn(), "Radio is not off!" );

    TInt err(KErrNone);

    TBool antennaAttached = ETrue;

    QVERIFY2(KErrNone == err, "Attaching property ERadioServPsAntennaStatus failed!" );

    err = RProperty::Set( KStub_KRadioServerPropertyCategory, ERadioServPsAntennaStatus,  antennaAttached );

    INFO_1("RProperty::Set( KStub_KRadioServerPropertyCategory, ERadioServPsAntennaStatus,  antennaAttached ) err: %d", err);

    QVERIFY2( KErrNone == err, "Setting property ERadioServPsAntennaStatus failed!" );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEngineWrapper->isAntennaAttached(), "Headset/Antenna not connected!");

    QVERIFY2(  mEnteredSlots &= HeadsetConnected, "Headset/Antenna not connected!");

    err = mRadioCR->Set( KRadioCRVisualRadioPowerState, ETrue );

    QVERIFY2( KErrNone == err, "Setting key KRadioCRVisualRadioPowerState failed!" );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEngineWrapper->isRadioOn(), "Radio is not on!" );

    //QVERIFY2(  !mEngineWrapper->isFrequencyValid( 0 ), "Zero frequency accepted!" );

}

void TestRadioEngineWrapper::testTuning()

    {

    FUNC_LOG;

    QVERIFY2( mEngineWrapper->isRadioOn(), "Radio is not on!" );

    mEngineWrapper->tuneFrequency( mEngineWrapper->minFrequency() );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEngineWrapper->currentFrequency() ==  mEngineWrapper->minFrequency(), "Tuning to minimum frequency failed!");

    uint freq_A = mEngineWrapper->currentFrequency();    

    mSchedulerTimer->StartTimer( 1000 );

    tstSetFrequency( freq_A + mEngineWrapper->frequencyStepSize() );   

    mEngineWrapper->startSeeking( Seeking::Up );

    QVERIFY2(  mEnteredSlots &= SeekingStarted, "Seeking upwards not started!");

    mEnteredSlots &= !SeekingStarted;

    TInt err = mPropertyFrequency.Set( KStub_KRadioServerPropertyCategory, ERadioServPsFrequency,  tstGetFrequency() );

    QVERIFY2( KErrNone == err, "Setting property ERadioServPsFrequency failed!" );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEnteredSlots &= TunedToFrequency, "Not Tuned to next upward frequency!");

    mEnteredSlots &= !TunedToFrequency;

    uint freq_B = mEngineWrapper->currentFrequency();

    QVERIFY2(  (freq_B - mEngineWrapper->frequencyStepSize()) == freq_A, "Seeking upwards failed!");

    tstSetFrequency( mEngineWrapper->maxFrequency() );   

    mEngineWrapper->tuneFrequency( mEngineWrapper->maxFrequency() );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2( mEngineWrapper->currentFrequency() == mEngineWrapper->maxFrequency(), "Current frequency not the maximum one!" );

    mEngineWrapper->startSeeking( Seeking::Down );

    QVERIFY2(  mEnteredSlots &= SeekingStarted, "Seeking downwards not started!");

    mEnteredSlots &= !SeekingStarted;

    tstSetFrequency(  mEngineWrapper->currentFrequency() - (2 * mEngineWrapper->frequencyStepSize()) );   

    err = mPropertyFrequency.Set( KStub_KRadioServerPropertyCategory, ERadioServPsFrequency,  tstGetFrequency() );

    QVERIFY2( KErrNone == err, "Setting property ERadioServPsFrequency failed!" );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEnteredSlots &= TunedToFrequency, "Not Tuned to next downward frequency!");

    mEnteredSlots &= !TunedToFrequency;

    QVERIFY2(  mEngineWrapper->currentFrequency() ==  mEngineWrapper->maxFrequency()- (2 * mEngineWrapper->frequencyStepSize()), "Seeking downwards failed!");

    mEngineWrapper->tuneFrequency( (mEngineWrapper->maxFrequency() + mEngineWrapper->minFrequency())/2 );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEngineWrapper->currentFrequency() ==  (mEngineWrapper->maxFrequency() + mEngineWrapper->minFrequency())/2, "Tuning to average frequency failed!");

    uint freq_C = mEngineWrapper->currentFrequency();

    TUNER.iSetFrequencyError.SetStubError( KRadioServErrFrequencyOutOfBandRange );

    mEngineWrapper->tuneFrequency( mEngineWrapper->maxFrequency() + mEngineWrapper->frequencyStepSize() );

    mSchedulerTimer->StartTimer( 1000000 );

    // Should be == not != as now. This is to continue after bug

    QVERIFY2( mEngineWrapper->currentFrequency() != freq_C, "Tuning over maximum frequency succeeded?");

    QVERIFY2( !mEngineWrapper->isFrequencyValid( mEngineWrapper->currentFrequency() ), "A frequency over maximum accepted?");

    uint freq_D = mEngineWrapper->currentFrequency();

    TUNER.iSetFrequencyError.SetStubError( KRadioServErrFrequencyOutOfBandRange );

    mEngineWrapper->tuneFrequency( mEngineWrapper->minFrequency() - mEngineWrapper->frequencyStepSize() );

    mSchedulerTimer->StartTimer( 1000000 );

    // Should be == not != as now. This is to continue after bug

    QVERIFY2(  mEngineWrapper->currentFrequency() != freq_D, "Tuning below minimum frequency succeeded?");

    QVERIFY2( !mEngineWrapper->isFrequencyValid( mEngineWrapper->currentFrequency() ), "A frequency below minimum accepted?");

    }

void TestRadioEngineWrapper::testTuningWithDelay()

    {

    FUNC_LOG;

    QVERIFY2( mEngineWrapper->isRadioOn(), "Radio is not on!" );

    uint freq_A = mEngineWrapper->currentFrequency();

    uint freq_B = mEngineWrapper->currentFrequency();

    mEngineWrapper->tuneWithDelay( freq_B );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEngineWrapper->currentFrequency() == freq_B, "Tuning with delay failed?");

    mEngineWrapper->tuneWithDelay( freq_A );

    mSchedulerTimer->StartTimer( 1000000 );

    QVERIFY2(  mEngineWrapper->currentFrequency() == freq_A, "Tuning with delay failed?");    

    }

void TestRadioEngineWrapper::testMuteToggling()

    {

    FUNC_LOG;

    QVERIFY2( mEngineWrapper->isRadioOn(), "Radio is not on!" );

    TBool muted_1( mEngineWrapper->isMuted() );

    mEngineWrapper->toggleMute();

    mSchedulerTimer->StartTimer( 1000000 );

    TBool muted_2( mEngineWrapper->isMuted() );

    QVERIFY2(  mEnteredSlots &= MuteChanged, "Mute not changed!");

    mEnteredSlots &= !MuteChanged;    

    QVERIFY2( muted_1 != muted_2, "Mute() not working!" );

    mEngineWrapper->toggleMute();

    mSchedulerTimer->StartTimer( 1000000 );

    TBool muted_3( mEngineWrapper->isMuted() );

    QVERIFY2(  mEnteredSlots &= MuteChanged, "Mute not changed!");

    mEnteredSlots &= !MuteChanged;    

    QVERIFY2( muted_1 == muted_3, "Mute status not changed to original value!") ;

    }

void TestRadioEngineWrapper::testVolumeSetting()

    {

    FUNC_LOG;

    // SetVoliúme(() seems to accept any value. Probably because the real check point

    //  is missing from test constellation.

    QVERIFY2( mEngineWrapper->isRadioOn(), "Radio is not on!" );

    INFO_1( "mLastRecordedVolume: %i", mLastRecordedVolume );

    TInt volume_1( 1000 );

    mEngineWrapper->setVolume( volume_1 );

    mSchedulerTimer->StartTimer( 1000000 );

    INFO_1( "mLastRecordedVolume: %i", mLastRecordedVolume );

    QVERIFY2(  mEnteredSlots &= VolumeChanged, "Volume not changed!");

    mEnteredSlots &= !VolumeChanged;    

    QVERIFY2( volume_1 == mLastRecordedVolume, "Volume has unexpected value!") ;

    volume_1 = mLastRecordedVolume;

    TInt volume_2( mLastRecordedVolume * 30 );

    mEngineWrapper->setVolume( volume_2 );

    mSchedulerTimer->StartTimer( 1000000 );

    INFO_1( "mLastRecordedVolume: %i", mLastRecordedVolume );

    QVERIFY2( volume_2 == mLastRecordedVolume, "Volume has unexpected value!") ;

    }

void TestRadioEngineWrapper::testLoudSpeakerUsage()

    {

    FUNC_LOG;

    QVERIFY2( mEngineWrapper->isRadioOn(), "Radio is not on!" );

    TBool isLoudSpeakerUsed( mEngineWrapper->isUsingLoudspeaker() );

    INFO_1( "isLoudSpeakerUsed: %i", isLoudSpeakerUsed );   

    }

void TestRadioEngineWrapper::testScanning()

    {

    FUNC_LOG;

    QVERIFY2( mEngineWrapper->isRadioOn(), "Radio is not on!" );

    tstSetScanningData( 10, mEngineWrapper->minFrequency(), mEngineWrapper->frequencyStepSize() );

    QVERIFY2( TUNER.iScanStations.iCount == 10, "Scanning not initialized!" );

    mEngineWrapper->scanFrequencyBand();

    mSchedulerTimer->StartTimer( 1000000 );

    INFO_1( "TUNER.iScanStations.iCount: %i", TUNER.iScanStations.iCount );

    QVERIFY2( TUNER.iScanStations.iCount == 0, "Scanning not completed!" );

    }

/*!

 * called after the last testfunction was executed

 */

void TestRadioEngineWrapper::cleanupTestCase()

{

    FUNC_LOG;

	delete mEngineWrapper;

	mEngineWrapper = NULL;

    //mSchedulerTimer->StartTimer( 1000000, CSchedulerStopAndStartTimer::ETimerIdDeleteMUT );

	delete mScheduler;

	mScheduler = NULL;

    mRadioStubManagerChunk.Close();

    mPropertyPlayerState.Close();

    mPropertyAntennaStatus.Close();

    mPropertyOfflineMode.Close();

    mPropertyTransmitterStatus.Close();

    mPropertyFrequency.Close();

    mPropertyFrequencyRange.Close();

    mPropertyForceMonoReception.Close();

    mPropertySquelch.Close();

    mPropertyVolume.Close();

    mPropertyMuteStatus.Close();

    mPropertyBalance.Close();

}

void TestRadioEngineWrapper::tstSetTunerCababilities(uint /*category*/)

    {

    FUNC_LOG;

    TUNER.iCaps.iFrequencyRange = ERsRangeFmEuroAmerica; 

    TUNER.iCaps.iCapabilities = 

        TRsTunerCapabilities::ETunerFunctionAvailableInOfflineMode | 

        TRsTunerCapabilities::ETunerFunctionRds | 

        TRsTunerCapabilities::ETunerFunctionDualTuner; 

    }

void TestRadioEngineWrapper::Timeout( TUint aTimerId )

    {

    FUNC_LOG;    

    if ( CSchedulerStopAndStartTimer::ETimerIdCreateMUT == aTimerId )

        {

        INFO("ETimerIdCreateMUT elapsed");

        }

    else if ( CSchedulerStopAndStartTimer::ETimerIdDeleteMUT == aTimerId )

        {

        INFO("ETimerIdDeleteMUT elapsed");

        }

    else if ( CSchedulerStopAndStartTimer::ETimerIdRunMUT == aTimerId )

        {

        INFO("ETimerIdRunMUT elapsed");

        }