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 "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:    Test module to implement Session trigger creation related test cases

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 // INCLUDE FILES

    23 #include <e32svr.h>

    24 #include <StifParser.h>

    25 #include <Stiftestinterface.h>

    26 #include "CreateSessiontrigger.h"

    27 #include "MyObserver.h"

    28 #include <lbt.h> 

    29 #include <lbtserver.h>

    30 #include <e32property.h>

    31 //#include "lbtstatuspskeys.h"

    32 #include <lbtgeocircle.h> 

    33 #include <lbtgeorect.h>

    34 #include <lbttriggerconditionarea.h> 

    35 #include <lbtsessiontrigger.h> 

    36 

    37 // EXTERNAL DATA STRUCTURES

    38 //extern  ?external_data;

    39 

    40 // EXTERNAL FUNCTION PROTOTYPES  

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

    42 

    43 // CONSTANTS

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

    45 

    46 // MACROS

    47 //#define ?macro ?macro_def

    48 

    49 // LOCAL CONSTANTS AND MACROS

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

    51 //#define ?macro_name ?macro_def

    52 

    53 // MODULE DATA STRUCTURES

    54 //enum ?declaration

    55 //typedef ?declaration

    56 

    57 // LOCAL FUNCTION PROTOTYPES

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

    59 

    60 // FORWARD DECLARATIONS

    61 //class ?FORWARD_CLASSNAME;

    62 

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

    64 

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

    66 // ?function_name ?description.

    67 // ?description

    68 // Returns: ?value_1: ?description

    69 //          ?value_n: ?description_line1

    70 //                    ?description_line2

    71 // -----------------------------------------------------------------------------

    72 //

    73 /*

    74 ?type ?function_name(

    75     ?arg_type arg,  // ?description

    76     ?arg_type arg)  // ?description

    77     {

    78 

    79     ?code  // ?comment

    80 

    81     // ?comment

    82     ?code

    83     }

    84 */

    85 

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

    87 

    88 // -----------------------------------------------------------------------------

    89 // CCreateSessiontrigger::Delete

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

    91 // Called from destructor. 

    92 // -----------------------------------------------------------------------------

    93 //

    94 void CCreateSessiontrigger::Delete() 

    95     {

    96 

    97     }

    98 

    99 // -----------------------------------------------------------------------------

   100 // CCreateSessiontrigger::RunMethodL

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

   102 // -----------------------------------------------------------------------------

   103 //

   104 TInt CCreateSessiontrigger::RunMethodL( 

   105     CStifItemParser& aItem ) 

   106     {

   107 

   108     static TStifFunctionInfo const KFunctions[] =

   109         {  

   110         // Copy this line for every implemented function.

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

   112         // Second is the actual implementation member function. 

   113         ENTRY( "Example", CCreateSessiontrigger::ExampleL ),

   114         ENTRY( "CreateSessiontrigger",CCreateSessiontrigger::CreatesingleSessiontriggerL),

   115         ENTRY( "CreateExittypeSessiontrigger",CCreateSessiontrigger::CreateExittypeSessiontriggerL),

   116         ENTRY( "CreateDisabledSessiontrigger",CCreateSessiontrigger::CreateDisabledSessiontriggerL),

   117         ENTRY( "CreatemultipeSessiontriggers",CCreateSessiontrigger::CreatemultipleSessiontriggersL),

   118         ENTRY( "CreateSessiontriggerwithoutConnect",CCreateSessiontrigger::CreateSessiontriggerwithoutConnectL),

   119         ENTRY( "CreateSessiontriggerwithoutOpen",CCreateSessiontrigger::CreateSessiontriggerwithoutOpenL),

   120         ENTRY( "SessiontriggerNameexceeds256L",CCreateSessiontrigger::SessiontriggerNameexceeds256L),

   121         ENTRY( "SessiontriggerNameequals0",CCreateSessiontrigger::SessiontriggerNameequals0L),

   122         ENTRY( "CreateSessiontriggerwithoutName",CCreateSessiontrigger::CreateSessiontriggerwithoutNameL),

   123         ENTRY( "CreateSessiontriggerwithoutcond",CCreateSessiontrigger::CreateSessiontriggerwithoutcondL),

   124         ENTRY( "CreateSessiontriggermanagerUINotFound",CCreateSessiontrigger::CreateSessiontriggermanagerUINotFoundL),

   125         ENTRY( "CreateSessiontriggerwithNonUIApplication",CCreateSessiontrigger::CreateSessiontriggerwithNonUIApplicationL),

   126         ENTRY( "ErrortriggerAreaToosmall",CCreateSessiontrigger::ErrortriggerAreaToosmallL),

   127         ENTRY( "ErrortriggerAreaRectangle",CCreateSessiontrigger::ErrortriggerAreaRectangleL),

   128         ENTRY( "CreateSessiontriggerwithoutRequestor",CCreateSessiontrigger::CreateSessiontriggerwithoutRequestorL),

   129 

   130         };

   131 

   132     const TInt count = sizeof( KFunctions ) / 

   133                         sizeof( TStifFunctionInfo );

   134 

   135     return RunInternalL( KFunctions, count, aItem );

   136 

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CCreateSessiontrigger::ExampleL

   141 // Example test method function.

   142 // (other items were commented in a header).

   143 // -----------------------------------------------------------------------------

   144 //

   145 TInt CCreateSessiontrigger::ExampleL( CStifItemParser& aItem )

   146     {

   147 

   148     // Print to UI

   149     _LIT( KCreateSessiontrigger, "CreateSessiontrigger" );

   150     _LIT( KExample, "In Example" );

   151     TestModuleIf().Printf( 0, KCreateSessiontrigger, KExample );

   152     // Print to log file

   153     iLog->Log( KExample );

   154 

   155     TInt i = 0;

   156     TPtrC string;

   157     _LIT( KParam, "Param[%i]: %S" );

   158     while ( aItem.GetNextString ( string ) == KErrNone )

   159         {

   160         TestModuleIf().Printf( i, KCreateSessiontrigger, 

   161                                 KParam, i, &string );

   162         i++;

   163         }

   164 

   165     return KErrNone;

   166 

   167     }

   168     // -----------------------------------------------------------------------------

   169 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   170 // Testing the creation of single entry type session trigger.

   171 // (other items were commented in a header).

   172 // -----------------------------------------------------------------------------

   173 //

   174        

   175     TInt CCreateSessiontrigger::CreatesingleSessiontriggerL( CStifItemParser& aItem )

   176     {

   177         //Connect to Location Triggering Server

   178    

   179   // #if 0

   180     RLbtServer lbtServ;

   181     User::LeaveIfError(lbtServ.Connect());

   182     CleanupClosePushL(lbtServ);

   183 

   184     RLbt lbt;

   185     User::LeaveIfError(lbt.Open(lbtServ));

   186     CleanupClosePushL(lbt);

   187         

   188     TRealX nan;

   189     nan.SetNaN();

   190         

   191     TRealX myLatitude=61.5;

   192     TRealX myLongitude= 24.3;   

   193     TRealX myAltitude =0; 

   194     TRealX myradius =100; 

   195     TCoordinate centre(myLatitude,myLongitude)  ;     

   196     //Define the triggering area

   197         

   198    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   199    						centre,100.1);

   200    							

   201    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   202    	trigArea->SetCenter(centre);

   203    	trigArea->SetRadius(10);*/

   204     CleanupStack::PushL( trigArea );

   205 

   206     //Construct trigger condition

   207     CLbtTriggerConditionArea* cond = 

   208         CLbtTriggerConditionArea::NewL( 

   209         trigArea,

   210         CLbtTriggerConditionArea::EFireOnEnter );

   211         

   212     CleanupStack::Pop( trigArea ); //ownership is transfered.

   213     CleanupStack::PushL( cond );

   214     

   215     _LIT( KMyTriggerName, "Trigger name" );

   216     _LIT( KMyRequestor , "Requestor" );

   217    

   218    	TUid aManagerUi;

   219 	aManagerUi = TUid::Uid(0x87654321);

   220     //Construct a startup trigger

   221     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   222         KMyTriggerName,                             //Trigger name

   223         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   224         CRequestorBase::ERequestorService,          //Requestor type

   225         CRequestorBase::EFormatApplication,         //Requestor format

   226         KMyRequestor,                               //Requestor data

   227         aManagerUi,				                      //Manager UI

   228         cond                                       //Trigger condition

   229         );     

   230         

   231         iLog->Log(_L("Session trigger entry created ")); 	                         

   232         

   233     //Pop trigger condition object

   234     CleanupStack::Pop( cond );

   235     

   236     //Push trigger object to cleanup stack

   237     CleanupStack::PushL( trig );

   238 

   239     //Create the trigger in Location Triggering Server

   240     TLbtTriggerId trigId;

   241     TRequestStatus status;

   242     

   243     CMyObserver *ao;

   244 	ao = CMyObserver::NewL();

   245 	CActiveSchedulerWait *schedulerwait;

   246 	schedulerwait= new CActiveSchedulerWait;

   247 	ao->GiveHandle(schedulerwait);

   248     

   249     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

   250     

   251     //iLog->Log(_L("Session trigger created ")); 

   252     

   253     ao->MySetActive();	

   254 	schedulerwait->Start();    

   255     

   256     //Delete the instance of trigger object

   257    CleanupStack::PopAndDestroy( trig );

   258    

   259     

   260    /* User::WaitForRequest( status );

   261     User::LeaveIfError( status.Int() );*/

   262     

   263     //Close connection to Location Triggering Server.

   264         

   265     lbt.Close();

   266     CleanupStack::Pop(&lbt); 

   267     //Close connection to RLbtServer

   268     lbtServ.Close(); 

   269     CleanupStack::PopAndDestroy(&lbtServ);  

   270     return KErrNone;

   271   //  #endif

   272     #if 0

   273     RLbtServer lbtServ;

   274     User::LeaveIfError(lbtServ.Connect());

   275     CleanupClosePushL(lbtServ);

   276 

   277     RLbt lbt;

   278     User::LeaveIfError(lbt.Open(lbtServ));

   279     CleanupClosePushL(lbt);

   280     CLbtSessionTrigger *iTrigger;

   281     CLbtGeoCircle* circle = CLbtGeoCircle::NewLC();

   282 		

   283 	iTrigger = CLbtSessionTrigger::NewL();

   284 		

   285 	iTrigger->SetNameL(_L("LbtRefAppTrigger"));

   286 	iTrigger->SetState(CLbtTriggerEntry::EStateEnabled);

   287 	/*iTrigger->SetRequestorL(CRequestorBase::ERequestorService,

   288 						   CRequestorBase::EFormatApplication,

   289 						   _L("LbtRefAppTrigger"));*/

   290 	iTrigger->SetManagerUi(TUid::Uid(0x10181081));

   291 	

   292 	CLbtTriggerConditionArea* conditionBasic = CLbtTriggerConditionArea::NewL(circle, CLbtTriggerConditionArea::EFireOnEnter);

   293 	CleanupStack::PushL(conditionBasic);

   294 	

   295 	iTrigger->SetCondition(conditionBasic);	

   296 	 TLbtTriggerId iTriggerid;

   297     TRequestStatus iStatus;

   298 	CMyObserver *ao;

   299 	ao = CMyObserver::NewL();

   300 

   301 //	test->CallCreateTrigger(lbt,&iTrigger,iTriggerid,EFalse,iStatus);

   302 	CActiveSchedulerWait *schedulerwait;

   303 	schedulerwait= new CActiveSchedulerWait;

   304 	ao->GiveHandle(schedulerwait);

   305 	lbt.CreateTrigger(*iTrigger, iTriggerid, EFalse, ao->iStatus);

   306 	ao->MySetActive();	

   307 	

   308 	

   309 	schedulerwait->Start();

   310 	

   311 	//User::WaitForRequest( iStatus );

   312     //User::LeaveIfError( iStatus.Int() );

   313 	CleanupStack::Pop(4); 

   314 	return KErrNone;

   315 	#endif

   316     }

   317   

   318   

   319   

   320       // -----------------------------------------------------------------------------

   321 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   322 // Testing the creation of single entry type session trigger.

   323 // (other items were commented in a header).

   324 // -----------------------------------------------------------------------------

   325 //

   326        

   327     TInt CCreateSessiontrigger::CreateExittypeSessiontriggerL( CStifItemParser& aItem )

   328     {

   329         //Connect to Location Triggering Server

   330     RLbtServer lbtServ;

   331     User::LeaveIfError(lbtServ.Connect());

   332     CleanupClosePushL(lbtServ);

   333 

   334     RLbt lbt;

   335     User::LeaveIfError(lbt.Open(lbtServ));

   336     CleanupClosePushL(lbt);

   337         

   338     TRealX nan;

   339     nan.SetNaN();

   340         

   341     TRealX myLatitude=61.5;

   342     TRealX myLongitude= 24.3;   

   343     TRealX myAltitude =0; 

   344     TRealX myradius =10; 

   345     TCoordinate centre(myLatitude,myLongitude)  ;     

   346     //Define the triggering area

   347         

   348    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   349    						centre,100.1);

   350    							

   351    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   352    	trigArea->SetCenter(centre);

   353    	trigArea->SetRadius(10);*/

   354     CleanupStack::PushL( trigArea );

   355 

   356     //Construct trigger condition

   357     CLbtTriggerConditionArea* cond = 

   358         CLbtTriggerConditionArea::NewL( 

   359         trigArea,

   360         CLbtTriggerConditionArea::EFireOnExit );

   361         

   362     CleanupStack::Pop( trigArea ); //ownership is transfered.

   363     CleanupStack::PushL( cond );

   364     

   365     _LIT( KMyTriggerName, "Trigger name" );

   366     _LIT( KMyRequestor , "Requestor" );

   367    

   368    	TUid aManagerUi;

   369 	aManagerUi = TUid::Uid(0x87654321);

   370     //Construct a startup trigger

   371     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   372         KMyTriggerName,                             //Trigger name

   373         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   374         CRequestorBase::ERequestorService,          //Requestor type

   375         CRequestorBase::EFormatApplication,         //Requestor format

   376         KMyRequestor,                               //Requestor data

   377         aManagerUi,				                      //Manager UI

   378         cond                                       //Trigger condition

   379         );     

   380         

   381         iLog->Log(_L("Session trigger entry created ")); 	                         

   382         

   383     //Pop trigger condition object

   384     CleanupStack::Pop( cond );

   385     

   386     //Push trigger object to cleanup stack

   387     CleanupStack::PushL( trig );

   388 

   389     //Create the trigger in Location Triggering Server

   390     TLbtTriggerId trigId;

   391     TRequestStatus status;

   392     

   393      CMyObserver *ao;

   394 	ao = CMyObserver::NewL();

   395 	CActiveSchedulerWait *schedulerwait;

   396 	schedulerwait= new CActiveSchedulerWait;

   397 	ao->GiveHandle(schedulerwait);

   398     

   399     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

   400     

   401     //iLog->Log(_L("Session trigger created ")); 

   402     

   403     ao->MySetActive();	

   404 	schedulerwait->Start();    

   405     

   406     iLog->Log(_L("Session trigger created ")); 

   407     

   408     //Delete the instance of trigger object

   409    CleanupStack::PopAndDestroy( trig );

   410    

   411     

   412    /* User::WaitForRequest( status );

   413     User::LeaveIfError( status.Int() );*/

   414     

   415     //Close connection to Location Triggering Server.

   416         

   417     lbt.Close();

   418     CleanupStack::Pop(&lbt); 

   419     //Close connection to RLbtServer

   420     lbtServ.Close(); 

   421     CleanupStack::PopAndDestroy(&lbtServ);  

   422     return KErrNone;

   423     

   424     }

   425     

   426     

   427         // -----------------------------------------------------------------------------

   428 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   429 // Testing the creation of single entry type session trigger.

   430 // (other items were commented in a header).

   431 // -----------------------------------------------------------------------------

   432 //

   433        

   434     TInt CCreateSessiontrigger::CreateDisabledSessiontriggerL( CStifItemParser& aItem )

   435     {

   436         //Connect to Location Triggering Server

   437     RLbtServer lbtServ;

   438     User::LeaveIfError(lbtServ.Connect());

   439     CleanupClosePushL(lbtServ);

   440 

   441     RLbt lbt;

   442     User::LeaveIfError(lbt.Open(lbtServ));

   443     CleanupClosePushL(lbt);

   444         

   445     TRealX nan;

   446     nan.SetNaN();

   447         

   448     TRealX myLatitude=61.5;

   449     TRealX myLongitude= 24.3;   

   450     TRealX myAltitude =0; 

   451     TRealX myradius =10; 

   452     TCoordinate centre(myLatitude,myLongitude)  ;     

   453     //Define the triggering area

   454         

   455    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   456    						centre,100.1);

   457    							

   458    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   459    	trigArea->SetCenter(centre);

   460    	trigArea->SetRadius(10);*/

   461     CleanupStack::PushL( trigArea );

   462 

   463     //Construct trigger condition

   464     CLbtTriggerConditionArea* cond = 

   465         CLbtTriggerConditionArea::NewL( 

   466         trigArea,

   467         CLbtTriggerConditionArea::EFireOnEnter );

   468         

   469     CleanupStack::Pop( trigArea ); //ownership is transfered.

   470     CleanupStack::PushL( cond );

   471     

   472     _LIT( KMyTriggerName, "Trigger name" );

   473     _LIT( KMyRequestor , "Requestor" );

   474    

   475    	TUid aManagerUi;

   476 	aManagerUi = TUid::Uid(0x87654321);

   477     //Construct a startup trigger

   478     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   479         KMyTriggerName,                             //Trigger name

   480         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   481         CRequestorBase::ERequestorService,          //Requestor type

   482         CRequestorBase::EFormatApplication,         //Requestor format

   483         KMyRequestor,                               //Requestor data

   484         aManagerUi,				                      //Manager UI

   485         cond                                       //Trigger condition

   486         );     

   487         

   488         iLog->Log(_L("Session trigger entry created ")); 	                         

   489         

   490     //Pop trigger condition object

   491     CleanupStack::Pop( cond );

   492     

   493     //Push trigger object to cleanup stack

   494     CleanupStack::PushL( trig );

   495 

   496     //Create the trigger in Location Triggering Server

   497     TLbtTriggerId trigId;

   498     TRequestStatus status;

   499     

   500      CMyObserver *ao;

   501 	ao = CMyObserver::NewL();

   502 	CActiveSchedulerWait *schedulerwait;

   503 	schedulerwait= new CActiveSchedulerWait;

   504 	ao->GiveHandle(schedulerwait);

   505     

   506     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

   507     

   508     //iLog->Log(_L("Session trigger created ")); 

   509     

   510     ao->MySetActive();	

   511 	schedulerwait->Start();    

   512     

   513     iLog->Log(_L("Session trigger created ")); 

   514     

   515     //Delete the instance of trigger object

   516    CleanupStack::PopAndDestroy( trig );

   517    

   518     

   519   /*  User::WaitForRequest( status );

   520     User::LeaveIfError( status.Int() );*/

   521     

   522     //Close connection to Location Triggering Server.

   523         

   524     lbt.Close();

   525     CleanupStack::Pop(&lbt); 

   526     //Close connection to RLbtServer

   527     lbtServ.Close(); 

   528     CleanupStack::PopAndDestroy(&lbtServ);  

   529     return KErrNone;

   530     

   531     }

   532     

   533     

   534         // -----------------------------------------------------------------------------

   535 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   536 // Testing the creation of single entry type session trigger.

   537 // (other items were commented in a header).

   538 // -----------------------------------------------------------------------------

   539 //

   540        

   541     TInt CCreateSessiontrigger::CreatemultipleSessiontriggersL( CStifItemParser& aItem )

   542     {

   543         //Connect to Location Triggering Server

   544     RLbtServer lbtServ;

   545     User::LeaveIfError(lbtServ.Connect());

   546     CleanupClosePushL(lbtServ);

   547 

   548     RLbt lbt;

   549     User::LeaveIfError(lbt.Open(lbtServ));

   550     CleanupClosePushL(lbt);

   551         

   552     TRealX nan;

   553     nan.SetNaN();

   554         

   555     TRealX myLatitude=61.5;

   556     TRealX myLongitude= 24.3;   

   557     TRealX myAltitude =0; 

   558     TRealX myradius =10; 

   559     TCoordinate centre(myLatitude,myLongitude)  ;     

   560     //Define the triggering area

   561         

   562    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   563    						centre,100.1);

   564    							

   565    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   566    	trigArea->SetCenter(centre);

   567    	trigArea->SetRadius(10);*/

   568     CleanupStack::PushL( trigArea );

   569 

   570     //Construct trigger condition

   571     CLbtTriggerConditionArea* cond = 

   572         CLbtTriggerConditionArea::NewL( 

   573         trigArea,

   574         CLbtTriggerConditionArea::EFireOnEnter );

   575         

   576     CleanupStack::Pop( trigArea ); //ownership is transfered.

   577     CleanupStack::PushL( cond );

   578     

   579     _LIT( KMyTriggerName, "Trigger name" );

   580     _LIT( KMyRequestor , "Requestor" );

   581    

   582    	TUid aManagerUi;

   583 	aManagerUi = TUid::Uid(0x87654321);

   584     //Construct a startup trigger

   585     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   586         KMyTriggerName,                             //Trigger name

   587         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   588         CRequestorBase::ERequestorService,          //Requestor type

   589         CRequestorBase::EFormatApplication,         //Requestor format

   590         KMyRequestor,                               //Requestor data

   591         aManagerUi,				                      //Manager UI

   592         cond                                       //Trigger condition

   593         );     

   594         

   595         iLog->Log(_L("Session trigger entry created ")); 	                         

   596         

   597     //Pop trigger condition object

   598     CleanupStack::Pop( cond );

   599     

   600     //Push trigger object to cleanup stack

   601     CleanupStack::PushL( trig );

   602 

   603     //Create the trigger in Location Triggering Server

   604     TLbtTriggerId trigId;

   605     TRequestStatus status;

   606    

   607     for(int i=0;i<5;i++)

   608     {//Remove braces for error test case LocTriggering:5(ELbtDuplicateRequest

   609       CMyObserver *ao;

   610 	ao = CMyObserver::NewL();

   611 	CActiveSchedulerWait *schedulerwait;

   612 	schedulerwait= new CActiveSchedulerWait;

   613 	ao->GiveHandle(schedulerwait);	

   614     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

   615     

   616     //iLog->Log(_L("Session trigger created ")); 

   617     ao->MySetActive();

   618    	schedulerwait->Start();    

   619     }

   620     	

   621 

   622     

   623    /* for(int i=0;i<5;i++)

   624     lbt.CreateTrigger( *trig, trigId, ETrue, status );*/

   625     

   626     iLog->Log(_L("Session trigger created ")); 

   627     

   628     //Delete the instance of trigger object

   629    CleanupStack::PopAndDestroy( trig );

   630    

   631     

   632    /* User::WaitForRequest( status );

   633     User::LeaveIfError( status.Int() );*/

   634     

   635     //Close connection to Location Triggering Server.

   636         

   637     lbt.Close();

   638     CleanupStack::Pop(&lbt); 

   639     //Close connection to RLbtServer

   640     lbtServ.Close(); 

   641     CleanupStack::PopAndDestroy(&lbtServ);  

   642     return KErrNone;

   643     

   644     }

   645     

   646     

   647        // -----------------------------------------------------------------------------

   648 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   649 // Testing the creation of single entry type session trigger.

   650 // (other items were commented in a header).

   651 // -----------------------------------------------------------------------------

   652 //

   653        

   654     TInt CCreateSessiontrigger::CreateSessiontriggerwithoutConnectL( CStifItemParser& aItem )

   655     {

   656         //Connect to Location Triggering Server

   657     RLbtServer lbtServ;

   658     

   659     RLbt lbt;

   660     

   661     TRealX nan;

   662     nan.SetNaN();

   663         

   664     TRealX myLatitude=61.5;

   665     TRealX myLongitude= 24.3;   

   666     TRealX myAltitude =0; 

   667     TRealX myradius =10; 

   668     TCoordinate centre(myLatitude,myLongitude)  ;     

   669     //Define the triggering area

   670         

   671    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   672    						centre,100.1);

   673    							

   674    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   675    	trigArea->SetCenter(centre);

   676    	trigArea->SetRadius(10);*/

   677     CleanupStack::PushL( trigArea );

   678 

   679     //Construct trigger condition

   680     CLbtTriggerConditionArea* cond = 

   681         CLbtTriggerConditionArea::NewL( 

   682         trigArea,

   683         CLbtTriggerConditionArea::EFireOnEnter );

   684         

   685     CleanupStack::Pop( trigArea ); //ownership is transfered.

   686     CleanupStack::PushL( cond );

   687     

   688     _LIT( KMyTriggerName, "Trigger name" );

   689     _LIT( KMyRequestor , "Requestor" );

   690    

   691    	TUid aManagerUi;

   692 	aManagerUi = TUid::Uid(0x87654321);

   693     //Construct a startup trigger

   694     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   695         KMyTriggerName,                             //Trigger name

   696         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   697         CRequestorBase::ERequestorService,          //Requestor type

   698         CRequestorBase::EFormatApplication,         //Requestor format

   699         KMyRequestor,                               //Requestor data

   700         aManagerUi,				                      //Manager UI

   701         cond                                       //Trigger condition

   702         );     

   703         

   704         iLog->Log(_L("Session trigger entry created ")); 	                         

   705         

   706     //Pop trigger condition object

   707     CleanupStack::Pop( cond );

   708     

   709     //Push trigger object to cleanup stack

   710     CleanupStack::PushL( trig );

   711 

   712     //Create the trigger in Location Triggering Server

   713     TLbtTriggerId trigId;

   714     TRequestStatus status;

   715     

   716      CMyObserver *ao;

   717 	ao = CMyObserver::NewL();

   718 	CActiveSchedulerWait *schedulerwait;

   719 	schedulerwait= new CActiveSchedulerWait;

   720 	ao->GiveHandle(schedulerwait);

   721 	TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 2); 	

   722     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

   723     

   724     //iLog->Log(_L("Session trigger created ")); 

   725     ao->MySetActive();

   726    	schedulerwait->Start();  

   727     

   728     iLog->Log(_L("Session trigger created ")); 

   729     

   730     //Delete the instance of trigger object

   731    CleanupStack::PopAndDestroy( trig );

   732    

   733     

   734     /*User::WaitForRequest( status );

   735     User::LeaveIfError( status.Int() );*/

   736     

   737      

   738     return KErrNone;

   739     

   740     }

   741   

   742   

   743   

   744   TInt CCreateSessiontrigger::CreateSessiontriggerwithoutOpenL( CStifItemParser& aItem )

   745     {

   746         //Connect to Location Triggering Server

   747     RLbtServer lbtServ;

   748     User::LeaveIfError(lbtServ.Connect());

   749     CleanupClosePushL(lbtServ);

   750 

   751     RLbt lbt;

   752     

   753     CleanupClosePushL(lbt);

   754         

   755     TRealX nan;

   756     nan.SetNaN();

   757         

   758     TRealX myLatitude=61.5;

   759     TRealX myLongitude= 24.3;   

   760     TRealX myAltitude =0; 

   761     TRealX myradius =10; 

   762     TCoordinate centre(myLatitude,myLongitude)  ;     

   763     //Define the triggering area

   764         

   765    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   766    						centre,100.1);

   767    							

   768    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   769    	trigArea->SetCenter(centre);

   770    	trigArea->SetRadius(10);*/

   771     CleanupStack::PushL( trigArea );

   772 

   773     //Construct trigger condition

   774     CLbtTriggerConditionArea* cond = 

   775         CLbtTriggerConditionArea::NewL( 

   776         trigArea,

   777         CLbtTriggerConditionArea::EFireOnEnter );

   778         

   779     CleanupStack::Pop( trigArea ); //ownership is transfered.

   780     CleanupStack::PushL( cond );

   781     

   782     _LIT( KMyTriggerName, "Trigger name" );

   783     _LIT( KMyRequestor , "Requestor" );

   784    

   785    	TUid aManagerUi;

   786 	aManagerUi = TUid::Uid(0x87654321);

   787     //Construct a startup trigger

   788     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   789         KMyTriggerName,                             //Trigger name

   790         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   791         CRequestorBase::ERequestorService,          //Requestor type

   792         CRequestorBase::EFormatApplication,         //Requestor format

   793         KMyRequestor,                               //Requestor data

   794         aManagerUi,				                      //Manager UI

   795         cond                                       //Trigger condition

   796         );     

   797         

   798         iLog->Log(_L("Session trigger entry created ")); 	                         

   799         

   800     //Pop trigger condition object

   801     CleanupStack::Pop( cond );

   802     

   803     //Push trigger object to cleanup stack

   804     CleanupStack::PushL( trig );

   805 

   806     //Create the trigger in Location Triggering Server

   807     TLbtTriggerId trigId;

   808     TRequestStatus status;

   809     

   810      CMyObserver *ao;

   811 	ao = CMyObserver::NewL();

   812 	CActiveSchedulerWait *schedulerwait;

   813 	schedulerwait= new CActiveSchedulerWait;

   814 	ao->GiveHandle(schedulerwait);

   815 	TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 2); 	

   816     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

   817     

   818     //iLog->Log(_L("Session trigger created ")); 

   819     ao->MySetActive();

   820    	schedulerwait->Start();  

   821     

   822     iLog->Log(_L("Session trigger created ")); 

   823     

   824     //Delete the instance of trigger object

   825    CleanupStack::PopAndDestroy( trig );

   826    

   827     

   828    /* User::WaitForRequest( status );

   829     User::LeaveIfError( status.Int() );*/

   830     

   831     //Close connection to Location Triggering Server.

   832         

   833     

   834     CleanupStack::Pop(&lbt); 

   835     //Close connection to RLbtServer

   836     lbtServ.Close(); 

   837     CleanupStack::PopAndDestroy(&lbtServ);  

   838     return KErrNone;

   839     

   840     }

   841   

   842   

   843   

   844    // -----------------------------------------------------------------------------

   845 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   846 // Testing the creation of single entry type session trigger.

   847 // (other items were commented in a header).

   848 // -----------------------------------------------------------------------------

   849 //

   850        

   851     TInt CCreateSessiontrigger::SessiontriggerNameexceeds256L( CStifItemParser& aItem )

   852     {

   853         //Connect to Location Triggering Server

   854     RLbtServer lbtServ;

   855     User::LeaveIfError(lbtServ.Connect());

   856     CleanupClosePushL(lbtServ);

   857 

   858     RLbt lbt;

   859     User::LeaveIfError(lbt.Open(lbtServ));

   860     CleanupClosePushL(lbt);

   861         

   862     TRealX nan;

   863     nan.SetNaN();

   864         

   865     TRealX myLatitude=61.5;

   866     TRealX myLongitude= 24.3;   

   867     TRealX myAltitude =0; 

   868     TRealX myradius =10; 

   869     TCoordinate centre(myLatitude,myLongitude)  ;     

   870     //Define the triggering area

   871  //  TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 	        

   872    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   873    						centre,100.1);

   874    							

   875    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   876    	trigArea->SetCenter(centre);

   877    	trigArea->SetRadius(10);*/

   878     CleanupStack::PushL( trigArea );

   879 

   880     //Construct trigger condition

   881     CLbtTriggerConditionArea* cond = 

   882         CLbtTriggerConditionArea::NewL( 

   883         trigArea,

   884         CLbtTriggerConditionArea::EFireOnEnter );

   885         

   886     CleanupStack::Pop( trigArea ); //ownership is transfered.

   887     CleanupStack::PushL( cond );

   888     

   889     _LIT( KMyTriggerName, "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" );

   890     

   891     

   892     

   893    // _LIT( KMyTriggerName, "tst");

   894     _LIT( KMyRequestor , "Requestor" );

   895    

   896    	TUid aManagerUi;

   897 	aManagerUi = TUid::Uid(0x87654321);

   898 	

   899 //	TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6);

   900     //Construct a startup trigger

   901     TRAPD(error,CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   902         KMyTriggerName,                             //Trigger name

   903         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   904         CRequestorBase::ERequestorService,          //Requestor type

   905         CRequestorBase::EFormatApplication,         //Requestor format

   906         KMyRequestor,                               //Requestor data

   907         aManagerUi,				                      //Manager UI

   908         cond                                       //Trigger condition

   909         ));    

   910         if(error ==-6)

   911         {

   912         CleanupStack::Pop( cond );

   913         	lbt.Close();

   914     CleanupStack::Pop(&lbt); 

   915     //Close connection to RLbtServer

   916     lbtServ.Close(); 

   917     CleanupStack::PopAndDestroy(&lbtServ);  

   918         	return KErrNone;

   919         }

   920         else

   921         {

   922         	CleanupStack::Pop( cond );

   923         	lbt.Close();

   924     CleanupStack::Pop(&lbt); 

   925     //Close connection to RLbtServer

   926     lbtServ.Close(); 

   927     CleanupStack::PopAndDestroy(&lbtServ);  

   928         	return error;	

   929         }

   930        

   931         

   932     }

   933   

   934   

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

   936 // CCreateSessiontrigger::CreatesingleSessiontriggerL

   937 // Testing the creation of single entry type session trigger.

   938 // (other items were commented in a header).

   939 // -----------------------------------------------------------------------------

   940 //

   941        

   942     TInt CCreateSessiontrigger::SessiontriggerNameequals0L( CStifItemParser& aItem )

   943     {

   944         //Connect to Location Triggering Server

   945     RLbtServer lbtServ;

   946     User::LeaveIfError(lbtServ.Connect());

   947     CleanupClosePushL(lbtServ);

   948 

   949     RLbt lbt;

   950     User::LeaveIfError(lbt.Open(lbtServ));

   951     CleanupClosePushL(lbt);

   952         

   953     TRealX nan;

   954     nan.SetNaN();

   955         

   956     TRealX myLatitude=61.5;

   957     TRealX myLongitude= 24.3;   

   958     TRealX myAltitude =0; 

   959     TRealX myradius =10; 

   960     TCoordinate centre(myLatitude,myLongitude)  ;     

   961     //Define the triggering area

   962         

   963    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

   964    						centre,100.1);

   965    							

   966    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

   967    	trigArea->SetCenter(centre);

   968    	trigArea->SetRadius(10);*/

   969     CleanupStack::PushL( trigArea );

   970 

   971     //Construct trigger condition

   972     CLbtTriggerConditionArea* cond = 

   973         CLbtTriggerConditionArea::NewL( 

   974         trigArea,

   975         CLbtTriggerConditionArea::EFireOnEnter );

   976         

   977     CleanupStack::Pop( trigArea ); //ownership is transfered.

   978     CleanupStack::PushL( cond );

   979     

   980     _LIT( KMyTriggerName, "" );

   981     _LIT( KMyRequestor , "Requestor" );

   982    

   983    	TUid aManagerUi;

   984 	aManagerUi = TUid::Uid(0x87654321);

   985     //Construct a startup trigger

   986     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

   987         KMyTriggerName,                             //Trigger name

   988         CLbtTriggerEntry::EStateEnabled,       //Trigger state

   989         CRequestorBase::ERequestorService,          //Requestor type

   990         CRequestorBase::EFormatApplication,         //Requestor format

   991         KMyRequestor,                               //Requestor data

   992         aManagerUi,				                      //Manager UI

   993         cond                                       //Trigger condition

   994         );     

   995         

   996         iLog->Log(_L("Session trigger entry created ")); 	                         

   997         

   998         

   999    //Pop trigger condition object

  1000     CleanupStack::Pop( cond );

  1001     

  1002     //Push trigger object to cleanup stack

  1003     CleanupStack::PushL( trig );

  1004 

  1005     //Create the trigger in Location Triggering Server

  1006     TLbtTriggerId trigId;

  1007     TRequestStatus status;

  1008     

  1009      CMyObserver *ao;

  1010 	ao = CMyObserver::NewL();

  1011 	CActiveSchedulerWait *schedulerwait;

  1012 	schedulerwait= new CActiveSchedulerWait;

  1013 	ao->GiveHandle(schedulerwait);	

  1014     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );

  1015     

  1016     //iLog->Log(_L("Session trigger created ")); 

  1017     ao->MySetActive();

  1018    	schedulerwait->Start();  

  1019     

  1020     TInt errorflag=0;

  1021 	if(ao->iStatus == KErrArgument)

  1022 	{  

  1023          errorflag=1;

  1024 	}

  1025 	else

  1026 	{

  1027 		 errorflag=0;

  1028 	}

  1029     iLog->Log(_L("Session trigger created ")); 

  1030     

  1031     //Delete the instance of trigger object

  1032    CleanupStack::PopAndDestroy( trig );

  1033    

  1034     

  1035     /*User::WaitForRequest( status );

  1036     User::LeaveIfError( status.Int() );*/

  1037     

  1038     //Close connection to Location Triggering Server.

  1039         

  1040     lbt.Close();

  1041     CleanupStack::Pop(&lbt); 

  1042     //Close connection to RLbtServer

  1043     lbtServ.Close(); 

  1044     CleanupStack::PopAndDestroy(&lbtServ);  

  1045      if(errorflag ==1)

  1046     {

  1047     	return KErrNone;

  1048     }

  1049     else

  1050     {

  1051     	return -10;

  1052     }

  1053     

  1054     }

  1055   

  1056   

  1057      // -----------------------------------------------------------------------------

  1058 // CCreateSessiontrigger::CreatesingleSessiontriggerL

  1059 // Testing the creation of single entry type session trigger.

  1060 // (other items were commented in a header).

  1061 // -----------------------------------------------------------------------------

  1062 //

  1063        

  1064     TInt CCreateSessiontrigger::CreateSessiontriggerwithoutNameL( CStifItemParser& aItem )

  1065     {

  1066         //Connect to Location Triggering Server

  1067     RLbtServer lbtServ;

  1068     User::LeaveIfError(lbtServ.Connect());

  1069     CleanupClosePushL(lbtServ);

  1070 

  1071     RLbt lbt;

  1072     User::LeaveIfError(lbt.Open(lbtServ));

  1073     CleanupClosePushL(lbt);

  1074         

  1075     TRealX nan;

  1076     nan.SetNaN();

  1077         

  1078     TRealX myLatitude=61.5;

  1079     TRealX myLongitude= 24.3;   

  1080     TRealX myAltitude =0; 

  1081     TRealX myradius =10; 

  1082     TCoordinate centre(myLatitude,myLongitude)  ;     

  1083     //Define the triggering area

  1084         

  1085    CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL( 

  1086    						centre,100.1);

  1087    							

  1088    /*	CLbtGeoCircle* trigArea = CLbtGeoCircle::NewL();

  1089    	trigArea->SetCenter(centre);

  1090    	trigArea->SetRadius(10);*/

  1091     CleanupStack::PushL( trigArea );

  1092 

  1093     //Construct trigger condition

  1094     CLbtTriggerConditionArea* cond = 

  1095         CLbtTriggerConditionArea::NewL( 

  1096         trigArea,

  1097         CLbtTriggerConditionArea::EFireOnEnter );

  1098         

  1099     CleanupStack::Pop( trigArea ); //ownership is transfered.

  1100     CleanupStack::PushL( cond );

  1101     

  1102    // _LIT( KMyTriggerName, "Trigger name" );

  1103     _LIT( KMyRequestor , "Requestor" );

  1104    

  1105    	TUid aManagerUi;

  1106 	aManagerUi = TUid::Uid(0x87654321);

  1107     //Construct a startup trigger

  1108     CLbtSessionTrigger* trig = CLbtSessionTrigger::NewL( 

  1109         KNullDesC,                             //Trigger name

  1110         CLbtTriggerEntry::EStateEnabled,       //Trigger state

  1111         CRequestorBase::ERequestorService,          //Requestor type

  1112         CRequestorBase::EFormatApplication,         //Requestor format

  1113         KMyRequestor,                               //Requestor data

  1114         aManagerUi,				                      //Manager UI

  1115         cond                                       //Trigger condition

  1116         );     

  1117         

  1118         iLog->Log(_L("Session trigger entry created ")); 	                         

  1119         

  1120     //Pop trigger condition object

  1121     CleanupStack::Pop( cond );

  1122     

  1123     //Push trigger object to cleanup stack

  1124     CleanupStack::PushL( trig );

  1125 

  1126     //Create the trigger in Location Triggering Server

  1127     TLbtTriggerId trigId;

  1128     TRequestStatus status;

  1129     

  1130      CMyObserver *ao;

  1131 	ao = CMyObserver::NewL();

  1132 	CActiveSchedulerWait *schedulerwait;

  1133 	schedulerwait= new CActiveSchedulerWait;

  1134 	ao->GiveHandle(schedulerwait);	

  1135     lbt.CreateTrigger( *trig, trigId, ETrue, ao->iStatus );