1 /*

     2 * Copyright (c) 2002 - 2007 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 the License "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 

    21 // INCLUDE FILES

    22 #include <e32svr.h>

    23 #include <StifParser.h>

    24 #include <Stiftestinterface.h>

    25 #include <f32file.h>

    26 #include <hal.h>

    27 #include <liwcommon.h>

    28 #include <LiwServiceHandler.h>

    29 

    30 #include "tsysinfoprovidertests.h"

    31 #include "entitykeys.h"

    32 #include "sysinfoaiwparams.hrh"

    33 #include "tuseractivitynotifier.h"

    34 #include "serviceerrno.h"

    35 

    36 using namespace LIW ;

    37 using namespace SysInfo;

    38 using namespace sysinfoaiwparams;

    39 

    40 _LIT(KROMInstallDir,"\\system\\install\\");

    41 _LIT(KS60ProductIdFile,"Series60v*.sis");

    42 

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

    44 

    45 // -----------------------------------------------------------------------------

    46 // Ctsysinfoprovidertests::Delete

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

    48 // Called from destructor. 

    49 // -----------------------------------------------------------------------------

    50 //

    51 void Ctsysinfoprovidertests::Delete() 

    52     {

    53     if( iInterface )

    54 	    {

    55 		iInterface->Close();

    56 	    }

    57 	if(iServiceHandler)

    58     delete iServiceHandler ;

    59 	

    60     }

    61 

    62 // -----------------------------------------------------------------------------

    63 // Ctsysinfoprovidertests::RunMethodL

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

    65 // -----------------------------------------------------------------------------

    66 //

    67 TInt Ctsysinfoprovidertests::RunMethodL( 

    68     CStifItemParser& aItem ) 

    69     {

    70 

    71     static TStifFunctionInfo const KFunctions[] =

    72         {  

    73 		ENTRY( "VibraStatus",    Ctsysinfoprovidertests::VibraStatus),

    74 	    ENTRY( "VibraSync",    Ctsysinfoprovidertests::VibraSync),

    75 	    ENTRY( "VibraStatus1",    Ctsysinfoprovidertests::VibraStatus1),

    76        

    77         ENTRY( "SetVibraInvalidParamSysDataList",    Ctsysinfoprovidertests::SetVibraInvalidParamSysDataList),

    78         ENTRY( "SetVibraInvalidParamSysData",    Ctsysinfoprovidertests::SetVibraInvalidParamSysData),

    79         ENTRY( "SetVibraInvalidParamEntity",    Ctsysinfoprovidertests::SetVibraInvalidParamEntity),

    80         ENTRY( "SetVibraInvalidParamKey",    Ctsysinfoprovidertests::SetVibraInvalidParamKey),

    81       

    82         ENTRY( "VibraParamMissingEntity",    Ctsysinfoprovidertests::VibraParamMissingEntity),

    83         ENTRY( "VibraParamMissingKey",    Ctsysinfoprovidertests::VibraParamMissingKey),

    84         ENTRY( "VibraParamMissingSysData",    Ctsysinfoprovidertests::VibraParamMissingSysData),

    85         ENTRY( "VibraParamMissingEntityPos",    Ctsysinfoprovidertests::VibraParamMissingEntityPos),

    86         ENTRY( "VibraParamMissingKeyPos",    Ctsysinfoprovidertests::VibraParamMissingKeyPos),

    87         ENTRY( "VibraParamMissingSysDataPos",    Ctsysinfoprovidertests::VibraParamMissingSysDataPos),

    88 

    89         ENTRY( "WrongInterfaceName",    Ctsysinfoprovidertests::WrongInterfaceName),

    90         ENTRY( "LoadingInterfaceMultipletime",    Ctsysinfoprovidertests::LoadingInterfaceMultipletime),

    91        	ENTRY( "VibraInvalidCommand",    Ctsysinfoprovidertests::VibraInvalidCommand),

    92        

    93        ENTRY( "BtNotifyCancel",    Ctsysinfoprovidertests::BtNotifyCancel),

    94        ENTRY( "ActiveConnectionMissingCallback",    Ctsysinfoprovidertests::ActiveConnectionMissingCallback),

    95        ENTRY( "ActiveConnReqCancelMissingTransId",    Ctsysinfoprovidertests::ActiveConnReqCancelMissingTransId),

    96 

    97       	ENTRY( "SupportedLang",    Ctsysinfoprovidertests::SupportedLang),

    98      	

    99       	//input validation tests

   100       	ENTRY( "SetDisplayLang",    Ctsysinfoprovidertests::SetDisplayLang),

   101       	ENTRY( "SetInputLang",    Ctsysinfoprovidertests::SetInputLang),

   102       	ENTRY( "SetPredictiveText",    Ctsysinfoprovidertests::SetPredictiveText),

   103       	ENTRY( "SetVibra",    Ctsysinfoprovidertests::SetVibra),

   104       	ENTRY( "SetBluetoothStatus",    Ctsysinfoprovidertests::SetBluetoothStatus),

   105       	ENTRY( "SetInfraredStatus",    Ctsysinfoprovidertests::SetInfraredStatus),

   106       	ENTRY( "SetBrigthness",    Ctsysinfoprovidertests::SetBrigthness),

   107       	ENTRY( "SetScreenSaverTimeout",    Ctsysinfoprovidertests::SetScreenSaverTimeout),

   108       	ENTRY( "SetKeyGuardTimeout",    Ctsysinfoprovidertests::SetKeyGuardTimeout),

   109       	ENTRY( "SetAutoLockTimeout",    Ctsysinfoprovidertests::SetAutoLockTimeout),

   110       	ENTRY( "SetWallpaper",    Ctsysinfoprovidertests::SetWallpaper),

   111       	ENTRY( "SetLightTimeOut",    Ctsysinfoprovidertests::SetLightTimeOut),

   112       	ENTRY( "GetDriveInfoL",    Ctsysinfoprovidertests::GetDriveInfoL),

   113       	ENTRY( "UserInactivityNotify",    Ctsysinfoprovidertests::UserInactivityNotify),

   114   

   115           };

   116 

   117     const TInt count = sizeof( KFunctions ) / 

   118                         sizeof( TStifFunctionInfo );

   119 

   120     return RunInternalL( KFunctions, count, aItem );

   121 

   122     }

   123 

   124 void Ctsysinfoprovidertests::Init()

   125 {

   126 	iServiceHandler = CLiwServiceHandler::NewL();

   127 	iInparam = &(iServiceHandler->InParamListL());

   128 	iOutparam = &(iServiceHandler->OutParamListL());

   129 	

   130 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

   131 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   132 

   133 	RCriteriaArray a;

   134 	a.AppendL(crit);    

   135 

   136 	iServiceHandler->AttachL(a);

   137 

   138 	iServiceHandler->ExecuteServiceCmdL(*crit, *iInparam, *iOutparam); 

   139 

   140 	delete crit;

   141 	a.Reset();

   142 	

   143 	TInt pos = 0;

   144 	

   145 	iOutparam->FindFirst( pos, KIDataSource );

   146 	if(pos != KErrNotFound)

   147 		{

   148 		//getting the iInterface handle

   149 		iInterface = (*iOutparam)[pos].Value().AsInterface();	

   150 		}

   151 

   152 	iOutparam->Reset();

   153 	iInparam->Reset();

   154 }

   155 	

   156 	

   157 //  End of File

   158 

   159  // -----------------------------------------------------------------------------

   160 // Ctsysinfoprovidertests::SetVibraInvalidParams1

   161 // Input SysData as List(instead of map)

   162 // -----------------------------------------------------------------------------

   163 //		

   164 TInt  Ctsysinfoprovidertests::SetVibraInvalidParamSysDataList(CStifItemParser& /*aItem*/)

   165 	{

   166 	

   167 	TInt result =KErrNone;	

   168 

   169 	_LIT( KExample, "SupportedLang:" );

   170     iLog->Log( KExample );

   171     TInt pos = 0 ;

   172     

   173     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   174    

   175 	Init();

   176 	__UHEAP_MARK;

   177 

   178 	TLiwGenericParam entity;

   179 	TLiwVariant  entityname;

   180 	TLiwGenericParam key;

   181 	TLiwVariant  keyname;

   182 	

   183 	entityname.Set(KGeneral);

   184 	entity.SetNameAndValueL(KEntity,entityname);

   185 

   186 	keyname.Set(KVibraActive);

   187 	key.SetNameAndValueL(KKey,keyname);

   188 	

   189 	    //sysdata as map

   190 	CLiwList* list = CLiwDefaultList::NewL();

   191 	CleanupStack::PushL(list);

   192 

   193     TLiwVariant sysdata((TInt32)1);

   194     list->AppendL(sysdata); 

   195     sysdata.Reset();	

   196 

   197 

   198     TLiwVariant sysparam(list);

   199 	TLiwGenericParam element ;	

   200 	element.SetNameAndValueL(KSysData,sysparam);

   201 	sysparam.Reset();

   202 

   203 	iInparam->AppendL(entity);

   204 

   205 	iInparam->AppendL(key);

   206 	iInparam->AppendL(element);

   207 	

   208 	element.Reset();

   209 

   210 	list->DecRef();

   211 	CleanupStack::Pop(list);

   212 		

   213 	entity.Reset();

   214 	entityname.Reset();

   215 	key.Reset();

   216 	keyname.Reset();

   217 	sysdata.Reset();

   218 	

   219 	//get  supported language list

   220 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   221 	result = err;

   222 	if(err == SErrNone)

   223 	{

   224 	const TLiwGenericParam* output = iOutparam->FindFirst( pos,KErrorCode );

   225 	result = output->Value().AsTInt32(); 

   226 	if(result == SErrBadArgumentType)

   227 		{

   228 		result =  0;	

   229 		}

   230     else

   231 	    {

   232 		result =  -1;	

   233 	    }

   234 	}

   235 	iOutparam->Reset();

   236 	iInparam->Reset();

   237 	

   238 	__UHEAP_MARKEND;

   239 	return result;

   240 

   241 	}

   242 	

   243  // -----------------------------------------------------------------------------

   244 // Ctsysinfoprovidertests::SetVibraInvalidParams2

   245 // Input SysData contains a string value instead of int

   246 // -----------------------------------------------------------------------------

   247 //		

   248 TInt  Ctsysinfoprovidertests::SetVibraInvalidParamSysData(CStifItemParser& /*aItem*/)

   249 	{

   250 	

   251 	TInt result =KErrNone;	

   252 

   253 	_LIT( KExample, "SupportedLang:" );

   254     iLog->Log( KExample );

   255     TInt pos =0;

   256     

   257     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   258    

   259 	Init();

   260 	

   261    	__UHEAP_MARK;

   262 

   263 	TLiwGenericParam entity;

   264 	TLiwVariant  entityname;

   265 	TLiwGenericParam key;

   266 	TLiwVariant  keyname;

   267 	

   268 	entityname.Set(KGeneral);

   269 	entity.SetNameAndValueL(KEntity,entityname);

   270 

   271 	keyname.Set(KVibraActive);

   272 	key.SetNameAndValueL(KKey,keyname);

   273 	

   274 	    //sysdata as map

   275 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   276 	CleanupStack::PushL(map);

   277 

   278     TLiwVariant sysdata(KGeneral);

   279     map->InsertL(KStatus,sysdata); 

   280     sysdata.Reset();	

   281 

   282 

   283     TLiwVariant sysparam(map);

   284 	TLiwGenericParam element ;	

   285 	element.SetNameAndValueL(KSysData,sysparam);

   286 	sysparam.Reset();

   287 

   288 	iInparam->AppendL(entity);

   289 

   290 	iInparam->AppendL(key);

   291 	iInparam->AppendL(element);

   292 	

   293 	element.Reset();

   294 

   295 	map->DecRef();

   296 	CleanupStack::Pop(map);

   297 		

   298 	entity.Reset();

   299 	entityname.Reset();

   300 	key.Reset();

   301 	keyname.Reset();

   302 	sysdata.Reset();

   303 	

   304 	//get  supported language list

   305 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   306 	result = err;

   307 	if(err == SErrNone)

   308 	{

   309 	iOutparam->FindFirst( pos, KErrorCode );

   310 	if(pos != KErrNotFound)

   311 		{

   312 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   313 		}

   314 	if(result == SErrBadArgumentType)

   315 		{

   316 		result =  0;	

   317 		}

   318     else

   319 	    {

   320 		result =  -1;	

   321 	    }

   322 	}

   323 	iOutparam->Reset();

   324 	iInparam->Reset();

   325 	

   326 //	iInterface->Close();

   327 //	iInterface = NULL ;

   328 

   329 	__UHEAP_MARKEND;

   330 	return result;

   331 

   332 	}

   333 

   334  // -----------------------------------------------------------------------------

   335 // Ctsysinfoprovidertests::SetVibraInvalidParamEntity

   336 // Entity as a int instead of string

   337 // -----------------------------------------------------------------------------

   338 //		

   339 TInt  Ctsysinfoprovidertests::SetVibraInvalidParamEntity(CStifItemParser& /*aItem*/)

   340 	{

   341 	

   342 	TInt result =KErrNone;	

   343 

   344 	_LIT( KExample, "SupportedLang:" );

   345     iLog->Log( KExample );

   346     TInt pos = 0;

   347     

   348     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   349    

   350 	Init();

   351 	__UHEAP_MARK;

   352 

   353 	TLiwGenericParam entity;

   354 	TLiwVariant  entityname;

   355 	TLiwGenericParam key;

   356 	TLiwVariant  keyname;

   357 	

   358 	entityname.Set(1);

   359 	entity.SetNameAndValueL(KEntity,entityname);

   360 

   361 	keyname.Set(KVibraActive);

   362 	key.SetNameAndValueL(KKey,keyname);

   363 	

   364 	    //sysdata as map

   365 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   366 	CleanupStack::PushL(map);

   367 

   368     TLiwVariant sysdata((TInt32)1);

   369     map->InsertL(KStatus,sysdata); 

   370     sysdata.Reset();	

   371 

   372 

   373     TLiwVariant sysparam(map);

   374 	TLiwGenericParam element ;	

   375 	element.SetNameAndValueL(KSysData,sysparam);

   376 	sysparam.Reset();

   377 

   378 	iInparam->AppendL(entity);

   379 

   380 	iInparam->AppendL(key);

   381 	iInparam->AppendL(element);

   382 	

   383 	element.Reset();

   384 

   385 	map->DecRef();

   386 	CleanupStack::Pop(map);

   387 		

   388 	entity.Reset();

   389 	entityname.Reset();

   390 	key.Reset();

   391 	keyname.Reset();

   392 	sysdata.Reset();

   393 	

   394 	//get  supported language list

   395 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   396 	result = err;

   397 	if(err == SErrNone)

   398 	{

   399 	iOutparam->FindFirst( pos, KErrorCode );

   400 	if(pos != KErrNotFound)

   401 		{

   402 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   403 		}

   404 	if(result == SErrNotFound)

   405 		{

   406 		result =  0;	

   407 		}

   408     else

   409 	    {

   410 		result =  -1;	

   411 	    }

   412 	}

   413 	iOutparam->Reset();

   414 	iInparam->Reset();

   415 

   416 	__UHEAP_MARKEND;

   417 	return result;

   418 

   419 	}

   420 

   421 // -----------------------------------------------------------------------------

   422 // Ctsysinfoprovidertests::SetVibraInvalidParamKey

   423 // Key as a int instead of string

   424 // -----------------------------------------------------------------------------

   425 //		

   426 TInt  Ctsysinfoprovidertests::SetVibraInvalidParamKey(CStifItemParser& /*aItem*/)

   427 	{

   428 	

   429 	TInt result =KErrNone;	

   430 

   431 	_LIT( KExample, "SupportedLang:" );

   432     iLog->Log( KExample );

   433     TInt pos = 0;

   434     

   435     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   436     	

   437 	Init();

   438 	__UHEAP_MARK;

   439 

   440 	TLiwGenericParam entity;

   441 	TLiwVariant  entityname;

   442 	TLiwGenericParam key;

   443 	TLiwVariant  keyname;

   444 	

   445 	entityname.Set(KGeneral);

   446 	entity.SetNameAndValueL(KEntity,entityname);

   447 

   448 	keyname.Set(1);

   449 	key.SetNameAndValueL(KKey,keyname);

   450 	

   451 	    //sysdata as map

   452 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   453 	CleanupStack::PushL(map);

   454 

   455     TLiwVariant sysdata((TInt32)1);

   456     map->InsertL(KStatus,sysdata); 

   457     sysdata.Reset();	

   458 

   459 

   460     TLiwVariant sysparam(map);

   461 	TLiwGenericParam element ;	

   462 	element.SetNameAndValueL(KSysData,sysparam);

   463 	sysparam.Reset();

   464 

   465 	iInparam->AppendL(entity);

   466 

   467 	iInparam->AppendL(key);

   468 	iInparam->AppendL(element);

   469 	

   470 	element.Reset();

   471 

   472 	map->DecRef();

   473 	CleanupStack::Pop(map);

   474 		

   475 	entity.Reset();

   476 	entityname.Reset();

   477 	key.Reset();

   478 	keyname.Reset();

   479 	sysdata.Reset();

   480 	

   481 	//get  supported language list

   482 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   483 	result = err;

   484 	if(err == SErrNone)

   485 	{

   486 	iOutparam->FindFirst( pos, KErrorCode );

   487 	if(pos != KErrNotFound)

   488 		{

   489 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   490 		}

   491 	if(result != SErrBadArgumentType)

   492 		{

   493 		result =  0;	

   494 		}

   495     else

   496 	    {

   497 		result =  -1;	

   498 	    }

   499 	}

   500 	iOutparam->Reset();

   501 	iInparam->Reset();

   502 

   503 	__UHEAP_MARKEND;

   504 	return result;

   505 

   506 	}

   507 	

   508 

   509 

   510 // -----------------------------------------------------------------------------

   511 // Ctsysinfoprovidertests::VibraParamMissingEntity

   512 // without Entity Key(name based parsing).

   513 // -----------------------------------------------------------------------------

   514 //		

   515 TInt Ctsysinfoprovidertests::VibraParamMissingEntity( CStifItemParser& /*aItem*/ )

   516 {

   517 	TInt result =KErrNone;	

   518 

   519 	_LIT( KExample, "SupportedLang:" );

   520     iLog->Log( KExample );

   521     TInt pos = 0;

   522     

   523     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   524    

   525 	Init();

   526 	__UHEAP_MARK;

   527 

   528 //	TLiwGenericParam entity;

   529 //	TLiwVariant  entityname;

   530 	TLiwGenericParam key;

   531 	TLiwVariant  keyname;

   532 	

   533 //	entityname.Set(KGeneral);

   534 //	entity.SetNameAndValueL(KEntity,entityname);

   535 

   536 	keyname.Set(KVibraActive);

   537 	key.SetNameAndValueL(KKey,keyname);

   538 	

   539     //sysdata as map

   540 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   541 	CleanupStack::PushL(map);

   542 

   543     TLiwVariant sysdata((TInt32)1);

   544     map->InsertL(KStatus,sysdata); 

   545     sysdata.Reset();	

   546 

   547     TLiwVariant sysparam(map);

   548 	TLiwGenericParam element ;	

   549 	element.SetNameAndValueL(KSysData,sysparam);

   550 	sysparam.Reset();

   551 

   552 //	iInparam->AppendL(entity);

   553 

   554 	iInparam->AppendL(key);

   555 	iInparam->AppendL(element);

   556 	

   557 	element.Reset();

   558 

   559 	map->DecRef();

   560 	CleanupStack::Pop(map);

   561 		

   562 //	entity.Reset();

   563 //	entityname.Reset();

   564 	key.Reset();

   565 	keyname.Reset();

   566 	sysdata.Reset();

   567 	

   568 	//Set Vibra 

   569 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   570 	result = err;

   571 	if(err == KErrNone)

   572 	{

   573 	iOutparam->FindFirst( pos, KErrorCode );

   574 	if(pos != KErrNotFound)

   575 		{

   576 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   577 		}

   578 	if(result == SErrMissingArgument)

   579 		{

   580 		result =  0;	

   581 		}

   582     else

   583 	    {

   584 		result =  -1;	

   585 	    }

   586 	}

   587 	iOutparam->Reset();

   588 	iInparam->Reset();

   589 	

   590 	__UHEAP_MARKEND;

   591 	return result;

   592 

   593 	}	

   594 	

   595 // -----------------------------------------------------------------------------

   596 // Ctsysinfoprovidertests::VibraParamMissingKey

   597 // without Key (name based parsing).

   598 // -----------------------------------------------------------------------------

   599 //		

   600 TInt Ctsysinfoprovidertests::VibraParamMissingKey( CStifItemParser& /*aItem*/ )

   601 {

   602 	TInt result =KErrNone;	

   603 

   604 	_LIT( KExample, "SupportedLang:" );

   605     iLog->Log( KExample );

   606     TInt pos = 0;

   607     

   608     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   609    

   610 	Init();

   611 	__UHEAP_MARK;

   612 

   613 	TLiwGenericParam entity;

   614 	TLiwVariant  entityname;

   615 //	TLiwGenericParam key;

   616 //	TLiwVariant  keyname;

   617 	

   618 	entityname.Set(KGeneral);

   619 	entity.SetNameAndValueL(KEntity,entityname);

   620 

   621 //	keyname.Set(KVibraActive);

   622 //	key.SetNameAndValueL(KKey,keyname);

   623 	

   624     //sysdata as map

   625 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   626 	CleanupStack::PushL(map);

   627 

   628     TLiwVariant sysdata((TInt32)1);

   629     map->InsertL(KStatus,sysdata); 

   630     sysdata.Reset();	

   631 

   632     TLiwVariant sysparam(map);

   633 	TLiwGenericParam element ;	

   634 	element.SetNameAndValueL(KSysData,sysparam);

   635 	sysparam.Reset();

   636 

   637 	iInparam->AppendL(entity);

   638 

   639 //	iInparam->AppendL(key);

   640 	iInparam->AppendL(element);

   641 	

   642 	element.Reset();

   643 

   644 	map->DecRef();

   645 	CleanupStack::Pop(map);

   646 		

   647 	entity.Reset();

   648 	entityname.Reset();

   649 //	key.Reset();

   650 //	keyname.Reset();

   651 	sysdata.Reset();

   652 	

   653 	//Set Vibra 

   654 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   655 	result = err;

   656 	if(err == KErrNone)

   657 	{

   658 	iOutparam->FindFirst( pos, KErrorCode );

   659 	if(pos != KErrNotFound)

   660 		{

   661 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   662 		}

   663 	if(result == SErrMissingArgument)

   664 		{

   665 		result =  0;	

   666 		}

   667     else

   668 	    {

   669 		result =  -1;	

   670 	    }

   671 	}

   672 	iOutparam->Reset();

   673 	iInparam->Reset();

   674 

   675 	__UHEAP_MARKEND;

   676 	return result;

   677 

   678 	}

   679 	

   680 // -----------------------------------------------------------------------------

   681 // Ctsysinfoprovidertests::VibraParamMissingSysData

   682 // without Input SysData for setInfo (name based parsing).

   683 // -----------------------------------------------------------------------------

   684 //		

   685 TInt Ctsysinfoprovidertests::VibraParamMissingSysData( CStifItemParser& /*aItem*/ )

   686 {

   687 	TInt result =KErrNone;	

   688 

   689 	_LIT( KExample, "SupportedLang:" );

   690     iLog->Log( KExample );

   691     TInt pos = 0;

   692     

   693     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   694    

   695  	Init();

   696 	__UHEAP_MARK;

   697 

   698 	TLiwGenericParam entity;

   699 	TLiwVariant  entityname;

   700 	TLiwGenericParam key;

   701 	TLiwVariant  keyname;

   702 	

   703 	entityname.Set(KGeneral);

   704 	entity.SetNameAndValueL(KEntity,entityname);

   705 

   706 	keyname.Set(KVibraActive);

   707 	key.SetNameAndValueL(KKey,keyname);

   708 	

   709     //sysdata as map

   710 //	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   711 //	CleanupStack::PushL(map);

   712 

   713   //  TLiwVariant sysdata(1);

   714   //  map->InsertL(KStatus,sysdata); 

   715   //  sysdata.Reset();	

   716 

   717    // TLiwVariant sysparam(map);

   718 //	TLiwGenericParam element ;	

   719 //	element.SetNameAndValueL(KSysData,sysparam);

   720 //	sysparam.Reset();

   721 

   722 	iInparam->AppendL(entity);

   723 

   724 	iInparam->AppendL(key);

   725 //	iInparam->AppendL(element);

   726 	

   727 //	element.Reset();

   728 

   729 //	map->DecRef();

   730 //	CleanupStack::Pop(map);

   731 		

   732 	entity.Reset();

   733 	entityname.Reset();

   734 	key.Reset();

   735 	keyname.Reset();

   736 //	sysdata.Reset();

   737 	

   738 	//Set Vibra 

   739 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   740 	result = err;

   741 	if(err == KErrNone)

   742 	{

   743 	iOutparam->FindFirst( pos, KErrorCode );

   744 	if(pos != KErrNotFound)

   745 		{

   746 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   747 		}

   748 	if(result == SErrMissingArgument)

   749 		{

   750 		result =  0;	

   751 		}

   752     else

   753 	    {

   754 		result =  -1;	

   755 	    }

   756 	}

   757 	iOutparam->Reset();

   758 	iInparam->Reset();

   759 

   760 	__UHEAP_MARKEND;

   761 	return result;

   762 

   763 	}		

   764 	

   765 // -----------------------------------------------------------------------------

   766 // Ctsysinfoprovidertests::VibraParamMissingEntityPos

   767 // without Entity Key(Position based parsing).

   768 // -----------------------------------------------------------------------------

   769 //		

   770 TInt Ctsysinfoprovidertests::VibraParamMissingEntityPos( CStifItemParser& /*aItem*/ )

   771 {

   772 	TInt result =KErrNone;	

   773 

   774 	_LIT( KExample, "SupportedLang:" );

   775     iLog->Log( KExample );

   776     TInt pos = 0;

   777     

   778     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   779 

   780 	Init();

   781 	__UHEAP_MARK;

   782 

   783 //	TLiwGenericParam entity;

   784 //	TLiwVariant  entityname;

   785 	TLiwGenericParam key;

   786 	TLiwVariant  keyname;

   787 	

   788 //	entityname.Set(KGeneral);

   789 //	entity.SetNameAndValueL(KEntity,entityname);

   790 

   791 	keyname.Set(KVibraActive);

   792 	key.SetNameAndValueL(KNullDesC8,keyname);

   793 	

   794     //sysdata as map

   795 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   796 	CleanupStack::PushL(map);

   797 

   798     TLiwVariant sysdata((TInt32)1);

   799     map->InsertL(KStatus,sysdata); 

   800     sysdata.Reset();	

   801 

   802     TLiwVariant sysparam(map);

   803 	TLiwGenericParam element ;	

   804 	element.SetNameAndValueL(KNullDesC8,sysparam);

   805 	sysparam.Reset();

   806 

   807 //	iInparam->AppendL(entity);

   808 

   809 	iInparam->AppendL(key);

   810 	iInparam->AppendL(element);

   811 	

   812 	element.Reset();

   813 

   814 	map->DecRef();

   815 	CleanupStack::Pop(map);

   816 		

   817 //	entity.Reset();

   818 //	entityname.Reset();

   819 	key.Reset();

   820 	keyname.Reset();

   821 	sysdata.Reset();

   822 	

   823 	//Set Vibra 

   824 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   825 	result = err;

   826 	if(err == KErrNone)

   827 	{

   828 	iOutparam->FindFirst( pos, KErrorCode );

   829 	if(pos != KErrNotFound)

   830 		{

   831 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   832 		}

   833 	if(result == SErrMissingArgument)

   834 		{

   835 		result =  0;	

   836 		}

   837     else

   838 	    {

   839 		result =  -1;	

   840 	    }

   841 	}

   842 	iOutparam->Reset();

   843 	iInparam->Reset();

   844 	

   845 	__UHEAP_MARKEND;

   846 	return result;

   847 

   848 	}	

   849 	

   850 // -----------------------------------------------------------------------------

   851 // Ctsysinfoprovidertests::VibraParamMissingKeyPos

   852 // without Key (Position based parsing).

   853 // -----------------------------------------------------------------------------

   854 //		

   855 TInt Ctsysinfoprovidertests::VibraParamMissingKeyPos( CStifItemParser& /*aItem*/ )

   856 {

   857 	TInt result =KErrNone;	

   858 

   859 	_LIT( KExample, "SupportedLang:" );

   860     iLog->Log( KExample );

   861     TInt pos = 0;

   862     

   863     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   864    	

   865 	Init();

   866 	__UHEAP_MARK;

   867 

   868 	TLiwGenericParam entity;

   869 	TLiwVariant  entityname;

   870 //	TLiwGenericParam key;

   871 //	TLiwVariant  keyname;	

   872 	

   873 	entityname.Set(KGeneral);

   874 	entity.SetNameAndValueL(KNullDesC8,entityname);

   875 

   876 //	keyname.Set(KVibraActive);

   877 //	key.SetNameAndValueL(KKey,keyname);

   878 	

   879     //sysdata as map

   880 	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   881 	CleanupStack::PushL(map);

   882 

   883     TLiwVariant sysdata((TInt32)1);

   884     map->InsertL(KStatus,sysdata); 

   885     sysdata.Reset();	

   886 

   887     TLiwVariant sysparam(map);

   888 	TLiwGenericParam element ;	

   889 	element.SetNameAndValueL(KNullDesC8,sysparam);

   890 	sysparam.Reset();

   891 

   892 	iInparam->AppendL(entity);

   893 

   894 //	iInparam->AppendL(key);

   895 	iInparam->AppendL(element);

   896 	

   897 	element.Reset();

   898 

   899 	map->DecRef();

   900 	CleanupStack::Pop(map);

   901 		

   902 	entity.Reset();

   903 	entityname.Reset();

   904 //	key.Reset();

   905 //	keyname.Reset();

   906 	sysdata.Reset();

   907 	

   908 	//Set Vibra 

   909 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   910 	result = err;

   911 	if(err == KErrNone)

   912 	{

   913 	iOutparam->FindFirst( pos, KErrorCode );

   914 	if(pos != KErrNotFound)

   915 		{

   916 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

   917 		}

   918 	if(result == SErrMissingArgument)

   919 		{

   920 		result =  0;	

   921 		}

   922     else

   923 	    {

   924 		result =  -1;	

   925 	    }

   926 	}

   927 	iOutparam->Reset();

   928 	iInparam->Reset();

   929 	

   930 	__UHEAP_MARKEND;

   931 	return result;

   932 

   933 	}

   934 	

   935 // -----------------------------------------------------------------------------

   936 // Ctsysinfoprovidertests::VibraParamMissingSysDataPos

   937 // without Input SysData for setInfo (Position based parsing).

   938 // -----------------------------------------------------------------------------

   939 //		

   940 TInt Ctsysinfoprovidertests::VibraParamMissingSysDataPos( CStifItemParser& /*aItem*/ )

   941 {

   942 	TInt result =KErrNone;	

   943 

   944 	_LIT( KExample, "SupportedLang:" );

   945     iLog->Log( KExample );

   946     TInt pos = 0;

   947     

   948     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

   949    

   950    	

   951 	Init();

   952 	

   953 	__UHEAP_MARK;

   954 

   955 	TLiwGenericParam entity;

   956 	TLiwVariant  entityname;

   957 	TLiwGenericParam key;

   958 	TLiwVariant  keyname;

   959 	

   960 	entityname.Set(KGeneral);

   961 	entity.SetNameAndValueL(KNullDesC8,entityname);

   962 

   963 	keyname.Set(KVibraActive);

   964 	key.SetNameAndValueL(KNullDesC8,keyname);

   965 	

   966     //sysdata as map

   967 //	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   968 //	CleanupStack::PushL(map);

   969 

   970   //  TLiwVariant sysdata(1);

   971   //  map->InsertL(KStatus,sysdata); 

   972   //  sysdata.Reset();	

   973 

   974    // TLiwVariant sysparam(map);

   975 //	TLiwGenericParam element ;	

   976 //	element.SetNameAndValueL(KSysData,sysparam);

   977 //	sysparam.Reset();

   978 

   979 	iInparam->AppendL(entity);

   980 

   981 	iInparam->AppendL(key);

   982 //	iInparam->AppendL(element);

   983 	

   984 //	element.Reset();

   985 

   986 //	map->DecRef();

   987 //	CleanupStack::Pop(map);

   988 		

   989 	entity.Reset();

   990 	entityname.Reset();

   991 	key.Reset();

   992 	keyname.Reset();

   993 //	sysdata.Reset();

   994 	

   995 	//Set Vibra 

   996 	TRAPD(err,iInterface->ExecuteCmdL(KSetInfo,*iInparam,*iOutparam));

   997 	result = err;

   998 	if(err == KErrNone)

   999 	{

  1000 	iOutparam->FindFirst( pos, KErrorCode );

  1001 	if(pos != KErrNotFound)

  1002 		{

  1003 			result = (TInt)((*iOutparam)[pos].Value().AsTInt32());

  1004 		}

  1005 	if(result == SErrMissingArgument)

  1006 		{

  1007 		result =  0;	

  1008 		}

  1009     else

  1010 	    {

  1011 		result =  -1;	

  1012 	    }

  1013 	}

  1014 	iOutparam->Reset();

  1015 	iInparam->Reset();

  1016 	

  1017 	__UHEAP_MARKEND;

  1018 	return result;

  1019 

  1020 	}	

  1021 

  1022  // -----------------------------------------------------------------------------

  1023 // Ctsysinfoprovidertests::WrongInterfaceName

  1024 // Wrong Interface Name provided.

  1025 // -----------------------------------------------------------------------------

  1026 //		

  1027 TInt Ctsysinfoprovidertests::WrongInterfaceName( CStifItemParser& /*aItem*/ )

  1028 {

  1029 

  1030 	TInt result =KErrNone;	

  1031 

  1032 	_LIT( KExample, "SupportedLang:" );

  1033     iLog->Log( KExample );

  1034     TInt pos = 0;

  1035     

  1036     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

  1037    

  1038 //	Init();

  1039 	__UHEAP_MARK;

  1040 	_LIT8(KIDataSource,"ISys");

  1041 	

  1042 	iServiceHandler = CLiwServiceHandler::NewL();

  1043 	iInparam = &(iServiceHandler->InParamListL());

  1044 	iOutparam = &(iServiceHandler->OutParamListL());

  1045 	

  1046 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

  1047 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1048 

  1049 	RCriteriaArray a;

  1050 	a.AppendL(crit);    

  1051 

  1052 	iServiceHandler->AttachL(a);

  1053 

  1054 	TRAPD( err,iServiceHandler->ExecuteServiceCmdL(*crit, *iInparam, *iOutparam) ); 

  1055 

  1056 	delete crit;

  1057 	a.Reset();

  1058 	

  1059 	pos = 0;

  1060 	

  1061 	iOutparam->FindFirst( pos, KIDataSource );

  1062 	if(pos != KErrNotFound)

  1063 		{

  1064 		//getting the iInterface handle

  1065 		iInterface = (*iOutparam)[pos].Value().AsInterface();

  1066 		result = -1; 	

  1067 		}

  1068     else

  1069 	    {

  1070 		result =  0;	

  1071 	    }

  1072 	

  1073 	iOutparam->Reset();

  1074 	iInparam->Reset();

  1075     

  1076     if( iInterface )

  1077 	    {

  1078 		iInterface->Close();

  1079 	    }

  1080 	iLog->Log(_L("before delete iServiceHandler :"));

  1081     delete iServiceHandler ;

  1082     iServiceHandler = NULL;

  1083     iLog->Log(_L("after delete iServiceHandler :"));

  1084 

  1085 	__UHEAP_MARKEND;

  1086 	return result;

  1087 

  1088 	}

  1089 	

  1090  // -----------------------------------------------------------------------------

  1091 // Ctsysinfoprovidertests::LoadingInterfaceMultipletime

  1092 // Loading Interface Multiple time.

  1093 // -----------------------------------------------------------------------------

  1094 //		

  1095 TInt Ctsysinfoprovidertests::LoadingInterfaceMultipletime( CStifItemParser& /*aItem*/ )

  1096 {

  1097 	TInt result =KErrNone;	

  1098 

  1099 	_LIT( KExample, "SupportedLang:" );

  1100     iLog->Log( KExample );

  1101     TInt pos = 0;

  1102     

  1103     TInt32 oldDisplayLang = 0 ,newDisplayLang = 0,changedDisplayLang = 0;

  1104    

  1105 //	Init();

  1106 	__UHEAP_MARK;

  1107 	

  1108 	iServiceHandler = CLiwServiceHandler::NewL();

  1109 	iInparam = &(iServiceHandler->InParamListL());

  1110 	iOutparam = &(iServiceHandler->OutParamListL());

  1111 	

  1112 	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

  1113 	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1114 

  1115 	RCriteriaArray a;

  1116 	a.AppendL(crit);    

  1117 

  1118 	iServiceHandler->AttachL(a);

  1119 	TRAPD( err,iServiceHandler->ExecuteServiceCmdL(*crit, *iInparam, *iOutparam) ); 

  1120 

  1121 	delete crit;

  1122 	a.Reset();

  1123 	pos = 0;

  1124 	

  1125 	iOutparam->FindFirst( pos, KIDataSource );

  1126 	if(pos != KErrNotFound)

  1127 		{

  1128 		//getting the iInterface handle

  1129 		iInterface = (*iOutparam)[pos].Value().AsInterface();

  1130 		

  1131 		iOutparam->Reset();

  1132 		iInparam->Reset();

  1133 	

  1134 	//	iInparam = &(iServiceHandler->InParamListL());