1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  ?Description

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <e32svr.h>

    22 #include <StifParser.h>

    23 #include <Stiftestinterface.h>

    24 #include "SensrvTest.h"

    25 #include "sensrvchannelfinder.h"

    26 #include "sensrvchannel.h"

    27 #include "SensrvInternalPSKeys.h"

    28 #include "sensrvtestclient.h"

    29 #include "sensrvtestcases.h"

    30 #include "sensrvchanneldatatypes.h"

    31 #include "sensrvchannelcondition.h"

    32 #include "sensrvchannelconditionsetimpl.h"

    33 #include "sensrvtesttypes.h"

    34 #include "sensrvgeneralproperties.h"

    35 

    36 // EXTERNAL DATA STRUCTURES

    37 //extern  ?external_data;

    38 

    39 // EXTERNAL FUNCTION PROTOTYPES

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

    41 

    42 // CONSTANTS

    43 //const ?type ?constant_var = ?constant;

    44 

    45 // MACROS

    46 //#define ?macro ?macro_def

    47 

    48 // LOCAL CONSTANTS AND MACROS

    49 //const ?type ?constant_var = ?constant;

    50 //#define ?macro_name ?macro_def

    51 

    52 // MODULE DATA STRUCTURES

    53 //enum ?declaration

    54 //typedef ?declaration

    55 

    56 // LOCAL FUNCTION PROTOTYPES

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

    58 

    59 // FORWARD DECLARATIONS

    60 //class ?FORWARD_CLASSNAME;

    61 

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

    63 

    64 // -----------------------------------------------------------------------------

    65 // ?function_name ?description.

    66 // ?description

    67 // Returns: ?value_1: ?description

    68 //          ?value_n: ?description_line1

    69 //                    ?description_line2

    70 // -----------------------------------------------------------------------------

    71 //

    72 /*

    73 ?type ?function_name(

    74     ?arg_type arg,  // ?description

    75     ?arg_type arg)  // ?description

    76     {

    77 

    78     ?code  // ?comment

    79 

    80     // ?comment

    81     ?code

    82     }

    83 */

    84 

    85 

    86 

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

    88 

    89 // -----------------------------------------------------------------------------

    90 // CSensrvTest::Delete

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

    92 // Called from destructor.

    93 // -----------------------------------------------------------------------------

    94 //

    95 void CSensrvTest::Delete()

    96     {

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

    98 

    99     if( iTestCases )

   100         {

   101         TRequestStatus status;

   102         iThread.Logon( status );

   103         iTestCases->StopTest();

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

   105         User::WaitForRequest( status );

   106         }

   107 

   108 

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

   110     }

   111 

   112 // -----------------------------------------------------------------------------

   113 // CSensrvTest::RunMethodL

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

   115 // -----------------------------------------------------------------------------

   116 //

   117 

   118 

   119 TInt CSensrvTest::RunMethodL(

   120     CStifItemParser& aItem )

   121     {

   122 

   123     static TStifFunctionInfo const KFunctions[] =

   124         {

   125         // Copy this line for every implemented function.

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

   127         // Second is the actual implementation member function.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   173             //Regression Tests

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

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

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

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

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

   179             ENTRY( "TestChannelFinderL", CSensrvTest::TestChannelFinderL)

   180         };

   181 

   182     const TInt count = sizeof( KFunctions ) /

   183                         sizeof( TStifFunctionInfo );

   184 

   185 

   186     return RunInternalL( KFunctions, count, aItem );

   187 

   188     }

   189 

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

   191     {

   192     CSensrvChannelFinder* tempChannelFinder;

   193     CSensrvChannel* tempSensorChannel1;

   194     CSensrvChannel* tempSensorChannel2;

   195     CSensrvChannel* tempSensorChannel3;

   196     

   197     TInt err = CheckTest();

   198     if( err )

   199         {

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

   201         return err;

   202         }

   203     

   204     tempChannelFinder = CSensrvChannelFinder::NewL();    

   205             

   206     //List of found channels.

   207     RSensrvChannelInfoList tempChannelInfoList;

   208     TSensrvChannelInfo tempChannelInfo;

   209 

   210     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

   211 

   212     //Find the channel

   213     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   214     //10 channels & wait for more than 10 seconds        

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

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

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

   218     

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

   220         {

   221         //Open the channel

   222         tempSensorChannel1->OpenChannelL();

   223         tempSensorChannel2->OpenChannelL();

   224         tempSensorChannel3->OpenChannelL();

   225             

   226         User::After(1000000);

   227                                 

   228         //Close the channel

   229         tempSensorChannel1->CloseChannel();

   230         tempSensorChannel2->CloseChannel();

   231         tempSensorChannel3->CloseChannel();

   232             

   233         User::After(7000000);

   234         }

   235     

   236     delete tempChannelFinder;

   237     delete tempSensorChannel1;

   238     delete tempSensorChannel2;

   239     delete tempSensorChannel3;

   240     

   241     return err;

   242     }

   243 

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

   245     {

   246     CSensrvChannelFinder* tempChannelFinder1;

   247     CSensrvChannelFinder* tempChannelFinder2;

   248     CSensrvChannelFinder* tempChannelFinder3;

   249     CSensrvChannelFinder* tempChannelFinder4;

   250     CSensrvChannelFinder* tempChannelFinder5;

   251     CSensrvChannelFinder* tempChannelFinder6;

   252     CSensrvChannelFinder* tempChannelFinder7;

   253     CSensrvChannelFinder* tempChannelFinder8;

   254     CSensrvChannelFinder* tempChannelFinder9;

   255     CSensrvChannelFinder* tempChannelFinder10;

   256     CSensrvChannelFinder* tempChannelFinder11;

   257     CSensrvChannelFinder* tempChannelFinder12;

   258     CSensrvChannelFinder* tempChannelFinder13;

   259     CSensrvChannelFinder* tempChannelFinder14;

   260     CSensrvChannelFinder* tempChannelFinder15;

   261     CSensrvChannelFinder* tempChannelFinder16;

   262     CSensrvChannelFinder* tempChannelFinder17;

   263     CSensrvChannelFinder* tempChannelFinder18;

   264     CSensrvChannelFinder* tempChannelFinder19;

   265     CSensrvChannelFinder* tempChannelFinder20;

   266     

   267     tempChannelFinder1 = CSensrvChannelFinder::NewL();

   268     tempChannelFinder2 = CSensrvChannelFinder::NewL();

   269     tempChannelFinder3 = CSensrvChannelFinder::NewL();

   270     tempChannelFinder4 = CSensrvChannelFinder::NewL();

   271     tempChannelFinder5 = CSensrvChannelFinder::NewL();

   272     tempChannelFinder6 = CSensrvChannelFinder::NewL();

   273     tempChannelFinder7 = CSensrvChannelFinder::NewL();

   274     tempChannelFinder8 = CSensrvChannelFinder::NewL();

   275     tempChannelFinder9 = CSensrvChannelFinder::NewL();

   276     tempChannelFinder10 = CSensrvChannelFinder::NewL();

   277     tempChannelFinder11 = CSensrvChannelFinder::NewL();

   278     tempChannelFinder12 = CSensrvChannelFinder::NewL();

   279     tempChannelFinder13 = CSensrvChannelFinder::NewL();

   280     tempChannelFinder14 = CSensrvChannelFinder::NewL();

   281     tempChannelFinder15 = CSensrvChannelFinder::NewL();

   282     tempChannelFinder16 = CSensrvChannelFinder::NewL();

   283     tempChannelFinder17 = CSensrvChannelFinder::NewL();

   284     tempChannelFinder18 = CSensrvChannelFinder::NewL();

   285     tempChannelFinder19 = CSensrvChannelFinder::NewL();

   286     tempChannelFinder20 = CSensrvChannelFinder::NewL();

   287     

   288     //List of found channels.

   289     RSensrvChannelInfoList tempChannelInfoList;

   290     TSensrvChannelInfo tempChannelInfo;

   291 

   292     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

   293 

   294     //Find the channel

   295     tempChannelFinder1->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   296     tempChannelFinder2->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   297     tempChannelFinder3->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   298     tempChannelFinder4->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   299     tempChannelFinder5->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   300     tempChannelFinder6->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   301     tempChannelFinder7->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   302     tempChannelFinder8->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   303     tempChannelFinder9->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   304     tempChannelFinder10->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   305     tempChannelFinder11->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   306     tempChannelFinder12->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   307     tempChannelFinder13->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   308     tempChannelFinder14->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   309     tempChannelFinder15->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   310     tempChannelFinder16->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   311     tempChannelFinder17->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   312     tempChannelFinder18->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   313     tempChannelFinder19->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   314     tempChannelFinder20->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   315     

   316     delete tempChannelFinder1;

   317     delete tempChannelFinder2;

   318     delete tempChannelFinder3;

   319     delete tempChannelFinder4;

   320     delete tempChannelFinder5;

   321     delete tempChannelFinder6;

   322     delete tempChannelFinder7;

   323     delete tempChannelFinder8;

   324     delete tempChannelFinder9;

   325     delete tempChannelFinder10;

   326     delete tempChannelFinder11;

   327     delete tempChannelFinder12;

   328     delete tempChannelFinder13;

   329     delete tempChannelFinder14;

   330     delete tempChannelFinder15;

   331     delete tempChannelFinder16;

   332     delete tempChannelFinder17;

   333     delete tempChannelFinder18;

   334     delete tempChannelFinder19;

   335     delete tempChannelFinder20;

   336 

   337     return KErrNone;

   338     }

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

   340     {

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

   342     

   343     TInt err = CheckTest();

   344     if( err )

   345         {

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

   347         return err;

   348         }

   349     

   350     CSensrvChannelFinder* tempChannelFinder;

   351     CSensrvChannel* tempSensorChannel;

   352         

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

   354     if( err )

   355         {

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

   357         return err;

   358         }

   359             

   360     //List of found channels.

   361     RSensrvChannelInfoList tempChannelInfoList;

   362     TSensrvChannelInfo tempChannelInfo;

   363 

   364     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

   365 

   366     //Find the channel

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

   368     if( err )

   369         {

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

   371         return err;

   372         }        

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

   374     if( err )

   375         {

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

   377         return err;

   378         }

   379         

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

   381         {

   382         //Open the channel

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

   384         if( err )

   385             {

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

   387             return err;

   388             }

   389                 

   390         User::After(1000000);

   391                 

   392         //Close the channel

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

   394         if( err )

   395             {

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

   397             return err;

   398             }

   399         }

   400         

   401     delete tempChannelFinder;

   402     delete tempSensorChannel;

   403     

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

   405     

   406     return err;

   407     }

   408 

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

   410     {

   411     CSensrvChannelFinder* tempChannelFinder;

   412     CSensrvChannel* tempSensorChannel1;

   413     CSensrvChannel* tempSensorChannel2;

   414     CSensrvChannel* tempSensorChannel3;

   415         

   416     _LIT(KAccelerometerSSY, "Ssy@1");

   417     _LIT(KMagnetometerSSY, "Ssy@2");

   418     _LIT(KProximitySSY, "Ssy@3");

   419         

   420     TRequestStatus status;

   421     RProcess ssyProcess;

   422     TFullName ssyName;

   423     TFindProcess findProcess;

   424     TInt returnValue;

   425     

   426     TInt err = CheckTest();

   427     if( err )

   428         {

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

   430         return err;

   431         }

   432         

   433     tempChannelFinder = CSensrvChannelFinder::NewL();    

   434             

   435     //List of found channels.

   436     RSensrvChannelInfoList tempChannelInfoList;

   437     TSensrvChannelInfo tempChannelInfo;

   438 

   439     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

   440 

   441     //Find the channel

   442     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   443 

   444     //Checking for accelerometer

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

   446         {

   447         //Open the channel

   448         tempSensorChannel1->OpenChannelL();

   449         

   450         User::After(1000000);

   451         

   452         //Close the channel

   453         tempSensorChannel1->CloseChannel();

   454             

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

   456         User::After(70000000);

   457             

   458         //Checking whether the SSY is unloaded or not

   459         findProcess.Find(KAccelerometerSSY);

   460 

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

   462             {

   463             returnValue = ssyProcess.Open(ssyName);

   464             ssyProcess.Logon(status);

   465             User::WaitForRequest(status); 

   466             ssyProcess.Close();

   467             }

   468             

   469         }        

   470         

   471         //Checking for Magnetometer

   472     tempChannelInfo.iChannelType = KSensrvChannelTypeIdMagnetometerXYZAxisData;

   473 

   474     //Find the channel

   475     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   476         

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

   478         {

   479         //Open the channel

   480         tempSensorChannel2->OpenChannelL();

   481                 

   482         User::After(1000000);

   483             

   484         //Close the channel

   485         tempSensorChannel2->CloseChannel();

   486                     

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

   488         User::After(70000000);

   489                     

   490         //Checking whether the SSY is unloaded or not

   491         findProcess.Find(KMagnetometerSSY);

   492 

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

   494             {

   495             returnValue = ssyProcess.Open(ssyName);

   496             ssyProcess.Logon(status);

   497             User::WaitForRequest(status); 

   498             ssyProcess.Close();

   499             }

   500                     

   501         } 

   502             

   503     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAmbientLightData;

   504 

   505     //Find the channel

   506     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   507                 

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

   509         {

   510         //Open the channel

   511         tempSensorChannel3->OpenChannelL();

   512             

   513         User::After(1000000);

   514                     

   515         //Close the channel

   516         tempSensorChannel3->CloseChannel();

   517             

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

   519         User::After(70000000);

   520                             

   521         //Checking whether the SSY is unloaded or not

   522         findProcess.Find(KProximitySSY);

   523 

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

   525             {

   526             returnValue = ssyProcess.Open(ssyName);

   527             ssyProcess.Logon(status);

   528             User::WaitForRequest(status); 

   529             ssyProcess.Close();

   530             }

   531                             

   532         }

   533             

   534     delete tempChannelFinder;

   535     delete tempSensorChannel1;

   536     delete tempSensorChannel2;

   537     delete tempSensorChannel3;

   538     

   539     return err;

   540     }

   541 

   542 TInt CSensrvTest::TestOpenCloseSensorsL( CStifItemParser& aItem )

   543     {

   544     CSensrvChannelFinder* tempChannelFinder;

   545     CSensrvChannel* tempSensorChannel1;

   546     CSensrvChannel* tempSensorChannel2;

   547     CSensrvChannel* tempSensorChannel3;

   548         

   549     _LIT(KAccelerometerSSY, "Ssy@1");

   550     _LIT(KMagnetometerSSY, "Ssy@2");

   551     _LIT(KProximitySSY, "Ssy@3");

   552         

   553     TRequestStatus status;

   554     RProcess ssyProcess;

   555     TFullName name;

   556     TFindProcess findProcess;

   557     TInt returnValue;

   558         

   559     returnValue = ShutdownServer(aItem);

   560          

   561     User::After(3000000);

   562     

   563     returnValue = CheckServerAlive(aItem);

   564         

   565     tempChannelFinder = CSensrvChannelFinder::NewL();    

   566             

   567     //List of found channels.

   568     RSensrvChannelInfoList tempChannelInfoList;

   569     TSensrvChannelInfo tempChannelInfo;

   570 

   571     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

   572 

   573     //Find the channel

   574     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   575 

   576     //Checking for accelerometer

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

   578         {

   579         //Open the channel

   580         tempSensorChannel1->OpenChannelL();

   581                 

   582         User::After(1000000);

   583             

   584         //Close the channel

   585         tempSensorChannel1->CloseChannel();

   586             

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

   588         User::After(70000000);

   589             

   590         //Checking whether the SSY is unloaded or not

   591         findProcess.Find(KAccelerometerSSY);

   592 

   593         if ( findProcess.Next(name) == KErrNone )

   594             {

   595             returnValue = ssyProcess.Open(name);

   596             ssyProcess.Logon(status);

   597             User::WaitForRequest(status); 

   598             ssyProcess.Close();

   599             }

   600             

   601         }        

   602         

   603     //Checking for Magnetometer

   604     tempChannelInfo.iChannelType = KSensrvChannelTypeIdMagnetometerXYZAxisData;

   605 

   606     //Find the channel

   607     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   608         

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

   610         {

   611         //Open the channel

   612         tempSensorChannel2->OpenChannelL();

   613         

   614         User::After(1000000);

   615             

   616         //Close the channel

   617         tempSensorChannel2->CloseChannel();

   618                     

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

   620         User::After(70000000);

   621                     

   622         //Checking whether the SSY is unloaded or not

   623         findProcess.Find(KMagnetometerSSY);

   624 

   625         if ( findProcess.Next(name) == KErrNone )

   626             {

   627             returnValue = ssyProcess.Open(name);

   628             ssyProcess.Logon(status);

   629             User::WaitForRequest(status); 

   630             ssyProcess.Close();

   631             }

   632                     

   633         } 

   634             

   635     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAmbientLightData;

   636 

   637     //Find the channel

   638     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   639                 

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

   641         {

   642         //Open the channel

   643         tempSensorChannel3->OpenChannelL();

   644             

   645         User::After(1000000);

   646         

   647         //Close the channel

   648         tempSensorChannel3->CloseChannel();

   649             

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

   651         User::After(70000000);

   652                             

   653         //Checking whether the SSY is unloaded or not

   654         findProcess.Find(KProximitySSY);

   655 

   656         if ( findProcess.Next(name) == KErrNone )

   657             {

   658             returnValue = ssyProcess.Open(name);

   659             ssyProcess.Logon(status);

   660             User::WaitForRequest(status); 

   661             ssyProcess.Close();

   662             }

   663                             

   664         }

   665             

   666     delete tempChannelFinder;

   667         

   668     User::After(3000000);

   669     

   670     returnValue = CheckServerAlive(aItem);    

   671     

   672     if (returnValue == KErrNotFound)

   673         {

   674         returnValue = KErrNone;

   675         }

   676     delete tempSensorChannel1;

   677     delete tempSensorChannel2;

   678     delete tempSensorChannel3;

   679     

   680     return returnValue;

   681     }

   682 

   683 TInt CSensrvTest::TestOpenCloseCombinationSensorsL( CStifItemParser& aItem )

   684     {

   685     CSensrvChannelFinder* tempChannelFinder;

   686     CSensrvChannel* tempSensorChannel1;

   687     CSensrvChannel* tempSensorChannel2;

   688     CSensrvChannel* tempSensorChannel3;

   689     CSensrvChannel* tempSensorChannel4;

   690     CSensrvChannel* tempSensorChannel5;

   691     CSensrvChannel* tempSensorChannel6;

   692     

   693     _LIT(KAccelerometerSSY, "Ssy@1");

   694     _LIT(KMagnetometerSSY, "Ssy@2");

   695     _LIT(KProximitySSY, "Ssy@3");

   696     

   697     TRequestStatus status;

   698     RProcess ssyProcess;

   699     TFullName name;

   700     TFindProcess findProcess;

   701     TInt returnValue;

   702             

   703     //check for sensorserver existance.. if it exits, kill it

   704     returnValue = ShutdownServer(aItem);

   705     

   706     User::After(3000000);

   707         

   708     returnValue = CheckServerAlive(aItem);

   709     

   710     tempChannelFinder = CSensrvChannelFinder::NewL();    

   711         

   712     //List of found channels.

   713     RSensrvChannelInfoList tempChannelInfoList;

   714     TSensrvChannelInfo tempChannelInfo;

   715 

   716     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAccelerometerXYZAxisData;

   717 

   718     //Find the channel

   719     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   720 

   721     //Checking for accelerometer

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

   723         {

   724         //Open the channel

   725         tempSensorChannel1->OpenChannelL();

   726             

   727         User::After(1000000);

   728         

   729         //Close the channel

   730         tempSensorChannel1->CloseChannel();

   731         

   732         }        

   733 

   734     tempChannelInfo.iChannelType = KSensrvChannelTypeIdOrientationData;

   735 

   736     //Find the channel

   737     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   738     

   739     //Checking for accelerometer

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

   741         {

   742         //Open the channel

   743         tempSensorChannel2->OpenChannelL();

   744         

   745         User::After(1000000);

   746             

   747         //Close the channel

   748         tempSensorChannel2->CloseChannel();

   749             

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

   751         User::After(70000000);

   752         

   753         //Checking whether the SSY is unloaded or not

   754         findProcess.Find(KAccelerometerSSY);

   755         

   756         if ( findProcess.Next(name) == KErrNone )

   757             {

   758             returnValue = ssyProcess.Open(name);

   759             ssyProcess.Logon(status);

   760             User::WaitForRequest(status); 

   761             ssyProcess.Close();

   762             }

   763             

   764         }

   765     delete tempChannelFinder;

   766     //Wait for sensorserver to shutdown gracefully, it will take some time..

   767     User::After(30000000);    

   768     

   769     tempChannelFinder = CSensrvChannelFinder::NewL();  

   770     

   771     //Checking for Magnetometer

   772     tempChannelInfo.iChannelType = KSensrvChannelTypeIdMagnetometerXYZAxisData;

   773 

   774     //Find the channel

   775     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   776     

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

   778         {

   779         //Open the channel

   780         tempSensorChannel3->OpenChannelL();

   781             

   782         User::After(1000000);

   783         

   784         //Close the channel

   785         tempSensorChannel3->CloseChannel();

   786                 

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

   788         User::After(70000000);

   789                 

   790         //Checking whether the SSY is unloaded or not

   791         findProcess.Find(KMagnetometerSSY);

   792 

   793         if ( findProcess.Next(name) == KErrNone )

   794             {

   795             returnValue = ssyProcess.Open(name);

   796             ssyProcess.Logon(status);

   797             User::WaitForRequest(status); 

   798             ssyProcess.Close();

   799             }

   800                 

   801         } 

   802  

   803     //Checking for Magnetometer

   804     tempChannelInfo.iChannelType = KSensrvChannelTypeIdMagneticNorthData;

   805 

   806     //Find the channel

   807     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   808         

   809     tempSensorChannel4 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

   810         {

   811         //Open the channel

   812         tempSensorChannel4->OpenChannelL();

   813         

   814         User::After(1000000);

   815         

   816         //Close the channel

   817         tempSensorChannel4->CloseChannel();

   818         

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

   820         User::After(70000000);

   821                     

   822         //Checking whether the SSY is unloaded or not

   823         findProcess.Find(KMagnetometerSSY);

   824 

   825         if ( findProcess.Next(name) == KErrNone )

   826             {

   827             returnValue = ssyProcess.Open(name);

   828             ssyProcess.Logon(status);

   829             User::WaitForRequest(status); 

   830             ssyProcess.Close();

   831             }

   832         } 

   833 

   834     delete tempChannelFinder;

   835     

   836     //Wait for the sensorserver to shutdown

   837     

   838     User::After(3000000);

   839     

   840     tempChannelFinder = CSensrvChannelFinder::NewL();  

   841     //Checking for Magnetometer

   842     tempChannelInfo.iChannelType = KSensrvChannelTypeIdMagneticNorthData;

   843 

   844     //Find the channel

   845     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   846             

   847     tempSensorChannel5 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

   848         {

   849         //Open the channel

   850         tempSensorChannel5->OpenChannelL();

   851             

   852         User::After(1000000);

   853             

   854         //Close the channel

   855         tempSensorChannel5->CloseChannel();

   856             

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

   858         User::After(70000000);

   859                         

   860         //Checking whether the SSY is unloaded or not

   861         findProcess.Find(KMagnetometerSSY);

   862 

   863         if ( findProcess.Next(name) == KErrNone )

   864             {

   865             returnValue = ssyProcess.Open(name);

   866             ssyProcess.Logon(status);

   867             User::WaitForRequest(status); 

   868             ssyProcess.Close();

   869             }

   870         }         

   871         

   872     tempChannelInfo.iChannelType = KSensrvChannelTypeIdAmbientLightData;

   873 

   874     //Find the channel

   875     tempChannelFinder->FindChannelsL( tempChannelInfoList, tempChannelInfo );

   876             

   877     tempSensorChannel6 = CSensrvChannel::NewL( tempChannelInfoList[ 0 ] );

   878         {

   879         //Open the channel

   880         tempSensorChannel6->OpenChannelL();

   881         

   882         User::After(1000000);

   883                 

   884         //Close the channel

   885         tempSensorChannel6->CloseChannel();

   886         

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

   888         User::After(70000000);

   889                         

   890         //Checking whether the SSY is unloaded or not

   891         findProcess.Find(KProximitySSY);

   892 

   893         if ( findProcess.Next(name) == KErrNone )

   894             {

   895             returnValue = ssyProcess.Open(name);

   896             ssyProcess.Logon(status);

   897             User::WaitForRequest(status); 

   898             ssyProcess.Close();

   899             }

   900                         

   901         }

   902         

   903     delete tempChannelFinder;

   904     

   905     User::After(3000000);

   906         

   907     returnValue = CheckServerAlive(aItem); 

   908     

   909     if (returnValue == KErrNotFound)

   910         {

   911         returnValue = KErrNone;

   912         }

   913     

   914     delete tempSensorChannel1;

   915     delete tempSensorChannel2;

   916     delete tempSensorChannel3;

   917     delete tempSensorChannel4;

   918     delete tempSensorChannel5;

   919     delete tempSensorChannel6;

   920     

   921     return returnValue;

   922     }

   923 // -----------------------------------------------------------------------------

   924 // CSensrvTest::SetPSValue

   925 // Parameters: SRKey form SensrvInternalPSKeys.h(TUint32), value(TInt)

   926 //

   927 // -----------------------------------------------------------------------------

   928 //

   929 TInt CSensrvTest::SetPSValue( CStifItemParser& aItem )

   930     {

   931     RDebug::Print( _L("CSensrvTest::SetPSValue") );

   932 

   933     TUint srKey;

   934     TInt value;

   935 

   936     TInt err = aItem.GetNextInt( srKey );

   937     if( err )

   938         {

   939         RDebug::Print( _L("CSensrvTest::SetPSValue: srKey error: %d"), err );

   940         return err;

   941         }

   942 

   943     err = aItem.GetNextInt( value );

   944     if( err )

   945         {

   946         RDebug::Print(  _L("CSensrvTest::SetPSValue: value error: %d"), err );

   947         return err;

   948         }

   949 

   950     RDebug::Print( _L("CSensrvTest::SetPSValue - RProperty::Set( %d, %d )"), srKey, value );

   951 

   952     return RProperty::Set( KPSUidSensrvTest, srKey, value );

   953 

   954     }

   955 

   956 // -----------------------------------------------------------------------------

   957 // CSensrvTest::SetPSValue to test process

   958 // Parameters:

   959 //             TUInt   - process ID

   960 //             TUInt   - command

   961 //             TInt    - expected result

   962 //             TInt    - PropertyId

   963 //             TInt    - Property index

   964 //             TInt    - Property value

   965 //

   966 // -----------------------------------------------------------------------------

   967 //

   968 TInt CSensrvTest::SetProcessPSValue( CStifItemParser& aItem )

   969     {

   970     RDebug::Print( _L("CSensrvTest::SetProcessPSValue") );

   971 

   972     TInt  valueTInt;

   973     TUint valueTUInt;

   974     TPckgBuf< TSensrvProcessData > buf;

   975 /*

   976     TInt err = aItem.GetNextInt( srKey );

   977     if( err )

   978         {

   979         RDebug::Print( _L("CSensrvTest::SetProcessPSValue: srKey error: %d"), err );

   980         return err;

   981         }

   982 */

   983     TInt err = aItem.GetNextInt( valueTUInt );

   984     if( err )

   985         {

   986         RDebug::Print(  _L("CSensrvTest::SetProcessPSValue: value error1: %d"), err );

   987         return err;

   988         }

   989     buf().iProcessID = valueTUInt;

   990 

   991     err = aItem.GetNextInt( valueTUInt );

   992     if( err )

   993         {

   994         RDebug::Print(  _L("CSensrvTest::SetProcessPSValue: value error2: %d"), err );

   995         return err;

   996         }

   997     buf().iCommand = valueTUInt;

   998 

   999     err = aItem.GetNextInt( valueTInt );

  1000     if( err )

  1001         {

  1002         RDebug::Print(  _L("CSensrvTest::SetProcessPSValue: value error3: %d"), err );

  1003         return err;

  1004         }

  1005     buf().iExpectedResult = valueTInt;

  1006 

  1007 

  1008     //Property

  1009     TInt propertyId(0);

  1010     TInt propertyIndex(0);

  1011     TInt propertyValue(0);

  1012 

  1013     err = aItem.GetNextInt( propertyId );

  1014     err = aItem.GetNextInt( propertyIndex );

  1015 

  1016     if( !err )

  1017         {

  1018         if( propertyId == KSensrvPropIdDataRate )

  1019             {

  1020             aItem.GetNextInt( propertyValue );

  1021             buf().iProperty.SetPropertyId( KSensrvPropIdDataRate );

  1022             buf().iProperty.SetValue( propertyValue );

  1023             buf().iProperty.SetItemIndex( propertyIndex );

  1024             }

  1025         else if( propertyId == KSensrvPropIdAvailability )

  1026             {

  1027             aItem.GetNextInt( propertyValue );

  1028             buf().iProperty.SetPropertyId( KSensrvPropIdAvailability  );

  1029             buf().iProperty.SetValue( propertyValue );

  1030             buf().iProperty.SetItemIndex( propertyIndex );

  1031             }

  1032         else

  1033             {

  1034             RDebug::Print(  _L("CSensrvTest::SetProcessPSValue: property set to zero") );

  1035             buf().iProperty.SetPropertyId( 0 );

  1036             buf().iProperty.SetValue( 0 );

  1037             buf().iProperty.SetItemIndex( 0 );

  1038             }

  1039         }

  1040 

  1041 

  1042     return RProperty::Set( KPSUidSensrvTest, KSensrvTestProcessCommand, buf );

  1043     }

  1044 

  1045 // -----------------------------------------------------------------------------

  1046 // CSensrvTest::SetCompletedKey

  1047 // Parameters: SRKey form SensrvInternalPSKeys.h(TUint32)

  1048 //

  1049 // -----------------------------------------------------------------------------

  1050 //

  1051 TInt CSensrvTest::SetCompletedKeyL( CStifItemParser& aItem )

  1052     {

  1053     RDebug::Print( _L("CSensrvTest::SetCompletedKey") );

  1054     TInt err = aItem.GetNextInt( iCompletedKey );

  1055     if( err )

  1056         {

  1057         RDebug::Print( _L("CSensrvTest::SetCompletedKey:  error: %d"), err );

  1058         }

  1059 

  1060     DefinePSKeyL( iCompletedKey, RProperty::EInt );

  1061     RProperty::Set( KPSUidSensrvTest, iCompletedKey, KErrCompletion );

  1062 

  1063     return err;

  1064     }

  1065 

  1066 // -----------------------------------------------------------------------------

  1067 // CSensrvTest::SetGetDataDelay

  1068 // Parameters: Delay in millisecond

  1069 //

  1070 // -----------------------------------------------------------------------------

  1071 //

  1072 TInt CSensrvTest::SetGetDataDelay( CStifItemParser& aItem )

  1073     {

  1074     RDebug::Print( _L("CSensrvTest::SetGetDataDelay") );

  1075     TInt delay;

  1076     TInt err = aItem.GetNextInt( delay );

  1077     if( err )

  1078         {

  1079         RDebug::Print( _L("CSensrvTest::SetGetDataDelay:  error: %d"), err );

  1080         return err;

  1081         }

  1082 

  1083     err = CheckTest();

  1084 

  1085     if( err == KErrNone )

  1086         {

  1087         RDebug::Print( _L("CSensrvTest::SetGetDataDelay: delay: %d"), delay );

  1088         iTestCases->SetGetDataDelay( delay );

  1089         }

  1090 

  1091     return err;

  1092     }

  1093 

  1094 // -----------------------------------------------------------------------------

  1095 // CSensrvTest::WaitCompletedKey

  1096 // Parameters:

  1097 //

  1098 // -----------------------------------------------------------------------------

  1099 //

  1100 TInt CSensrvTest::WaitCompletedKey( CStifItemParser& /*aItem*/ )

  1101     {

  1102     RDebug::Print( _L("CSensrvTest::WaitCompletedKey") );

  1103     TInt err( KErrNone );

  1104     TInt ret( KErrNone );

  1105     if( iTestCases == NULL )

  1106         {

  1107         RDebug::Print( _L("CSensrvTest::WaitCompletedKey: ERROR - iTestCases = NULL") );

  1108         ret = KErrGeneral;

  1109         }

  1110     else

  1111         {

  1112         iTestCases->Mutex().Wait();

  1113         err = RProperty::Get( KPSUidSensrvTest, iCompletedKey, ret );

  1114 

  1115         if( err == KErrNone )

  1116             {

  1117             if( ret == KErrCompletion )

  1118                 {

  1119                 RProperty complete;

  1120                 err = complete.Attach( KPSUidSensrvTest, iCompletedKey );

  1121                 if( err == KErrNone )

  1122                     {

  1123                     // wait for test case complete

  1124                     TRequestStatus status;

  1125                     complete.Subscribe( status );

  1126                     iTestCases->Mutex().Signal();

  1127                     RDebug::Print( _L("CSensrvTest::WaitCompletedKey - Waiting...") );

  1128                     User::WaitForRequest( status );

  1129                     RDebug::Print( _L("CSensrvTest::WaitCompletedKey - Waiting completed") );

  1130                     complete.Get( ret );

  1131                     }

  1132                 else

  1133                     {

  1134                     RDebug::Print( _L("CSensrvTest::WaitCompletedKey:  Attach error: %d"), err );