1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Source code file for contact adapter's datastore unit tests.

    15 *

    16 */

    17 

    18 // CLASS HEADER

    19 #include "cnsmldummydatastore_test.h"

    20 

    21 // EXTERNAL INCLUDES

    22 #include <eunitmacros.h>

    23 #include <eunitdecorators.h>

    24 #include <cntdb.h>

    25 #include <cntitem.h>

    26 #include <cntfield.h>

    27 #include <cntfldst.h>

    28 #include <s32mem.h>

    29 #include <bautils.h>

    30 #include <smldataformat.h>

    31 

    32 // INTERNAL INCLUDES

    33 #include "cnsmladaptertestutilities.h"

    34 #include "nsmldummydatastore.h"

    35 #include "cnsmldummydatastorewaiter.h"

    36 

    37 namespace

    38     {

    39     // "abld test export" will export test data.

    40     _LIT( KVCardStandard, "c:\\Data\\TestData\\standard.vcf" );

    41     _LIT( KVCardBasic, "c:\\Data\\TestData\\basic.vcf" );

    42     }

    43 

    44 // - Construction -----------------------------------------------------------

    45 

    46 CNSmlDummyDataStore_Test* CNSmlDummyDataStore_Test::NewL()

    47     {

    48     CNSmlDummyDataStore_Test* self = CNSmlDummyDataStore_Test::NewLC();

    49     CleanupStack::Pop( self );

    50     return self;

    51     }

    52 

    53 CNSmlDummyDataStore_Test* CNSmlDummyDataStore_Test::NewLC()

    54     {

    55     CNSmlDummyDataStore_Test* self = new( ELeave ) CNSmlDummyDataStore_Test();

    56     CleanupStack::PushL( self );

    57     self->ConstructL();

    58     return self;

    59     }

    60 

    61 CNSmlDummyDataStore_Test::~CNSmlDummyDataStore_Test()

    62     {

    63     iWriteStream.Close();

    64     iFsSession.Close();

    65     delete iCNSmlDummyDataStore;

    66     delete iTestUtilities;

    67     delete iContactDatabase;

    68     delete iIdArray;

    69     delete iStoreWaiter;

    70     }

    71 

    72 CNSmlDummyDataStore_Test::CNSmlDummyDataStore_Test()

    73     {

    74     }

    75 

    76 void CNSmlDummyDataStore_Test::ConstructL()

    77     {

    78     CEUnitTestSuiteClass::ConstructL();

    79     User::LeaveIfError( iFsSession.Connect() );

    80     }

    81 

    82 // from MSmlSyncRelationship

    83 TSmlSyncTaskKey CNSmlDummyDataStore_Test::SyncTaskKey() const

    84     {

    85     TSmlSyncTaskKey key = 0;

    86     return key;

    87     }

    88 

    89 void CNSmlDummyDataStore_Test::OpenReadStreamLC(

    90         RReadStream& /*aReadStream*/, TUid /*aStreamUid*/)

    91     {

    92     }

    93 

    94 void CNSmlDummyDataStore_Test::OpenWriteStreamLC(

    95         RWriteStream& aWriteStream, TUid /*aStreamUid*/ )

    96     {

    97     User::LeaveIfError(

    98             iWriteStream.Replace( iFsSession, _L("store.test"), EFileWrite  ) );

    99     aWriteStream = iWriteStream;

   100     CleanupClosePushL( aWriteStream );

   101     }

   102 

   103 TBool CNSmlDummyDataStore_Test::IsStreamPresentL(TUid /*aStreamUid*/) const

   104     {

   105     return EFalse;

   106     }

   107 

   108 // - Setup & teardown ---------------------------------------------------------

   109 

   110 // ++++++++++++ SETUP METHODS ++++++++++++

   111 

   112 void CNSmlDummyDataStore_Test::SetupL(  )

   113     {

   114     iCNSmlDummyDataStore = CNSmlDummyDataStore::NewL();

   115     iTestUtilities = CNSmlAdapterTestUtilities::NewL();

   116     }

   117 

   118 void CNSmlDummyDataStore_Test::SetupAndOpenStoreL(  )

   119     {

   120     SetupL();

   121 

   122     iStoreWaiter =

   123         CNSmlDummyDataStoreWaiter::NewL( *iCNSmlDummyDataStore );

   124     iStoreWaiter->OpenStoreL( *this );

   125 

   126     iContactDatabase = CContactDatabase::OpenL();

   127     }

   128 

   129 void CNSmlDummyDataStore_Test::SetupPopulateDbAndOpenStoreL()

   130     {

   131     SetupAndPopulateContactDbL();

   132 

   133     EUNIT_ASSERT_NO_LEAVE(

   134     iCNSmlDummyDataStore = CNSmlDummyDataStore::NewL() );

   135 

   136     iStoreWaiter =

   137         CNSmlDummyDataStoreWaiter::NewL( *iCNSmlDummyDataStore );

   138     iStoreWaiter->OpenStoreL( *this );

   139     }

   140 

   141 /**

   142  * Setup contact DB with the following contacts

   143  *   + Tim Tester (id index 0)

   144  *   + Teddy McTest (id index 1)

   145  *   + Tod TestHill (id index 2)

   146  *   + Simon Software (id index 3)

   147  *   + Cyd Effect (id index 4)

   148  *

   149  */

   150 void CNSmlDummyDataStore_Test::SetupAndPopulateContactDbL()

   151     {

   152     if( !iContactDatabase )

   153         {

   154         iContactDatabase = CContactDatabase::OpenL();

   155         }

   156     if( !iTestUtilities )

   157         {

   158         iTestUtilities = CNSmlAdapterTestUtilities::NewL();

   159         }

   160 

   161     iIdArray = CContactIdArray::NewL();

   162 

   163     // Create test contacts

   164     iIdArray->AddL( AddContactL( _L( "Tim" ), _L( "Tester" ), _L( "+358501234567" ) ) );

   165     iIdArray->AddL( AddContactL( _L( "Teddy" ), _L("McTest" ), _L( "+358501112222" ) ) );

   166     iIdArray->AddL( AddContactL( _L( "Tod" ), _L( "TestHill" ), _L( "+358506666666" ) ) );

   167     iIdArray->AddL( AddContactL( _L( "Simon" ), _L( "Software" ), _L( "+3585011223333" ) ) );

   168     iIdArray->AddL( AddContactL( _L( "Cyd" ), _L( "Effect" ), _L( "+358503334444" ) ) );

   169     }

   170 

   171 //// ++++++++++++ TEARDOWN METHODS ++++++++++++

   172 //

   173 void CNSmlDummyDataStore_Test::Teardown()

   174     {

   175     delete iCNSmlDummyDataStore;

   176     iCNSmlDummyDataStore = NULL;

   177 

   178     delete iTestUtilities;

   179     iTestUtilities = NULL;

   180     }

   181 

   182 void CNSmlDummyDataStore_Test::TeardownAndCloseStore()

   183     {

   184     delete iStoreWaiter;

   185     iStoreWaiter = NULL;

   186 

   187     delete iContactDatabase;

   188     iContactDatabase = NULL;

   189 

   190     Teardown();

   191     }

   192 

   193 void CNSmlDummyDataStore_Test::TeardownCloseAndEmptyContactDb()

   194     {

   195     delete iStoreWaiter;

   196     iStoreWaiter = NULL;

   197 

   198     delete iCNSmlDummyDataStore;

   199     iCNSmlDummyDataStore = NULL;

   200 

   201     TeardownAndEmptyContactDb();

   202     }

   203 

   204 void CNSmlDummyDataStore_Test::TeardownAndEmptyContactDb()

   205     {

   206     if (iContactDatabase && iIdArray)

   207         {

   208         TRAP_IGNORE( iContactDatabase->DeleteContactsL( *iIdArray ) );

   209         }

   210     

   211     delete iIdArray;

   212     iIdArray = NULL;

   213     delete iContactDatabase;

   214     iContactDatabase = NULL;

   215     delete iTestUtilities;

   216     iTestUtilities = NULL;

   217     }

   218 

   219     

   220 // - Test methods -------------------------------------------------------------

   221 

   222 // MEMORY ALLOCATION FOR DATASTORE

   223 void CNSmlDummyDataStore_Test::NewLL(  )

   224     {

   225     CNSmlDummyDataStore* dataStore = NULL;

   226     EUNIT_ASSERT_NO_LEAVE( dataStore = CNSmlDummyDataStore::NewL() );

   227     EUNIT_ASSERT( dataStore );

   228     delete dataStore;

   229     }

   230 

   231 // DoOpenL()

   232 void CNSmlDummyDataStore_Test::DoOpenLL()

   233     {

   234     CNSmlDummyDataStoreWaiter* storeWaiter =

   235         CNSmlDummyDataStoreWaiter::NewLC( *iCNSmlDummyDataStore );

   236 

   237     TRAPD( err, storeWaiter->OpenStoreL( *this ) );

   238 

   239     // Check for leave

   240     EUNIT_PRINT( _L( "Leave code: %d" ), err );

   241     EUNIT_ASSERT_DESC( err == KErrNone, "DoOpenL() leave" );

   242     CleanupStack::PopAndDestroy( storeWaiter );

   243     }

   244 

   245 // DoHasSyncHistory()

   246 void CNSmlDummyDataStore_Test::DoHasSyncHistoryL()

   247     {

   248     TBool ret = iCNSmlDummyDataStore->DoHasSyncHistory();

   249     EUNIT_ASSERT_DESC( ret == EFalse, "DoHasSyncHistory returns faulty value");

   250     }

   251 

   252 // DoModifiedItems(), DoCommitChangeInfoL()

   253 void CNSmlDummyDataStore_Test::DoModifiedItemsL()

   254     {

   255     const MSmlDataItemUidSet& uiSet = iCNSmlDummyDataStore->DoModifiedItems();

   256     EUNIT_ASSERT_DESC( uiSet.ItemCount() == 0, "DoModifiedItems returns faulty uid set");

   257 

   258     TInt returnCode = KErrNone;

   259 

   260     TRAPD( err, returnCode = iStoreWaiter->DoCommitChangeInfoL( uiSet ) );

   261 

   262     // Check for leave

   263     EUNIT_PRINT( _L( "Leave code: %d" ), err );

   264     EUNIT_ASSERT_DESC( err == KErrNone, "DoCommitChangeInfoL() leave" );

   265 

   266     // Check for return code

   267     EUNIT_PRINT( _L( "Return code: %d" ), returnCode );

   268     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCommitChangeInfoL returns error");

   269     }

   270 

   271 // DoResetChangeInfoL()

   272 void CNSmlDummyDataStore_Test::DoResetChangeInfoLL()

   273     {

   274     TInt returnCode = KErrNone;

   275     TRAPD( err, returnCode = iStoreWaiter->DoResetChangeInfoL() );

   276 

   277     // Check for leave

   278     EUNIT_PRINT( _L( "Leave code: %d" ), err );

   279     EUNIT_ASSERT_DESC( err == KErrNone, "DoResetChangeInfoL() leave" );

   280 

   281     // Check for return code

   282     EUNIT_PRINT( _L( "Return code: %d" ), returnCode );

   283     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoResetChangeInfoL returns error");

   284     }

   285 

   286 // DoCommitChangeInfoL()

   287 void CNSmlDummyDataStore_Test::DoCommitChangeInfoLL()

   288     {

   289     TInt returnCode = KErrNone;

   290     TRAPD( err, returnCode = iStoreWaiter->DoCommitChangeInfoL() );

   291 

   292     // Check for leave

   293     EUNIT_PRINT( _L( "Leave code: %d" ), err );

   294     EUNIT_ASSERT_DESC( err == KErrNone, "DoCommitChangeInfoL() leave" );

   295 

   296     // Check for return code

   297     EUNIT_PRINT( _L( "Return code: %d" ), returnCode );

   298     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCommitChangeInfoL returns error");

   299     }

   300 

   301 // Item addition - "Normal" (non-batch) mode

   302 //  (DoCreateItemL(), DoWriteItemL(), DoCommitItemL(), LdoAddItemL())

   303 void CNSmlDummyDataStore_Test::AddSingleItemL()

   304     {

   305     TBuf8< 20 > type;

   306     TBuf8< 20 > ver = KNSmlvCard21Ver();

   307     TInt returnCode = KErrNone;

   308     iItemUid = KNullContactId;

   309 

   310     // Try creating contact with illegal MIME type

   311     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 1") );

   312     TRAPD( err, returnCode = iStoreWaiter->DoCreateItemL(

   313         iItemUid, 0, type, ver ) );

   314 

   315     EUNIT_PRINT( _L( "DoCreateItemL(): leave code: %d, return code: %d" ),

   316         err, returnCode );

   317     EUNIT_ASSERT_DESC( returnCode == KErrNotSupported,

   318         "DoCreateItemL() accepts illegal MIME" );

   319 

   320     // Create legal contact

   321     type = KNSmlvCard21Name();

   322     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 2") );

   323     TRAP( err, returnCode = iStoreWaiter->DoCreateItemL(

   324         iItemUid, 512, type, ver ) );

   325 

   326     EUNIT_PRINT( _L( "DoCreateItemL(): leave code: %d, return code: %d" ),

   327         err, returnCode );

   328     EUNIT_ASSERT_DESC( err == KErrNone, "DoCreateItemL() leave" );

   329     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCreateItemL returns error");

   330 

   331     // Perform item writing to data store

   332     HBufC8* vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardBasic() );

   333     EUNIT_PRINT( _L("Calling DoWriteItemL(), STEP 3") );

   334     // Non-async call (no need for iStoreWaiter usage)

   335     TRAP( err, iCNSmlDummyDataStore->DoWriteItemL( *vCard ) );

   336     EUNIT_PRINT( _L( "DoWriteItemL(): leave code: %d" ), err );

   337     EUNIT_ASSERT_DESC( err == KErrNone, "DoCreateItemL() leave" );

   338     CleanupStack::PopAndDestroy( vCard );

   339 

   340     // Commit the contact to be created

   341     EUNIT_PRINT( _L("Calling DoCommmitItemL(), STEP 4") );

   342     TRAP( err, returnCode = iStoreWaiter->DoCommitItemL() );

   343 

   344     EUNIT_PRINT( _L( "DoCommitItemL(): leave code: %d, return code: %d" ),

   345         err, returnCode );

   346     EUNIT_ASSERT_DESC( err == KErrNone, "DoCommitItemL() leave" );

   347     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCommitItemL returns error");

   348 

   349     // Check the imported item

   350     EUNIT_ASSERT_DESC( iItemUid != KNullContactId, "Illegal UID for imported contact" );

   351     EUNIT_PRINT( _L("Item ID: %d"), iItemUid );

   352 

   353     // Print out the imported vCard

   354     CContactIdArray* idArr = CContactIdArray::NewLC();

   355     idArr->AddL( iItemUid );

   356     CBufFlat* buffer = CBufFlat::NewL( 1024 );

   357     CleanupStack::PushL( buffer );

   358     RBufWriteStream writeStream( *buffer );

   359     CleanupClosePushL( writeStream );

   360 

   361     TRAP( err, iContactDatabase->ExportSelectedContactsL( TUid::Uid(KVersitEntityUidVCard), *idArr,

   362         writeStream, CContactDatabase::EExcludeUid, Versit::EUTF8CharSet ) );

   363 

   364     EUNIT_ASSERT_EQUALS_DESC( err, KErrNone, "ExportSelectedContactsL leave" );

   365 

   366     CleanupStack::PopAndDestroy( &writeStream );

   367 

   368     EUNIT_PRINT( buffer->Ptr( 0 ) );

   369 

   370     // Do some asserts

   371     EUNIT_ASSERT( buffer->Ptr( 0 ).Find( _L8("N:Smith;John") ) != KErrNotFound );

   372     EUNIT_ASSERT( buffer->Ptr( 0 ).Find( _L8("TITLE:Boss") ) != KErrNotFound );

   373 

   374     CleanupStack::PopAndDestroy( 2, idArr );  // buffer, idArr

   375 

   376     // Do cleanup (remove added contact)

   377     CContactIdArray* tmpArray = CContactIdArray::NewLC();

   378     tmpArray->AddL( iItemUid );

   379     TRAP_IGNORE( iContactDatabase->DeleteContactsL( *tmpArray ) );

   380     CleanupStack::PopAndDestroy( tmpArray );

   381     }

   382 

   383 // Item addition - Batch mode

   384 // (LdoAddItemsL())

   385 void CNSmlDummyDataStore_Test::AddItemBatchL()

   386     {

   387     TBuf8<20> type = KNSmlvCard21Name();

   388     TBuf8<20> ver = KNSmlvCard21Ver();

   389     TInt returnCode = KErrNone;

   390     HBufC8* vCard = NULL;

   391 

   392     // DoBeginBatchL()

   393     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 1") );

   394     TRAPD( err, iCNSmlDummyDataStore->DoBeginBatchL() );

   395     EUNIT_PRINT( _L( "DoBeginBatchL(): leave code: %d" ), err );

   396     EUNIT_ASSERT_DESC( err == KErrNone, "DoBeginBatchL() leave" );

   397 

   398     // == == CONTACT ITEM NO 1 == ==

   399     vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardBasic() );

   400     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 2") );

   401     TRAP( err, returnCode = iStoreWaiter->DoCreateItemL(

   402         iItemUid, vCard->Size(), type, ver ) );

   403 

   404     EUNIT_PRINT( _L( "DoCreateItemL(): leave code: %d, return code: %d" ),

   405         err, returnCode );

   406     EUNIT_ASSERT_DESC( err == KErrNone, "DoCreateItemL() leave" );

   407     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCreateItemL returns error");

   408 

   409     // Perform item writing to data store

   410     EUNIT_PRINT( _L("Calling DoWriteItemL(), STEP 3") );

   411     // Non-async call (no need for iStoreWaiter usage)

   412     TRAP( err, iCNSmlDummyDataStore->DoWriteItemL( *vCard ) );

   413     EUNIT_PRINT( _L( "DoWriteItemL(): leave code: %d" ), err );

   414     EUNIT_ASSERT_DESC( err == KErrNone, "DoCreateItemL() leave" );

   415     CleanupStack::PopAndDestroy( vCard );

   416     vCard = NULL;

   417 

   418     // Commit the contact to be created

   419     EUNIT_PRINT( _L("Calling DoCommitItemL(), STEP 4") );

   420     TRAP( err, returnCode = iStoreWaiter->DoCommitItemL() );

   421 

   422     EUNIT_PRINT( _L( "DoCommitItemL(): leave code: %d, return code: %d" ),

   423         err, returnCode );

   424     EUNIT_ASSERT_DESC( err == KErrNone, "DoCommitItemL() leave" );

   425     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCommitItemL returns error");

   426 

   427     // Commit batch

   428     RArray<TInt> array;

   429     EUNIT_PRINT( _L("Calling DoCommitBatchL(), STEP 5") );

   430     TRAP( err, returnCode = iStoreWaiter->DoCommitBatchL( array ) );

   431 

   432     EUNIT_PRINT( _L( "DoCommitBatchL(): leave code: %d, return code: %d" ),

   433         err, returnCode );

   434     EUNIT_ASSERT_DESC( err == KErrNone, "DoCommitBatchL() leave" );

   435     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCommitBatchL returns error" );

   436 

   437     // Verify results

   438     for( TInt i = 0; i < array.Count(); i++ )

   439         {

   440         EUNIT_PRINT( _L( "Contact: %d, Error code: %d "), i, array[ i ] );

   441         EUNIT_ASSERT( array[ i ] == KErrNone );

   442         }

   443     EUNIT_ASSERT_DESC( array.Count() == 1, "Wrong number of contacts added" );

   444     EUNIT_PRINT( _L("Item 1 ID = %d"), iItemUid );

   445 

   446     // Cleanup

   447     array.Reset();

   448     array.Close();

   449 

   450     CContactIdArray* tmpArray = CContactIdArray::NewLC();

   451     tmpArray->AddL( iItemUid );

   452     TRAP_IGNORE( iContactDatabase->DeleteContactsL( *tmpArray ) );

   453     CleanupStack::PopAndDestroy( tmpArray );

   454     }

   455 

   456 // Item addition - cancel Batch mode 

   457 void CNSmlDummyDataStore_Test::CancelBatchL()

   458     {

   459     TBuf8<20> type = KNSmlvCard21Name();

   460     TBuf8<20> ver = KNSmlvCard21Ver();

   461     TInt returnCode = KErrNone;

   462     HBufC8* vCard = NULL;

   463 

   464     // DoBeginBatchL()

   465     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 1") );

   466     TRAPD( err, iCNSmlDummyDataStore->DoBeginBatchL() );

   467     EUNIT_PRINT( _L( "DoBeginBatchL(): leave code: %d" ), err );

   468     EUNIT_ASSERT_DESC( err == KErrNone, "DoBeginBatchL() leave" );

   469 

   470     // == == CONTACT ITEM NO 1 == ==

   471     vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardBasic() );

   472     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 2") );

   473     TRAP( err, returnCode = iStoreWaiter->DoCreateItemL(

   474         iItemUid, vCard->Size(), type, ver ) );

   475 

   476     EUNIT_PRINT( _L( "DoCreateItemL(): leave code: %d, return code: %d" ),

   477         err, returnCode );

   478     EUNIT_ASSERT_DESC( err == KErrNone, "DoCreateItemL() leave" );

   479     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCreateItemL returns error");

   480 

   481     // Perform item writing to data store

   482     EUNIT_PRINT( _L("Calling DoWriteItemL(), STEP 3") );

   483     // Non-async call (no need for iStoreWaiter usage)

   484     TRAP( err, iCNSmlDummyDataStore->DoWriteItemL( *vCard ) );

   485     EUNIT_PRINT( _L( "DoWriteItemL(): leave code: %d" ), err );

   486     EUNIT_ASSERT_DESC( err == KErrNone, "DoCreateItemL() leave" );

   487     CleanupStack::PopAndDestroy( vCard );

   488     vCard = NULL;

   489 

   490     // Cancel Batch

   491     EUNIT_PRINT( _L("Calling DoCancelBatch(), STEP 4") );

   492     iStoreWaiter->DoCancelBatch();

   493     }

   494 

   495 // DoOpenItemL(), DoReadItemL(), DoCloseItemL()

   496 //  (LdoFetchItemL())

   497 void CNSmlDummyDataStore_Test::FetchItemL()

   498     {

   499     TBuf8<20> type;

   500     TBuf8<20> ver;

   501     TInt returnCode = KErrNone;

   502     TInt size = 0;

   503     TSmlDbItemUid parentId = KNullContactId;

   504     TBool fieldChange = EFalse;

   505 

   506     // Open item ("Tim Tester") for reading

   507     EUNIT_PRINT( _L("Calling DoOpenItemL()") );

   508 

   509     //Make some preparations:

   510     // (a) Set remote store format; needed by StripTxL()

   511     //      - Otherwise we get access violation

   512     EUNIT_ASSERT( iCNSmlDummyDataStore->iStoreFormat );

   513     iCNSmlDummyDataStore->DoSetRemoteStoreFormatL(

   514         *(iCNSmlDummyDataStore->iStoreFormat) );

   515 

   516     TRAPD( err, returnCode = iStoreWaiter->DoOpenItemL(

   517         ( *iIdArray )[ 0 ], fieldChange, size, parentId, type, ver ) );

   518 

   519     EUNIT_PRINT( _L( "DoOpenItemL(): leave code: %d, return code: %d" ),

   520         err, returnCode );

   521     EUNIT_ASSERT_DESC( err == KErrNone, "DoOpenItemL() leave" );

   522     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoOpenItemL returns error");

   523 

   524     // Execute some asserts to verify functionality

   525     EUNIT_PRINT( _L( "DoOpenItemL(): size: %d" ),

   526             size );

   527     EUNIT_ASSERT_DESC( size != 0, "Illegal size value" );

   528     EUNIT_ASSERT_DESC( parentId == KNullDataItemId, "Wrong parent ID" );

   529     EUNIT_ASSERT_DESC( type.Compare( KNSmlvCard21Name() ) == 0,

   530         "Illegal MIME type" );

   531     EUNIT_ASSERT_DESC( ver.Compare( KNSmlvCard21Ver() ) == 0,

   532         "Illegal MIME version" );

   533 

   534     // Read the item contents (i.e. vCard)

   535     HBufC8* vCard = HBufC8::NewLC( 86 );

   536     TPtr8 vCardPtr = vCard->Des();

   537     EUNIT_ASSERT_NO_LEAVE( iCNSmlDummyDataStore->DoReadItemL( vCardPtr ) );

   538 

   539     EUNIT_PRINT( *vCard );

   540     EUNIT_ASSERT( vCard->Find( _L8("N:Tester;Tim") ) != KErrNotFound );

   541     EUNIT_ASSERT( vCard->Find( _L8("TEL:+358501234567") ) != KErrNotFound );

   542 

   543     CleanupStack::PopAndDestroy( vCard );

   544 

   545     // Close the contact item

   546     iCNSmlDummyDataStore->DoCloseItem();

   547     }

   548 

   549 // Update a standard contact

   550 //  (DoReplaceItemL(), ExecuteBufferL()...)

   551 void CNSmlDummyDataStore_Test::UpdateItemL()

   552     {

   553     TInt returnCode = KErrNone;

   554     TSmlDbItemUid parentId = KNullContactId;

   555     TBool fieldChange = EFalse;

   556 

   557     HBufC8* vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardStandard() );

   558 

   559     // Update "Tim Tester" contact

   560     TRAPD( err, returnCode = iStoreWaiter->DoReplaceItemL(

   561         ( *iIdArray )[ 0 ], vCard->Size(), parentId, fieldChange ) );

   562 

   563     EUNIT_PRINT( _L( "DoReplaceItemL(): leave code: %d, return code: %d" ),

   564         err, returnCode );

   565     EUNIT_ASSERT_DESC( err == KErrNone, "DoReplaceItemL() leave" );

   566     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoReplaceItemL returns error");

   567 

   568     // Perform item writing to data store

   569     EUNIT_PRINT( _L("Calling DoWriteItemL()") );

   570     TRAP( err, iCNSmlDummyDataStore->DoWriteItemL( *vCard ) );

   571     EUNIT_PRINT( _L( "DoWriteItemL(): leave code: %d" ), err );

   572     EUNIT_ASSERT_DESC( err == KErrNone, "DoWriteItemL() leave" );

   573     CleanupStack::PopAndDestroy( vCard );

   574 

   575     // Commit the contact to be created

   576     EUNIT_PRINT( _L("Calling DoCommmitItemL()") );

   577     TRAP( err, returnCode = iStoreWaiter->DoCommitItemL() );

   578 

   579     EUNIT_PRINT( _L( "DoCommitItemL(): leave code: %d, return code: %d" ),

   580         err, returnCode );

   581     EUNIT_ASSERT_DESC( err == KErrNone, "DoCommitItemL() leave" );

   582     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoCommitItemL returns error");

   583 

   584     // Print out the imported vCard

   585     CContactIdArray* idArr = CContactIdArray::NewLC();

   586     idArr->AddL( ( *iIdArray )[ 0 ] );

   587     CBufFlat* buffer = CBufFlat::NewL( 1024 );

   588     CleanupStack::PushL( buffer );

   589     RBufWriteStream writeStream( *buffer );

   590     CleanupClosePushL( writeStream );

   591 

   592     TRAP( err, iContactDatabase->ExportSelectedContactsL(

   593         TUid::Uid(KVersitEntityUidVCard), *idArr,

   594         writeStream, CContactDatabase::EExcludeUid, Versit::EUTF8CharSet ) );

   595 

   596     EUNIT_ASSERT_EQUALS_DESC( err, KErrNone, "ExportSelectedContactsL leave" );

   597 

   598     CleanupStack::PopAndDestroy( &writeStream );

   599 

   600     EUNIT_PRINT( buffer->Ptr( 0 ) );

   601 

   602     // Do some asserts

   603     EUNIT_ASSERT( buffer->Ptr( 0 ).Find( _L8("N:Smith;John") ) != KErrNotFound );

   604     EUNIT_ASSERT( buffer->Ptr( 0 ).Find( _L8("TITLE:Boss") ) != KErrNotFound );

   605 

   606     CleanupStack::PopAndDestroy( 2, idArr );  // buffer, idArr

   607     }

   608 

   609 // DoDeleteItemL()

   610 void CNSmlDummyDataStore_Test::DeleteItemL()

   611     {

   612     // Delete item

   613     TInt returnCode = KErrNone;

   614     EUNIT_PRINT( _L("Calling DoDeleteItemL()") );

   615     TRAPD( err, returnCode = iStoreWaiter->DoDeleteItemL( ( *iIdArray )[ 0 ] ) );

   616 

   617     EUNIT_PRINT( _L( "DoDeleteItemL(): leave code: %d, return code: %d" ),

   618         err, returnCode );

   619     EUNIT_ASSERT_DESC( err == KErrNone, "DoDeleteItemL() leave" );

   620     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoDeleteItemL returns error");

   621     

   622     // Check that the contact does not exist any more

   623     CContactItem* item = NULL;

   624     CContactDatabase* cntDb = NULL;

   625     TRAP( err, cntDb = CContactDatabase::OpenL() );

   626     TRAP( err, item = cntDb->ReadMinimalContactL(

   627         ( *iIdArray )[ 0 ] ) );

   628     EUNIT_ASSERT( !item );

   629     EUNIT_PRINT( _L("Error=%d"), err );

   630     EUNIT_ASSERT_EQUALS_DESC( err, KErrNotFound, "Deleted item found" );

   631     delete item;

   632     item = NULL;

   633 

   634     if( cntDb )

   635         {

   636         delete cntDb;

   637         }

   638 

   639     iIdArray->Remove( 0 );

   640     }

   641 

   642 // DoDeleteAllItemsL()

   643 void CNSmlDummyDataStore_Test::DeleteAllItemsL()

   644     {

   645     // Temporarily remove ChangeFinder from Store to prevent leaves

   646     // when reseting ChangeFinder in code under test.

   647     CNSmlChangeFinder* cF = iCNSmlDummyDataStore->iChangeFinder;

   648     CleanupStack::PushL( cF );

   649     iCNSmlDummyDataStore->iChangeFinder = NULL;

   650 

   651     TInt returnCode = KErrNone;

   652     EUNIT_PRINT( _L("Calling DoDeleteAllItemsL()") );

   653     TRAPD( err, returnCode = iStoreWaiter->DoDeleteAllItemsL() );

   654 

   655     // Return ChangeFinders

   656     CleanupStack::Pop( cF );

   657     iCNSmlDummyDataStore->iChangeFinder = cF;

   658 

   659     EUNIT_PRINT( _L( "DoDeleteAllItemsL(): leave code: %d, return code: %d" ),

   660         err, returnCode );

   661     EUNIT_ASSERT_DESC( err == KErrNone, "DoDeleteAllItemsL() leave" );

   662     EUNIT_ASSERT_DESC( returnCode == KErrNone, "DoDeleteAllItemsL returns error");

   663 

   664     // Check that all normal contacts are removed

   665     TContactItemId ownCardId = iContactDatabase->OwnCardId();

   666 

   667     TInt contactCount = 0;

   668     TInt groupCount = iContactDatabase->GroupCount();

   669     TContactIter iter( *iContactDatabase );

   670     for( TContactItemId id = iter.FirstL(); id != KNullContactId; id = iter.NextL() )

   671         {

   672         // KUidContactGroup

   673         if( id != ownCardId )

   674             {

   675             contactCount++;

   676             }

   677         }

   678     EUNIT_PRINT( _L("Number of items in DB=%d"), contactCount );

   679     EUNIT_PRINT( _L("Number of groups in DB=%d"), groupCount );

   680     EUNIT_ASSERT_DESC( contactCount - groupCount == 0, "All contacts not deleted");

   681     }

   682 

   683 // GetStoreFormatResourceFileL()

   684 void CNSmlDummyDataStore_Test::GetStoreFormatResourceFileLL()

   685     {

   686     const TDesC& resourceFile = iCNSmlDummyDataStore->GetStoreFormatResourceFileL();

   687     EUNIT_PRINT( resourceFile );

   688     }

   689 

   690 void CNSmlDummyDataStore_Test::TestStoreSupportMimeTypeL()

   691     {

   692     EUNIT_ASSERT( iCNSmlDummyDataStore->iStoreFormat );

   693     EUNIT_ASSERT_EQUALS( iCNSmlDummyDataStore->iStoreFormat->MimeFormatCount() ,1 );

   694     EUNIT_ASSERT_EQUALS(

   695             iCNSmlDummyDataStore->iStoreFormat->MimeFormat(0).MimeType().DesC(),

   696             KNSmlvCard21Name() );

   697     EUNIT_ASSERT_EQUALS(

   698             iCNSmlDummyDataStore->iStoreFormat->MimeFormat(0).MimeVersion().DesC(),

   699                     KNSmlvCard21Ver() );

   700     }

   701 

   702 void CNSmlDummyDataStore_Test::GetDataMod()

   703     {

   704     CNSmlDataModBase& dataMod = iCNSmlDummyDataStore->GetDataMod();

   705     }

   706 

   707 void CNSmlDummyDataStore_Test::DoBeginTransactionL()

   708     {

   709     TRAPD( err, iCNSmlDummyDataStore->DoBeginTransactionL() );

   710     EUNIT_ASSERT( err == KErrNotSupported );

   711     }

   712 

   713 void CNSmlDummyDataStore_Test::DoCommitTransactionL()

   714     {

   715     TRequestStatus status;

   716     iCNSmlDummyDataStore->DoCommitTransactionL( status );

   717     User::WaitForRequest( status );

   718     EUNIT_ASSERT_DESC( status.Int() == KErrNotSupported, "DoCommitTransactionL fail"  )

   719     }

   720 

   721 void CNSmlDummyDataStore_Test::DoRevertTransaction()

   722     {

   723     TRequestStatus status;

   724     iCNSmlDummyDataStore->DoRevertTransaction( status );

   725     User::WaitForRequest( status );

   726     EUNIT_ASSERT_DESC( status.Int() == KErrNotSupported, "DoRevertTransaction fail"  )

   727     }

   728 

   729 void CNSmlDummyDataStore_Test::StoreNameL()

   730     {

   731     CreateDataStoreL();

   732     EUNIT_PRINT( iDataStore->StoreName() );

   733     iDataStore->CancelRequest();

   734     DeleteDataStoreL();

   735     }

   736 

   737 void CNSmlDummyDataStore_Test::FindChangedItemsL()

   738     {

   739     CreateDataStoreL();

   740     const MSmlDataItemUidSet& added = iDataStore->AddedItems();

   741     EUNIT_ASSERT_DESC( added.ItemCount() == 0, "AddedItems returns faulty uid set");

   742     const MSmlDataItemUidSet& deleted = iDataStore->DeletedItems();

   743     EUNIT_ASSERT_DESC( deleted.ItemCount() == 0, "DeletedItems returns faulty uid set");

   744     const MSmlDataItemUidSet& softDeleted = iDataStore->SoftDeletedItems();

   745     EUNIT_ASSERT_DESC( softDeleted.ItemCount() == 0, "SoftDeletedItems returns faulty uid set");

   746     const MSmlDataItemUidSet& moved = iDataStore->MovedItems();

   747     EUNIT_ASSERT_DESC( moved.ItemCount() == 0, "MovedItems returns faulty uid set");

   748     DeleteDataStoreL();

   749     }

   750 

   751 void CNSmlDummyDataStore_Test::MoveAndDeleteL()

   752     {

   753     CreateDataStoreL();

   754     TSmlDbItemUid uid = 1;

   755     TSmlDbItemUid parent = 0;

   756     TRequestStatus status;

   757     iDataStore->MoveItemL( uid, parent, status );

   758     User::WaitForRequest( status );

   759     

   760     TRequestStatus status2;

   761     iDataStore->SoftDeleteItemL( uid, status2 );

   762     User::WaitForRequest( status2 );

   763     

   764     DeleteDataStoreL();

   765     }

   766 

   767 void CNSmlDummyDataStore_Test::DoSetRemoteMaxObjectSize()

   768     {

   769     iCNSmlDummyDataStore->DoSetRemoteMaxObjectSize( 100000 );

   770     }

   771 

   772 void CNSmlDummyDataStore_Test::DoMaxObjectSize()

   773     {

   774     TInt size = iCNSmlDummyDataStore->DoMaxObjectSize();

   775     EUNIT_ASSERT( size == 102400 );

   776     }

   777 

   778 

   779 // --------------- Helper methods --------------

   780 

   781 // Helper method to add a simple contact to test contact DB

   782 TContactItemId CNSmlDummyDataStore_Test::AddContactL(

   783         const TDesC& aFirstName,

   784         const TDesC& aLastName,

   785         const TDesC& aPhoneNumber )

   786     {

   787     _LIT( KLabelFamilyName, "Last name");

   788     _LIT( KLabelGivenName, "First name");

   789     _LIT( KLabelPhone, "Phone");

   790 

   791     CContactCard* card = CContactCard::NewLC();

   792 

   793     // Family name field

   794     CContactItemField* familyNameField =

   795         CContactItemField::NewLC( KStorageTypeText, KUidContactFieldFamilyName );

   796     familyNameField->SetLabelL( KLabelFamilyName );

   797     familyNameField->SetMapping( KUidContactFieldVCardMapUnusedN );

   798     familyNameField->TextStorage()->SetTextL( aLastName );

   799     card->AddFieldL( *familyNameField ); // Takes ownership

   800     CleanupStack::Pop( familyNameField );

   801 

   802     // First name field

   803     CContactItemField* nameField =

   804     CContactItemField::NewLC( KStorageTypeText, KUidContactFieldGivenName );

   805     nameField->SetLabelL( KLabelGivenName );

   806     nameField->SetMapping( KUidContactFieldVCardMapUnusedN );

   807     nameField->TextStorage()->SetTextL( aFirstName );

   808     card->AddFieldL( *nameField );

   809     CleanupStack::Pop(nameField);

   810 

   811     // Phone number field

   812     CContactItemField* phoneField =

   813         CContactItemField::NewLC( KStorageTypeText, KUidContactFieldPhoneNumber );

   814     phoneField->SetLabelL( KLabelPhone );

   815     phoneField->SetMapping( KUidContactFieldVCardMapTEL );

   816     phoneField->TextStorage()->SetTextL( aPhoneNumber );

   817     card->AddFieldL( *phoneField );

   818     CleanupStack::Pop( phoneField );

   819 

   820     TContactItemId cardId = iContactDatabase->AddNewContactL( *card );

   821     CleanupStack::PopAndDestroy( card );

   822 

   823     return cardId;

   824     }

   825 

   826 void CNSmlDummyDataStore_Test::CreateDataStoreL()

   827     {

   828     TSmlDataProviderId id = {0x101F6DDD};// Contact Adapter Uid

   829     CSmlDataProvider* dp = CSmlDataProvider::NewL( id );

   830     iDataStore = dp->NewStoreInstanceLC();

   831     CleanupStack::Pop( iDataStore );

   832     delete dp;

   833     }

   834 

   835 void CNSmlDummyDataStore_Test::DeleteDataStoreL()

   836     {

   837     delete iDataStore;

   838     iDataStore = NULL;

   839     }

   840 

   841 // - EUnit test table -------------------------------------------------------

   842 

   843 EUNIT_BEGIN_TEST_TABLE(

   844     CNSmlDummyDataStore_Test,

   845     "Unit tests Contact adapter datastore",

   846     "UNIT" )

   847 

   848 EUNIT_TEST(

   849     "Test to verify memory allocation for the object",

   850     "CNSmlContactsDataStore",

   851     "NewL",

   852     "FUNCTIONALITY",

   853     Empty, NewLL, Empty)

   854 

   855 // The following unit test cases fail because of mis-match in 

   856 // heap cell count & thread handle count. This is caused by

   857 // DataStoreExtension component.

   858 EUNIT_TEST(

   859     "Open data store",

   860     "CNSmlContactsDataStore",

   861     "DoOpenL",

   862     "FUNCTIONALITY",

   863     SetupL, DoOpenLL, Teardown )

   864 

   865 EUNIT_TEST(

   866     "DoHasSyncHistory",

   867     "CNSmlContactsDataStore",

   868     "DoHasSyncHistory",

   869     "FUNCTIONALITY",

   870     SetupAndOpenStoreL, DoHasSyncHistoryL, TeardownAndCloseStore )

   871 

   872 EUNIT_TEST(

   873     "DoModifiedItems & DoCommitChangeInfoL",

   874     "CNSmlContactsDataStore",

   875     "DoModifiedItems",

   876     "FUNCTIONALITY",

   877     SetupAndOpenStoreL, DoModifiedItemsL, TeardownAndCloseStore )

   878 

   879 EUNIT_TEST(

   880     "DoResetChangeInfoL",

   881     "CNSmlContactsDataStore",

   882     "DoResetChangeInfoL",

   883     "FUNCTIONALITY",

   884     SetupAndOpenStoreL, DoResetChangeInfoLL, TeardownAndCloseStore )

   885 

   886 EUNIT_TEST(

   887     "DoCommitChangeInfoL",

   888     "CNSmlContactsDataStore",

   889     "DoCommitChangeInfoL",

   890     "FUNCTIONALITY",

   891     SetupAndOpenStoreL, DoCommitChangeInfoLL, TeardownAndCloseStore )

   892 

   893 EUNIT_TEST(

   894     "Add single item (normal mode)",

   895     "CNSmlContactsDataStore",

   896     "DoCreateItemL, DoCommitItemL, LdoAddItem",

   897     "FUNCTIONALITY",

   898     SetupAndOpenStoreL, AddSingleItemL, TeardownAndCloseStore )

   899 

   900 EUNIT_TEST(

   901     "Add item in batch mode",

   902     "CNSmlContactsDataStore",

   903     "DoBeginBatchL, DoCommitBatchL",

   904     "FUNCTIONALITY",

   905     SetupAndOpenStoreL, AddItemBatchL, TeardownAndCloseStore )

   906 

   907 EUNIT_TEST(

   908     "CancelBatchL",

   909     "CNSmlContactsDataStore",

   910     "DoCancelBatch",

   911     "FUNCTIONALITY",

   912     SetupAndOpenStoreL, CancelBatchL, TeardownAndCloseStore ) 

   913 

   914 EUNIT_TEST(

   915     "Fetch/read normal contact",

   916     "CNSmlContactsDataStore",

   917     "LdoFetchItemL",

   918     "FUNCTIONALITY",

   919     SetupPopulateDbAndOpenStoreL, FetchItemL, TeardownCloseAndEmptyContactDb )

   920 

   921 EUNIT_TEST(

   922     "Update normal contact",

   923     "CNSmlContactsDataStore",

   924     "LdoUpdateItemL",

   925     "FUNCTIONALITY",

   926     SetupPopulateDbAndOpenStoreL, UpdateItemL, TeardownCloseAndEmptyContactDb )

   927 

   928 EUNIT_TEST(

   929     "Delete normal contact",

   930     "CNSmlContactsDataStore",

   931     "DoDeleteItemL",

   932     "FUNCTIONALITY",

   933     SetupPopulateDbAndOpenStoreL, DeleteItemL, TeardownCloseAndEmptyContactDb )

   934 

   935 EUNIT_TEST(

   936     "Delete all contacts",

   937     "CNSmlContactsDataStore",

   938     "DoDeleteItemL",

   939     "FUNCTIONALITY",

   940     SetupPopulateDbAndOpenStoreL, DeleteAllItemsL, TeardownCloseAndEmptyContactDb )

   941 // End of failing test cases

   942 

   943 EUNIT_TEST(

   944     "Test for GetStoreFormatResourceFileL function",

   945     "CNSmlContactsDataStore",

   946     "",

   947     "FUNCTIONALITY",

   948     SetupL, GetStoreFormatResourceFileLL, Teardown )

   949 

   950 EUNIT_TEST(

   951     "Verify operator specific MIME type",

   952     "CNSmlContactsDataStore",

   953     "",

   954     "FUNCTIONALITY",

   955     SetupL, TestStoreSupportMimeTypeL, Teardown )

   956 

   957 EUNIT_TEST(

   958     "GetDataMod",

   959     "CNSmlContactsDataStore",

   960     "",

   961     "FUNCTIONALITY",

   962     SetupL, GetDataMod, Teardown )

   963 

   964 EUNIT_TEST(

   965     "DoBeginTransactionL",

   966     "CNSmlContactsDataStore",

   967     "",

   968     "FUNCTIONALITY",

   969     SetupL, DoBeginTransactionL, Teardown )

   970 

   971 EUNIT_TEST(

   972     "DoCommitTransactionL",

   973     "CNSmlContactsDataStore",

   974     "",

   975     "FUNCTIONALITY",

   976     SetupL, DoCommitTransactionL, Teardown )

   977 

   978 EUNIT_TEST(

   979     "DoRevertTransaction",

   980     "CNSmlContactsDataStore",

   981     "",

   982     "FUNCTIONALITY",

   983     SetupL, DoRevertTransaction, Teardown )

   984 

   985 EUNIT_TEST(

   986     "StoreNameL",

   987     "CNSmlContactsDataStore",

   988     "",

   989     "FUNCTIONALITY",

   990     SetupL, StoreNameL, Teardown )

   991     

   992 EUNIT_TEST(

   993     "FindChangedItemsL",

   994     "CNSmlContactsDataStore",

   995     "",

   996     "FUNCTIONALITY",

   997     SetupL, FindChangedItemsL, Teardown )   

   998 

   999 EUNIT_TEST(

  1000     "MoveAndDeleteL",

  1001     "CNSmlContactsDataStore",

  1002     "",

  1003     "FUNCTIONALITY",

  1004     SetupL, MoveAndDeleteL, Teardown )

  1005 

  1006 EUNIT_TEST(

  1007     "DoSetRemoteMaxObjectSize",

  1008     "CNSmlContactsDataStore",

  1009     "",

  1010     "FUNCTIONALITY",

  1011     SetupL, DoSetRemoteMaxObjectSize, Teardown )

  1012 

  1013 EUNIT_TEST(

  1014     "DoMaxObjectSize",

  1015     "CNSmlContactsDataStore",

  1016     "",

  1017     "FUNCTIONALITY",

  1018     SetupL, DoMaxObjectSize, Teardown )

  1019 

  1020 EUNIT_END_TEST_TABLE