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:  ?Description

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES] - do not remove

    21 #include <e32math.h>

    22 #include "RoapTest.h"

    23 #include "RoapTrigger.h"

    24 #include "RoapEng.h"

    25 #include "RoapEngBase.h"

    26 

    27 // EXTERNAL DATA STRUCTURES

    28 //extern  ?external_data;

    29 

    30 // EXTERNAL FUNCTION PROTOTYPES  

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

    32 

    33 // CONSTANTS

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

    35 

    36 // MACROS

    37 //#define ?macro ?macro_def

    38 

    39 // LOCAL CONSTANTS AND MACROS

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

    41 //#define ?macro_name ?macro_def

    42 _LIT( KRunning, "Running" );

    43 _LIT( KFinished, "Finished" );

    44 _LIT( KPassed, "Passed" );

    45 

    46 // MODULE DATA STRUCTURES

    47 //enum ?declaration

    48 //typedef ?declaration

    49 

    50 // LOCAL FUNCTION PROTOTYPES

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

    52 

    53 // FORWARD DECLARATIONS

    54 //class ?FORWARD_CLASSNAME;

    55 

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

    57 

    58 // -----------------------------------------------------------------------------

    59 // ?function_name ?description.

    60 // ?description

    61 // Returns: ?value_1: ?description

    62 //          ?value_n: ?description_line1

    63 //                    ?description_line2

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

    65 //

    66 /*

    67 ?type ?function_name(

    68     ?arg_type arg,  // ?description

    69     ?arg_type arg)  // ?description

    70     {

    71 

    72     ?code  // ?comment

    73 

    74     // ?comment

    75     ?code

    76     }

    77 */

    78 

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

    80 

    81 // -----------------------------------------------------------------------------

    82 // CRoapTest::Case

    83 // Returns a test case by number.

    84 //

    85 // This function contains an array of all available test cases 

    86 // i.e pair of case name and test function. If case specified by parameter

    87 // aCaseNumber is found from array, then that item is returned.

    88 // 

    89 // The reason for this rather complicated function is to specify all the

    90 // test cases only in one place. It is not necessary to understand how

    91 // function pointers to class member functions works when adding new test

    92 // cases. See function body for instructions how to add new test case.

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

    94 //

    95 const TCaseInfo CRoapTest::Case ( 

    96     const TInt aCaseNumber ) const 

    97      {

    98 

    99     /**

   100     * To add new test cases, implement new test case function and add new 

   101     * line to KCases array specify the name of the case and the function 

   102     * doing the test case

   103     * In practice, do following

   104     * 1) Make copy of existing test case function and change its name

   105     *    and functionality. Note that the function must be added to 

   106     *    RoapTest.cpp file and to RoapTest.h 

   107     *    header file.

   108     *

   109     * 2) Add entry to following KCases array either by using:

   110     *

   111     * 2.1: FUNCENTRY or ENTRY macro

   112     * ENTRY macro takes two parameters: test case name and test case 

   113     * function name.

   114     *

   115     * FUNCENTRY macro takes only test case function name as a parameter and

   116     * uses that as a test case name and test case function name.

   117     *

   118     * Or

   119     *

   120     * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

   121     * only with OOM (Out-Of-Memory) testing!

   122     *

   123     * OOM_ENTRY macro takes five parameters: test case name, test case 

   124     * function name, TBool which specifies is method supposed to be run using

   125     * OOM conditions, TInt value for first heap memory allocation failure and 

   126     * TInt value for last heap memory allocation failure.

   127     * 

   128     * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

   129     * that as a test case name, TBool which specifies is method supposed to be

   130     * run using OOM conditions, TInt value for first heap memory allocation 

   131     * failure and TInt value for last heap memory allocation failure. 

   132     */ 

   133 

   134     static TCaseInfoInternal const KCases[] =

   135         {

   136         // [test cases entries] - do not remove

   137         

   138         // NOTE: When compiled to GCCE, there must be Classname::

   139         // declaration in front of the method name, e.g. 

   140         // CRoapTest::PrintTest. Otherwise the compiler

   141         // gives errors.

   142         

   143         ENTRY( "RoapTrigger::ConstructionDestructionTrigger", CRoapTest::ConstructionDestructionTriggerL ),

   144         ENTRY( "RoapTrigger::MessageAsXml", CRoapTest::MessageAsXmlL ),

   145         ENTRY( "RoapTrigger::ValidTrigger", CRoapTest::ValidTriggerL ),

   146         ENTRY( "RoapEng/RoapEngBase::ConstructionDestructionRoapEng", CRoapTest::ConstructionDestructionRoapEngL ),

   147         ENTRY( "RoapEngBase::SetTrigger", CRoapTest::SetTriggerL ),

   148         ENTRY( "RoapEngBase::Accept", CRoapTest::AcceptL ),

   149         ENTRY( "RoapEngBase::Reject", CRoapTest::RejectL ),

   150         ENTRY( "RoapEngBase::DoCleanup", CRoapTest::DoCleanupL ),

   151         ENTRY( "RoapEngBase::HandleRoReponse", CRoapTest::HandleRoReponseL ),

   152         ENTRY( "RoapEngBase::Trigger", CRoapTest::TriggerL )

   153                 

   154         // Example how to use OOM functionality

   155         //OOM_ENTRY( "Loop test with OOM", CRoapTest::LoopTest, ETrue, 2, 3),

   156         //OOM_FUNCENTRY( CRoapTest::PrintTest, ETrue, 1, 3 ),

   157         };

   158 

   159     // Verify that case number is valid

   160     if( (TUint) aCaseNumber >= sizeof( KCases ) / 

   161                                sizeof( TCaseInfoInternal ) )

   162         {

   163         // Invalid case, construct empty object

   164         TCaseInfo null( (const TText*) L"" );

   165         null.iMethod = NULL;

   166         null.iIsOOMTest = EFalse;

   167         null.iFirstMemoryAllocation = 0;

   168         null.iLastMemoryAllocation = 0;

   169         return null;

   170         } 

   171 

   172     // Construct TCaseInfo object and return it

   173     TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

   174     tmp.iMethod = KCases[ aCaseNumber ].iMethod;

   175     tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

   176     tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

   177     tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

   178     return tmp;

   179 

   180     }

   181 

   182 

   183 // from CRoapTrigger

   184 

   185 // -----------------------------------------------------------------------------

   186 // CRoapTest::

   187 // -----------------------------------------------------------------------------

   188 // 

   189 TInt CRoapTest::ConstructionDestructionTriggerL( TTestResult& aResult )

   190     {

   191     _LIT( KData, "CRoapTest::ConstructionDestructionTriggerL" );

   192     TestModuleIf().Printf( 0, KRunning, KData );

   193     iLog->Log( KData );

   194    

   195     // Test Cases

   196     // -----------------------------------------------------------------------------

   197     // -----------------------------------------------------------------------------

   198 

   199     _LIT( KTestCase1, "TestCase1: Testing NewL:s of RoapTrigger: Expecting creation to succeed" );

   200     iLog->Log( KTestCase1 );

   201     

   202     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   203 

   204     TL( trigger );

   205     delete trigger;

   206     

   207     

   208     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   209     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   210     _LIT8(KDomainIdDummy,"DomainId001");

   211     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   212     RPointerArray<HBufC8> listRo;

   213     RPointerArray<HBufC8> listCid;

   214     

   215     trigger = Roap::CRoapTrigger::NewL( type,

   216                                         KRiIdDummy,

   217                                         KDomainIdDummy,

   218                                         KRoapUrl,

   219                                         listRo,

   220                                         listCid);

   221 

   222     TL( trigger );

   223     delete trigger;

   224     

   225     //Passed

   226     iLog->Log( KPassed );

   227 

   228     // -----------------------------------------------------------------------------

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

   230     // Test Cases End 

   231     

   232     TestModuleIf().Printf( 0, KFinished, KData);

   233 

   234     //Test case passed

   235     _LIT( KDescription, "CRoapTest::ConstructionDestructionTriggerL passed" );

   236     iLog->Log( KDescription );

   237     aResult.SetResult( KErrNone, KDescription );

   238 

   239     //Case was executed

   240     return KErrNone;

   241     };

   242                                   

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

   244 // CRoapTest::

   245 // -----------------------------------------------------------------------------

   246 //                                 

   247 TInt CRoapTest::MessageAsXmlL( TTestResult& aResult )

   248     {

   249     _LIT( KData, "CRoapTest::MessageAsXmlL" );

   250     TestModuleIf().Printf( 0, KRunning, KData );

   251     iLog->Log( KData );

   252    

   253     // Test Cases

   254     // -----------------------------------------------------------------------------

   255     // -----------------------------------------------------------------------------

   256 

   257     _LIT( KTestCase2, "TestCase2: Testing MessageAsXmlL of RoapTrigger: Expecting an output buffer" );

   258     iLog->Log( KTestCase2 );

   259     

   260     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   261     HBufC8* xmlData = NULL;

   262     

   263     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   264     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   265     _LIT8(KDomainIdDummy,"DomainId001");

   266     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   267     RPointerArray<HBufC8> listRo;

   268     RPointerArray<HBufC8> listCid;

   269     

   270     trigger = Roap::CRoapTrigger::NewL( type,

   271                                         KRiIdDummy,

   272                                         KDomainIdDummy,

   273                                         KRoapUrl,

   274                                         listRo,

   275                                         listCid);

   276                                                                             

   277     TL( trigger );

   278     CleanupStack::PushL(trigger);

   279     

   280     xmlData = trigger->MessageAsXmlL();

   281     

   282     delete xmlData;

   283     CleanupStack::PopAndDestroy();

   284     

   285     //Passed

   286     iLog->Log( KPassed );

   287 

   288     // -----------------------------------------------------------------------------

   289     // -----------------------------------------------------------------------------

   290     // Test Cases End 

   291     

   292     TestModuleIf().Printf( 0, KFinished, KData);

   293 

   294     //Test case passed

   295     _LIT( KDescription, "CRoapTest::MessageAsXmlL passed" );

   296     iLog->Log( KDescription );

   297     aResult.SetResult( KErrNone, KDescription );

   298 

   299     //Case was executed

   300     return KErrNone;    

   301     };

   302         

   303         

   304 // -----------------------------------------------------------------------------

   305 // CRoapTest::

   306 // -----------------------------------------------------------------------------

   307 //        

   308 TInt CRoapTest::ValidTriggerL( TTestResult& aResult )

   309     {

   310     _LIT( KData, "CRoapTest::MessageAsXmlL" );

   311     TestModuleIf().Printf( 0, KRunning, KData );

   312     iLog->Log( KData );

   313    

   314     // Test Cases

   315     // -----------------------------------------------------------------------------

   316     // -----------------------------------------------------------------------------

   317 

   318     _LIT( KTestCase3, "TestCase3: Testing ValidTrigger of RoapTrigger: Expecting an output buffer" );

   319     iLog->Log( KTestCase3 );

   320     

   321     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   322     

   323     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   324     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   325     _LIT8(KDomainIdDummy,"DomainId001");

   326     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   327     RPointerArray<HBufC8> listRo;

   328     RPointerArray<HBufC8> listCid;

   329     

   330     trigger = Roap::CRoapTrigger::NewL( type,

   331                                         KRiIdDummy,

   332                                         KDomainIdDummy,

   333                                         KRoapUrl,

   334                                         listRo,

   335                                         listCid);

   336                                                                             

   337     TL( trigger );

   338     

   339     TL( trigger->ValidTrigger() );

   340     

   341     delete trigger;

   342     

   343     //Passed

   344     iLog->Log( KPassed );

   345 

   346     // -----------------------------------------------------------------------------

   347     // -----------------------------------------------------------------------------

   348     // Test Cases End 

   349     

   350     TestModuleIf().Printf( 0, KFinished, KData);

   351 

   352     //Test case passed

   353     _LIT( KDescription, "CRoapTest::ValidTriggerL passed" );

   354     iLog->Log( KDescription );

   355     aResult.SetResult( KErrNone, KDescription );

   356 

   357     //Case was executed

   358     return KErrNone;    

   359     };

   360 

   361 // from CRoapEng

   362 

   363 // -----------------------------------------------------------------------------

   364 // CRoapTest::

   365 // -----------------------------------------------------------------------------

   366 // 

   367 TInt CRoapTest::ConstructionDestructionRoapEngL( TTestResult& aResult )

   368     {

   369     _LIT( KData, "CRoapTest::ConstructionDestructionRoapEngL" );

   370     TestModuleIf().Printf( 0, KRunning, KData );

   371     iLog->Log( KData );

   372    

   373     // Test Cases

   374     // -----------------------------------------------------------------------------

   375     // -----------------------------------------------------------------------------

   376 

   377     _LIT( KTestCase4, "TestCase4: Testing NewL:s of CRoapEng and CRoapEngBase: Expecting a working RoapEng" );

   378     iLog->Log( KTestCase4 );

   379     

   380     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   381     

   382     TL( roapEng );

   383     

   384     delete roapEng;

   385     

   386     //Passed

   387     iLog->Log( KPassed );

   388 

   389     // -----------------------------------------------------------------------------

   390     // -----------------------------------------------------------------------------

   391     // Test Cases End 

   392     

   393     TestModuleIf().Printf( 0, KFinished, KData);

   394 

   395     //Test case passed

   396     _LIT( KDescription, "CRoapTest::ConstructionDestructionRoapEngL passed" );

   397     iLog->Log( KDescription );

   398     aResult.SetResult( KErrNone, KDescription );

   399 

   400     //Case was executed

   401     return KErrNone;

   402     };

   403         

   404 

   405 // from CRoapEngBase

   406     

   407 // -----------------------------------------------------------------------------

   408 // CRoapTest::

   409 // -----------------------------------------------------------------------------

   410 // 

   411 TInt CRoapTest::SetTriggerL( TTestResult& aResult )

   412     {

   413     _LIT( KData, "CRoapTest::SetTriggerL" );

   414     TestModuleIf().Printf( 0, KRunning, KData );

   415     iLog->Log( KData );

   416    

   417     // Test Cases

   418     // -----------------------------------------------------------------------------

   419     // -----------------------------------------------------------------------------

   420 

   421     _LIT( KTestCase5, "TestCase5: Testing SetTriggerL of RoapEngBase" );

   422     iLog->Log( KTestCase5 );

   423     

   424     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   425     HBufC8* xmlData = NULL;

   426     

   427     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   428     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   429     _LIT8(KDomainIdDummy,"DomainId001");

   430     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   431     RPointerArray<HBufC8> listRo;

   432     RPointerArray<HBufC8> listCid;

   433     Roap::TRiContextStatus riStatus;

   434     Roap::TDomainOperation domainOperation;    

   435     

   436     trigger = Roap::CRoapTrigger::NewL( type,

   437                                         KRiIdDummy,

   438                                         KDomainIdDummy,

   439                                         KRoapUrl,

   440                                         listRo,

   441                                         listCid);

   442                                                                             

   443     TL( trigger );

   444     CleanupStack::PushL(trigger);

   445     

   446     xmlData = trigger->MessageAsXmlL();

   447     CleanupStack::PushL( xmlData );

   448     

   449     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   450     CleanupStack::PushL( roapEng );

   451     

   452     // Actual Test:

   453     roapEng->SetTriggerL( *xmlData,

   454                           NULL,

   455                           type,

   456                           riStatus,

   457                           domainOperation,

   458                           listCid );

   459     

   460     

   461     CleanupStack::PopAndDestroy(roapEng);

   462     CleanupStack::PopAndDestroy(xmlData);

   463     CleanupStack::PopAndDestroy(trigger);

   464             

   465     //Passed

   466     iLog->Log( KPassed );

   467 

   468     // -----------------------------------------------------------------------------

   469     // -----------------------------------------------------------------------------

   470     // Test Cases End 

   471     

   472     TestModuleIf().Printf( 0, KFinished, KData);

   473 

   474     //Test case passed

   475     _LIT( KDescription, "CRoapTest::SetTriggerL passed" );

   476     iLog->Log( KDescription );

   477     aResult.SetResult( KErrNone, KDescription );

   478 

   479     //Case was executed

   480     return KErrNone;     

   481     };

   482 

   483 // -----------------------------------------------------------------------------

   484 // CRoapTest::

   485 // -----------------------------------------------------------------------------

   486 //  

   487 TInt CRoapTest::AcceptL( TTestResult& aResult )

   488     {

   489     _LIT( KData, "CRoapTest::AcceptL" );

   490     TestModuleIf().Printf( 0, KRunning, KData );

   491     iLog->Log( KData );

   492    

   493     // Test Cases

   494     // -----------------------------------------------------------------------------

   495     // -----------------------------------------------------------------------------

   496 

   497     _LIT( KTestCase6, "TestCase6: Testing AcceptL of CRoapEngBase" );

   498     iLog->Log( KTestCase6 );

   499     

   500     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   501     TRequestStatus statusData;

   502     TRequestStatus* status = &statusData;

   503     

   504     TL( roapEng );

   505     

   506     // Ignore error for now, method got called ok:

   507     TRAPD( err, roapEng->AcceptL( NULL, status ));

   508     

   509     delete roapEng;

   510     

   511     //Passed

   512     iLog->Log( KPassed );

   513 

   514     // -----------------------------------------------------------------------------

   515     // -----------------------------------------------------------------------------

   516     // Test Cases End 

   517     

   518     TestModuleIf().Printf( 0, KFinished, KData);

   519 

   520     //Test case passed

   521     _LIT( KDescription, "CRoapTest::AcceptL passed" );

   522     iLog->Log( KDescription );

   523     aResult.SetResult( KErrNone, KDescription );

   524 

   525     //Case was executed

   526     return KErrNone;    

   527     };

   528         

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

   530 // CRoapTest::

   531 // -----------------------------------------------------------------------------

   532 // 

   533 TInt CRoapTest::RejectL( TTestResult& aResult )

   534     {

   535     _LIT( KData, "CRoapTest::RejectL" );

   536     TestModuleIf().Printf( 0, KRunning, KData );

   537     iLog->Log( KData );

   538    

   539     // Test Cases

   540     // -----------------------------------------------------------------------------

   541     // -----------------------------------------------------------------------------

   542 

   543     _LIT( KTestCase7, "TestCase7: Testing RejectL of CRoapEngBase" );

   544     iLog->Log( KTestCase7 );

   545     

   546     

   547     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   548     HBufC8* xmlData = NULL;

   549     

   550     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   551     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   552     _LIT8(KDomainIdDummy,"DomainId001");

   553     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   554     RPointerArray<HBufC8> listRo;

   555     RPointerArray<HBufC8> listCid;

   556     Roap::TRiContextStatus riStatus;

   557     Roap::TDomainOperation domainOperation;    

   558     

   559     trigger = Roap::CRoapTrigger::NewL( type,

   560                                         KRiIdDummy,

   561                                         KDomainIdDummy,

   562                                         KRoapUrl,

   563                                         listRo,

   564                                         listCid);

   565                                                                             

   566     TL( trigger );

   567     CleanupStack::PushL(trigger);

   568     

   569     xmlData = trigger->MessageAsXmlL();

   570     CleanupStack::PushL( xmlData );

   571     

   572     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   573     CleanupStack::PushL( roapEng );

   574     

   575 

   576     roapEng->SetTriggerL( *xmlData,

   577                           NULL,

   578                           type,

   579                           riStatus,

   580                           domainOperation,

   581                           listCid );

   582     

   583     // Actual Test:    

   584     roapEng->Reject();

   585     

   586     CleanupStack::PopAndDestroy(roapEng);

   587     CleanupStack::PopAndDestroy(xmlData);

   588     CleanupStack::PopAndDestroy(trigger);

   589     

   590     //Passed

   591     iLog->Log( KPassed );

   592     

   593     // -----------------------------------------------------------------------------

   594     // -----------------------------------------------------------------------------

   595     // Test Cases End 

   596     

   597     TestModuleIf().Printf( 0, KFinished, KData);

   598 

   599     //Test case passed

   600     _LIT( KDescription, "CRoapTest::RejectL passed" );

   601     iLog->Log( KDescription );

   602     aResult.SetResult( KErrNone, KDescription );

   603 

   604     //Case was executed

   605     return KErrNone;    

   606     };

   607         

   608 // -----------------------------------------------------------------------------

   609 // CRoapTest::

   610 // -----------------------------------------------------------------------------

   611 // 

   612 TInt CRoapTest::DoCleanupL( TTestResult& aResult )

   613     {

   614     _LIT( KData, "CRoapTest::DoCleanupL" );

   615     TestModuleIf().Printf( 0, KRunning, KData );

   616     iLog->Log( KData );

   617    

   618     // Test Cases

   619     // -----------------------------------------------------------------------------

   620     // -----------------------------------------------------------------------------

   621 

   622     _LIT( KTestCase8, "TestCase8: Testing DoCleanupL of CRoapEngBase" );

   623     iLog->Log( KTestCase8 );

   624     

   625     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   626     HBufC8* xmlData = NULL;

   627     

   628     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   629     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   630     _LIT8(KDomainIdDummy,"DomainId001");

   631     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   632     RPointerArray<HBufC8> listRo;

   633     RPointerArray<HBufC8> listCid;

   634     Roap::TRiContextStatus riStatus;

   635     Roap::TDomainOperation domainOperation;    

   636     

   637     trigger = Roap::CRoapTrigger::NewL( type,

   638                                         KRiIdDummy,

   639                                         KDomainIdDummy,

   640                                         KRoapUrl,

   641                                         listRo,

   642                                         listCid);

   643                                                                             

   644     TL( trigger );

   645     CleanupStack::PushL(trigger);

   646     

   647     xmlData = trigger->MessageAsXmlL();

   648     CleanupStack::PushL( xmlData );

   649     

   650     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   651     CleanupStack::PushL( roapEng );

   652     

   653 

   654     roapEng->SetTriggerL( *xmlData,

   655                           NULL,

   656                           type,

   657                           riStatus,

   658                           domainOperation,

   659                           listCid );

   660     

   661     // Actual Test:    

   662     roapEng->DoCleanup();

   663     

   664     CleanupStack::PopAndDestroy(roapEng);

   665     CleanupStack::PopAndDestroy(xmlData);

   666     CleanupStack::PopAndDestroy(trigger);

   667     

   668     //Passed

   669     iLog->Log( KPassed );

   670 

   671     // -----------------------------------------------------------------------------

   672     // -----------------------------------------------------------------------------

   673     // Test Cases End 

   674     

   675     TestModuleIf().Printf( 0, KFinished, KData);

   676 

   677     //Test case passed

   678     _LIT( KDescription, "CRoapTest::DoCleanupL passed" );

   679     iLog->Log( KDescription );

   680     aResult.SetResult( KErrNone, KDescription );

   681 

   682     //Case was executed

   683     return KErrNone;     

   684     };   

   685         

   686 // -----------------------------------------------------------------------------

   687 // CRoapTest::

   688 // -----------------------------------------------------------------------------

   689 // 

   690 TInt CRoapTest::HandleRoReponseL( TTestResult& aResult )

   691     {

   692     _LIT( KData, "CRoapTest::HandleRoReponseL" );

   693     TestModuleIf().Printf( 0, KRunning, KData );

   694     iLog->Log( KData );

   695    

   696     // Test Cases

   697     // -----------------------------------------------------------------------------

   698     // -----------------------------------------------------------------------------

   699 

   700     _LIT( KTestCase9, "TestCase9: Testing HandleRoReponseL of CRoapEngBase" );

   701     iLog->Log( KTestCase9 );

   702     

   703     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   704     CleanupStack::PushL( roapEng );

   705     

   706     RPointerArray<CDRMRights> rights;

   707     

   708     TRAPD(err, roapEng->HandleRoReponseL( KNullDesC8, rights ));

   709     

   710     CleanupStack::PopAndDestroy(roapEng);

   711     

   712     //Passed

   713     iLog->Log( KPassed );

   714 

   715     // -----------------------------------------------------------------------------

   716     // -----------------------------------------------------------------------------

   717     // Test Cases End 

   718     

   719     TestModuleIf().Printf( 0, KFinished, KData);

   720 

   721     //Test case passed

   722     _LIT( KDescription, "CRoapTest::HandleRoReponseL passed" );

   723     iLog->Log( KDescription );

   724     aResult.SetResult( KErrNone, KDescription );

   725 

   726     //Case was executed

   727     return KErrNone;    

   728     }; 

   729         

   730 

   731 // -----------------------------------------------------------------------------

   732 // CRoapTest::

   733 // -----------------------------------------------------------------------------

   734 // 

   735 TInt CRoapTest::TriggerL( TTestResult& aResult )

   736     {

   737     _LIT( KData, "CRoapTest::TriggerL" );

   738     TestModuleIf().Printf( 0, KRunning, KData );

   739     iLog->Log( KData );

   740    

   741     // Test Cases

   742     // -----------------------------------------------------------------------------

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

   744 

   745     _LIT( KTestCase10, "TestCase10: Testing Trigger of CRoapEngBase" );

   746     iLog->Log( KTestCase10 );

   747     

   748     Roap::CRoapTrigger* trigger = Roap::CRoapTrigger::NewL();

   749     HBufC8* xmlData = NULL;

   750     

   751     Roap::TTriggerType type = Roap::ERegistrationTrigger;

   752     _LIT8(KRiIdDummy,"abcdefghijabcdefghij");

   753     _LIT8(KDomainIdDummy,"DomainId001");

   754     _LIT8(KRoapUrl,"http://www.localhost.localdomain:80");

   755     RPointerArray<HBufC8> listRo;

   756     RPointerArray<HBufC8> listCid;

   757     Roap::TRiContextStatus riStatus;

   758     Roap::TDomainOperation domainOperation;    

   759     

   760     trigger = Roap::CRoapTrigger::NewL( type,

   761                                         KRiIdDummy,

   762                                         KDomainIdDummy,

   763                                         KRoapUrl,

   764                                         listRo,

   765                                         listCid);

   766                                                                             

   767     TL( trigger );

   768     CleanupStack::PushL(trigger);

   769     

   770     xmlData = trigger->MessageAsXmlL();

   771     CleanupStack::PushL( xmlData );

   772     

   773     Roap::CRoapEng* roapEng = Roap::CRoapEng::NewL();

   774     CleanupStack::PushL( roapEng );

   775     

   776 

   777     roapEng->SetTriggerL( *xmlData,

   778                           NULL,

   779                           type,

   780                           riStatus,

   781                           domainOperation,

   782                           listCid );

   783     

   784     // Actual Test:    

   785     roapEng->Trigger();

   786     

   787     CleanupStack::PopAndDestroy(roapEng);

   788     CleanupStack::PopAndDestroy(xmlData);

   789     CleanupStack::PopAndDestroy(trigger);

   790     

   791     //Passed

   792     iLog->Log( KPassed );

   793 

   794     // -----------------------------------------------------------------------------

   795     // -----------------------------------------------------------------------------

   796     // Test Cases End 

   797     

   798     TestModuleIf().Printf( 0, KFinished, KData);

   799 

   800     //Test case passed

   801     _LIT( KDescription, "CRoapTest::TriggerL passed" );

   802     iLog->Log( KDescription );

   803     aResult.SetResult( KErrNone, KDescription );

   804 

   805     //Case was executed

   806     return KErrNone;         

   807     };

   808 

   809 

   810 

   811 

   812 // -----------------------------------------------------------------------------

   813 // ?classname::?member_function

   814 // ?implementation_description

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

   816 // -----------------------------------------------------------------------------

   817 //

   818 /*

   819 ?type ?classname::?member_function(

   820    ?arg_type arg,

   821    ?arg_type arg )

   822    {

   823 

   824    ?code

   825 

   826    }

   827 */

   828 

   829 // ========================== OTHER EXPORTED FUNCTIONS =========================

   830 

   831 // -----------------------------------------------------------------------------

   832 // ?function_name implements...

   833 // ?implementation_description.

   834 // Returns: ?value_1: ?description

   835 //          ?value_n: ?description

   836 //                    ?description

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

   838 //

   839 /*

   840 ?type  ?function_name(

   841     ?arg_type arg,  // ?description

   842     ?arg_type arg )  // ?description

   843     {

   844 

   845     ?code

   846 

   847     }

   848 */

   849 //  [End of File] - do not remove