1 /*

     2 * Copyright (c) 2009 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:    This file contains testclass implementation.

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // [INCLUDE FILES] - do not remove

    22 #include <e32svr.h>

    23 #include <StifParser.h>

    24 #include <Stiftestinterface.h>

    25 #include "TestHybridTriggers.h"

    26 

    27 

    28 

    29 // EXTERNAL DATA STRUCTURES

    30 //extern  ?external_data;

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES  

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

    34 

    35 // CONSTANTS

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

    37 

    38 // MACROS

    39 //#define ?macro ?macro_def

    40 

    41 // LOCAL CONSTANTS AND MACROS

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

    43 //#define ?macro_name ?macro_def

    44 

    45 // MODULE DATA STRUCTURES

    46 //enum ?declaration

    47 //typedef ?declaration

    48 

    49 // LOCAL FUNCTION PROTOTYPES

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

    51 

    52 // FORWARD DECLARATIONS

    53 //class ?FORWARD_CLASSNAME;

    54 

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

    56 

    57 // -----------------------------------------------------------------------------

    58 // ?function_name ?description.

    59 // ?description

    60 // Returns: ?value_1: ?description

    61 //          ?value_n: ?description_line1

    62 //                    ?description_line2

    63 // -----------------------------------------------------------------------------

    64 //

    65 /*

    66 ?type ?function_name(

    67     ?arg_type arg,  // ?description

    68     ?arg_type arg)  // ?description

    69     {

    70 

    71     ?code  // ?comment

    72 

    73     // ?comment

    74     ?code

    75     }

    76 */

    77 

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

    79 

    80 // -----------------------------------------------------------------------------

    81 // CTestHybridTriggers::Delete

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

    83 // Called from destructor. 

    84 // -----------------------------------------------------------------------------

    85 //

    86 void CTestHybridTriggers::Delete() 

    87     {

    88 

    89     }

    90 

    91 // -----------------------------------------------------------------------------

    92 // CTestHybridTriggers::RunMethodL

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

    94 // -----------------------------------------------------------------------------

    95 //

    96 TInt CTestHybridTriggers::RunMethodL( 

    97     CStifItemParser& aItem ) 

    98     {

    99 

   100     static TStifFunctionInfo const KFunctions[] =

   101         {  

   102         // Copy this line for every implemented function.

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

   104         // Second is the actual implementation member function. 

   105         ENTRY( "TC_TestNewL1L", CTestHybridTriggers::TC_TestNewL1L ),

   106         ENTRY( "TC_TestNewL2L", CTestHybridTriggers::TC_TestNewL2L ),

   107         ENTRY( "TC_TestNewL3L", CTestHybridTriggers::TC_TestNewL3L ),

   108         ENTRY( "TC_TestNewL4L", CTestHybridTriggers::TC_TestNewL4L ),

   109         ENTRY( "TC_TestNewL5L", CTestHybridTriggers::TC_TestNewL5L ),

   110         ENTRY( "TC_TestNewLC1L", CTestHybridTriggers::TC_TestNewLC1L ),

   111         ENTRY( "TC_TestNewLC2L", CTestHybridTriggers::TC_TestNewLC2L ),

   112         ENTRY( "TC_TestNewLC3L", CTestHybridTriggers::TC_TestNewLC3L ),

   113         ENTRY( "TC_TestNewLC4L", CTestHybridTriggers::TC_TestNewLC4L ),

   114         ENTRY( "TC_TestNewLC5L", CTestHybridTriggers::TC_TestNewLC5L ),

   115         ENTRY( "TC_TestSetHybridArea1L", CTestHybridTriggers::TC_TestSetHybridArea1L ),

   116         ENTRY( "TC_TestSetHybridArea2L", CTestHybridTriggers::TC_TestSetHybridArea2L ),

   117         ENTRY( "TC_TestSetHybridArea3L", CTestHybridTriggers::TC_TestSetHybridArea3L ),

   118         ENTRY( "TC_TestInternalizeAndExternalizeL", CTestHybridTriggers::TC_TestInternalizeAndExternalizeL ),

   119         ENTRY( "TC_TestCLbtTriggerConditionArea1L", CTestHybridTriggers::TC_TestCLbtTriggerConditionArea1L ),

   120         ENTRY( "TC_TestCLbtTriggerConditionArea2L", CTestHybridTriggers::TC_TestCLbtTriggerConditionArea2L ),

   121         ENTRY( "TC_TestCLbtTriggerConditionArea3L", CTestHybridTriggers::TC_TestCLbtTriggerConditionArea3L ),

   122         ENTRY( "TC_TestCLbtTriggerConditionArea4L", CTestHybridTriggers::TC_TestCLbtTriggerConditionArea4L ),

   123         ENTRY( "TC_TestCLbtTriggerFilterByArea1L", CTestHybridTriggers::TC_TestCLbtTriggerFilterByArea1L ),

   124         ENTRY( "TC_TestCLbtTriggerFilterByArea2L", CTestHybridTriggers::TC_TestCLbtTriggerFilterByArea2L ),

   125         ENTRY( "TC_TestCLbtTriggerFilterByArea3L", CTestHybridTriggers::TC_TestCLbtTriggerFilterByArea3L ),

   126         ENTRY( "TC_TestCLbtTriggerFilterByArea4L", CTestHybridTriggers::TC_TestCLbtTriggerFilterByArea4L ),

   127         ENTRY( "TC_TestCreatetrigger1L", CTestHybridTriggers::TC_TestCreatetrigger1L ),

   128         ENTRY( "TC_TestCreatetrigger2L", CTestHybridTriggers::TC_TestCreatetrigger2L ),

   129         ENTRY( "TC_TestCreatetrigger3L", CTestHybridTriggers::TC_TestCreatetrigger3L ),

   130         ENTRY( "TC_TestCreatetrigger4L", CTestHybridTriggers::TC_TestCreatetrigger4L ),

   131         ENTRY( "TC_TestDeleteTrigger1L", CTestHybridTriggers::TC_TestDeleteTrigger1L ),

   132         ENTRY( "TC_TestDeleteTrigger2L", CTestHybridTriggers::TC_TestDeleteTrigger2L ),

   133         ENTRY( "TC_TestDeleteTriggers1L", CTestHybridTriggers::TC_TestDeleteTriggers1L ),

   134         ENTRY( "TC_TestDeleteTriggers2L", CTestHybridTriggers::TC_TestDeleteTriggers2L ),

   135         ENTRY( "TC_TestDeleteTriggers3L", CTestHybridTriggers::TC_TestDeleteTriggers3L ),

   136         ENTRY( "TC_TestDeleteTriggers4L", CTestHybridTriggers::TC_TestDeleteTriggers4L ),

   137         ENTRY( "TC_TestDeleteTriggers5L", CTestHybridTriggers::TC_TestDeleteTriggers5L ),

   138         ENTRY( "TC_TestDeleteTriggers6L", CTestHybridTriggers::TC_TestDeleteTriggers6L ),

   139         ENTRY( "TC_TestDeleteTriggers7L", CTestHybridTriggers::TC_TestDeleteTriggers7L ),

   140         ENTRY( "TC_TestDeleteTriggers8L", CTestHybridTriggers::TC_TestDeleteTriggers8L ),

   141         ENTRY( "TC_TestDeleteTriggers9L", CTestHybridTriggers::TC_TestDeleteTriggers9L ),

   142         ENTRY( "TC_TestDeleteTriggers10L", CTestHybridTriggers::TC_TestDeleteTriggers10L ),

   143         ENTRY( "TC_TestDeleteTriggers11L", CTestHybridTriggers::TC_TestDeleteTriggers11L ),

   144         ENTRY( "TC_TestDeleteTriggers12L", CTestHybridTriggers::TC_TestDeleteTriggers12L ),

   145         ENTRY( "TC_TestGetTriggers1L", CTestHybridTriggers::TC_TestGetTriggers1L ),

   146         ENTRY( "TC_TestGetTriggers2L", CTestHybridTriggers::TC_TestGetTriggers2L ),

   147         ENTRY( "TC_TestGetTriggers3L", CTestHybridTriggers::TC_TestGetTriggers3L ),

   148         ENTRY( "TC_TestGetTriggers4L", CTestHybridTriggers::TC_TestGetTriggers4L ),

   149         ENTRY( "TC_TestGetTriggers5L", CTestHybridTriggers::TC_TestGetTriggers5L ),

   150         ENTRY( "TC_TestGetTriggers6L", CTestHybridTriggers::TC_TestGetTriggers6L ),

   151         ENTRY( "TC_TestGetTriggers7L", CTestHybridTriggers::TC_TestGetTriggers7L ),

   152         ENTRY( "TC_TestGetTriggers8L", CTestHybridTriggers::TC_TestGetTriggers8L ),

   153         ENTRY( "TC_TestGetTriggers9L", CTestHybridTriggers::TC_TestGetTriggers9L ),

   154         ENTRY( "TC_TestGetTriggers10L", CTestHybridTriggers::TC_TestGetTriggers10L ),

   155         ENTRY( "TC_TestGetTriggers11L", CTestHybridTriggers::TC_TestGetTriggers11L ),

   156         ENTRY( "TC_TestGetTriggers12L", CTestHybridTriggers::TC_TestGetTriggers12L ),

   157         ENTRY( "TC_TestGetTriggers_Iterator1L", CTestHybridTriggers::TC_TestGetTriggers_Iterator1L ),

   158         ENTRY( "TC_TestGetTriggers_Iterator2L", CTestHybridTriggers::TC_TestGetTriggers_Iterator2L ),

   159         ENTRY( "TC_TestGetTriggers_Iterator3L", CTestHybridTriggers::TC_TestGetTriggers_Iterator3L ),

   160         ENTRY( "TC_TestGetTriggers_Iterator4L", CTestHybridTriggers::TC_TestGetTriggers_Iterator4L ),

   161         ENTRY( "TC_TestGetTriggers_Iterator5L", CTestHybridTriggers::TC_TestGetTriggers_Iterator5L ),

   162         ENTRY( "TC_TestGetTriggers_Iterator6L", CTestHybridTriggers::TC_TestGetTriggers_Iterator6L ),

   163         ENTRY( "TC_TestGetTriggers_Iterator7L", CTestHybridTriggers::TC_TestGetTriggers_Iterator7L ),

   164         ENTRY( "TC_TestGetTriggers_Iterator8L", CTestHybridTriggers::TC_TestGetTriggers_Iterator8L ),

   165         ENTRY( "TC_TestGetTriggers_Iterator9L", CTestHybridTriggers::TC_TestGetTriggers_Iterator9L ),

   166         ENTRY( "TC_TestGetTriggers_Iterator10L", CTestHybridTriggers::TC_TestGetTriggers_Iterator10L ),

   167         ENTRY( "TC_TestGetTriggers_Iterator11L", CTestHybridTriggers::TC_TestGetTriggers_Iterator11L ),

   168         ENTRY( "TC_TestGetTriggers_Iterator12L", CTestHybridTriggers::TC_TestGetTriggers_Iterator12L ),

   169         ENTRY( "TC_TestSetTriggersState1L", CTestHybridTriggers::TC_TestSetTriggersState1L ),

   170         ENTRY( "TC_TestSetTriggersState2L", CTestHybridTriggers::TC_TestSetTriggersState2L ),

   171         ENTRY( "TC_TestSetTriggersState3L", CTestHybridTriggers::TC_TestSetTriggersState3L ),

   172         ENTRY( "TC_TestSetTriggersState4L", CTestHybridTriggers::TC_TestSetTriggersState4L ),

   173         ENTRY( "TC_TestSetTriggersState5L", CTestHybridTriggers::TC_TestSetTriggersState5L ),

   174         ENTRY( "TC_TestSetTriggersState6L", CTestHybridTriggers::TC_TestSetTriggersState6L ),

   175         ENTRY( "TC_TestSetTriggersState7L", CTestHybridTriggers::TC_TestSetTriggersState7L ),

   176         ENTRY( "TC_TestSetTriggersState8L", CTestHybridTriggers::TC_TestSetTriggersState8L ),

   177         ENTRY( "TC_TestSetTriggersState9L", CTestHybridTriggers::TC_TestSetTriggersState9L ),

   178         ENTRY( "TC_TestSetTriggersState10L", CTestHybridTriggers::TC_TestSetTriggersState10L ),

   179         ENTRY( "TC_TestSetTriggersState11L", CTestHybridTriggers::TC_TestSetTriggersState11L ),

   180         ENTRY( "TC_TestSetTriggersState12L", CTestHybridTriggers::TC_TestSetTriggersState12L ),

   181         ENTRY( "TC_TestSetTriggerState1L", CTestHybridTriggers::TC_TestSetTriggerState1L ),

   182         ENTRY( "TC_TestListtriggerIds1L", CTestHybridTriggers::TC_TestListtriggerIds1L ),

   183         ENTRY( "TC_TestListtriggerIds2L", CTestHybridTriggers::TC_TestListtriggerIds2L ),

   184         ENTRY( "TC_TestListtriggerIds3L", CTestHybridTriggers::TC_TestListtriggerIds3L ),

   185         ENTRY( "TC_TestListtriggerIds4L", CTestHybridTriggers::TC_TestListtriggerIds4L ),

   186         ENTRY( "TC_TestListtriggerIds5L", CTestHybridTriggers::TC_TestListtriggerIds5L ),

   187         ENTRY( "TC_TestListtriggerIds6L", CTestHybridTriggers::TC_TestListtriggerIds6L ),

   188         ENTRY( "TC_TestListtriggerIds7L", CTestHybridTriggers::TC_TestListtriggerIds7L ),

   189         ENTRY( "TC_TestListtriggerIds8L", CTestHybridTriggers::TC_TestListtriggerIds8L ),

   190         ENTRY( "TC_TestListtriggerIds9L", CTestHybridTriggers::TC_TestListtriggerIds9L ),

   191         ENTRY( "TC_TestListtriggerIds10L", CTestHybridTriggers::TC_TestListtriggerIds10L ),

   192         ENTRY( "TC_TestListtriggerIds11L", CTestHybridTriggers::TC_TestListtriggerIds11L ),

   193         ENTRY( "TC_TestListtriggerIds12L", CTestHybridTriggers::TC_TestListtriggerIds12L ),

   194         ENTRY( "TC_TestGettriggerLC1L", CTestHybridTriggers::TC_TestGettriggerLC1L ),

   195         ENTRY( "TC_TestGettriggerLC2L", CTestHybridTriggers::TC_TestGettriggerLC2L ),

   196         ENTRY( "TC_TestUpdateTrigger1L", CTestHybridTriggers::TC_TestUpdateTrigger1L ),

   197         ENTRY( "TC_TestUpdateTrigger2L", CTestHybridTriggers::TC_TestUpdateTrigger2L ),

   198         ENTRY( "TC_TestUpdateTrigger3L", CTestHybridTriggers::TC_TestUpdateTrigger3L ),

   199         ENTRY( "TC_TestUpdateTrigger4L", CTestHybridTriggers::TC_TestUpdateTrigger4L ),

   200         ENTRY( "TC_TestUpdateTrigger5L", CTestHybridTriggers::TC_TestUpdateTrigger5L ),

   201         ENTRY( "TC_TestUpdateTrigger6L", CTestHybridTriggers::TC_TestUpdateTrigger6L ),

   202         ENTRY( "TC_TestHybridTriggerFiring1L", CTestHybridTriggers::TC_TestHybridTriggerFiring1L ),

   203         ENTRY( "TC_TestHybridTriggerFiring2L", CTestHybridTriggers::TC_TestHybridTriggerFiring2L ),

   204         ENTRY( "StartCellChangeNotifierL", CTestHybridTriggers::StartCellChangeNotifierL ),

   205         //ADD NEW ENTRY HERE

   206         // [test cases entries] - Do not remove

   207 

   208         };

   209 

   210     const TInt count = sizeof( KFunctions ) / 

   211                         sizeof( TStifFunctionInfo );

   212 

   213     return RunInternalL( KFunctions, count, aItem );

   214 

   215     }

   216 

   217 void CTestHybridTriggers::AssertTrueL( TBool aCondition,const TDesC& aMessage )

   218     {

   219            

   220          if(!aCondition)

   221          {

   222           

   223            iLog->Log( aMessage );

   224            User::LeaveIfError(KErrGeneral);

   225          }

   226     

   227     }

   228 

   229 // -----------------------------------------------------------------------------

   230 // CTestHybridTriggers::TC_TestNewL1L

   231 // Testing CLbtGeoWlan::NewL()

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

   233 // -----------------------------------------------------------------------------

   234 //

   235 TInt CTestHybridTriggers::TC_TestNewL1L( CStifItemParser& aItem )

   236     {

   237 

   238     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL();

   239     //Push to cleanup stack

   240     CleanupStack::PushL( Hybridarea );

   241         

   242     TBuf<4> Networkcountrycode1 = _L("1000");

   243     TBuf<8> Networkidentitycode1 = _L("10000000");

   244     TUint Locationareacode1 = 100;

   245     TUint CellId1 = 100;

   246         

   247     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   248                                                         Networkcountrycode1,

   249                                                         Networkidentitycode1,

   250                                                         Locationareacode1,

   251                                                         CellId1

   252                                                             );

   253     TBuf<4> Networkcountrycode2 = _L("2000");

   254     TBuf<8> Networkidentitycode2 = _L("20000000");

   255     TUint Locationareacode2 = 200;

   256     TUint CellId2 = 200;

   257         

   258     CLbtGeoCell* Cellarea2  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   259                                                         Networkcountrycode2,

   260                                                         Networkidentitycode2,

   261                                                         Locationareacode2,

   262                                                         CellId2

   263                                                             );

   264     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   265     Hybridareaarray1.Append(Cellarea1);

   266     Hybridareaarray1.Append(Cellarea2);

   267     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   268     

   269     Hybridareaarray2 = Hybridarea->HybridArea();

   270     AssertTrueL(Hybridareaarray2.Count()==0,_L("wrong array count"));

   271     Hybridarea->SetHybridArea(Hybridareaarray1);

   272     Hybridareaarray2 = Hybridarea->HybridArea();

   273     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   274     

   275     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   276         

   277     CLbtGeoCell* cell2=NULL;

   278     if(base->Type()==CLbtGeoAreaBase::ECellular)

   279     {

   280         cell2= static_cast<CLbtGeoCell*> (base);

   281     }    

   282     

   283     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   284     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode1,_L("Wrong Network Country code"));   

   285     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode1,_L("Wrong Network identity code"));            

   286     AssertTrueL(cell2->LocationAreaCode()==Locationareacode1,_L("Wrong Location Area code"));   

   287     AssertTrueL(cell2->CellId()==CellId1,_L("Wrong Cellid"));      

   288     

   289     base=Hybridareaarray2[1];

   290             

   291     cell2=NULL;

   292     if(base->Type()==CLbtGeoAreaBase::ECellular)

   293     {

   294         cell2= static_cast<CLbtGeoCell*> (base);

   295     }    

   296     

   297     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   298     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode2,_L("Wrong Network Country code"));   

   299     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode2,_L("Wrong Network identity code"));            

   300     AssertTrueL(cell2->LocationAreaCode()==Locationareacode2,_L("Wrong Location Area code"));   

   301     AssertTrueL(cell2->CellId()==CellId2,_L("Wrong Cellid"));      

   302     CleanupStack::PopAndDestroy( Hybridarea ); 

   303         

   304     return KErrNone;    

   305 

   306     }

   307 

   308 

   309 // -----------------------------------------------------------------------------

   310 // CTestHybridTriggers::TC_TestNewL2L

   311 // Testing CLbtGeoWlan::NewL()

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

   313 // -----------------------------------------------------------------------------

   314 //

   315 TInt CTestHybridTriggers::TC_TestNewL2L( CStifItemParser& aItem )

   316     {

   317 

   318     TBuf<4> Networkcountrycode1 = _L("1000");

   319     TBuf<8> Networkidentitycode1 = _L("10000000");

   320     TUint Locationareacode1 = 100;

   321     TUint CellId1 = 100;

   322         

   323     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   324                                                         Networkcountrycode1,

   325                                                         Networkidentitycode1,

   326                                                         Locationareacode1,

   327                                                         CellId1

   328                                                             );

   329     TBuf<4> Networkcountrycode2 = _L("2000");

   330     TBuf<8> Networkidentitycode2 = _L("20000000");

   331     TUint Locationareacode2 = 200;

   332     TUint CellId2 = 200;

   333         

   334     CLbtGeoCell* Cellarea2  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   335                                                         Networkcountrycode2,

   336                                                         Networkidentitycode2,

   337                                                         Locationareacode2,

   338                                                         CellId2

   339                                                             );

   340     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   341     Hybridareaarray1.Append(Cellarea1);

   342     Hybridareaarray1.Append(Cellarea2);

   343     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL(Hybridareaarray1);

   344     //Push to cleanup stack

   345     CleanupStack::PushL( Hybridarea );

   346         

   347     

   348     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   349     

   350     Hybridareaarray2 = Hybridarea->HybridArea();

   351     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   352     

   353     TBuf<4> Networkcountrycode3 = _L("3000");

   354     TBuf<8> Networkidentitycode3 = _L("30000000");

   355     TUint Locationareacode3 = 300;

   356     TUint CellId3 = 300;

   357         

   358     CLbtGeoCell* Cellarea3  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   359                                                         Networkcountrycode3,

   360                                                         Networkidentitycode3,

   361                                                         Locationareacode3,

   362                                                         CellId3

   363                                                             );

   364                                                             

   365     TBuf<4> Networkcountrycode4 = _L("4000");

   366     TBuf<8> Networkidentitycode4 = _L("40000000");

   367     TUint Locationareacode4 = 400;

   368     TUint CellId4 = 400;

   369         

   370     CLbtGeoCell* Cellarea4  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   371                                                         Networkcountrycode4,

   372                                                         Networkidentitycode4,

   373                                                         Locationareacode4,

   374                                                         CellId4

   375                                                             );

   376     RPointerArray<CLbtGeoAreaBase> Hybridareaarray3 ;

   377    // Hybridareaarray3.Append(Cellarea1);

   378    // Hybridareaarray3.Append(Cellarea2);

   379     Hybridareaarray3.Append(Cellarea3);

   380     Hybridareaarray3.Append(Cellarea4);

   381     Hybridarea->SetHybridArea(Hybridareaarray3);

   382     Hybridareaarray2 = Hybridarea->HybridArea();

   383     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   384     

   385     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   386         

   387     CLbtGeoCell* cell2=NULL;

   388     if(base->Type()==CLbtGeoAreaBase::ECellular)

   389     {

   390         cell2= static_cast<CLbtGeoCell*> (base);

   391     }    

   392     

   393     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   394     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode3,_L("Wrong Network Country code"));   

   395     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode3,_L("Wrong Network identity code"));            

   396     AssertTrueL(cell2->LocationAreaCode()==Locationareacode3,_L("Wrong Location Area code"));   

   397     AssertTrueL(cell2->CellId()==CellId3,_L("Wrong Cellid"));      

   398     

   399     base=Hybridareaarray2[1];

   400             

   401     cell2=NULL;

   402     if(base->Type()==CLbtGeoAreaBase::ECellular)

   403     {

   404         cell2= static_cast<CLbtGeoCell*> (base);

   405     }    

   406     

   407     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   408     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode4,_L("Wrong Network Country code"));   

   409     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode4,_L("Wrong Network identity code"));            

   410     AssertTrueL(cell2->LocationAreaCode()==Locationareacode4,_L("Wrong Location Area code"));   

   411     AssertTrueL(cell2->CellId()==CellId4,_L("Wrong Cellid"));      

   412     

   413     /*base=Hybridareaarray2[2];

   414                 

   415     cell2=NULL;

   416     if(base->Type()==CLbtGeoAreaBase::ECellular)

   417     {

   418         cell2= static_cast<CLbtGeoCell*> (base);

   419     }    

   420     

   421     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   422     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode3,_L("Wrong Network Country code"));   

   423     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode3,_L("Wrong Network identity code"));            

   424     AssertTrueL(cell2->LocationAreaCode()==Locationareacode3,_L("Wrong Location Area code"));   

   425     AssertTrueL(cell2->CellId()==CellId3,_L("Wrong Cellid"));   */   

   426     CleanupStack::PopAndDestroy( Hybridarea ); 

   427         

   428     return KErrNone;    

   429 

   430     }

   431 

   432 // -----------------------------------------------------------------------------

   433 // CTestHybridTriggers::TC_TestNewL3L

   434 // Testing CLbtGeoWlan::NewL() with circular area as part of the Hybrid area array

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

   436 // -----------------------------------------------------------------------------

   437 //

   438 TInt CTestHybridTriggers::TC_TestNewL3L( CStifItemParser& aItem )

   439     {

   440 

   441     TBuf<4> Networkcountrycode1 = _L("1000");

   442     TBuf<8> Networkidentitycode1 = _L("10000000");

   443     TUint Locationareacode1 = 100;

   444     TUint CellId1 = 100;

   445         

   446     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   447                                                         Networkcountrycode1,

   448                                                         Networkidentitycode1,

   449                                                         Locationareacode1,

   450                                                         CellId1

   451                                                             );

   452     TCoordinate coordinate(62.5285,23.9385);

   453         

   454     CLbtGeoCircle* circlearea=CLbtGeoCircle::NewL(coordinate,1000);

   455     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   456     Hybridareaarray1.Append(Cellarea1);

   457     Hybridareaarray1.Append(circlearea);

   458     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   459     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL(Hybridareaarray1);

   460     //Push to cleanup stack

   461     CleanupStack::PushL( Hybridarea );

   462         

   463     

   464     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   465     

   466     Hybridareaarray2 = Hybridarea->HybridArea();

   467     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   468       

   469     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   470     

   471     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   472         

   473     CLbtGeoCell* cell2=NULL;

   474     if(base->Type()==CLbtGeoAreaBase::ECellular)

   475     {

   476         cell2= static_cast<CLbtGeoCell*> (base);

   477     }    

   478     

   479     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   480     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode1,_L("Wrong Network Country code"));   

   481     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode1,_L("Wrong Network identity code"));            

   482     AssertTrueL(cell2->LocationAreaCode()==Locationareacode1,_L("Wrong Location Area code"));   

   483     AssertTrueL(cell2->CellId()==CellId1,_L("Wrong Cellid"));      

   484     

   485     base=Hybridareaarray2[1];

   486             

   487     CLbtGeoCircle* circle2 =NULL;

   488     if(base->Type()==CLbtGeoAreaBase::ECircle)

   489     {

   490     circle2= static_cast<CLbtGeoCircle*> (base);

   491     }    

   492     

   493     TCoordinate center2 = circle2->Center();

   494     TReal32 distance;

   495     center2.Distance(TCoordinate( 62.5285,23.9385,0 ),distance);

   496     if(distance!=0)

   497     {

   498         return KErrGeneral;

   499     }

   500     TReal radius = circle2->Radius();

   501     if(radius != 1000)

   502     {

   503         return KErrGeneral;

   504     }

   505    

   506     CleanupStack::PopAndDestroy( Hybridarea ); 

   507         

   508     return KErrNone;    

   509 

   510     }

   511 

   512 // -----------------------------------------------------------------------------

   513 // CTestHybridTriggers::TC_TestNewL4L

   514 // Testing CLbtGeoWlan::NewL() using empty array

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

   516 // -----------------------------------------------------------------------------

   517 //

   518 TInt CTestHybridTriggers::TC_TestNewL4L( CStifItemParser& aItem )

   519     {

   520  

   521     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   522     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   523     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL(Hybridareaarray1);

   524            

   525     return KErrNone;    

   526 

   527     }

   528 

   529 // -----------------------------------------------------------------------------

   530 // CTestHybridTriggers::TC_TestNewL5L

   531 // Testing CLbtGeoWlan::NewL() with CLbtGeoRect as one of the arae in the array

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

   533 // -----------------------------------------------------------------------------

   534 //

   535 TInt CTestHybridTriggers::TC_TestNewL5L( CStifItemParser& aItem )

   536     {

   537  

   538     TBuf<4> Networkcountrycode1 = _L("1000");

   539     TBuf<8> Networkidentitycode1 = _L("10000000");

   540     TUint Locationareacode1 = 100;

   541     TUint CellId1 = 100;

   542         

   543     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   544                                                         Networkcountrycode1,

   545                                                         Networkidentitycode1,

   546                                                         Locationareacode1,

   547                                                         CellId1

   548                                                             );

   549     CLbtGeoRect* Rectarea = CLbtGeoRect::NewL( 20,70,20,70);

   550     

   551     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   552     Hybridareaarray1.Append(Cellarea1);

   553     Hybridareaarray1.Append(Rectarea);

   554     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   555     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL(Hybridareaarray1);

   556 		return KErrNone;

   557     }

   558 

   559 // -----------------------------------------------------------------------------

   560 // CTestHybridTriggers::TC_TestNewLC1L

   561 // Testing CLbtGeoWlan::NewLC()

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

   563 // -----------------------------------------------------------------------------

   564 //

   565 TInt CTestHybridTriggers::TC_TestNewLC1L( CStifItemParser& aItem )

   566     {

   567 

   568     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewLC();

   569     

   570     TBuf<4> Networkcountrycode1 = _L("1000");

   571     TBuf<8> Networkidentitycode1 = _L("10000000");

   572     TUint Locationareacode1 = 100;

   573     TUint CellId1 = 100;

   574         

   575     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   576                                                         Networkcountrycode1,

   577                                                         Networkidentitycode1,

   578                                                         Locationareacode1,

   579                                                         CellId1

   580                                                             );

   581     TBuf<4> Networkcountrycode2 = _L("2000");

   582     TBuf<8> Networkidentitycode2 = _L("20000000");

   583     TUint Locationareacode2 = 200;

   584     TUint CellId2 = 200;

   585         

   586     CLbtGeoCell* Cellarea2  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   587                                                         Networkcountrycode2,

   588                                                         Networkidentitycode2,

   589                                                         Locationareacode2,

   590                                                         CellId2

   591                                                             );

   592     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   593             Hybridareaarray1.Append(Cellarea1);

   594             Hybridareaarray1.Append(Cellarea2);

   595     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   596     

   597     Hybridareaarray2 = Hybridarea->HybridArea();

   598     AssertTrueL(Hybridareaarray2.Count()==0,_L("wrong array count"));

   599     Hybridarea->SetHybridArea(Hybridareaarray1);

   600     Hybridareaarray2 = Hybridarea->HybridArea();

   601     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   602     

   603     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   604         

   605     CLbtGeoCell* cell2=NULL;

   606     if(base->Type()==CLbtGeoAreaBase::ECellular)

   607     {

   608         cell2= static_cast<CLbtGeoCell*> (base);

   609     }    

   610     

   611     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   612     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode1,_L("Wrong Network Country code"));   

   613     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode1,_L("Wrong Network identity code"));            

   614     AssertTrueL(cell2->LocationAreaCode()==Locationareacode1,_L("Wrong Location Area code"));   

   615     AssertTrueL(cell2->CellId()==CellId1,_L("Wrong Cellid"));      

   616     

   617     base=Hybridareaarray2[1];

   618             

   619     cell2=NULL;

   620     if(base->Type()==CLbtGeoAreaBase::ECellular)

   621     {

   622         cell2= static_cast<CLbtGeoCell*> (base);

   623     }    

   624     

   625     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   626     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode2,_L("Wrong Network Country code"));   

   627     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode2,_L("Wrong Network identity code"));            

   628     AssertTrueL(cell2->LocationAreaCode()==Locationareacode2,_L("Wrong Location Area code"));   

   629     AssertTrueL(cell2->CellId()==CellId2,_L("Wrong Cellid"));      

   630     CleanupStack::PopAndDestroy( Hybridarea ); 

   631         

   632     return KErrNone;    

   633 

   634     }

   635 

   636 

   637 // -----------------------------------------------------------------------------

   638 // CTestHybridTriggers::TC_TestNewLC2L

   639 // Testing CLbtGeoWlan::NewLC()

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

   641 // -----------------------------------------------------------------------------

   642 //

   643 TInt CTestHybridTriggers::TC_TestNewLC2L( CStifItemParser& aItem )

   644     {

   645 

   646     TBuf<4> Networkcountrycode1 = _L("1000");

   647     TBuf<8> Networkidentitycode1 = _L("10000000");

   648     TUint Locationareacode1 = 100;

   649     TUint CellId1 = 100;

   650         

   651     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   652                                                         Networkcountrycode1,

   653                                                         Networkidentitycode1,

   654                                                         Locationareacode1,

   655                                                         CellId1

   656                                                             );

   657     TBuf<4> Networkcountrycode2 = _L("2000");

   658     TBuf<8> Networkidentitycode2 = _L("20000000");

   659     TUint Locationareacode2 = 200;

   660     TUint CellId2 = 200;

   661         

   662     CLbtGeoCell* Cellarea2  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   663                                                         Networkcountrycode2,

   664                                                         Networkidentitycode2,

   665                                                         Locationareacode2,

   666                                                         CellId2

   667                                                             );

   668     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   669                 Hybridareaarray1.Append(Cellarea1);

   670                 Hybridareaarray1.Append(Cellarea2);

   671     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewLC(Hybridareaarray1);

   672     

   673     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   674     

   675     Hybridareaarray2 = Hybridarea->HybridArea();

   676     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   677     

   678     TBuf<4> Networkcountrycode3 = _L("3000");

   679     TBuf<8> Networkidentitycode3 = _L("30000000");

   680     TUint Locationareacode3 = 300;

   681     TUint CellId3 = 200;

   682         

   683     CLbtGeoCell* Cellarea3  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   684                                                         Networkcountrycode3,

   685                                                         Networkidentitycode3,

   686                                                         Locationareacode3,

   687                                                         CellId3

   688                                                             );

   689     TBuf<4> Networkcountrycode4 = _L("4000");

   690     TBuf<8> Networkidentitycode4 = _L("40000000");

   691     TUint Locationareacode4 = 400;

   692     TUint CellId4 = 400;

   693         

   694     CLbtGeoCell* Cellarea4  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   695                                                         Networkcountrycode4,

   696                                                         Networkidentitycode4,

   697                                                         Locationareacode4,

   698                                                         CellId4

   699                                                             );

   700     RPointerArray<CLbtGeoAreaBase> Hybridareaarray3 ;

   701    // Hybridareaarray3.Append(Cellarea1);

   702    // Hybridareaarray3.Append(Cellarea2);

   703     Hybridareaarray3.Append(Cellarea3);

   704     Hybridareaarray3.Append(Cellarea4);

   705     Hybridarea->SetHybridArea(Hybridareaarray3);

   706     Hybridareaarray2 = Hybridarea->HybridArea();

   707     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   708     

   709     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   710         

   711     CLbtGeoCell* cell2=NULL;

   712     if(base->Type()==CLbtGeoAreaBase::ECellular)

   713     {

   714         cell2= static_cast<CLbtGeoCell*> (base);

   715     }    

   716     

   717     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   718     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode3,_L("Wrong Network Country code"));   

   719     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode3,_L("Wrong Network identity code"));            

   720     AssertTrueL(cell2->LocationAreaCode()==Locationareacode3,_L("Wrong Location Area code"));   

   721     AssertTrueL(cell2->CellId()==CellId3,_L("Wrong Cellid"));      

   722     

   723     base=Hybridareaarray2[1];

   724             

   725     cell2=NULL;

   726     if(base->Type()==CLbtGeoAreaBase::ECellular)

   727     {

   728         cell2= static_cast<CLbtGeoCell*> (base);

   729     }    

   730     

   731     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   732     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode4,_L("Wrong Network Country code"));   

   733     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode4,_L("Wrong Network identity code"));            

   734     AssertTrueL(cell2->LocationAreaCode()==Locationareacode4,_L("Wrong Location Area code"));   

   735     AssertTrueL(cell2->CellId()==CellId4,_L("Wrong Cellid"));      

   736     

   737     

   738     CleanupStack::PopAndDestroy( Hybridarea ); 

   739     return KErrNone;    

   740 

   741     }

   742 

   743 // -----------------------------------------------------------------------------

   744 // CTestHybridTriggers::TC_TestNewL3L

   745 // Testing CLbtGeoWlan::NewL() with circular area as part of the Hybrid area array

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

   747 // -----------------------------------------------------------------------------

   748 //

   749 TInt CTestHybridTriggers::TC_TestNewLC3L( CStifItemParser& aItem )

   750     {

   751 

   752     TBuf<4> Networkcountrycode1 = _L("1000");

   753     TBuf<8> Networkidentitycode1 = _L("10000000");

   754     TUint Locationareacode1 = 100;

   755     TUint CellId1 = 100;

   756         

   757     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   758                                                         Networkcountrycode1,

   759                                                         Networkidentitycode1,

   760                                                         Locationareacode1,

   761                                                         CellId1

   762                                                             );

   763     TCoordinate coordinate(62.5285,23.9385);

   764         

   765     CLbtGeoCircle* circlearea=CLbtGeoCircle::NewL(coordinate,1000);

   766     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   767                     Hybridareaarray1.Append(Cellarea1);

   768                     Hybridareaarray1.Append(circlearea);

   769     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   770     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewLC(Hybridareaarray1);

   771     

   772     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   773     

   774     Hybridareaarray2 = Hybridarea->HybridArea();

   775     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   776       

   777     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   778     

   779     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   780         

   781     CLbtGeoCell* cell2=NULL;

   782     if(base->Type()==CLbtGeoAreaBase::ECellular)

   783     {

   784         cell2= static_cast<CLbtGeoCell*> (base);

   785     }    

   786     

   787     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   788     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode1,_L("Wrong Network Country code"));   

   789     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode1,_L("Wrong Network identity code"));            

   790     AssertTrueL(cell2->LocationAreaCode()==Locationareacode1,_L("Wrong Location Area code"));   

   791     AssertTrueL(cell2->CellId()==CellId1,_L("Wrong Cellid"));      

   792     

   793     base=Hybridareaarray2[1];

   794             

   795     CLbtGeoCircle* circle2=NULL;

   796     if(base->Type()==CLbtGeoAreaBase::ECircle)

   797     {

   798     circle2= static_cast<CLbtGeoCircle*> (base);

   799     }    

   800     

   801     TCoordinate center2 = circle2->Center();

   802     TReal32 distance;

   803     center2.Distance(TCoordinate( 62.5285,23.9385,0 ),distance);

   804     if(distance!=0)

   805     {

   806         return KErrGeneral;

   807     }

   808     TReal radius = circle2->Radius();

   809     if(radius != 1000)

   810     {

   811         return KErrGeneral;

   812     }

   813    

   814     CleanupStack::PopAndDestroy( Hybridarea ); 

   815         

   816     return KErrNone;    

   817 

   818     }

   819 

   820 // -----------------------------------------------------------------------------

   821 // CTestHybridTriggers::TC_TestNewLC3L

   822 // Testing CLbtGeoWlan::NewLC() using empty array

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

   824 // -----------------------------------------------------------------------------

   825 //

   826 TInt CTestHybridTriggers::TC_TestNewLC4L( CStifItemParser& aItem )

   827     {

   828  

   829     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   830     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   831     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewLC(Hybridareaarray1);

   832         

   833     return KErrNone;    

   834 

   835     }

   836 

   837 // -----------------------------------------------------------------------------

   838 // CTestHybridTriggers::TC_TestNewLC5L

   839 // Testing CLbtGeoWlan::NewLC() with CLbtGeoRect as one of the arae in the array

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

   841 // -----------------------------------------------------------------------------

   842 //

   843 TInt CTestHybridTriggers::TC_TestNewLC5L( CStifItemParser& aItem )

   844     {

   845  

   846     TBuf<4> Networkcountrycode1 = _L("1000");

   847     TBuf<8> Networkidentitycode1 = _L("10000000");

   848     TUint Locationareacode1 = 100;

   849     TUint CellId1 = 100;

   850         

   851     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   852                                                         Networkcountrycode1,

   853                                                         Networkidentitycode1,

   854                                                         Locationareacode1,

   855                                                         CellId1

   856                                                             );

   857     CLbtGeoRect* Rectarea = CLbtGeoRect::NewL( 20,70,20,70);

   858     

   859     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   860                         Hybridareaarray1.Append(Cellarea1);

   861                         Hybridareaarray1.Append(Rectarea);

   862     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   863     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewLC(Hybridareaarray1);

   864 		return KErrNone;

   865     }

   866 

   867 // -----------------------------------------------------------------------------

   868 // CTestHybridTriggers::TC_TestSetHybridArea1L

   869 // Testing SetHybridArea with one cellular area and one circular area

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

   871 // -----------------------------------------------------------------------------

   872 //

   873 TInt CTestHybridTriggers::TC_TestSetHybridArea1L( CStifItemParser& aItem )

   874     {

   875 

   876     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL();

   877     //Push to cleanup stack

   878     CleanupStack::PushL( Hybridarea );

   879         

   880     TBuf<4> Networkcountrycode1 = _L("1000");

   881     TBuf<8> Networkidentitycode1 = _L("10000000");

   882     TUint Locationareacode1 = 100;

   883     TUint CellId1 = 100;

   884         

   885     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   886                                                         Networkcountrycode1,

   887                                                         Networkidentitycode1,

   888                                                         Locationareacode1,

   889                                                         CellId1

   890                                                             );

   891     TCoordinate coordinate(62.5285,23.9385);

   892            

   893     CLbtGeoCircle* circlearea=CLbtGeoCircle::NewL(coordinate,1000);

   894     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   895     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   896                             Hybridareaarray1.Append(Cellarea1);

   897                             Hybridareaarray1.Append(circlearea);

   898     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

   899     

   900     Hybridareaarray2 = Hybridarea->HybridArea();

   901     AssertTrueL(Hybridareaarray2.Count()==0,_L("wrong array count"));

   902     Hybridarea->SetHybridArea(Hybridareaarray1);

   903     Hybridareaarray2 = Hybridarea->HybridArea();

   904     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

   905     

   906     CLbtGeoAreaBase* base=Hybridareaarray2[0];

   907         

   908     CLbtGeoCell* cell2=NULL;

   909     if(base->Type()==CLbtGeoAreaBase::ECellular)

   910     {

   911         cell2= static_cast<CLbtGeoCell*> (base);

   912     }    

   913     

   914     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

   915     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode1,_L("Wrong Network Country code"));   

   916     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode1,_L("Wrong Network identity code"));            

   917     AssertTrueL(cell2->LocationAreaCode()==Locationareacode1,_L("Wrong Location Area code"));   

   918     AssertTrueL(cell2->CellId()==CellId1,_L("Wrong Cellid"));      

   919     

   920     base=Hybridareaarray2[1];

   921                 

   922     CLbtGeoCircle* circle2 =NULL;

   923     if(base->Type()==CLbtGeoAreaBase::ECircle)

   924     {

   925     circle2= static_cast<CLbtGeoCircle*> (base);

   926     }    

   927     

   928     TCoordinate center2 = circle2->Center();

   929     TReal32 distance;

   930     center2.Distance(TCoordinate( 62.5285,23.9385,0 ),distance);

   931     if(distance!=0)

   932     {

   933         return KErrGeneral;

   934     }

   935     TReal radius = circle2->Radius();

   936     if(radius != 1000)

   937     {

   938         return KErrGeneral;

   939     }

   940     CleanupStack::PopAndDestroy( Hybridarea ); 

   941         

   942     return KErrNone;    

   943 

   944     }

   945 

   946 // -----------------------------------------------------------------------------

   947 // CTestHybridTriggers::TC_TestNewL4L

   948 // Testing SetHybridArea with empty array

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

   950 // -----------------------------------------------------------------------------

   951 //

   952 TInt CTestHybridTriggers::TC_TestSetHybridArea2L( CStifItemParser& aItem )

   953     {

   954  

   955     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   956     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   957     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL();

   958     Hybridarea->SetHybridArea(Hybridareaarray1);

   959            

   960     return KErrNone;    

   961 

   962     }

   963 

   964 // -----------------------------------------------------------------------------

   965 // CTestHybridTriggers::TC_TestNewL5L

   966 // Testing SetHybridArea with CLbtGeoRect as one of the arae in the array

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

   968 // -----------------------------------------------------------------------------

   969 //

   970 TInt CTestHybridTriggers::TC_TestSetHybridArea3L( CStifItemParser& aItem )

   971     {

   972  

   973     TBuf<4> Networkcountrycode1 = _L("1000");

   974     TBuf<8> Networkidentitycode1 = _L("10000000");

   975     TUint Locationareacode1 = 100;

   976     TUint CellId1 = 100;

   977         

   978     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

   979                                                         Networkcountrycode1,

   980                                                         Networkidentitycode1,

   981                                                         Locationareacode1,

   982                                                         CellId1

   983                                                             );

   984     CLbtGeoRect* Rectarea = CLbtGeoRect::NewL( 20,70,20,70);

   985     

   986     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

   987                                 Hybridareaarray1.Append(Cellarea1);

   988                                 Hybridareaarray1.Append(Rectarea);

   989     TestModuleIf().SetExitReason( CTestModuleIf::EPanic, 6); 

   990     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL();

   991     Hybridarea->SetHybridArea(Hybridareaarray1);

   992 		return KErrNone;

   993     }

   994 

   995 // -----------------------------------------------------------------------------

   996 // CTestHybridTriggers::TC_TestInternalizeAndExternalizeL

   997 // Calling Bssid() function by passing index greater than number of elements in the array

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

   999 // -----------------------------------------------------------------------------

  1000 //

  1001 TInt CTestHybridTriggers::TC_TestInternalizeAndExternalizeL( CStifItemParser& aItem )

  1002     {

  1003 

  1004     CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewLC();

  1005         

  1006     TBuf<4> Networkcountrycode1 = _L("1000");

  1007     TBuf<8> Networkidentitycode1 = _L("10000000");

  1008     TUint Locationareacode1 = 100;

  1009     TUint CellId1 = 100;

  1010         

  1011     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

  1012                                                         Networkcountrycode1,

  1013                                                         Networkidentitycode1,

  1014                                                         Locationareacode1,

  1015                                                         CellId1

  1016                                                             );

  1017     TBuf<4> Networkcountrycode2 = _L("2000");

  1018     TBuf<8> Networkidentitycode2 = _L("20000000");

  1019     TUint Locationareacode2 = 200;

  1020     TUint CellId2 = 200;

  1021         

  1022     CLbtGeoCell* Cellarea2  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

  1023                                                         Networkcountrycode2,

  1024                                                         Networkidentitycode2,

  1025                                                         Locationareacode2,

  1026                                                         CellId2

  1027                                                             );

  1028     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

  1029     Hybridareaarray1.Append(Cellarea1);

  1030     Hybridareaarray1.Append(Cellarea2);

  1031     RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

  1032     Hybridarea->SetHybridArea(Hybridareaarray1);

  1033     

  1034     CBufFlat* buffer= CBufFlat::NewL(256);

  1035     CleanupStack::PushL( buffer );  

  1036    

  1037     RBufWriteStream wr;

  1038     wr.Open(*buffer);

  1039     CleanupClosePushL(wr);

  1040     Hybridarea->ExternalizeL(wr);

  1041    

  1042     wr.CommitL();

  1043     CleanupStack::PopAndDestroy(&wr);

  1044 

  1045     CLbtGeoHybrid* Hybridarea2  = CLbtGeoHybrid::NewL();

  1046        

  1047     //Push to cleanup stack

  1048     CleanupStack::PushL( Hybridarea2 ); 

  1049    

  1050     RBufReadStream rd;

  1051     rd.Open(*buffer);

  1052     CleanupClosePushL(rd);

  1053    

  1054     Hybridarea2->InternalizeL(rd);

  1055    

  1056     CleanupStack::PopAndDestroy(&rd);

  1057    

  1058     buffer->Reset();

  1059    

  1060     Hybridareaarray2 = Hybridarea2->HybridArea();

  1061     AssertTrueL(Hybridareaarray2.Count()==2,_L("wrong array count"));

  1062     

  1063     CLbtGeoAreaBase* base=Hybridareaarray2[0];

  1064         

  1065     CLbtGeoCell* cell2=NULL;

  1066     if(base->Type()==CLbtGeoAreaBase::ECellular)

  1067     {

  1068         cell2= static_cast<CLbtGeoCell*> (base);

  1069     }    

  1070     

  1071     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

  1072     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode1,_L("Wrong Network Country code"));   

  1073     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode1,_L("Wrong Network identity code"));            

  1074     AssertTrueL(cell2->LocationAreaCode()==Locationareacode1,_L("Wrong Location Area code"));   

  1075     AssertTrueL(cell2->CellId()==CellId1,_L("Wrong Cellid"));      

  1076     

  1077     base=Hybridareaarray2[1];

  1078             

  1079     cell2=NULL;

  1080     if(base->Type()==CLbtGeoAreaBase::ECellular)

  1081     {

  1082         cell2= static_cast<CLbtGeoCell*> (base);

  1083     }    

  1084     

  1085     AssertTrueL(cell2->NetworkType()==RMobilePhone::ENetworkModeGsm,_L("Wrong network Type")); 

  1086     AssertTrueL(cell2->NetworkCountryCode()==Networkcountrycode2,_L("Wrong Network Country code"));   

  1087     AssertTrueL(cell2->NetworkIdentityCode()==Networkidentitycode2,_L("Wrong Network identity code"));            

  1088     AssertTrueL(cell2->LocationAreaCode()==Locationareacode2,_L("Wrong Location Area code"));   

  1089     AssertTrueL(cell2->CellId()==CellId2,_L("Wrong Cellid"));      

  1090           

  1091     CleanupStack::PopAndDestroy( 3 );

  1092         

  1093     return KErrNone;    

  1094     }

  1095 

  1096 // -----------------------------------------------------------------------------

  1097 // CTestHybridTriggers::TC_TestCLbtTriggerConditionArea1L

  1098 // Allocates and constructs a new Trigger Condition area object using CLbtGeoHybrid 1

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

  1100 // -----------------------------------------------------------------------------

  1101 //

  1102 TInt CTestHybridTriggers::TC_TestCLbtTriggerConditionArea1L( CStifItemParser& aItem )

  1103     {

  1104 

  1105     CLbtTriggerConditionArea* cond1= CLbtTriggerConditionArea::NewL( );

  1106     CleanupStack::PushL( cond1 ); 

  1107     

  1108     cond1->SetDirection( CLbtTriggerConditionArea::EFireOnExit );

  1109   

  1110     TBuf<4> Networkcountrycode1 = _L("1000");

  1111     TBuf<8> Networkidentitycode1 = _L("10000000");

  1112     TUint Locationareacode1 = 100;

  1113     TUint CellId1 = 100;

  1114         

  1115     CLbtGeoCell* Cellarea1  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

  1116                                                         Networkcountrycode1,

  1117                                                         Networkidentitycode1,

  1118                                                         Locationareacode1,

  1119                                                         CellId1

  1120                                                             );

  1121     TBuf<4> Networkcountrycode2 = _L("2000");

  1122     TBuf<8> Networkidentitycode2 = _L("20000000");

  1123     TUint Locationareacode2 = 200;

  1124     TUint CellId2 = 200;

  1125         

  1126     CLbtGeoCell* Cellarea2  = CLbtGeoCell::NewL(RMobilePhone :: ENetworkModeGsm,

  1127                                                         Networkcountrycode2,

  1128                                                         Networkidentitycode2,

  1129                                                         Locationareacode2,

  1130                                                         CellId2

  1131                                                             );

  1132     RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

  1133     Hybridareaarray1.Append(Cellarea1);

  1134     Hybridareaarray1.Append(Cellarea2);