1 /*

     2 * Copyright (c) 2006 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: XIMP Framework Test Code 

    15 *

    16 */

    17 

    18 

    19 #include <ecom/ecom.h>

    20 #include <badesca.h>

    21 #include <e32property.h>

    22 #include <e32base.h>

    23 #include <e32std.h>

    24 

    25 #include "eunittools.h"

    26 

    27 

    28 #include <platform/digia/eunit/eunitmacros.h>

    29 #include <platform/digia/eunit/teunitassertioninfo.h>

    30 

    31 #include "t_utils.h"

    32 

    33 

    34 

    35 #include <ximpbase.h>

    36 #include <presenceinfo.h>

    37 

    38 #include "ximpeventcodec.h"

    39 #include "ownpresenceeventimp.h"

    40 #include "prfwtestfiletool.h"

    41 #include "ximppanics.h"

    42 

    43 #include "prfwtestrobustnesstools.h"

    44 

    45 #include "ximpobjectfactoryimp.h"

    46 #include "ximpobjectcollection.h"

    47 #include "ximprestrictedobjectcollection.h"

    48 #include "ximpidentityimp.h"

    49 #include "ximpstatusimp.h"

    50 #include "ximprequestidbuilder.h"

    51 

    52 

    53 

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

    55 

    56 // CONSTRUCTION

    57 T_Utils* T_Utils::NewL()

    58     {

    59     T_Utils* self = new( ELeave ) T_Utils;

    60     CleanupStack::PushL( self );

    61     self->ConstructL();

    62     CleanupStack::Pop( self );

    63 

    64     return self;

    65     }

    66 

    67 

    68 T_Utils::~T_Utils()

    69     {

    70     }

    71 

    72 

    73 void T_Utils::ConstructL()

    74     {

    75     CEUnitTestSuiteClass::ConstructL();

    76     }

    77 

    78 

    79 T_Utils::T_Utils()

    80     {

    81     }

    82 

    83 // ===========================================================================

    84 // TEST CASE SETUP & TEARDOWN METHODS

    85 // ===========================================================================

    86 //

    87 

    88 void T_Utils::Setup_L()

    89     {

    90     }

    91 

    92 void T_Utils::Teardown()

    93     {

    94     }

    95 

    96 // ===========================================================================

    97 // TEST CASE

    98 // ===========================================================================

    99 void T_Utils::T_FileToolTest_L()

   100     {

   101     // TODO add more brains to the test

   102     EUNIT_PRINT( _L("FileTool test.") );

   103 

   104     /*

   105     CXIMPTestFileTool* tool = CXIMPTestFileTool::NewL();

   106     CleanupStack::PushL( tool );

   107     tool->CleanL( 0 );

   108     tool->PrepareL( 0 );

   109     TInt files = tool->NumObjectsL( 0 );

   110 

   111     EUNIT_ASSERT_DESC( files == 0, "Non-zero count of files, Clean or Prepare did not work" );

   112 

   113     // make a proper object and store it.

   114     MPresenceInfo::TPresenceInfoStatus status;

   115     status = MPresenceInfo::EDataSubscriptionPending;

   116     COwnPresenceEventImp* event = COwnPresenceEventImp::NewLC( status );

   117 

   118     CBufFlat* buf = CBufFlat::NewL( 50 );

   119     CleanupStack::PushL( buf );

   120     TInt32 eventType = 0;

   121     XIMPEventCodec::PackL( *event, eventType, buf );

   122     HBufC8* extObj = buf->Ptr( 0 ).AllocLC();

   123 

   124     // create more objects

   125     tool->StoreL( 0, *extObj );

   126     tool->StoreL( 0, *extObj );

   127     tool->StoreL( 0, *extObj );

   128     tool->StoreL( 0, *extObj );

   129     tool->StoreL( 0, *extObj );

   130 

   131     files = tool->NumObjectsL( 0 );

   132     EUNIT_ASSERT_DESC( files == 5, "Bad count of files" );

   133 

   134     COwnPresenceEventImp* object = static_cast<COwnPresenceEventImp*>( tool->RestoreLC( 0, 2 ) );

   135     EUNIT_ASSERT_DESC( status == object->Status(), "Wrong status from restored object." );

   136 

   137     CleanupStack::PopAndDestroy( 4, event ); // object, extObj, buf, event

   138 

   139     CleanupStack::PopAndDestroy( tool );

   140     */

   141     }

   142 

   143 // ===========================================================================

   144 // TEST CASE

   145 // ===========================================================================

   146 void T_Utils::T_KillServers_L()

   147     {

   148     EUNIT_PRINT( _L("Utility to kill the servers. Always succeeds.") );

   149 

   150     PrfwTestRobustness::DoPreCleaning();

   151     }

   152 

   153 _LIT8( KTestObjectName,    "John Doe" );     // regular

   154 _LIT8( KTestObjectName2,   "Jane Doe" );     // regular

   155 _LIT8( KTestObjectNameWC,  "Jo* Doe" );      // wildcards

   156 _LIT8( KTestObjectNameWC2, "Ja* Doe" );      // wildcards

   157 

   158 _LIT( KIdentity1, "Identity 1" );

   159 _LIT( KIdentity2, "Identity 2" );

   160 

   161 // ===========================================================================

   162 // TEST CASE

   163 // ===========================================================================

   164 void T_Utils::T_ObjectCollection_Unnamed_L()

   165     {

   166     EUNIT_PRINT( _L("Object collection unnamed tests.") );

   167 

   168     CXIMPObjectFactoryImp* factory = CXIMPObjectFactoryImp::NewL();

   169     CleanupStack::PushL( factory );

   170 

   171     MXIMPObjectCollection* collection = factory->NewObjectCollectionLC();

   172 

   173     // LookupByType should not find anything

   174     const MXIMPBase* obj = NULL;

   175     collection->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   176     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an object" );

   177 

   178     // LookupByTypeAndName should not find anything

   179     collection->LookupByTypeAndName( obj, MXIMPIdentity::KInterfaceId, KTestObjectName );

   180     EUNIT_ASSERT_DESC( obj == NULL, "LookupByTypeAndName found an object" );

   181 

   182     collection->LookupByTypeAndName( obj, MXIMPIdentity::KInterfaceId, KTestObjectNameWC );

   183     EUNIT_ASSERT_DESC( obj == NULL, "LookupByTypeAndName with wildcard found an object" );

   184 

   185     // add some

   186     MXIMPIdentity* identity2 = factory->NewIdentityLC();

   187     identity2->SetIdentityL( KIdentity2 );

   188 

   189     MXIMPStatus* status = factory->NewStatusLC();

   190     status->SetResultCode( KErrArgument );

   191 

   192     MXIMPIdentity* identity1 = factory->NewIdentityLC();

   193     identity1->SetIdentityL( KIdentity1 );

   194 

   195     collection->AddObjectL( identity1 );

   196     CleanupStack::Pop(); // identity1

   197 

   198     collection->AddObjectL( status );

   199     CleanupStack::Pop(); // status

   200 

   201     collection->AddObjectL( identity2 );

   202     CleanupStack::Pop(); // identity2

   203 

   204     // get and verify the status

   205     MXIMPBase* getObj = NULL;

   206     collection->GetByType( getObj, MXIMPStatus::KInterfaceId );

   207     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   208 

   209     MXIMPStatus* gotStatus = ( MXIMPStatus* ) getObj->GetInterface( MXIMPStatus::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   210     CleanupDeletePushL( gotStatus );

   211     EUNIT_ASSERT_DESC( gotStatus->ResultCode() == KErrArgument, "Status got corrupted" );

   212     CleanupStack::PopAndDestroy(); // gotStatus

   213 

   214     // check that status can't be found anymore

   215     obj = NULL;

   216     collection->LookupByType( obj, MXIMPStatus::KInterfaceId );

   217     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an object" );

   218 

   219     collection->LookupByTypeAndName( obj, MXIMPStatus::KInterfaceId, KTestObjectName );

   220     EUNIT_ASSERT_DESC( obj == NULL, "LookupByTypeAndName found an object" );

   221 

   222     collection->LookupByTypeAndName( obj, MXIMPStatus::KInterfaceId, KTestObjectNameWC );

   223     EUNIT_ASSERT_DESC( obj == NULL, "LookupByTypeAndName with wildcard found an object" );

   224 

   225     // get and verify the two identities

   226     // first identity

   227     getObj = NULL;

   228     collection->GetByType( getObj, MXIMPIdentity::KInterfaceId );

   229     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   230 

   231     MXIMPIdentity* gotIdentity = ( MXIMPIdentity* ) getObj->GetInterface( MXIMPIdentity::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   232     CleanupDeletePushL( gotIdentity );

   233     EUNIT_ASSERT_DESC( 0 == gotIdentity->Identity().Compare( KIdentity1 ), "Wrong identity object found" );

   234     CleanupStack::PopAndDestroy(); // gotIdentity

   235 

   236     // second identity

   237     getObj = NULL;

   238     collection->GetByType( getObj, MXIMPIdentity::KInterfaceId );

   239     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   240 

   241     gotIdentity = ( MXIMPIdentity* ) getObj->GetInterface( MXIMPIdentity::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   242     CleanupDeletePushL( gotIdentity );

   243     EUNIT_ASSERT_DESC( 0 == gotIdentity->Identity().Compare( KIdentity2 ), "Wrong identity object found" );

   244     CleanupStack::PopAndDestroy(); // gotIdentity

   245 

   246     // now there should not be anything anymore

   247     obj = NULL;

   248     collection->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   249     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an object" );

   250 

   251     CleanupStack::PopAndDestroy(); // collection

   252     CleanupStack::PopAndDestroy( factory );

   253     }

   254 

   255 // ===========================================================================

   256 // TEST CASE

   257 // ===========================================================================

   258 void T_Utils::T_ObjectCollection_Named_L()

   259     {

   260     EUNIT_PRINT( _L("Object collection named tests.") );

   261 

   262     CXIMPObjectFactoryImp* factory = CXIMPObjectFactoryImp::NewL();

   263     CleanupStack::PushL( factory );

   264 

   265     MXIMPObjectCollection* collection = factory->NewObjectCollectionLC();

   266 

   267     // LookupByType should not find anything

   268     const MXIMPBase* obj = NULL;

   269     collection->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   270     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an object" );

   271 

   272     // LookupByTypeAndName should not find anything

   273     collection->LookupByTypeAndName( obj, MXIMPIdentity::KInterfaceId, KTestObjectName );

   274     EUNIT_ASSERT_DESC( obj == NULL, "LookupByTypeAndName found an object" );

   275 

   276     collection->LookupByTypeAndName( obj, MXIMPIdentity::KInterfaceId, KTestObjectNameWC );

   277     EUNIT_ASSERT_DESC( obj == NULL, "LookupByTypeAndName with wildcard found an object" );

   278 

   279     // add some

   280     MXIMPIdentity* identity2 = factory->NewIdentityLC();

   281     identity2->SetIdentityL( KIdentity2 );

   282     

   283     MXIMPStatus* status = factory->NewStatusLC();

   284     status->SetResultCode( KErrArgument );

   285 

   286     MXIMPIdentity* identity1 = factory->NewIdentityLC();

   287     identity1->SetIdentityL( KIdentity1 );

   288     

   289     collection->AddObjectWithNameL( identity1, KTestObjectName );

   290     CleanupStack::Pop(); // identity1

   291 

   292     TRAPD( err, collection->AddObjectWithNameL( status, KTestObjectNameWC ) );

   293     EUNIT_ASSERT_DESC( err == KErrBadName, "Did not leave when given wildcards" );

   294     CleanupStack::PopAndDestroy(); // status

   295 

   296     collection->AddObjectWithNameL( identity2, KTestObjectName2 );

   297     CleanupStack::Pop(); // identity2

   298 

   299     // should not find the status object

   300     MXIMPBase* getObj = NULL;

   301     collection->GetByType( getObj, MXIMPStatus::KInterfaceId );

   302     EUNIT_ASSERT_DESC( getObj == NULL, "LookupByType found wrong object" );

   303 

   304     // get and verify the two identities

   305     // first identity

   306     getObj = NULL;

   307     collection->GetByTypeAndName( getObj, MXIMPIdentity::KInterfaceId, KTestObjectName );

   308     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   309 

   310     MXIMPIdentity* gotIdentity = ( MXIMPIdentity* ) getObj->GetInterface( MXIMPIdentity::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   311     CleanupDeletePushL( gotIdentity );

   312     EUNIT_ASSERT_DESC( 0 == gotIdentity->Identity().Compare( KIdentity1 ), "Wrong identity object found" );

   313     CleanupStack::PopAndDestroy(); // gotIdentity

   314 

   315     // second identity

   316     getObj = NULL;

   317     collection->GetByTypeAndName( getObj, MXIMPIdentity::KInterfaceId, KTestObjectNameWC2 );

   318     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   319 

   320     gotIdentity = ( MXIMPIdentity* ) getObj->GetInterface( MXIMPIdentity::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   321     CleanupDeletePushL( gotIdentity );

   322     EUNIT_ASSERT_DESC( 0 == gotIdentity->Identity().Compare( KIdentity2 ), "Wrong identity object found" );

   323     CleanupStack::PopAndDestroy(); // gotIdentity

   324 

   325     // now there should not be anything anymore

   326     obj = NULL;

   327     collection->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   328     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an object" );

   329 

   330     CleanupStack::PopAndDestroy(); // collection

   331     CleanupStack::PopAndDestroy( factory );

   332     }

   333 

   334 // ===========================================================================

   335 // TEST CASE

   336 // ===========================================================================

   337 void T_Utils::T_RestrictedObjectCollection_L()

   338     {

   339     EUNIT_PRINT( _L("Restricted object collection tests.") );

   340 

   341     CXIMPObjectFactoryImp* factory = CXIMPObjectFactoryImp::NewL();

   342     CleanupStack::PushL( factory );

   343 

   344     MXIMPRestrictedObjectCollection* resColl = factory->NewRestrictedObjectCollectionLC();

   345 

   346     // LookupByType should not find anything, empty collection

   347     const MXIMPBase* obj = NULL;

   348     resColl->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   349     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an object" );

   350 

   351     // add some

   352     MXIMPIdentity* identity2 = factory->NewIdentityLC();

   353     identity2->SetIdentityL( KIdentity2 );

   354     

   355     MXIMPStatus* status = factory->NewStatusLC();

   356     status->SetResultCode( KErrArgument );

   357 

   358     MXIMPIdentity* identity1 = factory->NewIdentityLC();

   359     identity1->SetIdentityL( KIdentity1 );

   360     

   361     resColl->AddOrReplaceTypeL( identity1 );

   362     CleanupStack::Pop(); // identity1

   363 

   364     resColl->AddOrReplaceTypeL( status );

   365     CleanupStack::Pop(); // identity1

   366 

   367     resColl->AddOrReplaceTypeL( identity2 );

   368     CleanupStack::Pop(); // identity2

   369 

   370     // there should only be {identity2, status} in the collection

   371     obj = NULL;

   372     resColl->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   373     EUNIT_ASSERT_DESC( obj != NULL, "LookupByType did not find an object" );

   374 

   375     obj = NULL;

   376     resColl->LookupByType( obj, MXIMPStatus::KInterfaceId );

   377     EUNIT_ASSERT_DESC( obj != NULL, "LookupByType did not find an object" );

   378 

   379     // get the objects and verify their contents

   380     

   381     // 1. identity

   382     MXIMPBase* getObj = NULL;

   383     resColl->GetByType( getObj, MXIMPIdentity::KInterfaceId );

   384     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   385 

   386     MXIMPIdentity* gotIdentity = ( MXIMPIdentity* ) getObj->GetInterface( MXIMPIdentity::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   387     CleanupDeletePushL( gotIdentity );

   388     EUNIT_ASSERT_DESC( 0 == gotIdentity->Identity().Compare( KIdentity2 ), "Second identity object did not replace the first one" );

   389     CleanupStack::PopAndDestroy(); // gotIdentity

   390 

   391     // 2. status

   392     getObj = NULL;

   393     resColl->GetByType( getObj, MXIMPStatus::KInterfaceId );

   394     EUNIT_ASSERT_DESC( getObj != NULL, "LookupByType did not find an object" );

   395 

   396     MXIMPStatus* gotStatus = ( MXIMPStatus* ) getObj->GetInterface( MXIMPStatus::KInterfaceId, MXIMPBase::EPanicIfUnknown );

   397     CleanupDeletePushL( gotStatus );

   398     EUNIT_ASSERT_DESC( KErrArgument == gotStatus->ResultCode(), "Status object was corrupted" );

   399     CleanupStack::PopAndDestroy(); // gotStatus

   400 

   401     // now there should not be anything anymore

   402     obj = NULL;

   403     resColl->LookupByType( obj, MXIMPIdentity::KInterfaceId );

   404     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found an identity object although it was removed" );

   405     

   406     obj = NULL;

   407     resColl->LookupByType( obj, MXIMPStatus::KInterfaceId );

   408     EUNIT_ASSERT_DESC( obj == NULL, "LookupByType found a status object although it was removed" );

   409 

   410     CleanupStack::PopAndDestroy(); // collection

   411     CleanupStack::PopAndDestroy( factory );

   412     }

   413 

   414 void T_Utils::T_DataSubscriptionState_L()

   415     {

   416     EUNIT_PRINT( _L("Data subscription state tests.") );

   417 

   418     CXIMPObjectFactoryImp* factory = CXIMPObjectFactoryImp::NewL();

   419     CleanupStack::PushL( factory );

   420 

   421     MXIMPDataSubscriptionState* dataState = factory->NewDataSubscriptionStateLC();

   422 

   423     EUNIT_ASSERT_DESC( dataState->DataState() == MXIMPDataSubscriptionState::EDataUnavailable, 

   424                       "Data was available." );

   425     EUNIT_ASSERT_DESC( dataState->SubscriptionState() == MXIMPDataSubscriptionState::ESubscriptionInactive, 

   426                       "Subscription was active." );

   427     

   428     dataState->SetDataStateL( MXIMPDataSubscriptionState::EDataAvailable );

   429     dataState->SetSubscriptionStateL( MXIMPDataSubscriptionState::ESubscriptionActive );

   430 

   431     EUNIT_ASSERT_DESC( dataState->DataState() == MXIMPDataSubscriptionState::EDataAvailable, 

   432                       "Data was unavailable." );

   433     EUNIT_ASSERT_DESC( dataState->SubscriptionState() == MXIMPDataSubscriptionState::ESubscriptionActive, 

   434                       "Subscription was inactive." );

   435 

   436     CleanupStack::PopAndDestroy(); // collection

   437     CleanupStack::PopAndDestroy( factory );

   438     }

   439 

   440 

   441 

   442 void T_Utils::T_TXIMPRequestIdBuilder_Test_L()

   443     {

   444     EUNIT_PRINT( _L("TXIMPRequestIdbuilder test.") );

   445     

   446     TXIMPRequestIdBuilder builder;

   447     builder.SetProtocolId( 1 );

   448     builder.SetSessionId( 1 );

   449     builder.SetRequestId( 1 );    

   450 

   451     TXIMPRequestId id1 = builder.BuildRequestId();

   452     EUNIT_ASSERT( id1 == id1 );

   453     EUNIT_ASSERT( id1 != TXIMPRequestId::Null() );

   454 

   455 

   456         {

   457         builder.SetProtocolId( 2 );   

   458         TXIMPRequestId id2 = builder.BuildRequestId();

   459         EUNIT_ASSERT( id2 == id2 );

   460         EUNIT_ASSERT( id1 != id2 );

   461         EUNIT_ASSERT( id2 != id1 );

   462         EUNIT_ASSERT( id2 != TXIMPRequestId::Null() );        

   463         }

   464 

   465         {

   466         builder.SetSessionId( 2 );   

   467         TXIMPRequestId id3 = builder.BuildRequestId();

   468         EUNIT_ASSERT( id3 == id3 );

   469         EUNIT_ASSERT( id1 != id3 );

   470         EUNIT_ASSERT( id3 != id1 );

   471         EUNIT_ASSERT( id3 != TXIMPRequestId::Null() );        

   472         }

   473 

   474 

   475         {

   476         builder.SetRequestId( 2 );   

   477         TXIMPRequestId id4 = builder.BuildRequestId();

   478         EUNIT_ASSERT( id4 == id4 );

   479         EUNIT_ASSERT( id1 != id4 );

   480         EUNIT_ASSERT( id4 != id1 );

   481         EUNIT_ASSERT( id4 != TXIMPRequestId::Null() );                

   482         }

   483         

   484         

   485         {

   486         builder.SetProtocolId( 33333333 );

   487         builder.SetSessionId( 44444444 );

   488         builder.SetRequestId( 55555555 );    

   489 

   490         TXIMPRequestId id5 = builder.BuildRequestId();

   491         EUNIT_ASSERT( id5 == id5 );

   492         EUNIT_ASSERT( id1 != id5 );

   493         EUNIT_ASSERT( id5 != id1 );

   494         EUNIT_ASSERT( id5 != TXIMPRequestId::Null() );                

   495         }

   496     }

   497 

   498 

   499 void T_Utils::T_TXIMPRequestId_Test_L()

   500     {

   501     EUNIT_PRINT( _L("TXIMPRequestIdbuilder test.") );

   502     

   503     TXIMPRequestId id0 = TXIMPRequestId::Null();

   504     EUNIT_ASSERT( id0 == TXIMPRequestId::Null() );  

   505     

   506         {

   507         TXIMPRequestId id1 = TXIMPRequestId::Init( 1 ); 

   508         EUNIT_ASSERT( id1 != TXIMPRequestId::Null() ); 

   509         }

   510 

   511 

   512         {

   513         TXIMPRequestId id2 = TXIMPRequestId::Init( 2);     

   514         EUNIT_ASSERT( id0 != id2 );             

   515         }

   516 

   517     

   518         {

   519         TXIMPRequestId id3 = TXIMPRequestId::Init( KMaxTInt );     

   520         EUNIT_ASSERT( id0 != id3 );             

   521         }

   522 

   523 

   524         {

   525         TXIMPRequestId id4 = TXIMPRequestId::Init( 33333333 );     

   526         EUNIT_ASSERT( id0 != id4 );             

   527         }

   528         

   529         {

   530         TXIMPRequestId id5 = TXIMPRequestId::Init( KMaxTInt );     

   531         TXIMPRequestId id6 = TXIMPRequestId::Init( KMinTInt );     

   532         EUNIT_ASSERT( id0 != id5 );             

   533         EUNIT_ASSERT( id0 != id6 );             

   534         EUNIT_ASSERT( id5 != id6 );             

   535         }

   536         

   537     }

   538 

   539 

   540 

   541 

   542 // ===========================================================================

   543 // TEST CASE TABLE

   544 // ===========================================================================

   545 //

   546 EUNIT_BEGIN_TEST_TABLE(

   547         T_Utils,

   548         "XIMP test utils tests",

   549         "MODULE" )

   550 

   551  PRFW_NOT_DECORATED_TEST(

   552         "Kill servers",

   553         "",

   554         "",

   555         "FUNCTIONALITY",

   556         Setup_L,

   557         T_KillServers_L,

   558         Teardown )

   559 

   560 PRFW_NOT_DECORATED_TEST(

   561         "Object collection without names",

   562         "",

   563         "",

   564         "FUNCTIONALITY",

   565         Setup_L,

   566         T_ObjectCollection_Unnamed_L,

   567         Teardown )

   568 

   569 PRFW_NOT_DECORATED_TEST(

   570         "Object collection using names",

   571         "",

   572         "",

   573         "FUNCTIONALITY",

   574         Setup_L,

   575         T_ObjectCollection_Named_L,

   576         Teardown )

   577 

   578 PRFW_NOT_DECORATED_TEST(

   579         "Restricted object collection",

   580         "",

   581         "",

   582         "FUNCTIONALITY",

   583         Setup_L,

   584         T_RestrictedObjectCollection_L,

   585         Teardown )

   586 

   587 PRFW_NOT_DECORATED_TEST(

   588         "Data subscription state",

   589         "",

   590         "",

   591         "FUNCTIONALITY",

   592         Setup_L,

   593         T_DataSubscriptionState_L,

   594         Teardown )

   595 

   596 

   597 PRFW_NOT_DECORATED_TEST(

   598         "TXIMPRequestIdBuilder test",

   599         "",

   600         "",

   601         "FUNCTIONALITY",

   602         Setup_L,

   603         T_TXIMPRequestIdBuilder_Test_L,

   604         Teardown )

   605 

   606 

   607 PRFW_NOT_DECORATED_TEST(

   608         "TXIMPRequestId test",

   609         "",

   610         "",

   611         "FUNCTIONALITY",

   612         Setup_L,

   613         T_TXIMPRequestId_Test_L,

   614         Teardown )

   615 

   616 

   617 /* PRFW_NOT_DECORATED_TEST(

   618         "FileTool test",

   619         "",

   620         "",

   621         "FUNCTIONALITY",

   622         Setup_L,

   623         T_FileToolTest_L,

   624         Teardown ) */

   625 

   626 

   627 EUNIT_END_TEST_TABLE

   628 

   629 

   630 // ===========================================================================

   631 // TEST SUITE CONSTRUCTION

   632 // ===========================================================================

   633 //

   634 EXPORT_C MEUnitTest* CreateTestSuiteL()

   635     {

   636     return T_Utils::NewL();

   637     }

   638 

   639 

   640 // end of file

   641 

   642 

   643 

   644 

   645 

   646