/*

* Copyright (c) 2002 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:  ?Description

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "SensrvTest.h"

#include "sensrvchannelfinder.h"

#include "sensrvchannel.h"

#include "SensrvInternalPSKeys.h"

#include "sensrvtestclient.h"

#include "sensrvtestcases.h"

#include "sensrvchanneldatatypes.h"

#include "sensrvchannelcondition.h"

#include "sensrvchannelconditionsetimpl.h"

#include "sensrvtesttypes.h"

#include "sensrvgeneralproperties.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

// -----------------------------------------------------------------------------

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSensrvTest::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

// -----------------------------------------------------------------------------

//

void CSensrvTest::Delete()

    {

    RDebug::Print( _L("CSensrvTest::Delete - START") );

    if( iTestCases )

        {

        TRequestStatus status;

        iThread.Logon( status );

        iTestCases->StopTest();

        RDebug::Print( _L("CSensrvTest::Delete - Waiting thread...") );

        User::WaitForRequest( status );

        }

    RDebug::Print( _L("CSensrvTest::Delete - END") );

    }

// -----------------------------------------------------------------------------

// CSensrvTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CSensrvTest::RunMethodL(

    CStifItemParser& aItem )

    {

    static TStifFunctionInfo const KFunctions[] =

        {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

            ENTRY( "SetPSValue", CSensrvTest::SetPSValue ),

            ENTRY( "SetCompletedKey", CSensrvTest::SetCompletedKeyL ),

            ENTRY( "SetGetDataDelay", CSensrvTest::SetGetDataDelay ),

            ENTRY( "WaitCompletedKey", CSensrvTest::WaitCompletedKey ),

            ENTRY( "ShutdownServer", CSensrvTest::ShutdownServer ),

            ENTRY( "StartServer", CSensrvTest::StartServer ),

            ENTRY( "CreateAndDestroyChannelFinder", CSensrvTest::CreateAndDestroyChannelFinderL ),

            ENTRY( "FindChannels", CSensrvTest::FindChannelsL ),

            ENTRY( "OpenChannel", CSensrvTest::OpenChannelL ),

            ENTRY( "CloseChannel", CSensrvTest::CloseChannelL ),

            ENTRY( "OpenClosePerformance", CSensrvTest::OpenClosePerformanceL ),

            ENTRY( "StartDataListening", CSensrvTest::StartDataListeningL ),

            ENTRY( "StopDataListening", CSensrvTest::StopDataListeningL ),

            ENTRY( "StartListeningWhenChannelIsNotOpen", CSensrvTest::StartListeningWhenChannelIsNotOpenL ),

            ENTRY( "PanicClient", CSensrvTest::PanicClient ),

            ENTRY( "GetProperty", CSensrvTest::GetPropertyL ),

            ENTRY( "SetProperty", CSensrvTest::SetPropertyL ),

            ENTRY( "StartPropertyListening", CSensrvTest::StartPropertyListeningL ),

            ENTRY( "StopPropertyListening", CSensrvTest::StopPropertyListeningL ),

            ENTRY( "GetAllProperties", CSensrvTest::GetAllPropertiesL ),

            ENTRY( "GetAllPropertiesWithPropertyId", CSensrvTest::GetAllPropertiesWithPropertyIdL ),

            ENTRY( "GetAllPropertiesWithArrayIndex", CSensrvTest::GetAllPropertiesWithArrayIndexL ),

            ENTRY( "WaitSSYUnloading", CSensrvTest::WaitSSYUnloading ),

            ENTRY( "CheckPropertyChangedCount", CSensrvTest::CheckPropertyChangedCount ),

            ENTRY( "ConditionUnitTest", CSensrvTest::ConditionUnitTestL ),

            ENTRY( "ConditionSetUnitTest", CSensrvTest::ConditionSetUnitTestL ),

            ENTRY( "AddCondition", CSensrvTest::AddConditionL ),

            ENTRY( "AddConditionSet", CSensrvTest::AddConditionSetL ),

            ENTRY( "RemoveConditions", CSensrvTest::RemoveConditionsL ),

            ENTRY( "StartConditionListening", CSensrvTest::StartConditionListeningL ),

            ENTRY( "CreateNewProcess", CSensrvTest::CreateNewProcess ),

            ENTRY( "KillProcess", CSensrvTest::KillProcess ),

            ENTRY( "SetProcessPSValue", CSensrvTest::SetProcessPSValue ),

            ENTRY( "StopConditionListening", CSensrvTest::StopConditionListeningL ),

            ENTRY( "CheckConditionMetCount", CSensrvTest::CheckConditionMetCount ),

            ENTRY( "CheckFoundChannelCount", CSensrvTest::CheckFoundChannelCount ),

            ENTRY( "StartChannelChangeListening", CSensrvTest::StartChannelChangeListeningL ),

            ENTRY( "StopChannelChangeListening", CSensrvTest::StopChannelChangeListeningL ),

            ENTRY( "AdjustChannels", CSensrvTest::AdjustChannelsL ),

            ENTRY( "GetPsResult", CSensrvTest::GetPsResult ),

            ENTRY( "StoreFoundChannels", CSensrvTest::StoreFoundChannelsL ),

            ENTRY( "GetPSValue", CSensrvTest::GetPSValue ),

            ENTRY( "CheckListenedSetPropertySuccessIndicator", CSensrvTest::CheckListenedSetPropertySuccessIndicator ),

            ENTRY( "CheckServerAlive", CSensrvTest::CheckServerAlive ),

            ENTRY( "SetDefaultValue", CSensrvTest::SetDefaultValueL),

            //Regression Tests

            ENTRY( "TestOpenClose", CSensrvTest::TestOpenClose),

            ENTRY( "TestOpenCloseSensorL", CSensrvTest::TestOpenCloseSensorL),

            ENTRY( "TestOpenCloseSensorsL", CSensrvTest::TestOpenCloseSensorsL),

            ENTRY( "TestOpenCloseCombinationSensorsL", CSensrvTest::TestOpenCloseCombinationSensorsL),

            ENTRY( "TestChannelsL", CSensrvTest::TestChannelsL),

            ENTRY( "TestChannelFinderL", CSensrvTest::TestChannelFinderL)

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

TInt CSensrvTest::TestChannelsL( CStifItemParser& /*aItem*/ )

    {

    CSensrvChannelFinder* tempChannelFinder;

    CSensrvChannel* tempSensorChannel1;

    CSensrvChannel* tempSensorChannel2;

    CSensrvChannel* tempSensorChannel3;

    TInt err = CheckTest();

    if( err )

        {

        RDebug::Print( _L("CSensrvTest::TestOpenCloseL Test Creattion error: %d"), err );

        return err;

        }

    tempChannelFinder = CSensrvChannelFinder::NewL();    

    //List of found channels.

    RSensrvChannelInfoList tempChannelInfoList;

    TSensrvChannelInfo tempChannelInfo;

    tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

    //Find the channel

    tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    //10 channels & wait for more than 10 seconds        

    tempSensorChannel1 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

    tempSensorChannel2 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

    tempSensorChannel3 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

    for (TInt i =0; i <10; i++)

        {

        //Open the channel

        tempSensorChannel1->OpenChannelL();

        tempSensorChannel2->OpenChannelL();

        tempSensorChannel3->OpenChannelL();

        User::After(1000000);

        //Close the channel

        tempSensorChannel1->CloseChannel();

        tempSensorChannel2->CloseChannel();

        tempSensorChannel3->CloseChannel();

        User::After(7000000);

        }

    delete tempChannelFinder;

    delete tempSensorChannel1;

    delete tempSensorChannel2;

    delete tempSensorChannel3;

    return err;

    }

TInt CSensrvTest::TestChannelFinderL( CStifItemParser& /*aItem*/ )

    {

    CSensrvChannelFinder* tempChannelFinder1;

    CSensrvChannelFinder* tempChannelFinder2;

    CSensrvChannelFinder* tempChannelFinder3;

    CSensrvChannelFinder* tempChannelFinder4;

    CSensrvChannelFinder* tempChannelFinder5;

    CSensrvChannelFinder* tempChannelFinder6;

    CSensrvChannelFinder* tempChannelFinder7;

    CSensrvChannelFinder* tempChannelFinder8;

    CSensrvChannelFinder* tempChannelFinder9;

    CSensrvChannelFinder* tempChannelFinder10;

    CSensrvChannelFinder* tempChannelFinder11;

    CSensrvChannelFinder* tempChannelFinder12;

    CSensrvChannelFinder* tempChannelFinder13;

    CSensrvChannelFinder* tempChannelFinder14;

    CSensrvChannelFinder* tempChannelFinder15;

    CSensrvChannelFinder* tempChannelFinder16;

    CSensrvChannelFinder* tempChannelFinder17;

    CSensrvChannelFinder* tempChannelFinder18;

    CSensrvChannelFinder* tempChannelFinder19;

    CSensrvChannelFinder* tempChannelFinder20;

    tempChannelFinder1 = CSensrvChannelFinder::NewL();

    tempChannelFinder2 = CSensrvChannelFinder::NewL();

    tempChannelFinder3 = CSensrvChannelFinder::NewL();

    tempChannelFinder4 = CSensrvChannelFinder::NewL();

    tempChannelFinder5 = CSensrvChannelFinder::NewL();

    tempChannelFinder6 = CSensrvChannelFinder::NewL();

    tempChannelFinder7 = CSensrvChannelFinder::NewL();

    tempChannelFinder8 = CSensrvChannelFinder::NewL();

    tempChannelFinder9 = CSensrvChannelFinder::NewL();

    tempChannelFinder10 = CSensrvChannelFinder::NewL();

    tempChannelFinder11 = CSensrvChannelFinder::NewL();

    tempChannelFinder12 = CSensrvChannelFinder::NewL();

    tempChannelFinder13 = CSensrvChannelFinder::NewL();

    tempChannelFinder14 = CSensrvChannelFinder::NewL();

    tempChannelFinder15 = CSensrvChannelFinder::NewL();

    tempChannelFinder16 = CSensrvChannelFinder::NewL();

    tempChannelFinder17 = CSensrvChannelFinder::NewL();

    tempChannelFinder18 = CSensrvChannelFinder::NewL();

    tempChannelFinder19 = CSensrvChannelFinder::NewL();

    tempChannelFinder20 = CSensrvChannelFinder::NewL();

    //List of found channels.

    RSensrvChannelInfoList tempChannelInfoList;

    TSensrvChannelInfo tempChannelInfo;

    tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

    //Find the channel

    tempChannelFinder1->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder2->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder3->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder4->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder5->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder6->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder7->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder8->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder9->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder10->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder11->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder12->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder13->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder14->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder15->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder16->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder17->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder18->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder19->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempChannelFinder20->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    delete tempChannelFinder1;

    delete tempChannelFinder2;

    delete tempChannelFinder3;

    delete tempChannelFinder4;

    delete tempChannelFinder5;

    delete tempChannelFinder6;

    delete tempChannelFinder7;

    delete tempChannelFinder8;

    delete tempChannelFinder9;

    delete tempChannelFinder10;

    delete tempChannelFinder11;

    delete tempChannelFinder12;

    delete tempChannelFinder13;

    delete tempChannelFinder14;

    delete tempChannelFinder15;

    delete tempChannelFinder16;

    delete tempChannelFinder17;

    delete tempChannelFinder18;

    delete tempChannelFinder19;

    delete tempChannelFinder20;

    return KErrNone;

    }

TInt CSensrvTest::TestOpenClose( CStifItemParser& /*aItem*/ )

    {

    RDebug::Print( _L("CSensrvTest::TestOpenCloseL") );

    TInt err = CheckTest();

    if( err )

        {

        RDebug::Print( _L("CSensrvTest::TestOpenCloseL Test Creattion error: %d"), err );

        return err;

        }

    CSensrvChannelFinder* tempChannelFinder;

    CSensrvChannel* tempSensorChannel;

    TRAP(err, tempChannelFinder = CSensrvChannelFinder::NewL());

    if( err )

        {

        RDebug::Print( _L("tempChannelFinder = CSensrvChannelFinder::NewL() error: %d"), err );

        return err;

        }

    //List of found channels.

    RSensrvChannelInfoList tempChannelInfoList;

    TSensrvChannelInfo tempChannelInfo;

    tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

    //Find the channel

    TRAP(err, tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo ));

    if( err )

        {

        RDebug::Print( _L("tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo ) error: %d"), err );

        return err;

        }        

    TRAP(err, tempSensorChannel = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] ));

    if( err )

        {

        RDebug::Print( _L("tempSensorChannel = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] ) error: %d"), err );

        return err;

        }

    for (TInt i =0; i <100; i++)

        {

        //Open the channel

        TRAP(err, tempSensorChannel->OpenChannelL());

        if( err )

            {

            RDebug::Print( _L("tempSensorChannel->OpenChannelL() error: %d"), err );

            return err;

            }

        User::After(1000000);

        //Close the channel

        TRAP(err, tempSensorChannel->CloseChannel());

        if( err )

            {

            RDebug::Print( _L("tempSensorChannel->CloseChannel() error: %d"), err );

            return err;

            }

        }

    delete tempChannelFinder;

    delete tempSensorChannel;

    RDebug::Print( _L("CSensrvTest::TestOpenCloseL") );

    return err;

    }

TInt CSensrvTest::TestOpenCloseSensorL( CStifItemParser& /*aItem*/ )

    {

    CSensrvChannelFinder* tempChannelFinder;

    CSensrvChannel* tempSensorChannel1;

    CSensrvChannel* tempSensorChannel2;

    CSensrvChannel* tempSensorChannel3;

    _LIT(KAccelerometerSSY, "Ssy@1");

    _LIT(KMagnetometerSSY, "Ssy@2");

    _LIT(KProximitySSY, "Ssy@3");

    TRequestStatus status;

    RProcess ssyProcess;

    TFullName ssyName;

    TFindProcess findProcess;

    TInt returnValue;

    TInt err = CheckTest();

    if( err )

        {

        RDebug::Print( _L("CSensrvTest::TestOpenCloseL Test Creattion error: %d"), err );

        return err;

        }

    tempChannelFinder = CSensrvChannelFinder::NewL();    

    //List of found channels.

    RSensrvChannelInfoList tempChannelInfoList;

    TSensrvChannelInfo tempChannelInfo;

    tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

    //Find the channel

    tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    //Checking for accelerometer

    tempSensorChannel1 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

        {

        //Open the channel

        tempSensorChannel1->OpenChannelL();

        User::After(1000000);

        //Close the channel

        tempSensorChannel1->CloseChannel();

        // SSY takes about a min to unload itself when there are no sessions

        User::After(70000000);

        //Checking whether the SSY is unloaded or not

        findProcess.Find(KAccelerometerSSY);

        if ( findProcess.Next(ssyName) == KErrNone )

            {

            returnValue = ssyProcess.Open(ssyName);

            ssyProcess.Logon(status);

            User::WaitForRequest(status); 

            ssyProcess.Close();

            }

        }        

        //Checking for Magnetometer

    tempChannelInfo.iChannelType = KSensrvChannelTypeIdMagnetometerXYZAxisData;

    //Find the channel

    tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempSensorChannel2 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

        {

        //Open the channel

        tempSensorChannel2->OpenChannelL();

        User::After(1000000);

        //Close the channel

        tempSensorChannel2->CloseChannel();

        // SSY takes about a min to unload itself when there are no sessions

        User::After(70000000);

        //Checking whether the SSY is unloaded or not

        findProcess.Find(KMagnetometerSSY);

        if ( findProcess.Next(ssyName) == KErrNone )

            {

            returnValue = ssyProcess.Open(ssyName);

            ssyProcess.Logon(status);

            User::WaitForRequest(status); 

            ssyProcess.Close();

            }

        } 

    tempChannelInfo.iChannelType = KSensrvChannelTypeIdAmbientLightData;

    //Find the channel

    tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

    tempSensorChannel3 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

        {

        //Open the channel

        tempSensorChannel3->OpenChannelL();

        User::After(1000000);

        //Close the channel

        tempSensorChannel3->CloseChannel();

        // SSY takes about a min to unload itself when there are no sessions

        User::After(70000000);

        //Checking whether the SSY is unloaded or not

        findProcess.Find(KProximitySSY);

        if ( findProcess.Next(ssyName) == KErrNone )

            {

            returnValue = ssyProcess.Open(ssyName);

            ssyProcess.Logon(status);

            User::WaitForRequest(status);