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 <eunitmacros.h>

    20 #include <ecom/ecom.h>

    21 #include <badesca.h>

    22 #include <e32property.h>

    23 #include <e32base.h>

    24 #include <e32std.h>

    25 

    26 #include "t_utils.h"

    27 

    28 #include "eunittools.h"

    29 

    30 #include <ximpbase.h>

    31 #include <presenceinfo.h>

    32 

    33 #include "ximpeventcodec.h"

    34 #include "ownpresenceeventimp.h"

    35 #include "prfwtestfiletool.h"

    36 #include "ximppanics.h"

    37 

    38 #include "prfwtestrobustnesstools.h"

    39 

    40 #include "ximpobjectfactoryimp.h"

    41 #include "ximpobjectcollection.h"

    42 #include "ximprestrictedobjectcollection.h"

    43 #include "ximpidentityimp.h"

    44 #include "ximpstatusimp.h"

    45 #include "ximprequestidbuilder.h"

    46 

    47 

    48 

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

    50 

    51 // CONSTRUCTION

    52 T_Utils* T_Utils::NewL()

    53     {

    54     T_Utils* self = new( ELeave ) T_Utils;

    55     CleanupStack::PushL( self );

    56     self->ConstructL();

    57     CleanupStack::Pop( self );

    58 

    59     return self;

    60     }

    61 

    62 

    63 T_Utils::~T_Utils()

    64     {

    65     }

    66 

    67 

    68 void T_Utils::ConstructL()

    69     {

    70     CEUnitTestSuiteClass::ConstructL();

    71     }

    72 

    73 

    74 T_Utils::T_Utils()

    75     {

    76     }

    77 

    78 // ===========================================================================

    79 // TEST CASE SETUP & TEARDOWN METHODS

    80 // ===========================================================================

    81 //

    82 

    83 void T_Utils::Setup_L()

    84     {

    85     }

    86 

    87 void T_Utils::Teardown()

    88     {

    89     }

    90 

    91 // ===========================================================================

    92 // TEST CASE

    93 // ===========================================================================

    94 void T_Utils::T_FileToolTest_L()

    95     {

    96     // TODO add more brains to the test

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

    98 

    99     /*

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

   101     CleanupStack::PushL( tool );

   102     tool->CleanL( 0 );

   103     tool->PrepareL( 0 );

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

   105 

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

   107 

   108     // make a proper object and store it.

   109     MPresenceInfo::TPresenceInfoStatus status;

   110     status = MPresenceInfo::EDataSubscriptionPending;

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

   112 

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

   114     CleanupStack::PushL( buf );

   115     TInt32 eventType = 0;

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

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

   118 

   119     // create more objects

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

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

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

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

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

   125 

   126     files = tool->NumObjectsL( 0 );

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

   128 

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

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

   131 

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

   133 

   134     CleanupStack::PopAndDestroy( tool );

   135     */

   136     }

   137 

   138 // ===========================================================================

   139 // TEST CASE

   140 // ===========================================================================

   141 void T_Utils::T_KillServers_L()

   142     {

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

   144 

   145     PrfwTestRobustness::DoPreCleaning();

   146     }

   147 

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

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

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

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

   152 

   153 _LIT( KIdentity1, "Identity 1" );

   154 _LIT( KIdentity2, "Identity 2" );

   155 

   156 // ===========================================================================

   157 // TEST CASE

   158 // ===========================================================================

   159 void T_Utils::T_ObjectCollection_Unnamed_L()

   160     {

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

   162 

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

   164     CleanupStack::PushL( factory );

   165 

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

   167 

   168     // LookupByType should not find anything

   169     const MXIMPBase* obj = NULL;

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

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

   172 

   173     // LookupByTypeAndName should not find anything

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

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

   176 

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

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

   179 

   180     // add some

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

   182     identity2->SetIdentityL( KIdentity2 );

   183 

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

   185     status->SetResultCode( KErrArgument );

   186 

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

   188     identity1->SetIdentityL( KIdentity1 );

   189 

   190     collection->AddObjectL( identity1 );

   191     CleanupStack::Pop(); // identity1

   192 

   193     collection->AddObjectL( status );

   194     CleanupStack::Pop(); // status

   195 

   196     collection->AddObjectL( identity2 );

   197     CleanupStack::Pop(); // identity2

   198 

   199     // get and verify the status

   200     MXIMPBase* getObj = NULL;

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

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

   203 

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

   205     CleanupDeletePushL( gotStatus );

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

   207     CleanupStack::PopAndDestroy(); // gotStatus

   208 

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

   210     obj = NULL;

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

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

   213 

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

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

   216 

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

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

   219 

   220     // get and verify the two identities

   221     // first identity

   222     getObj = NULL;

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

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

   225 

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

   227     CleanupDeletePushL( gotIdentity );

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

   229     CleanupStack::PopAndDestroy(); // gotIdentity

   230 

   231     // second identity

   232     getObj = NULL;

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

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

   235 

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

   237     CleanupDeletePushL( gotIdentity );

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

   239     CleanupStack::PopAndDestroy(); // gotIdentity

   240 

   241     // now there should not be anything anymore

   242     obj = NULL;

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

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

   245 

   246     CleanupStack::PopAndDestroy(); // collection

   247     CleanupStack::PopAndDestroy( factory );

   248     }

   249 

   250 // ===========================================================================

   251 // TEST CASE

   252 // ===========================================================================

   253 void T_Utils::T_ObjectCollection_Named_L()

   254     {

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

   256 

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

   258     CleanupStack::PushL( factory );

   259 

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

   261 

   262     // LookupByType should not find anything

   263     const MXIMPBase* obj = NULL;

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

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

   266 

   267     // LookupByTypeAndName should not find anything

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

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

   270 

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

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

   273 

   274     // add some

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

   276     identity2->SetIdentityL( KIdentity2 );

   277     

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

   279     status->SetResultCode( KErrArgument );

   280 

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

   282     identity1->SetIdentityL( KIdentity1 );

   283     

   284     collection->AddObjectWithNameL( identity1, KTestObjectName );

   285     CleanupStack::Pop(); // identity1

   286 

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

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

   289     CleanupStack::PopAndDestroy(); // status

   290 

   291     collection->AddObjectWithNameL( identity2, KTestObjectName2 );

   292     CleanupStack::Pop(); // identity2

   293 

   294     // should not find the status object

   295     MXIMPBase* getObj = NULL;

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

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

   298 

   299     // get and verify the two identities

   300     // first identity

   301     getObj = NULL;

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

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

   304 

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

   306     CleanupDeletePushL( gotIdentity );

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

   308     CleanupStack::PopAndDestroy(); // gotIdentity

   309 

   310     // second identity

   311     getObj = NULL;

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

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

   314 

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

   316     CleanupDeletePushL( gotIdentity );

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

   318     CleanupStack::PopAndDestroy(); // gotIdentity

   319 

   320     // now there should not be anything anymore

   321     obj = NULL;

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

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

   324 

   325     CleanupStack::PopAndDestroy(); // collection

   326     CleanupStack::PopAndDestroy( factory );

   327     }

   328 

   329 // ===========================================================================

   330 // TEST CASE

   331 // ===========================================================================

   332 void T_Utils::T_RestrictedObjectCollection_L()

   333     {

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

   335 

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

   337     CleanupStack::PushL( factory );

   338 

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

   340 

   341     // LookupByType should not find anything, empty collection

   342     const MXIMPBase* obj = NULL;

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

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

   345 

   346     // add some

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

   348     identity2->SetIdentityL( KIdentity2 );

   349     

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

   351     status->SetResultCode( KErrArgument );

   352 

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

   354     identity1->SetIdentityL( KIdentity1 );

   355     

   356     resColl->AddOrReplaceTypeL( identity1 );

   357     CleanupStack::Pop(); // identity1

   358 

   359     resColl->AddOrReplaceTypeL( status );

   360     CleanupStack::Pop(); // identity1

   361 

   362     resColl->AddOrReplaceTypeL( identity2 );

   363     CleanupStack::Pop(); // identity2

   364 

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

   366     obj = NULL;

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

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

   369 

   370     obj = NULL;

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

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

   373 

   374     // get the objects and verify their contents

   375     

   376     // 1. identity

   377     MXIMPBase* getObj = NULL;

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

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

   380 

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

   382     CleanupDeletePushL( gotIdentity );

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

   384     CleanupStack::PopAndDestroy(); // gotIdentity

   385 

   386     // 2. status

   387     getObj = NULL;

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

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

   390 

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

   392     CleanupDeletePushL( gotStatus );

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

   394     CleanupStack::PopAndDestroy(); // gotStatus

   395 

   396     // now there should not be anything anymore

   397     obj = NULL;

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

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

   400     

   401     obj = NULL;

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

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

   404 

   405     CleanupStack::PopAndDestroy(); // collection

   406     CleanupStack::PopAndDestroy( factory );

   407     }

   408 

   409 void T_Utils::T_DataSubscriptionState_L()

   410     {

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

   412 

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

   414     CleanupStack::PushL( factory );

   415 

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

   417 

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

   419                       "Data was available." );

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

   421                       "Subscription was active." );

   422     

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

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

   425 

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

   427                       "Data was unavailable." );

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

   429                       "Subscription was inactive." );

   430 

   431     CleanupStack::PopAndDestroy(); // collection

   432     CleanupStack::PopAndDestroy( factory );

   433     }

   434 

   435 

   436 

   437 void T_Utils::T_TXIMPRequestIdBuilder_Test_L()

   438     {

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

   440     

   441     TXIMPRequestIdBuilder builder;

   442     builder.SetProtocolId( 1 );

   443     builder.SetSessionId( 1 );

   444     builder.SetRequestId( 1 );    

   445 

   446     TXIMPRequestId id1 = builder.BuildRequestId();

   447     EUNIT_ASSERT( id1 == id1 );

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

   449 

   450 

   451         {

   452         builder.SetProtocolId( 2 );   

   453         TXIMPRequestId id2 = builder.BuildRequestId();

   454         EUNIT_ASSERT( id2 == id2 );

   455         EUNIT_ASSERT( id1 != id2 );

   456         EUNIT_ASSERT( id2 != id1 );

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

   458         }

   459 

   460         {

   461         builder.SetSessionId( 2 );   

   462         TXIMPRequestId id3 = builder.BuildRequestId();

   463         EUNIT_ASSERT( id3 == id3 );

   464         EUNIT_ASSERT( id1 != id3 );

   465         EUNIT_ASSERT( id3 != id1 );

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

   467         }

   468 

   469 

   470         {

   471         builder.SetRequestId( 2 );   

   472         TXIMPRequestId id4 = builder.BuildRequestId();

   473         EUNIT_ASSERT( id4 == id4 );

   474         EUNIT_ASSERT( id1 != id4 );

   475         EUNIT_ASSERT( id4 != id1 );

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

   477         }

   478         

   479         

   480         {

   481         builder.SetProtocolId( 33333333 );

   482         builder.SetSessionId( 44444444 );

   483         builder.SetRequestId( 55555555 );    

   484 

   485         TXIMPRequestId id5 = builder.BuildRequestId();

   486         EUNIT_ASSERT( id5 == id5 );

   487         EUNIT_ASSERT( id1 != id5 );

   488         EUNIT_ASSERT( id5 != id1 );

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

   490         }

   491     }

   492 

   493 

   494 void T_Utils::T_TXIMPRequestId_Test_L()

   495     {

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

   497     

   498     TXIMPRequestId id0 = TXIMPRequestId::Null();

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

   500     

   501         {

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

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

   504         }

   505 

   506 

   507         {

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

   509         EUNIT_ASSERT( id0 != id2 );             

   510         }

   511 

   512     

   513         {

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

   515         EUNIT_ASSERT( id0 != id3 );             

   516         }

   517 

   518 

   519         {

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

   521         EUNIT_ASSERT( id0 != id4 );             

   522         }

   523         

   524         {

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

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

   527         EUNIT_ASSERT( id0 != id5 );             

   528         EUNIT_ASSERT( id0 != id6 );             

   529         EUNIT_ASSERT( id5 != id6 );             

   530         }

   531         

   532     }

   533 

   534 

   535 

   536 

   537 // ===========================================================================

   538 // TEST CASE TABLE

   539 // ===========================================================================

   540 //

   541 EUNIT_BEGIN_TEST_TABLE(

   542         T_Utils,

   543         "XIMP test utils tests",

   544         "MODULE" )

   545 

   546  PRFW_NOT_DECORATED_TEST(

   547         "Kill servers",

   548         "",

   549         "",

   550         "FUNCTIONALITY",

   551         Setup_L,

   552         T_KillServers_L,

   553         Teardown )

   554 

   555 PRFW_NOT_DECORATED_TEST(

   556         "Object collection without names",

   557         "",

   558         "",

   559         "FUNCTIONALITY",

   560         Setup_L,

   561         T_ObjectCollection_Unnamed_L,

   562         Teardown )

   563 

   564 PRFW_NOT_DECORATED_TEST(

   565         "Object collection using names",

   566         "",

   567         "",

   568         "FUNCTIONALITY",

   569         Setup_L,

   570         T_ObjectCollection_Named_L,

   571         Teardown )

   572 

   573 PRFW_NOT_DECORATED_TEST(

   574         "Restricted object collection",

   575         "",

   576         "",

   577         "FUNCTIONALITY",

   578         Setup_L,

   579         T_RestrictedObjectCollection_L,

   580         Teardown )

   581 

   582 PRFW_NOT_DECORATED_TEST(

   583         "Data subscription state",

   584         "",

   585         "",

   586         "FUNCTIONALITY",

   587         Setup_L,

   588         T_DataSubscriptionState_L,

   589         Teardown )

   590 

   591 

   592 PRFW_NOT_DECORATED_TEST(

   593         "TXIMPRequestIdBuilder test",

   594         "",

   595         "",

   596         "FUNCTIONALITY",

   597         Setup_L,

   598         T_TXIMPRequestIdBuilder_Test_L,

   599         Teardown )

   600 

   601 

   602 PRFW_NOT_DECORATED_TEST(

   603         "TXIMPRequestId test",

   604         "",

   605         "",

   606         "FUNCTIONALITY",

   607         Setup_L,

   608         T_TXIMPRequestId_Test_L,

   609         Teardown )

   610 

   611 

   612 /* PRFW_NOT_DECORATED_TEST(

   613         "FileTool test",

   614         "",

   615         "",

   616         "FUNCTIONALITY",

   617         Setup_L,

   618         T_FileToolTest_L,

   619         Teardown ) */

   620 

   621 

   622 EUNIT_END_TEST_TABLE

   623 

   624 

   625 // ===========================================================================

   626 // TEST SUITE CONSTRUCTION

   627 // ===========================================================================

   628 //

   629 EXPORT_C MEUnitTest* CreateTestSuiteL()

   630     {

   631     return T_Utils::NewL();

   632     }

   633 

   634 

   635 // end of file

   636 

   637 

   638 

   639 

   640 

   641