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 #include "CNSmlDummyDataStore_Test.h"

    19 #include "CNSmlAdapterTestUtilities.h"

    20 #include <EUnitMacros.h>

    21 #include <EUnitDecorators.h>

    22 #include <cntdb.h>

    23 #include <cntitem.h>

    24 #include <cntfield.h>

    25 #include <cntfldst.h>

    26 #include <s32mem.h>

    27 #include <BAUTILS.H>

    28 #include <SmlDataFormat.h>

    29 #include <CVPbkContactViewDefinition.h>

    30 #include <CVPbkContactStoreUriArray.h>

    31 #include <tvpbkcontactstoreuriptr.h>

    32 #include <VPbkContactStoreUris.h>

    33 #include "nsmldummydatastore.h"

    34 #include "cnsmldummydatastorewaiter.h"

    35 

    36 namespace

    37     {

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

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

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

    41     _LIT( KVCardBasicInvalid, "c:\\Data\\TestData\\basicInvalid.vcf" );

    42     _LIT( KVCardMultiOccurence, "c:\\Data\\TestData\\multioccurence.vcf" );

    43     }

    44 

    45 

    46 // - Construction -----------------------------------------------------------

    47 

    48 CNSmlDummyDataStore_Test* CNSmlDummyDataStore_Test::NewL()

    49     {

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

    51     CleanupStack::Pop( self );

    52     return self;

    53     }

    54 

    55 CNSmlDummyDataStore_Test* CNSmlDummyDataStore_Test::NewLC()

    56     {

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

    58     CleanupStack::PushL( self );

    59     self->ConstructL();

    60     return self;

    61     }

    62 

    63 CNSmlDummyDataStore_Test::~CNSmlDummyDataStore_Test()

    64     {

    65     iWriteStream.Close();

    66     iFsSession.Close();

    67     delete iCNSmlDummyDataStore;

    68     delete iTestUtilities;

    69     delete iContactDatabase;

    70     delete iIdArray;

    71     delete iStoreWaiter;

    72     }

    73 

    74 CNSmlDummyDataStore_Test::CNSmlDummyDataStore_Test()

    75     {

    76     }

    77 

    78 void CNSmlDummyDataStore_Test::ConstructL()

    79     {

    80     CEUnitTestSuiteClass::ConstructL();

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

    82     }

    83 

    84 // from MSmlSyncRelationship

    85 TSmlSyncTaskKey CNSmlDummyDataStore_Test::SyncTaskKey() const

    86     {

    87     TSmlSyncTaskKey key = 0;

    88     return key;

    89     }

    90 

    91 void CNSmlDummyDataStore_Test::OpenReadStreamLC(

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

    93     {

    94     }

    95 

    96 void CNSmlDummyDataStore_Test::OpenWriteStreamLC(

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

    98     {

    99     User::LeaveIfError(

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

   101     aWriteStream = iWriteStream;

   102     CleanupClosePushL( aWriteStream );

   103     }

   104 

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

   106     {

   107     return EFalse;

   108     }

   109 

   110 // - Test methods -----------------------------------------------------------

   111 

   112 // ++++++++++++ SETUP METHODS ++++++++++++

   113 

   114 void CNSmlDummyDataStore_Test::SetupL(  )

   115     {

   116     iCNSmlDummyDataStore = CNSmlDummyDataStore::NewL();

   117     iTestUtilities = CNSmlAdapterTestUtilities::NewL();

   118     // Create contact manager

   119     CVPbkContactStoreUriArray* uriArray = CVPbkContactStoreUriArray::NewLC();

   120     uriArray->AppendL( TVPbkContactStoreUriPtr( VPbkContactStoreUris::DefaultCntDbUri() ) );

   121     iContactManager = CVPbkContactManager::NewL(*uriArray);

   122     CleanupStack::PopAndDestroy(uriArray);

   123     }

   124 

   125 void CNSmlDummyDataStore_Test::SetupAndOpenStoreL(  )

   126     {

   127     SetupL();

   128 

   129     iStoreWaiter =

   130         CNSmlDummyDataStoreWaiter::NewL( *iCNSmlDummyDataStore );

   131     iStoreWaiter->OpenStoreL( *this );

   132 

   133     iContactDatabase = CContactDatabase::OpenL();

   134     }

   135 

   136 void CNSmlDummyDataStore_Test::SetupPopulateDbAndOpenStoreL()

   137     {

   138     SetupAndPopulateContactDbL();

   139 

   140     EUNIT_ASSERT_NO_LEAVE(

   141     iCNSmlDummyDataStore = CNSmlDummyDataStore::NewL() );

   142 

   143     iStoreWaiter =

   144         CNSmlDummyDataStoreWaiter::NewL( *iCNSmlDummyDataStore );

   145     iStoreWaiter->OpenStoreL( *this );

   146     }

   147 

   148 /**

   149  * Setup contact DB with the following contacts

   150  *   + Tim Tester (id index 0)

   151  *   + Teddy McTest (id index 1)

   152  *   + Tod TestHill (id index 2)

   153  *   + Simon Software (id index 3)

   154  *   + Cyd Effect (id index 4)

   155  *

   156  */

   157 void CNSmlDummyDataStore_Test::SetupAndPopulateContactDbL()

   158     {

   159     if( !iContactDatabase )

   160         {

   161         iContactDatabase = CContactDatabase::OpenL();

   162         }

   163     if( !iTestUtilities )

   164         {

   165         iTestUtilities = CNSmlAdapterTestUtilities::NewL();

   166         }

   167 

   168     iIdArray = CContactIdArray::NewL();

   169 

   170     // Create test contacts

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

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

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

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

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

   176     }

   177 

   178 //// ++++++++++++ TEARDOWN METHODS ++++++++++++

   179 //

   180 void CNSmlDummyDataStore_Test::Teardown()

   181     {

   182     delete iCNSmlDummyDataStore;

   183     iCNSmlDummyDataStore = NULL;

   184 

   185     delete iTestUtilities;

   186     iTestUtilities = NULL;

   187     delete iContactManager;

   188     iContactManager = NULL;

   189     }

   190 

   191 void CNSmlDummyDataStore_Test::TeardownAndCloseStore()

   192     {

   193     delete iStoreWaiter;

   194     iStoreWaiter = NULL;

   195 

   196     delete iContactDatabase;

   197     iContactDatabase = NULL;

   198 

   199     Teardown();

   200     }

   201 

   202 void CNSmlDummyDataStore_Test::TeardownCloseAndEmptyContactDb()

   203     {

   204     delete iStoreWaiter;

   205     iStoreWaiter = NULL;

   206 

   207     delete iCNSmlDummyDataStore;

   208     iCNSmlDummyDataStore = NULL;

   209 

   210     TeardownAndEmptyContactDb();

   211     }

   212 

   213 void CNSmlDummyDataStore_Test::TeardownAndEmptyContactDb()

   214     {

   215     if (iContactDatabase && iIdArray)

   216         {

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

   218         }

   219     

   220     delete iIdArray;

   221     iIdArray = NULL;

   222     delete iContactDatabase;

   223     iContactDatabase = NULL;

   224     delete iTestUtilities;

   225     iTestUtilities = NULL;

   226     }

   227 

   228 // ++++++++++++ UNIT TEST METHODS ++++++++++++

   229 

   230 // ====================== CNSmlDummyDataStore ===========================

   231 

   232 // MEMORY ALLOCATION FOR DATASTORE

   233 void CNSmlDummyDataStore_Test::NewLL(  )

   234     {

   235     CNSmlDummyDataStore* dataStore = NULL;

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

   237     EUNIT_ASSERT( dataStore );

   238     delete dataStore;

   239     }

   240 

   241 // DoOpenL()

   242 void CNSmlDummyDataStore_Test::DoOpenLL()

   243     {

   244     CNSmlDummyDataStoreWaiter* storeWaiter =

   245     CNSmlDummyDataStoreWaiter::NewLC( *iCNSmlDummyDataStore );

   246 

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

   248 

   249     // Check for leave

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

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

   252     CleanupStack::PopAndDestroy( storeWaiter );

   253     }

   254 

   255 // DoHasSyncHistory()

   256 void CNSmlDummyDataStore_Test::DoHasSyncHistoryL()

   257     {

   258     TBool ret = iCNSmlDummyDataStore->DoHasSyncHistory();

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

   260     }

   261 

   262 // DoModifiedItems(), DoCommitChangeInfoL()

   263 void CNSmlDummyDataStore_Test::DoModifiedItemsL()

   264     {

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

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

   267 

   268     TInt returnCode = KErrNone;

   269 

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

   271 

   272     // Check for leave

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

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

   275 

   276     // Check for return code

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

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

   279     }

   280 

   281 

   282 // DoResetChangeInfoL()

   283 void CNSmlDummyDataStore_Test::DoResetChangeInfoLL()

   284     {

   285     // Temporarily remove ChangeFinders from Store to prevent leaves

   286     // when reseting ChangeFinders in code under test.

   287     CNSmlChangeFinder* cF = iCNSmlDummyDataStore->iChangeFinder;

   288     iCNSmlDummyDataStore->iChangeFinder = NULL;

   289 

   290     TInt returnCode = KErrNone;

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

   292 

   293     // Return ChangeFinders

   294     iCNSmlDummyDataStore->iChangeFinder = cF;

   295 

   296     // Check for leave

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

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

   299 

   300     // Check for return code

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

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

   303     }

   304 

   305 // DoCommitChangeInfoL()

   306 void CNSmlDummyDataStore_Test::DoCommitChangeInfoLL()

   307     {

   308     TInt returnCode = KErrNone;

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

   310 

   311     // Check for leave

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

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

   314 

   315     // Check for return code

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

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

   318     }

   319 

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

   321 //  (DoCreateItemL(), DoWriteItemL(), DoCommitItemL())

   322 void CNSmlDummyDataStore_Test::AddSingleItemL()

   323     {

   324     TBuf8< 20 > type;

   325     TBuf8< 20 > ver = KNSmlvCard21Ver();

   326     TInt returnCode = KErrNone;

   327     iItemUid = KNullContactId;

   328 

   329     // Try creating contact with illegal MIME type

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

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

   332         iItemUid, 0, type, ver ) );

   333 

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

   335         err, returnCode );

   336     EUNIT_ASSERT_DESC( returnCode == KErrNotSupported,

   337         "DoCreateItemL() accepts illegal MIME" );

   338 

   339     // Create legal contact

   340     type = KNSmlvCard21Name();

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

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

   343         iItemUid, 512, type, ver ) );

   344 

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

   346         err, returnCode );

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

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

   349 

   350     // Perform item writing to data store

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

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

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

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

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

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

   357     CleanupStack::PopAndDestroy( vCard );

   358 

   359     // Commit the contact to be created

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

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

   362 

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

   364         err, returnCode );

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

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

   367 

   368     // Check the imported item

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

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

   371 

   372     // Print out the imported vCard

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

   374     idArr->AddL( iItemUid );

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

   376     CleanupStack::PushL( buffer );

   377     RBufWriteStream writeStream( *buffer );

   378     CleanupClosePushL( writeStream );

   379 

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

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

   382 

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

   384 

   385     CleanupStack::PopAndDestroy( &writeStream );

   386 

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

   388 

   389     // Do some asserts

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

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

   392 

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

   394 

   395     // Do cleanup (remove added contact)

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

   397     tmpArray->AddL( iItemUid );

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

   399     CleanupStack::PopAndDestroy( tmpArray );

   400     }

   401 

   402 

   403 // Item addition - Batch mode, empty batch

   404 //  (DoBeginBatchL(), DoCommitBatchL())

   405 void CNSmlDummyDataStore_Test::AddEmptyBatchL()

   406     {

   407     // DoBeginBatchL()

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

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

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

   411 

   412     // DoCommitBatchL()

   413     TInt returnCode = KErrNone;

   414     RArray< TInt > array;

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

   416 

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

   418         err, returnCode );

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

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

   421     }

   422 

   423 // Item addition - Batch mode with two contacts

   424 void CNSmlDummyDataStore_Test::AddTwoItemBatchL()

   425     {

   426     TBuf8<20> type = KNSmlvCard21Name();

   427     TBuf8<20> ver = KNSmlvCard21Ver();

   428     TInt returnCode = KErrNone;

   429     HBufC8* vCard = NULL;

   430 

   431     // DoBeginBatchL()

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

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

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

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

   436 

   437     // == == CONTACT ITEM NO 1 == ==

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

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

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

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

   442 

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

   444         err, returnCode );

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

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

   447 

   448     // Perform item writing to data store

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

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

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

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

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

   454     CleanupStack::PopAndDestroy( vCard );

   455     vCard = NULL;

   456 

   457     // Commit the contact to be created

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

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

   460 

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

   462         err, returnCode );

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

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

   465 

   466     // == == CONTACT ITEM NO 2 == ==

   467     vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardStandard() );

   468 

   469     EUNIT_PRINT( _L("Calling DoCreateItemL(), STEP 5") );

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

   471         iItemUid2, vCard->Size(), type, ver ) );

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

   473         err, returnCode );

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

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

   476 

   477     // Perform item writing to data store

   478     EUNIT_PRINT( _L("Calling DoWriteItemL(), STEP 6") );

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

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

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

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

   483     CleanupStack::PopAndDestroy( vCard );

   484 

   485     // Commit the contact to be created

   486     EUNIT_PRINT( _L("Calling DoCommitItemL(), STEP 7") );

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

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

   489         err, returnCode );

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

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

   492 

   493     // Commit batch

   494     RArray<TInt> array;

   495     EUNIT_PRINT( _L("Calling DoCommitBatchL(), STEP 8") );

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

   497 

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

   499         err, returnCode );

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

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

   502 

   503     // Verify results

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

   505         {

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

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

   508         }

   509     EUNIT_ASSERT_DESC( array.Count() == 2, "Wrong number of contacts added" );

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

   511     EUNIT_PRINT( _L("Item 2 ID = %d"), iItemUid2 );

   512 

   513     // Cleanup

   514     array.Reset();

   515     array.Close();

   516 

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

   518     tmpArray->AddL( iItemUid );

   519     tmpArray->AddL( iItemUid2 );

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

   521     CleanupStack::PopAndDestroy( tmpArray );

   522     }

   523 

   524 // Item addition - cancel Batch mode 

   525 void CNSmlDummyDataStore_Test::CancelBatchL()

   526     {

   527     TBuf8<20> type = KNSmlvCard21Name();

   528     TBuf8<20> ver = KNSmlvCard21Ver();

   529     TInt returnCode = KErrNone;

   530     HBufC8* vCard = NULL;

   531 

   532     // DoBeginBatchL()

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

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

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

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

   537 

   538     // == == CONTACT ITEM NO 1 == ==

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

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

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

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

   543 

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

   545         err, returnCode );

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

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

   548 

   549     // Perform item writing to data store

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

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

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

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

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

   555     CleanupStack::PopAndDestroy( vCard );

   556     vCard = NULL;

   557 

   558     // Cancel Batch

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

   560     iStoreWaiter->DoCancelBatch();

   561     }

   562 

   563 // DoOpenItemL(), DoReadItemL(), DoCloseItemL()

   564 //  (LdoFetchItemL(), SingleContactOperationCompleteL())

   565 void CNSmlDummyDataStore_Test::FetchItemL()

   566     {

   567     TBuf8<20> type;

   568     TBuf8<20> ver;

   569     TInt returnCode = KErrNone;

   570     TInt size = 0;

   571     TSmlDbItemUid parentId = KNullContactId;

   572     TBool fieldChange = EFalse;

   573 

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

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

   576 

   577     //Make some preparations:

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

   579     //      - Otherwise we get access violation

   580     EUNIT_ASSERT( iCNSmlDummyDataStore->iStoreFormat );

   581     iCNSmlDummyDataStore->DoSetRemoteStoreFormatL(

   582         *(iCNSmlDummyDataStore->iStoreFormat) );

   583 

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

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

   586 

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

   588         err, returnCode );

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

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

   591 

   592     // Execute some asserts to verify functionality

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

   594             size );

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

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

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

   598         "Illegal MIME type" );

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

   600         "Illegal MIME version" );

   601 

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

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

   604     TPtr8 vCardPtr = vCard->Des();

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

   606 

   607     EUNIT_PRINT( *vCard );

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

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

   610 

   611     CleanupStack::PopAndDestroy( vCard );

   612 

   613     // Close the contact item

   614     iCNSmlDummyDataStore->DoCloseItem();

   615     }

   616 

   617 void CNSmlDummyDataStore_Test::FetchItem2L()

   618     {

   619     TBuf8<20> type;

   620     TBuf8<20> ver;

   621     TInt returnCode = KErrNone;

   622     TInt size = 0;

   623     TSmlDbItemUid parentId = KNullContactId;

   624     TBool fieldChange = EFalse;

   625 

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

   627         10000, fieldChange, size, parentId, type, ver ) );

   628 

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

   630         err, returnCode );

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

   632     EUNIT_ASSERT_DESC( returnCode == KErrNone || returnCode == KErrNotFound, "DoOpenItemL returns error");

   633     }

   634 

   635 // Update a standard contact

   636 //  (DoReplaceItemL(), ExecuteBufferL(), ExecuteUpdateL(), ...)

   637 void CNSmlDummyDataStore_Test::UpdateItemL()

   638     {

   639     TInt returnCode = KErrNone;

   640     TSmlDbItemUid parentId = KNullContactId;

   641     TBool fieldChange = EFalse;

   642 

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

   644 

   645     // Update "Tim Tester" contact

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

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

   648 

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

   650         err, returnCode );

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

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

   653 

   654     // Perform item writing to data store

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

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

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

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

   659     CleanupStack::PopAndDestroy( vCard );

   660 

   661     // Commit the contact to be created

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

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

   664 

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

   666         err, returnCode );

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

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

   669 

   670     // Print out the imported vCard

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

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

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

   674     CleanupStack::PushL( buffer );

   675     RBufWriteStream writeStream( *buffer );

   676     CleanupClosePushL( writeStream );

   677 

   678     TRAP( err, iContactDatabase->ExportSelectedContactsL(

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

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

   681 

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

   683 

   684     CleanupStack::PopAndDestroy( &writeStream );

   685 

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

   687 

   688     // Do some asserts

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

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

   691 

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

   693     }

   694 

   695 // Not working - memory leak: Heap cell count, 61, 73, Request count, 0, 1

   696 //  The test case never receives OpetionComplete() callback from VPbk. Therefore

   697 //  the request count & heap allocation do not match.

   698 // DoDeleteItemL(), StepComplete()

   699 void CNSmlDummyDataStore_Test::DeleteItemL()

   700     {

   701     // Delete item

   702     TInt returnCode = KErrNone;

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

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

   705 

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

   707         err, returnCode );

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

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

   710     iCNSmlDummyDataStore->ExecuteDeleteL();

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

   712     CContactItem* item = NULL;

   713     CContactDatabase* cntDb = NULL;

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

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

   716         ( *iIdArray )[ 0 ] ) );

   717     EUNIT_ASSERT( !item );

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

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

   720     delete item;

   721     item = NULL;

   722 

   723     if( cntDb )

   724         {

   725         delete cntDb;

   726         }

   727 

   728     iIdArray->Remove( 0 );

   729     }

   730 

   731 // DoDeleteAllItemsL(), DoDeleteAllContactsL(), ...

   732 void CNSmlDummyDataStore_Test::DeleteAllItemsL()

   733     {

   734     // Temporarily remove ChangeFinders from Store to prevent leaves

   735     // when reseting ChangeFinders in code under test.

   736     CNSmlChangeFinder* cF = iCNSmlDummyDataStore->iChangeFinder;

   737     CleanupStack::PushL( cF );

   738     iCNSmlDummyDataStore->iChangeFinder = NULL;

   739 

   740     TInt returnCode = KErrNone;

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

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

   743 

   744     // Return ChangeFinders

   745     CleanupStack::Pop( cF );

   746     iCNSmlDummyDataStore->iChangeFinder = cF;

   747 

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

   749         err, returnCode );

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

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

   752 

   753     // Check that all normal contacts are removed

   754     TContactItemId ownCardId = iContactDatabase->OwnCardId();

   755 

   756     TInt contactCount = 0;

   757     TInt groupCount = iContactDatabase->GroupCount();

   758     TContactIter iter( *iContactDatabase );

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

   760         {

   761         // KUidContactGroup

   762         if( id != ownCardId )

   763             {

   764             contactCount++;

   765             }

   766         }

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

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

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

   770     }

   771 

   772 // GetStoreFormatResourceFileL()

   773 void CNSmlDummyDataStore_Test::GetStoreFormatResourceFileLL()

   774     {

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

   776     EUNIT_PRINT( resourceFile );

   777     }

   778 

   779 

   780 // VCARD IMPORT TEST CASES

   781 

   782 void CNSmlDummyDataStore_Test::RemoveItemFromAddBatchL()

   783     {

   784     // Test case:

   785     // - Run RemoveItemFromAddBatch() and verify its functionality

   786 

   787     if( !iCNSmlDummyDataStore->iItemDataAddBatch )

   788         {

   789         iCNSmlDummyDataStore->iItemDataAddBatch =

   790             CBufFlat::NewL( KNSmlItemDataExpandSize );

   791         }

   792 

   793     HBufC8* vCard = NULL;

   794     // Test material: basic vCard

   795     vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardBasic );

   796     iCNSmlDummyDataStore->iItemDataAddBatch->InsertL(

   797         iCNSmlDummyDataStore->iItemDataAddBatch->Size(),

   798         *vCard, vCard->Size() );

   799     iCNSmlDummyDataStore->iItemDataAddBatch->InsertL(

   800         iCNSmlDummyDataStore->iItemDataAddBatch->Size(),

   801         KVersitTokenCRLF() );

   802     CleanupStack::PopAndDestroy( vCard );

   803 

   804     // Test material 2: vCard with multiple TEL fields

   805     vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardMultiOccurence );

   806     iCNSmlDummyDataStore->iItemDataAddBatch->InsertL(

   807         iCNSmlDummyDataStore->iItemDataAddBatch->Size(),

   808         *vCard, vCard->Size() );

   809     iCNSmlDummyDataStore->iItemDataAddBatch->InsertL(

   810         iCNSmlDummyDataStore->iItemDataAddBatch->Size(),

   811         KVersitTokenCRLF() );

   812     CleanupStack::PopAndDestroy( vCard );

   813 

   814 //    iTestUtilities->PrintData( _L8("Buffer contents"),

   815 //        *iCNSmlDummyDataStore->iItemDataAddBatch ); // DEBUG PRINT

   816     

   817     TInt count = 0;

   818 

   819     // ASSERTS

   820     count = CountItemsLeftInBatchL(

   821         *iCNSmlDummyDataStore->iItemDataAddBatch );

   822     EUNIT_PRINT( _L("Items left %d"), count ); // DEBUG PRINT

   823     EUNIT_ASSERT_DESC( count == 2, "Wrong initial item count in batch.")

   824 //    EUNIT_PRINT( _L("Items left %d"), count ); // DEBUG PRINT

   825     }

   826 

   827 

   828 void CNSmlDummyDataStore_Test::TestStoreSupportMimeTypeL()

   829     {

   830     EUNIT_ASSERT( iCNSmlDummyDataStore->iStoreFormat );

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

   832     EUNIT_ASSERT_EQUALS(

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

   834             KNSmlvCard21Name() );

   835     EUNIT_ASSERT_EQUALS(

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

   837                     KNSmlvCard21Ver() );

   838     }

   839 

   840 void CNSmlDummyDataStore_Test::DoBeginTransactionL()

   841     {

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

   843     EUNIT_ASSERT( err == KErrNotSupported );

   844     }

   845 

   846 void CNSmlDummyDataStore_Test::DoCommitTransactionL()

   847     {

   848     TRequestStatus status;

   849     iCNSmlDummyDataStore->DoCommitTransactionL( status );

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

   851     }

   852 

   853 void CNSmlDummyDataStore_Test::DoRevertTransaction()

   854     {

   855     TRequestStatus status;

   856     iCNSmlDummyDataStore->DoRevertTransaction( status );

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

   858     }

   859 

   860 void CNSmlDummyDataStore_Test::StoreNameL()

   861     {

   862     CreateDataStoreL();

   863     EUNIT_PRINT( iDataStore->StoreName() );

   864     iDataStore->CancelRequest();

   865     DeleteDataStoreL();

   866     }

   867 

   868 void CNSmlDummyDataStore_Test::FindChangedItemsL()

   869     {

   870     CreateDataStoreL();

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

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

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

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

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

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

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

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

   879     DeleteDataStoreL();

   880     }

   881 

   882 void CNSmlDummyDataStore_Test::MoveAndDeleteL()

   883     {

   884     CreateDataStoreL();

   885     TSmlDbItemUid uid = 1;

   886     TSmlDbItemUid parent = 0;

   887     TRequestStatus status;

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

   889     

   890     TRequestStatus status2;

   891     iDataStore->SoftDeleteItemL( uid, status2 );

   892         

   893     DeleteDataStoreL();

   894     }

   895 

   896 void CNSmlDummyDataStore_Test::ExecuteMoveL()

   897     {

   898     iCNSmlDummyDataStore->ExecuteMoveL();

   899     }

   900 

   901 void CNSmlDummyDataStore_Test::DoSetRemoteMaxObjectSize()

   902     {

   903     iCNSmlDummyDataStore->DoSetRemoteMaxObjectSize( 100000 );

   904     }

   905 

   906 void CNSmlDummyDataStore_Test::DoMaxObjectSize()

   907     {

   908     TInt size = iCNSmlDummyDataStore->DoMaxObjectSize();

   909     EUNIT_ASSERT( size == 102400 );

   910     }

   911 

   912 void CNSmlDummyDataStore_Test::ContactsSavingFailedL()

   913     {

   914     TBuf8< 20 > type= KNSmlvCard21Name();

   915     TBuf8< 20 > ver = KNSmlvCard21Ver();

   916     TInt returnCode = KErrNone;

   917     iItemUid = KNullContactId;

   918     // Create legal contact

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

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

   921         iItemUid, 512, type, ver ) );

   922 

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

   924         err, returnCode );

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

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

   927 

   928     // Perform item writing to data store

   929     HBufC8* vCard = iTestUtilities->ReadVCard8FromFileLC( KVCardBasicInvalid() );

   930     EUNIT_PRINT( _L("Calling DoWriteItemL(), STEP 2") );

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

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

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

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

   935     CleanupStack::PopAndDestroy( vCard );

   936 

   937     // Commit the contact to be created

   938     EUNIT_PRINT( _L("Calling DoCommmitItemL(), STEP 3") );

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

   940 

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

   942         err, returnCode );

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

   944     EUNIT_ASSERT_DESC( returnCode == KErrNotFound, "DoCommitItemL returns error");

   945     }

   946 

   947 void CNSmlDummyDataStore_Test::StepFailed()

   948     {

   949     TInt returnCode = KErrNone;

   950     // delete contact which not exist

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

   952     TRAPD( err, returnCode = iStoreWaiter->DoDeleteItemL( 10000 ) );

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

   954         err, returnCode );

   955     }

   956 

   957 void CNSmlDummyDataStore_Test::GetDataMod()

   958     {

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

   960     }

   961 

   962 

   963 // --------------- Helper methods --------------

   964 

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

   966 TContactItemId CNSmlDummyDataStore_Test::AddContactL(

   967         const TDesC& aFirstName,

   968         const TDesC& aLastName,

   969         const TDesC& aPhoneNumber )

   970     {

   971     _LIT( KLabelFamilyName, "Last name");

   972     _LIT( KLabelGivenName, "First name");

   973     _LIT( KLabelPhone, "Phone");

   974 

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

   976 

   977     // Family name field

   978     CContactItemField* familyNameField =

   979         CContactItemField::NewLC( KStorageTypeText, KUidContactFieldFamilyName );

   980     familyNameField->SetLabelL( KLabelFamilyName );

   981     familyNameField->SetMapping( KUidContactFieldVCardMapUnusedN );

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

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

   984     CleanupStack::Pop( familyNameField );

   985 

   986     // First name field

   987     CContactItemField* nameField =

   988     CContactItemField::NewLC( KStorageTypeText, KUidContactFieldGivenName );

   989     nameField->SetLabelL( KLabelGivenName );

   990     nameField->SetMapping( KUidContactFieldVCardMapUnusedN );

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

   992     card->AddFieldL( *nameField );

   993     CleanupStack::Pop(nameField);

   994 

   995     // Phone number field

   996     CContactItemField* phoneField =

   997         CContactItemField::NewLC( KStorageTypeText, KUidContactFieldPhoneNumber );

   998     phoneField->SetLabelL( KLabelPhone );

   999     phoneField->SetMapping( KUidContactFieldVCardMapTEL );

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

  1001     card->AddFieldL( *phoneField );

  1002     CleanupStack::Pop( phoneField );

  1003 

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

  1005     CleanupStack::PopAndDestroy( card );

  1006 

  1007     return cardId;

  1008     }

  1009 

  1010 TInt CNSmlDummyDataStore_Test::CountItemsLeftInBatchL( CBufBase& aItems )

  1011     {

  1012     _LIT8( KVCardBeginTag, "BEGIN:VCARD\r\n");

  1013     _LIT8( KVCardEndTag, "\r\nEND:VCARD\r\n");

  1014 

  1015     TInt vCardCount = 0;

  1016     TBool processed = EFalse;

  1017 

  1018     HBufC8* tmpBuf = HBufC8::NewLC( aItems.Size() );

  1019     TPtr8 ptr = tmpBuf->Des();

  1020     aItems.Read( 0, ptr, aItems.Size() );

  1021 

  1022     while( !processed )

  1023         {

  1024         TInt offsetBegin = ptr.FindF( KVCardBeginTag );

  1025         TInt offsetEnd = ptr.FindF( KVCardEndTag );

  1026 

  1027         if( offsetBegin != KErrNotFound && offsetEnd != KErrNotFound )

  1028             {

  1029             offsetEnd += KVCardEndTag().Length();

  1030             vCardCount++;

  1031             ptr = ptr.MidTPtr( offsetEnd );

  1032             }

  1033         else

  1034             {

  1035             processed = ETrue;

  1036             }

  1037         }

  1038     CleanupStack::PopAndDestroy( tmpBuf );

  1039     return vCardCount;

  1040     }

  1041 

  1042 void CNSmlDummyDataStore_Test::CreateDataStoreL()

  1043     {

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

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

  1046     iDataStore = dp->NewStoreInstanceLC();

  1047     CleanupStack::Pop( iDataStore );

  1048     delete dp;

  1049     }

  1050 

  1051 void CNSmlDummyDataStore_Test::DeleteDataStoreL()

  1052     {

  1053     delete iDataStore;

  1054     iDataStore = NULL;

  1055     }

  1056 

  1057 void CNSmlDummyDataStore_Test::CreateViewL()

  1058     {

  1059     CVPbkContactViewDefinition* viewDef = CVPbkContactViewDefinition::NewL();

  1060     CleanupStack::PushL( viewDef );

  1061     viewDef->SetType( EVPbkContactsView );

  1062 

  1063     iContactViewBase = iContactManager->CreateContactViewLC( 

  1064                                          *this, 

  1065                                          *viewDef, 

  1066                                          iContactManager->FieldTypes() );

  1067     CleanupStack::Pop();// iContactViewBase

  1068     CleanupStack::PopAndDestroy( viewDef );

  1069     } 

  1070 

  1071 // ------------------  From MVPbkContactViewObserver ---------------------

  1072 void CNSmlDummyDataStore_Test::ContactViewReady( MVPbkContactViewBase& /*aView*/ )

  1073     {

  1074     }   

  1075     

  1076 void CNSmlDummyDataStore_Test::ContactViewUnavailable(

  1077             MVPbkContactViewBase& /*aView*/ )

  1078     {

  1079     }

  1080 

  1081 void CNSmlDummyDataStore_Test::ContactAddedToView(

  1082             MVPbkContactViewBase& /*aView*/, 

  1083             TInt /*aIndex*/, 

  1084             const MVPbkContactLink& /*aContactLink*/ )

  1085     {

  1086     }

  1087 

  1088 void CNSmlDummyDataStore_Test::ContactRemovedFromView(

  1089             MVPbkContactViewBase& /*aView*/, 

  1090             TInt /*aIndex*/, 

  1091             const MVPbkContactLink& /*aContactLink*/ )

  1092     { 

  1093     }

  1094     

  1095 void CNSmlDummyDataStore_Test::ContactViewError(

  1096             MVPbkContactViewBase& /*aView*/, 

  1097             TInt /*aError*/, 

  1098             TBool /*aErrorNotified*/ )

  1099     { 

  1100     }

  1101 

  1102 // - EUnit test table -------------------------------------------------------

  1103 

  1104 EUNIT_BEGIN_TEST_TABLE(

  1105     CNSmlDummyDataStore_Test,

  1106     "Unit tests Contact adapter datastore",

  1107     "UNIT" )

  1108 

  1109 EUNIT_TEST(

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

  1111     "CNSmlContactsDataStore",

  1112     "NewL",

  1113     "FUNCTIONALITY",

  1114     Empty, NewLL, Empty)

  1115 

  1116 EUNIT_TEST(

  1117     "Open data store",

  1118     "CNSmlContactsDataStore",

  1119     "DoOpenL",

  1120     "FUNCTIONALITY",

  1121     SetupL, DoOpenLL, Teardown )

  1122 

  1123 EUNIT_TEST(

  1124     "DoHasSyncHistory",

  1125     "CNSmlContactsDataStore",

  1126     "DoHasSyncHistory",

  1127     "FUNCTIONALITY",

  1128     SetupAndOpenStoreL, DoHasSyncHistoryL, TeardownAndCloseStore )

  1129 

  1130 EUNIT_TEST(

  1131     "DoModifiedItems & DoCommitChangeInfoL",

  1132     "CNSmlContactsDataStore",

  1133     "DoModifiedItems",

  1134     "FUNCTIONALITY",