/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

* 

* Description:    This file contains testclass implementation.

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "TestHybridTriggers.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

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

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

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

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

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

// CTestHybridTriggers::Delete

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

// Called from destructor. 

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

//

void CTestHybridTriggers::Delete() 

    {

    }

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

// CTestHybridTriggers::RunMethodL

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

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

//

TInt CTestHybridTriggers::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

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

        // Second is the actual implementation member function. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

    {

         if(!aCondition)

         {

           iLog->Log( aMessage );

           User::LeaveIfError(KErrGeneral);

         }

    }

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

// CTestHybridTriggers::TC_TestNewL1L

// Testing CLbtGeoWlan::NewL()

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

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

//

TInt CTestHybridTriggers::TC_TestNewL1L( CStifItemParser& aItem )

    {

    CLbtGeoHybrid* Hybridarea  = CLbtGeoHybrid::NewL();

    //Push to cleanup stack

    CleanupStack::PushL( Hybridarea );

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

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

    TUint Locationareacode1 = 100;

    TUint CellId1 = 100;

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

                                                        Networkcountrycode1,

                                                        Networkidentitycode1,

                                                        Locationareacode1,

                                                        CellId1

                                                            );

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

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

    TUint Locationareacode2 = 200;

    TUint CellId2 = 200;

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

                                                        Networkcountrycode2,

                                                        Networkidentitycode2,

                                                        Locationareacode2,

                                                        CellId2

                                                            );

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

    Hybridareaarray1.Append(Cellarea1);

    Hybridareaarray1.Append(Cellarea2);

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

    Hybridareaarray2 = Hybridarea->HybridArea();

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

    Hybridarea->SetHybridArea(Hybridareaarray1);

    Hybridareaarray2 = Hybridarea->HybridArea();

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

    CLbtGeoAreaBase* base=Hybridareaarray2[0];

    CLbtGeoCell* cell2=NULL;

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

    {

        cell2= static_cast<CLbtGeoCell*> (base);

    }    

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

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

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

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

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

    base=Hybridareaarray2[1];

    cell2=NULL;

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

    {

        cell2= static_cast<CLbtGeoCell*> (base);

    }    

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

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

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

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

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

    CleanupStack::PopAndDestroy( Hybridarea ); 

    return KErrNone;    

    }

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

// CTestHybridTriggers::TC_TestNewL2L

// Testing CLbtGeoWlan::NewL()

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

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

//

TInt CTestHybridTriggers::TC_TestNewL2L( CStifItemParser& aItem )

    {

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

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

    TUint Locationareacode1 = 100;

    TUint CellId1 = 100;

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

                                                        Networkcountrycode1,

                                                        Networkidentitycode1,

                                                        Locationareacode1,

                                                        CellId1

                                                            );

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

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

    TUint Locationareacode2 = 200;

    TUint CellId2 = 200;

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

                                                        Networkcountrycode2,

                                                        Networkidentitycode2,

                                                        Locationareacode2,

                                                        CellId2

                                                            );

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

    Hybridareaarray1.Append(Cellarea1);

    Hybridareaarray1.Append(Cellarea2);

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

    //Push to cleanup stack

    CleanupStack::PushL( Hybridarea );

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

    Hybridareaarray2 = Hybridarea->HybridArea();

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

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

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

    TUint Locationareacode3 = 300;

    TUint CellId3 = 300;

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

                                                        Networkcountrycode3,

                                                        Networkidentitycode3,

                                                        Locationareacode3,

                                                        CellId3

                                                            );

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

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

    TUint Locationareacode4 = 400;

    TUint CellId4 = 400;

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

                                                        Networkcountrycode4,

                                                        Networkidentitycode4,

                                                        Locationareacode4,

                                                        CellId4

                                                            );

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray3 ;

   // Hybridareaarray3.Append(Cellarea1);

   // Hybridareaarray3.Append(Cellarea2);

    Hybridareaarray3.Append(Cellarea3);

    Hybridareaarray3.Append(Cellarea4);

    Hybridarea->SetHybridArea(Hybridareaarray3);

    Hybridareaarray2 = Hybridarea->HybridArea();

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

    CLbtGeoAreaBase* base=Hybridareaarray2[0];

    CLbtGeoCell* cell2=NULL;

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

    {

        cell2= static_cast<CLbtGeoCell*> (base);

    }    

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

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

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

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

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

    base=Hybridareaarray2[1];

    cell2=NULL;

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

    {

        cell2= static_cast<CLbtGeoCell*> (base);

    }    

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

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

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

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

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

    /*base=Hybridareaarray2[2];

    cell2=NULL;

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

    {

        cell2= static_cast<CLbtGeoCell*> (base);

    }    

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

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

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

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

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

    CleanupStack::PopAndDestroy( Hybridarea ); 

    return KErrNone;    

    }

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

// CTestHybridTriggers::TC_TestNewL3L

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

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

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

//

TInt CTestHybridTriggers::TC_TestNewL3L( CStifItemParser& aItem )

    {

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

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

    TUint Locationareacode1 = 100;

    TUint CellId1 = 100;

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

                                                        Networkcountrycode1,

                                                        Networkidentitycode1,

                                                        Locationareacode1,

                                                        CellId1

                                                            );

    TCoordinate coordinate(62.5285,23.9385);

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

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

    Hybridareaarray1.Append(Cellarea1);

    Hybridareaarray1.Append(circlearea);

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

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

    //Push to cleanup stack

    CleanupStack::PushL( Hybridarea );

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray2;

    Hybridareaarray2 = Hybridarea->HybridArea();

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

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

    CLbtGeoAreaBase* base=Hybridareaarray2[0];

    CLbtGeoCell* cell2=NULL;

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

    {

        cell2= static_cast<CLbtGeoCell*> (base);

    }    

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

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

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

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

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

    base=Hybridareaarray2[1];

    CLbtGeoCircle* circle2 =NULL;

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

    {

    circle2= static_cast<CLbtGeoCircle*> (base);

    }    

    TCoordinate center2 = circle2->Center();

    TReal32 distance;

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

    if(distance!=0)

    {

        return KErrGeneral;

    }

    TReal radius = circle2->Radius();

    if(radius != 1000)

    {

        return KErrGeneral;

    }

    CleanupStack::PopAndDestroy( Hybridarea ); 

    return KErrNone;    

    }

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

// CTestHybridTriggers::TC_TestNewL4L

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

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

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

//

TInt CTestHybridTriggers::TC_TestNewL4L( CStifItemParser& aItem )

    {

    RPointerArray<CLbtGeoAreaBase> Hybridareaarray1 ;

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

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

    return KErrNone;    

    }