/*

* 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 "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

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

    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!");

    mSchedulerTimer->StartTimer( 1000000 );

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

}

void TestRadioEngineWrapper::testTuning()

    {

    FUNC_LOG;

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

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

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

    mSchedulerTimer->StartTimer( 1000000 );

    mEnteredSlots &= !TunedToFrequency;

    uint freq_B = mEngineWrapper->currentFrequency();

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

    tstSetFrequency( mEngineWrapper->maxFrequency() );   

    mSchedulerTimer->StartTimer( 1000000 );

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

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

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

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

    mSchedulerTimer->StartTimer( 1000000 );

    mEnteredSlots &= !TunedToFrequency;

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

    mSchedulerTimer->StartTimer( 1000000 );

    uint freq_C = mEngineWrapper->currentFrequency();

    TUNER.iSetFrequencyError.SetStubError( KRadioServErrFrequencyOutOfBandRange );

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

    mSchedulerTimer->StartTimer( 1000000 );

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

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

    }

    {

    FUNC_LOG;

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

    mSchedulerTimer->StartTimer( 1000000 );

    mSchedulerTimer->StartTimer( 1000000 );

    }

    {

    FUNC_LOG;

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

    TBool muted_1( mEngineWrapper->isMuted() );

    mSchedulerTimer->StartTimer( 1000000 );

    TBool muted_2( mEngineWrapper->isMuted() );

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

    mEnteredSlots &= !MuteChanged;    

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

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

    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;

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

    }

/*!

 * called after the last testfunction was executed

 */

void TestRadioEngineWrapper::cleanupTestCase()

{

    FUNC_LOG;

	delete mScheduler;

	mScheduler = NULL;

    mRadioStubManagerChunk.Close();

    mPropertyPlayerState.Close();